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