projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Add option to repeat the kernel on the device NUM times to increase benchmark accuracy
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 *
5 * License.....: MIT
6 */
7
8 #ifdef OSX
9 #include <stdio.h>
10 #endif
11
12 #include <common.h>
13 #include <shared.h>
14 #include <rp_kernel_on_cpu.h>
15 #include <getopt.h>
16
17 const char *PROGNAME = "oclHashcat";
18 const uint VERSION_BIN = 210;
19 const uint RESTORE_MIN = 210;
20
21 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
22
23 #define INCR_RULES 10000
24 #define INCR_SALTS 100000
25 #define INCR_MASKS 1000
26 #define INCR_POT 1000
27
28 #define USAGE 0
29 #define VERSION 0
30 #define QUIET 0
31 #define MARKOV_THRESHOLD 0
32 #define MARKOV_DISABLE 0
33 #define MARKOV_CLASSIC 0
34 #define BENCHMARK 0
35 #define BENCHMARK_REPEATS 2
36 #define RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define STATUS_AUTOMAT 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 80
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS 64
87 #define POWERTUNE_ENABLE 0
88 #define LOGFILE_DISABLE 0
89 #define SCRYPT_TMTO 0
90 #define OPENCL_VECTOR_WIDTH 0
91
92 #define WL_MODE_STDIN 1
93 #define WL_MODE_FILE 2
94 #define WL_MODE_MASK 3
95
96 #define HL_MODE_FILE 4
97 #define HL_MODE_ARG 5
98
99 #define HLFMT_HASHCAT 0
100 #define HLFMT_PWDUMP 1
101 #define HLFMT_PASSWD 2
102 #define HLFMT_SHADOW 3
103 #define HLFMT_DCC 4
104 #define HLFMT_DCC2 5
105 #define HLFMT_NETNTLM1 7
106 #define HLFMT_NETNTLM2 8
107 #define HLFMT_NSLDAP 9
108 #define HLFMT_NSLDAPS 10
109 #define HLFMTS_CNT 11
110
111 #define ATTACK_MODE_STRAIGHT 0
112 #define ATTACK_MODE_COMBI 1
113 #define ATTACK_MODE_TOGGLE 2
114 #define ATTACK_MODE_BF 3
115 #define ATTACK_MODE_PERM 4
116 #define ATTACK_MODE_TABLE 5
117 #define ATTACK_MODE_HYBRID1 6
118 #define ATTACK_MODE_HYBRID2 7
119 #define ATTACK_MODE_NONE 100
120
121 #define ATTACK_KERN_STRAIGHT 0
122 #define ATTACK_KERN_COMBI 1
123 #define ATTACK_KERN_BF 3
124 #define ATTACK_KERN_NONE 100
125
126 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
127 #define ATTACK_EXEC_INSIDE_KERNEL 11
128
129 #define COMBINATOR_MODE_BASE_LEFT 10001
130 #define COMBINATOR_MODE_BASE_RIGHT 10002
131
132 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
133 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
134
135 #define MAX_CUT_TRIES 4
136
137 #define MAX_DICTSTAT 10000
138
139 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 130
140
141 #define global_free(attr) \
142 { \
143 myfree ((void *) data.attr); \
144 \
145 data.attr = NULL; \
146 }
147
148 #define local_free(attr) \
149 { \
150 myfree ((void *) attr); \
151 \
152 attr = NULL; \
153 }
154
155 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
156 {
157 900,
158 0,
159 5100,
160 100,
161 1400,
162 10800,
163 1700,
164 5000,
165 10100,
166 6000,
167 6100,
168 6900,
169 11700,
170 11800,
171 400,
172 8900,
173 11900,
174 12000,
175 10900,
176 12100,
177 23,
178 2500,
179 5300,
180 5400,
181 5500,
182 5600,
183 7300,
184 7500,
185 8300,
186 11100,
187 11200,
188 11400,
189 121,
190 2611,
191 2711,
192 2811,
193 8400,
194 11,
195 2612,
196 7900,
197 21,
198 11000,
199 124,
200 10000,
201 3711,
202 7600,
203 12,
204 131,
205 132,
206 1731,
207 200,
208 300,
209 3100,
210 112,
211 12300,
212 8000,
213 141,
214 1441,
215 1600,
216 12600,
217 1421,
218 101,
219 111,
220 1711,
221 3000, // broken in osx
222 1000,
223 1100,
224 2100,
225 12800,
226 1500, // broken in osx
227 12400,
228 500,
229 3200,
230 7400,
231 1800,
232 122,
233 1722,
234 7100,
235 6300,
236 6700,
237 6400,
238 6500,
239 2400,
240 2410,
241 5700,
242 9200,
243 9300,
244 22,
245 501,
246 5800,
247 8100,
248 8500,
249 7200,
250 9900,
251 7700,
252 7800,
253 10300,
254 8600,
255 8700,
256 9100,
257 133,
258 11600,
259 12500,
260 13000,
261 6211,
262 6221,
263 6231,
264 6241,
265 8800,
266 12900,
267 12200,
268 9700,
269 9710,
270 9800,
271 9810,
272 9400,
273 9500,
274 9600,
275 10400,
276 10410,
277 10500,
278 10600,
279 10700, // broken in osx
280 9000,
281 5200,
282 6800,
283 6600,
284 8200,
285 11300,
286 12700
287 };
288
289 /**
290 * types
291 */
292
293 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
294
295 /**
296 * globals
297 */
298
299 static unsigned int full01 = 0x01010101;
300 static unsigned int full80 = 0x80808080;
301
302 int SUPPRESS_OUTPUT = 0;
303
304 hc_thread_mutex_t mux_adl;
305 hc_thread_mutex_t mux_counter;
306 hc_thread_mutex_t mux_dispatcher;
307 hc_thread_mutex_t mux_display;
308
309 hc_global_data_t data;
310
311 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
312
313 const char *USAGE_MINI[] =
314 {
315 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
316 "",
317 "Try --help for more help.",
318 NULL
319 };
320
321 const char *USAGE_BIG[] =
322 {
323 "%s, advanced password recovery",
324 "",
325 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
326 "",
327 "=======",
328 "Options",
329 "=======",
330 "",
331 "* General:",
332 "",
333 " -m, --hash-type=NUM Hash-type, see references below",
334 " -a, --attack-mode=NUM Attack-mode, see references below",
335 " -V, --version Print version",
336 " -h, --help Print help",
337 " --quiet Suppress output",
338 "",
339 "* Misc:",
340 "",
341 " --hex-charset Assume charset is given in hex",
342 " --hex-salt Assume salt is given in hex",
343 " --hex-wordlist Assume words in wordlist is given in hex",
344 " --force Ignore warnings",
345 " --status Enable automatic update of the status-screen",
346 " --status-timer=NUM Seconds between status-screen update",
347 " --status-automat Display the status view in a machine readable format",
348 " --loopback Add new plains to induct directory",
349 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
350 "",
351 "* Markov:",
352 "",
353 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
354 " --markov-disable Disables markov-chains, emulates classic brute-force",
355 " --markov-classic Enables classic markov-chains, no per-position enhancement",
356 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
357 "",
358 "* Session:",
359 "",
360 " --runtime=NUM Abort session after NUM seconds of runtime",
361 " --session=STR Define specific session name",
362 " --restore Restore session from --session",
363 " --restore-disable Do not write restore file",
364 "",
365 "* Files:",
366 "",
367 " -o, --outfile=FILE Define outfile for recovered hash",
368 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
369 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
370 " --outfile-check-timer=NUM Seconds between outfile checks",
371 " -p, --separator=CHAR Separator char for hashlists and outfile",
372 " --show Show cracked passwords only",
373 " --left Show un-cracked passwords only",
374 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
375 " --remove Enable remove of hash once it is cracked",
376 " --remove-timer=NUM Update input hash file each NUM seconds",
377 " --potfile-disable Do not write potfile",
378 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
379 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
380 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
381 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
382 " --logfile-disable Disable the logfile",
383 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
384 "",
385 "* Resources:",
386 "",
387 " -b, --benchmark Run benchmark",
388 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
389 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
390 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
391 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
392 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
393 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
394 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
395 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
396 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4 or 8), overrides value from device query",
397 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
398 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
399 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
400 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
401 #ifdef HAVE_HWMON
402 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
403 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
404 #ifdef HAVE_ADL
405 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
406 #endif
407 #endif
408 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
409 "",
410 "* Distributed:",
411 "",
412 " -s, --skip=NUM Skip number of words",
413 " -l, --limit=NUM Limit number of words",
414 " --keyspace Show keyspace base:mod values and quit",
415 "",
416 "* Rules:",
417 "",
418 " -j, --rule-left=RULE Single rule applied to each word from left dict",
419 " -k, --rule-right=RULE Single rule applied to each word from right dict",
420 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
421 " -g, --generate-rules=NUM Generate NUM random rules",
422 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
423 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
424 " --generate-rules-seed=NUM Force RNG seed to NUM",
425 "",
426 "* Custom charsets:",
427 "",
428 " -1, --custom-charset1=CS User-defined charsets",
429 " -2, --custom-charset2=CS Example:",
430 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
431 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
432 "",
433 "* Increment:",
434 "",
435 " -i, --increment Enable increment mode",
436 " --increment-min=NUM Start incrementing at NUM",
437 " --increment-max=NUM Stop incrementing at NUM",
438 "",
439 "==========",
440 "References",
441 "==========",
442 "",
443 "* Workload Profile:",
444 "",
445 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
446 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
447 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
448 "",
449 "* OpenCL device-types:",
450 "",
451 " 1 = CPU devices",
452 " 2 = GPU devices",
453 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
454 "",
455 "* Outfile Formats:",
456 "",
457 " 1 = hash[:salt]",
458 " 2 = plain",
459 " 3 = hash[:salt]:plain",
460 " 4 = hex_plain",
461 " 5 = hash[:salt]:hex_plain",
462 " 6 = plain:hex_plain",
463 " 7 = hash[:salt]:plain:hex_plain",
464 " 8 = crackpos",
465 " 9 = hash[:salt]:crackpos",
466 " 10 = plain:crackpos",
467 " 11 = hash[:salt]:plain:crackpos",
468 " 12 = hex_plain:crackpos",
469 " 13 = hash[:salt]:hex_plain:crackpos",
470 " 14 = plain:hex_plain:crackpos",
471 " 15 = hash[:salt]:plain:hex_plain:crackpos",
472 "",
473 "* Debug mode output formats (for hybrid mode only, by using rules):",
474 "",
475 " 1 = save finding rule",
476 " 2 = save original word",
477 " 3 = save original word and finding rule",
478 " 4 = save original word, finding rule and modified plain",
479 "",
480 "* Built-in charsets:",
481 "",
482 " ?l = abcdefghijklmnopqrstuvwxyz",
483 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
484 " ?d = 0123456789",
485 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
486 " ?a = ?l?u?d?s",
487 " ?b = 0x00 - 0xff",
488 "",
489 "* Attack modes:",
490 "",
491 " 0 = Straight",
492 " 1 = Combination",
493 " 3 = Brute-force",
494 " 6 = Hybrid dict + mask",
495 " 7 = Hybrid mask + dict",
496 "",
497 "* Hash types:",
498 "",
499 "[[ Roll-your-own: Raw Hashes ]]",
500 "",
501 " 900 = MD4",
502 " 0 = MD5",
503 " 5100 = Half MD5",
504 " 100 = SHA1",
505 " 10800 = SHA-384",
506 " 1400 = SHA-256",
507 " 1700 = SHA-512",
508 " 5000 = SHA-3(Keccak)",
509 " 10100 = SipHash",
510 " 6000 = RipeMD160",
511 " 6100 = Whirlpool",
512 " 6900 = GOST R 34.11-94",
513 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
514 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
515 "",
516 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
517 "",
518 " 10 = md5($pass.$salt)",
519 " 20 = md5($salt.$pass)",
520 " 30 = md5(unicode($pass).$salt)",
521 " 40 = md5($salt.unicode($pass))",
522 " 3800 = md5($salt.$pass.$salt)",
523 " 3710 = md5($salt.md5($pass))",
524 " 2600 = md5(md5($pass)",
525 " 4300 = md5(strtoupper(md5($pass)))",
526 " 4400 = md5(sha1($pass))",
527 " 110 = sha1($pass.$salt)",
528 " 120 = sha1($salt.$pass)",
529 " 130 = sha1(unicode($pass).$salt)",
530 " 140 = sha1($salt.unicode($pass))",
531 " 4500 = sha1(sha1($pass)",
532 " 4700 = sha1(md5($pass))",
533 " 4900 = sha1($salt.$pass.$salt)",
534 " 1410 = sha256($pass.$salt)",
535 " 1420 = sha256($salt.$pass)",
536 " 1430 = sha256(unicode($pass).$salt)",
537 " 1440 = sha256($salt.unicode($pass))",
538 " 1710 = sha512($pass.$salt)",
539 " 1720 = sha512($salt.$pass)",
540 " 1730 = sha512(unicode($pass).$salt)",
541 " 1740 = sha512($salt.unicode($pass))",
542 "",
543 "[[ Roll-your-own: Authenticated Hashes ]]",
544 "",
545 " 50 = HMAC-MD5 (key = $pass)",
546 " 60 = HMAC-MD5 (key = $salt)",
547 " 150 = HMAC-SHA1 (key = $pass)",
548 " 160 = HMAC-SHA1 (key = $salt)",
549 " 1450 = HMAC-SHA256 (key = $pass)",
550 " 1460 = HMAC-SHA256 (key = $salt)",
551 " 1750 = HMAC-SHA512 (key = $pass)",
552 " 1760 = HMAC-SHA512 (key = $salt)",
553 "",
554 "[[ Generic KDF ]]",
555 "",
556 " 400 = phpass",
557 " 8900 = scrypt",
558 " 11900 = PBKDF2-HMAC-MD5",
559 " 12000 = PBKDF2-HMAC-SHA1",
560 " 10900 = PBKDF2-HMAC-SHA256",
561 " 12100 = PBKDF2-HMAC-SHA512",
562 "",
563 "[[ Network protocols, Challenge-Response ]]",
564 "",
565 " 23 = Skype",
566 " 2500 = WPA/WPA2",
567 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
568 " 5300 = IKE-PSK MD5",
569 " 5400 = IKE-PSK SHA1",
570 " 5500 = NetNTLMv1",
571 " 5500 = NetNTLMv1 + ESS",
572 " 5600 = NetNTLMv2",
573 " 7300 = IPMI2 RAKP HMAC-SHA1",
574 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
575 " 8300 = DNSSEC (NSEC3)",
576 " 10200 = Cram MD5",
577 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
578 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
579 " 11400 = SIP digest authentication (MD5)",
580 "",
581 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
582 "",
583 " 121 = SMF (Simple Machines Forum)",
584 " 400 = phpBB3",
585 " 2611 = vBulletin < v3.8.5",
586 " 2711 = vBulletin > v3.8.5",
587 " 2811 = MyBB",
588 " 2811 = IPB (Invison Power Board)",
589 " 8400 = WBB3 (Woltlab Burning Board)",
590 " 11 = Joomla < 2.5.18",
591 " 400 = Joomla > 2.5.18",
592 " 400 = Wordpress",
593 " 2612 = PHPS",
594 " 7900 = Drupal7",
595 " 21 = osCommerce",
596 " 21 = xt:Commerce",
597 " 11000 = PrestaShop",
598 " 124 = Django (SHA-1)",
599 " 10000 = Django (PBKDF2-SHA256)",
600 " 3711 = Mediawiki B type",
601 " 7600 = Redmine",
602 "",
603 "[[ Database Server ]]",
604 "",
605 " 12 = PostgreSQL",
606 " 131 = MSSQL(2000)",
607 " 132 = MSSQL(2005)",
608 " 1731 = MSSQL(2012)",
609 " 1731 = MSSQL(2014)",
610 " 200 = MySQL323",
611 " 300 = MySQL4.1/MySQL5",
612 " 3100 = Oracle H: Type (Oracle 7+)",
613 " 112 = Oracle S: Type (Oracle 11+)",
614 " 12300 = Oracle T: Type (Oracle 12+)",
615 " 8000 = Sybase ASE",
616 "",
617 "[[ HTTP, SMTP, LDAP Server ]]",
618 "",
619 " 141 = EPiServer 6.x < v4",
620 " 1441 = EPiServer 6.x > v4",
621 " 1600 = Apache $apr1$",
622 " 12600 = ColdFusion 10+",
623 " 1421 = hMailServer",
624 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
625 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
626 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
627 "",
628 "[[ Checksums ]]",
629 "",
630 " 11500 = CRC32",
631 "",
632 "[[ Operating-Systems ]]",
633 "",
634 " 3000 = LM",
635 " 1000 = NTLM",
636 " 1100 = Domain Cached Credentials (DCC), MS Cache",
637 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
638 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
639 " 1500 = descrypt, DES(Unix), Traditional DES",
640 " 12400 = BSDiCrypt, Extended DES",
641 " 500 = md5crypt $1$, MD5(Unix)",
642 " 3200 = bcrypt $2*$, Blowfish(Unix)",
643 " 7400 = sha256crypt $5$, SHA256(Unix)",
644 " 1800 = sha512crypt $6$, SHA512(Unix)",
645 " 122 = OSX v10.4",
646 " 122 = OSX v10.5",
647 " 122 = OSX v10.6",
648 " 1722 = OSX v10.7",
649 " 7100 = OSX v10.8",
650 " 7100 = OSX v10.9",
651 " 7100 = OSX v10.10",
652 " 6300 = AIX {smd5}",
653 " 6700 = AIX {ssha1}",
654 " 6400 = AIX {ssha256}",
655 " 6500 = AIX {ssha512}",
656 " 2400 = Cisco-PIX",
657 " 2410 = Cisco-ASA",
658 " 500 = Cisco-IOS $1$",
659 " 5700 = Cisco-IOS $4$",
660 " 9200 = Cisco-IOS $8$",
661 " 9300 = Cisco-IOS $9$",
662 " 22 = Juniper Netscreen/SSG (ScreenOS)",
663 " 501 = Juniper IVE",
664 " 5800 = Android PIN",
665 " 8100 = Citrix Netscaler",
666 " 8500 = RACF",
667 " 7200 = GRUB 2",
668 " 9900 = Radmin2",
669 "",
670 "[[ Enterprise Application Software (EAS) ]]",
671 "",
672 " 7700 = SAP CODVN B (BCODE)",
673 " 7800 = SAP CODVN F/G (PASSCODE)",
674 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
675 " 8600 = Lotus Notes/Domino 5",
676 " 8700 = Lotus Notes/Domino 6",
677 " 9100 = Lotus Notes/Domino 8",
678 " 133 = PeopleSoft",
679 "",
680 "[[ Archives ]]",
681 "",
682 " 11600 = 7-Zip",
683 " 12500 = RAR3-hp",
684 " 13000 = RAR5",
685 "",
686 "[[ Full-Disk encryptions (FDE) ]]",
687 "",
688 " 62XY = TrueCrypt 5.0+",
689 " X = 1 = PBKDF2-HMAC-RipeMD160",
690 " X = 2 = PBKDF2-HMAC-SHA512",
691 " X = 3 = PBKDF2-HMAC-Whirlpool",
692 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
693 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
694 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
695 " Y = 3 = XTS 1536 bit (Ciphers: All)",
696 " 8800 = Android FDE < v4.3",
697 " 12900 = Android FDE (Samsung DEK)",
698 " 12200 = eCryptfs",
699 "",
700 "[[ Documents ]]",
701 "",
702 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
703 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
704 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
705 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
706 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
707 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
708 " 9400 = MS Office 2007",
709 " 9500 = MS Office 2010",
710 " 9600 = MS Office 2013",
711 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
712 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
713 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
714 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
715 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
716 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
717 "",
718 "[[ Password Managers ]]",
719 "",
720 " 9000 = Password Safe v2",
721 " 5200 = Password Safe v3",
722 " 6800 = Lastpass",
723 " 6600 = 1Password, agilekeychain",
724 " 8200 = 1Password, cloudkeychain",
725 " 11300 = Bitcoin/Litecoin wallet.dat",
726 " 12700 = Blockchain, My Wallet",
727 "",
728 NULL
729 };
730
731 /**
732 * oclHashcat specific functions
733 */
734
735 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
736 {
737 int exec_pos = (int) device_param->exec_pos - last_num_entries;
738
739 if (exec_pos < 0) exec_pos += EXEC_CACHE;
740
741 double exec_ms_sum = 0;
742
743 int exec_ms_cnt = 0;
744
745 for (int i = 0; i < last_num_entries; i++)
746 {
747 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
748
749 if (exec_ms)
750 {
751 exec_ms_sum += exec_ms;
752
753 exec_ms_cnt++;
754 }
755 }
756
757 if (exec_ms_cnt == 0) return 0;
758
759 return exec_ms_sum / exec_ms_cnt;
760 }
761
762 void status_display_automat ()
763 {
764 FILE *out = stdout;
765
766 fprintf (out, "STATUS\t%u\t", data.devices_status);
767
768 /**
769 * speed new
770 */
771
772 fprintf (out, "SPEED\t");
773
774 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
775 {
776 hc_device_param_t *device_param = &data.devices_param[device_id];
777
778 if (device_param->skipped) continue;
779
780 u64 speed_cnt = 0;
781 float speed_ms = 0;
782
783 for (int i = 0; i < SPEED_CACHE; i++)
784 {
785 float rec_ms;
786
787 hc_timer_get (device_param->speed_rec[i], rec_ms);
788
789 if (rec_ms > SPEED_MAXAGE) continue;
790
791 speed_cnt += device_param->speed_cnt[i];
792 speed_ms += device_param->speed_ms[i];
793 }
794
795 speed_cnt /= SPEED_CACHE;
796 speed_ms /= SPEED_CACHE;
797
798 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
799 }
800
801 /**
802 * exec time
803 */
804
805 fprintf (out, "EXEC_RUNTIME\t");
806
807 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
808 {
809 hc_device_param_t *device_param = &data.devices_param[device_id];
810
811 if (device_param->skipped) continue;
812
813 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
814
815 fprintf (out, "%f\t", exec_ms_avg);
816 }
817
818 /**
819 * words_cur
820 */
821
822 u64 words_cur = get_lowest_words_done ();
823
824 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
825
826 /**
827 * counter
828 */
829
830 uint salts_left = data.salts_cnt - data.salts_done;
831
832 if (salts_left == 0) salts_left = 1;
833
834 u64 progress_total = data.words_cnt * salts_left;
835
836 u64 all_done = 0;
837 u64 all_rejected = 0;
838 u64 all_restored = 0;
839
840 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
841 {
842 if (salts_left > 1)
843 {
844 // otherwise the final cracked status shows 0/XXX progress
845
846 if (data.salts_shown[salt_pos] == 1) continue;
847 }
848
849 all_done += data.words_progress_done[salt_pos];
850 all_rejected += data.words_progress_rejected[salt_pos];
851 all_restored += data.words_progress_restored[salt_pos];
852 }
853
854 u64 progress_cur = all_restored + all_done + all_rejected;
855 u64 progress_end = progress_total;
856
857 u64 progress_skip = 0;
858
859 if (data.skip)
860 {
861 progress_skip = MIN (data.skip, data.words_base) * salts_left;
862
863 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
864 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
865 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
866 }
867
868 if (data.limit)
869 {
870 progress_end = MIN (data.limit, data.words_base) * salts_left;
871
872 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
873 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
874 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
875 }
876
877 u64 progress_cur_relative_skip = progress_cur - progress_skip;
878 u64 progress_end_relative_skip = progress_end - progress_skip;
879
880 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
881
882 /**
883 * cracks
884 */
885
886 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
887 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
888
889 /**
890 * temperature
891 */
892
893 #ifdef HAVE_HWMON
894 if (data.gpu_temp_disable == 0)
895 {
896 fprintf (out, "TEMP\t");
897
898 hc_thread_mutex_lock (mux_adl);
899
900 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
901 {
902 hc_device_param_t *device_param = &data.devices_param[device_id];
903
904 if (device_param->skipped) continue;
905
906 int temp = hm_get_temperature_with_device_id (device_id);
907
908 fprintf (out, "%d\t", temp);
909 }
910
911 hc_thread_mutex_unlock (mux_adl);
912 }
913 #endif // HAVE_HWMON
914
915 /**
916 * flush
917 */
918
919 #ifdef _WIN
920 fputc ('\r', out);
921 fputc ('\n', out);
922 #endif
923
924 #ifdef _POSIX
925 fputc ('\n', out);
926 #endif
927
928 fflush (out);
929 }
930
931 void status_display ()
932 {
933 if (data.devices_status == STATUS_INIT) return;
934 if (data.devices_status == STATUS_STARTING) return;
935 if (data.devices_status == STATUS_BYPASS) return;
936
937 if (data.status_automat == 1)
938 {
939 status_display_automat ();
940
941 return;
942 }
943
944 char tmp_buf[1000] = { 0 };
945
946 uint tmp_len = 0;
947
948 log_info ("Session.Name...: %s", data.session);
949
950 char *status_type = strstatus (data.devices_status);
951
952 uint hash_mode = data.hash_mode;
953
954 char *hash_type = strhashtype (hash_mode); // not a bug
955
956 log_info ("Status.........: %s", status_type);
957
958 /**
959 * show rules
960 */
961
962 if (data.rp_files_cnt)
963 {
964 uint i;
965
966 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
967 {
968 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
969 }
970
971 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
972
973 log_info ("Rules.Type.....: %s", tmp_buf);
974
975 tmp_len = 0;
976 }
977
978 if (data.rp_gen)
979 {
980 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
981
982 if (data.rp_gen_seed)
983 {
984 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
985 }
986 }
987
988 /**
989 * show input
990 */
991
992 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
993 {
994 if (data.wordlist_mode == WL_MODE_FILE)
995 {
996 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
997 }
998 else if (data.wordlist_mode == WL_MODE_STDIN)
999 {
1000 log_info ("Input.Mode.....: Pipe");
1001 }
1002 }
1003 else if (data.attack_mode == ATTACK_MODE_COMBI)
1004 {
1005 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1006 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1007 }
1008 else if (data.attack_mode == ATTACK_MODE_BF)
1009 {
1010 char *mask = data.mask;
1011
1012 if (mask != NULL)
1013 {
1014 uint mask_len = data.css_cnt;
1015
1016 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1017
1018 if (mask_len > 0)
1019 {
1020 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1021 {
1022 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1023 {
1024 mask_len -= data.salts_buf[0].salt_len;
1025 }
1026 }
1027
1028 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1029
1030 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1031 }
1032
1033 if (data.maskcnt > 1)
1034 {
1035 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1036
1037 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1038 }
1039
1040 log_info ("Input.Mode.....: %s", tmp_buf);
1041 }
1042
1043 tmp_len = 0;
1044 }
1045 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1046 {
1047 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1048 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1049 }
1050 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1051 {
1052 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1053 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1054 }
1055
1056 if (data.digests_cnt == 1)
1057 {
1058 if (data.hash_mode == 2500)
1059 {
1060 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1061
1062 uint pke[25] = { 0 };
1063
1064 char *pke_ptr = (char *) pke;
1065
1066 for (uint i = 0; i < 25; i++)
1067 {
1068 pke[i] = byte_swap_32 (wpa->pke[i]);
1069 }
1070
1071 char mac1[6] = { 0 };
1072 char mac2[6] = { 0 };
1073
1074 memcpy (mac1, pke_ptr + 23, 6);
1075 memcpy (mac2, pke_ptr + 29, 6);
1076
1077 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1078 (char *) data.salts_buf[0].salt_buf,
1079 mac1[0] & 0xff,
1080 mac1[1] & 0xff,
1081 mac1[2] & 0xff,
1082 mac1[3] & 0xff,
1083 mac1[4] & 0xff,
1084 mac1[5] & 0xff,
1085 mac2[0] & 0xff,
1086 mac2[1] & 0xff,
1087 mac2[2] & 0xff,
1088 mac2[3] & 0xff,
1089 mac2[4] & 0xff,
1090 mac2[5] & 0xff);
1091 }
1092 else if (data.hash_mode == 5200)
1093 {
1094 log_info ("Hash.Target....: File (%s)", data.hashfile);
1095 }
1096 else if (data.hash_mode == 9000)
1097 {
1098 log_info ("Hash.Target....: File (%s)", data.hashfile);
1099 }
1100 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1101 {
1102 log_info ("Hash.Target....: File (%s)", data.hashfile);
1103 }
1104 else
1105 {
1106 char out_buf[4096] = { 0 };
1107
1108 ascii_digest (out_buf, 0, 0);
1109
1110 // limit length
1111 if (strlen (out_buf) > 40)
1112 {
1113 out_buf[41] = '.';
1114 out_buf[42] = '.';
1115 out_buf[43] = '.';
1116 out_buf[44] = 0;
1117 }
1118
1119 log_info ("Hash.Target....: %s", out_buf);
1120 }
1121 }
1122 else
1123 {
1124 if (data.hash_mode == 3000)
1125 {
1126 char out_buf1[4096] = { 0 };
1127 char out_buf2[4096] = { 0 };
1128
1129 ascii_digest (out_buf1, 0, 0);
1130 ascii_digest (out_buf2, 0, 1);
1131
1132 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1133 }
1134 else
1135 {
1136 log_info ("Hash.Target....: File (%s)", data.hashfile);
1137 }
1138 }
1139
1140 log_info ("Hash.Type......: %s", hash_type);
1141
1142 /**
1143 * speed new
1144 */
1145
1146 u64 speed_cnt[DEVICES_MAX] = { 0 };
1147 float speed_ms[DEVICES_MAX] = { 0 };
1148
1149 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1150 {
1151 hc_device_param_t *device_param = &data.devices_param[device_id];
1152
1153 if (device_param->skipped) continue;
1154
1155 // we need to clear values (set to 0) because in case the device does
1156 // not get new candidates it idles around but speed display would
1157 // show it as working.
1158 // if we instantly set it to 0 after reading it happens that the
1159 // speed can be shown as zero if the users refreshes too fast.
1160 // therefore, we add a timestamp when a stat was recorded and if its
1161 // too old we will not use it
1162
1163 speed_cnt[device_id] = 0;
1164 speed_ms[device_id] = 0;
1165
1166 for (int i = 0; i < SPEED_CACHE; i++)
1167 {
1168 float rec_ms;
1169
1170 hc_timer_get (device_param->speed_rec[i], rec_ms);
1171
1172 if (rec_ms > SPEED_MAXAGE) continue;
1173
1174 speed_cnt[device_id] += device_param->speed_cnt[i];
1175 speed_ms[device_id] += device_param->speed_ms[i];
1176 }
1177
1178 speed_cnt[device_id] /= SPEED_CACHE;
1179 speed_ms[device_id] /= SPEED_CACHE;
1180 }
1181
1182 float hashes_all_ms = 0;
1183
1184 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1185
1186 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1187 {
1188 hc_device_param_t *device_param = &data.devices_param[device_id];
1189
1190 if (device_param->skipped) continue;
1191
1192 hashes_dev_ms[device_id] = 0;
1193
1194 if (speed_ms[device_id])
1195 {
1196 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1197
1198 hashes_all_ms += hashes_dev_ms[device_id];
1199 }
1200 }
1201
1202 /**
1203 * exec time
1204 */
1205
1206 double exec_all_ms[DEVICES_MAX] = { 0 };
1207
1208 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1209 {
1210 hc_device_param_t *device_param = &data.devices_param[device_id];
1211
1212 if (device_param->skipped) continue;
1213
1214 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1215
1216 exec_all_ms[device_id] = exec_ms_avg;
1217 }
1218
1219 /**
1220 * timers
1221 */
1222
1223 float ms_running = 0;
1224
1225 hc_timer_get (data.timer_running, ms_running);
1226
1227 float ms_paused = data.ms_paused;
1228
1229 if (data.devices_status == STATUS_PAUSED)
1230 {
1231 float ms_paused_tmp = 0;
1232
1233 hc_timer_get (data.timer_paused, ms_paused_tmp);
1234
1235 ms_paused += ms_paused_tmp;
1236 }
1237
1238 #ifdef WIN
1239
1240 __time64_t sec_run = ms_running / 1000;
1241
1242 #else
1243
1244 time_t sec_run = ms_running / 1000;
1245
1246 #endif
1247
1248 if (sec_run)
1249 {
1250 char display_run[32] = { 0 };
1251
1252 struct tm tm_run;
1253
1254 struct tm *tmp = NULL;
1255
1256 #ifdef WIN
1257
1258 tmp = _gmtime64 (&sec_run);
1259
1260 #else
1261
1262 tmp = gmtime (&sec_run);
1263
1264 #endif
1265
1266 if (tmp != NULL)
1267 {
1268 memset (&tm_run, 0, sizeof (tm_run));
1269
1270 memcpy (&tm_run, tmp, sizeof (tm_run));
1271
1272 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1273
1274 char *start = ctime (&data.proc_start);
1275
1276 size_t start_len = strlen (start);
1277
1278 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1279 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1280
1281 log_info ("Time.Started...: %s (%s)", start, display_run);
1282 }
1283 }
1284 else
1285 {
1286 log_info ("Time.Started...: 0 secs");
1287 }
1288
1289 /**
1290 * counters
1291 */
1292
1293 uint salts_left = data.salts_cnt - data.salts_done;
1294
1295 if (salts_left == 0) salts_left = 1;
1296
1297 u64 progress_total = data.words_cnt * salts_left;
1298
1299 u64 all_done = 0;
1300 u64 all_rejected = 0;
1301 u64 all_restored = 0;
1302
1303 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1304 {
1305 if (salts_left > 1)
1306 {
1307 // otherwise the final cracked status shows 0/XXX progress
1308
1309 if (data.salts_shown[salt_pos] == 1) continue;
1310 }
1311
1312 all_done += data.words_progress_done[salt_pos];
1313 all_rejected += data.words_progress_rejected[salt_pos];
1314 all_restored += data.words_progress_restored[salt_pos];
1315 }
1316
1317 u64 progress_cur = all_restored + all_done + all_rejected;
1318 u64 progress_end = progress_total;
1319
1320 u64 progress_skip = 0;
1321
1322 if (data.skip)
1323 {
1324 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1325
1326 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1327 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1328 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1329 }
1330
1331 if (data.limit)
1332 {
1333 progress_end = MIN (data.limit, data.words_base) * salts_left;
1334
1335 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1336 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1337 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1338 }
1339
1340 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1341 u64 progress_end_relative_skip = progress_end - progress_skip;
1342
1343 float speed_ms_real = ms_running - ms_paused;
1344 u64 speed_plains_real = all_done;
1345
1346 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1347 {
1348 if (data.devices_status != STATUS_CRACKED)
1349 {
1350 u64 words_per_ms = 0;
1351
1352 if (speed_plains_real && speed_ms_real)
1353 {
1354 words_per_ms = speed_plains_real / speed_ms_real;
1355 }
1356
1357 #ifdef WIN
1358 __time64_t sec_etc = 0;
1359 #else
1360 time_t sec_etc = 0;
1361 #endif
1362
1363 if (words_per_ms)
1364 {
1365 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1366
1367 u64 ms_left = progress_left_relative_skip / words_per_ms;
1368
1369 sec_etc = ms_left / 1000;
1370 }
1371
1372 if (sec_etc == 0)
1373 {
1374 log_info ("Time.Estimated.: 0 secs");
1375 }
1376 else if ((u64) sec_etc > ETC_MAX)
1377 {
1378 log_info ("Time.Estimated.: > 10 Years");
1379 }
1380 else
1381 {
1382 char display_etc[32] = { 0 };
1383
1384 struct tm tm_etc;
1385
1386 struct tm *tmp = NULL;
1387
1388 #ifdef WIN
1389
1390 tmp = _gmtime64 (&sec_etc);
1391
1392 #else
1393
1394 tmp = gmtime (&sec_etc);
1395
1396 #endif
1397
1398 if (tmp != NULL)
1399 {
1400 memset (&tm_etc, 0, sizeof (tm_etc));
1401
1402 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1403
1404 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1405
1406 time_t now;
1407
1408 time (&now);
1409
1410 now += sec_etc;
1411
1412 char *etc = ctime (&now);
1413
1414 size_t etc_len = strlen (etc);
1415
1416 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1417 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1418
1419 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1420 }
1421 }
1422 }
1423 }
1424
1425 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1426 {
1427 hc_device_param_t *device_param = &data.devices_param[device_id];
1428
1429 if (device_param->skipped) continue;
1430
1431 char display_dev_cur[16] = { 0 };
1432
1433 strncpy (display_dev_cur, "0.00", 4);
1434
1435 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1436
1437 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1438 }
1439
1440 char display_all_cur[16] = { 0 };
1441
1442 strncpy (display_all_cur, "0.00", 4);
1443
1444 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1445
1446 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1447
1448 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1449 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1450
1451 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);
1452
1453 // crack-per-time
1454
1455 if (data.digests_cnt > 100)
1456 {
1457 time_t now = time (NULL);
1458
1459 int cpt_cur_min = 0;
1460 int cpt_cur_hour = 0;
1461 int cpt_cur_day = 0;
1462
1463 for (int i = 0; i < CPT_BUF; i++)
1464 {
1465 const uint cracked = data.cpt_buf[i].cracked;
1466 const time_t timestamp = data.cpt_buf[i].timestamp;
1467
1468 if ((timestamp + 60) > now)
1469 {
1470 cpt_cur_min += cracked;
1471 }
1472
1473 if ((timestamp + 3600) > now)
1474 {
1475 cpt_cur_hour += cracked;
1476 }
1477
1478 if ((timestamp + 86400) > now)
1479 {
1480 cpt_cur_day += cracked;
1481 }
1482 }
1483
1484 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1485 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1486 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1487
1488 if ((data.cpt_start + 86400) < now)
1489 {
1490 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1491 cpt_cur_min,
1492 cpt_cur_hour,
1493 cpt_cur_day,
1494 cpt_avg_min,
1495 cpt_avg_hour,
1496 cpt_avg_day);
1497 }
1498 else if ((data.cpt_start + 3600) < now)
1499 {
1500 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1501 cpt_cur_min,
1502 cpt_cur_hour,
1503 cpt_avg_min,
1504 cpt_avg_hour,
1505 cpt_avg_day);
1506 }
1507 else if ((data.cpt_start + 60) < now)
1508 {
1509 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1510 cpt_cur_min,
1511 cpt_avg_min,
1512 cpt_avg_hour,
1513 cpt_avg_day);
1514 }
1515 else
1516 {
1517 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1518 cpt_avg_min,
1519 cpt_avg_hour,
1520 cpt_avg_day);
1521 }
1522 }
1523
1524 // Restore point
1525
1526 u64 restore_point = get_lowest_words_done ();
1527
1528 u64 restore_total = data.words_base;
1529
1530 float percent_restore = 0;
1531
1532 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1533
1534 if (progress_end_relative_skip)
1535 {
1536 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1537 {
1538 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1539 float percent_rejected = 0.0;
1540
1541 if (progress_cur)
1542 {
1543 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1544 }
1545
1546 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);
1547 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1548
1549 if (data.restore_disable == 0)
1550 {
1551 if (percent_finished != 1)
1552 {
1553 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1554 }
1555 }
1556 }
1557 }
1558 else
1559 {
1560 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1561 {
1562 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1563 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1564
1565 if (data.restore_disable == 0)
1566 {
1567 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1568 }
1569 }
1570 else
1571 {
1572 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1573 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1574
1575 // --restore not allowed if stdin is used -- really? why?
1576
1577 //if (data.restore_disable == 0)
1578 //{
1579 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1580 //}
1581 }
1582 }
1583
1584 #ifdef HAVE_HWMON
1585 if (data.gpu_temp_disable == 0)
1586 {
1587 hc_thread_mutex_lock (mux_adl);
1588
1589 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1590 {
1591 hc_device_param_t *device_param = &data.devices_param[device_id];
1592
1593 if (device_param->skipped) continue;
1594
1595 #define HM_STR_BUF_SIZE 255
1596
1597 if (data.hm_device[device_id].fan_supported == 1)
1598 {
1599 char utilization[HM_STR_BUF_SIZE] = { 0 };
1600 char temperature[HM_STR_BUF_SIZE] = { 0 };
1601 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1602
1603 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1604 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1605
1606 if (device_param->vendor_id == VENDOR_ID_AMD)
1607 {
1608 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1609 }
1610 else if (device_param->vendor_id == VENDOR_ID_NV)
1611 {
1612 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1613 }
1614
1615 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1616 }
1617 else
1618 {
1619 char utilization[HM_STR_BUF_SIZE] = { 0 };
1620 char temperature[HM_STR_BUF_SIZE] = { 0 };
1621
1622 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1623 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1624
1625 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1626 }
1627 }
1628
1629 hc_thread_mutex_unlock (mux_adl);
1630 }
1631 #endif // HAVE_HWMON
1632 }
1633
1634 static void status_benchmark ()
1635 {
1636 if (data.devices_status == STATUS_INIT) return;
1637 if (data.devices_status == STATUS_STARTING) return;
1638
1639 if (data.words_cnt == 0) return;
1640
1641 u64 speed_cnt[DEVICES_MAX] = { 0 };
1642 float speed_ms[DEVICES_MAX] = { 0 };
1643
1644 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1645 {
1646 hc_device_param_t *device_param = &data.devices_param[device_id];
1647
1648 if (device_param->skipped) continue;
1649
1650 speed_cnt[device_id] = 0;
1651 speed_ms[device_id] = 0;
1652
1653 for (int i = 0; i < SPEED_CACHE; i++)
1654 {
1655 speed_cnt[device_id] += device_param->speed_cnt[i];
1656 speed_ms[device_id] += device_param->speed_ms[i];
1657 }
1658
1659 speed_cnt[device_id] /= SPEED_CACHE;
1660 speed_ms[device_id] /= SPEED_CACHE;
1661 }
1662
1663 float hashes_all_ms = 0;
1664
1665 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1666
1667 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1668 {
1669 hc_device_param_t *device_param = &data.devices_param[device_id];
1670
1671 if (device_param->skipped) continue;
1672
1673 hashes_dev_ms[device_id] = 0;
1674
1675 if (speed_ms[device_id])
1676 {
1677 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1678
1679 hashes_all_ms += hashes_dev_ms[device_id];
1680 }
1681 }
1682
1683 /**
1684 * exec time
1685 */
1686
1687 double exec_all_ms[DEVICES_MAX] = { 0 };
1688
1689 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1690 {
1691 hc_device_param_t *device_param = &data.devices_param[device_id];
1692
1693 if (device_param->skipped) continue;
1694
1695 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1696
1697 exec_all_ms[device_id] = exec_ms_avg;
1698 }
1699
1700 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1701 {
1702 hc_device_param_t *device_param = &data.devices_param[device_id];
1703
1704 if (device_param->skipped) continue;
1705
1706 char display_dev_cur[16] = { 0 };
1707
1708 strncpy (display_dev_cur, "0.00", 4);
1709
1710 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1711
1712 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1713 }
1714
1715 char display_all_cur[16] = { 0 };
1716
1717 strncpy (display_all_cur, "0.00", 4);
1718
1719 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1720
1721 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1722 }
1723
1724 /**
1725 * oclHashcat -only- functions
1726 */
1727
1728 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1729 {
1730 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1731 {
1732 if (attack_kern == ATTACK_KERN_STRAIGHT)
1733 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1734 else if (attack_kern == ATTACK_KERN_COMBI)
1735 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1736 else if (attack_kern == ATTACK_KERN_BF)
1737 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1738 }
1739 else
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1741 }
1742
1743 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1744 {
1745 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1746 {
1747 if (attack_kern == ATTACK_KERN_STRAIGHT)
1748 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1749 else if (attack_kern == ATTACK_KERN_COMBI)
1750 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1751 else if (attack_kern == ATTACK_KERN_BF)
1752 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1753 }
1754 else
1755 {
1756 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1757 }
1758 }
1759
1760 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1761 {
1762 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1763 {
1764 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1765 }
1766 else
1767 {
1768 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1769 }
1770 }
1771
1772 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1773 {
1774 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1775 {
1776 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1777 }
1778 else
1779 {
1780 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1781 }
1782 }
1783
1784 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1785 {
1786 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1787 }
1788
1789 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1790 {
1791 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1792 }
1793
1794 static uint convert_from_hex (char *line_buf, const uint line_len)
1795 {
1796 if (line_len & 1) return (line_len); // not in hex
1797
1798 if (data.hex_wordlist == 1)
1799 {
1800 uint i;
1801 uint j;
1802
1803 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1804 {
1805 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1806 }
1807
1808 memset (line_buf + i, 0, line_len - i);
1809
1810 return (i);
1811 }
1812 else if (line_len >= 6) // $HEX[] = 6
1813 {
1814 if (line_buf[0] != '$') return (line_len);
1815 if (line_buf[1] != 'H') return (line_len);
1816 if (line_buf[2] != 'E') return (line_len);
1817 if (line_buf[3] != 'X') return (line_len);
1818 if (line_buf[4] != '[') return (line_len);
1819 if (line_buf[line_len - 1] != ']') return (line_len);
1820
1821 uint i;
1822 uint j;
1823
1824 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1825 {
1826 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1827 }
1828
1829 memset (line_buf + i, 0, line_len - i);
1830
1831 return (i);
1832 }
1833
1834 return (line_len);
1835 }
1836
1837 static void clear_prompt ()
1838 {
1839 fputc ('\r', stdout);
1840
1841 for (size_t i = 0; i < strlen (PROMPT); i++)
1842 {
1843 fputc (' ', stdout);
1844 }
1845
1846 fputc ('\r', stdout);
1847
1848 fflush (stdout);
1849 }
1850
1851 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1852 {
1853 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1854 }
1855
1856 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1857 {
1858 char *outfile = data.outfile;
1859 uint quiet = data.quiet;
1860 FILE *pot_fp = data.pot_fp;
1861 uint loopback = data.loopback;
1862 uint debug_mode = data.debug_mode;
1863 char *debug_file = data.debug_file;
1864
1865 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1866 int debug_rule_len = 0; // -1 error
1867 uint debug_plain_len = 0;
1868
1869 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1870
1871 // hash
1872
1873 char out_buf[4096] = { 0 };
1874
1875 ascii_digest (out_buf, salt_pos, digest_pos);
1876
1877 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1878
1879 // plain
1880
1881 plain_t plain;
1882
1883 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1884
1885 uint gidvid = plain.gidvid;
1886 uint il_pos = plain.il_pos;
1887
1888 u64 crackpos = device_param->words_off;
1889
1890 uint plain_buf[16] = { 0 };
1891
1892 u8 *plain_ptr = (u8 *) plain_buf;
1893 unsigned int plain_len = 0;
1894
1895 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1896 {
1897 u64 gidd = gidvid;
1898 u64 gidm = 0;
1899
1900 pw_t pw;
1901
1902 gidd_to_pw_t (device_param, gidd, &pw);
1903
1904 for (int i = 0, j = gidm; i < 16; i++, j++)
1905 {
1906 plain_buf[i] = pw.h.hi1[0][j];
1907 }
1908
1909 plain_len = pw.pw_len;
1910
1911 const uint off = device_param->innerloop_pos + il_pos;
1912
1913 if (debug_mode > 0)
1914 {
1915 debug_rule_len = 0;
1916
1917 // save rule
1918 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1919 {
1920 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1921
1922 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1923 }
1924
1925 // save plain
1926 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1927 {
1928 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1929
1930 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1931
1932 debug_plain_len = plain_len;
1933 }
1934 }
1935
1936 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1937
1938 crackpos += gidvid;
1939 crackpos *= data.kernel_rules_cnt;
1940 crackpos += device_param->innerloop_pos + il_pos;
1941
1942 if (plain_len > data.pw_max) plain_len = data.pw_max;
1943 }
1944 else if (data.attack_mode == ATTACK_MODE_COMBI)
1945 {
1946 u64 gidd = gidvid;
1947 u64 gidm = 0;
1948
1949 pw_t pw;
1950
1951 gidd_to_pw_t (device_param, gidd, &pw);
1952
1953 for (int i = 0, j = gidm; i < 16; i++, j++)
1954 {
1955 plain_buf[i] = pw.h.hi1[0][j];
1956 }
1957
1958 plain_len = pw.pw_len;
1959
1960 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1961 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1962
1963 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1964 {
1965 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1966 }
1967 else
1968 {
1969 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1970
1971 memcpy (plain_ptr, comb_buf, comb_len);
1972 }
1973
1974 plain_len += comb_len;
1975
1976 crackpos += gidvid;
1977 crackpos *= data.combs_cnt;
1978 crackpos += device_param->innerloop_pos + il_pos;
1979
1980 if (data.pw_max != PW_DICTMAX1)
1981 {
1982 if (plain_len > data.pw_max) plain_len = data.pw_max;
1983 }
1984 }
1985 else if (data.attack_mode == ATTACK_MODE_BF)
1986 {
1987 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1988 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1989
1990 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1991 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1992
1993 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1994 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1995
1996 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1997 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1998
1999 plain_len = data.css_cnt;
2000
2001 crackpos += gidvid;
2002 crackpos *= data.bfs_cnt;
2003 crackpos += device_param->innerloop_pos + il_pos;
2004 }
2005 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2006 {
2007 u64 gidd = gidvid;
2008 u64 gidm = 0;
2009
2010 pw_t pw;
2011
2012 gidd_to_pw_t (device_param, gidd, &pw);
2013
2014 for (int i = 0, j = gidm; i < 16; i++, j++)
2015 {
2016 plain_buf[i] = pw.h.hi1[0][j];
2017 }
2018
2019 plain_len = pw.pw_len;
2020
2021 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2022
2023 uint start = 0;
2024 uint stop = device_param->kernel_params_mp_buf32[4];
2025
2026 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2027
2028 plain_len += start + stop;
2029
2030 crackpos += gidvid;
2031 crackpos *= data.combs_cnt;
2032 crackpos += device_param->innerloop_pos + il_pos;
2033
2034 if (data.pw_max != PW_DICTMAX1)
2035 {
2036 if (plain_len > data.pw_max) plain_len = data.pw_max;
2037 }
2038 }
2039 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2040 {
2041 u64 gidd = gidvid;
2042 u64 gidm = 0;
2043
2044 pw_t pw;
2045
2046 gidd_to_pw_t (device_param, gidd, &pw);
2047
2048 for (int i = 0, j = gidm; i < 16; i++, j++)
2049 {
2050 plain_buf[i] = pw.h.hi1[0][j];
2051 }
2052
2053 plain_len = pw.pw_len;
2054
2055 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2056
2057 uint start = 0;
2058 uint stop = device_param->kernel_params_mp_buf32[4];
2059
2060 memmove (plain_ptr + stop, plain_ptr, plain_len);
2061
2062 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2063
2064 plain_len += start + stop;
2065
2066 crackpos += gidvid;
2067 crackpos *= data.combs_cnt;
2068 crackpos += device_param->innerloop_pos + il_pos;
2069
2070 if (data.pw_max != PW_DICTMAX1)
2071 {
2072 if (plain_len > data.pw_max) plain_len = data.pw_max;
2073 }
2074 }
2075
2076 if (data.attack_mode == ATTACK_MODE_BF)
2077 {
2078 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2079 {
2080 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2081 {
2082 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2083 {
2084 plain_len = plain_len - data.salts_buf[0].salt_len;
2085 }
2086 }
2087
2088 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2089 {
2090 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2091 {
2092 plain_ptr[j] = plain_ptr[i];
2093 }
2094
2095 plain_len = plain_len / 2;
2096 }
2097 }
2098 }
2099
2100 // if enabled, update also the potfile
2101
2102 if (pot_fp)
2103 {
2104 lock_file (pot_fp);
2105
2106 fprintf (pot_fp, "%s:", out_buf);
2107
2108 format_plain (pot_fp, plain_ptr, plain_len, 1);
2109
2110 fputc ('\n', pot_fp);
2111
2112 fflush (pot_fp);
2113
2114 unlock_file (pot_fp);
2115 }
2116
2117 // outfile
2118
2119 FILE *out_fp = NULL;
2120
2121 if (outfile != NULL)
2122 {
2123 if ((out_fp = fopen (outfile, "ab")) == NULL)
2124 {
2125 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2126
2127 out_fp = stdout;
2128 }
2129 lock_file (out_fp);
2130 }
2131 else
2132 {
2133 out_fp = stdout;
2134
2135 if (quiet == 0) clear_prompt ();
2136 }
2137
2138 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2139
2140 if (outfile != NULL)
2141 {
2142 if (out_fp != stdout)
2143 {
2144 fclose (out_fp);
2145 }
2146 }
2147 else
2148 {
2149 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2150 {
2151 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2152 {
2153 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2154 if (quiet == 0) fflush (stdout);
2155 }
2156 }
2157 }
2158
2159 // loopback
2160
2161 if (loopback)
2162 {
2163 char *loopback_file = data.loopback_file;
2164
2165 FILE *fb_fp = NULL;
2166
2167 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2168 {
2169 lock_file (fb_fp);
2170
2171 format_plain (fb_fp, plain_ptr, plain_len, 1);
2172
2173 fputc ('\n', fb_fp);
2174
2175 fclose (fb_fp);
2176 }
2177 }
2178
2179 // (rule) debug mode
2180
2181 // the next check implies that:
2182 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2183 // - debug_mode > 0
2184
2185 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2186 {
2187 if (debug_rule_len < 0) debug_rule_len = 0;
2188
2189 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2190
2191 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2192
2193 if ((quiet == 0) && (debug_file == NULL))
2194 {
2195 fprintf (stdout, "%s", PROMPT);
2196 fflush (stdout);
2197 }
2198 }
2199 }
2200
2201 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2202 {
2203 salt_t *salt_buf = &data.salts_buf[salt_pos];
2204
2205 int found = 0;
2206
2207 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2208
2209 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2210
2211 if (found == 1)
2212 {
2213 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2214
2215 log_info_nn ("");
2216
2217 hc_clEnqueueReadBuffer (data.ocl, 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);
2218
2219 uint cpt_cracked = 0;
2220
2221 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2222 {
2223 uint idx = salt_buf->digests_offset + digest_pos;
2224
2225 if (data.digests_shown_tmp[idx] == 0) continue;
2226
2227 if (data.digests_shown[idx] == 1) continue;
2228
2229 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2230 {
2231 data.digests_shown[idx] = 1;
2232
2233 data.digests_done++;
2234
2235 cpt_cracked++;
2236
2237 salt_buf->digests_done++;
2238
2239 if (salt_buf->digests_done == salt_buf->digests_cnt)
2240 {
2241 data.salts_shown[salt_pos] = 1;
2242
2243 data.salts_done++;
2244 }
2245 }
2246
2247 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2248
2249 check_hash (device_param, salt_pos, digest_pos);
2250 }
2251
2252 if (cpt_cracked > 0)
2253 {
2254 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2255 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2256
2257 data.cpt_pos++;
2258
2259 data.cpt_total += cpt_cracked;
2260
2261 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2262 }
2263
2264 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2265 {
2266 // we need to reset cracked state on the device
2267 // otherwise host thinks again and again the hash was cracked
2268 // and returns invalid password each time
2269
2270 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2271
2272 hc_clEnqueueWriteBuffer (data.ocl, 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);
2273 }
2274
2275 memset (device_param->result, 0, device_param->size_results);
2276
2277 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2278 }
2279 }
2280
2281 static void save_hash ()
2282 {
2283 char *hashfile = data.hashfile;
2284
2285 char new_hashfile[256] = { 0 };
2286 char old_hashfile[256] = { 0 };
2287
2288 snprintf (new_hashfile, 255, "%s.new", hashfile);
2289 snprintf (old_hashfile, 255, "%s.old", hashfile);
2290
2291 unlink (new_hashfile);
2292
2293 char separator = data.separator;
2294
2295 FILE *fp = fopen (new_hashfile, "wb");
2296
2297 if (fp == NULL)
2298 {
2299 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2300
2301 exit (-1);
2302 }
2303
2304 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2305 {
2306 if (data.salts_shown[salt_pos] == 1) continue;
2307
2308 salt_t *salt_buf = &data.salts_buf[salt_pos];
2309
2310 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2311 {
2312 uint idx = salt_buf->digests_offset + digest_pos;
2313
2314 if (data.digests_shown[idx] == 1) continue;
2315
2316 if (data.hash_mode != 2500)
2317 {
2318 char out_buf[4096] = { 0 };
2319
2320 if (data.username == 1)
2321 {
2322 user_t *user = data.hash_info[idx]->user;
2323
2324 uint i;
2325
2326 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2327
2328 fputc (separator, fp);
2329 }
2330
2331 ascii_digest (out_buf, salt_pos, digest_pos);
2332
2333 fputs (out_buf, fp);
2334
2335 log_out (fp, "");
2336 }
2337 else
2338 {
2339 hccap_t hccap;
2340
2341 to_hccap_t (&hccap, salt_pos, digest_pos);
2342
2343 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2344 }
2345 }
2346 }
2347
2348 fflush (fp);
2349
2350 fclose (fp);
2351
2352 unlink (old_hashfile);
2353
2354 if (rename (hashfile, old_hashfile) != 0)
2355 {
2356 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2357
2358 exit (-1);
2359 }
2360
2361 unlink (hashfile);
2362
2363 if (rename (new_hashfile, hashfile) != 0)
2364 {
2365 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2366
2367 exit (-1);
2368 }
2369
2370 unlink (old_hashfile);
2371 }
2372
2373 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2374 {
2375 // function called only in case kernel_power_all > words_left
2376
2377 float kernel_power_div = (float) (total_left) / kernel_power_all;
2378
2379 kernel_power_div += kernel_power_div / 100;
2380
2381 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2382
2383 while (kernel_power_new < total_left)
2384 {
2385 kernel_power_div += kernel_power_div / 100;
2386
2387 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2388 }
2389
2390 if (data.quiet == 0)
2391 {
2392 clear_prompt ();
2393
2394 log_info ("");
2395
2396 log_info ("INFO: approaching final keyspace, workload adjusted");
2397
2398 log_info ("");
2399
2400 fprintf (stdout, "%s", PROMPT);
2401
2402 fflush (stdout);
2403 }
2404
2405 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2406
2407 return kernel_power_div;
2408 }
2409
2410 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2411 {
2412 uint num_elements = num;
2413
2414 device_param->kernel_params_buf32[30] = data.combs_mode;
2415 device_param->kernel_params_buf32[31] = num;
2416
2417 uint kernel_threads = device_param->kernel_threads;
2418
2419 while (num_elements % kernel_threads) num_elements++;
2420
2421 cl_kernel kernel = NULL;
2422
2423 switch (kern_run)
2424 {
2425 case KERN_RUN_1: kernel = device_param->kernel1; break;
2426 case KERN_RUN_12: kernel = device_param->kernel12; break;
2427 case KERN_RUN_2: kernel = device_param->kernel2; break;
2428 case KERN_RUN_23: kernel = device_param->kernel23; break;
2429 case KERN_RUN_3: kernel = device_param->kernel3; break;
2430 }
2431
2432 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2433 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2434 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2435 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2436 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2437 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2438 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2439 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2440 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2441 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2442 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2443
2444 cl_event event;
2445
2446 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2447 {
2448 const size_t global_work_size[3] = { num_elements, 32, 1 };
2449 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2450
2451 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event, true);
2452 }
2453 else
2454 {
2455 const size_t global_work_size[3] = { num_elements, 1, 1 };
2456 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2457
2458 const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event, false);
2459
2460 if (rc != CL_SUCCESS)
2461 {
2462 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2463
2464 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, &event, true);
2465 }
2466 }
2467
2468 hc_clFlush (data.ocl, device_param->command_queue);
2469
2470 hc_clWaitForEvents (data.ocl, 1, &event);
2471
2472 if (event_update)
2473 {
2474 cl_ulong time_start;
2475 cl_ulong time_end;
2476
2477 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2478 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2479
2480 const double exec_time = (time_end - time_start) / 1000000.0;
2481
2482 uint exec_pos = device_param->exec_pos;
2483
2484 device_param->exec_ms[exec_pos] = exec_time;
2485
2486 exec_pos++;
2487
2488 if (exec_pos == EXEC_CACHE)
2489 {
2490 exec_pos = 0;
2491 }
2492
2493 device_param->exec_pos = exec_pos;
2494 }
2495
2496 hc_clReleaseEvent (data.ocl, event);
2497
2498 hc_clFinish (data.ocl, device_param->command_queue);
2499 }
2500
2501 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2502 {
2503 uint num_elements = num;
2504
2505 switch (kern_run)
2506 {
2507 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2508 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2509 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2510 }
2511
2512 // causes problems with special threads like in bcrypt
2513 // const uint kernel_threads = device_param->kernel_threads;
2514
2515 const uint kernel_threads = KERNEL_THREADS;
2516
2517 while (num_elements % kernel_threads) num_elements++;
2518
2519 cl_kernel kernel = NULL;
2520
2521 switch (kern_run)
2522 {
2523 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2524 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2525 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2526 }
2527
2528 switch (kern_run)
2529 {
2530 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2531 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2532 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2533 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2534 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2535 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2536 break;
2537 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2538 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2539 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2540 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2541 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2542 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2543 break;
2544 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2545 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2546 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2547 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2548 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2549 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2550 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2551 break;
2552 }
2553
2554 const size_t global_work_size[3] = { num_elements, 1, 1 };
2555 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2556
2557 const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, false);
2558
2559 if (rc != CL_SUCCESS)
2560 {
2561 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2562
2563 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2564 }
2565
2566 hc_clFlush (data.ocl, device_param->command_queue);
2567
2568 hc_clFinish (data.ocl, device_param->command_queue);
2569 }
2570
2571 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2572 {
2573 uint num_elements = num;
2574
2575 uint kernel_threads = device_param->kernel_threads;
2576
2577 while (num_elements % kernel_threads) num_elements++;
2578
2579 cl_kernel kernel = device_param->kernel_tb;
2580
2581 const size_t global_work_size[3] = { num_elements, 1, 1 };
2582 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2583
2584 const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, false);
2585
2586 if (rc != CL_SUCCESS)
2587 {
2588 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2589
2590 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2591 }
2592
2593 hc_clFlush (data.ocl, device_param->command_queue);
2594
2595 hc_clFinish (data.ocl, device_param->command_queue);
2596 }
2597
2598 static void run_kernel_tm (hc_device_param_t *device_param)
2599 {
2600 const uint num_elements = 1024; // fixed
2601
2602 const uint kernel_threads = 32;
2603
2604 cl_kernel kernel = device_param->kernel_tm;
2605
2606 const size_t global_work_size[3] = { num_elements, 1, 1 };
2607 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2608
2609 const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, false);
2610
2611 if (rc != CL_SUCCESS)
2612 {
2613 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2614
2615 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2616 }
2617
2618 hc_clFlush (data.ocl, device_param->command_queue);
2619
2620 hc_clFinish (data.ocl, device_param->command_queue);
2621 }
2622
2623 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2624 {
2625 uint num_elements = num;
2626
2627 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2628 device_param->kernel_params_amp_buf32[6] = num_elements;
2629
2630 // causes problems with special threads like in bcrypt
2631 // const uint kernel_threads = device_param->kernel_threads;
2632
2633 const uint kernel_threads = KERNEL_THREADS;
2634
2635 while (num_elements % kernel_threads) num_elements++;
2636
2637 cl_kernel kernel = device_param->kernel_amp;
2638
2639 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2640 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2641
2642 const size_t global_work_size[3] = { num_elements, 1, 1 };
2643 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2644
2645 const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, false);
2646
2647 if (rc != CL_SUCCESS)
2648 {
2649 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2650
2651 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2652 }
2653
2654 hc_clFlush (data.ocl, device_param->command_queue);
2655
2656 hc_clFinish (data.ocl, device_param->command_queue);
2657 }
2658
2659 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2660 {
2661 int rc = -1;
2662
2663 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2664 {
2665 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2666
2667 const cl_uchar zero = 0;
2668
2669 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2670 }
2671
2672 if (rc != 0)
2673 {
2674 // NOTE: clEnqueueFillBuffer () always fails with -59
2675 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2676 // How's that possible, OpenCL 1.2 support is advertised??
2677 // We need to workaround...
2678
2679 #define FILLSZ 0x100000
2680
2681 char *tmp = (char *) mymalloc (FILLSZ);
2682
2683 for (uint i = 0; i < size; i += FILLSZ)
2684 {
2685 const int left = size - i;
2686
2687 const int fillsz = MIN (FILLSZ, left);
2688
2689 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2690 }
2691
2692 myfree (tmp);
2693 }
2694 }
2695
2696 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt)
2697 {
2698 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2699 {
2700 if (attack_mode == ATTACK_MODE_BF)
2701 {
2702 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2703 {
2704 const uint size_tm = 32 * sizeof (bs_word_t);
2705
2706 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2707
2708 run_kernel_tm (device_param);
2709
2710 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2711 }
2712 }
2713
2714 if (highest_pw_len < 16)
2715 {
2716 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2717 }
2718 else if (highest_pw_len < 32)
2719 {
2720 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2721 }
2722 else
2723 {
2724 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2725 }
2726 }
2727 else
2728 {
2729 run_kernel_amp (device_param, pws_cnt);
2730
2731 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2732
2733 if (opts_type & OPTS_TYPE_HOOK12)
2734 {
2735 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2736 }
2737
2738 uint iter = salt_buf->salt_iter;
2739
2740 uint loop_step = device_param->kernel_loops;
2741
2742 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2743 {
2744 uint loop_left = iter - loop_pos;
2745
2746 loop_left = MIN (loop_left, loop_step);
2747
2748 device_param->kernel_params_buf32[25] = loop_pos;
2749 device_param->kernel_params_buf32[26] = loop_left;
2750
2751 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2752
2753 if (data.devices_status == STATUS_CRACKED) break;
2754 if (data.devices_status == STATUS_ABORTED) break;
2755 if (data.devices_status == STATUS_QUIT) break;
2756 }
2757
2758 if (opts_type & OPTS_TYPE_HOOK23)
2759 {
2760 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2761
2762 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2763
2764 // do something with data
2765
2766 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2767 }
2768
2769 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2770 }
2771 }
2772
2773 static int run_rule_engine (const int rule_len, const char *rule_buf)
2774 {
2775 if (rule_len == 0)
2776 {
2777 return 0;
2778 }
2779 else if (rule_len == 1)
2780 {
2781 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2782 }
2783
2784 return 1;
2785 }
2786
2787 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2788 {
2789 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2790 {
2791 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2792 }
2793 else if (data.attack_kern == ATTACK_KERN_COMBI)
2794 {
2795 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2796 }
2797 else if (data.attack_kern == ATTACK_KERN_BF)
2798 {
2799 const u64 off = device_param->words_off;
2800
2801 device_param->kernel_params_mp_l_buf64[3] = off;
2802
2803 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2804 }
2805 }
2806
2807 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2808 {
2809 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2810
2811 device_param->kernel_params_buf32[26] = kernel_loops;
2812 device_param->kernel_params_buf32[27] = kernel_loops;
2813
2814 // caching run
2815
2816 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2817 {
2818 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2819 }
2820 else
2821 {
2822 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2823 }
2824
2825 // now user repeats
2826
2827 for (int i = 0; i < repeat; i++)
2828 {
2829 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2830 {
2831 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2832 }
2833 else
2834 {
2835 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2836 }
2837 }
2838
2839 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2840
2841 return exec_ms_prev;
2842 }
2843
2844 static void autotune (hc_device_param_t *device_param)
2845 {
2846 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2847
2848 u32 kernel_loops_min = device_param->kernel_loops_min;
2849 u32 kernel_loops_max = device_param->kernel_loops_max;
2850
2851 u32 kernel_accel_min = device_param->kernel_accel_min;
2852 u32 kernel_accel_max = device_param->kernel_accel_max;
2853
2854 u32 kernel_loops = kernel_loops_min;
2855 u32 kernel_accel = kernel_accel_min;
2856
2857 // init some fake words
2858
2859 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel_max;
2860
2861 for (u32 i = 0; i < kernel_power_max; i++)
2862 {
2863 device_param->pws_buf[i].pw_len = 8;
2864 }
2865
2866 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, device_param->size_pws, device_param->pws_buf, 0, NULL, NULL);
2867 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, device_param->size_pws, device_param->pws_buf, 0, NULL, NULL);
2868
2869 // steps for loops
2870
2871 #define STEPS_LOOPS_CNT 15
2872
2873 u32 steps_loops[STEPS_LOOPS_CNT];
2874
2875 steps_loops[ 0] = 1;
2876 steps_loops[ 1] = 2;
2877 steps_loops[ 2] = 4;
2878 steps_loops[ 3] = 8;
2879 steps_loops[ 4] = 16;
2880 steps_loops[ 5] = 32;
2881 steps_loops[ 6] = 64;
2882 steps_loops[ 7] = 100;
2883 steps_loops[ 8] = 128;
2884 steps_loops[ 9] = 200;
2885 steps_loops[10] = 256;
2886 steps_loops[11] = 500;
2887 steps_loops[12] = 512;
2888 steps_loops[13] = 1000;
2889 steps_loops[14] = 1024;
2890
2891 // steps for accel
2892
2893 #define STEPS_ACCEL_CNT 13
2894
2895 u32 steps_accel[STEPS_ACCEL_CNT];
2896
2897 steps_accel[ 0] = 1;
2898 steps_accel[ 1] = 2;
2899 steps_accel[ 2] = 4;
2900 steps_accel[ 3] = 8;
2901 steps_accel[ 4] = 16;
2902 steps_accel[ 5] = 32;
2903 steps_accel[ 6] = 64;
2904 steps_accel[ 7] = 128;
2905 steps_accel[ 8] = 256;
2906 steps_accel[ 9] = 384;
2907 steps_accel[10] = 512;
2908 steps_accel[11] = 768;
2909 steps_accel[12] = 1024;
2910
2911 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2912
2913 u32 kernel_loops_tmp;
2914
2915 for (kernel_loops_tmp = MIN (kernel_loops_max, 200); kernel_loops_tmp >= kernel_loops_min; kernel_loops_tmp >>= 1)
2916 {
2917 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2918
2919 if (exec_ms < target_ms) break;
2920
2921 if (kernel_loops_tmp == kernel_loops_min) break;
2922 }
2923
2924 // kernel-accel
2925
2926 double e_best = 0;
2927
2928 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2929 {
2930 const u32 kernel_accel_try = steps_accel[i];
2931
2932 if (kernel_accel_try < kernel_accel_min) continue;
2933 if (kernel_accel_try > kernel_accel_max) break;
2934
2935 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2936
2937 if (exec_ms > target_ms) break;
2938
2939 const double e = kernel_accel_try / exec_ms;
2940
2941 if (e > e_best)
2942 {
2943 kernel_accel = kernel_accel_try;
2944
2945 e_best = e;
2946 }
2947 }
2948
2949 // kernel-loops final
2950
2951 e_best = 0;
2952
2953 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2954 {
2955 const u32 kernel_loops_try = steps_loops[i];
2956
2957 if (kernel_loops_try < kernel_loops_min) continue;
2958 if (kernel_loops_try > kernel_loops_max) break;
2959
2960 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2961
2962 if (exec_ms > target_ms) break;
2963
2964 const double e = kernel_loops_try / exec_ms;
2965
2966 if (e > e_best)
2967 {
2968 kernel_loops = kernel_loops_try;
2969
2970 e_best = e;
2971 }
2972 }
2973
2974 // final balance
2975
2976 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops, 1);
2977
2978 e_best = exec_ms;
2979
2980 u32 kernel_accel_try = kernel_accel;
2981 u32 kernel_loops_try = kernel_loops;
2982
2983 for (int i = 0; i < 2; i++)
2984 {
2985 kernel_accel_try >>= 1;
2986 kernel_loops_try <<= 1;
2987
2988 if (kernel_accel_try < kernel_accel_min) break;
2989 if (kernel_loops_try > kernel_loops_max) break;
2990
2991 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2992
2993 if (exec_ms > e_best) break;
2994
2995 kernel_accel = kernel_accel_try;
2996 kernel_loops = kernel_loops_try;
2997
2998 e_best = exec_ms;
2999 }
3000
3001 kernel_accel_try = kernel_accel;
3002 kernel_loops_try = kernel_loops;
3003
3004 for (int i = 0; i < 2; i++)
3005 {
3006 kernel_accel_try <<= 1;
3007 kernel_loops_try >>= 1;
3008
3009 if (kernel_accel_try > kernel_accel_max) break;
3010 if (kernel_loops_try < kernel_loops_min) break;
3011
3012 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3013
3014 if (exec_ms > e_best) break;
3015
3016 kernel_accel = kernel_accel_try;
3017 kernel_loops = kernel_loops_try;
3018
3019 e_best = exec_ms;
3020 }
3021
3022 // reset timer
3023
3024 device_param->exec_pos = 0;
3025
3026 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3027
3028 // reset fake words
3029
3030 for (u32 i = 0; i < kernel_power_max; i++)
3031 {
3032 device_param->pws_buf[i].pw_len = 0;
3033 }
3034
3035 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, device_param->size_pws, device_param->pws_buf, 0, NULL, NULL);
3036 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, device_param->size_pws, device_param->pws_buf, 0, NULL, NULL);
3037
3038 // store
3039
3040 device_param->kernel_loops = kernel_loops;
3041 device_param->kernel_accel = kernel_accel;
3042
3043 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3044
3045 device_param->kernel_power = kernel_power;
3046
3047 log_info ("Device #%u: autotuned kernel-accel to %u", device_param->device_id + 1, kernel_accel);
3048 log_info ("Device #%u: autotuned kernel-loops to %u", device_param->device_id + 1, kernel_loops);
3049 log_info ("");
3050 }
3051
3052 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
3053 {
3054 // init speed timer
3055
3056 uint speed_pos = device_param->speed_pos;
3057
3058 #ifdef _POSIX
3059 if (device_param->timer_speed.tv_sec == 0)
3060 {
3061 hc_timer_set (&device_param->timer_speed);
3062 }
3063 #endif
3064
3065 #ifdef _WIN
3066 if (device_param->timer_speed.QuadPart == 0)
3067 {
3068 hc_timer_set (&device_param->timer_speed);
3069 }
3070 #endif
3071
3072 // find higest password length, this is for optimization stuff
3073
3074 uint highest_pw_len = 0;
3075
3076 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3077 {
3078 }
3079 else if (data.attack_kern == ATTACK_KERN_COMBI)
3080 {
3081 }
3082 else if (data.attack_kern == ATTACK_KERN_BF)
3083 {
3084 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3085 + device_param->kernel_params_mp_l_buf32[5];
3086 }
3087
3088 // bitslice optimization stuff
3089
3090 if (data.attack_mode == ATTACK_MODE_BF)
3091 {
3092 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
3093 {
3094 run_kernel_tb (device_param, pws_cnt);
3095 }
3096 }
3097
3098 // iteration type
3099
3100 uint innerloop_step = 0;
3101 uint innerloop_cnt = 0;
3102
3103 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3104 else innerloop_step = 1;
3105
3106 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3107 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3108 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3109
3110 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3111
3112 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3113 {
3114 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3115
3116 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3117
3118 if (data.devices_status == STATUS_CRACKED) break;
3119 if (data.devices_status == STATUS_ABORTED) break;
3120 if (data.devices_status == STATUS_QUIT) break;
3121 if (data.devices_status == STATUS_BYPASS) break;
3122
3123 if (data.salts_shown[salt_pos] == 1) continue;
3124
3125 salt_t *salt_buf = &data.salts_buf[salt_pos];
3126
3127 device_param->kernel_params_buf32[24] = salt_pos;
3128 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3129 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3130
3131 FILE *combs_fp = device_param->combs_fp;
3132
3133 if (data.attack_mode == ATTACK_MODE_COMBI)
3134 {
3135 rewind (combs_fp);
3136 }
3137
3138 // innerloops
3139
3140 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3141 {
3142 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3143
3144 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3145
3146 if (data.devices_status == STATUS_CRACKED) break;
3147 if (data.devices_status == STATUS_ABORTED) break;
3148 if (data.devices_status == STATUS_QUIT) break;
3149 if (data.devices_status == STATUS_BYPASS) break;
3150
3151 uint innerloop_left = innerloop_cnt - innerloop_pos;
3152
3153 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3154
3155 device_param->innerloop_pos = innerloop_pos;
3156 device_param->innerloop_left = innerloop_left;
3157
3158 device_param->kernel_params_buf32[27] = innerloop_left;
3159
3160 // i think we can get rid of this
3161 if (innerloop_left == 0)
3162 {
3163 puts ("bug, how should this happen????\n");
3164
3165 continue;
3166 }
3167
3168 // initialize amplifiers
3169
3170 if (data.attack_mode == ATTACK_MODE_COMBI)
3171 {
3172 char line_buf[BUFSIZ] = { 0 };
3173
3174 uint i = 0;
3175
3176 while (i < innerloop_left)
3177 {
3178 if (feof (combs_fp)) break;
3179
3180 int line_len = fgetl (combs_fp, line_buf);
3181
3182 if (line_len >= PW_MAX1) continue;
3183
3184 line_len = convert_from_hex (line_buf, line_len);
3185
3186 char *line_buf_new = line_buf;
3187
3188 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3189 {
3190 char rule_buf_out[BLOCK_SIZE] = { 0 };
3191
3192 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3193
3194 if (rule_len_out < 0)
3195 {
3196 data.words_progress_rejected[salt_pos] += pw_cnt;
3197
3198 continue;
3199 }
3200
3201 line_len = rule_len_out;
3202
3203 line_buf_new = rule_buf_out;
3204 }
3205
3206 line_len = MIN (line_len, PW_DICTMAX);
3207
3208 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3209
3210 memcpy (ptr, line_buf_new, line_len);
3211
3212 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3213
3214 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3215 {
3216 uppercase (ptr, line_len);
3217 }
3218
3219 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3220 {
3221 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3222 {
3223 ptr[line_len] = 0x80;
3224 }
3225
3226 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3227 {
3228 ptr[line_len] = 0x01;
3229 }
3230 }
3231
3232 device_param->combs_buf[i].pw_len = line_len;
3233
3234 i++;
3235 }
3236
3237 for (uint j = i; j < innerloop_left; j++)
3238 {
3239 device_param->combs_buf[j].i[0] = 0;
3240 device_param->combs_buf[j].i[1] = 0;
3241 device_param->combs_buf[j].i[2] = 0;
3242 device_param->combs_buf[j].i[3] = 0;
3243 device_param->combs_buf[j].i[4] = 0;
3244 device_param->combs_buf[j].i[5] = 0;
3245 device_param->combs_buf[j].i[6] = 0;
3246 device_param->combs_buf[j].i[7] = 0;
3247
3248 device_param->combs_buf[j].pw_len = 0;
3249 }
3250
3251 innerloop_left = i;
3252 }
3253 else if (data.attack_mode == ATTACK_MODE_BF)
3254 {
3255 u64 off = innerloop_pos;
3256
3257 device_param->kernel_params_mp_r_buf64[3] = off;
3258
3259 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3260 }
3261 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3262 {
3263 u64 off = innerloop_pos;
3264
3265 device_param->kernel_params_mp_buf64[3] = off;
3266
3267 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3268 }
3269 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3270 {
3271 u64 off = innerloop_pos;
3272
3273 device_param->kernel_params_mp_buf64[3] = off;
3274
3275 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3276 }
3277
3278 // copy amplifiers
3279
3280 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3281 {
3282 hc_clEnqueueCopyBuffer (data.ocl, 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);
3283 }
3284 else if (data.attack_mode == ATTACK_MODE_COMBI)
3285 {
3286 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
3287 }
3288 else if (data.attack_mode == ATTACK_MODE_BF)
3289 {
3290 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
3291 }
3292 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3293 {
3294 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3295 }
3296 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3297 {
3298 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3299 }
3300
3301 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3302
3303 if (data.benchmark == 1)
3304 {
3305 for (u32 i = 0; i < data.benchmark_repeats; i++)
3306 {
3307 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3308 }
3309 }
3310
3311 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3312
3313 if (data.devices_status == STATUS_CRACKED) break;
3314 if (data.devices_status == STATUS_ABORTED) break;
3315 if (data.devices_status == STATUS_QUIT) break;
3316
3317 /**
3318 * result
3319 */
3320
3321 hc_thread_mutex_lock (mux_display);
3322
3323 check_cracked (device_param, salt_pos);
3324
3325 hc_thread_mutex_unlock (mux_display);
3326
3327 /**
3328 * progress
3329 */
3330
3331 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
3332
3333 if (data.benchmark == 1)
3334 {
3335 perf_sum_all = (perf_sum_all * data.benchmark_repeats) + perf_sum_all;
3336 }
3337
3338 hc_thread_mutex_lock (mux_counter);
3339
3340 data.words_progress_done[salt_pos] += perf_sum_all;
3341
3342 hc_thread_mutex_unlock (mux_counter);
3343
3344 /**
3345 * speed
3346 */
3347
3348 float speed_ms;
3349
3350 hc_timer_get (device_param->timer_speed, speed_ms);
3351
3352 hc_timer_set (&device_param->timer_speed);
3353
3354 hc_thread_mutex_lock (mux_display);
3355
3356 device_param->speed_cnt[speed_pos] = perf_sum_all;
3357
3358 device_param->speed_ms[speed_pos] = speed_ms;
3359
3360 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3361
3362 hc_thread_mutex_unlock (mux_display);
3363
3364 speed_pos++;
3365
3366 if (speed_pos == SPEED_CACHE)
3367 {
3368 speed_pos = 0;
3369 }
3370
3371 /**
3372 * benchmark
3373 */
3374
3375 if (data.benchmark == 1)
3376 {
3377 data.devices_status = STATUS_BYPASS;
3378 };
3379 }
3380 }
3381
3382 device_param->speed_pos = speed_pos;
3383 }
3384
3385 static void load_segment (wl_data_t *wl_data, FILE *fd)
3386 {
3387 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3388
3389 wl_data->pos = 0;
3390
3391 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3392
3393 wl_data->buf[wl_data->cnt] = 0;
3394
3395 if (wl_data->cnt == 0) return;
3396
3397 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3398
3399 while (!feof (fd))
3400 {
3401 if (wl_data->cnt == wl_data->avail)
3402 {
3403 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3404
3405 wl_data->avail += wl_data->incr;
3406 }
3407
3408 const int c = fgetc (fd);
3409
3410 if (c == EOF) break;
3411
3412 wl_data->buf[wl_data->cnt] = (char) c;
3413
3414 wl_data->cnt++;
3415
3416 if (c == '\n') break;
3417 }
3418
3419 // ensure stream ends with a newline
3420
3421 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3422 {
3423 wl_data->cnt++;
3424
3425 wl_data->buf[wl_data->cnt - 1] = '\n';
3426 }
3427
3428 return;
3429 }
3430
3431 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3432 {
3433 char *ptr = buf;
3434
3435 for (u32 i = 0; i < sz; i++, ptr++)
3436 {
3437 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3438
3439 if (i == 7)
3440 {
3441 *off = i;
3442 *len = i;
3443
3444 return;
3445 }
3446
3447 if (*ptr != '\n') continue;
3448
3449 *off = i + 1;
3450
3451 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3452
3453 *len = i;
3454
3455 return;
3456 }
3457
3458 *off = sz;
3459 *len = sz;
3460 }
3461
3462 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3463 {
3464 char *ptr = buf;
3465
3466 for (u32 i = 0; i < sz; i++, ptr++)
3467 {
3468 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3469
3470 if (*ptr != '\n') continue;
3471
3472 *off = i + 1;
3473
3474 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3475
3476 *len = i;
3477
3478 return;
3479 }
3480
3481 *off = sz;
3482 *len = sz;
3483 }
3484
3485 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3486 {
3487 char *ptr = buf;
3488
3489 for (u32 i = 0; i < sz; i++, ptr++)
3490 {
3491 if (*ptr != '\n') continue;
3492
3493 *off = i + 1;
3494
3495 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3496
3497 *len = i;
3498
3499 return;
3500 }
3501
3502 *off = sz;
3503 *len = sz;
3504 }
3505
3506 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3507 {
3508 while (wl_data->pos < wl_data->cnt)
3509 {
3510 uint off;
3511 uint len;
3512
3513 char *ptr = wl_data->buf + wl_data->pos;
3514
3515 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3516
3517 wl_data->pos += off;
3518
3519 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3520 {
3521 char rule_buf_out[BLOCK_SIZE] = { 0 };
3522
3523 int rule_len_out = -1;
3524
3525 if (len < BLOCK_SIZE)
3526 {
3527 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3528 }
3529
3530 if (rule_len_out < 0)
3531 {
3532 continue;
3533 }
3534
3535 if (rule_len_out > PW_MAX)
3536 {
3537 continue;
3538 }
3539 }
3540 else
3541 {
3542 if (len > PW_MAX)
3543 {
3544 continue;
3545 }
3546 }
3547
3548 *out_buf = ptr;
3549 *out_len = len;
3550
3551 return;
3552 }
3553
3554 if (feof (fd))
3555 {
3556 fprintf (stderr, "bug!!\n");
3557
3558 return;
3559 }
3560
3561 load_segment (wl_data, fd);
3562
3563 get_next_word (wl_data, fd, out_buf, out_len);
3564 }
3565
3566 #ifdef _POSIX
3567 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3568 #endif
3569
3570 #ifdef _WIN
3571 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3572 #endif
3573 {
3574 hc_signal (NULL);
3575
3576 dictstat_t d;
3577
3578 d.cnt = 0;
3579
3580 #ifdef _POSIX
3581 fstat (fileno (fd), &d.stat);
3582 #endif
3583
3584 #ifdef _WIN
3585 _fstat64 (fileno (fd), &d.stat);
3586 #endif
3587
3588 d.stat.st_mode = 0;
3589 d.stat.st_nlink = 0;
3590 d.stat.st_uid = 0;
3591 d.stat.st_gid = 0;
3592 d.stat.st_rdev = 0;
3593 d.stat.st_atime = 0;
3594
3595 #ifdef _POSIX
3596 d.stat.st_blksize = 0;
3597 d.stat.st_blocks = 0;
3598 #endif
3599
3600 if (d.stat.st_size == 0) return 0;
3601
3602 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3603
3604 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3605 {
3606 if (d_cache)
3607 {
3608 u64 cnt = d_cache->cnt;
3609
3610 u64 keyspace = cnt;
3611
3612 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3613 {
3614 keyspace *= data.kernel_rules_cnt;
3615 }
3616 else if (data.attack_kern == ATTACK_KERN_COMBI)
3617 {
3618 keyspace *= data.combs_cnt;
3619 }
3620
3621 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);
3622 if (data.quiet == 0) log_info ("");
3623
3624 hc_signal (sigHandler_default);
3625
3626 return (keyspace);
3627 }
3628 }
3629
3630 time_t now = 0;
3631 time_t prev = 0;
3632
3633 u64 comp = 0;
3634 u64 cnt = 0;
3635 u64 cnt2 = 0;
3636
3637 while (!feof (fd))
3638 {
3639 load_segment (wl_data, fd);
3640
3641 comp += wl_data->cnt;
3642
3643 u32 i = 0;
3644
3645 while (i < wl_data->cnt)
3646 {
3647 u32 len;
3648 u32 off;
3649
3650 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3651
3652 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3653 {
3654 char rule_buf_out[BLOCK_SIZE] = { 0 };
3655
3656 int rule_len_out = -1;
3657
3658 if (len < BLOCK_SIZE)
3659 {
3660 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3661 }
3662
3663 if (rule_len_out < 0)
3664 {
3665 len = PW_MAX1;
3666 }
3667 else
3668 {
3669 len = rule_len_out;
3670 }
3671 }
3672
3673 if (len < PW_MAX1)
3674 {
3675 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3676 {
3677 cnt += data.kernel_rules_cnt;
3678 }
3679 else if (data.attack_kern == ATTACK_KERN_COMBI)
3680 {
3681 cnt += data.combs_cnt;
3682 }
3683
3684 d.cnt++;
3685 }
3686
3687 i += off;
3688
3689 cnt2++;
3690 }
3691
3692 time (&now);
3693
3694 if ((now - prev) == 0) continue;
3695
3696 float percent = (float) comp / (float) d.stat.st_size;
3697
3698 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);
3699
3700 time (&prev);
3701 }
3702
3703 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);
3704 if (data.quiet == 0) log_info ("");
3705
3706 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3707
3708 hc_signal (sigHandler_default);
3709
3710 return (cnt);
3711 }
3712
3713 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3714 {
3715 memcpy (p2->h.hi1, p1->h.hi1, 64 * sizeof (uint));
3716 }
3717
3718 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3719 {
3720 if (data.devices_status == STATUS_BYPASS) return 0;
3721
3722 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3723
3724 uint cache_cnt = pw_cache->cnt;
3725
3726 u8 *pw_hc1 = pw_cache->pw_buf.h.hc1[cache_cnt];
3727
3728 memcpy (pw_hc1, pw_buf, pw_len);
3729
3730 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3731
3732 uint pws_cnt = device_param->pws_cnt;
3733
3734 cache_cnt++;
3735
3736 pw_t *pw = device_param->pws_buf + pws_cnt;
3737
3738 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3739
3740 pw->pw_len = pw_len;
3741
3742 pws_cnt++;
3743
3744 device_param->pws_cnt = pws_cnt;
3745 device_param->pw_cnt = pws_cnt * 1;
3746
3747 cache_cnt = 0;
3748
3749 pw_cache->cnt = cache_cnt;
3750
3751 return pws_cnt;
3752 }
3753
3754 static void *thread_monitor (void *p)
3755 {
3756 uint runtime_check = 0;
3757 uint remove_check = 0;
3758 uint status_check = 0;
3759 uint restore_check = 0;
3760
3761 uint restore_left = data.restore_timer;
3762 uint remove_left = data.remove_timer;
3763 uint status_left = data.status_timer;
3764
3765 #ifdef HAVE_HWMON
3766 uint hwmon_check = 0;
3767
3768 // these variables are mainly used for fan control (AMD only)
3769
3770 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3771
3772 // temperature controller "loopback" values
3773
3774 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3775 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3776
3777 #ifdef HAVE_ADL
3778 int temp_threshold = 1; // degrees celcius
3779
3780 int fan_speed_min = 15; // in percentage
3781 int fan_speed_max = 100;
3782 #endif // HAVE_ADL
3783
3784 time_t last_temp_check_time;
3785 #endif // HAVE_HWMON
3786
3787 uint sleep_time = 1;
3788
3789 if (data.runtime)
3790 {
3791 runtime_check = 1;
3792 }
3793
3794 if (data.restore_timer)
3795 {
3796 restore_check = 1;
3797 }
3798
3799 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3800 {
3801 remove_check = 1;
3802 }
3803
3804 if (data.status == 1)
3805 {
3806 status_check = 1;
3807 }
3808
3809 #ifdef HAVE_HWMON
3810 if (data.gpu_temp_disable == 0)
3811 {
3812 time (&last_temp_check_time);
3813
3814 hwmon_check = 1;
3815 }
3816 #endif
3817
3818 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3819 {
3820 #ifdef HAVE_HWMON
3821 if (hwmon_check == 0)
3822 #endif
3823 return (p);
3824 }
3825
3826 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3827 {
3828 hc_sleep (sleep_time);
3829
3830 if (data.devices_status != STATUS_RUNNING) continue;
3831
3832 #ifdef HAVE_HWMON
3833 if (hwmon_check == 1)
3834 {
3835 hc_thread_mutex_lock (mux_adl);
3836
3837 time_t temp_check_time;
3838
3839 time (&temp_check_time);
3840
3841 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3842
3843 if (Ta == 0) Ta = 1;
3844
3845 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3846 {
3847 hc_device_param_t *device_param = &data.devices_param[device_id];
3848
3849 if (device_param->skipped) continue;
3850
3851 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3852
3853 const int temperature = hm_get_temperature_with_device_id (device_id);
3854
3855 if (temperature > (int) data.gpu_temp_abort)
3856 {
3857 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3858
3859 if (data.devices_status != STATUS_QUIT) myabort ();
3860
3861 break;
3862 }
3863
3864 #ifdef HAVE_ADL
3865 const int gpu_temp_retain = data.gpu_temp_retain;
3866
3867 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3868 {
3869 if (data.hm_device[device_id].fan_supported == 1)
3870 {
3871 int temp_cur = temperature;
3872
3873 int temp_diff_new = gpu_temp_retain - temp_cur;
3874
3875 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3876
3877 // calculate Ta value (time difference in seconds between the last check and this check)
3878
3879 last_temp_check_time = temp_check_time;
3880
3881 float Kp = 1.8;
3882 float Ki = 0.005;
3883 float Kd = 6;
3884
3885 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3886
3887 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[device_id] + Kd * ((float)(temp_diff_new - temp_diff_old[device_id])) / Ta);
3888
3889 if (abs (fan_diff_required) >= temp_threshold)
3890 {
3891 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3892
3893 int fan_speed_level = fan_speed_cur;
3894
3895 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3896
3897 int fan_speed_new = fan_speed_level - fan_diff_required;
3898
3899 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3900 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3901
3902 if (fan_speed_new != fan_speed_cur)
3903 {
3904 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3905 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3906
3907 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3908 {
3909 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3910
3911 fan_speed_chgd[device_id] = 1;
3912 }
3913
3914 temp_diff_old[device_id] = temp_diff_new;
3915 }
3916 }
3917 }
3918 }
3919 #endif // HAVE_ADL
3920 }
3921
3922 hc_thread_mutex_unlock (mux_adl);
3923 }
3924 #endif // HAVE_HWMON
3925
3926 if (restore_check == 1)
3927 {
3928 restore_left--;
3929
3930 if (restore_left == 0)
3931 {
3932 if (data.restore_disable == 0) cycle_restore ();
3933
3934 restore_left = data.restore_timer;
3935 }
3936 }
3937
3938 if ((runtime_check == 1) && (data.runtime_start > 0))
3939 {
3940 time_t runtime_cur;
3941
3942 time (&runtime_cur);
3943
3944 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3945
3946 if (runtime_left <= 0)
3947 {
3948 if (data.benchmark == 0)
3949 {
3950 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3951 }
3952
3953 if (data.devices_status != STATUS_QUIT) myabort ();
3954 }
3955 }
3956
3957 if (remove_check == 1)
3958 {
3959 remove_left--;
3960
3961 if (remove_left == 0)
3962 {
3963 if (data.digests_saved != data.digests_done)
3964 {
3965 data.digests_saved = data.digests_done;
3966
3967 save_hash ();
3968 }
3969
3970 remove_left = data.remove_timer;
3971 }
3972 }
3973
3974 if (status_check == 1)
3975 {
3976 status_left--;
3977
3978 if (status_left == 0)
3979 {
3980 hc_thread_mutex_lock (mux_display);
3981
3982 if (data.quiet == 0) clear_prompt ();
3983
3984 if (data.quiet == 0) log_info ("");
3985
3986 status_display ();
3987
3988 if (data.quiet == 0) log_info ("");
3989
3990 hc_thread_mutex_unlock (mux_display);
3991
3992 status_left = data.status_timer;
3993 }
3994 }
3995 }
3996
3997 #ifdef HAVE_HWMON
3998 myfree (fan_speed_chgd);
3999
4000 myfree (temp_diff_old);
4001 myfree (temp_diff_sum);
4002 #endif
4003
4004 p = NULL;
4005
4006 return (p);
4007 }
4008
4009 static void *thread_outfile_remove (void *p)
4010 {
4011 // some hash-dependent constants
4012 char *outfile_dir = data.outfile_check_directory;
4013 uint dgst_size = data.dgst_size;
4014 uint isSalted = data.isSalted;
4015 uint esalt_size = data.esalt_size;
4016 uint hash_mode = data.hash_mode;
4017
4018 uint outfile_check_timer = data.outfile_check_timer;
4019
4020 char separator = data.separator;
4021
4022 // some hash-dependent functions
4023 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4024 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4025
4026 // buffers
4027 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4028
4029 hash_buf.digest = mymalloc (dgst_size);
4030
4031 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4032
4033 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4034
4035 uint digest_buf[64] = { 0 };
4036
4037 outfile_data_t *out_info = NULL;
4038
4039 char **out_files = NULL;
4040
4041 time_t folder_mtime = 0;
4042
4043 int out_cnt = 0;
4044
4045 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4046
4047 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4048 {
4049 hc_sleep (1);
4050
4051 if (data.devices_status != STATUS_RUNNING) continue;
4052
4053 check_left--;
4054
4055 if (check_left == 0)
4056 {
4057 struct stat outfile_check_stat;
4058
4059 if (stat (outfile_dir, &outfile_check_stat) == 0)
4060 {
4061 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4062
4063 if (is_dir == 1)
4064 {
4065 if (outfile_check_stat.st_mtime > folder_mtime)
4066 {
4067 char **out_files_new = scan_directory (outfile_dir);
4068
4069 int out_cnt_new = count_dictionaries (out_files_new);
4070
4071 outfile_data_t *out_info_new = NULL;
4072
4073 if (out_cnt_new > 0)
4074 {
4075 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4076
4077 for (int i = 0; i < out_cnt_new; i++)
4078 {
4079 out_info_new[i].file_name = out_files_new[i];
4080
4081 // check if there are files that we have seen/checked before (and not changed)
4082
4083 for (int j = 0; j < out_cnt; j++)
4084 {
4085 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4086 {
4087 struct stat outfile_stat;
4088
4089 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4090 {
4091 if (outfile_stat.st_ctime == out_info[j].ctime)
4092 {
4093 out_info_new[i].ctime = out_info[j].ctime;
4094 out_info_new[i].seek = out_info[j].seek;
4095 }
4096 }
4097 }
4098 }
4099 }
4100 }
4101
4102 local_free (out_info);
4103 local_free (out_files);
4104
4105 out_files = out_files_new;
4106 out_cnt = out_cnt_new;
4107 out_info = out_info_new;
4108
4109 folder_mtime = outfile_check_stat.st_mtime;
4110 }
4111
4112 for (int j = 0; j < out_cnt; j++)
4113 {
4114 FILE *fp = fopen (out_info[j].file_name, "rb");
4115
4116 if (fp != NULL)
4117 {
4118 //hc_thread_mutex_lock (mux_display);
4119
4120 #ifdef _POSIX
4121 struct stat outfile_stat;
4122
4123 fstat (fileno (fp), &outfile_stat);
4124 #endif
4125
4126 #ifdef _WIN
4127 struct stat64 outfile_stat;
4128
4129 _fstat64 (fileno (fp), &outfile_stat);
4130 #endif
4131
4132 if (outfile_stat.st_ctime > out_info[j].ctime)
4133 {
4134 out_info[j].ctime = outfile_stat.st_ctime;
4135 out_info[j].seek = 0;
4136 }
4137
4138 fseek (fp, out_info[j].seek, SEEK_SET);
4139
4140 while (!feof (fp))
4141 {
4142 char line_buf[BUFSIZ] = { 0 };
4143
4144 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
4145
4146 if (ptr == NULL) break;
4147
4148 int line_len = strlen (line_buf);
4149
4150 if (line_len <= 0) continue;
4151
4152 int iter = MAX_CUT_TRIES;
4153
4154 for (uint i = line_len - 1; i && iter; i--, line_len--)
4155 {
4156 if (line_buf[i] != separator) continue;
4157
4158 int parser_status = PARSER_OK;
4159
4160 if ((hash_mode != 2500) && (hash_mode != 6800))
4161 {
4162 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4163 }
4164
4165 uint found = 0;
4166
4167 if (parser_status == PARSER_OK)
4168 {
4169 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4170 {
4171 if (data.salts_shown[salt_pos] == 1) continue;
4172
4173 salt_t *salt_buf = &data.salts_buf[salt_pos];
4174
4175 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4176 {
4177 uint idx = salt_buf->digests_offset + digest_pos;
4178
4179 if (data.digests_shown[idx] == 1) continue;
4180
4181 uint cracked = 0;
4182
4183 if (hash_mode == 6800)
4184 {
4185 if (i == salt_buf->salt_len)
4186 {
4187 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4188 }
4189 }
4190 else if (hash_mode == 2500)
4191 {
4192 // BSSID : MAC1 : MAC2 (:plain)
4193 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4194 {
4195 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4196
4197 if (!cracked) continue;
4198
4199 // now compare MAC1 and MAC2 too, since we have this additional info
4200 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4201 char *mac2_pos = mac1_pos + 12 + 1;
4202
4203 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4204 wpa_t *wpa = &wpas[salt_pos];
4205
4206 uint pke[25] = { 0 };
4207
4208 char *pke_ptr = (char *) pke;
4209
4210 for (uint i = 0; i < 25; i++)
4211 {
4212 pke[i] = byte_swap_32 (wpa->pke[i]);
4213 }
4214
4215 u8 mac1[6] = { 0 };
4216 u8 mac2[6] = { 0 };
4217
4218 memcpy (mac1, pke_ptr + 23, 6);
4219 memcpy (mac2, pke_ptr + 29, 6);
4220
4221 // compare hex string(s) vs binary MAC address(es)
4222
4223 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4224 {
4225 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4226 {
4227 cracked = 0;
4228 break;
4229 }
4230 }
4231
4232 // early skip ;)
4233 if (!cracked) continue;
4234
4235 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4236 {
4237 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4238 {
4239 cracked = 0;
4240 break;
4241 }
4242 }
4243 }
4244 }
4245 else
4246 {
4247 char *digests_buf_ptr = (char *) data.digests_buf;
4248
4249 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4250
4251 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4252 }
4253
4254 if (cracked == 1)
4255 {
4256 found = 1;
4257
4258 data.digests_shown[idx] = 1;
4259
4260 data.digests_done++;
4261
4262 salt_buf->digests_done++;
4263
4264 if (salt_buf->digests_done == salt_buf->digests_cnt)
4265 {
4266 data.salts_shown[salt_pos] = 1;
4267
4268 data.salts_done++;
4269
4270 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4271 }
4272 }
4273 }
4274
4275 if (data.devices_status == STATUS_CRACKED) break;
4276 }
4277 }
4278
4279 if (found) break;
4280
4281 if (data.devices_status == STATUS_CRACKED) break;
4282
4283 iter--;
4284 }
4285
4286 if (data.devices_status == STATUS_CRACKED) break;
4287 }
4288
4289 out_info[j].seek = ftell (fp);
4290
4291 //hc_thread_mutex_unlock (mux_display);
4292
4293 fclose (fp);
4294 }
4295 }
4296 }
4297 }
4298
4299 check_left = outfile_check_timer;
4300 }
4301 }
4302
4303 if (esalt_size) local_free (hash_buf.esalt);
4304
4305 if (isSalted) local_free (hash_buf.salt);
4306
4307 local_free (hash_buf.digest);
4308
4309 local_free (out_info);
4310
4311 local_free (out_files);
4312
4313 p = NULL;
4314
4315 return (p);
4316 }
4317
4318 static uint get_work (hc_device_param_t *device_param, const u64 max)
4319 {
4320 hc_thread_mutex_lock (mux_dispatcher);
4321
4322 const u64 words_cur = data.words_cur;
4323 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4324
4325 device_param->words_off = words_cur;
4326
4327 const u64 words_left = words_base - words_cur;
4328
4329 if (data.kernel_power_all > words_left)
4330 {
4331 if (data.kernel_power_div == 0)
4332 {
4333 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4334 }
4335 }
4336
4337 if (data.kernel_power_div)
4338 {
4339 if (device_param->kernel_power == device_param->kernel_power_user)
4340 {
4341 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4342
4343 if (kernel_power_new < device_param->kernel_power)
4344 {
4345 device_param->kernel_power = kernel_power_new;
4346 }
4347 }
4348 }
4349
4350 const uint kernel_power = device_param->kernel_power;
4351
4352 uint work = MIN (words_left, kernel_power);
4353
4354 work = MIN (work, max);
4355
4356 data.words_cur += work;
4357
4358 hc_thread_mutex_unlock (mux_dispatcher);
4359
4360 return work;
4361 }
4362
4363 static void *thread_calc_stdin (void *p)
4364 {
4365 hc_device_param_t *device_param = (hc_device_param_t *) p;
4366
4367 if (device_param->skipped) return NULL;
4368
4369 if ((device_param->kernel_accel == 0) && (device_param->kernel_loops == 0))
4370 {
4371 autotune (device_param);
4372 }
4373
4374 const uint attack_kern = data.attack_kern;
4375
4376 const uint kernel_power = device_param->kernel_power;
4377
4378 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4379 {
4380 hc_thread_mutex_lock (mux_dispatcher);
4381
4382 if (feof (stdin) != 0)
4383 {
4384 hc_thread_mutex_unlock (mux_dispatcher);
4385
4386 break;
4387 }
4388
4389 uint words_cur = 0;
4390
4391 while (words_cur < kernel_power)
4392 {
4393 char buf[BUFSIZ] = { 0 };
4394
4395 char *line_buf = fgets (buf, sizeof (buf), stdin);
4396
4397 if (line_buf == NULL) break;
4398
4399 uint line_len = in_superchop (line_buf);
4400
4401 line_len = convert_from_hex (line_buf, line_len);
4402
4403 // post-process rule engine
4404
4405 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4406 {
4407 char rule_buf_out[BLOCK_SIZE] = { 0 };
4408
4409 int rule_len_out = -1;
4410
4411 if (line_len < BLOCK_SIZE)
4412 {
4413 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4414 }
4415
4416 if (rule_len_out < 0) continue;
4417
4418 line_buf = rule_buf_out;
4419 line_len = rule_len_out;
4420 }
4421
4422 if (line_len > PW_MAX)
4423 {
4424 continue;
4425 }
4426
4427 if (attack_kern == ATTACK_KERN_STRAIGHT)
4428 {
4429 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4430 {
4431 hc_thread_mutex_lock (mux_counter);
4432
4433 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4434 {
4435 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4436 }
4437
4438 hc_thread_mutex_unlock (mux_counter);
4439
4440 continue;
4441 }
4442 }
4443 else if (attack_kern == ATTACK_KERN_COMBI)
4444 {
4445 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4446 // since we still need to combine the plains
4447
4448 if (line_len > data.pw_max)
4449 {
4450 hc_thread_mutex_lock (mux_counter);
4451
4452 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4453 {
4454 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4455 }
4456
4457 hc_thread_mutex_unlock (mux_counter);
4458
4459 continue;
4460 }
4461 }
4462
4463 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4464
4465 words_cur++;
4466
4467 if (data.devices_status == STATUS_CRACKED) break;
4468 if (data.devices_status == STATUS_ABORTED) break;
4469 if (data.devices_status == STATUS_QUIT) break;
4470 if (data.devices_status == STATUS_BYPASS) break;
4471 }
4472
4473 hc_thread_mutex_unlock (mux_dispatcher);
4474
4475 if (data.devices_status == STATUS_CRACKED) break;
4476 if (data.devices_status == STATUS_ABORTED) break;
4477 if (data.devices_status == STATUS_QUIT) break;
4478 if (data.devices_status == STATUS_BYPASS) break;
4479
4480 // we need 2 flushing because we have two independant caches and it can occur
4481 // that one buffer is already at threshold plus for that length also exists
4482 // more data in the 2nd buffer so it would overflow
4483
4484 // flush session 1
4485
4486 {
4487 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4488 {
4489 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4490
4491 const uint pw_cache_cnt = pw_cache->cnt;
4492
4493 if (pw_cache_cnt == 0) continue;
4494
4495 pw_cache->cnt = 0;
4496
4497 uint pws_cnt = device_param->pws_cnt;
4498
4499 pw_t *pw = device_param->pws_buf + pws_cnt;
4500
4501 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4502
4503 pw->pw_len = pw_len;
4504
4505 uint pw_cnt = device_param->pw_cnt;
4506
4507 pw_cnt += pw_cache_cnt;
4508
4509 device_param->pw_cnt = pw_cnt;
4510
4511 pws_cnt++;
4512
4513 device_param->pws_cnt = pws_cnt;
4514
4515 if (pws_cnt == device_param->kernel_power_user) break;
4516 }
4517
4518 const uint pw_cnt = device_param->pw_cnt;
4519 const uint pws_cnt = device_param->pws_cnt;
4520
4521 if (pws_cnt)
4522 {
4523 run_copy (device_param, pws_cnt);
4524
4525 run_cracker (device_param, pw_cnt, pws_cnt);
4526
4527 device_param->pw_cnt = 0;
4528 device_param->pws_cnt = 0;
4529 }
4530 }
4531
4532 // flush session 2
4533
4534 {
4535 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4536 {
4537 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4538
4539 const uint pw_cache_cnt = pw_cache->cnt;
4540
4541 if (pw_cache_cnt == 0) continue;
4542
4543 pw_cache->cnt = 0;
4544
4545 uint pws_cnt = device_param->pws_cnt;
4546
4547 pw_t *pw = device_param->pws_buf + pws_cnt;
4548
4549 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4550
4551 pw->pw_len = pw_len;
4552
4553 uint pw_cnt = device_param->pw_cnt;
4554
4555 pw_cnt += pw_cache_cnt;
4556
4557 device_param->pw_cnt = pw_cnt;
4558
4559 pws_cnt++;
4560
4561 device_param->pws_cnt = pws_cnt;
4562 }
4563
4564 const uint pw_cnt = device_param->pw_cnt;
4565 const uint pws_cnt = device_param->pws_cnt;
4566
4567 if (pws_cnt)
4568 {
4569 run_copy (device_param, pws_cnt);
4570
4571 run_cracker (device_param, pw_cnt, pws_cnt);
4572
4573 device_param->pw_cnt = 0;
4574 device_param->pws_cnt = 0;
4575 }
4576 }
4577 }
4578
4579 return NULL;
4580 }
4581
4582 static void *thread_calc (void *p)
4583 {
4584 hc_device_param_t *device_param = (hc_device_param_t *) p;
4585
4586 if (device_param->skipped) return NULL;
4587
4588 if ((device_param->kernel_accel == 0) && (device_param->kernel_loops == 0))
4589 {
4590 autotune (device_param);
4591 }
4592
4593 const uint attack_mode = data.attack_mode;
4594 const uint attack_kern = data.attack_kern;
4595
4596 if (attack_mode == ATTACK_MODE_BF)
4597 {
4598 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4599 {
4600 const uint work = get_work (device_param, -1);
4601
4602 if (work == 0) break;
4603
4604 const u64 words_off = device_param->words_off;
4605 const u64 words_fin = words_off + work;
4606
4607 const uint pw_cnt = work;
4608 const uint pws_cnt = work;
4609
4610 device_param->pw_cnt = pw_cnt;
4611 device_param->pws_cnt = pws_cnt;
4612
4613 if (pws_cnt)
4614 {
4615 run_copy (device_param, pws_cnt);
4616
4617 run_cracker (device_param, pw_cnt, pws_cnt);
4618
4619 device_param->pw_cnt = 0;
4620 device_param->pws_cnt = 0;
4621 }
4622
4623 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4624
4625 if (data.devices_status == STATUS_CRACKED) break;
4626 if (data.devices_status == STATUS_ABORTED) break;
4627 if (data.devices_status == STATUS_QUIT) break;
4628 if (data.devices_status == STATUS_BYPASS) break;
4629
4630 device_param->words_done = words_fin;
4631 }
4632 }
4633 else
4634 {
4635 const uint segment_size = data.segment_size;
4636
4637 char *dictfile = data.dictfile;
4638
4639 if (attack_mode == ATTACK_MODE_COMBI)
4640 {
4641 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4642 {
4643 dictfile = data.dictfile2;
4644 }
4645 }
4646
4647 FILE *fd = fopen (dictfile, "rb");
4648
4649 if (fd == NULL)
4650 {
4651 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4652
4653 return NULL;
4654 }
4655
4656 if (attack_mode == ATTACK_MODE_COMBI)
4657 {
4658 const uint combs_mode = data.combs_mode;
4659
4660 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4661 {
4662 const char *dictfilec = data.dictfile2;
4663
4664 FILE *combs_fp = fopen (dictfilec, "rb");
4665
4666 if (combs_fp == NULL)
4667 {
4668 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4669
4670 fclose (fd);
4671
4672 return NULL;
4673 }
4674
4675 device_param->combs_fp = combs_fp;
4676 }
4677 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4678 {
4679 const char *dictfilec = data.dictfile;
4680
4681 FILE *combs_fp = fopen (dictfilec, "rb");
4682
4683 if (combs_fp == NULL)
4684 {
4685 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4686
4687 fclose (fd);
4688
4689 return NULL;
4690 }
4691
4692 device_param->combs_fp = combs_fp;
4693 }
4694 }
4695
4696 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4697
4698 wl_data->buf = (char *) mymalloc (segment_size);
4699 wl_data->avail = segment_size;
4700 wl_data->incr = segment_size;
4701 wl_data->cnt = 0;
4702 wl_data->pos = 0;
4703
4704 u64 words_cur = 0;
4705
4706 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4707 {
4708 u64 words_off = 0;
4709 u64 words_fin = 0;
4710
4711 u64 max = -1;
4712
4713 while (max)
4714 {
4715 const uint work = get_work (device_param, max);
4716
4717 if (work == 0) break;
4718
4719 words_off = device_param->words_off;
4720 words_fin = words_off + work;
4721
4722 char *line_buf;
4723 uint line_len;
4724
4725 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4726
4727 max = 0;
4728
4729 for ( ; words_cur < words_fin; words_cur++)
4730 {
4731 get_next_word (wl_data, fd, &line_buf, &line_len);
4732
4733 line_len = convert_from_hex (line_buf, line_len);
4734
4735 // post-process rule engine
4736
4737 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4738 {
4739 char rule_buf_out[BLOCK_SIZE] = { 0 };
4740
4741 int rule_len_out = -1;
4742
4743 if (line_len < BLOCK_SIZE)
4744 {
4745 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4746 }
4747
4748 if (rule_len_out < 0) continue;
4749
4750 line_buf = rule_buf_out;
4751 line_len = rule_len_out;
4752 }
4753
4754 if (attack_kern == ATTACK_KERN_STRAIGHT)
4755 {
4756 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4757 {
4758 max++;
4759
4760 hc_thread_mutex_lock (mux_counter);
4761
4762 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4763 {
4764 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4765 }
4766
4767 hc_thread_mutex_unlock (mux_counter);
4768
4769 continue;
4770 }
4771 }
4772 else if (attack_kern == ATTACK_KERN_COMBI)
4773 {
4774 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4775 // since we still need to combine the plains
4776
4777 if (line_len > data.pw_max)
4778 {
4779 max++;
4780
4781 hc_thread_mutex_lock (mux_counter);
4782
4783 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4784 {
4785 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4786 }
4787
4788 hc_thread_mutex_unlock (mux_counter);
4789
4790 continue;
4791 }
4792 }
4793
4794 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4795
4796 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4797
4798 if (data.devices_status == STATUS_CRACKED) break;
4799 if (data.devices_status == STATUS_ABORTED) break;
4800 if (data.devices_status == STATUS_QUIT) break;
4801 if (data.devices_status == STATUS_BYPASS) break;
4802 }
4803
4804 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4805
4806 if (data.devices_status == STATUS_CRACKED) break;
4807 if (data.devices_status == STATUS_ABORTED) break;
4808 if (data.devices_status == STATUS_QUIT) break;
4809 if (data.devices_status == STATUS_BYPASS) break;
4810 }
4811
4812 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4813
4814 if (data.devices_status == STATUS_CRACKED) break;
4815 if (data.devices_status == STATUS_ABORTED) break;
4816 if (data.devices_status == STATUS_QUIT) break;
4817 if (data.devices_status == STATUS_BYPASS) break;
4818
4819 // we need 2 flushing because we have two independant caches and it can occur
4820 // that one buffer is already at threshold plus for that length also exists
4821 // more data in the 2nd buffer so it would overflow
4822
4823 //
4824 // flush session 1
4825 //
4826
4827 {
4828 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4829 {
4830 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4831
4832 const uint pw_cache_cnt = pw_cache->cnt;
4833
4834 if (pw_cache_cnt == 0) continue;
4835
4836 pw_cache->cnt = 0;
4837
4838 uint pws_cnt = device_param->pws_cnt;
4839
4840 pw_t *pw = device_param->pws_buf + pws_cnt;
4841
4842 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4843
4844 pw->pw_len = pw_len;
4845
4846 uint pw_cnt = device_param->pw_cnt;
4847
4848 pw_cnt += pw_cache_cnt;
4849
4850 device_param->pw_cnt = pw_cnt;
4851
4852 pws_cnt++;
4853
4854 device_param->pws_cnt = pws_cnt;
4855
4856 if (pws_cnt == device_param->kernel_power_user) break;
4857 }
4858
4859 const uint pw_cnt = device_param->pw_cnt;
4860 const uint pws_cnt = device_param->pws_cnt;
4861
4862 if (pws_cnt)
4863 {
4864 run_copy (device_param, pws_cnt);
4865
4866 run_cracker (device_param, pw_cnt, pws_cnt);
4867
4868 device_param->pw_cnt = 0;
4869 device_param->pws_cnt = 0;
4870 }
4871
4872 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4873
4874 if (data.devices_status == STATUS_CRACKED) break;
4875 if (data.devices_status == STATUS_ABORTED) break;
4876 if (data.devices_status == STATUS_QUIT) break;
4877 if (data.devices_status == STATUS_BYPASS) break;
4878 }
4879
4880 //
4881 // flush session 2
4882 //
4883
4884 {
4885 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4886 {
4887 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4888
4889 const uint pw_cache_cnt = pw_cache->cnt;
4890
4891 if (pw_cache_cnt == 0) continue;
4892
4893 pw_cache->cnt = 0;
4894
4895 uint pws_cnt = device_param->pws_cnt;
4896
4897 pw_t *pw = device_param->pws_buf + pws_cnt;
4898
4899 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4900
4901 pw->pw_len = pw_len;
4902
4903 uint pw_cnt = device_param->pw_cnt;
4904
4905 pw_cnt += pw_cache_cnt;
4906
4907 device_param->pw_cnt = pw_cnt;
4908
4909 pws_cnt++;
4910
4911 device_param->pws_cnt = pws_cnt;
4912 }
4913
4914 const uint pw_cnt = device_param->pw_cnt;
4915 const uint pws_cnt = device_param->pws_cnt;
4916
4917 if (pws_cnt)
4918 {
4919 run_copy (device_param, pws_cnt);
4920
4921 run_cracker (device_param, pw_cnt, pws_cnt);
4922
4923 device_param->pw_cnt = 0;
4924 device_param->pws_cnt = 0;
4925 }
4926
4927 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4928
4929 if (data.devices_status == STATUS_CRACKED) break;
4930 if (data.devices_status == STATUS_ABORTED) break;
4931 if (data.devices_status == STATUS_QUIT) break;
4932 if (data.devices_status == STATUS_BYPASS) break;
4933 }
4934
4935 if (words_fin == 0) break;
4936
4937 device_param->words_done = words_fin;
4938 }
4939
4940 if (attack_mode == ATTACK_MODE_COMBI)
4941 {
4942 fclose (device_param->combs_fp);
4943 }
4944
4945 free (wl_data->buf);
4946 free (wl_data);
4947
4948 fclose (fd);
4949 }
4950
4951 return NULL;
4952 }
4953
4954 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4955 {
4956 if (!device_param)
4957 {
4958 log_error ("ERROR: %s : Invalid argument", __func__);
4959
4960 exit (-1);
4961 }
4962
4963 salt_t *salt_buf = &data.salts_buf[salt_pos];
4964
4965 device_param->kernel_params_buf32[24] = salt_pos;
4966 device_param->kernel_params_buf32[27] = 1;
4967 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4968 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4969 device_param->kernel_params_buf32[30] = 0;
4970 device_param->kernel_params_buf32[31] = 1;
4971
4972 char *dictfile_old = data.dictfile;
4973
4974 const char *weak_hash_check = "weak-hash-check";
4975
4976 data.dictfile = (char *) weak_hash_check;
4977
4978 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4979
4980 data.kernel_rules_buf[0].cmds[0] = 0;
4981
4982 /**
4983 * run the kernel
4984 */
4985
4986 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4987 {
4988 run_kernel (KERN_RUN_1, device_param, 1, false);
4989 }
4990 else
4991 {
4992 run_kernel (KERN_RUN_1, device_param, 1, false);
4993
4994 uint loop_step = 16;
4995
4996 const uint iter = salt_buf->salt_iter;
4997
4998 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4999 {
5000 uint loop_left = iter - loop_pos;
5001
5002 loop_left = MIN (loop_left, loop_step);
5003
5004 device_param->kernel_params_buf32[25] = loop_pos;
5005 device_param->kernel_params_buf32[26] = loop_left;
5006
5007 run_kernel (KERN_RUN_2, device_param, 1, false);
5008 }
5009
5010 run_kernel (KERN_RUN_3, device_param, 1, false);
5011 }
5012
5013 /**
5014 * result
5015 */
5016
5017 check_cracked (device_param, salt_pos);
5018
5019 /**
5020 * cleanup
5021 */
5022
5023 device_param->kernel_params_buf32[24] = 0;
5024 device_param->kernel_params_buf32[25] = 0;
5025 device_param->kernel_params_buf32[26] = 0;
5026 device_param->kernel_params_buf32[27] = 0;
5027 device_param->kernel_params_buf32[28] = 0;
5028 device_param->kernel_params_buf32[29] = 0;
5029 device_param->kernel_params_buf32[30] = 0;
5030 device_param->kernel_params_buf32[31] = 0;
5031
5032 data.dictfile = dictfile_old;
5033
5034 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5035 }
5036
5037 // hlfmt hashcat
5038
5039 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5040 {
5041 if (data.username == 0)
5042 {
5043 *hashbuf_pos = line_buf;
5044 *hashbuf_len = line_len;
5045 }
5046 else
5047 {
5048 char *pos = line_buf;
5049 int len = line_len;
5050
5051 for (int i = 0; i < line_len; i++, pos++, len--)
5052 {
5053 if (line_buf[i] == data.separator)
5054 {
5055 pos++;
5056
5057 len--;
5058
5059 break;
5060 }
5061 }
5062
5063 *hashbuf_pos = pos;
5064 *hashbuf_len = len;
5065 }
5066 }
5067
5068 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5069 {
5070 char *pos = NULL;
5071 int len = 0;
5072
5073 int sep_cnt = 0;
5074
5075 for (int i = 0; i < line_len; i++)
5076 {
5077 if (line_buf[i] == data.separator)
5078 {
5079 sep_cnt++;
5080
5081 continue;
5082 }
5083
5084 if (sep_cnt == 0)
5085 {
5086 if (pos == NULL) pos = line_buf + i;
5087
5088 len++;
5089 }
5090 }
5091
5092 *userbuf_pos = pos;
5093 *userbuf_len = len;
5094 }
5095
5096 // hlfmt pwdump
5097
5098 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
5099 {
5100 int sep_cnt = 0;
5101
5102 int sep2_len = 0;
5103 int sep3_len = 0;
5104
5105 for (int i = 0; i < line_len; i++)
5106 {
5107 if (line_buf[i] == ':')
5108 {
5109 sep_cnt++;
5110
5111 continue;
5112 }
5113
5114 if (sep_cnt == 2) sep2_len++;
5115 if (sep_cnt == 3) sep3_len++;
5116 }
5117
5118 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5119
5120 return 0;
5121 }
5122
5123 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5124 {
5125 char *pos = NULL;
5126 int len = 0;
5127
5128 int sep_cnt = 0;
5129
5130 for (int i = 0; i < line_len; i++)
5131 {
5132 if (line_buf[i] == ':')
5133 {
5134 sep_cnt++;
5135
5136 continue;
5137 }
5138
5139 if (data.hash_mode == 1000)
5140 {
5141 if (sep_cnt == 3)
5142 {
5143 if (pos == NULL) pos = line_buf + i;
5144
5145 len++;
5146 }
5147 }
5148 else if (data.hash_mode == 3000)
5149 {
5150 if (sep_cnt == 2)
5151 {
5152 if (pos == NULL) pos = line_buf + i;
5153
5154 len++;
5155 }
5156 }
5157 }
5158
5159 *hashbuf_pos = pos;
5160 *hashbuf_len = len;
5161 }
5162
5163 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5164 {
5165 char *pos = NULL;
5166 int len = 0;
5167
5168 int sep_cnt = 0;
5169
5170 for (int i = 0; i < line_len; i++)
5171 {
5172 if (line_buf[i] == ':')
5173 {
5174 sep_cnt++;
5175
5176 continue;
5177 }
5178
5179 if (sep_cnt == 0)
5180 {
5181 if (pos == NULL) pos = line_buf + i;
5182
5183 len++;
5184 }
5185 }
5186
5187 *userbuf_pos = pos;
5188 *userbuf_len = len;
5189 }
5190
5191 // hlfmt passwd
5192
5193 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
5194 {
5195 int sep_cnt = 0;
5196
5197 char sep5_first = 0;
5198 char sep6_first = 0;
5199
5200 for (int i = 0; i < line_len; i++)
5201 {
5202 if (line_buf[i] == ':')
5203 {
5204 sep_cnt++;
5205
5206 continue;
5207 }
5208
5209 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5210 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5211 }
5212
5213 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5214
5215 return 0;
5216 }
5217
5218 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5219 {
5220 char *pos = NULL;
5221 int len = 0;
5222
5223 int sep_cnt = 0;
5224
5225 for (int i = 0; i < line_len; i++)
5226 {
5227 if (line_buf[i] == ':')
5228 {
5229 sep_cnt++;
5230
5231 continue;
5232 }
5233
5234 if (sep_cnt == 1)
5235 {
5236 if (pos == NULL) pos = line_buf + i;
5237
5238 len++;
5239 }
5240 }
5241
5242 *hashbuf_pos = pos;
5243 *hashbuf_len = len;
5244 }
5245
5246 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5247 {
5248 char *pos = NULL;
5249 int len = 0;
5250
5251 int sep_cnt = 0;
5252
5253 for (int i = 0; i < line_len; i++)
5254 {
5255 if (line_buf[i] == ':')
5256 {
5257 sep_cnt++;
5258
5259 continue;
5260 }
5261
5262 if (sep_cnt == 0)
5263 {
5264 if (pos == NULL) pos = line_buf + i;
5265
5266 len++;
5267 }
5268 }
5269
5270 *userbuf_pos = pos;
5271 *userbuf_len = len;
5272 }
5273
5274 // hlfmt shadow
5275
5276 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
5277 {
5278 int sep_cnt = 0;
5279
5280 for (int i = 0; i < line_len; i++)
5281 {
5282 if (line_buf[i] == ':') sep_cnt++;
5283 }
5284
5285 if (sep_cnt == 8) return 1;
5286
5287 return 0;
5288 }
5289
5290 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5291 {
5292 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5293 }
5294
5295 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5296 {
5297 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5298 }
5299
5300 // hlfmt main
5301
5302 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5303 {
5304 switch (hashfile_format)
5305 {
5306 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5307 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5308 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5309 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5310 }
5311 }
5312
5313 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5314 {
5315 switch (hashfile_format)
5316 {
5317 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5318 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5319 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5320 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5321 }
5322 }
5323
5324 static uint hlfmt_detect (FILE *fp, uint max_check)
5325 {
5326 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5327
5328 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5329 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5330
5331 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5332
5333 uint num_check = 0;
5334
5335 while (!feof (fp))
5336 {
5337 char line_buf[BUFSIZ] = { 0 };
5338
5339 int line_len = fgetl (fp, line_buf);
5340
5341 if (line_len == 0) continue;
5342
5343 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5344 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5345 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5346
5347 if (num_check == max_check) break;
5348
5349 num_check++;
5350 }
5351
5352 uint hashlist_format = HLFMT_HASHCAT;
5353
5354 for (int i = 1; i < HLFMTS_CNT; i++)
5355 {
5356 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5357
5358 hashlist_format = i;
5359 }
5360
5361 free (formats_cnt);
5362
5363 return hashlist_format;
5364 }
5365
5366 /**
5367 * some further helper function
5368 */
5369
5370 // wrapper around mymalloc for ADL
5371
5372 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5373 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5374 {
5375 return mymalloc (iSize);
5376 }
5377 #endif
5378
5379 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 u64 collisions_max)
5380 {
5381 u64 collisions = 0;
5382
5383 const uint dgst_pos0 = data.dgst_pos0;
5384 const uint dgst_pos1 = data.dgst_pos1;
5385 const uint dgst_pos2 = data.dgst_pos2;
5386 const uint dgst_pos3 = data.dgst_pos3;
5387
5388 memset (bitmap_a, 0, bitmap_size);
5389 memset (bitmap_b, 0, bitmap_size);
5390 memset (bitmap_c, 0, bitmap_size);
5391 memset (bitmap_d, 0, bitmap_size);
5392
5393 for (uint i = 0; i < digests_cnt; i++)
5394 {
5395 uint *digest_ptr = (uint *) digests_buf_ptr;
5396
5397 digests_buf_ptr += dgst_size;
5398
5399 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5400 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5401 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5402 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5403
5404 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5405 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5406 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5407 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5408
5409 if (bitmap_a[idx0] & val0) collisions++;
5410 if (bitmap_b[idx1] & val1) collisions++;
5411 if (bitmap_c[idx2] & val2) collisions++;
5412 if (bitmap_d[idx3] & val3) collisions++;
5413
5414 bitmap_a[idx0] |= val0;
5415 bitmap_b[idx1] |= val1;
5416 bitmap_c[idx2] |= val2;
5417 bitmap_d[idx3] |= val3;
5418
5419 if (collisions >= collisions_max) return 0x7fffffff;
5420 }
5421
5422 return collisions;
5423 }
5424
5425 /**
5426 * main
5427 */
5428
5429 int main (int argc, char **argv)
5430 {
5431 /**
5432 * To help users a bit
5433 */
5434
5435 char *compute = getenv ("COMPUTE");
5436
5437 if (compute)
5438 {
5439 static char display[100];
5440
5441 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5442
5443 putenv (display);
5444 }
5445 else
5446 {
5447 if (getenv ("DISPLAY") == NULL)
5448 putenv ((char *) "DISPLAY=:0");
5449 }
5450
5451 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5452 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5453
5454 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5455 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5456
5457 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5458 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5459
5460 /**
5461 * Real init
5462 */
5463
5464 memset (&data, 0, sizeof (hc_global_data_t));
5465
5466 time_t proc_start;
5467
5468 time (&proc_start);
5469
5470 data.proc_start = proc_start;
5471
5472 int myargc = argc;
5473 char **myargv = argv;
5474
5475 hc_thread_mutex_init (mux_dispatcher);
5476 hc_thread_mutex_init (mux_counter);
5477 hc_thread_mutex_init (mux_display);
5478 hc_thread_mutex_init (mux_adl);
5479
5480 /**
5481 * commandline parameters
5482 */
5483
5484 uint usage = USAGE;
5485 uint version = VERSION;
5486 uint quiet = QUIET;
5487 uint benchmark = BENCHMARK;
5488 uint benchmark_repeats = BENCHMARK_REPEATS;
5489 uint show = SHOW;
5490 uint left = LEFT;
5491 uint username = USERNAME;
5492 uint remove = REMOVE;
5493 uint remove_timer = REMOVE_TIMER;
5494 u64 skip = SKIP;
5495 u64 limit = LIMIT;
5496 uint keyspace = KEYSPACE;
5497 uint potfile_disable = POTFILE_DISABLE;
5498 uint debug_mode = DEBUG_MODE;
5499 char *debug_file = NULL;
5500 char *induction_dir = NULL;
5501 char *outfile_check_dir = NULL;
5502 uint force = FORCE;
5503 uint runtime = RUNTIME;
5504 uint hash_mode = HASH_MODE;
5505 uint attack_mode = ATTACK_MODE;
5506 uint markov_disable = MARKOV_DISABLE;
5507 uint markov_classic = MARKOV_CLASSIC;
5508 uint markov_threshold = MARKOV_THRESHOLD;
5509 char *markov_hcstat = NULL;
5510 char *outfile = NULL;
5511 uint outfile_format = OUTFILE_FORMAT;
5512 uint outfile_autohex = OUTFILE_AUTOHEX;
5513 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5514 uint restore = RESTORE;
5515 uint restore_timer = RESTORE_TIMER;
5516 uint restore_disable = RESTORE_DISABLE;
5517 uint status = STATUS;
5518 uint status_timer = STATUS_TIMER;
5519 uint status_automat = STATUS_AUTOMAT;
5520 uint loopback = LOOPBACK;
5521 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5522 char *session = NULL;
5523 uint hex_charset = HEX_CHARSET;
5524 uint hex_salt = HEX_SALT;
5525 uint hex_wordlist = HEX_WORDLIST;
5526 uint rp_gen = RP_GEN;
5527 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5528 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5529 uint rp_gen_seed = RP_GEN_SEED;
5530 char *rule_buf_l = (char *) RULE_BUF_L;
5531 char *rule_buf_r = (char *) RULE_BUF_R;
5532 uint increment = INCREMENT;
5533 uint increment_min = INCREMENT_MIN;
5534 uint increment_max = INCREMENT_MAX;
5535 char *cpu_affinity = NULL;
5536 OCL_PTR *ocl = NULL;
5537 char *opencl_devices = NULL;
5538 char *opencl_platforms = NULL;
5539 char *opencl_device_types = NULL;
5540 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5541 char *truecrypt_keyfiles = NULL;
5542 uint workload_profile = WORKLOAD_PROFILE;
5543 uint kernel_accel = KERNEL_ACCEL;
5544 uint kernel_loops = KERNEL_LOOPS;
5545 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5546 #ifdef HAVE_HWMON
5547 uint gpu_temp_abort = GPU_TEMP_ABORT;
5548 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5549 #ifdef HAVE_ADL
5550 uint powertune_enable = POWERTUNE_ENABLE;
5551 #endif
5552 #endif
5553 uint logfile_disable = LOGFILE_DISABLE;
5554 uint segment_size = SEGMENT_SIZE;
5555 uint scrypt_tmto = SCRYPT_TMTO;
5556 char separator = SEPARATOR;
5557 uint bitmap_min = BITMAP_MIN;
5558 uint bitmap_max = BITMAP_MAX;
5559 char *custom_charset_1 = NULL;
5560 char *custom_charset_2 = NULL;
5561 char *custom_charset_3 = NULL;
5562 char *custom_charset_4 = NULL;
5563
5564 #define IDX_HELP 'h'
5565 #define IDX_VERSION 'V'
5566 #define IDX_VERSION_LOWER 'v'
5567 #define IDX_QUIET 0xff02
5568 #define IDX_SHOW 0xff03
5569 #define IDX_LEFT 0xff04
5570 #define IDX_REMOVE 0xff05
5571 #define IDX_REMOVE_TIMER 0xff37
5572 #define IDX_SKIP 's'
5573 #define IDX_LIMIT 'l'
5574 #define IDX_KEYSPACE 0xff35
5575 #define IDX_POTFILE_DISABLE 0xff06
5576 #define IDX_DEBUG_MODE 0xff43
5577 #define IDX_DEBUG_FILE 0xff44
5578 #define IDX_INDUCTION_DIR 0xff46
5579 #define IDX_OUTFILE_CHECK_DIR 0xff47
5580 #define IDX_USERNAME 0xff07
5581 #define IDX_FORCE 0xff08
5582 #define IDX_RUNTIME 0xff09
5583 #define IDX_BENCHMARK 'b'
5584 #define IDX_BENCHMARK_REPEATS 0xff78
5585 #define IDX_HASH_MODE 'm'
5586 #define IDX_ATTACK_MODE 'a'
5587 #define IDX_RP_FILE 'r'
5588 #define IDX_RP_GEN 'g'
5589 #define IDX_RP_GEN_FUNC_MIN 0xff10
5590 #define IDX_RP_GEN_FUNC_MAX 0xff11
5591 #define IDX_RP_GEN_SEED 0xff34
5592 #define IDX_RULE_BUF_L 'j'
5593 #define IDX_RULE_BUF_R 'k'
5594 #define IDX_INCREMENT 'i'
5595 #define IDX_INCREMENT_MIN 0xff12
5596 #define IDX_INCREMENT_MAX 0xff13
5597 #define IDX_OUTFILE 'o'
5598 #define IDX_OUTFILE_FORMAT 0xff14
5599 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5600 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5601 #define IDX_RESTORE 0xff15
5602 #define IDX_RESTORE_DISABLE 0xff27
5603 #define IDX_STATUS 0xff17
5604 #define IDX_STATUS_TIMER 0xff18
5605 #define IDX_STATUS_AUTOMAT 0xff50
5606 #define IDX_LOOPBACK 0xff38
5607 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5608 #define IDX_SESSION 0xff19
5609 #define IDX_HEX_CHARSET 0xff20
5610 #define IDX_HEX_SALT 0xff21
5611 #define IDX_HEX_WORDLIST 0xff40
5612 #define IDX_MARKOV_DISABLE 0xff22
5613 #define IDX_MARKOV_CLASSIC 0xff23
5614 #define IDX_MARKOV_THRESHOLD 't'
5615 #define IDX_MARKOV_HCSTAT 0xff24
5616 #define IDX_CPU_AFFINITY 0xff25
5617 #define IDX_OPENCL_DEVICES 'd'
5618 #define IDX_OPENCL_PLATFORMS 0xff72
5619 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5620 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5621 #define IDX_WORKLOAD_PROFILE 'w'
5622 #define IDX_KERNEL_ACCEL 'n'
5623 #define IDX_KERNEL_LOOPS 'u'
5624 #define IDX_GPU_TEMP_DISABLE 0xff29
5625 #define IDX_GPU_TEMP_ABORT 0xff30
5626 #define IDX_GPU_TEMP_RETAIN 0xff31
5627 #define IDX_POWERTUNE_ENABLE 0xff41
5628 #define IDX_LOGFILE_DISABLE 0xff51
5629 #define IDX_TRUECRYPT_KEYFILES 0xff52
5630 #define IDX_SCRYPT_TMTO 0xff61
5631 #define IDX_SEGMENT_SIZE 'c'
5632 #define IDX_SEPARATOR 'p'
5633 #define IDX_BITMAP_MIN 0xff70
5634 #define IDX_BITMAP_MAX 0xff71
5635 #define IDX_CUSTOM_CHARSET_1 '1'
5636 #define IDX_CUSTOM_CHARSET_2 '2'
5637 #define IDX_CUSTOM_CHARSET_3 '3'
5638 #define IDX_CUSTOM_CHARSET_4 '4'
5639
5640 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5641
5642 struct option long_options[] =
5643 {
5644 {"help", no_argument, 0, IDX_HELP},
5645 {"version", no_argument, 0, IDX_VERSION},
5646 {"quiet", no_argument, 0, IDX_QUIET},
5647 {"show", no_argument, 0, IDX_SHOW},
5648 {"left", no_argument, 0, IDX_LEFT},
5649 {"username", no_argument, 0, IDX_USERNAME},
5650 {"remove", no_argument, 0, IDX_REMOVE},
5651 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5652 {"skip", required_argument, 0, IDX_SKIP},
5653 {"limit", required_argument, 0, IDX_LIMIT},
5654 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5655 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5656 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5657 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5658 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5659 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5660 {"force", no_argument, 0, IDX_FORCE},
5661 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5662 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5663 {"restore", no_argument, 0, IDX_RESTORE},
5664 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5665 {"status", no_argument, 0, IDX_STATUS},
5666 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5667 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5668 {"loopback", no_argument, 0, IDX_LOOPBACK},
5669 {"weak-hash-threshold",
5670 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5671 {"session", required_argument, 0, IDX_SESSION},
5672 {"runtime", required_argument, 0, IDX_RUNTIME},
5673 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5674 {"generate-rules-func-min",
5675 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5676 {"generate-rules-func-max",
5677 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5678 {"generate-rules-seed",
5679 required_argument, 0, IDX_RP_GEN_SEED},
5680 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5681 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5682 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5683 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5684 {"rules-file", required_argument, 0, IDX_RP_FILE},
5685 {"outfile", required_argument, 0, IDX_OUTFILE},
5686 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5687 {"outfile-autohex-disable",
5688 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5689 {"outfile-check-timer",
5690 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5691 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5692 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5693 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5694 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5695 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5696 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5697 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5698 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5699 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5700 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5701 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5702 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5703 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5704 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5705 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5706 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5707 #ifdef HAVE_HWMON
5708 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5709 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5710 #ifdef HAVE_ADL
5711 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5712 #endif
5713 #endif // HAVE_HWMON
5714 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5715 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5716 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5717 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5718 // deprecated
5719 {"seperator", required_argument, 0, IDX_SEPARATOR},
5720 {"separator", required_argument, 0, IDX_SEPARATOR},
5721 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5722 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5723 {"increment", no_argument, 0, IDX_INCREMENT},
5724 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5725 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5726 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5727 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5728 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5729 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5730
5731 {0, 0, 0, 0}
5732 };
5733
5734 uint rp_files_cnt = 0;
5735
5736 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5737
5738 int option_index = 0;
5739 int c = -1;
5740
5741 optind = 1;
5742 optopt = 0;
5743
5744 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5745 {
5746 switch (c)
5747 {
5748 case IDX_HELP: usage = 1; break;
5749 case IDX_VERSION:
5750 case IDX_VERSION_LOWER: version = 1; break;
5751 case IDX_RESTORE: restore = 1; break;
5752 case IDX_SESSION: session = optarg; break;
5753 case IDX_SHOW: show = 1; break;
5754 case IDX_LEFT: left = 1; break;
5755 case '?': return (-1);
5756 }
5757 }
5758
5759 if (optopt != 0)
5760 {
5761 log_error ("ERROR: Invalid argument specified");
5762
5763 return (-1);
5764 }
5765
5766 /**
5767 * exit functions
5768 */
5769
5770 if (version)
5771 {
5772 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5773
5774 return (0);
5775 }
5776
5777 if (usage)
5778 {
5779 usage_big_print (PROGNAME);
5780
5781 return (0);
5782 }
5783
5784 /**
5785 * session needs to be set, always!
5786 */
5787
5788 if (session == NULL) session = (char *) PROGNAME;
5789
5790 /**
5791 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5792 */
5793
5794 char *exec_path = get_exec_path ();
5795
5796 #ifdef LINUX
5797
5798 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5799 char *resolved_exec_path = realpath (exec_path, NULL);
5800
5801 char *install_dir = get_install_dir (resolved_exec_path);
5802 char *profile_dir = NULL;
5803 char *session_dir = NULL;
5804 char *shared_dir = NULL;
5805
5806 if (strcmp (install_dir, resolved_install_folder) == 0)
5807 {
5808 struct passwd *pw = getpwuid (getuid ());
5809
5810 const char *homedir = pw->pw_dir;
5811
5812 profile_dir = get_profile_dir (homedir);
5813 session_dir = get_session_dir (profile_dir);
5814 shared_dir = strdup (SHARED_FOLDER);
5815
5816 mkdir (profile_dir, 0700);
5817 mkdir (session_dir, 0700);
5818 }
5819 else
5820 {
5821 profile_dir = install_dir;
5822 session_dir = install_dir;
5823 shared_dir = install_dir;
5824 }
5825
5826 myfree (resolved_install_folder);
5827 myfree (resolved_exec_path);
5828
5829 #else
5830
5831 char *install_dir = get_install_dir (exec_path);
5832 char *profile_dir = install_dir;
5833 char *session_dir = install_dir;
5834 char *shared_dir = install_dir;
5835
5836 #endif
5837
5838 data.install_dir = install_dir;
5839 data.profile_dir = profile_dir;
5840 data.session_dir = session_dir;
5841 data.shared_dir = shared_dir;
5842
5843 myfree (exec_path);
5844
5845 /**
5846 * kernel cache, we need to make sure folder exist
5847 */
5848
5849 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5850
5851 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5852
5853 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5854
5855 mkdir (kernels_folder, 0700);
5856
5857 myfree (kernels_folder);
5858
5859 /**
5860 * session
5861 */
5862
5863 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5864
5865 data.session = session;
5866
5867 char *eff_restore_file = (char *) mymalloc (session_size);
5868 char *new_restore_file = (char *) mymalloc (session_size);
5869
5870 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5871 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5872
5873 data.eff_restore_file = eff_restore_file;
5874 data.new_restore_file = new_restore_file;
5875
5876 if (((show == 1) || (left == 1)) && (restore == 1))
5877 {
5878 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5879 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5880
5881 return (-1);
5882 }
5883
5884 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5885 if ((show == 1) || (left == 1))
5886 {
5887 restore_disable = 1;
5888
5889 restore = 0;
5890 }
5891
5892 data.restore_disable = restore_disable;
5893
5894 restore_data_t *rd = init_restore (argc, argv);
5895
5896 data.rd = rd;
5897
5898 /**
5899 * restore file
5900 */
5901
5902 if (restore == 1)
5903 {
5904 read_restore (eff_restore_file, rd);
5905
5906 if (rd->version_bin < RESTORE_MIN)
5907 {
5908 log_error ("ERROR: Incompatible restore-file version");
5909
5910 return (-1);
5911 }
5912
5913 myargc = rd->argc;
5914 myargv = rd->argv;
5915
5916 #ifdef _POSIX
5917 rd->pid = getpid ();
5918 #elif _WIN
5919 rd->pid = GetCurrentProcessId ();
5920 #endif
5921 }
5922
5923 uint hash_mode_chgd = 0;
5924 uint runtime_chgd = 0;
5925 uint kernel_loops_chgd = 0;
5926 uint kernel_accel_chgd = 0;
5927 uint attack_mode_chgd = 0;
5928 uint outfile_format_chgd = 0;
5929 uint rp_gen_seed_chgd = 0;
5930 uint remove_timer_chgd = 0;
5931 uint increment_min_chgd = 0;
5932 uint increment_max_chgd = 0;
5933 uint workload_profile_chgd = 0;
5934 uint opencl_vector_width_chgd = 0;
5935
5936 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5937 uint gpu_temp_retain_chgd = 0;
5938 uint gpu_temp_abort_chgd = 0;
5939 #endif
5940
5941 optind = 1;
5942 optopt = 0;
5943 option_index = 0;
5944
5945 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5946 {
5947 switch (c)
5948 {
5949 //case IDX_HELP: usage = 1; break;
5950 //case IDX_VERSION: version = 1; break;
5951 //case IDX_RESTORE: restore = 1; break;
5952 case IDX_QUIET: quiet = 1; break;
5953 //case IDX_SHOW: show = 1; break;
5954 case IDX_SHOW: break;
5955 //case IDX_LEFT: left = 1; break;
5956 case IDX_LEFT: break;
5957 case IDX_USERNAME: username = 1; break;
5958 case IDX_REMOVE: remove = 1; break;
5959 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5960 remove_timer_chgd = 1; break;
5961 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5962 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5963 case IDX_DEBUG_FILE: debug_file = optarg; break;
5964 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5965 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5966 case IDX_FORCE: force = 1; break;
5967 case IDX_SKIP: skip = atoll (optarg); break;
5968 case IDX_LIMIT: limit = atoll (optarg); break;
5969 case IDX_KEYSPACE: keyspace = 1; break;
5970 case IDX_BENCHMARK: benchmark = 1; break;
5971 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5972 case IDX_RESTORE: break;
5973 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5974 case IDX_STATUS: status = 1; break;
5975 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5976 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5977 case IDX_LOOPBACK: loopback = 1; break;
5978 case IDX_WEAK_HASH_THRESHOLD:
5979 weak_hash_threshold = atoi (optarg); break;
5980 //case IDX_SESSION: session = optarg; break;
5981 case IDX_SESSION: break;
5982 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5983 hash_mode_chgd = 1; break;
5984 case IDX_RUNTIME: runtime = atoi (optarg);
5985 runtime_chgd = 1; break;
5986 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5987 attack_mode_chgd = 1; break;
5988 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5989 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5990 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5991 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5992 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5993 rp_gen_seed_chgd = 1; break;
5994 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5995 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5996 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5997 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5998 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5999 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6000 case IDX_OUTFILE: outfile = optarg; break;
6001 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6002 outfile_format_chgd = 1; break;
6003 case IDX_OUTFILE_AUTOHEX_DISABLE:
6004 outfile_autohex = 0; break;
6005 case IDX_OUTFILE_CHECK_TIMER:
6006 outfile_check_timer = atoi (optarg); break;
6007 case IDX_HEX_CHARSET: hex_charset = 1; break;
6008 case IDX_HEX_SALT: hex_salt = 1; break;
6009 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6010 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6011 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6012 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6013 case IDX_OPENCL_DEVICE_TYPES:
6014 opencl_device_types = optarg; break;
6015 case IDX_OPENCL_VECTOR_WIDTH:
6016 opencl_vector_width = atoi (optarg);
6017 opencl_vector_width_chgd = 1; break;
6018 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6019 workload_profile_chgd = 1; break;
6020 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6021 kernel_accel_chgd = 1; break;
6022 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6023 kernel_loops_chgd = 1; break;
6024 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6025 #ifdef HAVE_HWMON
6026 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
6027 #ifdef HAVE_ADL
6028 gpu_temp_abort_chgd = 1;
6029 #endif
6030 break;
6031 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
6032 #ifdef HAVE_ADL
6033 gpu_temp_retain_chgd = 1;
6034 #endif
6035 break;
6036 #ifdef HAVE_ADL
6037 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6038 #endif
6039 #endif // HAVE_HWMON
6040 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6041 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6042 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6043 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6044 case IDX_SEPARATOR: separator = optarg[0]; break;
6045 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6046 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6047 case IDX_INCREMENT: increment = 1; break;
6048 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6049 increment_min_chgd = 1; break;
6050 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6051 increment_max_chgd = 1; break;
6052 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6053 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6054 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6055 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6056
6057 default:
6058 log_error ("ERROR: Invalid argument specified");
6059 return (-1);
6060 }
6061 }
6062
6063 if (optopt != 0)
6064 {
6065 log_error ("ERROR: Invalid argument specified");
6066
6067 return (-1);
6068 }
6069
6070 /**
6071 * Inform user things getting started,
6072 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6073 * - we do not need to check algorithm_pos
6074 */
6075
6076 if (quiet == 0)
6077 {
6078 if (benchmark == 1)
6079 {
6080 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
6081
6082 log_info ("");
6083 }
6084 else if (restore == 1)
6085 {
6086 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
6087
6088 log_info ("");
6089 }
6090 else
6091 {
6092 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
6093
6094 log_info ("");
6095 }
6096 }
6097
6098 /**
6099 * sanity check
6100 */
6101
6102 if (attack_mode > 7)
6103 {
6104 log_error ("ERROR: Invalid attack-mode specified");
6105
6106 return (-1);
6107 }
6108
6109 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6110 {
6111 log_error ("ERROR: Invalid runtime specified");
6112
6113 return (-1);
6114 }
6115
6116 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
6117 {
6118 log_error ("ERROR: Invalid hash-type specified");
6119
6120 return (-1);
6121 }
6122
6123 // renamed hash modes
6124
6125 if (hash_mode_chgd)
6126 {
6127 int n = -1;
6128
6129 switch (hash_mode)
6130 {
6131 case 123: n = 124;
6132 break;
6133 }
6134
6135 if (n >= 0)
6136 {
6137 log_error ("Old -m specified, use -m %d instead", n);
6138
6139 return (-1);
6140 }
6141 }
6142
6143 if (username == 1)
6144 {
6145 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
6146 {
6147 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6148
6149 return (-1);
6150 }
6151 }
6152
6153 if (outfile_format > 16)
6154 {
6155 log_error ("ERROR: Invalid outfile-format specified");
6156
6157 return (-1);
6158 }
6159
6160 if (left == 1)
6161 {
6162 if (outfile_format_chgd == 1)
6163 {
6164 if (outfile_format > 1)
6165 {
6166 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6167
6168 return (-1);
6169 }
6170 }
6171 else
6172 {
6173 outfile_format = OUTFILE_FMT_HASH;
6174 }
6175 }
6176
6177 if (show == 1)
6178 {
6179 if (outfile_format_chgd == 1)
6180 {
6181 if ((outfile_format > 7) && (outfile_format < 16))
6182 {
6183 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6184
6185 return (-1);
6186 }
6187 }
6188 }
6189
6190 if (increment_min < INCREMENT_MIN)
6191 {
6192 log_error ("ERROR: Invalid increment-min specified");
6193
6194 return (-1);
6195 }
6196
6197 if (increment_max > INCREMENT_MAX)
6198 {
6199 log_error ("ERROR: Invalid increment-max specified");
6200
6201 return (-1);
6202 }
6203
6204 if (increment_min > increment_max)
6205 {
6206 log_error ("ERROR: Invalid increment-min specified");
6207
6208 return (-1);
6209 }
6210
6211 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6212 {
6213 log_error ("ERROR: increment is not allowed in attack-mode 0");
6214
6215 return (-1);
6216 }
6217
6218 if ((increment == 0) && (increment_min_chgd == 1))
6219 {
6220 log_error ("ERROR: increment-min is only supported together with increment switch");
6221
6222 return (-1);
6223 }
6224
6225 if ((increment == 0) && (increment_max_chgd == 1))
6226 {
6227 log_error ("ERROR: increment-max is only supported together with increment switch");
6228
6229 return (-1);
6230 }
6231
6232 if (rp_files_cnt && rp_gen)
6233 {
6234 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6235
6236 return (-1);
6237 }
6238
6239 if (rp_files_cnt || rp_gen)
6240 {
6241 if (attack_mode != ATTACK_MODE_STRAIGHT)
6242 {
6243 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6244
6245 return (-1);
6246 }
6247 }
6248
6249 if (rp_gen_func_min > rp_gen_func_max)
6250 {
6251 log_error ("ERROR: Invalid rp-gen-func-min specified");
6252
6253 return (-1);
6254 }
6255
6256 if (kernel_accel_chgd == 1 && kernel_loops_chgd == 0)
6257 {
6258 log_error ("ERROR: If kernel-accel is specified, kernel-loops need to be specified as well");
6259
6260 return (-1);
6261 }
6262
6263 if (kernel_loops_chgd == 1 && kernel_accel_chgd == 0)
6264 {
6265 log_error ("ERROR: If kernel-loops is specified, kernel-accel need to be specified as well");
6266
6267 return (-1);
6268 }
6269
6270 if (kernel_accel_chgd == 1)
6271 {
6272 if (kernel_accel < 1)
6273 {
6274 log_error ("ERROR: Invalid kernel-accel specified");
6275
6276 return (-1);
6277 }
6278
6279 if (kernel_accel > 1024)
6280 {
6281 log_error ("ERROR: Invalid kernel-accel specified");
6282
6283 return (-1);
6284 }
6285 }
6286
6287 if (kernel_loops_chgd == 1)
6288 {
6289 if (kernel_loops < 1)
6290 {
6291 log_error ("ERROR: Invalid kernel-loops specified");
6292
6293 return (-1);
6294 }
6295
6296 if (kernel_loops > 1024)
6297 {
6298 log_error ("ERROR: Invalid kernel-loops specified");
6299
6300 return (-1);
6301 }
6302 }
6303
6304 if ((workload_profile < 1) || (workload_profile > 3))
6305 {
6306 log_error ("ERROR: workload-profile %i not available", workload_profile);
6307
6308 return (-1);
6309 }
6310
6311 if ((opencl_vector_width != 0) && (opencl_vector_width != 1) && (opencl_vector_width != 2) && (opencl_vector_width != 4) && (opencl_vector_width != 8))
6312 {
6313 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6314
6315 return (-1);
6316 }
6317
6318 if (show == 1 || left == 1)
6319 {
6320 attack_mode = ATTACK_MODE_NONE;
6321
6322 if (remove == 1)
6323 {
6324 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6325
6326 return (-1);
6327 }
6328
6329 if (potfile_disable == 1)
6330 {
6331 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6332
6333 return (-1);
6334 }
6335 }
6336
6337 uint attack_kern = ATTACK_KERN_NONE;
6338
6339 switch (attack_mode)
6340 {
6341 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6342 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6343 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6344 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6345 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6346 }
6347
6348 if (benchmark == 0)
6349 {
6350 if (keyspace == 1)
6351 {
6352 int num_additional_params = 1;
6353
6354 if (attack_kern == ATTACK_KERN_COMBI)
6355 {
6356 num_additional_params = 2;
6357 }
6358
6359 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6360
6361 if (keyspace_wordlist_specified == 0) optind--;
6362 }
6363
6364 if (attack_kern == ATTACK_KERN_NONE)
6365 {
6366 if ((optind + 1) != myargc)
6367 {
6368 usage_mini_print (myargv[0]);
6369
6370 return (-1);
6371 }
6372 }
6373 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6374 {
6375 if ((optind + 1) > myargc)
6376 {
6377 usage_mini_print (myargv[0]);
6378
6379 return (-1);
6380 }
6381 }
6382 else if (attack_kern == ATTACK_KERN_COMBI)
6383 {
6384 if ((optind + 3) != myargc)
6385 {
6386 usage_mini_print (myargv[0]);
6387
6388 return (-1);
6389 }
6390 }
6391 else if (attack_kern == ATTACK_KERN_BF)
6392 {
6393 if ((optind + 1) > myargc)
6394 {
6395 usage_mini_print (myargv[0]);
6396
6397 return (-1);
6398 }
6399 }
6400 else
6401 {
6402 usage_mini_print (myargv[0]);
6403
6404 return (-1);
6405 }
6406 }
6407 else
6408 {
6409 if (myargv[optind] != 0)
6410 {
6411 log_error ("ERROR: Invalid argument for benchmark mode specified");
6412
6413 return (-1);
6414 }
6415
6416 if (attack_mode_chgd == 1)
6417 {
6418 if (attack_mode != ATTACK_MODE_BF)
6419 {
6420 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6421
6422 return (-1);
6423 }
6424 }
6425 }
6426
6427 if (skip != 0 && limit != 0)
6428 {
6429 limit += skip;
6430 }
6431
6432 if (keyspace == 1)
6433 {
6434 if (show == 1)
6435 {
6436 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6437
6438 return (-1);
6439 }
6440 else if (left == 1)
6441 {
6442 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6443
6444 return (-1);
6445 }
6446
6447 potfile_disable = 1;
6448
6449 restore_disable = 1;
6450
6451 restore = 0;
6452
6453 weak_hash_threshold = 0;
6454
6455 quiet = 1;
6456 }
6457
6458 if (remove_timer_chgd == 1)
6459 {
6460 if (remove == 0)
6461 {
6462 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6463
6464 return (-1);
6465 }
6466
6467 if (remove_timer < 1)
6468 {
6469 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6470
6471 return (-1);
6472 }
6473 }
6474
6475 if (loopback == 1)
6476 {
6477 if (attack_mode == ATTACK_MODE_BF)
6478 {
6479 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6480
6481 return (-1);
6482 }
6483 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6484 {
6485 if ((rp_files_cnt == 0) && (rp_gen == 0))
6486 {
6487 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6488
6489 return (-1);
6490 }
6491 }
6492 }
6493
6494 if (debug_mode > 0)
6495 {
6496 if (attack_mode != ATTACK_MODE_STRAIGHT)
6497 {
6498 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6499
6500 return (-1);
6501 }
6502
6503 if ((rp_files_cnt == 0) && (rp_gen == 0))
6504 {
6505 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6506
6507 return (-1);
6508 }
6509 }
6510
6511 if (debug_mode > 4)
6512 {
6513 log_error ("ERROR: Invalid debug-mode specified");
6514
6515 return (-1);
6516 }
6517
6518 if (debug_file != NULL)
6519 {
6520 if (debug_mode < 1)
6521 {
6522 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6523
6524 return (-1);
6525 }
6526 }
6527
6528 if (induction_dir != NULL)
6529 {
6530 if (attack_mode == ATTACK_MODE_BF)
6531 {
6532 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6533
6534 return (-1);
6535 }
6536 }
6537
6538 if (attack_mode != ATTACK_MODE_STRAIGHT)
6539 {
6540 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6541 {
6542 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6543
6544 return (-1);
6545 }
6546
6547 weak_hash_threshold = 0;
6548 }
6549
6550 /**
6551 * induction directory
6552 */
6553
6554 char *induction_directory = NULL;
6555
6556 if (attack_mode != ATTACK_MODE_BF)
6557 {
6558 if (induction_dir == NULL)
6559 {
6560 induction_directory = (char *) mymalloc (session_size);
6561
6562 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6563
6564 // create induction folder if it does not already exist
6565
6566 if (keyspace == 0)
6567 {
6568 if (rmdir (induction_directory) == -1)
6569 {
6570 if (errno == ENOENT)
6571 {
6572 // good, we can ignore
6573 }
6574 else if (errno == ENOTEMPTY)
6575 {
6576 char *induction_directory_mv = (char *) mymalloc (session_size);
6577
6578 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6579
6580 if (rename (induction_directory, induction_directory_mv) != 0)
6581 {
6582 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6583
6584 return (-1);
6585 }
6586 }
6587 else
6588 {
6589 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6590
6591 return (-1);
6592 }
6593 }
6594
6595 if (mkdir (induction_directory, 0700) == -1)
6596 {
6597 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6598
6599 return (-1);
6600 }
6601 }
6602 }
6603 else
6604 {
6605 induction_directory = induction_dir;
6606 }
6607 }
6608
6609 data.induction_directory = induction_directory;
6610
6611 /**
6612 * loopback
6613 */
6614
6615 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6616
6617 char *loopback_file = (char *) mymalloc (loopback_size);
6618
6619 /**
6620 * tuning db
6621 */
6622
6623 char tuning_db_file[256] = { 0 };
6624
6625 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6626
6627 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6628
6629 /**
6630 * outfile-check directory
6631 */
6632
6633 char *outfile_check_directory = NULL;
6634
6635 if (outfile_check_dir == NULL)
6636 {
6637 outfile_check_directory = (char *) mymalloc (session_size);
6638
6639 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6640 }
6641 else
6642 {
6643 outfile_check_directory = outfile_check_dir;
6644 }
6645
6646 data.outfile_check_directory = outfile_check_directory;
6647
6648 if (keyspace == 0)
6649 {
6650 struct stat outfile_check_stat;
6651
6652 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6653 {
6654 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6655
6656 if (is_dir == 0)
6657 {
6658 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6659
6660 return (-1);
6661 }
6662 }
6663 else if (outfile_check_dir == NULL)
6664 {
6665 if (mkdir (outfile_check_directory, 0700) == -1)
6666 {
6667 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6668
6669 return (-1);
6670 }
6671 }
6672 }
6673
6674 /**
6675 * special other stuff
6676 */
6677
6678 if (hash_mode == 9710)
6679 {
6680 outfile_format = 5;
6681 outfile_format_chgd = 1;
6682 }
6683
6684 if (hash_mode == 9810)
6685 {
6686 outfile_format = 5;
6687 outfile_format_chgd = 1;
6688 }
6689
6690 if (hash_mode == 10410)
6691 {
6692 outfile_format = 5;
6693 outfile_format_chgd = 1;
6694 }
6695
6696 /**
6697 * store stuff
6698 */
6699
6700 data.hash_mode = hash_mode;
6701 data.restore = restore;
6702 data.restore_timer = restore_timer;
6703 data.restore_disable = restore_disable;
6704 data.status = status;
6705 data.status_timer = status_timer;
6706 data.status_automat = status_automat;
6707 data.loopback = loopback;
6708 data.runtime = runtime;
6709 data.remove = remove;
6710 data.remove_timer = remove_timer;
6711 data.debug_mode = debug_mode;
6712 data.debug_file = debug_file;
6713 data.username = username;
6714 data.quiet = quiet;
6715 data.outfile = outfile;
6716 data.outfile_format = outfile_format;
6717 data.outfile_autohex = outfile_autohex;
6718 data.hex_charset = hex_charset;
6719 data.hex_salt = hex_salt;
6720 data.hex_wordlist = hex_wordlist;
6721 data.separator = separator;
6722 data.rp_files = rp_files;
6723 data.rp_files_cnt = rp_files_cnt;
6724 data.rp_gen = rp_gen;
6725 data.rp_gen_seed = rp_gen_seed;
6726 data.force = force;
6727 data.benchmark = benchmark;
6728 data.benchmark_repeats = benchmark_repeats;
6729 data.skip = skip;
6730 data.limit = limit;
6731 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6732 data.powertune_enable = powertune_enable;
6733 #endif
6734 data.logfile_disable = logfile_disable;
6735 data.truecrypt_keyfiles = truecrypt_keyfiles;
6736 data.scrypt_tmto = scrypt_tmto;
6737 data.workload_profile = workload_profile;
6738
6739 /**
6740 * cpu affinity
6741 */
6742
6743 if (cpu_affinity)
6744 {
6745 set_cpu_affinity (cpu_affinity);
6746 }
6747
6748 if (rp_gen_seed_chgd == 0)
6749 {
6750 srand (proc_start);
6751 }
6752 else
6753 {
6754 srand (rp_gen_seed);
6755 }
6756
6757 /**
6758 * logfile init
6759 */
6760
6761 if (logfile_disable == 0)
6762 {
6763 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6764
6765 char *logfile = (char *) mymalloc (logfile_size);
6766
6767 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6768
6769 data.logfile = logfile;
6770
6771 char *topid = logfile_generate_topid ();
6772
6773 data.topid = topid;
6774 }
6775
6776 // logfile_append() checks for logfile_disable internally to make it easier from here
6777
6778 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6779 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6780 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6781 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6782 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6783 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6784 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6785 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6786 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6787 #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));
6788
6789 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6790 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6791 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6792 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6793 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6794 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6795 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6796 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6797
6798 logfile_top_msg ("START");
6799
6800 logfile_top_uint (attack_mode);
6801 logfile_top_uint (attack_kern);
6802 logfile_top_uint (benchmark);
6803 logfile_top_uint (benchmark_repeats);
6804 logfile_top_uint (bitmap_min);
6805 logfile_top_uint (bitmap_max);
6806 logfile_top_uint (debug_mode);
6807 logfile_top_uint (force);
6808 logfile_top_uint (kernel_accel);
6809 logfile_top_uint (kernel_loops);
6810 logfile_top_uint (gpu_temp_disable);
6811 #ifdef HAVE_HWMON
6812 logfile_top_uint (gpu_temp_abort);
6813 logfile_top_uint (gpu_temp_retain);
6814 #endif
6815 logfile_top_uint (hash_mode);
6816 logfile_top_uint (hex_charset);
6817 logfile_top_uint (hex_salt);
6818 logfile_top_uint (hex_wordlist);
6819 logfile_top_uint (increment);
6820 logfile_top_uint (increment_max);
6821 logfile_top_uint (increment_min);
6822 logfile_top_uint (keyspace);
6823 logfile_top_uint (left);
6824 logfile_top_uint (logfile_disable);
6825 logfile_top_uint (loopback);
6826 logfile_top_uint (markov_classic);
6827 logfile_top_uint (markov_disable);
6828 logfile_top_uint (markov_threshold);
6829 logfile_top_uint (outfile_autohex);
6830 logfile_top_uint (outfile_check_timer);
6831 logfile_top_uint (outfile_format);
6832 logfile_top_uint (potfile_disable);
6833 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6834 logfile_top_uint (powertune_enable);
6835 #endif
6836 logfile_top_uint (scrypt_tmto);
6837 logfile_top_uint (quiet);
6838 logfile_top_uint (remove);
6839 logfile_top_uint (remove_timer);
6840 logfile_top_uint (restore);
6841 logfile_top_uint (restore_disable);
6842 logfile_top_uint (restore_timer);
6843 logfile_top_uint (rp_gen);
6844 logfile_top_uint (rp_gen_func_max);
6845 logfile_top_uint (rp_gen_func_min);
6846 logfile_top_uint (rp_gen_seed);
6847 logfile_top_uint (runtime);
6848 logfile_top_uint (segment_size);
6849 logfile_top_uint (show);
6850 logfile_top_uint (status);
6851 logfile_top_uint (status_automat);
6852 logfile_top_uint (status_timer);
6853 logfile_top_uint (usage);
6854 logfile_top_uint (username);
6855 logfile_top_uint (version);
6856 logfile_top_uint (weak_hash_threshold);
6857 logfile_top_uint (workload_profile);
6858 logfile_top_uint64 (limit);
6859 logfile_top_uint64 (skip);
6860 logfile_top_char (separator);
6861 logfile_top_string (cpu_affinity);
6862 logfile_top_string (custom_charset_1);
6863 logfile_top_string (custom_charset_2);
6864 logfile_top_string (custom_charset_3);
6865 logfile_top_string (custom_charset_4);
6866 logfile_top_string (debug_file);
6867 logfile_top_string (opencl_devices);
6868 logfile_top_string (opencl_platforms);
6869 logfile_top_string (opencl_device_types);
6870 logfile_top_uint (opencl_vector_width);
6871 logfile_top_string (induction_dir);
6872 logfile_top_string (markov_hcstat);
6873 logfile_top_string (outfile);
6874 logfile_top_string (outfile_check_dir);
6875 logfile_top_string (rule_buf_l);
6876 logfile_top_string (rule_buf_r);
6877 logfile_top_string (session);
6878 logfile_top_string (truecrypt_keyfiles);
6879
6880 /**
6881 * Init OpenCL library loader
6882 */
6883
6884 if (keyspace == 0)
6885 {
6886 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6887
6888 ocl_init (ocl);
6889
6890 data.ocl = ocl;
6891 }
6892
6893 /**
6894 * OpenCL platform selection
6895 */
6896
6897 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6898
6899 /**
6900 * OpenCL device selection
6901 */
6902
6903 u32 devices_filter = setup_devices_filter (opencl_devices);
6904
6905 /**
6906 * OpenCL device type selection
6907 */
6908
6909 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6910
6911 /**
6912 * benchmark
6913 */
6914
6915 if (benchmark == 1)
6916 {
6917 /**
6918 * disable useless stuff for benchmark
6919 */
6920
6921 status_timer = 0;
6922 restore_timer = 0;
6923 restore_disable = 1;
6924 potfile_disable = 1;
6925 weak_hash_threshold = 0;
6926 gpu_temp_disable = 1;
6927
6928 data.status_timer = status_timer;
6929 data.restore_timer = restore_timer;
6930 data.restore_disable = restore_disable;
6931
6932 /**
6933 * force attack mode to be bruteforce
6934 */
6935
6936 attack_mode = ATTACK_MODE_BF;
6937 attack_kern = ATTACK_KERN_BF;
6938
6939 if (workload_profile_chgd == 0)
6940 {
6941 workload_profile = 3;
6942
6943 data.workload_profile = workload_profile;
6944 }
6945 }
6946
6947 /**
6948 * config
6949 */
6950
6951 uint hash_type = 0;
6952 uint salt_type = 0;
6953 uint attack_exec = 0;
6954 uint opts_type = 0;
6955 uint kern_type = 0;
6956 uint dgst_size = 0;
6957 uint esalt_size = 0;
6958 uint opti_type = 0;
6959 uint dgst_pos0 = -1;
6960 uint dgst_pos1 = -1;
6961 uint dgst_pos2 = -1;
6962 uint dgst_pos3 = -1;
6963
6964 int (*parse_func) (char *, uint, hash_t *);
6965 int (*sort_by_digest) (const void *, const void *);
6966
6967 uint algorithm_pos = 0;
6968 uint algorithm_max = 1;
6969
6970 uint *algorithms = default_benchmark_algorithms;
6971
6972 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6973
6974 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6975 {
6976 /*
6977 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6978 * the following algos are skipped entirely
6979 */
6980
6981 if (algorithm_pos > 0)
6982 {
6983 local_free (rd);
6984
6985 rd = init_restore (argc, argv);
6986
6987 data.rd = rd;
6988 }
6989
6990 /**
6991 * update hash_mode in case of multihash benchmark
6992 */
6993
6994 if (benchmark == 1)
6995 {
6996 if (hash_mode_chgd == 0)
6997 {
6998 hash_mode = algorithms[algorithm_pos];
6999
7000 data.hash_mode = hash_mode;
7001 }
7002
7003 quiet = 1;
7004
7005 data.quiet = quiet;
7006 }
7007
7008 switch (hash_mode)
7009 {
7010 case 0: hash_type = HASH_TYPE_MD5;
7011 salt_type = SALT_TYPE_NONE;
7012 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7013 opts_type = OPTS_TYPE_PT_GENERATE_LE
7014 | OPTS_TYPE_PT_ADD80
7015 | OPTS_TYPE_PT_ADDBITS14;
7016 kern_type = KERN_TYPE_MD5;
7017 dgst_size = DGST_SIZE_4_4;
7018 parse_func = md5_parse_hash;
7019 sort_by_digest = sort_by_digest_4_4;
7020 opti_type = OPTI_TYPE_ZERO_BYTE
7021 | OPTI_TYPE_PRECOMPUTE_INIT
7022 | OPTI_TYPE_PRECOMPUTE_MERKLE
7023 | OPTI_TYPE_MEET_IN_MIDDLE
7024 | OPTI_TYPE_EARLY_SKIP
7025 | OPTI_TYPE_NOT_ITERATED
7026 | OPTI_TYPE_NOT_SALTED
7027 | OPTI_TYPE_RAW_HASH;
7028 dgst_pos0 = 0;
7029 dgst_pos1 = 3;
7030 dgst_pos2 = 2;
7031 dgst_pos3 = 1;
7032 break;
7033
7034 case 10: hash_type = HASH_TYPE_MD5;
7035 salt_type = SALT_TYPE_INTERN;
7036 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7037 opts_type = OPTS_TYPE_PT_GENERATE_LE
7038 | OPTS_TYPE_ST_ADD80
7039 | OPTS_TYPE_ST_ADDBITS14;
7040 kern_type = KERN_TYPE_MD5_PWSLT;
7041 dgst_size = DGST_SIZE_4_4;
7042 parse_func = md5s_parse_hash;
7043 sort_by_digest = sort_by_digest_4_4;
7044 opti_type = OPTI_TYPE_ZERO_BYTE
7045 | OPTI_TYPE_PRECOMPUTE_INIT
7046 | OPTI_TYPE_PRECOMPUTE_MERKLE
7047 | OPTI_TYPE_MEET_IN_MIDDLE
7048 | OPTI_TYPE_EARLY_SKIP
7049 | OPTI_TYPE_NOT_ITERATED
7050 | OPTI_TYPE_APPENDED_SALT
7051 | OPTI_TYPE_RAW_HASH;
7052 dgst_pos0 = 0;
7053 dgst_pos1 = 3;
7054 dgst_pos2 = 2;
7055 dgst_pos3 = 1;
7056 break;
7057
7058 case 11: hash_type = HASH_TYPE_MD5;
7059 salt_type = SALT_TYPE_INTERN;
7060 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7061 opts_type = OPTS_TYPE_PT_GENERATE_LE
7062 | OPTS_TYPE_ST_ADD80
7063 | OPTS_TYPE_ST_ADDBITS14;
7064 kern_type = KERN_TYPE_MD5_PWSLT;
7065 dgst_size = DGST_SIZE_4_4;
7066 parse_func = joomla_parse_hash;
7067 sort_by_digest = sort_by_digest_4_4;
7068 opti_type = OPTI_TYPE_ZERO_BYTE
7069 | OPTI_TYPE_PRECOMPUTE_INIT
7070 | OPTI_TYPE_PRECOMPUTE_MERKLE
7071 | OPTI_TYPE_MEET_IN_MIDDLE
7072 | OPTI_TYPE_EARLY_SKIP
7073 | OPTI_TYPE_NOT_ITERATED
7074 | OPTI_TYPE_APPENDED_SALT
7075 | OPTI_TYPE_RAW_HASH;
7076 dgst_pos0 = 0;
7077 dgst_pos1 = 3;
7078 dgst_pos2 = 2;
7079 dgst_pos3 = 1;
7080 break;
7081
7082 case 12: hash_type = HASH_TYPE_MD5;
7083 salt_type = SALT_TYPE_INTERN;
7084 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7085 opts_type = OPTS_TYPE_PT_GENERATE_LE
7086 | OPTS_TYPE_ST_ADD80
7087 | OPTS_TYPE_ST_ADDBITS14;
7088 kern_type = KERN_TYPE_MD5_PWSLT;
7089 dgst_size = DGST_SIZE_4_4;
7090 parse_func = postgresql_parse_hash;
7091 sort_by_digest = sort_by_digest_4_4;
7092 opti_type = OPTI_TYPE_ZERO_BYTE
7093 | OPTI_TYPE_PRECOMPUTE_INIT
7094 | OPTI_TYPE_PRECOMPUTE_MERKLE
7095 | OPTI_TYPE_MEET_IN_MIDDLE
7096 | OPTI_TYPE_EARLY_SKIP
7097 | OPTI_TYPE_NOT_ITERATED
7098 | OPTI_TYPE_APPENDED_SALT
7099 | OPTI_TYPE_RAW_HASH;
7100 dgst_pos0 = 0;
7101 dgst_pos1 = 3;
7102 dgst_pos2 = 2;
7103 dgst_pos3 = 1;
7104 break;
7105
7106 case 20: hash_type = HASH_TYPE_MD5;
7107 salt_type = SALT_TYPE_INTERN;
7108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7109 opts_type = OPTS_TYPE_PT_GENERATE_LE
7110 | OPTS_TYPE_PT_ADD80
7111 | OPTS_TYPE_PT_ADDBITS14;
7112 kern_type = KERN_TYPE_MD5_SLTPW;
7113 dgst_size = DGST_SIZE_4_4;
7114 parse_func = md5s_parse_hash;
7115 sort_by_digest = sort_by_digest_4_4;
7116 opti_type = OPTI_TYPE_ZERO_BYTE
7117 | OPTI_TYPE_PRECOMPUTE_INIT
7118 | OPTI_TYPE_PRECOMPUTE_MERKLE
7119 | OPTI_TYPE_EARLY_SKIP
7120 | OPTI_TYPE_NOT_ITERATED
7121 | OPTI_TYPE_PREPENDED_SALT
7122 | OPTI_TYPE_RAW_HASH;
7123 dgst_pos0 = 0;
7124 dgst_pos1 = 3;
7125 dgst_pos2 = 2;
7126 dgst_pos3 = 1;
7127 break;
7128
7129 case 21: hash_type = HASH_TYPE_MD5;
7130 salt_type = SALT_TYPE_INTERN;
7131 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7132 opts_type = OPTS_TYPE_PT_GENERATE_LE
7133 | OPTS_TYPE_PT_ADD80
7134 | OPTS_TYPE_PT_ADDBITS14;
7135 kern_type = KERN_TYPE_MD5_SLTPW;
7136 dgst_size = DGST_SIZE_4_4;
7137 parse_func = osc_parse_hash;
7138 sort_by_digest = sort_by_digest_4_4;
7139 opti_type = OPTI_TYPE_ZERO_BYTE
7140 | OPTI_TYPE_PRECOMPUTE_INIT
7141 | OPTI_TYPE_PRECOMPUTE_MERKLE
7142 | OPTI_TYPE_EARLY_SKIP
7143 | OPTI_TYPE_NOT_ITERATED
7144 | OPTI_TYPE_PREPENDED_SALT
7145 | OPTI_TYPE_RAW_HASH;
7146 dgst_pos0 = 0;
7147 dgst_pos1 = 3;
7148 dgst_pos2 = 2;
7149 dgst_pos3 = 1;
7150 break;
7151
7152 case 22: hash_type = HASH_TYPE_MD5;
7153 salt_type = SALT_TYPE_EMBEDDED;
7154 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7155 opts_type = OPTS_TYPE_PT_GENERATE_LE
7156 | OPTS_TYPE_PT_ADD80
7157 | OPTS_TYPE_PT_ADDBITS14;
7158 kern_type = KERN_TYPE_MD5_SLTPW;
7159 dgst_size = DGST_SIZE_4_4;
7160 parse_func = netscreen_parse_hash;
7161 sort_by_digest = sort_by_digest_4_4;
7162 opti_type = OPTI_TYPE_ZERO_BYTE
7163 | OPTI_TYPE_PRECOMPUTE_INIT
7164 | OPTI_TYPE_PRECOMPUTE_MERKLE
7165 | OPTI_TYPE_EARLY_SKIP
7166 | OPTI_TYPE_NOT_ITERATED
7167 | OPTI_TYPE_PREPENDED_SALT
7168 | OPTI_TYPE_RAW_HASH;
7169 dgst_pos0 = 0;
7170 dgst_pos1 = 3;
7171 dgst_pos2 = 2;
7172 dgst_pos3 = 1;
7173 break;
7174
7175 case 23: hash_type = HASH_TYPE_MD5;
7176 salt_type = SALT_TYPE_EMBEDDED;
7177 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7178 opts_type = OPTS_TYPE_PT_GENERATE_LE
7179 | OPTS_TYPE_PT_ADD80
7180 | OPTS_TYPE_PT_ADDBITS14;
7181 kern_type = KERN_TYPE_MD5_SLTPW;
7182 dgst_size = DGST_SIZE_4_4;
7183 parse_func = skype_parse_hash;
7184 sort_by_digest = sort_by_digest_4_4;
7185 opti_type = OPTI_TYPE_ZERO_BYTE
7186 | OPTI_TYPE_PRECOMPUTE_INIT
7187 | OPTI_TYPE_PRECOMPUTE_MERKLE
7188 | OPTI_TYPE_EARLY_SKIP
7189 | OPTI_TYPE_NOT_ITERATED
7190 | OPTI_TYPE_PREPENDED_SALT
7191 | OPTI_TYPE_RAW_HASH;
7192 dgst_pos0 = 0;
7193 dgst_pos1 = 3;
7194 dgst_pos2 = 2;
7195 dgst_pos3 = 1;
7196 break;
7197
7198 case 30: hash_type = HASH_TYPE_MD5;
7199 salt_type = SALT_TYPE_INTERN;
7200 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7201 opts_type = OPTS_TYPE_PT_GENERATE_LE
7202 | OPTS_TYPE_PT_UNICODE
7203 | OPTS_TYPE_ST_ADD80
7204 | OPTS_TYPE_ST_ADDBITS14;
7205 kern_type = KERN_TYPE_MD5_PWUSLT;
7206 dgst_size = DGST_SIZE_4_4;
7207 parse_func = md5s_parse_hash;
7208 sort_by_digest = sort_by_digest_4_4;
7209 opti_type = OPTI_TYPE_ZERO_BYTE
7210 | OPTI_TYPE_PRECOMPUTE_INIT
7211 | OPTI_TYPE_PRECOMPUTE_MERKLE
7212 | OPTI_TYPE_MEET_IN_MIDDLE
7213 | OPTI_TYPE_EARLY_SKIP
7214 | OPTI_TYPE_NOT_ITERATED
7215 | OPTI_TYPE_APPENDED_SALT
7216 | OPTI_TYPE_RAW_HASH;
7217 dgst_pos0 = 0;
7218 dgst_pos1 = 3;
7219 dgst_pos2 = 2;
7220 dgst_pos3 = 1;
7221 break;
7222
7223 case 40: hash_type = HASH_TYPE_MD5;
7224 salt_type = SALT_TYPE_INTERN;
7225 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7226 opts_type = OPTS_TYPE_PT_GENERATE_LE
7227 | OPTS_TYPE_PT_ADD80
7228 | OPTS_TYPE_PT_ADDBITS14
7229 | OPTS_TYPE_PT_UNICODE;
7230 kern_type = KERN_TYPE_MD5_SLTPWU;
7231 dgst_size = DGST_SIZE_4_4;
7232 parse_func = md5s_parse_hash;
7233 sort_by_digest = sort_by_digest_4_4;
7234 opti_type = OPTI_TYPE_ZERO_BYTE
7235 | OPTI_TYPE_PRECOMPUTE_INIT
7236 | OPTI_TYPE_PRECOMPUTE_MERKLE
7237 | OPTI_TYPE_EARLY_SKIP
7238 | OPTI_TYPE_NOT_ITERATED
7239 | OPTI_TYPE_PREPENDED_SALT
7240 | OPTI_TYPE_RAW_HASH;
7241 dgst_pos0 = 0;
7242 dgst_pos1 = 3;
7243 dgst_pos2 = 2;
7244 dgst_pos3 = 1;
7245 break;
7246
7247 case 50: hash_type = HASH_TYPE_MD5;
7248 salt_type = SALT_TYPE_INTERN;
7249 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7250 opts_type = OPTS_TYPE_PT_GENERATE_LE
7251 | OPTS_TYPE_ST_ADD80
7252 | OPTS_TYPE_ST_ADDBITS14;
7253 kern_type = KERN_TYPE_HMACMD5_PW;
7254 dgst_size = DGST_SIZE_4_4;
7255 parse_func = hmacmd5_parse_hash;
7256 sort_by_digest = sort_by_digest_4_4;
7257 opti_type = OPTI_TYPE_ZERO_BYTE
7258 | OPTI_TYPE_NOT_ITERATED;
7259 dgst_pos0 = 0;
7260 dgst_pos1 = 3;
7261 dgst_pos2 = 2;
7262 dgst_pos3 = 1;
7263 break;
7264
7265 case 60: hash_type = HASH_TYPE_MD5;
7266 salt_type = SALT_TYPE_INTERN;
7267 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7268 opts_type = OPTS_TYPE_PT_GENERATE_LE
7269 | OPTS_TYPE_PT_ADD80
7270 | OPTS_TYPE_PT_ADDBITS14;
7271 kern_type = KERN_TYPE_HMACMD5_SLT;
7272 dgst_size = DGST_SIZE_4_4;
7273 parse_func = hmacmd5_parse_hash;
7274 sort_by_digest = sort_by_digest_4_4;
7275 opti_type = OPTI_TYPE_ZERO_BYTE
7276 | OPTI_TYPE_NOT_ITERATED;
7277 dgst_pos0 = 0;
7278 dgst_pos1 = 3;
7279 dgst_pos2 = 2;
7280 dgst_pos3 = 1;
7281 break;
7282
7283 case 100: hash_type = HASH_TYPE_SHA1;
7284 salt_type = SALT_TYPE_NONE;
7285 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7286 opts_type = OPTS_TYPE_PT_GENERATE_BE
7287 | OPTS_TYPE_PT_ADD80
7288 | OPTS_TYPE_PT_ADDBITS15;
7289 kern_type = KERN_TYPE_SHA1;
7290 dgst_size = DGST_SIZE_4_5;
7291 parse_func = sha1_parse_hash;
7292 sort_by_digest = sort_by_digest_4_5;
7293 opti_type = OPTI_TYPE_ZERO_BYTE
7294 | OPTI_TYPE_PRECOMPUTE_INIT
7295 | OPTI_TYPE_PRECOMPUTE_MERKLE
7296 | OPTI_TYPE_EARLY_SKIP
7297 | OPTI_TYPE_NOT_ITERATED
7298 | OPTI_TYPE_NOT_SALTED
7299 | OPTI_TYPE_RAW_HASH;
7300 dgst_pos0 = 3;
7301 dgst_pos1 = 4;
7302 dgst_pos2 = 2;
7303 dgst_pos3 = 1;
7304 break;
7305
7306 case 101: hash_type = HASH_TYPE_SHA1;
7307 salt_type = SALT_TYPE_NONE;
7308 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7309 opts_type = OPTS_TYPE_PT_GENERATE_BE
7310 | OPTS_TYPE_PT_ADD80
7311 | OPTS_TYPE_PT_ADDBITS15;
7312 kern_type = KERN_TYPE_SHA1;
7313 dgst_size = DGST_SIZE_4_5;
7314 parse_func = sha1b64_parse_hash;
7315 sort_by_digest = sort_by_digest_4_5;
7316 opti_type = OPTI_TYPE_ZERO_BYTE
7317 | OPTI_TYPE_PRECOMPUTE_INIT
7318 | OPTI_TYPE_PRECOMPUTE_MERKLE
7319 | OPTI_TYPE_EARLY_SKIP
7320 | OPTI_TYPE_NOT_ITERATED
7321 | OPTI_TYPE_NOT_SALTED
7322 | OPTI_TYPE_RAW_HASH;
7323 dgst_pos0 = 3;
7324 dgst_pos1 = 4;
7325 dgst_pos2 = 2;
7326 dgst_pos3 = 1;
7327 break;
7328
7329 case 110: hash_type = HASH_TYPE_SHA1;
7330 salt_type = SALT_TYPE_INTERN;
7331 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7332 opts_type = OPTS_TYPE_PT_GENERATE_BE
7333 | OPTS_TYPE_ST_ADD80
7334 | OPTS_TYPE_ST_ADDBITS15;
7335 kern_type = KERN_TYPE_SHA1_PWSLT;
7336 dgst_size = DGST_SIZE_4_5;
7337 parse_func = sha1s_parse_hash;
7338 sort_by_digest = sort_by_digest_4_5;
7339 opti_type = OPTI_TYPE_ZERO_BYTE
7340 | OPTI_TYPE_PRECOMPUTE_INIT
7341 | OPTI_TYPE_PRECOMPUTE_MERKLE
7342 | OPTI_TYPE_EARLY_SKIP
7343 | OPTI_TYPE_NOT_ITERATED
7344 | OPTI_TYPE_APPENDED_SALT
7345 | OPTI_TYPE_RAW_HASH;
7346 dgst_pos0 = 3;
7347 dgst_pos1 = 4;
7348 dgst_pos2 = 2;
7349 dgst_pos3 = 1;
7350 break;
7351
7352 case 111: hash_type = HASH_TYPE_SHA1;
7353 salt_type = SALT_TYPE_EMBEDDED;
7354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7355 opts_type = OPTS_TYPE_PT_GENERATE_BE
7356 | OPTS_TYPE_ST_ADD80
7357 | OPTS_TYPE_ST_ADDBITS15;
7358 kern_type = KERN_TYPE_SHA1_PWSLT;
7359 dgst_size = DGST_SIZE_4_5;
7360 parse_func = sha1b64s_parse_hash;
7361 sort_by_digest = sort_by_digest_4_5;
7362 opti_type = OPTI_TYPE_ZERO_BYTE
7363 | OPTI_TYPE_PRECOMPUTE_INIT
7364 | OPTI_TYPE_PRECOMPUTE_MERKLE
7365 | OPTI_TYPE_EARLY_SKIP
7366 | OPTI_TYPE_NOT_ITERATED
7367 | OPTI_TYPE_APPENDED_SALT
7368 | OPTI_TYPE_RAW_HASH;
7369 dgst_pos0 = 3;
7370 dgst_pos1 = 4;
7371 dgst_pos2 = 2;
7372 dgst_pos3 = 1;
7373 break;
7374
7375 case 112: hash_type = HASH_TYPE_SHA1;
7376 salt_type = SALT_TYPE_INTERN;
7377 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7378 opts_type = OPTS_TYPE_PT_GENERATE_BE
7379 | OPTS_TYPE_ST_ADD80
7380 | OPTS_TYPE_ST_ADDBITS15
7381 | OPTS_TYPE_ST_HEX;
7382 kern_type = KERN_TYPE_SHA1_PWSLT;
7383 dgst_size = DGST_SIZE_4_5;
7384 parse_func = oracles_parse_hash;
7385 sort_by_digest = sort_by_digest_4_5;
7386 opti_type = OPTI_TYPE_ZERO_BYTE
7387 | OPTI_TYPE_PRECOMPUTE_INIT
7388 | OPTI_TYPE_PRECOMPUTE_MERKLE
7389 | OPTI_TYPE_EARLY_SKIP
7390 | OPTI_TYPE_NOT_ITERATED
7391 | OPTI_TYPE_APPENDED_SALT
7392 | OPTI_TYPE_RAW_HASH;
7393 dgst_pos0 = 3;
7394 dgst_pos1 = 4;
7395 dgst_pos2 = 2;
7396 dgst_pos3 = 1;
7397 break;
7398
7399 case 120: hash_type = HASH_TYPE_SHA1;
7400 salt_type = SALT_TYPE_INTERN;
7401 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7402 opts_type = OPTS_TYPE_PT_GENERATE_BE
7403 | OPTS_TYPE_PT_ADD80
7404 | OPTS_TYPE_PT_ADDBITS15;
7405 kern_type = KERN_TYPE_SHA1_SLTPW;
7406 dgst_size = DGST_SIZE_4_5;
7407 parse_func = sha1s_parse_hash;
7408 sort_by_digest = sort_by_digest_4_5;
7409 opti_type = OPTI_TYPE_ZERO_BYTE
7410 | OPTI_TYPE_PRECOMPUTE_INIT
7411 | OPTI_TYPE_PRECOMPUTE_MERKLE
7412 | OPTI_TYPE_EARLY_SKIP
7413 | OPTI_TYPE_NOT_ITERATED
7414 | OPTI_TYPE_PREPENDED_SALT
7415 | OPTI_TYPE_RAW_HASH;
7416 dgst_pos0 = 3;
7417 dgst_pos1 = 4;
7418 dgst_pos2 = 2;
7419 dgst_pos3 = 1;
7420 break;
7421
7422 case 121: hash_type = HASH_TYPE_SHA1;
7423 salt_type = SALT_TYPE_INTERN;
7424 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7425 opts_type = OPTS_TYPE_PT_GENERATE_BE
7426 | OPTS_TYPE_PT_ADD80
7427 | OPTS_TYPE_PT_ADDBITS15
7428 | OPTS_TYPE_ST_LOWER;
7429 kern_type = KERN_TYPE_SHA1_SLTPW;
7430 dgst_size = DGST_SIZE_4_5;
7431 parse_func = smf_parse_hash;
7432 sort_by_digest = sort_by_digest_4_5;
7433 opti_type = OPTI_TYPE_ZERO_BYTE
7434 | OPTI_TYPE_PRECOMPUTE_INIT
7435 | OPTI_TYPE_PRECOMPUTE_MERKLE
7436 | OPTI_TYPE_EARLY_SKIP
7437 | OPTI_TYPE_NOT_ITERATED
7438 | OPTI_TYPE_PREPENDED_SALT
7439 | OPTI_TYPE_RAW_HASH;
7440 dgst_pos0 = 3;
7441 dgst_pos1 = 4;
7442 dgst_pos2 = 2;
7443 dgst_pos3 = 1;
7444 break;
7445
7446 case 122: hash_type = HASH_TYPE_SHA1;
7447 salt_type = SALT_TYPE_EMBEDDED;
7448 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7449 opts_type = OPTS_TYPE_PT_GENERATE_BE
7450 | OPTS_TYPE_PT_ADD80
7451 | OPTS_TYPE_PT_ADDBITS15
7452 | OPTS_TYPE_ST_HEX;
7453 kern_type = KERN_TYPE_SHA1_SLTPW;
7454 dgst_size = DGST_SIZE_4_5;
7455 parse_func = osx1_parse_hash;
7456 sort_by_digest = sort_by_digest_4_5;
7457 opti_type = OPTI_TYPE_ZERO_BYTE
7458 | OPTI_TYPE_PRECOMPUTE_INIT
7459 | OPTI_TYPE_PRECOMPUTE_MERKLE
7460 | OPTI_TYPE_EARLY_SKIP
7461 | OPTI_TYPE_NOT_ITERATED
7462 | OPTI_TYPE_PREPENDED_SALT
7463 | OPTI_TYPE_RAW_HASH;
7464 dgst_pos0 = 3;
7465 dgst_pos1 = 4;
7466 dgst_pos2 = 2;
7467 dgst_pos3 = 1;
7468 break;
7469
7470 case 124: hash_type = HASH_TYPE_SHA1;
7471 salt_type = SALT_TYPE_EMBEDDED;
7472 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7473 opts_type = OPTS_TYPE_PT_GENERATE_BE
7474 | OPTS_TYPE_PT_ADD80
7475 | OPTS_TYPE_PT_ADDBITS15;
7476 kern_type = KERN_TYPE_SHA1_SLTPW;
7477 dgst_size = DGST_SIZE_4_5;
7478 parse_func = djangosha1_parse_hash;
7479 sort_by_digest = sort_by_digest_4_5;
7480 opti_type = OPTI_TYPE_ZERO_BYTE
7481 | OPTI_TYPE_PRECOMPUTE_INIT
7482 | OPTI_TYPE_PRECOMPUTE_MERKLE
7483 | OPTI_TYPE_EARLY_SKIP
7484 | OPTI_TYPE_NOT_ITERATED
7485 | OPTI_TYPE_PREPENDED_SALT
7486 | OPTI_TYPE_RAW_HASH;
7487 dgst_pos0 = 3;
7488 dgst_pos1 = 4;
7489 dgst_pos2 = 2;
7490 dgst_pos3 = 1;
7491 break;
7492
7493 case 130: hash_type = HASH_TYPE_SHA1;
7494 salt_type = SALT_TYPE_INTERN;
7495 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7496 opts_type = OPTS_TYPE_PT_GENERATE_BE
7497 | OPTS_TYPE_PT_UNICODE
7498 | OPTS_TYPE_ST_ADD80
7499 | OPTS_TYPE_ST_ADDBITS15;
7500 kern_type = KERN_TYPE_SHA1_PWUSLT;
7501 dgst_size = DGST_SIZE_4_5;
7502 parse_func = sha1s_parse_hash;
7503 sort_by_digest = sort_by_digest_4_5;
7504 opti_type = OPTI_TYPE_ZERO_BYTE
7505 | OPTI_TYPE_PRECOMPUTE_INIT
7506 | OPTI_TYPE_PRECOMPUTE_MERKLE
7507 | OPTI_TYPE_EARLY_SKIP
7508 | OPTI_TYPE_NOT_ITERATED
7509 | OPTI_TYPE_APPENDED_SALT
7510 | OPTI_TYPE_RAW_HASH;
7511 dgst_pos0 = 3;
7512 dgst_pos1 = 4;
7513 dgst_pos2 = 2;
7514 dgst_pos3 = 1;
7515 break;
7516
7517 case 131: hash_type = HASH_TYPE_SHA1;
7518 salt_type = SALT_TYPE_EMBEDDED;
7519 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7520 opts_type = OPTS_TYPE_PT_GENERATE_BE
7521 | OPTS_TYPE_PT_UNICODE
7522 | OPTS_TYPE_PT_UPPER
7523 | OPTS_TYPE_ST_ADD80
7524 | OPTS_TYPE_ST_ADDBITS15
7525 | OPTS_TYPE_ST_HEX;
7526 kern_type = KERN_TYPE_SHA1_PWUSLT;
7527 dgst_size = DGST_SIZE_4_5;
7528 parse_func = mssql2000_parse_hash;
7529 sort_by_digest = sort_by_digest_4_5;
7530 opti_type = OPTI_TYPE_ZERO_BYTE
7531 | OPTI_TYPE_PRECOMPUTE_INIT
7532 | OPTI_TYPE_PRECOMPUTE_MERKLE
7533 | OPTI_TYPE_EARLY_SKIP
7534 | OPTI_TYPE_NOT_ITERATED
7535 | OPTI_TYPE_APPENDED_SALT
7536 | OPTI_TYPE_RAW_HASH;
7537 dgst_pos0 = 3;
7538 dgst_pos1 = 4;
7539 dgst_pos2 = 2;
7540 dgst_pos3 = 1;
7541 break;
7542
7543 case 132: hash_type = HASH_TYPE_SHA1;
7544 salt_type = SALT_TYPE_EMBEDDED;
7545 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7546 opts_type = OPTS_TYPE_PT_GENERATE_BE
7547 | OPTS_TYPE_PT_UNICODE
7548 | OPTS_TYPE_ST_ADD80
7549 | OPTS_TYPE_ST_ADDBITS15
7550 | OPTS_TYPE_ST_HEX;
7551 kern_type = KERN_TYPE_SHA1_PWUSLT;
7552 dgst_size = DGST_SIZE_4_5;
7553 parse_func = mssql2005_parse_hash;
7554 sort_by_digest = sort_by_digest_4_5;
7555 opti_type = OPTI_TYPE_ZERO_BYTE
7556 | OPTI_TYPE_PRECOMPUTE_INIT
7557 | OPTI_TYPE_PRECOMPUTE_MERKLE
7558 | OPTI_TYPE_EARLY_SKIP
7559 | OPTI_TYPE_NOT_ITERATED
7560 | OPTI_TYPE_APPENDED_SALT
7561 | OPTI_TYPE_RAW_HASH;
7562 dgst_pos0 = 3;
7563 dgst_pos1 = 4;
7564 dgst_pos2 = 2;
7565 dgst_pos3 = 1;
7566 break;
7567
7568 case 133: hash_type = HASH_TYPE_SHA1;
7569 salt_type = SALT_TYPE_EMBEDDED;
7570 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7571 opts_type = OPTS_TYPE_PT_GENERATE_BE
7572 | OPTS_TYPE_PT_UNICODE
7573 | OPTS_TYPE_ST_ADD80
7574 | OPTS_TYPE_ST_ADDBITS15;
7575 kern_type = KERN_TYPE_SHA1_PWUSLT;
7576 dgst_size = DGST_SIZE_4_5;
7577 parse_func = peoplesoft_parse_hash;
7578 sort_by_digest = sort_by_digest_4_5;
7579 opti_type = OPTI_TYPE_ZERO_BYTE
7580 | OPTI_TYPE_PRECOMPUTE_INIT
7581 | OPTI_TYPE_PRECOMPUTE_MERKLE
7582 | OPTI_TYPE_EARLY_SKIP
7583 | OPTI_TYPE_NOT_ITERATED
7584 | OPTI_TYPE_APPENDED_SALT
7585 | OPTI_TYPE_RAW_HASH;
7586 dgst_pos0 = 3;
7587 dgst_pos1 = 4;
7588 dgst_pos2 = 2;
7589 dgst_pos3 = 1;
7590 break;
7591
7592 case 140: hash_type = HASH_TYPE_SHA1;
7593 salt_type = SALT_TYPE_INTERN;
7594 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7595 opts_type = OPTS_TYPE_PT_GENERATE_BE
7596 | OPTS_TYPE_PT_ADD80
7597 | OPTS_TYPE_PT_ADDBITS15
7598 | OPTS_TYPE_PT_UNICODE;
7599 kern_type = KERN_TYPE_SHA1_SLTPWU;
7600 dgst_size = DGST_SIZE_4_5;
7601 parse_func = sha1s_parse_hash;
7602 sort_by_digest = sort_by_digest_4_5;
7603 opti_type = OPTI_TYPE_ZERO_BYTE
7604 | OPTI_TYPE_PRECOMPUTE_INIT
7605 | OPTI_TYPE_PRECOMPUTE_MERKLE
7606 | OPTI_TYPE_EARLY_SKIP
7607 | OPTI_TYPE_NOT_ITERATED
7608 | OPTI_TYPE_PREPENDED_SALT
7609 | OPTI_TYPE_RAW_HASH;
7610 dgst_pos0 = 3;
7611 dgst_pos1 = 4;
7612 dgst_pos2 = 2;
7613 dgst_pos3 = 1;
7614 break;
7615
7616 case 141: hash_type = HASH_TYPE_SHA1;
7617 salt_type = SALT_TYPE_EMBEDDED;
7618 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7619 opts_type = OPTS_TYPE_PT_GENERATE_BE
7620 | OPTS_TYPE_PT_ADD80
7621 | OPTS_TYPE_PT_ADDBITS15
7622 | OPTS_TYPE_PT_UNICODE
7623 | OPTS_TYPE_ST_BASE64;
7624 kern_type = KERN_TYPE_SHA1_SLTPWU;
7625 dgst_size = DGST_SIZE_4_5;
7626 parse_func = episerver_parse_hash;
7627 sort_by_digest = sort_by_digest_4_5;
7628 opti_type = OPTI_TYPE_ZERO_BYTE
7629 | OPTI_TYPE_PRECOMPUTE_INIT
7630 | OPTI_TYPE_PRECOMPUTE_MERKLE
7631 | OPTI_TYPE_EARLY_SKIP
7632 | OPTI_TYPE_NOT_ITERATED
7633 | OPTI_TYPE_PREPENDED_SALT
7634 | OPTI_TYPE_RAW_HASH;
7635 dgst_pos0 = 3;
7636 dgst_pos1 = 4;
7637 dgst_pos2 = 2;
7638 dgst_pos3 = 1;
7639 break;
7640
7641 case 150: hash_type = HASH_TYPE_SHA1;
7642 salt_type = SALT_TYPE_INTERN;
7643 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7644 opts_type = OPTS_TYPE_PT_GENERATE_BE
7645 | OPTS_TYPE_ST_ADD80
7646 | OPTS_TYPE_ST_ADDBITS15;
7647 kern_type = KERN_TYPE_HMACSHA1_PW;
7648 dgst_size = DGST_SIZE_4_5;
7649 parse_func = hmacsha1_parse_hash;
7650 sort_by_digest = sort_by_digest_4_5;
7651 opti_type = OPTI_TYPE_ZERO_BYTE
7652 | OPTI_TYPE_NOT_ITERATED;
7653 dgst_pos0 = 3;
7654 dgst_pos1 = 4;
7655 dgst_pos2 = 2;
7656 dgst_pos3 = 1;
7657 break;
7658
7659 case 160: hash_type = HASH_TYPE_SHA1;
7660 salt_type = SALT_TYPE_INTERN;
7661 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7662 opts_type = OPTS_TYPE_PT_GENERATE_BE
7663 | OPTS_TYPE_PT_ADD80
7664 | OPTS_TYPE_PT_ADDBITS15;
7665 kern_type = KERN_TYPE_HMACSHA1_SLT;
7666 dgst_size = DGST_SIZE_4_5;
7667 parse_func = hmacsha1_parse_hash;
7668 sort_by_digest = sort_by_digest_4_5;
7669 opti_type = OPTI_TYPE_ZERO_BYTE
7670 | OPTI_TYPE_NOT_ITERATED;
7671 dgst_pos0 = 3;
7672 dgst_pos1 = 4;
7673 dgst_pos2 = 2;
7674 dgst_pos3 = 1;
7675 break;
7676
7677 case 190: hash_type = HASH_TYPE_SHA1;
7678 salt_type = SALT_TYPE_NONE;
7679 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7680 opts_type = OPTS_TYPE_PT_GENERATE_BE
7681 | OPTS_TYPE_PT_ADD80
7682 | OPTS_TYPE_PT_ADDBITS15;
7683 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7684 dgst_size = DGST_SIZE_4_5;
7685 parse_func = sha1linkedin_parse_hash;
7686 sort_by_digest = sort_by_digest_4_5;
7687 opti_type = OPTI_TYPE_ZERO_BYTE
7688 | OPTI_TYPE_PRECOMPUTE_INIT
7689 | OPTI_TYPE_EARLY_SKIP
7690 | OPTI_TYPE_NOT_ITERATED
7691 | OPTI_TYPE_NOT_SALTED;
7692 dgst_pos0 = 0;
7693 dgst_pos1 = 4;
7694 dgst_pos2 = 3;
7695 dgst_pos3 = 2;
7696 break;
7697
7698 case 200: hash_type = HASH_TYPE_MYSQL;
7699 salt_type = SALT_TYPE_NONE;
7700 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7701 opts_type = 0;
7702 kern_type = KERN_TYPE_MYSQL;
7703 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7704 parse_func = mysql323_parse_hash;
7705 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7706 opti_type = OPTI_TYPE_ZERO_BYTE;
7707 dgst_pos0 = 0;
7708 dgst_pos1 = 1;
7709 dgst_pos2 = 2;
7710 dgst_pos3 = 3;
7711 break;
7712
7713 case 300: hash_type = HASH_TYPE_SHA1;
7714 salt_type = SALT_TYPE_NONE;
7715 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7716 opts_type = OPTS_TYPE_PT_GENERATE_BE
7717 | OPTS_TYPE_PT_ADD80
7718 | OPTS_TYPE_PT_ADDBITS15;
7719 kern_type = KERN_TYPE_MYSQL41;
7720 dgst_size = DGST_SIZE_4_5;
7721 parse_func = sha1_parse_hash;
7722 sort_by_digest = sort_by_digest_4_5;
7723 opti_type = OPTI_TYPE_ZERO_BYTE
7724 | OPTI_TYPE_PRECOMPUTE_INIT
7725 | OPTI_TYPE_PRECOMPUTE_MERKLE
7726 | OPTI_TYPE_EARLY_SKIP
7727 | OPTI_TYPE_NOT_ITERATED
7728 | OPTI_TYPE_NOT_SALTED;
7729 dgst_pos0 = 3;
7730 dgst_pos1 = 4;
7731 dgst_pos2 = 2;
7732 dgst_pos3 = 1;
7733 break;
7734
7735 case 400: hash_type = HASH_TYPE_MD5;
7736 salt_type = SALT_TYPE_EMBEDDED;
7737 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7738 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7739 kern_type = KERN_TYPE_PHPASS;
7740 dgst_size = DGST_SIZE_4_4;
7741 parse_func = phpass_parse_hash;
7742 sort_by_digest = sort_by_digest_4_4;
7743 opti_type = OPTI_TYPE_ZERO_BYTE;
7744 dgst_pos0 = 0;
7745 dgst_pos1 = 1;
7746 dgst_pos2 = 2;
7747 dgst_pos3 = 3;
7748 break;
7749
7750 case 500: hash_type = HASH_TYPE_MD5;
7751 salt_type = SALT_TYPE_EMBEDDED;
7752 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7753 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7754 kern_type = KERN_TYPE_MD5CRYPT;
7755 dgst_size = DGST_SIZE_4_4;
7756 parse_func = md5crypt_parse_hash;
7757 sort_by_digest = sort_by_digest_4_4;
7758 opti_type = OPTI_TYPE_ZERO_BYTE;
7759 dgst_pos0 = 0;
7760 dgst_pos1 = 1;
7761 dgst_pos2 = 2;
7762 dgst_pos3 = 3;
7763 break;
7764
7765 case 501: hash_type = HASH_TYPE_MD5;
7766 salt_type = SALT_TYPE_EMBEDDED;
7767 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7768 opts_type = OPTS_TYPE_PT_GENERATE_LE
7769 | OPTS_TYPE_HASH_COPY;
7770 kern_type = KERN_TYPE_MD5CRYPT;
7771 dgst_size = DGST_SIZE_4_4;
7772 parse_func = juniper_parse_hash;
7773 sort_by_digest = sort_by_digest_4_4;
7774 opti_type = OPTI_TYPE_ZERO_BYTE;
7775 dgst_pos0 = 0;
7776 dgst_pos1 = 1;
7777 dgst_pos2 = 2;
7778 dgst_pos3 = 3;
7779 break;
7780
7781 case 900: hash_type = HASH_TYPE_MD4;
7782 salt_type = SALT_TYPE_NONE;
7783 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7784 opts_type = OPTS_TYPE_PT_GENERATE_LE
7785 | OPTS_TYPE_PT_ADD80
7786 | OPTS_TYPE_PT_ADDBITS14;
7787 kern_type = KERN_TYPE_MD4;
7788 dgst_size = DGST_SIZE_4_4;
7789 parse_func = md4_parse_hash;
7790 sort_by_digest = sort_by_digest_4_4;
7791 opti_type = OPTI_TYPE_ZERO_BYTE
7792 | OPTI_TYPE_PRECOMPUTE_INIT
7793 | OPTI_TYPE_PRECOMPUTE_MERKLE
7794 | OPTI_TYPE_MEET_IN_MIDDLE
7795 | OPTI_TYPE_EARLY_SKIP
7796 | OPTI_TYPE_NOT_ITERATED
7797 | OPTI_TYPE_NOT_SALTED
7798 | OPTI_TYPE_RAW_HASH;
7799 dgst_pos0 = 0;
7800 dgst_pos1 = 3;
7801 dgst_pos2 = 2;
7802 dgst_pos3 = 1;
7803 break;
7804
7805 case 1000: hash_type = HASH_TYPE_MD4;
7806 salt_type = SALT_TYPE_NONE;
7807 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7808 opts_type = OPTS_TYPE_PT_GENERATE_LE
7809 | OPTS_TYPE_PT_ADD80
7810 | OPTS_TYPE_PT_ADDBITS14
7811 | OPTS_TYPE_PT_UNICODE;
7812 kern_type = KERN_TYPE_MD4_PWU;
7813 dgst_size = DGST_SIZE_4_4;
7814 parse_func = md4_parse_hash;
7815 sort_by_digest = sort_by_digest_4_4;
7816 opti_type = OPTI_TYPE_ZERO_BYTE
7817 | OPTI_TYPE_PRECOMPUTE_INIT
7818 | OPTI_TYPE_PRECOMPUTE_MERKLE
7819 | OPTI_TYPE_MEET_IN_MIDDLE
7820 | OPTI_TYPE_EARLY_SKIP
7821 | OPTI_TYPE_NOT_ITERATED
7822 | OPTI_TYPE_NOT_SALTED
7823 | OPTI_TYPE_RAW_HASH;
7824 dgst_pos0 = 0;
7825 dgst_pos1 = 3;
7826 dgst_pos2 = 2;
7827 dgst_pos3 = 1;
7828 break;
7829
7830 case 1100: hash_type = HASH_TYPE_MD4;
7831 salt_type = SALT_TYPE_INTERN;
7832 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7833 opts_type = OPTS_TYPE_PT_GENERATE_LE
7834 | OPTS_TYPE_PT_ADD80
7835 | OPTS_TYPE_PT_ADDBITS14
7836 | OPTS_TYPE_PT_UNICODE
7837 | OPTS_TYPE_ST_ADD80
7838 | OPTS_TYPE_ST_UNICODE
7839 | OPTS_TYPE_ST_LOWER;
7840 kern_type = KERN_TYPE_MD44_PWUSLT;
7841 dgst_size = DGST_SIZE_4_4;
7842 parse_func = dcc_parse_hash;
7843 sort_by_digest = sort_by_digest_4_4;
7844 opti_type = OPTI_TYPE_ZERO_BYTE
7845 | OPTI_TYPE_PRECOMPUTE_INIT
7846 | OPTI_TYPE_PRECOMPUTE_MERKLE
7847 | OPTI_TYPE_EARLY_SKIP
7848 | OPTI_TYPE_NOT_ITERATED;
7849 dgst_pos0 = 0;
7850 dgst_pos1 = 3;
7851 dgst_pos2 = 2;
7852 dgst_pos3 = 1;
7853 break;
7854
7855 case 1400: hash_type = HASH_TYPE_SHA256;
7856 salt_type = SALT_TYPE_NONE;
7857 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7858 opts_type = OPTS_TYPE_PT_GENERATE_BE
7859 | OPTS_TYPE_PT_ADD80
7860 | OPTS_TYPE_PT_ADDBITS15;
7861 kern_type = KERN_TYPE_SHA256;
7862 dgst_size = DGST_SIZE_4_8;
7863 parse_func = sha256_parse_hash;
7864 sort_by_digest = sort_by_digest_4_8;
7865 opti_type = OPTI_TYPE_ZERO_BYTE
7866 | OPTI_TYPE_PRECOMPUTE_INIT
7867 | OPTI_TYPE_PRECOMPUTE_MERKLE
7868 | OPTI_TYPE_EARLY_SKIP
7869 | OPTI_TYPE_NOT_ITERATED
7870 | OPTI_TYPE_NOT_SALTED
7871 | OPTI_TYPE_RAW_HASH;
7872 dgst_pos0 = 3;
7873 dgst_pos1 = 7;
7874 dgst_pos2 = 2;
7875 dgst_pos3 = 6;
7876 break;
7877
7878 case 1410: hash_type = HASH_TYPE_SHA256;
7879 salt_type = SALT_TYPE_INTERN;
7880 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7881 opts_type = OPTS_TYPE_PT_GENERATE_BE
7882 | OPTS_TYPE_ST_ADD80
7883 | OPTS_TYPE_ST_ADDBITS15;
7884 kern_type = KERN_TYPE_SHA256_PWSLT;
7885 dgst_size = DGST_SIZE_4_8;
7886 parse_func = sha256s_parse_hash;
7887 sort_by_digest = sort_by_digest_4_8;
7888 opti_type = OPTI_TYPE_ZERO_BYTE
7889 | OPTI_TYPE_PRECOMPUTE_INIT
7890 | OPTI_TYPE_PRECOMPUTE_MERKLE
7891 | OPTI_TYPE_EARLY_SKIP
7892 | OPTI_TYPE_NOT_ITERATED
7893 | OPTI_TYPE_APPENDED_SALT
7894 | OPTI_TYPE_RAW_HASH;
7895 dgst_pos0 = 3;
7896 dgst_pos1 = 7;
7897 dgst_pos2 = 2;
7898 dgst_pos3 = 6;
7899 break;
7900
7901 case 1420: hash_type = HASH_TYPE_SHA256;
7902 salt_type = SALT_TYPE_INTERN;
7903 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7904 opts_type = OPTS_TYPE_PT_GENERATE_BE
7905 | OPTS_TYPE_PT_ADD80
7906 | OPTS_TYPE_PT_ADDBITS15;
7907 kern_type = KERN_TYPE_SHA256_SLTPW;
7908 dgst_size = DGST_SIZE_4_8;
7909 parse_func = sha256s_parse_hash;
7910 sort_by_digest = sort_by_digest_4_8;
7911 opti_type = OPTI_TYPE_ZERO_BYTE
7912 | OPTI_TYPE_PRECOMPUTE_INIT
7913 | OPTI_TYPE_PRECOMPUTE_MERKLE
7914 | OPTI_TYPE_EARLY_SKIP
7915 | OPTI_TYPE_NOT_ITERATED
7916 | OPTI_TYPE_PREPENDED_SALT
7917 | OPTI_TYPE_RAW_HASH;
7918 dgst_pos0 = 3;
7919 dgst_pos1 = 7;
7920 dgst_pos2 = 2;
7921 dgst_pos3 = 6;
7922 break;
7923
7924 case 1421: hash_type = HASH_TYPE_SHA256;
7925 salt_type = SALT_TYPE_EMBEDDED;
7926 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7927 opts_type = OPTS_TYPE_PT_GENERATE_BE
7928 | OPTS_TYPE_PT_ADD80
7929 | OPTS_TYPE_PT_ADDBITS15;
7930 kern_type = KERN_TYPE_SHA256_SLTPW;
7931 dgst_size = DGST_SIZE_4_8;
7932 parse_func = hmailserver_parse_hash;
7933 sort_by_digest = sort_by_digest_4_8;
7934 opti_type = OPTI_TYPE_ZERO_BYTE
7935 | OPTI_TYPE_PRECOMPUTE_INIT
7936 | OPTI_TYPE_PRECOMPUTE_MERKLE
7937 | OPTI_TYPE_EARLY_SKIP
7938 | OPTI_TYPE_NOT_ITERATED
7939 | OPTI_TYPE_PREPENDED_SALT
7940 | OPTI_TYPE_RAW_HASH;
7941 dgst_pos0 = 3;
7942 dgst_pos1 = 7;
7943 dgst_pos2 = 2;
7944 dgst_pos3 = 6;
7945 break;
7946
7947 case 1430: hash_type = HASH_TYPE_SHA256;
7948 salt_type = SALT_TYPE_INTERN;
7949 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7950 opts_type = OPTS_TYPE_PT_GENERATE_BE
7951 | OPTS_TYPE_PT_UNICODE
7952 | OPTS_TYPE_ST_ADD80
7953 | OPTS_TYPE_ST_ADDBITS15;
7954 kern_type = KERN_TYPE_SHA256_PWUSLT;
7955 dgst_size = DGST_SIZE_4_8;
7956 parse_func = sha256s_parse_hash;
7957 sort_by_digest = sort_by_digest_4_8;
7958 opti_type = OPTI_TYPE_ZERO_BYTE
7959 | OPTI_TYPE_PRECOMPUTE_INIT
7960 | OPTI_TYPE_PRECOMPUTE_MERKLE
7961 | OPTI_TYPE_EARLY_SKIP
7962 | OPTI_TYPE_NOT_ITERATED
7963 | OPTI_TYPE_APPENDED_SALT
7964 | OPTI_TYPE_RAW_HASH;
7965 dgst_pos0 = 3;
7966 dgst_pos1 = 7;
7967 dgst_pos2 = 2;
7968 dgst_pos3 = 6;
7969 break;
7970
7971 case 1440: hash_type = HASH_TYPE_SHA256;
7972 salt_type = SALT_TYPE_INTERN;
7973 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7974 opts_type = OPTS_TYPE_PT_GENERATE_BE
7975 | OPTS_TYPE_PT_ADD80
7976 | OPTS_TYPE_PT_ADDBITS15
7977 | OPTS_TYPE_PT_UNICODE;
7978 kern_type = KERN_TYPE_SHA256_SLTPWU;
7979 dgst_size = DGST_SIZE_4_8;
7980 parse_func = sha256s_parse_hash;
7981 sort_by_digest = sort_by_digest_4_8;
7982 opti_type = OPTI_TYPE_ZERO_BYTE
7983 | OPTI_TYPE_PRECOMPUTE_INIT
7984 | OPTI_TYPE_PRECOMPUTE_MERKLE
7985 | OPTI_TYPE_EARLY_SKIP
7986 | OPTI_TYPE_NOT_ITERATED
7987 | OPTI_TYPE_PREPENDED_SALT
7988 | OPTI_TYPE_RAW_HASH;
7989 dgst_pos0 = 3;
7990 dgst_pos1 = 7;
7991 dgst_pos2 = 2;
7992 dgst_pos3 = 6;
7993 break;
7994
7995 case 1441: hash_type = HASH_TYPE_SHA256;
7996 salt_type = SALT_TYPE_EMBEDDED;
7997 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7998 opts_type = OPTS_TYPE_PT_GENERATE_BE
7999 | OPTS_TYPE_PT_ADD80
8000 | OPTS_TYPE_PT_ADDBITS15
8001 | OPTS_TYPE_PT_UNICODE
8002 | OPTS_TYPE_ST_BASE64;
8003 kern_type = KERN_TYPE_SHA256_SLTPWU;
8004 dgst_size = DGST_SIZE_4_8;
8005 parse_func = episerver4_parse_hash;
8006 sort_by_digest = sort_by_digest_4_8;
8007 opti_type = OPTI_TYPE_ZERO_BYTE
8008 | OPTI_TYPE_PRECOMPUTE_INIT
8009 | OPTI_TYPE_PRECOMPUTE_MERKLE
8010 | OPTI_TYPE_EARLY_SKIP
8011 | OPTI_TYPE_NOT_ITERATED
8012 | OPTI_TYPE_PREPENDED_SALT
8013 | OPTI_TYPE_RAW_HASH;
8014 dgst_pos0 = 3;
8015 dgst_pos1 = 7;
8016 dgst_pos2 = 2;
8017 dgst_pos3 = 6;
8018 break;
8019
8020 case 1450: hash_type = HASH_TYPE_SHA256;
8021 salt_type = SALT_TYPE_INTERN;
8022 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8023 opts_type = OPTS_TYPE_PT_GENERATE_BE
8024 | OPTS_TYPE_ST_ADD80;
8025 kern_type = KERN_TYPE_HMACSHA256_PW;
8026 dgst_size = DGST_SIZE_4_8;
8027 parse_func = hmacsha256_parse_hash;
8028 sort_by_digest = sort_by_digest_4_8;
8029 opti_type = OPTI_TYPE_ZERO_BYTE
8030 | OPTI_TYPE_NOT_ITERATED;
8031 dgst_pos0 = 3;
8032 dgst_pos1 = 7;
8033 dgst_pos2 = 2;
8034 dgst_pos3 = 6;
8035 break;
8036
8037 case 1460: hash_type = HASH_TYPE_SHA256;
8038 salt_type = SALT_TYPE_INTERN;
8039 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8040 opts_type = OPTS_TYPE_PT_GENERATE_BE
8041 | OPTS_TYPE_PT_ADD80
8042 | OPTS_TYPE_PT_ADDBITS15;
8043 kern_type = KERN_TYPE_HMACSHA256_SLT;
8044 dgst_size = DGST_SIZE_4_8;
8045 parse_func = hmacsha256_parse_hash;
8046 sort_by_digest = sort_by_digest_4_8;
8047 opti_type = OPTI_TYPE_ZERO_BYTE
8048 | OPTI_TYPE_NOT_ITERATED;
8049 dgst_pos0 = 3;
8050 dgst_pos1 = 7;
8051 dgst_pos2 = 2;
8052 dgst_pos3 = 6;
8053 break;
8054
8055 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8056 salt_type = SALT_TYPE_EMBEDDED;
8057 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8058 opts_type = OPTS_TYPE_PT_GENERATE_LE
8059 | OPTS_TYPE_PT_BITSLICE;
8060 kern_type = KERN_TYPE_DESCRYPT;
8061 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8062 parse_func = descrypt_parse_hash;
8063 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8064 opti_type = OPTI_TYPE_ZERO_BYTE
8065 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8066 dgst_pos0 = 0;
8067 dgst_pos1 = 1;
8068 dgst_pos2 = 2;
8069 dgst_pos3 = 3;
8070 break;
8071
8072 case 1600: hash_type = HASH_TYPE_MD5;
8073 salt_type = SALT_TYPE_EMBEDDED;
8074 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8075 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8076 kern_type = KERN_TYPE_APR1CRYPT;
8077 dgst_size = DGST_SIZE_4_4;
8078 parse_func = md5apr1_parse_hash;
8079 sort_by_digest = sort_by_digest_4_4;
8080 opti_type = OPTI_TYPE_ZERO_BYTE;
8081 dgst_pos0 = 0;
8082 dgst_pos1 = 1;
8083 dgst_pos2 = 2;
8084 dgst_pos3 = 3;
8085 break;
8086
8087 case 1700: hash_type = HASH_TYPE_SHA512;
8088 salt_type = SALT_TYPE_NONE;
8089 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8090 opts_type = OPTS_TYPE_PT_GENERATE_BE
8091 | OPTS_TYPE_PT_ADD80
8092 | OPTS_TYPE_PT_ADDBITS15;
8093 kern_type = KERN_TYPE_SHA512;
8094 dgst_size = DGST_SIZE_8_8;
8095 parse_func = sha512_parse_hash;
8096 sort_by_digest = sort_by_digest_8_8;
8097 opti_type = OPTI_TYPE_ZERO_BYTE
8098 | OPTI_TYPE_PRECOMPUTE_INIT
8099 | OPTI_TYPE_PRECOMPUTE_MERKLE
8100 | OPTI_TYPE_EARLY_SKIP
8101 | OPTI_TYPE_NOT_ITERATED
8102 | OPTI_TYPE_NOT_SALTED
8103 | OPTI_TYPE_USES_BITS_64
8104 | OPTI_TYPE_RAW_HASH;
8105 dgst_pos0 = 14;
8106 dgst_pos1 = 15;
8107 dgst_pos2 = 6;
8108 dgst_pos3 = 7;
8109 break;
8110
8111 case 1710: hash_type = HASH_TYPE_SHA512;
8112 salt_type = SALT_TYPE_INTERN;
8113 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8114 opts_type = OPTS_TYPE_PT_GENERATE_BE
8115 | OPTS_TYPE_ST_ADD80
8116 | OPTS_TYPE_ST_ADDBITS15;
8117 kern_type = KERN_TYPE_SHA512_PWSLT;
8118 dgst_size = DGST_SIZE_8_8;
8119 parse_func = sha512s_parse_hash;
8120 sort_by_digest = sort_by_digest_8_8;
8121 opti_type = OPTI_TYPE_ZERO_BYTE
8122 | OPTI_TYPE_PRECOMPUTE_INIT
8123 | OPTI_TYPE_PRECOMPUTE_MERKLE
8124 | OPTI_TYPE_EARLY_SKIP
8125 | OPTI_TYPE_NOT_ITERATED
8126 | OPTI_TYPE_APPENDED_SALT
8127 | OPTI_TYPE_USES_BITS_64
8128 | OPTI_TYPE_RAW_HASH;
8129 dgst_pos0 = 14;
8130 dgst_pos1 = 15;
8131 dgst_pos2 = 6;
8132 dgst_pos3 = 7;
8133 break;
8134
8135 case 1711: hash_type = HASH_TYPE_SHA512;
8136 salt_type = SALT_TYPE_EMBEDDED;
8137 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8138 opts_type = OPTS_TYPE_PT_GENERATE_BE
8139 | OPTS_TYPE_ST_ADD80
8140 | OPTS_TYPE_ST_ADDBITS15;
8141 kern_type = KERN_TYPE_SHA512_PWSLT;
8142 dgst_size = DGST_SIZE_8_8;
8143 parse_func = sha512b64s_parse_hash;
8144 sort_by_digest = sort_by_digest_8_8;
8145 opti_type = OPTI_TYPE_ZERO_BYTE
8146 | OPTI_TYPE_PRECOMPUTE_INIT
8147 | OPTI_TYPE_PRECOMPUTE_MERKLE
8148 | OPTI_TYPE_EARLY_SKIP
8149 | OPTI_TYPE_NOT_ITERATED
8150 | OPTI_TYPE_APPENDED_SALT
8151 | OPTI_TYPE_USES_BITS_64
8152 | OPTI_TYPE_RAW_HASH;
8153 dgst_pos0 = 14;
8154 dgst_pos1 = 15;
8155 dgst_pos2 = 6;
8156 dgst_pos3 = 7;
8157 break;
8158
8159 case 1720: hash_type = HASH_TYPE_SHA512;
8160 salt_type = SALT_TYPE_INTERN;
8161 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8162 opts_type = OPTS_TYPE_PT_GENERATE_BE
8163 | OPTS_TYPE_PT_ADD80
8164 | OPTS_TYPE_PT_ADDBITS15;
8165 kern_type = KERN_TYPE_SHA512_SLTPW;
8166 dgst_size = DGST_SIZE_8_8;
8167 parse_func = sha512s_parse_hash;
8168 sort_by_digest = sort_by_digest_8_8;
8169 opti_type = OPTI_TYPE_ZERO_BYTE
8170 | OPTI_TYPE_PRECOMPUTE_INIT
8171 | OPTI_TYPE_PRECOMPUTE_MERKLE
8172 | OPTI_TYPE_EARLY_SKIP
8173 | OPTI_TYPE_NOT_ITERATED
8174 | OPTI_TYPE_PREPENDED_SALT
8175 | OPTI_TYPE_USES_BITS_64
8176 | OPTI_TYPE_RAW_HASH;
8177 dgst_pos0 = 14;
8178 dgst_pos1 = 15;
8179 dgst_pos2 = 6;
8180 dgst_pos3 = 7;
8181 break;
8182
8183 case 1722: hash_type = HASH_TYPE_SHA512;
8184 salt_type = SALT_TYPE_EMBEDDED;
8185 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8186 opts_type = OPTS_TYPE_PT_GENERATE_BE
8187 | OPTS_TYPE_PT_ADD80
8188 | OPTS_TYPE_PT_ADDBITS15
8189 | OPTS_TYPE_ST_HEX;
8190 kern_type = KERN_TYPE_SHA512_SLTPW;
8191 dgst_size = DGST_SIZE_8_8;
8192 parse_func = osx512_parse_hash;
8193 sort_by_digest = sort_by_digest_8_8;
8194 opti_type = OPTI_TYPE_ZERO_BYTE
8195 | OPTI_TYPE_PRECOMPUTE_INIT
8196 | OPTI_TYPE_PRECOMPUTE_MERKLE
8197 | OPTI_TYPE_EARLY_SKIP
8198 | OPTI_TYPE_NOT_ITERATED
8199 | OPTI_TYPE_PREPENDED_SALT
8200 | OPTI_TYPE_USES_BITS_64
8201 | OPTI_TYPE_RAW_HASH;
8202 dgst_pos0 = 14;
8203 dgst_pos1 = 15;
8204 dgst_pos2 = 6;
8205 dgst_pos3 = 7;
8206 break;
8207
8208 case 1730: hash_type = HASH_TYPE_SHA512;
8209 salt_type = SALT_TYPE_INTERN;
8210 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8211 opts_type = OPTS_TYPE_PT_GENERATE_BE
8212 | OPTS_TYPE_PT_UNICODE
8213 | OPTS_TYPE_ST_ADD80
8214 | OPTS_TYPE_ST_ADDBITS15;
8215 kern_type = KERN_TYPE_SHA512_PWSLTU;
8216 dgst_size = DGST_SIZE_8_8;
8217 parse_func = sha512s_parse_hash;
8218 sort_by_digest = sort_by_digest_8_8;
8219 opti_type = OPTI_TYPE_ZERO_BYTE
8220 | OPTI_TYPE_PRECOMPUTE_INIT
8221 | OPTI_TYPE_PRECOMPUTE_MERKLE
8222 | OPTI_TYPE_EARLY_SKIP
8223 | OPTI_TYPE_NOT_ITERATED
8224 | OPTI_TYPE_APPENDED_SALT
8225 | OPTI_TYPE_USES_BITS_64
8226 | OPTI_TYPE_RAW_HASH;
8227 dgst_pos0 = 14;
8228 dgst_pos1 = 15;
8229 dgst_pos2 = 6;
8230 dgst_pos3 = 7;
8231 break;
8232
8233 case 1731: hash_type = HASH_TYPE_SHA512;
8234 salt_type = SALT_TYPE_EMBEDDED;
8235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8236 opts_type = OPTS_TYPE_PT_GENERATE_BE
8237 | OPTS_TYPE_PT_UNICODE
8238 | OPTS_TYPE_ST_ADD80
8239 | OPTS_TYPE_ST_ADDBITS15
8240 | OPTS_TYPE_ST_HEX;
8241 kern_type = KERN_TYPE_SHA512_PWSLTU;
8242 dgst_size = DGST_SIZE_8_8;
8243 parse_func = mssql2012_parse_hash;
8244 sort_by_digest = sort_by_digest_8_8;
8245 opti_type = OPTI_TYPE_ZERO_BYTE
8246 | OPTI_TYPE_PRECOMPUTE_INIT
8247 | OPTI_TYPE_PRECOMPUTE_MERKLE
8248 | OPTI_TYPE_EARLY_SKIP
8249 | OPTI_TYPE_NOT_ITERATED
8250 | OPTI_TYPE_APPENDED_SALT
8251 | OPTI_TYPE_USES_BITS_64
8252 | OPTI_TYPE_RAW_HASH;
8253 dgst_pos0 = 14;
8254 dgst_pos1 = 15;
8255 dgst_pos2 = 6;
8256 dgst_pos3 = 7;
8257 break;
8258
8259 case 1740: hash_type = HASH_TYPE_SHA512;
8260 salt_type = SALT_TYPE_INTERN;
8261 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8262 opts_type = OPTS_TYPE_PT_GENERATE_BE
8263 | OPTS_TYPE_PT_ADD80
8264 | OPTS_TYPE_PT_ADDBITS15
8265 | OPTS_TYPE_PT_UNICODE;
8266 kern_type = KERN_TYPE_SHA512_SLTPWU;
8267 dgst_size = DGST_SIZE_8_8;
8268 parse_func = sha512s_parse_hash;
8269 sort_by_digest = sort_by_digest_8_8;
8270 opti_type = OPTI_TYPE_ZERO_BYTE
8271 | OPTI_TYPE_PRECOMPUTE_INIT
8272 | OPTI_TYPE_PRECOMPUTE_MERKLE
8273 | OPTI_TYPE_EARLY_SKIP
8274 | OPTI_TYPE_NOT_ITERATED
8275 | OPTI_TYPE_PREPENDED_SALT
8276 | OPTI_TYPE_USES_BITS_64
8277 | OPTI_TYPE_RAW_HASH;
8278 dgst_pos0 = 14;
8279 dgst_pos1 = 15;
8280 dgst_pos2 = 6;
8281 dgst_pos3 = 7;
8282 break;
8283
8284 case 1750: hash_type = HASH_TYPE_SHA512;
8285 salt_type = SALT_TYPE_INTERN;
8286 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8287 opts_type = OPTS_TYPE_PT_GENERATE_BE
8288 | OPTS_TYPE_ST_ADD80;
8289 kern_type = KERN_TYPE_HMACSHA512_PW;
8290 dgst_size = DGST_SIZE_8_8;
8291 parse_func = hmacsha512_parse_hash;
8292 sort_by_digest = sort_by_digest_8_8;
8293 opti_type = OPTI_TYPE_ZERO_BYTE
8294 | OPTI_TYPE_USES_BITS_64
8295 | OPTI_TYPE_NOT_ITERATED;
8296 dgst_pos0 = 14;
8297 dgst_pos1 = 15;
8298 dgst_pos2 = 6;
8299 dgst_pos3 = 7;
8300 break;
8301
8302 case 1760: hash_type = HASH_TYPE_SHA512;
8303 salt_type = SALT_TYPE_INTERN;
8304 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8305 opts_type = OPTS_TYPE_PT_GENERATE_BE
8306 | OPTS_TYPE_PT_ADD80
8307 | OPTS_TYPE_PT_ADDBITS15;
8308 kern_type = KERN_TYPE_HMACSHA512_SLT;
8309 dgst_size = DGST_SIZE_8_8;
8310 parse_func = hmacsha512_parse_hash;
8311 sort_by_digest = sort_by_digest_8_8;
8312 opti_type = OPTI_TYPE_ZERO_BYTE
8313 | OPTI_TYPE_USES_BITS_64
8314 | OPTI_TYPE_NOT_ITERATED;
8315 dgst_pos0 = 14;
8316 dgst_pos1 = 15;
8317 dgst_pos2 = 6;
8318 dgst_pos3 = 7;
8319 break;
8320
8321 case 1800: hash_type = HASH_TYPE_SHA512;
8322 salt_type = SALT_TYPE_EMBEDDED;
8323 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8324 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8325 kern_type = KERN_TYPE_SHA512CRYPT;
8326 dgst_size = DGST_SIZE_8_8;
8327 parse_func = sha512crypt_parse_hash;
8328 sort_by_digest = sort_by_digest_8_8;
8329 opti_type = OPTI_TYPE_ZERO_BYTE
8330 | OPTI_TYPE_USES_BITS_64;
8331 dgst_pos0 = 0;
8332 dgst_pos1 = 1;
8333 dgst_pos2 = 2;
8334 dgst_pos3 = 3;
8335 break;
8336
8337 case 2100: hash_type = HASH_TYPE_DCC2;
8338 salt_type = SALT_TYPE_EMBEDDED;
8339 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8340 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8341 | OPTS_TYPE_ST_LOWER
8342 | OPTS_TYPE_ST_UNICODE;
8343 kern_type = KERN_TYPE_DCC2;
8344 dgst_size = DGST_SIZE_4_4;
8345 parse_func = dcc2_parse_hash;
8346 sort_by_digest = sort_by_digest_4_4;
8347 opti_type = OPTI_TYPE_ZERO_BYTE;
8348 dgst_pos0 = 0;
8349 dgst_pos1 = 1;
8350 dgst_pos2 = 2;
8351 dgst_pos3 = 3;
8352 break;
8353
8354 case 2400: hash_type = HASH_TYPE_MD5;
8355 salt_type = SALT_TYPE_NONE;
8356 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8357 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8358 kern_type = KERN_TYPE_MD5PIX;
8359 dgst_size = DGST_SIZE_4_4;
8360 parse_func = md5pix_parse_hash;
8361 sort_by_digest = sort_by_digest_4_4;
8362 opti_type = OPTI_TYPE_ZERO_BYTE
8363 | OPTI_TYPE_PRECOMPUTE_INIT
8364 | OPTI_TYPE_PRECOMPUTE_MERKLE
8365 | OPTI_TYPE_EARLY_SKIP
8366 | OPTI_TYPE_NOT_ITERATED
8367 | OPTI_TYPE_NOT_SALTED;
8368 dgst_pos0 = 0;
8369 dgst_pos1 = 3;
8370 dgst_pos2 = 2;
8371 dgst_pos3 = 1;
8372 break;
8373
8374 case 2410: hash_type = HASH_TYPE_MD5;
8375 salt_type = SALT_TYPE_INTERN;
8376 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8377 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8378 kern_type = KERN_TYPE_MD5ASA;
8379 dgst_size = DGST_SIZE_4_4;
8380 parse_func = md5asa_parse_hash;
8381 sort_by_digest = sort_by_digest_4_4;
8382 opti_type = OPTI_TYPE_ZERO_BYTE
8383 | OPTI_TYPE_PRECOMPUTE_INIT
8384 | OPTI_TYPE_PRECOMPUTE_MERKLE
8385 | OPTI_TYPE_EARLY_SKIP
8386 | OPTI_TYPE_NOT_ITERATED;
8387 dgst_pos0 = 0;
8388 dgst_pos1 = 3;
8389 dgst_pos2 = 2;
8390 dgst_pos3 = 1;
8391 break;
8392
8393 case 2500: hash_type = HASH_TYPE_WPA;
8394 salt_type = SALT_TYPE_EMBEDDED;
8395 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8396 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8397 kern_type = KERN_TYPE_WPA;
8398 dgst_size = DGST_SIZE_4_4;
8399 parse_func = wpa_parse_hash;
8400 sort_by_digest = sort_by_digest_4_4;
8401 opti_type = OPTI_TYPE_ZERO_BYTE;
8402 dgst_pos0 = 0;
8403 dgst_pos1 = 1;
8404 dgst_pos2 = 2;
8405 dgst_pos3 = 3;
8406 break;
8407
8408 case 2600: hash_type = HASH_TYPE_MD5;
8409 salt_type = SALT_TYPE_VIRTUAL;
8410 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8411 opts_type = OPTS_TYPE_PT_GENERATE_LE
8412 | OPTS_TYPE_PT_ADD80
8413 | OPTS_TYPE_PT_ADDBITS14
8414 | OPTS_TYPE_ST_ADD80;
8415 kern_type = KERN_TYPE_MD55_PWSLT1;
8416 dgst_size = DGST_SIZE_4_4;
8417 parse_func = md5md5_parse_hash;
8418 sort_by_digest = sort_by_digest_4_4;
8419 opti_type = OPTI_TYPE_ZERO_BYTE
8420 | OPTI_TYPE_PRECOMPUTE_INIT
8421 | OPTI_TYPE_PRECOMPUTE_MERKLE
8422 | OPTI_TYPE_EARLY_SKIP;
8423 dgst_pos0 = 0;
8424 dgst_pos1 = 3;
8425 dgst_pos2 = 2;
8426 dgst_pos3 = 1;
8427 break;
8428
8429 case 2611: hash_type = HASH_TYPE_MD5;
8430 salt_type = SALT_TYPE_INTERN;
8431 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8432 opts_type = OPTS_TYPE_PT_GENERATE_LE
8433 | OPTS_TYPE_PT_ADD80
8434 | OPTS_TYPE_PT_ADDBITS14
8435 | OPTS_TYPE_ST_ADD80;
8436 kern_type = KERN_TYPE_MD55_PWSLT1;
8437 dgst_size = DGST_SIZE_4_4;
8438 parse_func = vb3_parse_hash;
8439 sort_by_digest = sort_by_digest_4_4;
8440 opti_type = OPTI_TYPE_ZERO_BYTE
8441 | OPTI_TYPE_PRECOMPUTE_INIT
8442 | OPTI_TYPE_PRECOMPUTE_MERKLE
8443 | OPTI_TYPE_EARLY_SKIP;
8444 dgst_pos0 = 0;
8445 dgst_pos1 = 3;
8446 dgst_pos2 = 2;
8447 dgst_pos3 = 1;
8448 break;
8449
8450 case 2612: hash_type = HASH_TYPE_MD5;
8451 salt_type = SALT_TYPE_EMBEDDED;
8452 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8453 opts_type = OPTS_TYPE_PT_GENERATE_LE
8454 | OPTS_TYPE_PT_ADD80
8455 | OPTS_TYPE_PT_ADDBITS14
8456 | OPTS_TYPE_ST_ADD80
8457 | OPTS_TYPE_ST_HEX;
8458 kern_type = KERN_TYPE_MD55_PWSLT1;
8459 dgst_size = DGST_SIZE_4_4;
8460 parse_func = phps_parse_hash;
8461 sort_by_digest = sort_by_digest_4_4;
8462 opti_type = OPTI_TYPE_ZERO_BYTE
8463 | OPTI_TYPE_PRECOMPUTE_INIT
8464 | OPTI_TYPE_PRECOMPUTE_MERKLE
8465 | OPTI_TYPE_EARLY_SKIP;
8466 dgst_pos0 = 0;
8467 dgst_pos1 = 3;
8468 dgst_pos2 = 2;
8469 dgst_pos3 = 1;
8470 break;
8471
8472 case 2711: hash_type = HASH_TYPE_MD5;
8473 salt_type = SALT_TYPE_INTERN;
8474 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8475 opts_type = OPTS_TYPE_PT_GENERATE_LE
8476 | OPTS_TYPE_PT_ADD80
8477 | OPTS_TYPE_PT_ADDBITS14
8478 | OPTS_TYPE_ST_ADD80;
8479 kern_type = KERN_TYPE_MD55_PWSLT2;
8480 dgst_size = DGST_SIZE_4_4;
8481 parse_func = vb30_parse_hash;
8482 sort_by_digest = sort_by_digest_4_4;
8483 opti_type = OPTI_TYPE_ZERO_BYTE
8484 | OPTI_TYPE_PRECOMPUTE_INIT
8485 | OPTI_TYPE_EARLY_SKIP;
8486 dgst_pos0 = 0;
8487 dgst_pos1 = 3;
8488 dgst_pos2 = 2;
8489 dgst_pos3 = 1;
8490 break;
8491
8492 case 2811: hash_type = HASH_TYPE_MD5;
8493 salt_type = SALT_TYPE_INTERN;
8494 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8495 opts_type = OPTS_TYPE_PT_GENERATE_LE
8496 | OPTS_TYPE_PT_ADD80
8497 | OPTS_TYPE_PT_ADDBITS14;
8498 kern_type = KERN_TYPE_MD55_SLTPW;
8499 dgst_size = DGST_SIZE_4_4;
8500 parse_func = ipb2_parse_hash;
8501 sort_by_digest = sort_by_digest_4_4;
8502 opti_type = OPTI_TYPE_ZERO_BYTE
8503 | OPTI_TYPE_PRECOMPUTE_INIT
8504 | OPTI_TYPE_EARLY_SKIP;
8505 dgst_pos0 = 0;
8506 dgst_pos1 = 3;
8507 dgst_pos2 = 2;
8508 dgst_pos3 = 1;
8509 break;
8510
8511 case 3000: hash_type = HASH_TYPE_LM;
8512 salt_type = SALT_TYPE_NONE;
8513 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8514 opts_type = OPTS_TYPE_PT_GENERATE_LE
8515 | OPTS_TYPE_PT_UPPER
8516 | OPTS_TYPE_PT_BITSLICE;
8517 kern_type = KERN_TYPE_LM;
8518 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8519 parse_func = lm_parse_hash;
8520 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8521 opti_type = OPTI_TYPE_ZERO_BYTE
8522 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8523 dgst_pos0 = 0;
8524 dgst_pos1 = 1;
8525 dgst_pos2 = 2;
8526 dgst_pos3 = 3;
8527 break;
8528
8529 case 3100: hash_type = HASH_TYPE_ORACLEH;
8530 salt_type = SALT_TYPE_INTERN;
8531 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8532 opts_type = OPTS_TYPE_PT_GENERATE_LE
8533 | OPTS_TYPE_PT_UPPER
8534 | OPTS_TYPE_ST_UPPER;
8535 kern_type = KERN_TYPE_ORACLEH;
8536 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8537 parse_func = oracleh_parse_hash;
8538 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8539 opti_type = OPTI_TYPE_ZERO_BYTE;
8540 dgst_pos0 = 0;
8541 dgst_pos1 = 1;
8542 dgst_pos2 = 2;
8543 dgst_pos3 = 3;
8544 break;
8545
8546 case 3200: hash_type = HASH_TYPE_BCRYPT;
8547 salt_type = SALT_TYPE_EMBEDDED;
8548 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8549 opts_type = OPTS_TYPE_PT_GENERATE_LE
8550 | OPTS_TYPE_ST_GENERATE_LE;
8551 kern_type = KERN_TYPE_BCRYPT;
8552 dgst_size = DGST_SIZE_4_6;
8553 parse_func = bcrypt_parse_hash;
8554 sort_by_digest = sort_by_digest_4_6;
8555 opti_type = OPTI_TYPE_ZERO_BYTE;
8556 dgst_pos0 = 0;
8557 dgst_pos1 = 1;
8558 dgst_pos2 = 2;
8559 dgst_pos3 = 3;
8560 break;
8561
8562 case 3710: hash_type = HASH_TYPE_MD5;
8563 salt_type = SALT_TYPE_INTERN;
8564 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8565 opts_type = OPTS_TYPE_PT_GENERATE_LE
8566 | OPTS_TYPE_PT_ADD80
8567 | OPTS_TYPE_PT_ADDBITS14;
8568 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8569 dgst_size = DGST_SIZE_4_4;
8570 parse_func = md5s_parse_hash;
8571 sort_by_digest = sort_by_digest_4_4;
8572 opti_type = OPTI_TYPE_ZERO_BYTE
8573 | OPTI_TYPE_PRECOMPUTE_INIT
8574 | OPTI_TYPE_PRECOMPUTE_MERKLE
8575 | OPTI_TYPE_EARLY_SKIP;
8576 dgst_pos0 = 0;
8577 dgst_pos1 = 3;
8578 dgst_pos2 = 2;
8579 dgst_pos3 = 1;
8580 break;
8581
8582 case 3711: hash_type = HASH_TYPE_MD5;
8583 salt_type = SALT_TYPE_EMBEDDED;
8584 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8585 opts_type = OPTS_TYPE_PT_GENERATE_LE
8586 | OPTS_TYPE_PT_ADD80
8587 | OPTS_TYPE_PT_ADDBITS14;
8588 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8589 dgst_size = DGST_SIZE_4_4;
8590 parse_func = mediawiki_b_parse_hash;
8591 sort_by_digest = sort_by_digest_4_4;
8592 opti_type = OPTI_TYPE_ZERO_BYTE
8593 | OPTI_TYPE_PRECOMPUTE_INIT
8594 | OPTI_TYPE_PRECOMPUTE_MERKLE
8595 | OPTI_TYPE_EARLY_SKIP;
8596 dgst_pos0 = 0;
8597 dgst_pos1 = 3;
8598 dgst_pos2 = 2;
8599 dgst_pos3 = 1;
8600 break;
8601
8602 case 3800: hash_type = HASH_TYPE_MD5;
8603 salt_type = SALT_TYPE_INTERN;
8604 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8605 opts_type = OPTS_TYPE_PT_GENERATE_LE
8606 | OPTS_TYPE_ST_ADDBITS14;
8607 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8608 dgst_size = DGST_SIZE_4_4;
8609 parse_func = md5s_parse_hash;
8610 sort_by_digest = sort_by_digest_4_4;
8611 opti_type = OPTI_TYPE_ZERO_BYTE
8612 | OPTI_TYPE_PRECOMPUTE_INIT
8613 | OPTI_TYPE_PRECOMPUTE_MERKLE
8614 | OPTI_TYPE_EARLY_SKIP
8615 | OPTI_TYPE_NOT_ITERATED
8616 | OPTI_TYPE_RAW_HASH;
8617 dgst_pos0 = 0;
8618 dgst_pos1 = 3;
8619 dgst_pos2 = 2;
8620 dgst_pos3 = 1;
8621 break;
8622
8623 case 4300: hash_type = HASH_TYPE_MD5;
8624 salt_type = SALT_TYPE_VIRTUAL;
8625 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8626 opts_type = OPTS_TYPE_PT_GENERATE_LE
8627 | OPTS_TYPE_PT_ADD80
8628 | OPTS_TYPE_PT_ADDBITS14
8629 | OPTS_TYPE_ST_ADD80;
8630 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8631 dgst_size = DGST_SIZE_4_4;
8632 parse_func = md5md5_parse_hash;
8633 sort_by_digest = sort_by_digest_4_4;
8634 opti_type = OPTI_TYPE_ZERO_BYTE
8635 | OPTI_TYPE_PRECOMPUTE_INIT
8636 | OPTI_TYPE_PRECOMPUTE_MERKLE
8637 | OPTI_TYPE_EARLY_SKIP;
8638 dgst_pos0 = 0;
8639 dgst_pos1 = 3;
8640 dgst_pos2 = 2;
8641 dgst_pos3 = 1;
8642 break;
8643
8644
8645 case 4400: hash_type = HASH_TYPE_MD5;
8646 salt_type = SALT_TYPE_NONE;
8647 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8648 opts_type = OPTS_TYPE_PT_GENERATE_BE
8649 | OPTS_TYPE_PT_ADD80
8650 | OPTS_TYPE_PT_ADDBITS15;
8651 kern_type = KERN_TYPE_MD5_SHA1;
8652 dgst_size = DGST_SIZE_4_4;
8653 parse_func = md5_parse_hash;
8654 sort_by_digest = sort_by_digest_4_4;
8655 opti_type = OPTI_TYPE_ZERO_BYTE
8656 | OPTI_TYPE_PRECOMPUTE_INIT
8657 | OPTI_TYPE_PRECOMPUTE_MERKLE
8658 | OPTI_TYPE_EARLY_SKIP
8659 | OPTI_TYPE_NOT_ITERATED
8660 | OPTI_TYPE_NOT_SALTED
8661 | OPTI_TYPE_RAW_HASH;
8662 dgst_pos0 = 0;
8663 dgst_pos1 = 3;
8664 dgst_pos2 = 2;
8665 dgst_pos3 = 1;
8666 break;
8667
8668 case 4500: hash_type = HASH_TYPE_SHA1;
8669 salt_type = SALT_TYPE_NONE;
8670 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8671 opts_type = OPTS_TYPE_PT_GENERATE_BE
8672 | OPTS_TYPE_PT_ADD80
8673 | OPTS_TYPE_PT_ADDBITS15;
8674 kern_type = KERN_TYPE_SHA11;
8675 dgst_size = DGST_SIZE_4_5;
8676 parse_func = sha1_parse_hash;
8677 sort_by_digest = sort_by_digest_4_5;
8678 opti_type = OPTI_TYPE_ZERO_BYTE
8679 | OPTI_TYPE_PRECOMPUTE_INIT
8680 | OPTI_TYPE_PRECOMPUTE_MERKLE
8681 | OPTI_TYPE_EARLY_SKIP
8682 | OPTI_TYPE_NOT_SALTED;
8683 dgst_pos0 = 3;
8684 dgst_pos1 = 4;
8685 dgst_pos2 = 2;
8686 dgst_pos3 = 1;
8687 break;
8688
8689 case 4700: hash_type = HASH_TYPE_SHA1;
8690 salt_type = SALT_TYPE_NONE;
8691 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8692 opts_type = OPTS_TYPE_PT_GENERATE_LE
8693 | OPTS_TYPE_PT_ADD80
8694 | OPTS_TYPE_PT_ADDBITS14;
8695 kern_type = KERN_TYPE_SHA1_MD5;
8696 dgst_size = DGST_SIZE_4_5;
8697 parse_func = sha1_parse_hash;
8698 sort_by_digest = sort_by_digest_4_5;
8699 opti_type = OPTI_TYPE_ZERO_BYTE
8700 | OPTI_TYPE_PRECOMPUTE_INIT
8701 | OPTI_TYPE_PRECOMPUTE_MERKLE
8702 | OPTI_TYPE_EARLY_SKIP
8703 | OPTI_TYPE_NOT_ITERATED
8704 | OPTI_TYPE_NOT_SALTED
8705 | OPTI_TYPE_RAW_HASH;
8706 dgst_pos0 = 3;
8707 dgst_pos1 = 4;
8708 dgst_pos2 = 2;
8709 dgst_pos3 = 1;
8710 break;
8711
8712 case 4800: hash_type = HASH_TYPE_MD5;
8713 salt_type = SALT_TYPE_EMBEDDED;
8714 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8715 opts_type = OPTS_TYPE_PT_GENERATE_LE
8716 | OPTS_TYPE_PT_ADDBITS14;
8717 kern_type = KERN_TYPE_MD5_CHAP;
8718 dgst_size = DGST_SIZE_4_4;
8719 parse_func = chap_parse_hash;
8720 sort_by_digest = sort_by_digest_4_4;
8721 opti_type = OPTI_TYPE_ZERO_BYTE
8722 | OPTI_TYPE_PRECOMPUTE_INIT
8723 | OPTI_TYPE_PRECOMPUTE_MERKLE
8724 | OPTI_TYPE_MEET_IN_MIDDLE
8725 | OPTI_TYPE_EARLY_SKIP
8726 | OPTI_TYPE_NOT_ITERATED
8727 | OPTI_TYPE_RAW_HASH;
8728 dgst_pos0 = 0;
8729 dgst_pos1 = 3;
8730 dgst_pos2 = 2;
8731 dgst_pos3 = 1;
8732 break;
8733
8734 case 4900: hash_type = HASH_TYPE_SHA1;
8735 salt_type = SALT_TYPE_INTERN;
8736 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8737 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8738 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8739 dgst_size = DGST_SIZE_4_5;
8740 parse_func = sha1s_parse_hash;
8741 sort_by_digest = sort_by_digest_4_5;
8742 opti_type = OPTI_TYPE_ZERO_BYTE
8743 | OPTI_TYPE_PRECOMPUTE_INIT
8744 | OPTI_TYPE_PRECOMPUTE_MERKLE
8745 | OPTI_TYPE_EARLY_SKIP;
8746 dgst_pos0 = 3;
8747 dgst_pos1 = 4;
8748 dgst_pos2 = 2;
8749 dgst_pos3 = 1;
8750 break;
8751
8752 case 5000: hash_type = HASH_TYPE_KECCAK;
8753 salt_type = SALT_TYPE_EMBEDDED;
8754 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8755 opts_type = OPTS_TYPE_PT_GENERATE_LE
8756 | OPTS_TYPE_PT_ADD01;
8757 kern_type = KERN_TYPE_KECCAK;
8758 dgst_size = DGST_SIZE_8_25;
8759 parse_func = keccak_parse_hash;
8760 sort_by_digest = sort_by_digest_8_25;
8761 opti_type = OPTI_TYPE_ZERO_BYTE
8762 | OPTI_TYPE_USES_BITS_64
8763 | OPTI_TYPE_RAW_HASH;
8764 dgst_pos0 = 2;
8765 dgst_pos1 = 3;
8766 dgst_pos2 = 4;
8767 dgst_pos3 = 5;
8768 break;
8769
8770 case 5100: hash_type = HASH_TYPE_MD5H;
8771 salt_type = SALT_TYPE_NONE;
8772 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8773 opts_type = OPTS_TYPE_PT_GENERATE_LE
8774 | OPTS_TYPE_PT_ADD80
8775 | OPTS_TYPE_PT_ADDBITS14;
8776 kern_type = KERN_TYPE_MD5H;
8777 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8778 parse_func = md5half_parse_hash;
8779 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8780 opti_type = OPTI_TYPE_ZERO_BYTE
8781 | OPTI_TYPE_RAW_HASH;
8782 dgst_pos0 = 0;
8783 dgst_pos1 = 1;
8784 dgst_pos2 = 2;
8785 dgst_pos3 = 3;
8786 break;
8787
8788 case 5200: hash_type = HASH_TYPE_SHA256;
8789 salt_type = SALT_TYPE_EMBEDDED;
8790 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8791 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8792 kern_type = KERN_TYPE_PSAFE3;
8793 dgst_size = DGST_SIZE_4_8;
8794 parse_func = psafe3_parse_hash;
8795 sort_by_digest = sort_by_digest_4_8;
8796 opti_type = OPTI_TYPE_ZERO_BYTE;
8797 dgst_pos0 = 0;
8798 dgst_pos1 = 1;
8799 dgst_pos2 = 2;
8800 dgst_pos3 = 3;
8801 break;
8802
8803 case 5300: hash_type = HASH_TYPE_MD5;
8804 salt_type = SALT_TYPE_EMBEDDED;
8805 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8806 opts_type = OPTS_TYPE_PT_GENERATE_LE
8807 | OPTS_TYPE_ST_ADD80;
8808 kern_type = KERN_TYPE_IKEPSK_MD5;
8809 dgst_size = DGST_SIZE_4_4;
8810 parse_func = ikepsk_md5_parse_hash;
8811 sort_by_digest = sort_by_digest_4_4;
8812 opti_type = OPTI_TYPE_ZERO_BYTE;
8813 dgst_pos0 = 0;
8814 dgst_pos1 = 3;
8815 dgst_pos2 = 2;
8816 dgst_pos3 = 1;
8817 break;
8818
8819 case 5400: hash_type = HASH_TYPE_SHA1;
8820 salt_type = SALT_TYPE_EMBEDDED;
8821 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8822 opts_type = OPTS_TYPE_PT_GENERATE_BE
8823 | OPTS_TYPE_ST_ADD80;
8824 kern_type = KERN_TYPE_IKEPSK_SHA1;
8825 dgst_size = DGST_SIZE_4_5;
8826 parse_func = ikepsk_sha1_parse_hash;
8827 sort_by_digest = sort_by_digest_4_5;
8828 opti_type = OPTI_TYPE_ZERO_BYTE;
8829 dgst_pos0 = 3;
8830 dgst_pos1 = 4;
8831 dgst_pos2 = 2;
8832 dgst_pos3 = 1;
8833 break;
8834
8835 case 5500: hash_type = HASH_TYPE_NETNTLM;
8836 salt_type = SALT_TYPE_EMBEDDED;
8837 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8838 opts_type = OPTS_TYPE_PT_GENERATE_LE
8839 | OPTS_TYPE_PT_ADD80
8840 | OPTS_TYPE_PT_ADDBITS14
8841 | OPTS_TYPE_PT_UNICODE
8842 | OPTS_TYPE_ST_HEX;
8843 kern_type = KERN_TYPE_NETNTLMv1;
8844 dgst_size = DGST_SIZE_4_4;
8845 parse_func = netntlmv1_parse_hash;
8846 sort_by_digest = sort_by_digest_4_4;
8847 opti_type = OPTI_TYPE_ZERO_BYTE
8848 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8849 dgst_pos0 = 0;
8850 dgst_pos1 = 1;
8851 dgst_pos2 = 2;
8852 dgst_pos3 = 3;
8853 break;
8854
8855 case 5600: hash_type = HASH_TYPE_MD5;
8856 salt_type = SALT_TYPE_EMBEDDED;
8857 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8858 opts_type = OPTS_TYPE_PT_GENERATE_LE
8859 | OPTS_TYPE_PT_ADD80
8860 | OPTS_TYPE_PT_ADDBITS14
8861 | OPTS_TYPE_PT_UNICODE;
8862 kern_type = KERN_TYPE_NETNTLMv2;
8863 dgst_size = DGST_SIZE_4_4;
8864 parse_func = netntlmv2_parse_hash;
8865 sort_by_digest = sort_by_digest_4_4;
8866 opti_type = OPTI_TYPE_ZERO_BYTE;
8867 dgst_pos0 = 0;
8868 dgst_pos1 = 3;
8869 dgst_pos2 = 2;
8870 dgst_pos3 = 1;
8871 break;
8872
8873 case 5700: hash_type = HASH_TYPE_SHA256;
8874 salt_type = SALT_TYPE_NONE;
8875 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8876 opts_type = OPTS_TYPE_PT_GENERATE_BE
8877 | OPTS_TYPE_PT_ADD80
8878 | OPTS_TYPE_PT_ADDBITS15;
8879 kern_type = KERN_TYPE_SHA256;
8880 dgst_size = DGST_SIZE_4_8;
8881 parse_func = cisco4_parse_hash;
8882 sort_by_digest = sort_by_digest_4_8;
8883 opti_type = OPTI_TYPE_ZERO_BYTE
8884 | OPTI_TYPE_PRECOMPUTE_INIT
8885 | OPTI_TYPE_PRECOMPUTE_MERKLE
8886 | OPTI_TYPE_EARLY_SKIP
8887 | OPTI_TYPE_NOT_ITERATED
8888 | OPTI_TYPE_NOT_SALTED
8889 | OPTI_TYPE_RAW_HASH;
8890 dgst_pos0 = 3;
8891 dgst_pos1 = 7;
8892 dgst_pos2 = 2;
8893 dgst_pos3 = 6;
8894 break;
8895
8896 case 5800: hash_type = HASH_TYPE_SHA1;
8897 salt_type = SALT_TYPE_INTERN;
8898 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8899 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8900 | OPTS_TYPE_ST_ADD80;
8901 kern_type = KERN_TYPE_ANDROIDPIN;
8902 dgst_size = DGST_SIZE_4_5;
8903 parse_func = androidpin_parse_hash;
8904 sort_by_digest = sort_by_digest_4_5;
8905 opti_type = OPTI_TYPE_ZERO_BYTE;
8906 dgst_pos0 = 0;
8907 dgst_pos1 = 1;
8908 dgst_pos2 = 2;
8909 dgst_pos3 = 3;
8910 break;
8911
8912 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8913 salt_type = SALT_TYPE_NONE;
8914 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8915 opts_type = OPTS_TYPE_PT_GENERATE_LE
8916 | OPTS_TYPE_PT_ADD80;
8917 kern_type = KERN_TYPE_RIPEMD160;
8918 dgst_size = DGST_SIZE_4_5;
8919 parse_func = ripemd160_parse_hash;
8920 sort_by_digest = sort_by_digest_4_5;
8921 opti_type = OPTI_TYPE_ZERO_BYTE;
8922 dgst_pos0 = 0;
8923 dgst_pos1 = 1;
8924 dgst_pos2 = 2;
8925 dgst_pos3 = 3;
8926 break;
8927
8928 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8929 salt_type = SALT_TYPE_NONE;
8930 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8931 opts_type = OPTS_TYPE_PT_GENERATE_BE
8932 | OPTS_TYPE_PT_ADD80;
8933 kern_type = KERN_TYPE_WHIRLPOOL;
8934 dgst_size = DGST_SIZE_4_16;
8935 parse_func = whirlpool_parse_hash;
8936 sort_by_digest = sort_by_digest_4_16;
8937 opti_type = OPTI_TYPE_ZERO_BYTE;
8938 dgst_pos0 = 0;
8939 dgst_pos1 = 1;
8940 dgst_pos2 = 2;
8941 dgst_pos3 = 3;
8942 break;
8943
8944 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8945 salt_type = SALT_TYPE_EMBEDDED;
8946 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8947 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8948 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8949 dgst_size = DGST_SIZE_4_5;
8950 parse_func = truecrypt_parse_hash_2k;
8951 sort_by_digest = sort_by_digest_4_5;
8952 opti_type = OPTI_TYPE_ZERO_BYTE;
8953 dgst_pos0 = 0;
8954 dgst_pos1 = 1;
8955 dgst_pos2 = 2;
8956 dgst_pos3 = 3;
8957 break;
8958
8959 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8960 salt_type = SALT_TYPE_EMBEDDED;
8961 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8962 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8963 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8964 dgst_size = DGST_SIZE_4_5;
8965 parse_func = truecrypt_parse_hash_2k;
8966 sort_by_digest = sort_by_digest_4_5;
8967 opti_type = OPTI_TYPE_ZERO_BYTE;
8968 dgst_pos0 = 0;
8969 dgst_pos1 = 1;
8970 dgst_pos2 = 2;
8971 dgst_pos3 = 3;
8972 break;
8973
8974 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8975 salt_type = SALT_TYPE_EMBEDDED;
8976 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8977 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8978 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8979 dgst_size = DGST_SIZE_4_5;
8980 parse_func = truecrypt_parse_hash_2k;
8981 sort_by_digest = sort_by_digest_4_5;
8982 opti_type = OPTI_TYPE_ZERO_BYTE;
8983 dgst_pos0 = 0;
8984 dgst_pos1 = 1;
8985 dgst_pos2 = 2;
8986 dgst_pos3 = 3;
8987 break;
8988
8989 case 6221: hash_type = HASH_TYPE_SHA512;
8990 salt_type = SALT_TYPE_EMBEDDED;
8991 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8992 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8993 kern_type = KERN_TYPE_TCSHA512_XTS512;
8994 dgst_size = DGST_SIZE_8_8;
8995 parse_func = truecrypt_parse_hash_1k;
8996 sort_by_digest = sort_by_digest_8_8;
8997 opti_type = OPTI_TYPE_ZERO_BYTE
8998 | OPTI_TYPE_USES_BITS_64;
8999 dgst_pos0 = 0;
9000 dgst_pos1 = 1;
9001 dgst_pos2 = 2;
9002 dgst_pos3 = 3;
9003 break;
9004
9005 case 6222: hash_type = HASH_TYPE_SHA512;
9006 salt_type = SALT_TYPE_EMBEDDED;
9007 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9008 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9009 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9010 dgst_size = DGST_SIZE_8_8;
9011 parse_func = truecrypt_parse_hash_1k;
9012 sort_by_digest = sort_by_digest_8_8;
9013 opti_type = OPTI_TYPE_ZERO_BYTE
9014 | OPTI_TYPE_USES_BITS_64;
9015 dgst_pos0 = 0;
9016 dgst_pos1 = 1;
9017 dgst_pos2 = 2;
9018 dgst_pos3 = 3;
9019 break;
9020
9021 case 6223: hash_type = HASH_TYPE_SHA512;
9022 salt_type = SALT_TYPE_EMBEDDED;
9023 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9024 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9025 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9026 dgst_size = DGST_SIZE_8_8;
9027 parse_func = truecrypt_parse_hash_1k;
9028 sort_by_digest = sort_by_digest_8_8;
9029 opti_type = OPTI_TYPE_ZERO_BYTE
9030 | OPTI_TYPE_USES_BITS_64;
9031 dgst_pos0 = 0;
9032 dgst_pos1 = 1;
9033 dgst_pos2 = 2;
9034 dgst_pos3 = 3;
9035 break;
9036
9037 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9038 salt_type = SALT_TYPE_EMBEDDED;
9039 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9040 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9041 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9042 dgst_size = DGST_SIZE_4_8;
9043 parse_func = truecrypt_parse_hash_1k;
9044 sort_by_digest = sort_by_digest_4_8;
9045 opti_type = OPTI_TYPE_ZERO_BYTE;
9046 dgst_pos0 = 0;
9047 dgst_pos1 = 1;
9048 dgst_pos2 = 2;
9049 dgst_pos3 = 3;
9050 break;
9051
9052 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9053 salt_type = SALT_TYPE_EMBEDDED;
9054 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9055 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9056 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9057 dgst_size = DGST_SIZE_4_8;
9058 parse_func = truecrypt_parse_hash_1k;
9059 sort_by_digest = sort_by_digest_4_8;
9060 opti_type = OPTI_TYPE_ZERO_BYTE;
9061 dgst_pos0 = 0;
9062 dgst_pos1 = 1;
9063 dgst_pos2 = 2;
9064 dgst_pos3 = 3;
9065 break;
9066
9067 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9068 salt_type = SALT_TYPE_EMBEDDED;
9069 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9070 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9071 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9072 dgst_size = DGST_SIZE_4_8;
9073 parse_func = truecrypt_parse_hash_1k;
9074 sort_by_digest = sort_by_digest_4_8;
9075 opti_type = OPTI_TYPE_ZERO_BYTE;
9076 dgst_pos0 = 0;
9077 dgst_pos1 = 1;
9078 dgst_pos2 = 2;
9079 dgst_pos3 = 3;
9080 break;
9081
9082 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9083 salt_type = SALT_TYPE_EMBEDDED;
9084 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9085 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9086 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9087 dgst_size = DGST_SIZE_4_5;
9088 parse_func = truecrypt_parse_hash_1k;
9089 sort_by_digest = sort_by_digest_4_5;
9090 opti_type = OPTI_TYPE_ZERO_BYTE;
9091 dgst_pos0 = 0;
9092 dgst_pos1 = 1;
9093 dgst_pos2 = 2;
9094 dgst_pos3 = 3;
9095 break;
9096
9097 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9098 salt_type = SALT_TYPE_EMBEDDED;
9099 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9100 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9101 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9102 dgst_size = DGST_SIZE_4_5;
9103 parse_func = truecrypt_parse_hash_1k;
9104 sort_by_digest = sort_by_digest_4_5;
9105 opti_type = OPTI_TYPE_ZERO_BYTE;
9106 dgst_pos0 = 0;
9107 dgst_pos1 = 1;
9108 dgst_pos2 = 2;
9109 dgst_pos3 = 3;
9110 break;
9111
9112 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9113 salt_type = SALT_TYPE_EMBEDDED;
9114 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9115 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9116 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9117 dgst_size = DGST_SIZE_4_5;
9118 parse_func = truecrypt_parse_hash_1k;
9119 sort_by_digest = sort_by_digest_4_5;
9120 opti_type = OPTI_TYPE_ZERO_BYTE;
9121 dgst_pos0 = 0;
9122 dgst_pos1 = 1;
9123 dgst_pos2 = 2;
9124 dgst_pos3 = 3;
9125 break;
9126
9127 case 6300: hash_type = HASH_TYPE_MD5;
9128 salt_type = SALT_TYPE_EMBEDDED;
9129 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9130 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9131 kern_type = KERN_TYPE_MD5AIX;
9132 dgst_size = DGST_SIZE_4_4;
9133 parse_func = md5aix_parse_hash;
9134 sort_by_digest = sort_by_digest_4_4;
9135 opti_type = OPTI_TYPE_ZERO_BYTE;
9136 dgst_pos0 = 0;
9137 dgst_pos1 = 1;
9138 dgst_pos2 = 2;
9139 dgst_pos3 = 3;
9140 break;
9141
9142 case 6400: hash_type = HASH_TYPE_SHA256;
9143 salt_type = SALT_TYPE_EMBEDDED;
9144 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9145 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9146 kern_type = KERN_TYPE_SHA256AIX;
9147 dgst_size = DGST_SIZE_4_8;
9148 parse_func = sha256aix_parse_hash;
9149 sort_by_digest = sort_by_digest_4_8;
9150 opti_type = OPTI_TYPE_ZERO_BYTE;
9151 dgst_pos0 = 0;
9152 dgst_pos1 = 1;
9153 dgst_pos2 = 2;
9154 dgst_pos3 = 3;
9155 break;
9156
9157 case 6500: hash_type = HASH_TYPE_SHA512;
9158 salt_type = SALT_TYPE_EMBEDDED;
9159 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9160 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9161 kern_type = KERN_TYPE_SHA512AIX;
9162 dgst_size = DGST_SIZE_8_8;
9163 parse_func = sha512aix_parse_hash;
9164 sort_by_digest = sort_by_digest_8_8;
9165 opti_type = OPTI_TYPE_ZERO_BYTE
9166 | OPTI_TYPE_USES_BITS_64;
9167 dgst_pos0 = 0;
9168 dgst_pos1 = 1;
9169 dgst_pos2 = 2;
9170 dgst_pos3 = 3;
9171 break;
9172
9173 case 6600: hash_type = HASH_TYPE_AES;
9174 salt_type = SALT_TYPE_EMBEDDED;
9175 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9176 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9177 kern_type = KERN_TYPE_AGILEKEY;
9178 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9179 parse_func = agilekey_parse_hash;
9180 sort_by_digest = sort_by_digest_4_5;
9181 opti_type = OPTI_TYPE_ZERO_BYTE;
9182 dgst_pos0 = 0;
9183 dgst_pos1 = 1;
9184 dgst_pos2 = 2;
9185 dgst_pos3 = 3;
9186 break;
9187
9188 case 6700: hash_type = HASH_TYPE_SHA1;
9189 salt_type = SALT_TYPE_EMBEDDED;
9190 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9191 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9192 kern_type = KERN_TYPE_SHA1AIX;
9193 dgst_size = DGST_SIZE_4_5;
9194 parse_func = sha1aix_parse_hash;
9195 sort_by_digest = sort_by_digest_4_5;
9196 opti_type = OPTI_TYPE_ZERO_BYTE;
9197 dgst_pos0 = 0;
9198 dgst_pos1 = 1;
9199 dgst_pos2 = 2;
9200 dgst_pos3 = 3;
9201 break;
9202
9203 case 6800: hash_type = HASH_TYPE_AES;
9204 salt_type = SALT_TYPE_EMBEDDED;
9205 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9206 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9207 kern_type = KERN_TYPE_LASTPASS;
9208 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9209 parse_func = lastpass_parse_hash;
9210 sort_by_digest = sort_by_digest_4_8;
9211 opti_type = OPTI_TYPE_ZERO_BYTE;
9212 dgst_pos0 = 0;
9213 dgst_pos1 = 1;
9214 dgst_pos2 = 2;
9215 dgst_pos3 = 3;
9216 break;
9217
9218 case 6900: hash_type = HASH_TYPE_GOST;
9219 salt_type = SALT_TYPE_NONE;
9220 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9221 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9222 kern_type = KERN_TYPE_GOST;
9223 dgst_size = DGST_SIZE_4_8;
9224 parse_func = gost_parse_hash;
9225 sort_by_digest = sort_by_digest_4_8;
9226 opti_type = OPTI_TYPE_ZERO_BYTE;
9227 dgst_pos0 = 0;
9228 dgst_pos1 = 1;
9229 dgst_pos2 = 2;
9230 dgst_pos3 = 3;
9231 break;
9232
9233 case 7100: hash_type = HASH_TYPE_SHA512;
9234 salt_type = SALT_TYPE_EMBEDDED;
9235 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9236 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9237 kern_type = KERN_TYPE_PBKDF2_SHA512;
9238 dgst_size = DGST_SIZE_8_16;
9239 parse_func = sha512osx_parse_hash;
9240 sort_by_digest = sort_by_digest_8_16;
9241 opti_type = OPTI_TYPE_ZERO_BYTE
9242 | OPTI_TYPE_USES_BITS_64;
9243 dgst_pos0 = 0;
9244 dgst_pos1 = 1;
9245 dgst_pos2 = 2;
9246 dgst_pos3 = 3;
9247 break;
9248
9249 case 7200: hash_type = HASH_TYPE_SHA512;
9250 salt_type = SALT_TYPE_EMBEDDED;
9251 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9252 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9253 kern_type = KERN_TYPE_PBKDF2_SHA512;
9254 dgst_size = DGST_SIZE_8_16;
9255 parse_func = sha512grub_parse_hash;
9256 sort_by_digest = sort_by_digest_8_16;
9257 opti_type = OPTI_TYPE_ZERO_BYTE
9258 | OPTI_TYPE_USES_BITS_64;
9259 dgst_pos0 = 0;
9260 dgst_pos1 = 1;
9261 dgst_pos2 = 2;
9262 dgst_pos3 = 3;
9263 break;
9264
9265 case 7300: hash_type = HASH_TYPE_SHA1;
9266 salt_type = SALT_TYPE_EMBEDDED;
9267 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9268 opts_type = OPTS_TYPE_PT_GENERATE_BE
9269 | OPTS_TYPE_ST_ADD80
9270 | OPTS_TYPE_ST_ADDBITS15;
9271 kern_type = KERN_TYPE_RAKP;
9272 dgst_size = DGST_SIZE_4_5;
9273 parse_func = rakp_parse_hash;
9274 sort_by_digest = sort_by_digest_4_5;
9275 opti_type = OPTI_TYPE_ZERO_BYTE
9276 | OPTI_TYPE_NOT_ITERATED;
9277 dgst_pos0 = 3;
9278 dgst_pos1 = 4;
9279 dgst_pos2 = 2;
9280 dgst_pos3 = 1;
9281 break;
9282
9283 case 7400: hash_type = HASH_TYPE_SHA256;
9284 salt_type = SALT_TYPE_EMBEDDED;
9285 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9286 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9287 kern_type = KERN_TYPE_SHA256CRYPT;
9288 dgst_size = DGST_SIZE_4_8;
9289 parse_func = sha256crypt_parse_hash;
9290 sort_by_digest = sort_by_digest_4_8;
9291 opti_type = OPTI_TYPE_ZERO_BYTE;
9292 dgst_pos0 = 0;
9293 dgst_pos1 = 1;
9294 dgst_pos2 = 2;
9295 dgst_pos3 = 3;
9296 break;
9297
9298 case 7500: hash_type = HASH_TYPE_KRB5PA;
9299 salt_type = SALT_TYPE_EMBEDDED;
9300 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9301 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9302 kern_type = KERN_TYPE_KRB5PA;
9303 dgst_size = DGST_SIZE_4_4;
9304 parse_func = krb5pa_parse_hash;
9305 sort_by_digest = sort_by_digest_4_4;
9306 opti_type = OPTI_TYPE_ZERO_BYTE
9307 | OPTI_TYPE_NOT_ITERATED;
9308 dgst_pos0 = 0;
9309 dgst_pos1 = 1;
9310 dgst_pos2 = 2;
9311 dgst_pos3 = 3;
9312 break;
9313
9314 case 7600: hash_type = HASH_TYPE_SHA1;
9315 salt_type = SALT_TYPE_INTERN;
9316 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9317 opts_type = OPTS_TYPE_PT_GENERATE_BE
9318 | OPTS_TYPE_PT_ADD80
9319 | OPTS_TYPE_PT_ADDBITS15;
9320 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9321 dgst_size = DGST_SIZE_4_5;
9322 parse_func = redmine_parse_hash;
9323 sort_by_digest = sort_by_digest_4_5;
9324 opti_type = OPTI_TYPE_ZERO_BYTE
9325 | OPTI_TYPE_PRECOMPUTE_INIT
9326 | OPTI_TYPE_EARLY_SKIP
9327 | OPTI_TYPE_NOT_ITERATED
9328 | OPTI_TYPE_PREPENDED_SALT;
9329 dgst_pos0 = 3;
9330 dgst_pos1 = 4;
9331 dgst_pos2 = 2;
9332 dgst_pos3 = 1;
9333 break;
9334
9335 case 7700: hash_type = HASH_TYPE_SAPB;
9336 salt_type = SALT_TYPE_EMBEDDED;
9337 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9338 opts_type = OPTS_TYPE_PT_GENERATE_LE
9339 | OPTS_TYPE_PT_UPPER
9340 | OPTS_TYPE_ST_UPPER;
9341 kern_type = KERN_TYPE_SAPB;
9342 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9343 parse_func = sapb_parse_hash;
9344 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9345 opti_type = OPTI_TYPE_ZERO_BYTE
9346 | OPTI_TYPE_PRECOMPUTE_INIT
9347 | OPTI_TYPE_NOT_ITERATED;
9348 dgst_pos0 = 0;
9349 dgst_pos1 = 1;
9350 dgst_pos2 = 2;
9351 dgst_pos3 = 3;
9352 break;
9353
9354 case 7800: hash_type = HASH_TYPE_SAPG;
9355 salt_type = SALT_TYPE_EMBEDDED;
9356 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9357 opts_type = OPTS_TYPE_PT_GENERATE_BE
9358 | OPTS_TYPE_ST_ADD80
9359 | OPTS_TYPE_ST_UPPER;
9360 kern_type = KERN_TYPE_SAPG;
9361 dgst_size = DGST_SIZE_4_5;
9362 parse_func = sapg_parse_hash;
9363 sort_by_digest = sort_by_digest_4_5;
9364 opti_type = OPTI_TYPE_ZERO_BYTE
9365 | OPTI_TYPE_PRECOMPUTE_INIT
9366 | OPTI_TYPE_NOT_ITERATED;
9367 dgst_pos0 = 3;
9368 dgst_pos1 = 4;
9369 dgst_pos2 = 2;
9370 dgst_pos3 = 1;
9371 break;
9372
9373 case 7900: hash_type = HASH_TYPE_SHA512;
9374 salt_type = SALT_TYPE_EMBEDDED;
9375 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9376 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9377 kern_type = KERN_TYPE_DRUPAL7;
9378 dgst_size = DGST_SIZE_8_8;
9379 parse_func = drupal7_parse_hash;
9380 sort_by_digest = sort_by_digest_8_8;
9381 opti_type = OPTI_TYPE_ZERO_BYTE
9382 | OPTI_TYPE_USES_BITS_64;
9383 dgst_pos0 = 0;
9384 dgst_pos1 = 1;
9385 dgst_pos2 = 2;
9386 dgst_pos3 = 3;
9387 break;
9388
9389 case 8000: hash_type = HASH_TYPE_SHA256;
9390 salt_type = SALT_TYPE_EMBEDDED;
9391 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9392 opts_type = OPTS_TYPE_PT_GENERATE_BE
9393 | OPTS_TYPE_PT_UNICODE
9394 | OPTS_TYPE_ST_ADD80
9395 | OPTS_TYPE_ST_HEX;
9396 kern_type = KERN_TYPE_SYBASEASE;
9397 dgst_size = DGST_SIZE_4_8;
9398 parse_func = sybasease_parse_hash;
9399 sort_by_digest = sort_by_digest_4_8;
9400 opti_type = OPTI_TYPE_ZERO_BYTE
9401 | OPTI_TYPE_PRECOMPUTE_INIT
9402 | OPTI_TYPE_EARLY_SKIP
9403 | OPTI_TYPE_NOT_ITERATED
9404 | OPTI_TYPE_RAW_HASH;
9405 dgst_pos0 = 3;
9406 dgst_pos1 = 7;
9407 dgst_pos2 = 2;
9408 dgst_pos3 = 6;
9409 break;
9410
9411 case 8100: hash_type = HASH_TYPE_SHA1;
9412 salt_type = SALT_TYPE_EMBEDDED;
9413 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9414 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9415 kern_type = KERN_TYPE_NETSCALER;
9416 dgst_size = DGST_SIZE_4_5;
9417 parse_func = netscaler_parse_hash;
9418 sort_by_digest = sort_by_digest_4_5;
9419 opti_type = OPTI_TYPE_ZERO_BYTE
9420 | OPTI_TYPE_PRECOMPUTE_INIT
9421 | OPTI_TYPE_PRECOMPUTE_MERKLE
9422 | OPTI_TYPE_EARLY_SKIP
9423 | OPTI_TYPE_NOT_ITERATED
9424 | OPTI_TYPE_PREPENDED_SALT
9425 | OPTI_TYPE_RAW_HASH;
9426 dgst_pos0 = 3;
9427 dgst_pos1 = 4;
9428 dgst_pos2 = 2;
9429 dgst_pos3 = 1;
9430 break;
9431
9432 case 8200: hash_type = HASH_TYPE_SHA256;
9433 salt_type = SALT_TYPE_EMBEDDED;
9434 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9435 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9436 kern_type = KERN_TYPE_CLOUDKEY;
9437 dgst_size = DGST_SIZE_4_8;
9438 parse_func = cloudkey_parse_hash;
9439 sort_by_digest = sort_by_digest_4_8;
9440 opti_type = OPTI_TYPE_ZERO_BYTE;
9441 dgst_pos0 = 0;
9442 dgst_pos1 = 1;
9443 dgst_pos2 = 2;
9444 dgst_pos3 = 3;
9445 break;
9446
9447 case 8300: hash_type = HASH_TYPE_SHA1;
9448 salt_type = SALT_TYPE_EMBEDDED;
9449 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9450 opts_type = OPTS_TYPE_PT_GENERATE_LE
9451 | OPTS_TYPE_ST_HEX
9452 | OPTS_TYPE_ST_ADD80;
9453 kern_type = KERN_TYPE_NSEC3;
9454 dgst_size = DGST_SIZE_4_5;
9455 parse_func = nsec3_parse_hash;
9456 sort_by_digest = sort_by_digest_4_5;
9457 opti_type = OPTI_TYPE_ZERO_BYTE;
9458 dgst_pos0 = 3;
9459 dgst_pos1 = 4;
9460 dgst_pos2 = 2;
9461 dgst_pos3 = 1;
9462 break;
9463
9464 case 8400: hash_type = HASH_TYPE_SHA1;
9465 salt_type = SALT_TYPE_INTERN;
9466 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9467 opts_type = OPTS_TYPE_PT_GENERATE_BE
9468 | OPTS_TYPE_PT_ADD80
9469 | OPTS_TYPE_PT_ADDBITS15;
9470 kern_type = KERN_TYPE_WBB3;
9471 dgst_size = DGST_SIZE_4_5;
9472 parse_func = wbb3_parse_hash;
9473 sort_by_digest = sort_by_digest_4_5;
9474 opti_type = OPTI_TYPE_ZERO_BYTE
9475 | OPTI_TYPE_PRECOMPUTE_INIT
9476 | OPTI_TYPE_NOT_ITERATED;
9477 dgst_pos0 = 3;
9478 dgst_pos1 = 4;
9479 dgst_pos2 = 2;
9480 dgst_pos3 = 1;
9481 break;
9482
9483 case 8500: hash_type = HASH_TYPE_DESRACF;
9484 salt_type = SALT_TYPE_EMBEDDED;
9485 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9486 opts_type = OPTS_TYPE_PT_GENERATE_LE
9487 | OPTS_TYPE_ST_UPPER;
9488 kern_type = KERN_TYPE_RACF;
9489 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9490 parse_func = racf_parse_hash;
9491 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9492 opti_type = OPTI_TYPE_ZERO_BYTE
9493 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9494 dgst_pos0 = 0;
9495 dgst_pos1 = 1;
9496 dgst_pos2 = 2;
9497 dgst_pos3 = 3;
9498 break;
9499
9500 case 8600: hash_type = HASH_TYPE_LOTUS5;
9501 salt_type = SALT_TYPE_NONE;
9502 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9503 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9504 kern_type = KERN_TYPE_LOTUS5;
9505 dgst_size = DGST_SIZE_4_4;
9506 parse_func = lotus5_parse_hash;
9507 sort_by_digest = sort_by_digest_4_4;
9508 opti_type = OPTI_TYPE_EARLY_SKIP
9509 | OPTI_TYPE_NOT_ITERATED
9510 | OPTI_TYPE_NOT_SALTED
9511 | OPTI_TYPE_RAW_HASH;
9512 dgst_pos0 = 0;
9513 dgst_pos1 = 1;
9514 dgst_pos2 = 2;
9515 dgst_pos3 = 3;
9516 break;
9517
9518 case 8700: hash_type = HASH_TYPE_LOTUS6;
9519 salt_type = SALT_TYPE_EMBEDDED;
9520 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9521 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9522 kern_type = KERN_TYPE_LOTUS6;
9523 dgst_size = DGST_SIZE_4_4;
9524 parse_func = lotus6_parse_hash;
9525 sort_by_digest = sort_by_digest_4_4;
9526 opti_type = OPTI_TYPE_EARLY_SKIP
9527 | OPTI_TYPE_NOT_ITERATED
9528 | OPTI_TYPE_RAW_HASH;
9529 dgst_pos0 = 0;
9530 dgst_pos1 = 1;
9531 dgst_pos2 = 2;
9532 dgst_pos3 = 3;
9533 break;
9534
9535 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9536 salt_type = SALT_TYPE_EMBEDDED;
9537 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9538 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9539 kern_type = KERN_TYPE_ANDROIDFDE;
9540 dgst_size = DGST_SIZE_4_4;
9541 parse_func = androidfde_parse_hash;
9542 sort_by_digest = sort_by_digest_4_4;
9543 opti_type = OPTI_TYPE_ZERO_BYTE;
9544 dgst_pos0 = 0;
9545 dgst_pos1 = 1;
9546 dgst_pos2 = 2;
9547 dgst_pos3 = 3;
9548 break;
9549
9550 case 8900: hash_type = HASH_TYPE_SCRYPT;
9551 salt_type = SALT_TYPE_EMBEDDED;
9552 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9553 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9554 kern_type = KERN_TYPE_SCRYPT;
9555 dgst_size = DGST_SIZE_4_8;
9556 parse_func = scrypt_parse_hash;
9557 sort_by_digest = sort_by_digest_4_8;
9558 opti_type = OPTI_TYPE_ZERO_BYTE;
9559 dgst_pos0 = 0;
9560 dgst_pos1 = 1;
9561 dgst_pos2 = 2;
9562 dgst_pos3 = 3;
9563 break;
9564
9565 case 9000: hash_type = HASH_TYPE_SHA1;
9566 salt_type = SALT_TYPE_EMBEDDED;
9567 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9568 opts_type = OPTS_TYPE_PT_GENERATE_LE
9569 | OPTS_TYPE_ST_GENERATE_LE;
9570 kern_type = KERN_TYPE_PSAFE2;
9571 dgst_size = DGST_SIZE_4_5;
9572 parse_func = psafe2_parse_hash;
9573 sort_by_digest = sort_by_digest_4_5;
9574 opti_type = OPTI_TYPE_ZERO_BYTE;
9575 dgst_pos0 = 0;
9576 dgst_pos1 = 1;
9577 dgst_pos2 = 2;
9578 dgst_pos3 = 3;
9579 break;
9580
9581 case 9100: hash_type = HASH_TYPE_LOTUS8;
9582 salt_type = SALT_TYPE_EMBEDDED;
9583 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9584 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9585 kern_type = KERN_TYPE_LOTUS8;
9586 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9587 parse_func = lotus8_parse_hash;
9588 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9589 opti_type = OPTI_TYPE_ZERO_BYTE;
9590 dgst_pos0 = 0;
9591 dgst_pos1 = 1;
9592 dgst_pos2 = 2;
9593 dgst_pos3 = 3;
9594 break;
9595
9596 case 9200: hash_type = HASH_TYPE_SHA256;
9597 salt_type = SALT_TYPE_EMBEDDED;
9598 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9599 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9600 kern_type = KERN_TYPE_PBKDF2_SHA256;
9601 dgst_size = DGST_SIZE_4_32;
9602 parse_func = cisco8_parse_hash;
9603 sort_by_digest = sort_by_digest_4_32;
9604 opti_type = OPTI_TYPE_ZERO_BYTE;
9605 dgst_pos0 = 0;
9606 dgst_pos1 = 1;
9607 dgst_pos2 = 2;
9608 dgst_pos3 = 3;
9609 break;
9610
9611 case 9300: hash_type = HASH_TYPE_SCRYPT;
9612 salt_type = SALT_TYPE_EMBEDDED;
9613 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9614 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9615 kern_type = KERN_TYPE_SCRYPT;
9616 dgst_size = DGST_SIZE_4_8;
9617 parse_func = cisco9_parse_hash;
9618 sort_by_digest = sort_by_digest_4_8;
9619 opti_type = OPTI_TYPE_ZERO_BYTE;
9620 dgst_pos0 = 0;
9621 dgst_pos1 = 1;
9622 dgst_pos2 = 2;
9623 dgst_pos3 = 3;
9624 break;
9625
9626 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9627 salt_type = SALT_TYPE_EMBEDDED;
9628 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9629 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9630 kern_type = KERN_TYPE_OFFICE2007;
9631 dgst_size = DGST_SIZE_4_4;
9632 parse_func = office2007_parse_hash;
9633 sort_by_digest = sort_by_digest_4_4;
9634 opti_type = OPTI_TYPE_ZERO_BYTE;
9635 dgst_pos0 = 0;
9636 dgst_pos1 = 1;
9637 dgst_pos2 = 2;
9638 dgst_pos3 = 3;
9639 break;
9640
9641 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9642 salt_type = SALT_TYPE_EMBEDDED;
9643 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9644 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9645 kern_type = KERN_TYPE_OFFICE2010;
9646 dgst_size = DGST_SIZE_4_4;
9647 parse_func = office2010_parse_hash;
9648 sort_by_digest = sort_by_digest_4_4;
9649 opti_type = OPTI_TYPE_ZERO_BYTE;
9650 dgst_pos0 = 0;
9651 dgst_pos1 = 1;
9652 dgst_pos2 = 2;
9653 dgst_pos3 = 3;
9654 break;
9655
9656 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9657 salt_type = SALT_TYPE_EMBEDDED;
9658 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9659 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9660 kern_type = KERN_TYPE_OFFICE2013;
9661 dgst_size = DGST_SIZE_4_4;
9662 parse_func = office2013_parse_hash;
9663 sort_by_digest = sort_by_digest_4_4;
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 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9672 salt_type = SALT_TYPE_EMBEDDED;
9673 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9674 opts_type = OPTS_TYPE_PT_GENERATE_LE
9675 | OPTS_TYPE_PT_ADD80
9676 | OPTS_TYPE_PT_UNICODE;
9677 kern_type = KERN_TYPE_OLDOFFICE01;
9678 dgst_size = DGST_SIZE_4_4;
9679 parse_func = oldoffice01_parse_hash;
9680 sort_by_digest = sort_by_digest_4_4;
9681 opti_type = OPTI_TYPE_ZERO_BYTE
9682 | OPTI_TYPE_PRECOMPUTE_INIT
9683 | OPTI_TYPE_NOT_ITERATED;
9684 dgst_pos0 = 0;
9685 dgst_pos1 = 1;
9686 dgst_pos2 = 2;
9687 dgst_pos3 = 3;
9688 break;
9689
9690 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9691 salt_type = SALT_TYPE_EMBEDDED;
9692 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9693 opts_type = OPTS_TYPE_PT_GENERATE_LE
9694 | OPTS_TYPE_PT_ADD80;
9695 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9696 dgst_size = DGST_SIZE_4_4;
9697 parse_func = oldoffice01cm1_parse_hash;
9698 sort_by_digest = sort_by_digest_4_4;
9699 opti_type = OPTI_TYPE_ZERO_BYTE
9700 | OPTI_TYPE_PRECOMPUTE_INIT
9701 | OPTI_TYPE_NOT_ITERATED;
9702 dgst_pos0 = 0;
9703 dgst_pos1 = 1;
9704 dgst_pos2 = 2;
9705 dgst_pos3 = 3;
9706 break;
9707
9708 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9709 salt_type = SALT_TYPE_EMBEDDED;
9710 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9711 opts_type = OPTS_TYPE_PT_GENERATE_LE
9712 | OPTS_TYPE_PT_ADD80
9713 | OPTS_TYPE_PT_UNICODE
9714 | OPTS_TYPE_PT_NEVERCRACK;
9715 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9716 dgst_size = DGST_SIZE_4_4;
9717 parse_func = oldoffice01cm2_parse_hash;
9718 sort_by_digest = sort_by_digest_4_4;
9719 opti_type = OPTI_TYPE_ZERO_BYTE
9720 | OPTI_TYPE_PRECOMPUTE_INIT
9721 | OPTI_TYPE_NOT_ITERATED;
9722 dgst_pos0 = 0;
9723 dgst_pos1 = 1;
9724 dgst_pos2 = 2;
9725 dgst_pos3 = 3;
9726 break;
9727
9728 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9729 salt_type = SALT_TYPE_EMBEDDED;
9730 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9731 opts_type = OPTS_TYPE_PT_GENERATE_BE
9732 | OPTS_TYPE_PT_ADD80
9733 | OPTS_TYPE_PT_UNICODE;
9734 kern_type = KERN_TYPE_OLDOFFICE34;
9735 dgst_size = DGST_SIZE_4_4;
9736 parse_func = oldoffice34_parse_hash;
9737 sort_by_digest = sort_by_digest_4_4;
9738 opti_type = OPTI_TYPE_ZERO_BYTE
9739 | OPTI_TYPE_PRECOMPUTE_INIT
9740 | OPTI_TYPE_NOT_ITERATED;
9741 dgst_pos0 = 0;
9742 dgst_pos1 = 1;
9743 dgst_pos2 = 2;
9744 dgst_pos3 = 3;
9745 break;
9746
9747 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9748 salt_type = SALT_TYPE_EMBEDDED;
9749 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9750 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9751 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9752 dgst_size = DGST_SIZE_4_4;
9753 parse_func = oldoffice34cm1_parse_hash;
9754 sort_by_digest = sort_by_digest_4_4;
9755 opti_type = OPTI_TYPE_ZERO_BYTE
9756 | OPTI_TYPE_PRECOMPUTE_INIT
9757 | OPTI_TYPE_NOT_ITERATED;
9758 dgst_pos0 = 0;
9759 dgst_pos1 = 1;
9760 dgst_pos2 = 2;
9761 dgst_pos3 = 3;
9762 break;
9763
9764 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9765 salt_type = SALT_TYPE_EMBEDDED;
9766 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9767 opts_type = OPTS_TYPE_PT_GENERATE_BE
9768 | OPTS_TYPE_PT_ADD80
9769 | OPTS_TYPE_PT_UNICODE
9770 | OPTS_TYPE_PT_NEVERCRACK;
9771 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9772 dgst_size = DGST_SIZE_4_4;
9773 parse_func = oldoffice34cm2_parse_hash;
9774 sort_by_digest = sort_by_digest_4_4;
9775 opti_type = OPTI_TYPE_ZERO_BYTE
9776 | OPTI_TYPE_PRECOMPUTE_INIT
9777 | OPTI_TYPE_NOT_ITERATED;
9778 dgst_pos0 = 0;
9779 dgst_pos1 = 1;
9780 dgst_pos2 = 2;
9781 dgst_pos3 = 3;
9782 break;
9783
9784 case 9900: hash_type = HASH_TYPE_MD5;
9785 salt_type = SALT_TYPE_NONE;
9786 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9787 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9788 kern_type = KERN_TYPE_RADMIN2;
9789 dgst_size = DGST_SIZE_4_4;
9790 parse_func = radmin2_parse_hash;
9791 sort_by_digest = sort_by_digest_4_4;
9792 opti_type = OPTI_TYPE_ZERO_BYTE
9793 | OPTI_TYPE_PRECOMPUTE_INIT
9794 | OPTI_TYPE_EARLY_SKIP
9795 | OPTI_TYPE_NOT_ITERATED
9796 | OPTI_TYPE_NOT_SALTED;
9797 dgst_pos0 = 0;
9798 dgst_pos1 = 3;
9799 dgst_pos2 = 2;
9800 dgst_pos3 = 1;
9801 break;
9802
9803 case 10000: hash_type = HASH_TYPE_SHA256;
9804 salt_type = SALT_TYPE_EMBEDDED;
9805 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9806 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9807 kern_type = KERN_TYPE_PBKDF2_SHA256;
9808 dgst_size = DGST_SIZE_4_32;
9809 parse_func = djangopbkdf2_parse_hash;
9810 sort_by_digest = sort_by_digest_4_32;
9811 opti_type = OPTI_TYPE_ZERO_BYTE;
9812 dgst_pos0 = 0;
9813 dgst_pos1 = 1;
9814 dgst_pos2 = 2;
9815 dgst_pos3 = 3;
9816 break;
9817
9818 case 10100: hash_type = HASH_TYPE_SIPHASH;
9819 salt_type = SALT_TYPE_EMBEDDED;
9820 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9821 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9822 kern_type = KERN_TYPE_SIPHASH;
9823 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9824 parse_func = siphash_parse_hash;
9825 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9826 opti_type = OPTI_TYPE_ZERO_BYTE
9827 | OPTI_TYPE_NOT_ITERATED
9828 | OPTI_TYPE_RAW_HASH;
9829 dgst_pos0 = 0;
9830 dgst_pos1 = 1;
9831 dgst_pos2 = 2;
9832 dgst_pos3 = 3;
9833 break;
9834
9835 case 10200: hash_type = HASH_TYPE_MD5;
9836 salt_type = SALT_TYPE_EMBEDDED;
9837 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9838 opts_type = OPTS_TYPE_PT_GENERATE_LE
9839 | OPTS_TYPE_ST_ADD80
9840 | OPTS_TYPE_ST_ADDBITS14;
9841 kern_type = KERN_TYPE_HMACMD5_PW;
9842 dgst_size = DGST_SIZE_4_4;
9843 parse_func = crammd5_parse_hash;
9844 sort_by_digest = sort_by_digest_4_4;
9845 opti_type = OPTI_TYPE_ZERO_BYTE
9846 | OPTI_TYPE_NOT_ITERATED;
9847 dgst_pos0 = 0;
9848 dgst_pos1 = 3;
9849 dgst_pos2 = 2;
9850 dgst_pos3 = 1;
9851 break;
9852
9853 case 10300: hash_type = HASH_TYPE_SHA1;
9854 salt_type = SALT_TYPE_EMBEDDED;
9855 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9856 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9857 kern_type = KERN_TYPE_SAPH_SHA1;
9858 dgst_size = DGST_SIZE_4_5;
9859 parse_func = saph_sha1_parse_hash;
9860 sort_by_digest = sort_by_digest_4_5;
9861 opti_type = OPTI_TYPE_ZERO_BYTE;
9862 dgst_pos0 = 0;
9863 dgst_pos1 = 1;
9864 dgst_pos2 = 2;
9865 dgst_pos3 = 3;
9866 break;
9867
9868 case 10400: hash_type = HASH_TYPE_PDFU16;
9869 salt_type = SALT_TYPE_EMBEDDED;
9870 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9871 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9872 kern_type = KERN_TYPE_PDF11;
9873 dgst_size = DGST_SIZE_4_4;
9874 parse_func = pdf11_parse_hash;
9875 sort_by_digest = sort_by_digest_4_4;
9876 opti_type = OPTI_TYPE_ZERO_BYTE
9877 | OPTI_TYPE_NOT_ITERATED;
9878 dgst_pos0 = 0;
9879 dgst_pos1 = 1;
9880 dgst_pos2 = 2;
9881 dgst_pos3 = 3;
9882 break;
9883
9884 case 10410: hash_type = HASH_TYPE_PDFU16;
9885 salt_type = SALT_TYPE_EMBEDDED;
9886 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9887 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9888 kern_type = KERN_TYPE_PDF11CM1;
9889 dgst_size = DGST_SIZE_4_4;
9890 parse_func = pdf11cm1_parse_hash;
9891 sort_by_digest = sort_by_digest_4_4;
9892 opti_type = OPTI_TYPE_ZERO_BYTE
9893 | OPTI_TYPE_NOT_ITERATED;
9894 dgst_pos0 = 0;
9895 dgst_pos1 = 1;
9896 dgst_pos2 = 2;
9897 dgst_pos3 = 3;
9898 break;
9899
9900 case 10420: hash_type = HASH_TYPE_PDFU16;
9901 salt_type = SALT_TYPE_EMBEDDED;
9902 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9903 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9904 kern_type = KERN_TYPE_PDF11CM2;
9905 dgst_size = DGST_SIZE_4_4;
9906 parse_func = pdf11cm2_parse_hash;
9907 sort_by_digest = sort_by_digest_4_4;
9908 opti_type = OPTI_TYPE_ZERO_BYTE
9909 | OPTI_TYPE_NOT_ITERATED;
9910 dgst_pos0 = 0;
9911 dgst_pos1 = 1;
9912 dgst_pos2 = 2;
9913 dgst_pos3 = 3;
9914 break;
9915
9916 case 10500: hash_type = HASH_TYPE_PDFU16;
9917 salt_type = SALT_TYPE_EMBEDDED;
9918 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9919 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9920 kern_type = KERN_TYPE_PDF14;
9921 dgst_size = DGST_SIZE_4_4;
9922 parse_func = pdf14_parse_hash;
9923 sort_by_digest = sort_by_digest_4_4;
9924 opti_type = OPTI_TYPE_ZERO_BYTE
9925 | OPTI_TYPE_NOT_ITERATED;
9926 dgst_pos0 = 0;
9927 dgst_pos1 = 1;
9928 dgst_pos2 = 2;
9929 dgst_pos3 = 3;
9930 break;
9931
9932 case 10600: hash_type = HASH_TYPE_SHA256;
9933 salt_type = SALT_TYPE_EMBEDDED;
9934 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9935 opts_type = OPTS_TYPE_PT_GENERATE_BE
9936 | OPTS_TYPE_ST_ADD80
9937 | OPTS_TYPE_ST_ADDBITS15
9938 | OPTS_TYPE_HASH_COPY;
9939 kern_type = KERN_TYPE_SHA256_PWSLT;
9940 dgst_size = DGST_SIZE_4_8;
9941 parse_func = pdf17l3_parse_hash;
9942 sort_by_digest = sort_by_digest_4_8;
9943 opti_type = OPTI_TYPE_ZERO_BYTE
9944 | OPTI_TYPE_PRECOMPUTE_INIT
9945 | OPTI_TYPE_PRECOMPUTE_MERKLE
9946 | OPTI_TYPE_EARLY_SKIP
9947 | OPTI_TYPE_NOT_ITERATED
9948 | OPTI_TYPE_APPENDED_SALT
9949 | OPTI_TYPE_RAW_HASH;
9950 dgst_pos0 = 3;
9951 dgst_pos1 = 7;
9952 dgst_pos2 = 2;
9953 dgst_pos3 = 6;
9954 break;
9955
9956 case 10700: hash_type = HASH_TYPE_PDFU32;
9957 salt_type = SALT_TYPE_EMBEDDED;
9958 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9959 opts_type = OPTS_TYPE_PT_GENERATE_LE
9960 | OPTS_TYPE_HASH_COPY;
9961 kern_type = KERN_TYPE_PDF17L8;
9962 dgst_size = DGST_SIZE_4_8;
9963 parse_func = pdf17l8_parse_hash;
9964 sort_by_digest = sort_by_digest_4_8;
9965 opti_type = OPTI_TYPE_ZERO_BYTE
9966 | OPTI_TYPE_NOT_ITERATED;
9967 dgst_pos0 = 0;
9968 dgst_pos1 = 1;
9969 dgst_pos2 = 2;
9970 dgst_pos3 = 3;
9971 break;
9972
9973 case 10800: hash_type = HASH_TYPE_SHA384;
9974 salt_type = SALT_TYPE_NONE;
9975 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9976 opts_type = OPTS_TYPE_PT_GENERATE_BE
9977 | OPTS_TYPE_PT_ADD80
9978 | OPTS_TYPE_PT_ADDBITS15;
9979 kern_type = KERN_TYPE_SHA384;
9980 dgst_size = DGST_SIZE_8_8;
9981 parse_func = sha384_parse_hash;
9982 sort_by_digest = sort_by_digest_8_8;
9983 opti_type = OPTI_TYPE_ZERO_BYTE
9984 | OPTI_TYPE_PRECOMPUTE_INIT
9985 | OPTI_TYPE_PRECOMPUTE_MERKLE
9986 | OPTI_TYPE_EARLY_SKIP
9987 | OPTI_TYPE_NOT_ITERATED
9988 | OPTI_TYPE_NOT_SALTED
9989 | OPTI_TYPE_USES_BITS_64
9990 | OPTI_TYPE_RAW_HASH;
9991 dgst_pos0 = 6;
9992 dgst_pos1 = 7;
9993 dgst_pos2 = 4;
9994 dgst_pos3 = 5;
9995 break;
9996
9997 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9998 salt_type = SALT_TYPE_EMBEDDED;
9999 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10000 opts_type = OPTS_TYPE_PT_GENERATE_LE
10001 | OPTS_TYPE_ST_BASE64
10002 | OPTS_TYPE_HASH_COPY;
10003 kern_type = KERN_TYPE_PBKDF2_SHA256;
10004 dgst_size = DGST_SIZE_4_32;
10005 parse_func = pbkdf2_sha256_parse_hash;
10006 sort_by_digest = sort_by_digest_4_32;
10007 opti_type = OPTI_TYPE_ZERO_BYTE;
10008 dgst_pos0 = 0;
10009 dgst_pos1 = 1;
10010 dgst_pos2 = 2;
10011 dgst_pos3 = 3;
10012 break;
10013
10014 case 11000: hash_type = HASH_TYPE_MD5;
10015 salt_type = SALT_TYPE_INTERN;
10016 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10017 opts_type = OPTS_TYPE_PT_GENERATE_LE
10018 | OPTS_TYPE_PT_ADD80;
10019 kern_type = KERN_TYPE_PRESTASHOP;
10020 dgst_size = DGST_SIZE_4_4;
10021 parse_func = prestashop_parse_hash;
10022 sort_by_digest = sort_by_digest_4_4;
10023 opti_type = OPTI_TYPE_ZERO_BYTE
10024 | OPTI_TYPE_PRECOMPUTE_INIT
10025 | OPTI_TYPE_NOT_ITERATED
10026 | OPTI_TYPE_PREPENDED_SALT;
10027 dgst_pos0 = 0;
10028 dgst_pos1 = 3;
10029 dgst_pos2 = 2;
10030 dgst_pos3 = 1;
10031 break;
10032
10033 case 11100: hash_type = HASH_TYPE_MD5;
10034 salt_type = SALT_TYPE_EMBEDDED;
10035 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10036 opts_type = OPTS_TYPE_PT_GENERATE_LE
10037 | OPTS_TYPE_ST_ADD80;
10038 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10039 dgst_size = DGST_SIZE_4_4;
10040 parse_func = postgresql_auth_parse_hash;
10041 sort_by_digest = sort_by_digest_4_4;
10042 opti_type = OPTI_TYPE_ZERO_BYTE
10043 | OPTI_TYPE_PRECOMPUTE_INIT
10044 | OPTI_TYPE_PRECOMPUTE_MERKLE
10045 | OPTI_TYPE_EARLY_SKIP;
10046 dgst_pos0 = 0;
10047 dgst_pos1 = 3;
10048 dgst_pos2 = 2;
10049 dgst_pos3 = 1;
10050 break;
10051
10052 case 11200: hash_type = HASH_TYPE_SHA1;
10053 salt_type = SALT_TYPE_EMBEDDED;
10054 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10055 opts_type = OPTS_TYPE_PT_GENERATE_BE
10056 | OPTS_TYPE_PT_ADD80
10057 | OPTS_TYPE_ST_HEX;
10058 kern_type = KERN_TYPE_MYSQL_AUTH;
10059 dgst_size = DGST_SIZE_4_5;
10060 parse_func = mysql_auth_parse_hash;
10061 sort_by_digest = sort_by_digest_4_5;
10062 opti_type = OPTI_TYPE_ZERO_BYTE
10063 | OPTI_TYPE_EARLY_SKIP;
10064 dgst_pos0 = 3;
10065 dgst_pos1 = 4;
10066 dgst_pos2 = 2;
10067 dgst_pos3 = 1;
10068 break;
10069
10070 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10071 salt_type = SALT_TYPE_EMBEDDED;
10072 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10073 opts_type = OPTS_TYPE_PT_GENERATE_LE
10074 | OPTS_TYPE_ST_HEX
10075 | OPTS_TYPE_ST_ADD80;
10076 kern_type = KERN_TYPE_BITCOIN_WALLET;
10077 dgst_size = DGST_SIZE_4_4;
10078 parse_func = bitcoin_wallet_parse_hash;
10079 sort_by_digest = sort_by_digest_4_4;
10080 opti_type = OPTI_TYPE_ZERO_BYTE;
10081 dgst_pos0 = 0;
10082 dgst_pos1 = 1;
10083 dgst_pos2 = 2;
10084 dgst_pos3 = 3;
10085 break;
10086
10087 case 11400: hash_type = HASH_TYPE_MD5;
10088 salt_type = SALT_TYPE_EMBEDDED;
10089 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10090 opts_type = OPTS_TYPE_PT_GENERATE_LE
10091 | OPTS_TYPE_PT_ADD80
10092 | OPTS_TYPE_HASH_COPY;
10093 kern_type = KERN_TYPE_SIP_AUTH;
10094 dgst_size = DGST_SIZE_4_4;
10095 parse_func = sip_auth_parse_hash;
10096 sort_by_digest = sort_by_digest_4_4;
10097 opti_type = OPTI_TYPE_ZERO_BYTE;
10098 dgst_pos0 = 0;
10099 dgst_pos1 = 3;
10100 dgst_pos2 = 2;
10101 dgst_pos3 = 1;
10102 break;
10103
10104 case 11500: hash_type = HASH_TYPE_CRC32;
10105 salt_type = SALT_TYPE_INTERN;
10106 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10107 opts_type = OPTS_TYPE_PT_GENERATE_LE
10108 | OPTS_TYPE_ST_GENERATE_LE
10109 | OPTS_TYPE_ST_HEX;
10110 kern_type = KERN_TYPE_CRC32;
10111 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10112 parse_func = crc32_parse_hash;
10113 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10114 opti_type = OPTI_TYPE_ZERO_BYTE;
10115 dgst_pos0 = 0;
10116 dgst_pos1 = 1;
10117 dgst_pos2 = 2;
10118 dgst_pos3 = 3;
10119 break;
10120
10121 case 11600: hash_type = HASH_TYPE_AES;
10122 salt_type = SALT_TYPE_EMBEDDED;
10123 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10124 opts_type = OPTS_TYPE_PT_GENERATE_LE
10125 | OPTS_TYPE_PT_NEVERCRACK;
10126 kern_type = KERN_TYPE_SEVEN_ZIP;
10127 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10128 parse_func = seven_zip_parse_hash;
10129 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10130 opti_type = OPTI_TYPE_ZERO_BYTE;
10131 dgst_pos0 = 0;
10132 dgst_pos1 = 1;
10133 dgst_pos2 = 2;
10134 dgst_pos3 = 3;
10135 break;
10136
10137 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10138 salt_type = SALT_TYPE_NONE;
10139 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10140 opts_type = OPTS_TYPE_PT_GENERATE_LE
10141 | OPTS_TYPE_PT_ADD01;
10142 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10143 dgst_size = DGST_SIZE_4_8;
10144 parse_func = gost2012sbog_256_parse_hash;
10145 sort_by_digest = sort_by_digest_4_8;
10146 opti_type = OPTI_TYPE_ZERO_BYTE;
10147 dgst_pos0 = 0;
10148 dgst_pos1 = 1;
10149 dgst_pos2 = 2;
10150 dgst_pos3 = 3;
10151 break;
10152
10153 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10154 salt_type = SALT_TYPE_NONE;
10155 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10156 opts_type = OPTS_TYPE_PT_GENERATE_LE
10157 | OPTS_TYPE_PT_ADD01;
10158 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10159 dgst_size = DGST_SIZE_4_16;
10160 parse_func = gost2012sbog_512_parse_hash;
10161 sort_by_digest = sort_by_digest_4_16;
10162 opti_type = OPTI_TYPE_ZERO_BYTE;
10163 dgst_pos0 = 0;
10164 dgst_pos1 = 1;
10165 dgst_pos2 = 2;
10166 dgst_pos3 = 3;
10167 break;
10168
10169 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10170 salt_type = SALT_TYPE_EMBEDDED;
10171 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10172 opts_type = OPTS_TYPE_PT_GENERATE_LE
10173 | OPTS_TYPE_ST_BASE64
10174 | OPTS_TYPE_HASH_COPY;
10175 kern_type = KERN_TYPE_PBKDF2_MD5;
10176 dgst_size = DGST_SIZE_4_32;
10177 parse_func = pbkdf2_md5_parse_hash;
10178 sort_by_digest = sort_by_digest_4_32;
10179 opti_type = OPTI_TYPE_ZERO_BYTE;
10180 dgst_pos0 = 0;
10181 dgst_pos1 = 1;
10182 dgst_pos2 = 2;
10183 dgst_pos3 = 3;
10184 break;
10185
10186 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10187 salt_type = SALT_TYPE_EMBEDDED;
10188 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10189 opts_type = OPTS_TYPE_PT_GENERATE_LE
10190 | OPTS_TYPE_ST_BASE64
10191 | OPTS_TYPE_HASH_COPY;
10192 kern_type = KERN_TYPE_PBKDF2_SHA1;
10193 dgst_size = DGST_SIZE_4_32;
10194 parse_func = pbkdf2_sha1_parse_hash;
10195 sort_by_digest = sort_by_digest_4_32;
10196 opti_type = OPTI_TYPE_ZERO_BYTE;
10197 dgst_pos0 = 0;
10198 dgst_pos1 = 1;
10199 dgst_pos2 = 2;
10200 dgst_pos3 = 3;
10201 break;
10202
10203 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10204 salt_type = SALT_TYPE_EMBEDDED;
10205 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10206 opts_type = OPTS_TYPE_PT_GENERATE_LE
10207 | OPTS_TYPE_ST_BASE64
10208 | OPTS_TYPE_HASH_COPY;
10209 kern_type = KERN_TYPE_PBKDF2_SHA512;
10210 dgst_size = DGST_SIZE_8_16;
10211 parse_func = pbkdf2_sha512_parse_hash;
10212 sort_by_digest = sort_by_digest_8_16;
10213 opti_type = OPTI_TYPE_ZERO_BYTE
10214 | OPTI_TYPE_USES_BITS_64;
10215 dgst_pos0 = 0;
10216 dgst_pos1 = 1;
10217 dgst_pos2 = 2;
10218 dgst_pos3 = 3;
10219 break;
10220
10221 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10222 salt_type = SALT_TYPE_EMBEDDED;
10223 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10224 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10225 kern_type = KERN_TYPE_ECRYPTFS;
10226 dgst_size = DGST_SIZE_8_8;
10227 parse_func = ecryptfs_parse_hash;
10228 sort_by_digest = sort_by_digest_8_8;
10229 opti_type = OPTI_TYPE_ZERO_BYTE
10230 | OPTI_TYPE_USES_BITS_64;
10231 dgst_pos0 = 0;
10232 dgst_pos1 = 1;
10233 dgst_pos2 = 2;
10234 dgst_pos3 = 3;
10235 break;
10236
10237 case 12300: hash_type = HASH_TYPE_ORACLET;
10238 salt_type = SALT_TYPE_EMBEDDED;
10239 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10240 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10241 kern_type = KERN_TYPE_ORACLET;
10242 dgst_size = DGST_SIZE_8_16;
10243 parse_func = oraclet_parse_hash;
10244 sort_by_digest = sort_by_digest_8_16;
10245 opti_type = OPTI_TYPE_ZERO_BYTE
10246 | OPTI_TYPE_USES_BITS_64;
10247 dgst_pos0 = 0;
10248 dgst_pos1 = 1;
10249 dgst_pos2 = 2;
10250 dgst_pos3 = 3;
10251 break;
10252
10253 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10254 salt_type = SALT_TYPE_EMBEDDED;
10255 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10256 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10257 kern_type = KERN_TYPE_BSDICRYPT;
10258 dgst_size = DGST_SIZE_4_4;
10259 parse_func = bsdicrypt_parse_hash;
10260 sort_by_digest = sort_by_digest_4_4;
10261 opti_type = OPTI_TYPE_ZERO_BYTE
10262 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10263 dgst_pos0 = 0;
10264 dgst_pos1 = 1;
10265 dgst_pos2 = 2;
10266 dgst_pos3 = 3;
10267 break;
10268
10269 case 12500: hash_type = HASH_TYPE_RAR3HP;
10270 salt_type = SALT_TYPE_EMBEDDED;
10271 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10272 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10273 kern_type = KERN_TYPE_RAR3;
10274 dgst_size = DGST_SIZE_4_4;
10275 parse_func = rar3hp_parse_hash;
10276 sort_by_digest = sort_by_digest_4_4;
10277 opti_type = OPTI_TYPE_ZERO_BYTE;
10278 dgst_pos0 = 0;
10279 dgst_pos1 = 1;
10280 dgst_pos2 = 2;
10281 dgst_pos3 = 3;
10282 break;
10283
10284 case 12600: hash_type = HASH_TYPE_SHA256;
10285 salt_type = SALT_TYPE_INTERN;
10286 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10287 opts_type = OPTS_TYPE_PT_GENERATE_BE
10288 | OPTS_TYPE_PT_ADD80;
10289 kern_type = KERN_TYPE_CF10;
10290 dgst_size = DGST_SIZE_4_8;
10291 parse_func = cf10_parse_hash;
10292 sort_by_digest = sort_by_digest_4_8;
10293 opti_type = OPTI_TYPE_ZERO_BYTE
10294 | OPTI_TYPE_PRECOMPUTE_INIT
10295 | OPTI_TYPE_EARLY_SKIP
10296 | OPTI_TYPE_NOT_ITERATED;
10297 dgst_pos0 = 3;
10298 dgst_pos1 = 7;
10299 dgst_pos2 = 2;
10300 dgst_pos3 = 6;
10301 break;
10302
10303 case 12700: hash_type = HASH_TYPE_AES;
10304 salt_type = SALT_TYPE_EMBEDDED;
10305 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10306 opts_type = OPTS_TYPE_PT_GENERATE_LE
10307 | OPTS_TYPE_HASH_COPY;
10308 kern_type = KERN_TYPE_MYWALLET;
10309 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10310 parse_func = mywallet_parse_hash;
10311 sort_by_digest = sort_by_digest_4_5;
10312 opti_type = OPTI_TYPE_ZERO_BYTE;
10313 dgst_pos0 = 0;
10314 dgst_pos1 = 1;
10315 dgst_pos2 = 2;
10316 dgst_pos3 = 3;
10317 break;
10318
10319 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10320 salt_type = SALT_TYPE_EMBEDDED;
10321 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10322 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10323 kern_type = KERN_TYPE_MS_DRSR;
10324 dgst_size = DGST_SIZE_4_8;
10325 parse_func = ms_drsr_parse_hash;
10326 sort_by_digest = sort_by_digest_4_8;
10327 opti_type = OPTI_TYPE_ZERO_BYTE;
10328 dgst_pos0 = 0;
10329 dgst_pos1 = 1;
10330 dgst_pos2 = 2;
10331 dgst_pos3 = 3;
10332 break;
10333
10334 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10335 salt_type = SALT_TYPE_EMBEDDED;
10336 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10337 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10338 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10339 dgst_size = DGST_SIZE_4_8;
10340 parse_func = androidfde_samsung_parse_hash;
10341 sort_by_digest = sort_by_digest_4_8;
10342 opti_type = OPTI_TYPE_ZERO_BYTE;
10343 dgst_pos0 = 0;
10344 dgst_pos1 = 1;
10345 dgst_pos2 = 2;
10346 dgst_pos3 = 3;
10347 break;
10348
10349 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10350 salt_type = SALT_TYPE_EMBEDDED;
10351 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10352 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10353 kern_type = KERN_TYPE_RAR5;
10354 dgst_size = DGST_SIZE_4_4;
10355 parse_func = rar5_parse_hash;
10356 sort_by_digest = sort_by_digest_4_4;
10357 opti_type = OPTI_TYPE_ZERO_BYTE;
10358 dgst_pos0 = 0;
10359 dgst_pos1 = 1;
10360 dgst_pos2 = 2;
10361 dgst_pos3 = 3;
10362 break;
10363
10364 default: usage_mini_print (PROGNAME); return (-1);
10365 }
10366
10367 /**
10368 * transpose
10369 */
10370
10371 data.parse_func = parse_func;
10372
10373 /**
10374 * misc stuff
10375 */
10376
10377 if (hex_salt)
10378 {
10379 if (salt_type == SALT_TYPE_INTERN)
10380 {
10381 opts_type |= OPTS_TYPE_ST_HEX;
10382 }
10383 else
10384 {
10385 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10386
10387 return (-1);
10388 }
10389 }
10390
10391 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10392 | (salt_type == SALT_TYPE_EXTERN)
10393 | (salt_type == SALT_TYPE_EMBEDDED)
10394 | (salt_type == SALT_TYPE_VIRTUAL));
10395
10396 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10397
10398 data.hash_type = hash_type;
10399 data.attack_mode = attack_mode;
10400 data.attack_kern = attack_kern;
10401 data.attack_exec = attack_exec;
10402 data.kern_type = kern_type;
10403 data.opts_type = opts_type;
10404 data.dgst_size = dgst_size;
10405 data.salt_type = salt_type;
10406 data.isSalted = isSalted;
10407 data.sort_by_digest = sort_by_digest;
10408 data.dgst_pos0 = dgst_pos0;
10409 data.dgst_pos1 = dgst_pos1;
10410 data.dgst_pos2 = dgst_pos2;
10411 data.dgst_pos3 = dgst_pos3;
10412
10413 esalt_size = 0;
10414
10415 switch (hash_mode)
10416 {
10417 case 2500: esalt_size = sizeof (wpa_t); break;
10418 case 5300: esalt_size = sizeof (ikepsk_t); break;
10419 case 5400: esalt_size = sizeof (ikepsk_t); break;
10420 case 5500: esalt_size = sizeof (netntlm_t); break;
10421 case 5600: esalt_size = sizeof (netntlm_t); break;
10422 case 6211: esalt_size = sizeof (tc_t); break;
10423 case 6212: esalt_size = sizeof (tc_t); break;
10424 case 6213: esalt_size = sizeof (tc_t); break;
10425 case 6221: esalt_size = sizeof (tc_t); break;
10426 case 6222: esalt_size = sizeof (tc_t); break;
10427 case 6223: esalt_size = sizeof (tc_t); break;
10428 case 6231: esalt_size = sizeof (tc_t); break;
10429 case 6232: esalt_size = sizeof (tc_t); break;
10430 case 6233: esalt_size = sizeof (tc_t); break;
10431 case 6241: esalt_size = sizeof (tc_t); break;
10432 case 6242: esalt_size = sizeof (tc_t); break;
10433 case 6243: esalt_size = sizeof (tc_t); break;
10434 case 6600: esalt_size = sizeof (agilekey_t); break;
10435 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10436 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10437 case 7300: esalt_size = sizeof (rakp_t); break;
10438 case 7500: esalt_size = sizeof (krb5pa_t); break;
10439 case 8200: esalt_size = sizeof (cloudkey_t); break;
10440 case 8800: esalt_size = sizeof (androidfde_t); break;
10441 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10442 case 9400: esalt_size = sizeof (office2007_t); break;
10443 case 9500: esalt_size = sizeof (office2010_t); break;
10444 case 9600: esalt_size = sizeof (office2013_t); break;
10445 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10446 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10447 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10448 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10449 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10450 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10451 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10452 case 10200: esalt_size = sizeof (cram_md5_t); break;
10453 case 10400: esalt_size = sizeof (pdf_t); break;
10454 case 10410: esalt_size = sizeof (pdf_t); break;
10455 case 10420: esalt_size = sizeof (pdf_t); break;
10456 case 10500: esalt_size = sizeof (pdf_t); break;
10457 case 10600: esalt_size = sizeof (pdf_t); break;
10458 case 10700: esalt_size = sizeof (pdf_t); break;
10459 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10460 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10461 case 11400: esalt_size = sizeof (sip_t); break;
10462 case 11600: esalt_size = sizeof (seven_zip_t); break;
10463 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10464 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10465 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10466 case 13000: esalt_size = sizeof (rar5_t); break;
10467 }
10468
10469 data.esalt_size = esalt_size;
10470
10471 /**
10472 * choose dictionary parser
10473 */
10474
10475 if (hash_type == HASH_TYPE_LM)
10476 {
10477 get_next_word_func = get_next_word_lm;
10478 }
10479 else if (opts_type & OPTS_TYPE_PT_UPPER)
10480 {
10481 get_next_word_func = get_next_word_uc;
10482 }
10483 else
10484 {
10485 get_next_word_func = get_next_word_std;
10486 }
10487
10488 /**
10489 * dictstat
10490 */
10491
10492 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10493
10494 #ifdef _POSIX
10495 size_t dictstat_nmemb = 0;
10496 #endif
10497
10498 #ifdef _WIN
10499 uint dictstat_nmemb = 0;
10500 #endif
10501
10502 char dictstat[256] = { 0 };
10503
10504 FILE *dictstat_fp = NULL;
10505
10506 if (keyspace == 0)
10507 {
10508 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10509
10510 dictstat_fp = fopen (dictstat, "rb");
10511
10512 if (dictstat_fp)
10513 {
10514 #ifdef _POSIX
10515 struct stat tmpstat;
10516
10517 fstat (fileno (dictstat_fp), &tmpstat);
10518 #endif
10519
10520 #ifdef _WIN
10521 struct stat64 tmpstat;
10522
10523 _fstat64 (fileno (dictstat_fp), &tmpstat);
10524 #endif
10525
10526 if (tmpstat.st_mtime < COMPTIME)
10527 {
10528 /* with v0.15 the format changed so we have to ensure user is using a good version
10529 since there is no version-header in the dictstat file */
10530
10531 fclose (dictstat_fp);
10532
10533 unlink (dictstat);
10534 }
10535 else
10536 {
10537 while (!feof (dictstat_fp))
10538 {
10539 dictstat_t d;
10540
10541 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10542
10543 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10544
10545 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10546 {
10547 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10548
10549 return -1;
10550 }
10551 }
10552
10553 fclose (dictstat_fp);
10554 }
10555 }
10556 }
10557
10558 /**
10559 * potfile
10560 */
10561
10562 char potfile[256] = { 0 };
10563
10564 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10565
10566 data.pot_fp = NULL;
10567
10568 FILE *out_fp = NULL;
10569 FILE *pot_fp = NULL;
10570
10571 if (show == 1 || left == 1)
10572 {
10573 pot_fp = fopen (potfile, "rb");
10574
10575 if (pot_fp == NULL)
10576 {
10577 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10578
10579 return (-1);
10580 }
10581
10582 if (outfile != NULL)
10583 {
10584 if ((out_fp = fopen (outfile, "ab")) == NULL)
10585 {
10586 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10587
10588 fclose (pot_fp);
10589
10590 return (-1);
10591 }
10592 }
10593 else
10594 {
10595 out_fp = stdout;
10596 }
10597 }
10598 else
10599 {
10600 if (potfile_disable == 0)
10601 {
10602 pot_fp = fopen (potfile, "ab");
10603
10604 if (pot_fp == NULL)
10605 {
10606 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10607
10608 return (-1);
10609 }
10610
10611 data.pot_fp = pot_fp;
10612 }
10613 }
10614
10615 pot_t *pot = NULL;
10616
10617 uint pot_cnt = 0;
10618 uint pot_avail = 0;
10619
10620 if (show == 1 || left == 1)
10621 {
10622 SUPPRESS_OUTPUT = 1;
10623
10624 pot_avail = count_lines (pot_fp);
10625
10626 rewind (pot_fp);
10627
10628 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10629
10630 uint pot_hashes_avail = 0;
10631
10632 uint line_num = 0;
10633
10634 while (!feof (pot_fp))
10635 {
10636 line_num++;
10637
10638 char line_buf[BUFSIZ] = { 0 };
10639
10640 int line_len = fgetl (pot_fp, line_buf);
10641
10642 if (line_len == 0) continue;
10643
10644 char *plain_buf = line_buf + line_len;
10645
10646 pot_t *pot_ptr = &pot[pot_cnt];
10647
10648 hash_t *hashes_buf = &pot_ptr->hash;
10649
10650 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10651 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10652
10653 if (pot_cnt == pot_hashes_avail)
10654 {
10655 uint pos = 0;
10656
10657 for (pos = 0; pos < INCR_POT; pos++)
10658 {
10659 if ((pot_cnt + pos) >= pot_avail) break;
10660
10661 pot_t *tmp_pot = &pot[pot_cnt + pos];
10662
10663 hash_t *tmp_hash = &tmp_pot->hash;
10664
10665 tmp_hash->digest = mymalloc (dgst_size);
10666
10667 if (isSalted)
10668 {
10669 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10670 }
10671
10672 if (esalt_size)
10673 {
10674 tmp_hash->esalt = mymalloc (esalt_size);
10675 }
10676
10677 pot_hashes_avail++;
10678 }
10679 }
10680
10681 int plain_len = 0;
10682
10683 int parser_status;
10684
10685 int iter = MAX_CUT_TRIES;
10686
10687 do
10688 {
10689 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10690 {
10691 if (line_buf[i] == ':')
10692 {
10693 line_len--;
10694
10695 break;
10696 }
10697 }
10698
10699 if (data.hash_mode != 2500)
10700 {
10701 parser_status = parse_func (line_buf, line_len, hashes_buf);
10702 }
10703 else
10704 {
10705 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10706
10707 if (line_len > max_salt_size)
10708 {
10709 parser_status = PARSER_GLOBAL_LENGTH;
10710 }
10711 else
10712 {
10713 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10714
10715 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10716
10717 hashes_buf->salt->salt_len = line_len;
10718
10719 parser_status = PARSER_OK;
10720 }
10721 }
10722
10723 // if NOT parsed without error, we add the ":" to the plain
10724
10725 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10726 {
10727 plain_len++;
10728 plain_buf--;
10729 }
10730
10731 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10732
10733 if (parser_status < PARSER_GLOBAL_ZERO)
10734 {
10735 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10736
10737 continue;
10738 }
10739
10740 if (plain_len >= 255) continue;
10741
10742 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10743
10744 pot_ptr->plain_len = plain_len;
10745
10746 pot_cnt++;
10747 }
10748
10749 fclose (pot_fp);
10750
10751 SUPPRESS_OUTPUT = 0;
10752
10753 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10754 }
10755
10756 /**
10757 * word len
10758 */
10759
10760 uint pw_min = PW_MIN;
10761 uint pw_max = PW_MAX;
10762
10763 switch (hash_mode)
10764 {
10765 case 400: if (pw_max > 40) pw_max = 40;
10766 break;
10767 case 500: if (pw_max > 16) pw_max = 16;
10768 break;
10769 case 1500: if (pw_max > 8) pw_max = 8;
10770 break;
10771 case 1600: if (pw_max > 16) pw_max = 16;
10772 break;
10773 case 1800: if (pw_max > 16) pw_max = 16;
10774 break;
10775 case 2100: if (pw_max > 16) pw_max = 16;
10776 break;
10777 case 2500: if (pw_min < 8) pw_min = 8;
10778 break;
10779 case 3000: if (pw_max > 7) pw_max = 7;
10780 break;
10781 case 5200: if (pw_max > 24) pw_max = 24;
10782 break;
10783 case 5800: if (pw_max > 16) pw_max = 16;
10784 break;
10785 case 6300: if (pw_max > 16) pw_max = 16;
10786 break;
10787 case 7400: if (pw_max > 16) pw_max = 16;
10788 break;
10789 case 7900: if (pw_max > 48) pw_max = 48;
10790 break;
10791 case 8500: if (pw_max > 8) pw_max = 8;
10792 break;
10793 case 8600: if (pw_max > 16) pw_max = 16;
10794 break;
10795 case 9710: pw_min = 5;
10796 pw_max = 5;
10797 break;
10798 case 9810: pw_min = 5;
10799 pw_max = 5;
10800 break;
10801 case 10410: pw_min = 5;
10802 pw_max = 5;
10803 break;
10804 case 10300: if (pw_max < 3) pw_min = 3;
10805 if (pw_max > 40) pw_max = 40;
10806 break;
10807 case 10500: if (pw_max < 3) pw_min = 3;
10808 if (pw_max > 40) pw_max = 40;
10809 break;
10810 case 10700: if (pw_max > 16) pw_max = 16;
10811 break;
10812 case 11300: if (pw_max > 40) pw_max = 40;
10813 break;
10814 case 12500: if (pw_max > 20) pw_max = 20;
10815 break;
10816 case 12800: if (pw_max > 24) pw_max = 24;
10817 break;
10818 }
10819
10820 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10821 {
10822 switch (attack_kern)
10823 {
10824 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10825 break;
10826 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10827 break;
10828 }
10829 }
10830
10831 /**
10832 * charsets : keep them together for more easy maintainnce
10833 */
10834
10835 cs_t mp_sys[6] = { { { 0 }, 0 } };
10836 cs_t mp_usr[4] = { { { 0 }, 0 } };
10837
10838 mp_setup_sys (mp_sys);
10839
10840 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10841 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10842 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10843 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10844
10845 /**
10846 * load hashes, part I: find input mode, count hashes
10847 */
10848
10849 uint hashlist_mode = 0;
10850 uint hashlist_format = HLFMT_HASHCAT;
10851
10852 uint hashes_avail = 0;
10853
10854 if (benchmark == 0)
10855 {
10856 struct stat f;
10857
10858 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10859
10860 if ((hash_mode == 2500) ||
10861 (hash_mode == 5200) ||
10862 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10863 (hash_mode == 9000))
10864 {
10865 hashlist_mode = HL_MODE_ARG;
10866
10867 char *hashfile = myargv[optind];
10868
10869 data.hashfile = hashfile;
10870
10871 logfile_top_var_string ("target", hashfile);
10872 }
10873
10874 if (hashlist_mode == HL_MODE_ARG)
10875 {
10876 if (hash_mode == 2500)
10877 {
10878 struct stat st;
10879
10880 if (stat (data.hashfile, &st) == -1)
10881 {
10882 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10883
10884 return (-1);
10885 }
10886
10887 hashes_avail = st.st_size / sizeof (hccap_t);
10888 }
10889 else
10890 {
10891 hashes_avail = 1;
10892 }
10893 }
10894 else if (hashlist_mode == HL_MODE_FILE)
10895 {
10896 char *hashfile = myargv[optind];
10897
10898 data.hashfile = hashfile;
10899
10900 logfile_top_var_string ("target", hashfile);
10901
10902 FILE *fp = NULL;
10903
10904 if ((fp = fopen (hashfile, "rb")) == NULL)
10905 {
10906 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10907
10908 return (-1);
10909 }
10910
10911 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10912
10913 hashes_avail = count_lines (fp);
10914
10915 rewind (fp);
10916
10917 if (hashes_avail == 0)
10918 {
10919 log_error ("ERROR: hashfile is empty or corrupt");
10920
10921 fclose (fp);
10922
10923 return (-1);
10924 }
10925
10926 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10927
10928 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10929 {
10930 log_error ("ERROR: remove not supported in native hashfile-format mode");
10931
10932 fclose (fp);
10933
10934 return (-1);
10935 }
10936
10937 fclose (fp);
10938 }
10939 }
10940 else
10941 {
10942 hashlist_mode = HL_MODE_ARG;
10943
10944 hashes_avail = 1;
10945 }
10946
10947 if (hash_mode == 3000) hashes_avail *= 2;
10948
10949 data.hashlist_mode = hashlist_mode;
10950 data.hashlist_format = hashlist_format;
10951
10952 logfile_top_uint (hashlist_mode);
10953 logfile_top_uint (hashlist_format);
10954
10955 /**
10956 * load hashes, part II: allocate required memory, set pointers
10957 */
10958
10959 hash_t *hashes_buf = NULL;
10960 void *digests_buf = NULL;
10961 salt_t *salts_buf = NULL;
10962 void *esalts_buf = NULL;
10963
10964 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10965
10966 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10967
10968 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10969 {
10970 u32 hash_pos;
10971
10972 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10973 {
10974 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10975
10976 hashes_buf[hash_pos].hash_info = hash_info;
10977
10978 if (username && (remove || show || left))
10979 {
10980 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10981 }
10982
10983 if (benchmark)
10984 {
10985 hash_info->orighash = (char *) mymalloc (256);
10986 }
10987 }
10988 }
10989
10990 if (isSalted)
10991 {
10992 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10993
10994 if (esalt_size)
10995 {
10996 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10997 }
10998 }
10999 else
11000 {
11001 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11002 }
11003
11004 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11005 {
11006 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11007
11008 if (isSalted)
11009 {
11010 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11011
11012 if (esalt_size)
11013 {
11014 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11015 }
11016 }
11017 else
11018 {
11019 hashes_buf[hash_pos].salt = &salts_buf[0];
11020 }
11021 }
11022
11023 /**
11024 * load hashes, part III: parse hashes or generate them if benchmark
11025 */
11026
11027 uint hashes_cnt = 0;
11028
11029 if (benchmark == 0)
11030 {
11031 if (keyspace == 1)
11032 {
11033 // useless to read hash file for keyspace, cheat a little bit w/ optind
11034 }
11035 else if (hashes_avail == 0)
11036 {
11037 }
11038 else if (hashlist_mode == HL_MODE_ARG)
11039 {
11040 char *input_buf = myargv[optind];
11041
11042 uint input_len = strlen (input_buf);
11043
11044 logfile_top_var_string ("target", input_buf);
11045
11046 char *hash_buf = NULL;
11047 int hash_len = 0;
11048
11049 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11050
11051 if (hash_len)
11052 {
11053 if (opts_type & OPTS_TYPE_HASH_COPY)
11054 {
11055 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11056
11057 hash_info_tmp->orighash = mystrdup (hash_buf);
11058 }
11059
11060 if (isSalted)
11061 {
11062 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11063 }
11064
11065 int parser_status = PARSER_OK;
11066
11067 if (hash_mode == 2500)
11068 {
11069 if (hash_len == 0)
11070 {
11071 log_error ("ERROR: hccap file not specified");
11072
11073 return (-1);
11074 }
11075
11076 hashlist_mode = HL_MODE_FILE;
11077
11078 data.hashlist_mode = hashlist_mode;
11079
11080 FILE *fp = fopen (hash_buf, "rb");
11081
11082 if (fp == NULL)
11083 {
11084 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11085
11086 return (-1);
11087 }
11088
11089 if (hashes_avail < 1)
11090 {
11091 log_error ("ERROR: hccap file is empty or corrupt");
11092
11093 fclose (fp);
11094
11095 return (-1);
11096 }
11097
11098 uint hccap_size = sizeof (hccap_t);
11099
11100 char *in = (char *) mymalloc (hccap_size);
11101
11102 while (!feof (fp))
11103 {
11104 int n = fread (in, hccap_size, 1, fp);
11105
11106 if (n != 1)
11107 {
11108 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11109
11110 break;
11111 }
11112
11113 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11114
11115 if (parser_status != PARSER_OK)
11116 {
11117 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11118
11119 continue;
11120 }
11121
11122 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11123
11124 if ((show == 1) || (left == 1))
11125 {
11126 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11127
11128 char *salt_ptr = (char *) tmp_salt->salt_buf;
11129
11130 int cur_pos = tmp_salt->salt_len;
11131 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11132
11133 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11134
11135 u8 *pke_ptr = (u8 *) wpa->pke;
11136
11137 // do the appending task
11138
11139 snprintf (salt_ptr + cur_pos,
11140 rem_len,
11141 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11142 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
11143 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
11144
11145
11146 // memset () the remaining part of the salt
11147
11148 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11149 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11150
11151 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11152
11153 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11154 }
11155
11156 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);
11157 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);
11158
11159 hashes_cnt++;
11160 }
11161
11162 fclose (fp);
11163
11164 myfree (in);
11165 }
11166 else if (hash_mode == 3000)
11167 {
11168 if (hash_len == 32)
11169 {
11170 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11171
11172 hash_t *lm_hash_left = NULL;
11173
11174 if (parser_status == PARSER_OK)
11175 {
11176 lm_hash_left = &hashes_buf[hashes_cnt];
11177
11178 hashes_cnt++;
11179 }
11180 else
11181 {
11182 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11183 }
11184
11185 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11186
11187 hash_t *lm_hash_right = NULL;
11188
11189 if (parser_status == PARSER_OK)
11190 {
11191 lm_hash_right = &hashes_buf[hashes_cnt];
11192
11193 hashes_cnt++;
11194 }
11195 else
11196 {
11197 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11198 }
11199
11200 // show / left
11201
11202 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11203 {
11204 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);
11205 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);
11206 }
11207 }
11208 else
11209 {
11210 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11211
11212 if (parser_status == PARSER_OK)
11213 {
11214 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11215 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11216 }
11217
11218 if (parser_status == PARSER_OK)
11219 {
11220 hashes_cnt++;
11221 }
11222 else
11223 {
11224 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11225 }
11226 }
11227 }
11228 else
11229 {
11230 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11231
11232 if (parser_status == PARSER_OK)
11233 {
11234 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11235 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11236 }
11237
11238 if (parser_status == PARSER_OK)
11239 {
11240 hashes_cnt++;
11241 }
11242 else
11243 {
11244 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11245 }
11246 }
11247 }
11248 }
11249 else if (hashlist_mode == HL_MODE_FILE)
11250 {
11251 char *hashfile = data.hashfile;
11252
11253 FILE *fp;
11254
11255 if ((fp = fopen (hashfile, "rb")) == NULL)
11256 {
11257 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11258
11259 return (-1);
11260 }
11261
11262 uint line_num = 0;
11263
11264 while (!feof (fp))
11265 {
11266 line_num++;
11267
11268 char line_buf[BUFSIZ] = { 0 };
11269
11270 int line_len = fgetl (fp, line_buf);
11271
11272 if (line_len == 0) continue;
11273
11274 char *hash_buf = NULL;
11275 int hash_len = 0;
11276
11277 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11278
11279 if (username)
11280 {
11281 char *user_buf = NULL;
11282 int user_len = 0;
11283
11284 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11285
11286 if (remove || show)
11287 {
11288 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11289
11290 *user = (user_t *) mymalloc (sizeof (user_t));
11291
11292 user_t *user_ptr = *user;
11293
11294 if (user_buf != NULL)
11295 {
11296 user_ptr->user_name = mystrdup (user_buf);
11297 }
11298 else
11299 {
11300 user_ptr->user_name = mystrdup ("");
11301 }
11302
11303 user_ptr->user_len = user_len;
11304 }
11305 }
11306
11307 if (opts_type & OPTS_TYPE_HASH_COPY)
11308 {
11309 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11310
11311 hash_info_tmp->orighash = mystrdup (hash_buf);
11312 }
11313
11314 if (isSalted)
11315 {
11316 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11317 }
11318
11319 if (hash_mode == 3000)
11320 {
11321 if (hash_len == 32)
11322 {
11323 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11324
11325 if (parser_status < PARSER_GLOBAL_ZERO)
11326 {
11327 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11328
11329 continue;
11330 }
11331
11332 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11333
11334 hashes_cnt++;
11335
11336 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11337
11338 if (parser_status < PARSER_GLOBAL_ZERO)
11339 {
11340 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11341
11342 continue;
11343 }
11344
11345 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11346
11347 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);
11348
11349 hashes_cnt++;
11350
11351 // show / left
11352
11353 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);
11354 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);
11355 }
11356 else
11357 {
11358 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11359
11360 if (parser_status < PARSER_GLOBAL_ZERO)
11361 {
11362 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11363
11364 continue;
11365 }
11366
11367 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);
11368
11369 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11370 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11371
11372 hashes_cnt++;
11373 }
11374 }
11375 else
11376 {
11377 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11378
11379 if (parser_status < PARSER_GLOBAL_ZERO)
11380 {
11381 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11382
11383 continue;
11384 }
11385
11386 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);
11387
11388 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11389 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11390
11391 hashes_cnt++;
11392 }
11393 }
11394
11395 fclose (fp);
11396
11397 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11398
11399 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11400 }
11401 }
11402 else
11403 {
11404 if (isSalted)
11405 {
11406 hashes_buf[0].salt->salt_len = 8;
11407
11408 // special salt handling
11409
11410 switch (hash_mode)
11411 {
11412 case 1500: hashes_buf[0].salt->salt_len = 2;
11413 break;
11414 case 1731: hashes_buf[0].salt->salt_len = 4;
11415 break;
11416 case 2410: hashes_buf[0].salt->salt_len = 4;
11417 break;
11418 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11419 break;
11420 case 3100: hashes_buf[0].salt->salt_len = 1;
11421 break;
11422 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11423 break;
11424 case 5800: hashes_buf[0].salt->salt_len = 16;
11425 break;
11426 case 6800: hashes_buf[0].salt->salt_len = 32;
11427 break;
11428 case 8400: hashes_buf[0].salt->salt_len = 40;
11429 break;
11430 case 8800: hashes_buf[0].salt->salt_len = 16;
11431 break;
11432 case 8900: hashes_buf[0].salt->salt_len = 16;
11433 hashes_buf[0].salt->scrypt_N = 1024;
11434 hashes_buf[0].salt->scrypt_r = 1;
11435 hashes_buf[0].salt->scrypt_p = 1;
11436 break;
11437 case 9100: hashes_buf[0].salt->salt_len = 16;
11438 break;
11439 case 9300: hashes_buf[0].salt->salt_len = 14;
11440 hashes_buf[0].salt->scrypt_N = 16384;
11441 hashes_buf[0].salt->scrypt_r = 1;
11442 hashes_buf[0].salt->scrypt_p = 1;
11443 break;
11444 case 9400: hashes_buf[0].salt->salt_len = 16;
11445 break;
11446 case 9500: hashes_buf[0].salt->salt_len = 16;
11447 break;
11448 case 9600: hashes_buf[0].salt->salt_len = 16;
11449 break;
11450 case 9700: hashes_buf[0].salt->salt_len = 16;
11451 break;
11452 case 9710: hashes_buf[0].salt->salt_len = 16;
11453 break;
11454 case 9720: hashes_buf[0].salt->salt_len = 16;
11455 break;
11456 case 9800: hashes_buf[0].salt->salt_len = 16;
11457 break;
11458 case 9810: hashes_buf[0].salt->salt_len = 16;
11459 break;
11460 case 9820: hashes_buf[0].salt->salt_len = 16;
11461 break;
11462 case 10300: hashes_buf[0].salt->salt_len = 12;
11463 break;
11464 case 11500: hashes_buf[0].salt->salt_len = 4;
11465 break;
11466 case 11600: hashes_buf[0].salt->salt_len = 4;
11467 break;
11468 case 12400: hashes_buf[0].salt->salt_len = 4;
11469 break;
11470 case 12500: hashes_buf[0].salt->salt_len = 8;
11471 break;
11472 case 12600: hashes_buf[0].salt->salt_len = 64;
11473 break;
11474 }
11475
11476 // special esalt handling
11477
11478 switch (hash_mode)
11479 {
11480 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11481 break;
11482 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11483 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11484 break;
11485 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11486 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11487 break;
11488 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11489 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11490 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11491 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11492 break;
11493 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11494 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11495 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11496 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11497 break;
11498 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11499 break;
11500 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11501 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11502 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11503 break;
11504 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11505 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11506 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11507 break;
11508 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11509 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11510 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11511 break;
11512 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11513 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11514 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11515 break;
11516 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11517 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11518 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11519 break;
11520 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11521 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11522 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11523 break;
11524 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11525 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11526 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11527 break;
11528 }
11529 }
11530
11531 // set hashfile
11532
11533 switch (hash_mode)
11534 {
11535 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11536 break;
11537 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11538 break;
11539 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11540 break;
11541 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11542 break;
11543 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11544 break;
11545 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11546 break;
11547 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11548 break;
11549 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11550 break;
11551 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11552 break;
11553 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11554 break;
11555 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11556 break;
11557 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11558 break;
11559 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11560 break;
11561 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11562 break;
11563 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11564 break;
11565 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11566 break;
11567 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11568 break;
11569 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11570 break;
11571 }
11572
11573 // set default iterations
11574
11575 switch (hash_mode)
11576 {
11577 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11578 break;
11579 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11580 break;
11581 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11582 break;
11583 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11584 break;
11585 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11586 break;
11587 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11588 break;
11589 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11590 break;
11591 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11592 break;
11593 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11594 break;
11595 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11596 break;
11597 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11598 break;
11599 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11600 break;
11601 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11602 break;
11603 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11604 break;
11605 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11606 break;
11607 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11608 break;
11609 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11610 break;
11611 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11612 break;
11613 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11614 break;
11615 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11616 break;
11617 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11618 break;
11619 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11620 break;
11621 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11622 break;
11623 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11624 break;
11625 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11626 break;
11627 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11628 break;
11629 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11630 break;
11631 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11632 break;
11633 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11634 break;
11635 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11636 break;
11637 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11638 break;
11639 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11640 break;
11641 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11642 break;
11643 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11644 break;
11645 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11646 break;
11647 case 8900: hashes_buf[0].salt->salt_iter = 1;
11648 break;
11649 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11650 break;
11651 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11652 break;
11653 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11654 break;
11655 case 9300: hashes_buf[0].salt->salt_iter = 1;
11656 break;
11657 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11658 break;
11659 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11660 break;
11661 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11662 break;
11663 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11664 break;
11665 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11666 break;
11667 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11668 break;
11669 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11670 break;
11671 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11672 break;
11673 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11674 break;
11675 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11676 break;
11677 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11678 break;
11679 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11680 break;
11681 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11682 break;
11683 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11684 break;
11685 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11686 break;
11687 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11688 break;
11689 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11690 break;
11691 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11692 break;
11693 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11694 break;
11695 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11696 break;
11697 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11698 break;
11699 }
11700
11701 hashes_cnt = 1;
11702 }
11703
11704 if (show == 1 || left == 1)
11705 {
11706 for (uint i = 0; i < pot_cnt; i++)
11707 {
11708 pot_t *pot_ptr = &pot[i];
11709
11710 hash_t *hashes_buf = &pot_ptr->hash;
11711
11712 local_free (hashes_buf->digest);
11713
11714 if (isSalted)
11715 {
11716 local_free (hashes_buf->salt);
11717 }
11718 }
11719
11720 local_free (pot);
11721
11722 if (data.quiet == 0) log_info_nn ("");
11723
11724 return (0);
11725 }
11726
11727 if (keyspace == 0)
11728 {
11729 if (hashes_cnt == 0)
11730 {
11731 log_error ("ERROR: No hashes loaded");
11732
11733 return (-1);
11734 }
11735 }
11736
11737 /**
11738 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11739 */
11740
11741 if (data.outfile != NULL)
11742 {
11743 if (data.hashfile != NULL)
11744 {
11745 #ifdef _POSIX
11746 struct stat tmpstat_outfile;
11747 struct stat tmpstat_hashfile;
11748 #endif
11749
11750 #ifdef _WIN
11751 struct stat64 tmpstat_outfile;
11752 struct stat64 tmpstat_hashfile;
11753 #endif
11754
11755 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11756
11757 if (tmp_outfile_fp)
11758 {
11759 #ifdef _POSIX
11760 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11761 #endif
11762
11763 #ifdef _WIN
11764 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11765 #endif
11766
11767 fclose (tmp_outfile_fp);
11768 }
11769
11770 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11771
11772 if (tmp_hashfile_fp)
11773 {
11774 #ifdef _POSIX
11775 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11776 #endif
11777
11778 #ifdef _WIN
11779 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11780 #endif
11781
11782 fclose (tmp_hashfile_fp);
11783 }
11784
11785 if (tmp_outfile_fp && tmp_outfile_fp)
11786 {
11787 tmpstat_outfile.st_mode = 0;
11788 tmpstat_outfile.st_nlink = 0;
11789 tmpstat_outfile.st_uid = 0;
11790 tmpstat_outfile.st_gid = 0;
11791 tmpstat_outfile.st_rdev = 0;
11792 tmpstat_outfile.st_atime = 0;
11793
11794 tmpstat_hashfile.st_mode = 0;
11795 tmpstat_hashfile.st_nlink = 0;
11796 tmpstat_hashfile.st_uid = 0;
11797 tmpstat_hashfile.st_gid = 0;
11798 tmpstat_hashfile.st_rdev = 0;
11799 tmpstat_hashfile.st_atime = 0;
11800
11801 #ifdef _POSIX
11802 tmpstat_outfile.st_blksize = 0;
11803 tmpstat_outfile.st_blocks = 0;
11804
11805 tmpstat_hashfile.st_blksize = 0;
11806 tmpstat_hashfile.st_blocks = 0;
11807 #endif
11808
11809 #ifdef _POSIX
11810 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11811 {
11812 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11813
11814 return (-1);
11815 }
11816 #endif
11817
11818 #ifdef _WIN
11819 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11820 {
11821 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11822
11823 return (-1);
11824 }
11825 #endif
11826 }
11827 }
11828 }
11829
11830 /**
11831 * Remove duplicates
11832 */
11833
11834 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11835
11836 if (isSalted)
11837 {
11838 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11839 }
11840 else
11841 {
11842 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11843 }
11844
11845 uint hashes_cnt_orig = hashes_cnt;
11846
11847 hashes_cnt = 1;
11848
11849 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11850 {
11851 if (isSalted)
11852 {
11853 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11854 {
11855 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11856 }
11857 }
11858 else
11859 {
11860 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11861 }
11862
11863 if (hashes_pos > hashes_cnt)
11864 {
11865 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11866 }
11867
11868 hashes_cnt++;
11869 }
11870
11871 /**
11872 * Potfile removes
11873 */
11874
11875 uint potfile_remove_cracks = 0;
11876
11877 if (potfile_disable == 0)
11878 {
11879 hash_t hash_buf;
11880
11881 hash_buf.digest = mymalloc (dgst_size);
11882 hash_buf.salt = NULL;
11883 hash_buf.esalt = NULL;
11884 hash_buf.hash_info = NULL;
11885 hash_buf.cracked = 0;
11886
11887 if (isSalted)
11888 {
11889 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11890 }
11891
11892 if (esalt_size)
11893 {
11894 hash_buf.esalt = mymalloc (esalt_size);
11895 }
11896
11897 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11898
11899 // no solution for these special hash types (for instane because they use hashfile in output etc)
11900 if ((hash_mode != 5200) &&
11901 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11902 (hash_mode != 9000))
11903 {
11904 FILE *fp = fopen (potfile, "rb");
11905
11906 if (fp != NULL)
11907 {
11908 while (!feof (fp))
11909 {
11910 char line_buf[BUFSIZ] = { 0 };
11911
11912 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11913
11914 if (ptr == NULL) break;
11915
11916 int line_len = strlen (line_buf);
11917
11918 if (line_len == 0) continue;
11919
11920 int iter = MAX_CUT_TRIES;
11921
11922 for (int i = line_len - 1; i && iter; i--, line_len--)
11923 {
11924 if (line_buf[i] != ':') continue;
11925
11926 if (isSalted)
11927 {
11928 memset (hash_buf.salt, 0, sizeof (salt_t));
11929 }
11930
11931 hash_t *found = NULL;
11932
11933 if (hash_mode == 6800)
11934 {
11935 if (i < 64) // 64 = 16 * uint in salt_buf[]
11936 {
11937 // manipulate salt_buf
11938 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11939
11940 hash_buf.salt->salt_len = i;
11941
11942 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11943 }
11944 }
11945 else if (hash_mode == 2500)
11946 {
11947 if (i < 64) // 64 = 16 * uint in salt_buf[]
11948 {
11949 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11950 // manipulate salt_buf
11951
11952 // to be safe work with a copy (because of line_len loop, i etc)
11953
11954 char line_buf_cpy[BUFSIZ] = { 0 };
11955
11956 memcpy (line_buf_cpy, line_buf, i);
11957
11958 char *mac2_pos = strrchr (line_buf_cpy, ':');
11959
11960 if (mac2_pos == NULL) continue;
11961
11962 mac2_pos[0] = 0;
11963 mac2_pos++;
11964
11965 if (strlen (mac2_pos) != 12) continue;
11966
11967 char *mac1_pos = strrchr (line_buf_cpy, ':');
11968
11969 if (mac1_pos == NULL) continue;
11970
11971 mac1_pos[0] = 0;
11972 mac1_pos++;
11973
11974 if (strlen (mac1_pos) != 12) continue;
11975
11976 uint essid_length = mac1_pos - line_buf_cpy - 1;
11977
11978 // here we need the ESSID
11979 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11980
11981 hash_buf.salt->salt_len = essid_length;
11982
11983 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11984
11985 if (found)
11986 {
11987 wpa_t *wpa = (wpa_t *) found->esalt;
11988
11989 uint pke[25] = { 0 };
11990
11991 char *pke_ptr = (char *) pke;
11992
11993 for (uint i = 0; i < 25; i++)
11994 {
11995 pke[i] = byte_swap_32 (wpa->pke[i]);
11996 }
11997
11998 u8 mac1[6] = { 0 };
11999 u8 mac2[6] = { 0 };
12000
12001 memcpy (mac1, pke_ptr + 23, 6);
12002 memcpy (mac2, pke_ptr + 29, 6);
12003
12004 // compare hex string(s) vs binary MAC address(es)
12005
12006 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12007 {
12008 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12009 {
12010 found = NULL;
12011 break;
12012 }
12013 }
12014
12015 // early skip ;)
12016 if (!found) continue;
12017
12018 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12019 {
12020 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12021 {
12022 found = NULL;
12023 break;
12024 }
12025 }
12026 }
12027 }
12028 }
12029 else
12030 {
12031 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12032
12033 if (parser_status == PARSER_OK)
12034 {
12035 if (isSalted)
12036 {
12037 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12038 }
12039 else
12040 {
12041 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12042 }
12043 }
12044 }
12045
12046 if (found == NULL) continue;
12047
12048 if (!found->cracked) potfile_remove_cracks++;
12049
12050 found->cracked = 1;
12051
12052 if (found) break;
12053
12054 iter--;
12055 }
12056 }
12057
12058 fclose (fp);
12059 }
12060 }
12061
12062 if (esalt_size)
12063 {
12064 local_free (hash_buf.esalt);
12065 }
12066
12067 if (isSalted)
12068 {
12069 local_free (hash_buf.salt);
12070 }
12071
12072 local_free (hash_buf.digest);
12073 }
12074
12075 /**
12076 * Now generate all the buffers required for later
12077 */
12078
12079 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12080
12081 salt_t *salts_buf_new = NULL;
12082 void *esalts_buf_new = NULL;
12083
12084 if (isSalted)
12085 {
12086 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12087
12088 if (esalt_size)
12089 {
12090 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12091 }
12092 }
12093 else
12094 {
12095 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12096 }
12097
12098 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12099
12100 uint digests_cnt = hashes_cnt;
12101 uint digests_done = 0;
12102
12103 uint size_digests = digests_cnt * dgst_size;
12104 uint size_shown = digests_cnt * sizeof (uint);
12105
12106 uint *digests_shown = (uint *) mymalloc (size_shown);
12107 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12108
12109 uint salts_cnt = 0;
12110 uint salts_done = 0;
12111
12112 hashinfo_t **hash_info = NULL;
12113
12114 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12115 {
12116 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12117
12118 if (username && (remove || show))
12119 {
12120 uint user_pos;
12121
12122 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12123 {
12124 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12125
12126 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12127 }
12128 }
12129 }
12130
12131 uint *salts_shown = (uint *) mymalloc (size_shown);
12132
12133 salt_t *salt_buf;
12134
12135 {
12136 // copied from inner loop
12137
12138 salt_buf = &salts_buf_new[salts_cnt];
12139
12140 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12141
12142 if (esalt_size)
12143 {
12144 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12145 }
12146
12147 salt_buf->digests_cnt = 0;
12148 salt_buf->digests_done = 0;
12149 salt_buf->digests_offset = 0;
12150
12151 salts_cnt++;
12152 }
12153
12154 if (hashes_buf[0].cracked == 1)
12155 {
12156 digests_shown[0] = 1;
12157
12158 digests_done++;
12159
12160 salt_buf->digests_done++;
12161 }
12162
12163 salt_buf->digests_cnt++;
12164
12165 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12166
12167 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12168 {
12169 hash_info[0] = hashes_buf[0].hash_info;
12170 }
12171
12172 // copy from inner loop
12173
12174 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12175 {
12176 if (isSalted)
12177 {
12178 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12179 {
12180 salt_buf = &salts_buf_new[salts_cnt];
12181
12182 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12183
12184 if (esalt_size)
12185 {
12186 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12187 }
12188
12189 salt_buf->digests_cnt = 0;
12190 salt_buf->digests_done = 0;
12191 salt_buf->digests_offset = hashes_pos;
12192
12193 salts_cnt++;
12194 }
12195 }
12196
12197 if (hashes_buf[hashes_pos].cracked == 1)
12198 {
12199 digests_shown[hashes_pos] = 1;
12200
12201 digests_done++;
12202
12203 salt_buf->digests_done++;
12204 }
12205
12206 salt_buf->digests_cnt++;
12207
12208 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12209
12210 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12211 {
12212 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12213 }
12214 }
12215
12216 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12217 {
12218 salt_t *salt_buf = &salts_buf_new[salt_pos];
12219
12220 if (salt_buf->digests_done == salt_buf->digests_cnt)
12221 {
12222 salts_shown[salt_pos] = 1;
12223
12224 salts_done++;
12225 }
12226
12227 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12228 }
12229
12230 local_free (digests_buf);
12231 local_free (salts_buf);
12232 local_free (esalts_buf);
12233
12234 digests_buf = digests_buf_new;
12235 salts_buf = salts_buf_new;
12236 esalts_buf = esalts_buf_new;
12237
12238 local_free (hashes_buf);
12239
12240 /**
12241 * special modification not set from parser
12242 */
12243
12244 switch (hash_mode)
12245 {
12246 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12247 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12248 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12249 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12250 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12251 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12252 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12253 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12254 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12255 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12256 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12257 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12258 }
12259
12260 if (truecrypt_keyfiles)
12261 {
12262 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12263
12264 char *keyfiles = strdup (truecrypt_keyfiles);
12265
12266 char *keyfile = strtok (keyfiles, ",");
12267
12268 do
12269 {
12270 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12271
12272 } while ((keyfile = strtok (NULL, ",")) != NULL);
12273
12274 free (keyfiles);
12275 }
12276
12277 data.digests_cnt = digests_cnt;
12278 data.digests_done = digests_done;
12279 data.digests_buf = digests_buf;
12280 data.digests_shown = digests_shown;
12281 data.digests_shown_tmp = digests_shown_tmp;
12282
12283 data.salts_cnt = salts_cnt;
12284 data.salts_done = salts_done;
12285 data.salts_buf = salts_buf;
12286 data.salts_shown = salts_shown;
12287
12288 data.esalts_buf = esalts_buf;
12289 data.hash_info = hash_info;
12290
12291 /**
12292 * Automatic Optimizers
12293 */
12294
12295 if (salts_cnt == 1)
12296 opti_type |= OPTI_TYPE_SINGLE_SALT;
12297
12298 if (digests_cnt == 1)
12299 opti_type |= OPTI_TYPE_SINGLE_HASH;
12300
12301 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12302 opti_type |= OPTI_TYPE_NOT_ITERATED;
12303
12304 if (attack_mode == ATTACK_MODE_BF)
12305 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12306
12307 data.opti_type = opti_type;
12308
12309 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12310 {
12311 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12312 {
12313 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12314 {
12315 if (opts_type & OPTS_TYPE_ST_ADD80)
12316 {
12317 opts_type &= ~OPTS_TYPE_ST_ADD80;
12318 opts_type |= OPTS_TYPE_PT_ADD80;
12319 }
12320
12321 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12322 {
12323 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12324 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12325 }
12326
12327 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12328 {
12329 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12330 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12331 }
12332 }
12333 }
12334 }
12335
12336 /**
12337 * Some algorithm, like descrypt, can benefit from JIT compilation
12338 */
12339
12340 int force_jit_compilation = -1;
12341
12342 if (hash_mode == 8900)
12343 {
12344 force_jit_compilation = 8900;
12345 }
12346 else if (hash_mode == 9300)
12347 {
12348 force_jit_compilation = 8900;
12349 }
12350 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12351 {
12352 force_jit_compilation = 1500;
12353 }
12354
12355 /**
12356 * generate bitmap tables
12357 */
12358
12359 const uint bitmap_shift1 = 5;
12360 const uint bitmap_shift2 = 13;
12361
12362 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12363
12364 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12365 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12366 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12367 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12368 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12369 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12370 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12371 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12372
12373 uint bitmap_bits;
12374 uint bitmap_nums;
12375 uint bitmap_mask;
12376 uint bitmap_size;
12377
12378 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12379 {
12380 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12381
12382 bitmap_nums = 1 << bitmap_bits;
12383
12384 bitmap_mask = bitmap_nums - 1;
12385
12386 bitmap_size = bitmap_nums * sizeof (uint);
12387
12388 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12389
12390 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;
12391 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;
12392
12393 break;
12394 }
12395
12396 bitmap_nums = 1 << bitmap_bits;
12397
12398 bitmap_mask = bitmap_nums - 1;
12399
12400 bitmap_size = bitmap_nums * sizeof (uint);
12401
12402 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);
12403 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);
12404
12405 /**
12406 * prepare quick rule
12407 */
12408
12409 data.rule_buf_l = rule_buf_l;
12410 data.rule_buf_r = rule_buf_r;
12411
12412 int rule_len_l = (int) strlen (rule_buf_l);
12413 int rule_len_r = (int) strlen (rule_buf_r);
12414
12415 data.rule_len_l = rule_len_l;
12416 data.rule_len_r = rule_len_r;
12417
12418 /**
12419 * load rules
12420 */
12421
12422 uint *all_kernel_rules_cnt = NULL;
12423
12424 kernel_rule_t **all_kernel_rules_buf = NULL;
12425
12426 if (rp_files_cnt)
12427 {
12428 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12429
12430 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12431 }
12432
12433 char rule_buf[BUFSIZ] = { 0 };
12434
12435 int rule_len = 0;
12436
12437 for (uint i = 0; i < rp_files_cnt; i++)
12438 {
12439 uint kernel_rules_avail = 0;
12440
12441 uint kernel_rules_cnt = 0;
12442
12443 kernel_rule_t *kernel_rules_buf = NULL;
12444
12445 char *rp_file = rp_files[i];
12446
12447 char in[BLOCK_SIZE] = { 0 };
12448 char out[BLOCK_SIZE] = { 0 };
12449
12450 FILE *fp = NULL;
12451
12452 uint rule_line = 0;
12453
12454 if ((fp = fopen (rp_file, "rb")) == NULL)
12455 {
12456 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12457
12458 return (-1);
12459 }
12460
12461 while (!feof (fp))
12462 {
12463 memset (rule_buf, 0, BUFSIZ);
12464
12465 rule_len = fgetl (fp, rule_buf);
12466
12467 rule_line++;
12468
12469 if (rule_len == 0) continue;
12470
12471 if (rule_buf[0] == '#') continue;
12472
12473 if (kernel_rules_avail == kernel_rules_cnt)
12474 {
12475 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12476
12477 kernel_rules_avail += INCR_RULES;
12478 }
12479
12480 memset (in, 0, BLOCK_SIZE);
12481 memset (out, 0, BLOCK_SIZE);
12482
12483 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12484
12485 if (result == -1)
12486 {
12487 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12488
12489 continue;
12490 }
12491
12492 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12493 {
12494 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12495
12496 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12497
12498 continue;
12499 }
12500
12501 /* its so slow
12502 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12503 {
12504 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12505
12506 continue;
12507 }
12508 */
12509
12510 kernel_rules_cnt++;
12511 }
12512
12513 fclose (fp);
12514
12515 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12516
12517 all_kernel_rules_buf[i] = kernel_rules_buf;
12518 }
12519
12520 /**
12521 * merge rules or automatic rule generator
12522 */
12523
12524 uint kernel_rules_cnt = 0;
12525
12526 kernel_rule_t *kernel_rules_buf = NULL;
12527
12528 if (attack_mode == ATTACK_MODE_STRAIGHT)
12529 {
12530 if (rp_files_cnt)
12531 {
12532 kernel_rules_cnt = 1;
12533
12534 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12535
12536 repeats[0] = kernel_rules_cnt;
12537
12538 for (uint i = 0; i < rp_files_cnt; i++)
12539 {
12540 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12541
12542 repeats[i + 1] = kernel_rules_cnt;
12543 }
12544
12545 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12546
12547 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12548
12549 for (uint i = 0; i < kernel_rules_cnt; i++)
12550 {
12551 uint out_pos = 0;
12552
12553 kernel_rule_t *out = &kernel_rules_buf[i];
12554
12555 for (uint j = 0; j < rp_files_cnt; j++)
12556 {
12557 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12558 uint in_pos;
12559
12560 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12561
12562 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12563 {
12564 if (out_pos == RULES_MAX - 1)
12565 {
12566 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12567
12568 break;
12569 }
12570
12571 out->cmds[out_pos] = in->cmds[in_pos];
12572 }
12573 }
12574 }
12575
12576 local_free (repeats);
12577 }
12578 else if (rp_gen)
12579 {
12580 uint kernel_rules_avail = 0;
12581
12582 while (kernel_rules_cnt < rp_gen)
12583 {
12584 if (kernel_rules_avail == kernel_rules_cnt)
12585 {
12586 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12587
12588 kernel_rules_avail += INCR_RULES;
12589 }
12590
12591 memset (rule_buf, 0, BLOCK_SIZE);
12592
12593 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12594
12595 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12596
12597 kernel_rules_cnt++;
12598 }
12599 }
12600 }
12601
12602 /**
12603 * generate NOP rules
12604 */
12605
12606 if (kernel_rules_cnt == 0)
12607 {
12608 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12609
12610 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12611
12612 kernel_rules_cnt++;
12613 }
12614
12615 data.kernel_rules_cnt = kernel_rules_cnt;
12616 data.kernel_rules_buf = kernel_rules_buf;
12617
12618 /**
12619 * OpenCL platforms: detect
12620 */
12621
12622 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12623 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12624
12625 cl_uint platforms_cnt = 0;
12626 cl_uint platform_devices_cnt = 0;
12627
12628 if (keyspace == 0)
12629 {
12630 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12631
12632 if (platforms_cnt == 0)
12633 {
12634 log_error ("ERROR: No OpenCL compatible platform found");
12635
12636 return (-1);
12637 }
12638 }
12639
12640 /**
12641 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12642 */
12643
12644 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12645 {
12646 cl_platform_id platform = platforms[platform_id];
12647
12648 char platform_vendor[INFOSZ] = { 0 };
12649
12650 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12651
12652 #ifdef HAVE_HWMON
12653 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12654 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12655 {
12656 // make sure that we do not directly control the fan for NVidia
12657
12658 gpu_temp_retain = 0;
12659
12660 data.gpu_temp_retain = gpu_temp_retain;
12661 }
12662 #endif // HAVE_NVML || HAVE_NVAPI
12663 #endif
12664 }
12665
12666 /**
12667 * OpenCL devices: simply push all devices from all platforms into the same device array
12668 */
12669
12670 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12671
12672 data.devices_param = devices_param;
12673
12674 uint devices_cnt = 0;
12675
12676 uint devices_active = 0;
12677
12678 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12679 {
12680 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12681
12682 cl_platform_id platform = platforms[platform_id];
12683
12684 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12685
12686 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12687 {
12688 size_t param_value_size = 0;
12689
12690 const uint device_id = devices_cnt;
12691
12692 hc_device_param_t *device_param = &data.devices_param[device_id];
12693
12694 device_param->device = platform_devices[platform_devices_id];
12695
12696 device_param->device_id = device_id;
12697
12698 device_param->platform_devices_id = platform_devices_id;
12699
12700 // device_type
12701
12702 cl_device_type device_type;
12703
12704 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12705
12706 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12707
12708 device_param->device_type = device_type;
12709
12710 // vendor_id
12711
12712 cl_uint vendor_id = 0;
12713
12714 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12715
12716 device_param->vendor_id = vendor_id;
12717
12718 // device_name
12719
12720 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12721
12722 char *device_name = (char *) mymalloc (param_value_size);
12723
12724 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12725
12726 device_param->device_name = device_name;
12727
12728 // tuning db
12729
12730 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param->device_name, attack_mode, hash_mode);
12731
12732 // device_version
12733
12734 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12735
12736 char *device_version = (char *) mymalloc (param_value_size);
12737
12738 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12739
12740 device_param->device_version = device_version;
12741
12742 // device_opencl_version
12743
12744 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12745
12746 char *device_opencl_version = (char *) mymalloc (param_value_size);
12747
12748 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12749
12750 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12751
12752 myfree (device_opencl_version);
12753
12754 if (strstr (device_version, "pocl"))
12755 {
12756 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12757 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12758
12759 cl_uint vendor_id = VENDOR_ID_GENERIC;
12760
12761 device_param->vendor_id = vendor_id;
12762 }
12763
12764 // vector_width
12765
12766 cl_uint vector_width;
12767
12768 if (opencl_vector_width_chgd == 0)
12769 {
12770 if (tuningdb_entry == NULL)
12771 {
12772 if (opti_type & OPTI_TYPE_USES_BITS_64)
12773 {
12774 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12775 }
12776 else
12777 {
12778 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12779 }
12780 }
12781 else
12782 {
12783 if (tuningdb_entry->vector_width == -1)
12784 {
12785 if (opti_type & OPTI_TYPE_USES_BITS_64)
12786 {
12787 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12788 }
12789 else
12790 {
12791 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12792 }
12793 }
12794 else
12795 {
12796 vector_width = (cl_uint) tuningdb_entry->vector_width;
12797 }
12798 }
12799 }
12800 else
12801 {
12802 vector_width = opencl_vector_width;
12803 }
12804
12805 if (vector_width > 8) vector_width = 8;
12806
12807 device_param->vector_width = vector_width;
12808
12809 // max_compute_units
12810
12811 cl_uint device_processors;
12812
12813 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12814
12815 device_param->device_processors = device_processors;
12816
12817 // max_mem_alloc_size
12818
12819 cl_ulong device_maxmem_alloc;
12820
12821 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12822
12823 device_param->device_maxmem_alloc = device_maxmem_alloc;
12824
12825 // max_mem_alloc_size
12826
12827 cl_ulong device_global_mem;
12828
12829 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12830
12831 device_param->device_global_mem = device_global_mem;
12832
12833 // max_clock_frequency
12834
12835 cl_uint device_maxclock_frequency;
12836
12837 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12838
12839 device_param->device_maxclock_frequency = device_maxclock_frequency;
12840
12841 // skipped
12842
12843 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12844 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12845
12846 device_param->skipped = (skipped1 || skipped2);
12847
12848 // driver_version
12849 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12850
12851 char *driver_version = (char *) mymalloc (param_value_size);
12852
12853 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12854
12855 device_param->driver_version = driver_version;
12856
12857 // device_name_chksum
12858
12859 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12860
12861 #if __x86_64__
12862 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 64, device_param->vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
12863 #else
12864 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 32, device_param->vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
12865 #endif
12866
12867 uint device_name_digest[4] = { 0 };
12868
12869 md5_64 ((uint *) device_name_chksum, device_name_digest);
12870
12871 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12872
12873 device_param->device_name_chksum = device_name_chksum;
12874
12875 // device_processor_cores
12876
12877 if (device_type & CL_DEVICE_TYPE_CPU)
12878 {
12879 cl_uint device_processor_cores = 1;
12880
12881 device_param->device_processor_cores = device_processor_cores;
12882 }
12883
12884 if (device_type & CL_DEVICE_TYPE_GPU)
12885 {
12886 if (vendor_id == VENDOR_ID_AMD)
12887 {
12888 cl_uint device_processor_cores = 0;
12889
12890 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12891
12892 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12893
12894 device_param->device_processor_cores = device_processor_cores;
12895 }
12896 else if (vendor_id == VENDOR_ID_NV)
12897 {
12898 cl_uint kernel_exec_timeout = 0;
12899
12900 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12901
12902 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12903
12904 device_param->kernel_exec_timeout = kernel_exec_timeout;
12905
12906 cl_uint device_processor_cores = 0;
12907
12908 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12909
12910 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12911
12912 device_param->device_processor_cores = device_processor_cores;
12913
12914 cl_uint sm_minor = 0;
12915 cl_uint sm_major = 0;
12916
12917 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12918 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12919
12920 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12921 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12922
12923 device_param->sm_minor = sm_minor;
12924 device_param->sm_major = sm_major;
12925 }
12926 else
12927 {
12928 cl_uint device_processor_cores = 1;
12929
12930 device_param->device_processor_cores = device_processor_cores;
12931 }
12932 }
12933
12934 // display results
12935
12936 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12937 {
12938 if (device_param->skipped == 0)
12939 {
12940 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12941 device_id + 1,
12942 device_name,
12943 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12944 (unsigned int) (device_global_mem / 1024 / 1024),
12945 (unsigned int) (device_maxclock_frequency),
12946 (unsigned int) device_processors);
12947 }
12948 else
12949 {
12950 log_info ("Device #%u: %s, skipped",
12951 device_id + 1,
12952 device_name);
12953 }
12954 }
12955
12956 // common driver check
12957
12958 if (device_param->skipped == 0)
12959 {
12960 if (strstr (device_version, "pocl"))
12961 {
12962 if (force == 0)
12963 {
12964 log_info ("");
12965 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12966 log_info ("You are STRONGLY encouraged not to use it");
12967 log_info ("You can use --force to override this but do not post error reports if you do so");
12968 log_info ("");
12969
12970 return (-1);
12971 }
12972 }
12973
12974 if (device_type & CL_DEVICE_TYPE_GPU)
12975 {
12976 if (vendor_id == VENDOR_ID_NV)
12977 {
12978 if (device_param->kernel_exec_timeout != 0)
12979 {
12980 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);
12981 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12982 }
12983 }
12984 else if (vendor_id == VENDOR_ID_AMD)
12985 {
12986 int catalyst_check = (force == 1) ? 0 : 1;
12987
12988 int catalyst_warn = 0;
12989
12990 int catalyst_broken = 0;
12991
12992 if (catalyst_check == 1)
12993 {
12994 catalyst_warn = 1;
12995
12996 // v14.9 and higher
12997 if (atoi (device_param->driver_version) >= 1573)
12998 {
12999 catalyst_warn = 0;
13000 }
13001
13002 catalyst_check = 0;
13003 }
13004
13005 if (catalyst_broken == 1)
13006 {
13007 log_info ("");
13008 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13009 log_info ("It will pass over cracked hashes and does not report them as cracked");
13010 log_info ("You are STRONGLY encouraged not to use it");
13011 log_info ("You can use --force to override this but do not post error reports if you do so");
13012 log_info ("");
13013
13014 return (-1);
13015 }
13016
13017 if (catalyst_warn == 1)
13018 {
13019 log_info ("");
13020 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13021 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13022 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
13023 #ifdef _WIN
13024 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13025 #endif
13026 log_info ("You can use --force to override this but do not post error reports if you do so");
13027 log_info ("");
13028
13029 return (-1);
13030 }
13031 }
13032 }
13033
13034 /**
13035 * kernel accel and loops tuning db adjustment
13036 */
13037
13038 uint _kernel_accel = kernel_accel;
13039 uint _kernel_loops = kernel_loops;
13040
13041 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param->device_name, attack_mode, hash_mode);
13042
13043 if (kernel_accel_chgd == 0)
13044 {
13045 if (tuningdb_entry)
13046 {
13047 _kernel_accel = tuningdb_entry->kernel_accel;
13048 }
13049 }
13050
13051 if (kernel_loops_chgd == 0)
13052 {
13053 if (tuningdb_entry)
13054 {
13055 _kernel_loops = tuningdb_entry->kernel_loops;
13056
13057 if (workload_profile == 1)
13058 {
13059 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13060 }
13061 else if (workload_profile == 2)
13062 {
13063 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13064 }
13065 }
13066 }
13067
13068 device_param->kernel_accel = _kernel_accel;
13069 device_param->kernel_loops = _kernel_loops;
13070
13071 devices_active++;
13072 }
13073
13074 // next please
13075
13076 devices_cnt++;
13077 }
13078 }
13079
13080 if (keyspace == 0 && devices_active == 0)
13081 {
13082 log_error ("ERROR: No devices found/left");
13083
13084 return (-1);
13085 }
13086
13087 data.devices_cnt = devices_cnt;
13088
13089 data.devices_active = devices_active;
13090
13091 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13092 {
13093 log_info ("");
13094 }
13095
13096 /**
13097 * HM devices: init
13098 */
13099
13100 #ifdef HAVE_HWMON
13101 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13102 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13103 #endif
13104
13105 #ifdef HAVE_ADL
13106 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13107 #endif
13108
13109 if (gpu_temp_disable == 0)
13110 {
13111 #if defined(WIN) && defined(HAVE_NVAPI)
13112 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13113
13114 if (nvapi_init (nvapi) == 0)
13115 data.hm_nv = nvapi;
13116
13117 if (data.hm_nv)
13118 {
13119 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13120 {
13121 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13122
13123 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13124
13125 int tmp_out = 0;
13126
13127 for (int i = 0; i < tmp_in; i++)
13128 {
13129 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13130 }
13131
13132 for (int i = 0; i < tmp_out; i++)
13133 {
13134 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13135
13136 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13137
13138 if (hm_NvAPI_GPU_GetCoolerSettings (data.hm_nv, hm_adapters_nv[i].adapter_index.nv, 0, &pCoolerSettings) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
13139 }
13140 }
13141 }
13142 #endif // WIN && HAVE_NVAPI
13143
13144 #if defined(LINUX) && defined(HAVE_NVML)
13145 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13146
13147 if (nvml_init (nvml) == 0)
13148 data.hm_nv = nvml;
13149
13150 if (data.hm_nv)
13151 {
13152 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13153 {
13154 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13155
13156 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13157
13158 int tmp_out = 0;
13159
13160 for (int i = 0; i < tmp_in; i++)
13161 {
13162 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13163 }
13164
13165 for (int i = 0; i < tmp_out; i++)
13166 {
13167 unsigned int speed;
13168
13169 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
13170 }
13171 }
13172 }
13173 #endif // LINUX && HAVE_NVML
13174
13175 data.hm_amd = NULL;
13176
13177 #ifdef HAVE_ADL
13178 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13179
13180 if (adl_init (adl) == 0)
13181 data.hm_amd = adl;
13182
13183 if (data.hm_amd)
13184 {
13185 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13186 {
13187 // total number of adapters
13188
13189 int hm_adapters_num;
13190
13191 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13192
13193 // adapter info
13194
13195 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13196
13197 if (lpAdapterInfo == NULL) return (-1);
13198
13199 // get a list (of ids of) valid/usable adapters
13200
13201 int num_adl_adapters = 0;
13202
13203 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13204
13205 if (num_adl_adapters > 0)
13206 {
13207 hc_thread_mutex_lock (mux_adl);
13208
13209 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13210
13211 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13212
13213 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13214 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13215
13216 hc_thread_mutex_unlock (mux_adl);
13217 }
13218
13219 myfree (valid_adl_device_list);
13220 myfree (lpAdapterInfo);
13221 }
13222 }
13223 #endif // HAVE_ADL
13224
13225 if (data.hm_amd == NULL && data.hm_nv == NULL)
13226 {
13227 gpu_temp_disable = 1;
13228 }
13229 }
13230
13231 /**
13232 * OpenCL devices: allocate buffer for device specific information
13233 */
13234
13235 #ifdef HAVE_HWMON
13236 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13237
13238 #ifdef HAVE_ADL
13239 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13240
13241 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13242 #endif // ADL
13243 #endif
13244
13245 /**
13246 * enable custom signal handler(s)
13247 */
13248
13249 if (benchmark == 0)
13250 {
13251 hc_signal (sigHandler_default);
13252 }
13253 else
13254 {
13255 hc_signal (sigHandler_benchmark);
13256 }
13257
13258 /**
13259 * User-defined GPU temp handling
13260 */
13261
13262 #ifdef HAVE_HWMON
13263 if (gpu_temp_disable == 1)
13264 {
13265 gpu_temp_abort = 0;
13266 gpu_temp_retain = 0;
13267 }
13268
13269 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13270 {
13271 if (gpu_temp_abort < gpu_temp_retain)
13272 {
13273 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13274
13275 return (-1);
13276 }
13277 }
13278
13279 data.gpu_temp_disable = gpu_temp_disable;
13280 data.gpu_temp_abort = gpu_temp_abort;
13281 data.gpu_temp_retain = gpu_temp_retain;
13282 #endif
13283
13284 /**
13285 * inform the user
13286 */
13287
13288 if (data.quiet == 0)
13289 {
13290 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13291
13292 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);
13293
13294 if (attack_mode == ATTACK_MODE_STRAIGHT)
13295 {
13296 log_info ("Rules: %u", kernel_rules_cnt);
13297 }
13298
13299 if (opti_type)
13300 {
13301 log_info ("Applicable Optimizers:");
13302
13303 for (uint i = 0; i < 32; i++)
13304 {
13305 const uint opti_bit = 1u << i;
13306
13307 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13308 }
13309 }
13310
13311 /**
13312 * Watchdog and Temperature balance
13313 */
13314
13315 #ifdef HAVE_HWMON
13316 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13317 {
13318 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13319 }
13320
13321 if (gpu_temp_abort == 0)
13322 {
13323 log_info ("Watchdog: Temperature abort trigger disabled");
13324 }
13325 else
13326 {
13327 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13328 }
13329
13330 if (gpu_temp_retain == 0)
13331 {
13332 log_info ("Watchdog: Temperature retain trigger disabled");
13333 }
13334 else
13335 {
13336 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13337 }
13338 #endif
13339 }
13340
13341 if (data.quiet == 0) log_info ("");
13342
13343 /**
13344 * HM devices: copy
13345 */
13346
13347 if (gpu_temp_disable == 0)
13348 {
13349 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13350 {
13351 hc_device_param_t *device_param = &data.devices_param[device_id];
13352
13353 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13354
13355 if (device_param->skipped) continue;
13356
13357 const uint platform_devices_id = device_param->platform_devices_id;
13358
13359 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13360 if (device_param->vendor_id == VENDOR_ID_NV)
13361 {
13362 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13363 }
13364 #endif
13365
13366 #ifdef HAVE_ADL
13367 if (device_param->vendor_id == VENDOR_ID_AMD)
13368 {
13369 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13370 }
13371 #endif
13372 }
13373 }
13374
13375 /*
13376 * Temporary fix:
13377 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13378 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13379 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13380 * Driver / ADL bug?
13381 */
13382
13383 #ifdef HAVE_ADL
13384 if (powertune_enable == 1)
13385 {
13386 hc_thread_mutex_lock (mux_adl);
13387
13388 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13389 {
13390 hc_device_param_t *device_param = &data.devices_param[device_id];
13391
13392 if (device_param->skipped) continue;
13393
13394 if (data.hm_device[device_id].od_version == 6)
13395 {
13396 // set powertune value only
13397
13398 int powertune_supported = 0;
13399
13400 int ADL_rc = 0;
13401
13402 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13403 {
13404 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13405
13406 return (-1);
13407 }
13408
13409 if (powertune_supported != 0)
13410 {
13411 // powertune set
13412 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13413
13414 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13415 {
13416 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13417
13418 return (-1);
13419 }
13420
13421 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13422 {
13423 log_error ("ERROR: Failed to set new ADL PowerControl values");
13424
13425 return (-1);
13426 }
13427 }
13428 }
13429 }
13430
13431 hc_thread_mutex_unlock (mux_adl);
13432 }
13433 #endif // HAVE_ADK
13434 #endif // HAVE_HWMON
13435
13436 #ifdef OSX
13437 if (hash_mode == 3000 || hash_mode == 1500 || hash_mode == 10700)
13438 {
13439 if (force == 0)
13440 {
13441 log_info ("");
13442 log_info ("Warning: Hash mode %d is not stable with OSX.", hash_mode);
13443 log_info ("You can use --force to override this but do not post error reports if you do so");
13444 log_info ("");
13445
13446 continue;
13447 }
13448 }
13449 #endif
13450
13451 #ifdef DEBUG
13452 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13453 #endif
13454
13455 uint kernel_power_all = 0;
13456
13457 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13458 {
13459 /**
13460 * host buffer
13461 */
13462
13463 hc_device_param_t *device_param = &data.devices_param[device_id];
13464
13465 if (device_param->skipped) continue;
13466
13467 /**
13468 * device properties
13469 */
13470
13471 const char *device_name_chksum = device_param->device_name_chksum;
13472 const u32 device_processors = device_param->device_processors;
13473 const u32 device_processor_cores = device_param->device_processor_cores;
13474
13475 /**
13476 * create context for each device
13477 */
13478
13479 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13480
13481 /**
13482 * create command-queue
13483 */
13484
13485 // not supported with NV
13486 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13487
13488 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13489
13490 /**
13491 * create input buffers on device : calculate size of fixed memory buffers
13492 */
13493
13494 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13495 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13496
13497 device_param->size_root_css = size_root_css;
13498 device_param->size_markov_css = size_markov_css;
13499
13500 uint size_results = KERNEL_THREADS * sizeof (uint);
13501
13502 device_param->size_results = size_results;
13503
13504 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13505 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13506
13507 uint size_plains = digests_cnt * sizeof (plain_t);
13508 uint size_salts = salts_cnt * sizeof (salt_t);
13509 uint size_esalts = salts_cnt * esalt_size;
13510
13511 device_param->size_plains = size_plains;
13512 device_param->size_digests = size_digests;
13513 device_param->size_shown = size_shown;
13514 device_param->size_salts = size_salts;
13515
13516 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13517 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13518 uint size_tm = 32 * sizeof (bs_word_t);
13519
13520 // scryptV stuff
13521
13522 u64 size_scryptV = 1;
13523
13524 if ((hash_mode == 8900) || (hash_mode == 9300))
13525 {
13526 uint tmto_start = 0;
13527 uint tmto_stop = 10;
13528
13529 if (scrypt_tmto)
13530 {
13531 tmto_start = scrypt_tmto;
13532 }
13533 else
13534 {
13535 // in case the user did not specify the tmto manually
13536 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13537 // but set the lower end only in case the user has a device with too less memory
13538
13539 if (hash_mode == 8900)
13540 {
13541 if (device_param->vendor_id == VENDOR_ID_AMD)
13542 {
13543 tmto_start = 1;
13544 }
13545 else if (device_param->vendor_id == VENDOR_ID_NV)
13546 {
13547 tmto_start = 3;
13548 }
13549 }
13550 else if (hash_mode == 9300)
13551 {
13552 if (device_param->vendor_id == VENDOR_ID_AMD)
13553 {
13554 tmto_start = 3;
13555 }
13556 else if (device_param->vendor_id == VENDOR_ID_NV)
13557 {
13558 tmto_start = 5;
13559 }
13560 }
13561 }
13562
13563 if (quiet == 0) log_info ("");
13564
13565 uint shader_per_mp = 1;
13566
13567 if (device_param->vendor_id == VENDOR_ID_AMD)
13568 {
13569 shader_per_mp = 8;
13570 }
13571 else if (device_param->vendor_id == VENDOR_ID_NV)
13572 {
13573 shader_per_mp = 32;
13574 }
13575
13576 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13577 {
13578 // TODO: in theory the following calculation needs to be done per salt, not global
13579 // we assume all hashes have the same scrypt settings
13580
13581 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13582
13583 size_scryptV /= 1 << tmto;
13584
13585 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13586
13587 if (size_scryptV > device_param->device_maxmem_alloc)
13588 {
13589 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13590
13591 continue;
13592 }
13593
13594 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13595 {
13596 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13597 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13598 }
13599
13600 break;
13601 }
13602
13603 if (data.salts_buf[0].scrypt_phy == 0)
13604 {
13605 log_error ("ERROR: can't allocate enough device memory");
13606
13607 return -1;
13608 }
13609
13610 if (quiet == 0) log_info ("");
13611 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13612 }
13613
13614 /**
13615 * create input buffers on device : calculate size of dynamic size memory buffers
13616 */
13617
13618 uint kernel_threads = KERNEL_THREADS;
13619
13620 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13621
13622 if (hash_mode == 3200) kernel_threads = 8;
13623 if (hash_mode == 9000) kernel_threads = 8;
13624
13625 /**
13626 * some algorithms need a fixed kernel-loops count
13627 */
13628
13629 u32 kernel_loops_min = 1;
13630 u32 kernel_loops_max = 1024;
13631
13632 if (hash_mode == 1500)
13633 {
13634 const u32 kernel_loops_fixed = 1024;
13635
13636 kernel_loops_min = kernel_loops_fixed;
13637 kernel_loops_max = kernel_loops_fixed;
13638 }
13639
13640 if (hash_mode == 3000)
13641 {
13642 const u32 kernel_loops_fixed = 1024;
13643
13644 kernel_loops_min = kernel_loops_fixed;
13645 kernel_loops_max = kernel_loops_fixed;
13646 }
13647
13648 if (hash_mode == 8900)
13649 {
13650 const u32 kernel_loops_fixed = 1;
13651
13652 kernel_loops_min = kernel_loops_fixed;
13653 kernel_loops_max = kernel_loops_fixed;
13654 }
13655
13656 if (hash_mode == 9300)
13657 {
13658 const u32 kernel_loops_fixed = 1;
13659
13660 kernel_loops_min = kernel_loops_fixed;
13661 kernel_loops_max = kernel_loops_fixed;
13662 }
13663
13664 if (hash_mode == 12500)
13665 {
13666 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13667
13668 kernel_loops_min = kernel_loops_fixed;
13669 kernel_loops_max = kernel_loops_fixed;
13670 }
13671
13672 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13673 {
13674 if (data.salts_buf[0].salt_iter < kernel_loops_max)
13675 {
13676 kernel_loops_max = data.salts_buf[0].salt_iter;
13677 }
13678 }
13679
13680 device_param->kernel_loops_min = kernel_loops_min;
13681 device_param->kernel_loops_max = kernel_loops_max;
13682
13683 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13684
13685 uint size_pws = 4;
13686 uint size_tmps = 4;
13687 uint size_hooks = 4;
13688
13689 uint kernel_accel_min = 1;
13690 uint kernel_accel_max = 1024;
13691
13692 /**
13693 * some algorithms need a special kernel-accel
13694 */
13695
13696 if (hash_mode == 8900)
13697 {
13698 kernel_accel_max = 64;
13699 }
13700
13701 if (hash_mode == 9300)
13702 {
13703 kernel_accel_max = 64;
13704 }
13705
13706 while (kernel_accel_max)
13707 {
13708 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13709
13710 // size_pws
13711
13712 size_pws = kernel_power_max * sizeof (pw_t);
13713
13714 // size_tmps
13715
13716 switch (hash_mode)
13717 {
13718 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13719 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13720 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13721 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13722 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13723 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13724 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13725 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13726 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13727 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13728 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13729 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13730 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13731 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13732 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13733 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13734 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13735 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13736 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13737 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13738 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13739 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13740 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13741 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13742 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13743 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13744 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13745 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13746 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13747 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13748 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13749 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13750 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13751 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13752 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13753 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13754 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13755 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13756 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13757 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13758 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13759 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13760 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13761 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13762 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13763 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13764 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13765 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13766 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13767 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13768 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13769 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13770 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13771 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13772 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13773 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13774 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13775 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13776 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13777 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13778 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13779 };
13780
13781 // size_hooks
13782
13783 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13784 {
13785 // none yet
13786 }
13787
13788 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13789 // if not, decrease amplifier and try again
13790
13791 int skip = 0;
13792
13793 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13794 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13795 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13796
13797 if (( bitmap_size
13798 + bitmap_size
13799 + bitmap_size
13800 + bitmap_size
13801 + bitmap_size
13802 + bitmap_size
13803 + bitmap_size
13804 + bitmap_size
13805 + size_bfs
13806 + size_combs
13807 + size_digests
13808 + size_esalts
13809 + size_hooks
13810 + size_markov_css
13811 + size_plains
13812 + size_pws
13813 + size_results
13814 + size_root_css
13815 + size_rules
13816 + size_rules_c
13817 + size_salts
13818 + size_scryptV
13819 + size_shown
13820 + size_tm
13821 + size_tmps) > device_param->device_global_mem) skip = 1;
13822
13823 if (skip == 1)
13824 {
13825 kernel_accel_max--;
13826
13827 continue;
13828 }
13829
13830 break;
13831 }
13832
13833 if (kernel_accel_max == 0)
13834 {
13835 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13836
13837 return -1;
13838 }
13839
13840 device_param->kernel_accel_min = kernel_accel_min;
13841 device_param->kernel_accel_max = kernel_accel_max;
13842
13843 if (kernel_accel_max < kernel_accel)
13844 {
13845 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13846
13847 device_param->kernel_accel = kernel_accel_max;
13848 }
13849
13850 const u32 kernel_accel = device_param->kernel_accel;
13851
13852 device_param->size_pws = size_pws;
13853 device_param->size_tmps = size_tmps;
13854 device_param->size_hooks = size_hooks;
13855
13856 // do not confuse kernel_accel_max with kernel_accel here
13857
13858 const u32 kernel_power = device_processors * kernel_threads * kernel_accel;
13859
13860 device_param->kernel_threads = kernel_threads;
13861 device_param->kernel_power_user = kernel_power;
13862
13863 kernel_power_all += kernel_power;
13864
13865 /**
13866 * default building options
13867 */
13868
13869 char build_opts[1024] = { 0 };
13870
13871 // we don't have sm_* on vendors not NV but it doesn't matter
13872
13873 snprintf (build_opts, sizeof (build_opts) - 1, "-I%s/ -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type);
13874
13875 /**
13876 * main kernel
13877 */
13878
13879 {
13880 /**
13881 * kernel source filename
13882 */
13883
13884 char source_file[256] = { 0 };
13885
13886 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13887
13888 struct stat sst;
13889
13890 if (stat (source_file, &sst) == -1)
13891 {
13892 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13893
13894 return -1;
13895 }
13896
13897 /**
13898 * kernel cached filename
13899 */
13900
13901 char cached_file[256] = { 0 };
13902
13903 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13904
13905 int cached = 1;
13906
13907 struct stat cst;
13908
13909 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13910 {
13911 cached = 0;
13912 }
13913
13914 /**
13915 * kernel compile or load
13916 */
13917
13918 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13919
13920 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13921
13922 if (force_jit_compilation == -1)
13923 {
13924 if (cached == 0)
13925 {
13926 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13927
13928 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13929
13930 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13931
13932 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13933
13934 if (rc != 0)
13935 {
13936 device_param->skipped = true;
13937 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13938 continue;
13939 }
13940
13941 size_t binary_size;
13942
13943 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13944
13945 u8 *binary = (u8 *) mymalloc (binary_size);
13946
13947 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13948
13949 writeProgramBin (cached_file, binary, binary_size);
13950
13951 local_free (binary);
13952 }
13953 else
13954 {
13955 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13956
13957 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13958
13959 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13960
13961 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13962 }
13963 }
13964 else
13965 {
13966 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13967
13968 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13969
13970 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13971
13972 char build_opts_update[1024] = { 0 };
13973
13974 if (force_jit_compilation == 1500)
13975 {
13976 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13977 }
13978 else if (force_jit_compilation == 8900)
13979 {
13980 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%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);
13981 }
13982
13983 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13984
13985 if (rc != 0)
13986 {
13987 device_param->skipped = true;
13988 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13989 }
13990 }
13991
13992 local_free (kernel_lengths);
13993 local_free (kernel_sources[0]);
13994 local_free (kernel_sources);
13995 }
13996
13997 /**
13998 * word generator kernel
13999 */
14000
14001 if (attack_mode != ATTACK_MODE_STRAIGHT)
14002 {
14003 /**
14004 * kernel mp source filename
14005 */
14006
14007 char source_file[256] = { 0 };
14008
14009 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14010
14011 struct stat sst;
14012
14013 if (stat (source_file, &sst) == -1)
14014 {
14015 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14016
14017 return -1;
14018 }
14019
14020 /**
14021 * kernel mp cached filename
14022 */
14023
14024 char cached_file[256] = { 0 };
14025
14026 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14027
14028 int cached = 1;
14029
14030 struct stat cst;
14031
14032 if (stat (cached_file, &cst) == -1)
14033 {
14034 cached = 0;
14035 }
14036
14037 /**
14038 * kernel compile or load
14039 */
14040
14041 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14042
14043 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14044
14045 if (cached == 0)
14046 {
14047 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14048
14049 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14050
14051 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14052
14053 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14054
14055 if (rc != 0)
14056 {
14057 device_param->skipped = true;
14058 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14059 continue;
14060 }
14061
14062 size_t binary_size;
14063
14064 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14065
14066 u8 *binary = (u8 *) mymalloc (binary_size);
14067
14068 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14069
14070 writeProgramBin (cached_file, binary, binary_size);
14071
14072 local_free (binary);
14073 }
14074 else
14075 {
14076 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14077
14078 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14079
14080 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14081
14082 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14083 }
14084
14085 local_free (kernel_lengths);
14086 local_free (kernel_sources[0]);
14087 local_free (kernel_sources);
14088 }
14089
14090 /**
14091 * amplifier kernel
14092 */
14093
14094 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14095 {
14096
14097 }
14098 else
14099 {
14100 /**
14101 * kernel amp source filename
14102 */
14103
14104 char source_file[256] = { 0 };
14105
14106 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14107
14108 struct stat sst;
14109
14110 if (stat (source_file, &sst) == -1)
14111 {
14112 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14113
14114 return -1;
14115 }
14116
14117 /**
14118 * kernel amp cached filename
14119 */
14120
14121 char cached_file[256] = { 0 };
14122
14123 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14124
14125 int cached = 1;
14126
14127 struct stat cst;
14128
14129 if (stat (cached_file, &cst) == -1)
14130 {
14131 cached = 0;
14132 }
14133
14134 /**
14135 * kernel compile or load
14136 */
14137
14138 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14139
14140 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14141
14142 if (cached == 0)
14143 {
14144 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14145
14146 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14147
14148 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14149
14150 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14151
14152 if (rc != 0)
14153 {
14154 device_param->skipped = true;
14155 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14156 continue;
14157 }
14158
14159 size_t binary_size;
14160
14161 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14162
14163 u8 *binary = (u8 *) mymalloc (binary_size);
14164
14165 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14166
14167 writeProgramBin (cached_file, binary, binary_size);
14168
14169 local_free (binary);
14170 }
14171 else
14172 {
14173 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14174
14175 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14176
14177 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14178
14179 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14180 }
14181
14182 local_free (kernel_lengths);
14183 local_free (kernel_sources[0]);
14184 local_free (kernel_sources);
14185 }
14186
14187 // some algorithm collide too fast, make that impossible
14188
14189 if (benchmark == 1)
14190 {
14191 ((uint *) digests_buf)[0] = -1;
14192 ((uint *) digests_buf)[1] = -1;
14193 ((uint *) digests_buf)[2] = -1;
14194 ((uint *) digests_buf)[3] = -1;
14195 }
14196
14197 /**
14198 * global buffers
14199 */
14200
14201 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14202 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14203 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14204 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14205 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14206 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14207 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14208 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14209 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14210 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14211 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14212 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14213 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14214 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14215 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14216 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14217 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14218 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14219
14220 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
14221 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
14222 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
14223 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
14224 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
14225 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
14226 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
14227 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
14228 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14229 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14230 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14231
14232 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14233 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14234 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14235 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14236 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14237 run_kernel_bzero (device_param, device_param->d_result, size_results);
14238
14239 /**
14240 * special buffers
14241 */
14242
14243 if (attack_kern == ATTACK_KERN_STRAIGHT)
14244 {
14245 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14246 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14247
14248 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14249
14250 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14251 }
14252 else if (attack_kern == ATTACK_KERN_COMBI)
14253 {
14254 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14255 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14256 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14257 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14258
14259 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14260 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14261 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14262 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14263 }
14264 else if (attack_kern == ATTACK_KERN_BF)
14265 {
14266 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14267 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14268 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14269 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14270 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14271
14272 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14273 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14274 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14275 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14276 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14277 }
14278
14279 if (size_esalts)
14280 {
14281 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14282
14283 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14284 }
14285
14286 /**
14287 * main host data
14288 */
14289
14290 uint *result = (uint *) mymalloc (size_results);
14291
14292 device_param->result = result;
14293
14294 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14295
14296 device_param->pws_buf = pws_buf;
14297
14298 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
14299
14300 for (int i = 0; i < 64; i++)
14301 {
14302 pw_caches[i].pw_buf.pw_len = i;
14303 pw_caches[i].cnt = 0;
14304 }
14305
14306 device_param->pw_caches = pw_caches;
14307
14308 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14309
14310 device_param->combs_buf = combs_buf;
14311
14312 void *hooks_buf = mymalloc (size_hooks);
14313
14314 device_param->hooks_buf = hooks_buf;
14315
14316 device_param->pw_transpose = pw_transpose_to_hi1;
14317 device_param->pw_add = pw_add_to_hc1;
14318
14319 /**
14320 * kernel args
14321 */
14322
14323 device_param->kernel_params_buf32[21] = bitmap_mask;
14324 device_param->kernel_params_buf32[22] = bitmap_shift1;
14325 device_param->kernel_params_buf32[23] = bitmap_shift2;
14326 device_param->kernel_params_buf32[24] = 0; // salt_pos
14327 device_param->kernel_params_buf32[25] = 0; // loop_pos
14328 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14329 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14330 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14331 device_param->kernel_params_buf32[29] = 0; // digests_offset
14332 device_param->kernel_params_buf32[30] = 0; // combs_mode
14333 device_param->kernel_params_buf32[31] = 0; // gid_max
14334
14335 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14336 ? &device_param->d_pws_buf
14337 : &device_param->d_pws_amp_buf;
14338 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14339 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14340 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14341 device_param->kernel_params[ 4] = &device_param->d_tmps;
14342 device_param->kernel_params[ 5] = &device_param->d_hooks;
14343 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14344 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14345 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14346 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14347 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14348 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14349 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14350 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14351 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14352 device_param->kernel_params[15] = &device_param->d_digests_buf;
14353 device_param->kernel_params[16] = &device_param->d_digests_shown;
14354 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14355 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14356 device_param->kernel_params[19] = &device_param->d_result;
14357 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14358 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14359 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14360 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14361 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14362 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14363 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14364 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14365 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14366 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14367 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14368 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14369
14370 device_param->kernel_params_mp_buf64[3] = 0;
14371 device_param->kernel_params_mp_buf32[4] = 0;
14372 device_param->kernel_params_mp_buf32[5] = 0;
14373 device_param->kernel_params_mp_buf32[6] = 0;
14374 device_param->kernel_params_mp_buf32[7] = 0;
14375 device_param->kernel_params_mp_buf32[8] = 0;
14376
14377 device_param->kernel_params_mp[0] = NULL;
14378 device_param->kernel_params_mp[1] = NULL;
14379 device_param->kernel_params_mp[2] = NULL;
14380 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14381 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14382 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14383 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14384 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14385 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14386
14387 device_param->kernel_params_mp_l_buf64[3] = 0;
14388 device_param->kernel_params_mp_l_buf32[4] = 0;
14389 device_param->kernel_params_mp_l_buf32[5] = 0;
14390 device_param->kernel_params_mp_l_buf32[6] = 0;
14391 device_param->kernel_params_mp_l_buf32[7] = 0;
14392 device_param->kernel_params_mp_l_buf32[8] = 0;
14393 device_param->kernel_params_mp_l_buf32[9] = 0;
14394
14395 device_param->kernel_params_mp_l[0] = NULL;
14396 device_param->kernel_params_mp_l[1] = NULL;
14397 device_param->kernel_params_mp_l[2] = NULL;
14398 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14399 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14400 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14401 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14402 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14403 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14404 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14405
14406 device_param->kernel_params_mp_r_buf64[3] = 0;
14407 device_param->kernel_params_mp_r_buf32[4] = 0;
14408 device_param->kernel_params_mp_r_buf32[5] = 0;
14409 device_param->kernel_params_mp_r_buf32[6] = 0;
14410 device_param->kernel_params_mp_r_buf32[7] = 0;
14411 device_param->kernel_params_mp_r_buf32[8] = 0;
14412
14413 device_param->kernel_params_mp_r[0] = NULL;
14414 device_param->kernel_params_mp_r[1] = NULL;
14415 device_param->kernel_params_mp_r[2] = NULL;
14416 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14417 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14418 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14419 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14420 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14421 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14422
14423 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14424 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14425
14426 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14427 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14428 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14429 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14430 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14431 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14432 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14433
14434 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14435
14436 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14437 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14438
14439 /**
14440 * kernel name
14441 */
14442
14443 char kernel_name[64] = { 0 };
14444
14445 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14446 {
14447 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14448 {
14449 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14450
14451 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14452
14453 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14454
14455 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14456
14457 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14458
14459 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14460 }
14461 else
14462 {
14463 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14464
14465 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14466
14467 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14468
14469 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14470
14471 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14472
14473 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14474 }
14475
14476 if (data.attack_mode == ATTACK_MODE_BF)
14477 {
14478 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14479 {
14480 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14481
14482 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14483
14484 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14485
14486 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14487 }
14488 }
14489 }
14490 else
14491 {
14492 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14493
14494 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14495
14496 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14497
14498 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14499
14500 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14501
14502 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14503
14504 if (opts_type & OPTS_TYPE_HOOK12)
14505 {
14506 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14507
14508 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14509 }
14510
14511 if (opts_type & OPTS_TYPE_HOOK23)
14512 {
14513 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14514
14515 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14516 }
14517 }
14518
14519 for (uint i = 0; i <= 20; i++)
14520 {
14521 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14522 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14523 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14524
14525 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14526 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14527 }
14528
14529 for (uint i = 21; i <= 31; i++)
14530 {
14531 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14532 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14533 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14534
14535 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14536 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14537 }
14538
14539 if (attack_mode == ATTACK_MODE_BF)
14540 {
14541 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14542 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14543
14544 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14545 {
14546 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14547
14548 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14549 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14550 }
14551 }
14552 else if (attack_mode == ATTACK_MODE_HYBRID1)
14553 {
14554 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14555 }
14556 else if (attack_mode == ATTACK_MODE_HYBRID2)
14557 {
14558 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14559 }
14560
14561 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14562 {
14563 // nothing to do
14564 }
14565 else
14566 {
14567 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14568 }
14569
14570 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14571 {
14572 // nothing to do
14573 }
14574 else
14575 {
14576 for (uint i = 0; i < 5; i++)
14577 {
14578 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14579 }
14580
14581 for (uint i = 5; i < 7; i++)
14582 {
14583 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14584 }
14585 }
14586
14587 /**
14588 * Store initial fanspeed if gpu_temp_retain is enabled
14589 */
14590
14591 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14592 int gpu_temp_retain_set = 0;
14593
14594 if (gpu_temp_disable == 0)
14595 {
14596 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14597 {
14598 hc_thread_mutex_lock (mux_adl);
14599
14600 if (data.hm_device[device_id].fan_supported == 1)
14601 {
14602 if (gpu_temp_retain_chgd == 0)
14603 {
14604 uint cur_temp = 0;
14605 uint default_temp = 0;
14606
14607 int ADL_rc = hm_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, (int *) &cur_temp, (int *) &default_temp);
14608
14609 if (ADL_rc == ADL_OK)
14610 {
14611 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14612
14613 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14614
14615 // special case with multi gpu setups: always use minimum retain
14616
14617 if (gpu_temp_retain_set == 0)
14618 {
14619 gpu_temp_retain = gpu_temp_retain_target;
14620 gpu_temp_retain_set = 1;
14621 }
14622 else
14623 {
14624 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14625 }
14626
14627 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14628 }
14629 }
14630
14631 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14632
14633 temp_retain_fanspeed_value[device_id] = fan_speed;
14634
14635 if (fan_speed == -1)
14636 {
14637 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14638
14639 temp_retain_fanspeed_value[device_id] = 0;
14640 }
14641 }
14642
14643 hc_thread_mutex_unlock (mux_adl);
14644 }
14645 }
14646
14647 /**
14648 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14649 */
14650
14651 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14652 {
14653 hc_thread_mutex_lock (mux_adl);
14654
14655 if (data.hm_device[device_id].od_version == 6)
14656 {
14657 int ADL_rc;
14658
14659 // check powertune capabilities first, if not available then skip device
14660
14661 int powertune_supported = 0;
14662
14663 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14664 {
14665 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14666
14667 return (-1);
14668 }
14669
14670 if (powertune_supported != 0)
14671 {
14672 // powercontrol settings
14673
14674 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14675
14676 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14677 {
14678 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14679 }
14680
14681 if (ADL_rc != ADL_OK)
14682 {
14683 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14684
14685 return (-1);
14686 }
14687
14688 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14689 {
14690 log_error ("ERROR: Failed to set new ADL PowerControl values");
14691
14692 return (-1);
14693 }
14694
14695 // clocks
14696
14697 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14698
14699 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14700
14701 if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
14702 {
14703 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14704
14705 return (-1);
14706 }
14707
14708 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14709
14710 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14711
14712 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14713 {
14714 log_error ("ERROR: Failed to get ADL device capabilities");
14715
14716 return (-1);
14717 }
14718
14719 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14720 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14721
14722 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14723 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14724
14725 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14726 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14727
14728 // warning if profile has too low max values
14729
14730 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14731 {
14732 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14733 }
14734
14735 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14736 {
14737 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14738 }
14739
14740 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14741
14742 performance_state->iNumberOfPerformanceLevels = 2;
14743
14744 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14745 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14746 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14747 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14748
14749 if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
14750 {
14751 log_info ("ERROR: Failed to set ADL performance state");
14752
14753 return (-1);
14754 }
14755
14756 local_free (performance_state);
14757 }
14758 }
14759
14760 hc_thread_mutex_unlock (mux_adl);
14761 }
14762 #endif // HAVE_HWMON && HAVE_ADL
14763 }
14764
14765 data.kernel_power_all = kernel_power_all;
14766
14767 if (data.quiet == 0) log_info ("");
14768
14769 /**
14770 * Inform user which algorithm is checked and at which workload setting
14771 */
14772
14773 if (benchmark == 1)
14774 {
14775 quiet = 0;
14776
14777 data.quiet = quiet;
14778
14779 char *hash_type = strhashtype (data.hash_mode); // not a bug
14780
14781 log_info ("Hashtype: %s", hash_type);
14782 log_info ("");
14783 }
14784
14785 /**
14786 * keep track of the progress
14787 */
14788
14789 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14790 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14791 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14792
14793 /**
14794 * open filehandles
14795 */
14796
14797 #if _WIN
14798 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14799 {
14800 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14801
14802 return (-1);
14803 }
14804
14805 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14806 {
14807 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14808
14809 return (-1);
14810 }
14811
14812 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14813 {
14814 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14815
14816 return (-1);
14817 }
14818 #endif
14819
14820 /**
14821 * dictionary pad
14822 */
14823
14824 segment_size *= (1024 * 1024);
14825
14826 data.segment_size = segment_size;
14827
14828 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14829
14830 wl_data->buf = (char *) mymalloc (segment_size);
14831 wl_data->avail = segment_size;
14832 wl_data->incr = segment_size;
14833 wl_data->cnt = 0;
14834 wl_data->pos = 0;
14835
14836 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14837
14838 data.wordlist_mode = wordlist_mode;
14839
14840 cs_t *css_buf = NULL;
14841 uint css_cnt = 0;
14842 uint dictcnt = 0;
14843 uint maskcnt = 1;
14844 char **masks = NULL;
14845 char **dictfiles = NULL;
14846
14847 uint mask_from_file = 0;
14848
14849 if (attack_mode == ATTACK_MODE_STRAIGHT)
14850 {
14851 if (wordlist_mode == WL_MODE_FILE)
14852 {
14853 int wls_left = myargc - (optind + 1);
14854
14855 for (int i = 0; i < wls_left; i++)
14856 {
14857 char *l0_filename = myargv[optind + 1 + i];
14858
14859 struct stat l0_stat;
14860
14861 if (stat (l0_filename, &l0_stat) == -1)
14862 {
14863 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14864
14865 return (-1);
14866 }
14867
14868 uint is_dir = S_ISDIR (l0_stat.st_mode);
14869
14870 if (is_dir == 0)
14871 {
14872 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14873
14874 dictcnt++;
14875
14876 dictfiles[dictcnt - 1] = l0_filename;
14877 }
14878 else
14879 {
14880 // do not allow --keyspace w/ a directory
14881
14882 if (keyspace == 1)
14883 {
14884 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14885
14886 return (-1);
14887 }
14888
14889 char **dictionary_files = NULL;
14890
14891 dictionary_files = scan_directory (l0_filename);
14892
14893 if (dictionary_files != NULL)
14894 {
14895 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14896
14897 for (int d = 0; dictionary_files[d] != NULL; d++)
14898 {
14899 char *l1_filename = dictionary_files[d];
14900
14901 struct stat l1_stat;
14902
14903 if (stat (l1_filename, &l1_stat) == -1)
14904 {
14905 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14906
14907 return (-1);
14908 }
14909
14910 if (S_ISREG (l1_stat.st_mode))
14911 {
14912 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14913
14914 dictcnt++;
14915
14916 dictfiles[dictcnt - 1] = strdup (l1_filename);
14917 }
14918 }
14919 }
14920
14921 local_free (dictionary_files);
14922 }
14923 }
14924
14925 if (dictcnt < 1)
14926 {
14927 log_error ("ERROR: No usable dictionary file found.");
14928
14929 return (-1);
14930 }
14931 }
14932 else if (wordlist_mode == WL_MODE_STDIN)
14933 {
14934 dictcnt = 1;
14935 }
14936 }
14937 else if (attack_mode == ATTACK_MODE_COMBI)
14938 {
14939 // display
14940
14941 char *dictfile1 = myargv[optind + 1 + 0];
14942 char *dictfile2 = myargv[optind + 1 + 1];
14943
14944 // find the bigger dictionary and use as base
14945
14946 FILE *fp1 = NULL;
14947 FILE *fp2 = NULL;
14948
14949 struct stat tmp_stat;
14950
14951 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14952 {
14953 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14954
14955 return (-1);
14956 }
14957
14958 if (stat (dictfile1, &tmp_stat) == -1)
14959 {
14960 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14961
14962 fclose (fp1);
14963
14964 return (-1);
14965 }
14966
14967 if (S_ISDIR (tmp_stat.st_mode))
14968 {
14969 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14970
14971 fclose (fp1);
14972
14973 return (-1);
14974 }
14975
14976 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14977 {
14978 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14979
14980 fclose (fp1);
14981
14982 return (-1);
14983 }
14984
14985 if (stat (dictfile2, &tmp_stat) == -1)
14986 {
14987 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14988
14989 fclose (fp1);
14990 fclose (fp2);
14991
14992 return (-1);
14993 }
14994
14995 if (S_ISDIR (tmp_stat.st_mode))
14996 {
14997 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14998
14999 fclose (fp1);
15000 fclose (fp2);
15001
15002 return (-1);
15003 }
15004
15005 data.combs_cnt = 1;
15006
15007 data.quiet = 1;
15008
15009 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15010
15011 data.quiet = quiet;
15012
15013 if (words1_cnt == 0)
15014 {
15015 log_error ("ERROR: %s: empty file", dictfile1);
15016
15017 fclose (fp1);
15018 fclose (fp2);
15019
15020 return (-1);
15021 }
15022
15023 data.combs_cnt = 1;
15024
15025 data.quiet = 1;
15026
15027 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15028
15029 data.quiet = quiet;
15030
15031 if (words2_cnt == 0)
15032 {
15033 log_error ("ERROR: %s: empty file", dictfile2);
15034
15035 fclose (fp1);
15036 fclose (fp2);
15037
15038 return (-1);
15039 }
15040
15041 fclose (fp1);
15042 fclose (fp2);
15043
15044 data.dictfile = dictfile1;
15045 data.dictfile2 = dictfile2;
15046
15047 if (words1_cnt >= words2_cnt)
15048 {
15049 data.combs_cnt = words2_cnt;
15050 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15051
15052 dictfiles = &data.dictfile;
15053
15054 dictcnt = 1;
15055 }
15056 else
15057 {
15058 data.combs_cnt = words1_cnt;
15059 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15060
15061 dictfiles = &data.dictfile2;
15062
15063 dictcnt = 1;
15064
15065 // we also have to switch wordlist related rules!
15066
15067 char *tmpc = data.rule_buf_l;
15068
15069 data.rule_buf_l = data.rule_buf_r;
15070 data.rule_buf_r = tmpc;
15071
15072 int tmpi = data.rule_len_l;
15073
15074 data.rule_len_l = data.rule_len_r;
15075 data.rule_len_r = tmpi;
15076 }
15077 }
15078 else if (attack_mode == ATTACK_MODE_BF)
15079 {
15080 char *mask = NULL;
15081
15082 maskcnt = 0;
15083
15084 if (benchmark == 0)
15085 {
15086 mask = myargv[optind + 1];
15087
15088 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15089
15090 if ((optind + 2) <= myargc)
15091 {
15092 struct stat file_stat;
15093
15094 if (stat (mask, &file_stat) == -1)
15095 {
15096 maskcnt = 1;
15097
15098 masks[maskcnt - 1] = mystrdup (mask);
15099 }
15100 else
15101 {
15102 int wls_left = myargc - (optind + 1);
15103
15104 uint masks_avail = INCR_MASKS;
15105
15106 for (int i = 0; i < wls_left; i++)
15107 {
15108 if (i != 0)
15109 {
15110 mask = myargv[optind + 1 + i];
15111
15112 if (stat (mask, &file_stat) == -1)
15113 {
15114 log_error ("ERROR: %s: %s", mask, strerror (errno));
15115
15116 return (-1);
15117 }
15118 }
15119
15120 uint is_file = S_ISREG (file_stat.st_mode);
15121
15122 if (is_file == 1)
15123 {
15124 FILE *mask_fp;
15125
15126 if ((mask_fp = fopen (mask, "r")) == NULL)
15127 {
15128 log_error ("ERROR: %s: %s", mask, strerror (errno));
15129
15130 return (-1);
15131 }
15132
15133 char line_buf[BUFSIZ] = { 0 };
15134
15135 while (!feof (mask_fp))
15136 {
15137 memset (line_buf, 0, BUFSIZ);
15138
15139 int line_len = fgetl (mask_fp, line_buf);
15140
15141 if (line_len == 0) continue;
15142
15143 if (line_buf[0] == '#') continue;
15144
15145 if (masks_avail == maskcnt)
15146 {
15147 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15148
15149 masks_avail += INCR_MASKS;
15150 }
15151
15152 masks[maskcnt] = mystrdup (line_buf);
15153
15154 maskcnt++;
15155 }
15156
15157 fclose (mask_fp);
15158 }
15159 else
15160 {
15161 log_error ("ERROR: %s: unsupported file-type", mask);
15162
15163 return (-1);
15164 }
15165 }
15166
15167 mask_from_file = 1;
15168 }
15169 }
15170 else
15171 {
15172 custom_charset_1 = (char *) "?l?d?u";
15173 custom_charset_2 = (char *) "?l?d";
15174 custom_charset_3 = (char *) "?l?d*!$@_";
15175
15176 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15177 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15178 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15179
15180 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15181
15182 wordlist_mode = WL_MODE_MASK;
15183
15184 data.wordlist_mode = wordlist_mode;
15185
15186 increment = 1;
15187
15188 maskcnt = 1;
15189 }
15190 }
15191 else
15192 {
15193 /**
15194 * generate full masks and charsets
15195 */
15196
15197 masks = (char **) mymalloc (sizeof (char *));
15198
15199 switch (hash_mode)
15200 {
15201 case 1731: pw_min = 5;
15202 pw_max = 5;
15203 mask = mystrdup ("?b?b?b?b?b");
15204 break;
15205 case 12500: pw_min = 5;
15206 pw_max = 5;
15207 mask = mystrdup ("?b?b?b?b?b");
15208 break;
15209 default: pw_min = 7;
15210 pw_max = 7;
15211 mask = mystrdup ("?b?b?b?b?b?b?b");
15212 break;
15213 }
15214
15215 maskcnt = 1;
15216
15217 masks[maskcnt - 1] = mystrdup (mask);
15218
15219 wordlist_mode = WL_MODE_MASK;
15220
15221 data.wordlist_mode = wordlist_mode;
15222
15223 increment = 1;
15224 }
15225
15226 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15227
15228 if (increment)
15229 {
15230 if (increment_min > pw_min) pw_min = increment_min;
15231
15232 if (increment_max < pw_max) pw_max = increment_max;
15233 }
15234 }
15235 else if (attack_mode == ATTACK_MODE_HYBRID1)
15236 {
15237 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15238
15239 // display
15240
15241 char *mask = myargv[myargc - 1];
15242
15243 maskcnt = 0;
15244
15245 masks = (char **) mymalloc (1 * sizeof (char *));
15246
15247 // mod
15248
15249 struct stat file_stat;
15250
15251 if (stat (mask, &file_stat) == -1)
15252 {
15253 maskcnt = 1;
15254
15255 masks[maskcnt - 1] = mystrdup (mask);
15256 }
15257 else
15258 {
15259 uint is_file = S_ISREG (file_stat.st_mode);
15260
15261 if (is_file == 1)
15262 {
15263 FILE *mask_fp;
15264
15265 if ((mask_fp = fopen (mask, "r")) == NULL)
15266 {
15267 log_error ("ERROR: %s: %s", mask, strerror (errno));
15268
15269 return (-1);
15270 }
15271
15272 char line_buf[BUFSIZ] = { 0 };
15273
15274 uint masks_avail = 1;
15275
15276 while (!feof (mask_fp))
15277 {
15278 memset (line_buf, 0, BUFSIZ);
15279
15280 int line_len = fgetl (mask_fp, line_buf);
15281
15282 if (line_len == 0) continue;
15283
15284 if (line_buf[0] == '#') continue;
15285
15286 if (masks_avail == maskcnt)
15287 {
15288 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15289
15290 masks_avail += INCR_MASKS;
15291 }
15292
15293 masks[maskcnt] = mystrdup (line_buf);
15294
15295 maskcnt++;
15296 }
15297
15298 fclose (mask_fp);
15299
15300 mask_from_file = 1;
15301 }
15302 else
15303 {
15304 maskcnt = 1;
15305
15306 masks[maskcnt - 1] = mystrdup (mask);
15307 }
15308 }
15309
15310 // base
15311
15312 int wls_left = myargc - (optind + 2);
15313
15314 for (int i = 0; i < wls_left; i++)
15315 {
15316 char *filename = myargv[optind + 1 + i];
15317
15318 struct stat file_stat;
15319
15320 if (stat (filename, &file_stat) == -1)
15321 {
15322 log_error ("ERROR: %s: %s", filename, strerror (errno));
15323
15324 return (-1);
15325 }
15326
15327 uint is_dir = S_ISDIR (file_stat.st_mode);
15328
15329 if (is_dir == 0)
15330 {
15331 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15332
15333 dictcnt++;
15334
15335 dictfiles[dictcnt - 1] = filename;
15336 }
15337 else
15338 {
15339 // do not allow --keyspace w/ a directory
15340
15341 if (keyspace == 1)
15342 {
15343 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15344
15345 return (-1);
15346 }
15347
15348 char **dictionary_files = NULL;
15349
15350 dictionary_files = scan_directory (filename);
15351
15352 if (dictionary_files != NULL)
15353 {
15354 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15355
15356 for (int d = 0; dictionary_files[d] != NULL; d++)
15357 {
15358 char *l1_filename = dictionary_files[d];
15359
15360 struct stat l1_stat;
15361
15362 if (stat (l1_filename, &l1_stat) == -1)
15363 {
15364 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15365
15366 return (-1);
15367 }
15368
15369 if (S_ISREG (l1_stat.st_mode))
15370 {
15371 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15372
15373 dictcnt++;
15374
15375 dictfiles[dictcnt - 1] = strdup (l1_filename);
15376 }
15377 }
15378 }
15379
15380 local_free (dictionary_files);
15381 }
15382 }
15383
15384 if (dictcnt < 1)
15385 {
15386 log_error ("ERROR: No usable dictionary file found.");
15387
15388 return (-1);
15389 }
15390
15391 if (increment)
15392 {
15393 maskcnt = 0;
15394
15395 uint mask_min = increment_min; // we can't reject smaller masks here
15396 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15397
15398 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15399 {
15400 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15401
15402 if (cur_mask == NULL) break;
15403
15404 masks[maskcnt] = cur_mask;
15405
15406 maskcnt++;
15407
15408 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15409 }
15410 }
15411 }
15412 else if (attack_mode == ATTACK_MODE_HYBRID2)
15413 {
15414 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15415
15416 // display
15417
15418 char *mask = myargv[optind + 1 + 0];
15419
15420 maskcnt = 0;
15421
15422 masks = (char **) mymalloc (1 * sizeof (char *));
15423
15424 // mod
15425
15426 struct stat file_stat;
15427
15428 if (stat (mask, &file_stat) == -1)
15429 {
15430 maskcnt = 1;
15431
15432 masks[maskcnt - 1] = mystrdup (mask);
15433 }
15434 else
15435 {
15436 uint is_file = S_ISREG (file_stat.st_mode);
15437
15438 if (is_file == 1)
15439 {
15440 FILE *mask_fp;
15441
15442 if ((mask_fp = fopen (mask, "r")) == NULL)
15443 {
15444 log_error ("ERROR: %s: %s", mask, strerror (errno));
15445
15446 return (-1);
15447 }
15448
15449 char line_buf[BUFSIZ] = { 0 };
15450
15451 uint masks_avail = 1;
15452
15453 while (!feof (mask_fp))
15454 {
15455 memset (line_buf, 0, BUFSIZ);
15456
15457 int line_len = fgetl (mask_fp, line_buf);
15458
15459 if (line_len == 0) continue;
15460
15461 if (line_buf[0] == '#') continue;
15462
15463 if (masks_avail == maskcnt)
15464 {
15465 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15466
15467 masks_avail += INCR_MASKS;
15468 }
15469
15470 masks[maskcnt] = mystrdup (line_buf);
15471
15472 maskcnt++;
15473 }
15474
15475 fclose (mask_fp);
15476
15477 mask_from_file = 1;
15478 }
15479 else
15480 {
15481 maskcnt = 1;
15482
15483 masks[maskcnt - 1] = mystrdup (mask);
15484 }
15485 }
15486
15487 // base
15488
15489 int wls_left = myargc - (optind + 2);
15490
15491 for (int i = 0; i < wls_left; i++)
15492 {
15493 char *filename = myargv[optind + 2 + i];
15494
15495 struct stat file_stat;
15496
15497 if (stat (filename, &file_stat) == -1)
15498 {
15499 log_error ("ERROR: %s: %s", filename, strerror (errno));
15500
15501 return (-1);
15502 }
15503
15504 uint is_dir = S_ISDIR (file_stat.st_mode);
15505
15506 if (is_dir == 0)
15507 {
15508 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15509
15510 dictcnt++;
15511
15512 dictfiles[dictcnt - 1] = filename;
15513 }
15514 else
15515 {
15516 // do not allow --keyspace w/ a directory
15517
15518 if (keyspace == 1)
15519 {
15520 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15521
15522 return (-1);
15523 }
15524
15525 char **dictionary_files = NULL;
15526
15527 dictionary_files = scan_directory (filename);
15528
15529 if (dictionary_files != NULL)
15530 {
15531 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15532
15533 for (int d = 0; dictionary_files[d] != NULL; d++)
15534 {
15535 char *l1_filename = dictionary_files[d];
15536
15537 struct stat l1_stat;
15538
15539 if (stat (l1_filename, &l1_stat) == -1)
15540 {
15541 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15542
15543 return (-1);
15544 }
15545
15546 if (S_ISREG (l1_stat.st_mode))
15547 {
15548 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15549
15550 dictcnt++;
15551
15552 dictfiles[dictcnt - 1] = strdup (l1_filename);
15553 }
15554 }
15555 }
15556
15557 local_free (dictionary_files);
15558 }
15559 }
15560
15561 if (dictcnt < 1)
15562 {
15563 log_error ("ERROR: No usable dictionary file found.");
15564
15565 return (-1);
15566 }
15567
15568 if (increment)
15569 {
15570 maskcnt = 0;
15571
15572 uint mask_min = increment_min; // we can't reject smaller masks here
15573 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15574
15575 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15576 {
15577 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15578
15579 if (cur_mask == NULL) break;
15580
15581 masks[maskcnt] = cur_mask;
15582
15583 maskcnt++;
15584
15585 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15586 }
15587 }
15588 }
15589
15590 data.pw_min = pw_min;
15591 data.pw_max = pw_max;
15592
15593 /**
15594 * weak hash check
15595 */
15596
15597 if (weak_hash_threshold >= salts_cnt)
15598 {
15599 hc_device_param_t *device_param = NULL;
15600
15601 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15602 {
15603 device_param = &data.devices_param[device_id];
15604
15605 if (device_param->skipped) continue;
15606
15607 break;
15608 }
15609
15610 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15611
15612 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15613 {
15614 weak_hash_check (device_param, salt_pos);
15615 }
15616 }
15617
15618 // Display hack, guarantee that there is at least one \r before real start
15619
15620 if (data.quiet == 0) log_info_nn ("");
15621
15622 /**
15623 * status and monitor threads
15624 */
15625
15626 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15627
15628 hc_thread_t i_thread = 0;
15629
15630 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15631 {
15632 hc_thread_create (i_thread, thread_keypress, &benchmark);
15633 }
15634
15635 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15636
15637 uint ni_threads_cnt = 0;
15638
15639 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15640
15641 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15642
15643 ni_threads_cnt++;
15644
15645 /**
15646 * Outfile remove
15647 */
15648
15649 if (keyspace == 0)
15650 {
15651 if (outfile_check_timer != 0)
15652 {
15653 if (data.outfile_check_directory != NULL)
15654 {
15655 if ((hash_mode != 5200) &&
15656 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15657 (hash_mode != 9000))
15658 {
15659 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15660
15661 ni_threads_cnt++;
15662 }
15663 else
15664 {
15665 outfile_check_timer = 0;
15666 }
15667 }
15668 else
15669 {
15670 outfile_check_timer = 0;
15671 }
15672 }
15673 }
15674
15675 /**
15676 * Inform the user if we got some hashes remove because of the pot file remove feature
15677 */
15678
15679 if (data.quiet == 0)
15680 {
15681 if (potfile_remove_cracks > 0)
15682 {
15683 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15684 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15685 }
15686 }
15687
15688 data.outfile_check_timer = outfile_check_timer;
15689
15690 /**
15691 * main loop
15692 */
15693
15694 char **induction_dictionaries = NULL;
15695
15696 int induction_dictionaries_cnt = 0;
15697
15698 hcstat_table_t *root_table_buf = NULL;
15699 hcstat_table_t *markov_table_buf = NULL;
15700
15701 uint initial_restore_done = 0;
15702
15703 data.maskcnt = maskcnt;
15704
15705 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15706 {
15707 if (data.devices_status == STATUS_CRACKED) break;
15708
15709 data.devices_status = STATUS_INIT;
15710
15711 if (maskpos > rd->maskpos)
15712 {
15713 rd->dictpos = 0;
15714 }
15715
15716 rd->maskpos = maskpos;
15717 data.maskpos = maskpos;
15718
15719 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15720 {
15721 char *mask = masks[maskpos];
15722
15723 if (mask_from_file == 1)
15724 {
15725 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15726
15727 char *str_ptr;
15728 uint str_pos;
15729
15730 uint mask_offset = 0;
15731
15732 uint separator_cnt;
15733
15734 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15735 {
15736 str_ptr = strstr (mask + mask_offset, ",");
15737
15738 if (str_ptr == NULL) break;
15739
15740 str_pos = str_ptr - mask;
15741
15742 // escaped separator, i.e. "\,"
15743
15744 if (str_pos > 0)
15745 {
15746 if (mask[str_pos - 1] == '\\')
15747 {
15748 separator_cnt --;
15749
15750 mask_offset = str_pos + 1;
15751
15752 continue;
15753 }
15754 }
15755
15756 // reset the offset
15757
15758 mask_offset = 0;
15759
15760 mask[str_pos] = '\0';
15761
15762 switch (separator_cnt)
15763 {
15764 case 0:
15765 mp_reset_usr (mp_usr, 0);
15766
15767 custom_charset_1 = mask;
15768 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15769 break;
15770
15771 case 1:
15772 mp_reset_usr (mp_usr, 1);
15773
15774 custom_charset_2 = mask;
15775 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15776 break;
15777
15778 case 2:
15779 mp_reset_usr (mp_usr, 2);
15780
15781 custom_charset_3 = mask;
15782 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15783 break;
15784
15785 case 3:
15786 mp_reset_usr (mp_usr, 3);
15787
15788 custom_charset_4 = mask;
15789 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15790 break;
15791 }
15792
15793 mask = mask + str_pos + 1;
15794 }
15795 }
15796
15797 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15798 {
15799 if (maskpos > 0)
15800 {
15801 local_free (css_buf);
15802 local_free (data.root_css_buf);
15803 local_free (data.markov_css_buf);
15804
15805 local_free (masks[maskpos - 1]);
15806 }
15807
15808 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15809
15810 data.mask = mask;
15811 data.css_cnt = css_cnt;
15812 data.css_buf = css_buf;
15813
15814 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15815
15816 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15817
15818 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15819 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15820
15821 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15822
15823 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15824
15825 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15826 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15827
15828 data.root_css_buf = root_css_buf;
15829 data.markov_css_buf = markov_css_buf;
15830
15831 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15832
15833 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15834
15835 local_free (root_table_buf);
15836 local_free (markov_table_buf);
15837
15838 // args
15839
15840 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15841 {
15842 hc_device_param_t *device_param = &data.devices_param[device_id];
15843
15844 if (device_param->skipped) continue;
15845
15846 device_param->kernel_params_mp[0] = &device_param->d_combs;
15847 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15848 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15849
15850 device_param->kernel_params_mp_buf64[3] = 0;
15851 device_param->kernel_params_mp_buf32[4] = css_cnt;
15852 device_param->kernel_params_mp_buf32[5] = 0;
15853 device_param->kernel_params_mp_buf32[6] = 0;
15854 device_param->kernel_params_mp_buf32[7] = 0;
15855
15856 if (attack_mode == ATTACK_MODE_HYBRID1)
15857 {
15858 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15859 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15860 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15861 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15862 }
15863 else if (attack_mode == ATTACK_MODE_HYBRID2)
15864 {
15865 device_param->kernel_params_mp_buf32[5] = 0;
15866 device_param->kernel_params_mp_buf32[6] = 0;
15867 device_param->kernel_params_mp_buf32[7] = 0;
15868 }
15869
15870 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15871 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15872 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15873
15874 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_root_css_buf, CL_TRUE, 0, device_param->size_root_css, root_css_buf, 0, NULL, NULL);
15875 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, markov_css_buf, 0, NULL, NULL);
15876 }
15877 }
15878 else if (attack_mode == ATTACK_MODE_BF)
15879 {
15880 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15881
15882 if (increment)
15883 {
15884 for (uint i = 0; i < dictcnt; i++)
15885 {
15886 local_free (dictfiles[i]);
15887 }
15888
15889 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15890 {
15891 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15892
15893 if (l1_filename == NULL) break;
15894
15895 dictcnt++;
15896
15897 dictfiles[dictcnt - 1] = l1_filename;
15898 }
15899 }
15900 else
15901 {
15902 dictcnt++;
15903
15904 dictfiles[dictcnt - 1] = mask;
15905 }
15906
15907 if (dictcnt == 0)
15908 {
15909 log_error ("ERROR: Mask is too small");
15910
15911 return (-1);
15912 }
15913 }
15914 }
15915
15916 free (induction_dictionaries);
15917
15918 // induction_dictionaries_cnt = 0; // implied
15919
15920 if (attack_mode != ATTACK_MODE_BF)
15921 {
15922 if (keyspace == 0)
15923 {
15924 induction_dictionaries = scan_directory (induction_directory);
15925
15926 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15927 }
15928 }
15929
15930 if (induction_dictionaries_cnt)
15931 {
15932 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15933 }
15934
15935 /**
15936 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15937 */
15938 if (keyspace == 1)
15939 {
15940 if ((maskcnt > 1) || (dictcnt > 1))
15941 {
15942 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15943
15944 return (-1);
15945 }
15946 }
15947
15948 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15949 {
15950 char *subid = logfile_generate_subid ();
15951
15952 data.subid = subid;
15953
15954 logfile_sub_msg ("START");
15955
15956 data.devices_status = STATUS_INIT;
15957
15958 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15959 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15960 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15961
15962 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15963
15964 data.cpt_pos = 0;
15965
15966 data.cpt_start = time (NULL);
15967
15968 data.cpt_total = 0;
15969
15970 if (data.restore == 0)
15971 {
15972 rd->words_cur = skip;
15973
15974 skip = 0;
15975
15976 data.skip = 0;
15977 }
15978
15979 data.ms_paused = 0;
15980
15981 data.words_cur = rd->words_cur;
15982
15983 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15984 {
15985 hc_device_param_t *device_param = &data.devices_param[device_id];
15986
15987 if (device_param->skipped) continue;
15988
15989 device_param->speed_pos = 0;
15990
15991 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15992 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15993 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15994
15995 device_param->exec_pos = 0;
15996
15997 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
15998
15999 device_param->kernel_power = device_param->kernel_power_user;
16000
16001 device_param->outerloop_pos = 0;
16002 device_param->outerloop_left = 0;
16003 device_param->innerloop_pos = 0;
16004 device_param->innerloop_left = 0;
16005
16006 // some more resets:
16007
16008 if (device_param->pw_caches) memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
16009
16010 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16011
16012 device_param->pw_cnt = 0;
16013 device_param->pws_cnt = 0;
16014
16015 device_param->words_off = 0;
16016 device_param->words_done = 0;
16017 }
16018
16019 data.kernel_power_div = 0;
16020
16021 // figure out some workload
16022
16023 if (attack_mode == ATTACK_MODE_STRAIGHT)
16024 {
16025 if (data.wordlist_mode == WL_MODE_FILE)
16026 {
16027 char *dictfile = NULL;
16028
16029 if (induction_dictionaries_cnt)
16030 {
16031 dictfile = induction_dictionaries[0];
16032 }
16033 else
16034 {
16035 dictfile = dictfiles[dictpos];
16036 }
16037
16038 data.dictfile = dictfile;
16039
16040 logfile_sub_string (dictfile);
16041
16042 for (uint i = 0; i < rp_files_cnt; i++)
16043 {
16044 logfile_sub_var_string ("rulefile", rp_files[i]);
16045 }
16046
16047 FILE *fd2 = fopen (dictfile, "rb");
16048
16049 if (fd2 == NULL)
16050 {
16051 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16052
16053 return (-1);
16054 }
16055
16056 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16057
16058 fclose (fd2);
16059
16060 if (data.words_cnt == 0)
16061 {
16062 if (data.devices_status == STATUS_CRACKED) break;
16063 if (data.devices_status == STATUS_ABORTED) break;
16064
16065 dictpos++;
16066
16067 continue;
16068 }
16069 }
16070 }
16071 else if (attack_mode == ATTACK_MODE_COMBI)
16072 {
16073 char *dictfile = data.dictfile;
16074 char *dictfile2 = data.dictfile2;
16075
16076 logfile_sub_string (dictfile);
16077 logfile_sub_string (dictfile2);
16078
16079 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16080 {
16081 FILE *fd2 = fopen (dictfile, "rb");
16082
16083 if (fd2 == NULL)
16084 {
16085 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16086
16087 return (-1);
16088 }
16089
16090 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16091
16092 fclose (fd2);
16093 }
16094 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16095 {
16096 FILE *fd2 = fopen (dictfile2, "rb");
16097
16098 if (fd2 == NULL)
16099 {
16100 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16101
16102 return (-1);
16103 }
16104
16105 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16106
16107 fclose (fd2);
16108 }
16109
16110 if (data.words_cnt == 0)
16111 {
16112 if (data.devices_status == STATUS_CRACKED) break;
16113 if (data.devices_status == STATUS_ABORTED) break;
16114
16115 dictpos++;
16116
16117 continue;
16118 }
16119 }
16120 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16121 {
16122 char *dictfile = NULL;
16123
16124 if (induction_dictionaries_cnt)
16125 {
16126 dictfile = induction_dictionaries[0];
16127 }
16128 else
16129 {
16130 dictfile = dictfiles[dictpos];
16131 }
16132
16133 data.dictfile = dictfile;
16134
16135 char *mask = data.mask;
16136
16137 logfile_sub_string (dictfile);
16138 logfile_sub_string (mask);
16139
16140 FILE *fd2 = fopen (dictfile, "rb");
16141
16142 if (fd2 == NULL)
16143 {
16144 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16145
16146 return (-1);
16147 }
16148
16149 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16150
16151 fclose (fd2);
16152
16153 if (data.words_cnt == 0)
16154 {
16155 if (data.devices_status == STATUS_CRACKED) break;
16156 if (data.devices_status == STATUS_ABORTED) break;
16157
16158 dictpos++;
16159
16160 continue;
16161 }
16162 }
16163 else if (attack_mode == ATTACK_MODE_BF)
16164 {
16165 local_free (css_buf);
16166 local_free (data.root_css_buf);
16167 local_free (data.markov_css_buf);
16168
16169 char *mask = dictfiles[dictpos];
16170
16171 logfile_sub_string (mask);
16172
16173 // base
16174
16175 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16176
16177 if (opts_type & OPTS_TYPE_PT_UNICODE)
16178 {
16179 uint css_cnt_unicode = css_cnt * 2;
16180
16181 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16182
16183 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16184 {
16185 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16186
16187 css_buf_unicode[j + 1].cs_buf[0] = 0;
16188 css_buf_unicode[j + 1].cs_len = 1;
16189 }
16190
16191 free (css_buf);
16192
16193 css_buf = css_buf_unicode;
16194 css_cnt = css_cnt_unicode;
16195 }
16196
16197 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16198
16199 uint mask_min = pw_min;
16200 uint mask_max = pw_max;
16201
16202 if (opts_type & OPTS_TYPE_PT_UNICODE)
16203 {
16204 mask_min *= 2;
16205 mask_max *= 2;
16206 }
16207
16208 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16209 {
16210 if (css_cnt < mask_min)
16211 {
16212 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16213 }
16214
16215 if (css_cnt > mask_max)
16216 {
16217 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16218 }
16219
16220 // skip to next mask
16221
16222 dictpos++;
16223
16224 rd->dictpos = dictpos;
16225
16226 logfile_sub_msg ("STOP");
16227
16228 continue;
16229 }
16230
16231 uint save_css_cnt = css_cnt;
16232
16233 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16234 {
16235 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16236 {
16237 uint salt_len = (uint) data.salts_buf[0].salt_len;
16238 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16239
16240 uint css_cnt_salt = css_cnt + salt_len;
16241
16242 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16243
16244 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16245
16246 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16247 {
16248 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16249 css_buf_salt[j].cs_len = 1;
16250 }
16251
16252 free (css_buf);
16253
16254 css_buf = css_buf_salt;
16255 css_cnt = css_cnt_salt;
16256 }
16257 }
16258
16259 data.mask = mask;
16260 data.css_cnt = css_cnt;
16261 data.css_buf = css_buf;
16262
16263 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16264
16265 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16266
16267 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16268
16269 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16270 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16271
16272 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16273
16274 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16275
16276 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16277 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16278
16279 data.root_css_buf = root_css_buf;
16280 data.markov_css_buf = markov_css_buf;
16281
16282 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16283
16284 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16285
16286 local_free (root_table_buf);
16287 local_free (markov_table_buf);
16288
16289 // copy + args
16290
16291 uint css_cnt_l = css_cnt;
16292 uint css_cnt_r;
16293
16294 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16295 {
16296 if (save_css_cnt < 6)
16297 {
16298 css_cnt_r = 1;
16299 }
16300 else if (save_css_cnt == 6)
16301 {
16302 css_cnt_r = 2;
16303 }
16304 else
16305 {
16306 if (opts_type & OPTS_TYPE_PT_UNICODE)
16307 {
16308 if (save_css_cnt == 8 || save_css_cnt == 10)
16309 {
16310 css_cnt_r = 2;
16311 }
16312 else
16313 {
16314 css_cnt_r = 4;
16315 }
16316 }
16317 else
16318 {
16319 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16320 {
16321 css_cnt_r = 3;
16322 }
16323 else
16324 {
16325 css_cnt_r = 4;
16326 }
16327 }
16328 }
16329 }
16330 else
16331 {
16332 css_cnt_r = 1;
16333
16334 /* unfinished code?
16335 int sum = css_buf[css_cnt_r - 1].cs_len;
16336
16337 for (uint i = 1; i < 4 && i < css_cnt; i++)
16338 {
16339 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16340
16341 css_cnt_r++;
16342
16343 sum *= css_buf[css_cnt_r - 1].cs_len;
16344 }
16345 */
16346 }
16347
16348 css_cnt_l -= css_cnt_r;
16349
16350 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16351
16352 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16353 {
16354 hc_device_param_t *device_param = &data.devices_param[device_id];
16355
16356 if (device_param->skipped) continue;
16357
16358 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16359 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16360 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16361
16362 device_param->kernel_params_mp_l_buf64[3] = 0;
16363 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16364 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16365 device_param->kernel_params_mp_l_buf32[6] = 0;
16366 device_param->kernel_params_mp_l_buf32[7] = 0;
16367 device_param->kernel_params_mp_l_buf32[8] = 0;
16368
16369 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16370 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16371 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16372 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16373
16374 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16375 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16376 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16377
16378 device_param->kernel_params_mp_r_buf64[3] = 0;
16379 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16380 device_param->kernel_params_mp_r_buf32[5] = 0;
16381 device_param->kernel_params_mp_r_buf32[6] = 0;
16382 device_param->kernel_params_mp_r_buf32[7] = 0;
16383
16384 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_l[i]);
16385 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_l[i]);
16386 for (uint i = 4; i < 9; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_l[i]);
16387
16388 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_r[i]);
16389 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_r[i]);
16390 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_r[i]);
16391
16392 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_root_css_buf, CL_TRUE, 0, device_param->size_root_css, root_css_buf, 0, NULL, NULL);
16393 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, markov_css_buf, 0, NULL, NULL);
16394 }
16395 }
16396
16397 u64 words_base = data.words_cnt;
16398
16399 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16400 {
16401 if (data.kernel_rules_cnt)
16402 {
16403 words_base /= data.kernel_rules_cnt;
16404 }
16405 }
16406 else if (data.attack_kern == ATTACK_KERN_COMBI)
16407 {
16408 if (data.combs_cnt)
16409 {
16410 words_base /= data.combs_cnt;
16411 }
16412 }
16413 else if (data.attack_kern == ATTACK_KERN_BF)
16414 {
16415 if (data.bfs_cnt)
16416 {
16417 words_base /= data.bfs_cnt;
16418 }
16419 }
16420
16421 data.words_base = words_base;
16422
16423 if (keyspace == 1)
16424 {
16425 log_info ("%llu", (unsigned long long int) words_base);
16426
16427 return (0);
16428 }
16429
16430 if (data.words_cur > data.words_base)
16431 {
16432 log_error ("ERROR: restore value greater keyspace");
16433
16434 return (-1);
16435 }
16436
16437 if (data.words_cur)
16438 {
16439 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16440 {
16441 for (uint i = 0; i < data.salts_cnt; i++)
16442 {
16443 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16444 }
16445 }
16446 else if (data.attack_kern == ATTACK_KERN_COMBI)
16447 {
16448 for (uint i = 0; i < data.salts_cnt; i++)
16449 {
16450 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16451 }
16452 }
16453 else if (data.attack_kern == ATTACK_KERN_BF)
16454 {
16455 for (uint i = 0; i < data.salts_cnt; i++)
16456 {
16457 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16458 }
16459 }
16460 }
16461
16462 /*
16463 * Inform user about possible slow speeds
16464 */
16465
16466 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16467 {
16468 if (data.words_base < kernel_power_all)
16469 {
16470 if (quiet == 0)
16471 {
16472 log_info ("");
16473 log_info ("ATTENTION!");
16474 log_info (" The wordlist or mask you are using is too small.");
16475 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16476 log_info (" The cracking speed will drop.");
16477 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16478 log_info ("");
16479 }
16480 }
16481 }
16482
16483 /*
16484 * Update loopback file
16485 */
16486
16487 if (loopback == 1)
16488 {
16489 time_t now;
16490
16491 time (&now);
16492
16493 uint random_num = get_random_num (0, 9999);
16494
16495 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16496
16497 data.loopback_file = loopback_file;
16498 }
16499
16500 /*
16501 * Update dictionary statistic
16502 */
16503
16504 if (keyspace == 0)
16505 {
16506 dictstat_fp = fopen (dictstat, "wb");
16507
16508 if (dictstat_fp)
16509 {
16510 lock_file (dictstat_fp);
16511
16512 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16513
16514 fclose (dictstat_fp);
16515 }
16516 }
16517
16518 data.devices_status = STATUS_RUNNING;
16519
16520 if (initial_restore_done == 0)
16521 {
16522 if (data.restore_disable == 0) cycle_restore ();
16523
16524 initial_restore_done = 1;
16525 }
16526
16527 hc_timer_set (&data.timer_running);
16528
16529 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16530 {
16531 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16532 {
16533 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16534 if (quiet == 0) fflush (stdout);
16535 }
16536 }
16537 else if (wordlist_mode == WL_MODE_STDIN)
16538 {
16539 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16540 if (data.quiet == 0) log_info ("");
16541 }
16542
16543 time_t runtime_start;
16544
16545 time (&runtime_start);
16546
16547 data.runtime_start = runtime_start;
16548
16549 /**
16550 * create cracker threads
16551 */
16552
16553 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16554
16555 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16556 {
16557 hc_device_param_t *device_param = &devices_param[device_id];
16558
16559 if (wordlist_mode == WL_MODE_STDIN)
16560 {
16561 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16562 }
16563 else
16564 {
16565 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16566 }
16567 }
16568
16569 // wait for crack threads to exit
16570
16571 hc_thread_wait (data.devices_cnt, c_threads);
16572
16573 local_free (c_threads);
16574
16575 data.restore = 0;
16576
16577 // finalize task
16578
16579 logfile_sub_var_uint ("status-after-work", data.devices_status);
16580
16581 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16582
16583 if (data.devices_status == STATUS_CRACKED) break;
16584 if (data.devices_status == STATUS_ABORTED) break;
16585
16586 if (data.devices_status == STATUS_BYPASS)
16587 {
16588 data.devices_status = STATUS_RUNNING;
16589 }
16590
16591 if (induction_dictionaries_cnt)
16592 {
16593 unlink (induction_dictionaries[0]);
16594 }
16595
16596 free (induction_dictionaries);
16597
16598 if (attack_mode != ATTACK_MODE_BF)
16599 {
16600 induction_dictionaries = scan_directory (induction_directory);
16601
16602 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16603 }
16604
16605 if (benchmark == 0)
16606 {
16607 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16608 {
16609 if (quiet == 0) clear_prompt ();
16610
16611 if (quiet == 0) log_info ("");
16612
16613 if (status == 1)
16614 {
16615 status_display ();
16616 }
16617 else
16618 {
16619 if (quiet == 0) status_display ();
16620 }
16621
16622 if (quiet == 0) log_info ("");
16623 }
16624 }
16625
16626 if (attack_mode == ATTACK_MODE_BF)
16627 {
16628 dictpos++;
16629
16630 rd->dictpos = dictpos;
16631 }
16632 else
16633 {
16634 if (induction_dictionaries_cnt)
16635 {
16636 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16637 }
16638 else
16639 {
16640 dictpos++;
16641
16642 rd->dictpos = dictpos;
16643 }
16644 }
16645
16646 time_t runtime_stop;
16647
16648 time (&runtime_stop);
16649
16650 data.runtime_stop = runtime_stop;
16651
16652 logfile_sub_uint (runtime_start);
16653 logfile_sub_uint (runtime_stop);
16654
16655 logfile_sub_msg ("STOP");
16656
16657 global_free (subid);
16658 }
16659
16660 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16661
16662 if (data.devices_status == STATUS_CRACKED) break;
16663 if (data.devices_status == STATUS_ABORTED) break;
16664 if (data.devices_status == STATUS_QUIT) break;
16665
16666 if (data.devices_status == STATUS_BYPASS)
16667 {
16668 data.devices_status = STATUS_RUNNING;
16669 }
16670 }
16671
16672 // 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
16673
16674 if (attack_mode == ATTACK_MODE_STRAIGHT)
16675 {
16676 if (data.wordlist_mode == WL_MODE_FILE)
16677 {
16678 if (data.dictfile == NULL)
16679 {
16680 if (dictfiles != NULL)
16681 {
16682 data.dictfile = dictfiles[0];
16683
16684 hc_timer_set (&data.timer_running);
16685 }
16686 }
16687 }
16688 }
16689 // NOTE: combi is okay because it is already set beforehand
16690 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16691 {
16692 if (data.dictfile == NULL)
16693 {
16694 if (dictfiles != NULL)
16695 {
16696 hc_timer_set (&data.timer_running);
16697
16698 data.dictfile = dictfiles[0];
16699 }
16700 }
16701 }
16702 else if (attack_mode == ATTACK_MODE_BF)
16703 {
16704 if (data.mask == NULL)
16705 {
16706 hc_timer_set (&data.timer_running);
16707
16708 data.mask = masks[0];
16709 }
16710 }
16711
16712 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16713 {
16714 data.devices_status = STATUS_EXHAUSTED;
16715 }
16716
16717 // if cracked / aborted remove last induction dictionary
16718
16719 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16720 {
16721 struct stat induct_stat;
16722
16723 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16724 {
16725 unlink (induction_dictionaries[file_pos]);
16726 }
16727 }
16728
16729 // wait for non-interactive threads
16730
16731 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16732 {
16733 hc_thread_wait (1, &ni_threads[thread_idx]);
16734 }
16735
16736 local_free (ni_threads);
16737
16738 // wait for interactive threads
16739
16740 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16741 {
16742 hc_thread_wait (1, &i_thread);
16743 }
16744
16745 // we dont need restore file anymore
16746 if (data.restore_disable == 0)
16747 {
16748 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16749 {
16750 unlink (eff_restore_file);
16751 unlink (new_restore_file);
16752 }
16753 else
16754 {
16755 cycle_restore ();
16756 }
16757 }
16758
16759 // finally save left hashes
16760
16761 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16762 {
16763 save_hash ();
16764 }
16765
16766 /**
16767 * Clean up
16768 */
16769
16770 if (benchmark == 1)
16771 {
16772 status_benchmark ();
16773
16774 log_info ("");
16775 }
16776 else
16777 {
16778 if (quiet == 0) clear_prompt ();
16779
16780 if (quiet == 0) log_info ("");
16781
16782 if (status == 1)
16783 {
16784 status_display ();
16785 }
16786 else
16787 {
16788 if (quiet == 0) status_display ();
16789 }
16790
16791 if (quiet == 0) log_info ("");
16792 }
16793
16794 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16795 {
16796 hc_device_param_t *device_param = &data.devices_param[device_id];
16797
16798 if (device_param->skipped) continue;
16799
16800 local_free (device_param->result);
16801
16802 local_free (device_param->pw_caches);
16803
16804 local_free (device_param->combs_buf);
16805
16806 local_free (device_param->hooks_buf);
16807
16808 local_free (device_param->device_name);
16809
16810 local_free (device_param->device_name_chksum);
16811
16812 local_free (device_param->device_version);
16813
16814 local_free (device_param->driver_version);
16815
16816 if (device_param->pws_buf) myfree (device_param->pws_buf);
16817 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16818 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16819 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16820 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16821 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16822 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16823 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16824 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16825 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16826 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16827 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16828 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16829 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16830 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16831 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16832 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16833 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16834 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16835 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16836 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16837 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16838 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16839 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16840 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16841 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16842 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16843 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16844 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16845
16846 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16847 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16848 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16849 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16850 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16851 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16852 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16853 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16854 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16855 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16856 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16857
16858 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16859 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16860 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16861
16862 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16863 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16864 }
16865
16866 // reset default fan speed
16867
16868 #ifdef HAVE_HWMON
16869 if (gpu_temp_disable == 0)
16870 {
16871 #ifdef HAVE_ADL
16872 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16873 {
16874 hc_thread_mutex_lock (mux_adl);
16875
16876 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16877 {
16878 hc_device_param_t *device_param = &data.devices_param[device_id];
16879
16880 if (device_param->skipped) continue;
16881
16882 if (data.hm_device[device_id].fan_supported == 1)
16883 {
16884 int fanspeed = temp_retain_fanspeed_value[device_id];
16885
16886 if (fanspeed == -1) continue;
16887
16888 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16889
16890 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16891 }
16892 }
16893
16894 hc_thread_mutex_unlock (mux_adl);
16895 }
16896 #endif // HAVE_ADL
16897 }
16898
16899 #ifdef HAVE_ADL
16900 // reset power tuning
16901
16902 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16903 {
16904 hc_thread_mutex_lock (mux_adl);
16905
16906 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16907 {
16908 hc_device_param_t *device_param = &data.devices_param[device_id];
16909
16910 if (device_param->skipped) continue;
16911
16912 if (data.hm_device[device_id].od_version == 6)
16913 {
16914 // check powertune capabilities first, if not available then skip device
16915
16916 int powertune_supported = 0;
16917
16918 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16919 {
16920 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16921
16922 return (-1);
16923 }
16924
16925 if (powertune_supported != 0)
16926 {
16927 // powercontrol settings
16928
16929 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, od_power_control_status[device_id])) != ADL_OK)
16930 {
16931 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16932
16933 return (-1);
16934 }
16935
16936 // clocks
16937
16938 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16939
16940 performance_state->iNumberOfPerformanceLevels = 2;
16941
16942 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16943 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16944 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16945 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16946
16947 if ((hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
16948 {
16949 log_info ("ERROR: Failed to restore ADL performance state");
16950
16951 return (-1);
16952 }
16953
16954 local_free (performance_state);
16955 }
16956 }
16957 }
16958
16959 hc_thread_mutex_unlock (mux_adl);
16960 }
16961 #endif // HAVE_ADL
16962
16963 if (gpu_temp_disable == 0)
16964 {
16965 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16966 if (data.hm_nv)
16967 {
16968 #if defined(LINUX) && defined(HAVE_NVML)
16969
16970 hm_NVML_nvmlShutdown (data.hm_nv);
16971
16972 nvml_close (data.hm_nv);
16973
16974 #elif defined(WIN) && (HAVE_NVAPI)
16975
16976 hm_NvAPI_Unload (data.hm_nv);
16977
16978 nvapi_close (data.hm_nv);
16979
16980 #endif
16981
16982 data.hm_nv = NULL;
16983 }
16984 #endif
16985
16986 #ifdef HAVE_ADL
16987 if (data.hm_amd)
16988 {
16989 hm_ADL_Main_Control_Destroy (data.hm_amd);
16990
16991 adl_close (data.hm_amd);
16992 data.hm_amd = NULL;
16993 }
16994 #endif
16995 }
16996 #endif // HAVE_HWMON
16997
16998 // free memory
16999
17000 local_free (masks);
17001
17002 local_free (dictstat_base);
17003
17004 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17005 {
17006 pot_t *pot_ptr = &pot[pot_pos];
17007
17008 hash_t *hash = &pot_ptr->hash;
17009
17010 local_free (hash->digest);
17011
17012 if (isSalted)
17013 {
17014 local_free (hash->salt);
17015 }
17016 }
17017
17018 local_free (pot);
17019
17020 local_free (all_kernel_rules_cnt);
17021 local_free (all_kernel_rules_buf);
17022
17023 local_free (wl_data->buf);
17024 local_free (wl_data);
17025
17026 local_free (bitmap_s1_a);
17027 local_free (bitmap_s1_b);
17028 local_free (bitmap_s1_c);
17029 local_free (bitmap_s1_d);
17030 local_free (bitmap_s2_a);
17031 local_free (bitmap_s2_b);
17032 local_free (bitmap_s2_c);
17033 local_free (bitmap_s2_d);
17034
17035 #ifdef HAVE_HWMON
17036 local_free (temp_retain_fanspeed_value);
17037 #ifdef HAVE_ADL
17038 local_free (od_clock_mem_status);
17039 local_free (od_power_control_status);
17040 #endif // ADL
17041 #endif
17042
17043 global_free (devices_param);
17044
17045 global_free (kernel_rules_buf);
17046
17047 global_free (root_css_buf);
17048 global_free (markov_css_buf);
17049
17050 global_free (digests_buf);
17051 global_free (digests_shown);
17052 global_free (digests_shown_tmp);
17053
17054 global_free (salts_buf);
17055 global_free (salts_shown);
17056
17057 global_free (esalts_buf);
17058
17059 global_free (words_progress_done);
17060 global_free (words_progress_rejected);
17061 global_free (words_progress_restored);
17062
17063 if (pot_fp) fclose (pot_fp);
17064
17065 if (data.devices_status == STATUS_QUIT) break;
17066 }
17067
17068 // destroy others mutex
17069
17070 hc_thread_mutex_delete (mux_dispatcher);
17071 hc_thread_mutex_delete (mux_counter);
17072 hc_thread_mutex_delete (mux_display);
17073 hc_thread_mutex_delete (mux_adl);
17074
17075 // free memory
17076
17077 local_free (eff_restore_file);
17078 local_free (new_restore_file);
17079
17080 local_free (rd);
17081
17082 // tuning db
17083
17084 tuning_db_destroy (tuning_db);
17085
17086 // loopback
17087
17088 local_free (loopback_file);
17089
17090 if (loopback == 1) unlink (loopback_file);
17091
17092 // induction directory
17093
17094 if (induction_dir == NULL)
17095 {
17096 if (attack_mode != ATTACK_MODE_BF)
17097 {
17098 if (rmdir (induction_directory) == -1)
17099 {
17100 if (errno == ENOENT)
17101 {
17102 // good, we can ignore
17103 }
17104 else if (errno == ENOTEMPTY)
17105 {
17106 // good, we can ignore
17107 }
17108 else
17109 {
17110 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17111
17112 return (-1);
17113 }
17114 }
17115
17116 local_free (induction_directory);
17117 }
17118 }
17119
17120 // outfile-check directory
17121
17122 if (outfile_check_dir == NULL)
17123 {
17124 if (rmdir (outfile_check_directory) == -1)
17125 {
17126 if (errno == ENOENT)
17127 {
17128 // good, we can ignore
17129 }
17130 else if (errno == ENOTEMPTY)
17131 {
17132 // good, we can ignore
17133 }
17134 else
17135 {
17136 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17137
17138 return (-1);
17139 }
17140 }
17141
17142 local_free (outfile_check_directory);
17143 }
17144
17145 time_t proc_stop;
17146
17147 time (&proc_stop);
17148
17149 logfile_top_uint (proc_start);
17150 logfile_top_uint (proc_stop);
17151
17152 logfile_top_msg ("STOP");
17153
17154 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17155 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17156
17157 if (data.ocl) ocl_close (data.ocl);
17158
17159 if (data.devices_status == STATUS_ABORTED) return 2;
17160 if (data.devices_status == STATUS_QUIT) return 2;
17161 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17162 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17163 if (data.devices_status == STATUS_CRACKED) return 0;
17164
17165 return -1;
17166 }
Hashcat additions to support pwdhash