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