projects / hashcat.git / blob
? search:


c50e03fca41cb0b139bc45288026e582738c2c35
[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 131
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 13100,
186 8300,
187 11100,
188 11200,
189 11400,
190 121,
191 2611,
192 2711,
193 2811,
194 8400,
195 11,
196 2612,
197 7900,
198 21,
199 11000,
200 124,
201 10000,
202 3711,
203 7600,
204 12,
205 131,
206 132,
207 1731,
208 200,
209 300,
210 3100,
211 112,
212 12300,
213 8000,
214 141,
215 1441,
216 1600,
217 12600,
218 1421,
219 101,
220 111,
221 1711,
222 3000, // broken in osx
223 1000,
224 1100,
225 2100,
226 12800,
227 1500, // broken in osx
228 12400,
229 500,
230 3200,
231 7400,
232 1800,
233 122,
234 1722,
235 7100,
236 6300,
237 6700,
238 6400,
239 6500,
240 2400,
241 2410,
242 5700,
243 9200,
244 9300,
245 22,
246 501,
247 5800,
248 8100,
249 8500,
250 7200,
251 9900,
252 7700,
253 7800,
254 10300,
255 8600,
256 8700,
257 9100,
258 133,
259 11600,
260 12500,
261 13000,
262 6211,
263 6221,
264 6231,
265 6241,
266 8800,
267 12900,
268 12200,
269 9700,
270 9710,
271 9800,
272 9810,
273 9400,
274 9500,
275 9600,
276 10400,
277 10410,
278 10500,
279 10600,
280 10700, // broken in osx
281 9000,
282 5200,
283 6800,
284 6600,
285 8200,
286 11300,
287 12700
288 };
289
290 /**
291 * types
292 */
293
294 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
295
296 /**
297 * globals
298 */
299
300 static unsigned int full01 = 0x01010101;
301 static unsigned int full80 = 0x80808080;
302
303 int SUPPRESS_OUTPUT = 0;
304
305 hc_thread_mutex_t mux_adl;
306 hc_thread_mutex_t mux_counter;
307 hc_thread_mutex_t mux_dispatcher;
308 hc_thread_mutex_t mux_display;
309
310 hc_global_data_t data;
311
312 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
313
314 const char *USAGE_MINI[] =
315 {
316 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
317 "",
318 "Try --help for more help.",
319 NULL
320 };
321
322 const char *USAGE_BIG[] =
323 {
324 "%s, advanced password recovery",
325 "",
326 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
327 "",
328 "=======",
329 "Options",
330 "=======",
331 "",
332 "* General:",
333 "",
334 " -m, --hash-type=NUM Hash-type, see references below",
335 " -a, --attack-mode=NUM Attack-mode, see references below",
336 " -V, --version Print version",
337 " -h, --help Print help",
338 " --quiet Suppress output",
339 "",
340 "* Misc:",
341 "",
342 " --hex-charset Assume charset is given in hex",
343 " --hex-salt Assume salt is given in hex",
344 " --hex-wordlist Assume words in wordlist is given in hex",
345 " --force Ignore warnings",
346 " --status Enable automatic update of the status-screen",
347 " --status-timer=NUM Seconds between status-screen update",
348 " --status-automat Display the status view in a machine readable format",
349 " --loopback Add new plains to induct directory",
350 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
351 "",
352 "* Markov:",
353 "",
354 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
355 " --markov-disable Disables markov-chains, emulates classic brute-force",
356 " --markov-classic Enables classic markov-chains, no per-position enhancement",
357 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
358 "",
359 "* Session:",
360 "",
361 " --runtime=NUM Abort session after NUM seconds of runtime",
362 " --session=STR Define specific session name",
363 " --restore Restore session from --session",
364 " --restore-disable Do not write restore file",
365 "",
366 "* Files:",
367 "",
368 " -o, --outfile=FILE Define outfile for recovered hash",
369 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
370 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
371 " --outfile-check-timer=NUM Seconds between outfile checks",
372 " -p, --separator=CHAR Separator char for hashlists and outfile",
373 " --show Show cracked passwords only",
374 " --left Show un-cracked passwords only",
375 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
376 " --remove Enable remove of hash once it is cracked",
377 " --remove-timer=NUM Update input hash file each NUM seconds",
378 " --potfile-disable Do not write potfile",
379 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
380 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
381 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
382 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
383 " --logfile-disable Disable the logfile",
384 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
385 "",
386 "* Resources:",
387 "",
388 " -b, --benchmark Run benchmark",
389 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
390 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
391 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
392 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
393 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
394 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
395 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
396 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
397 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4 or 8), overrides value from device query",
398 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
399 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
400 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
401 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
402 #ifdef HAVE_HWMON
403 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
404 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
405 #ifdef HAVE_ADL
406 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
407 #endif
408 #endif
409 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
410 "",
411 "* Distributed:",
412 "",
413 " -s, --skip=NUM Skip number of words",
414 " -l, --limit=NUM Limit number of words",
415 " --keyspace Show keyspace base:mod values and quit",
416 "",
417 "* Rules:",
418 "",
419 " -j, --rule-left=RULE Single rule applied to each word from left dict",
420 " -k, --rule-right=RULE Single rule applied to each word from right dict",
421 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
422 " -g, --generate-rules=NUM Generate NUM random rules",
423 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
424 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
425 " --generate-rules-seed=NUM Force RNG seed to NUM",
426 "",
427 "* Custom charsets:",
428 "",
429 " -1, --custom-charset1=CS User-defined charsets",
430 " -2, --custom-charset2=CS Example:",
431 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
432 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
433 "",
434 "* Increment:",
435 "",
436 " -i, --increment Enable increment mode",
437 " --increment-min=NUM Start incrementing at NUM",
438 " --increment-max=NUM Stop incrementing at NUM",
439 "",
440 "==========",
441 "References",
442 "==========",
443 "",
444 "* Workload Profile:",
445 "",
446 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
447 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
448 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
449 "",
450 "* OpenCL device-types:",
451 "",
452 " 1 = CPU devices",
453 " 2 = GPU devices",
454 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
455 "",
456 "* Outfile Formats:",
457 "",
458 " 1 = hash[:salt]",
459 " 2 = plain",
460 " 3 = hash[:salt]:plain",
461 " 4 = hex_plain",
462 " 5 = hash[:salt]:hex_plain",
463 " 6 = plain:hex_plain",
464 " 7 = hash[:salt]:plain:hex_plain",
465 " 8 = crackpos",
466 " 9 = hash[:salt]:crackpos",
467 " 10 = plain:crackpos",
468 " 11 = hash[:salt]:plain:crackpos",
469 " 12 = hex_plain:crackpos",
470 " 13 = hash[:salt]:hex_plain:crackpos",
471 " 14 = plain:hex_plain:crackpos",
472 " 15 = hash[:salt]:plain:hex_plain:crackpos",
473 "",
474 "* Debug mode output formats (for hybrid mode only, by using rules):",
475 "",
476 " 1 = save finding rule",
477 " 2 = save original word",
478 " 3 = save original word and finding rule",
479 " 4 = save original word, finding rule and modified plain",
480 "",
481 "* Built-in charsets:",
482 "",
483 " ?l = abcdefghijklmnopqrstuvwxyz",
484 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
485 " ?d = 0123456789",
486 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
487 " ?a = ?l?u?d?s",
488 " ?b = 0x00 - 0xff",
489 "",
490 "* Attack modes:",
491 "",
492 " 0 = Straight",
493 " 1 = Combination",
494 " 3 = Brute-force",
495 " 6 = Hybrid dict + mask",
496 " 7 = Hybrid mask + dict",
497 "",
498 "* Hash types:",
499 "",
500 "[[ Roll-your-own: Raw Hashes ]]",
501 "",
502 " 900 = MD4",
503 " 0 = MD5",
504 " 5100 = Half MD5",
505 " 100 = SHA1",
506 " 10800 = SHA-384",
507 " 1400 = SHA-256",
508 " 1700 = SHA-512",
509 " 5000 = SHA-3(Keccak)",
510 " 10100 = SipHash",
511 " 6000 = RipeMD160",
512 " 6100 = Whirlpool",
513 " 6900 = GOST R 34.11-94",
514 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
515 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
516 "",
517 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
518 "",
519 " 10 = md5($pass.$salt)",
520 " 20 = md5($salt.$pass)",
521 " 30 = md5(unicode($pass).$salt)",
522 " 40 = md5($salt.unicode($pass))",
523 " 3800 = md5($salt.$pass.$salt)",
524 " 3710 = md5($salt.md5($pass))",
525 " 2600 = md5(md5($pass)",
526 " 4300 = md5(strtoupper(md5($pass)))",
527 " 4400 = md5(sha1($pass))",
528 " 110 = sha1($pass.$salt)",
529 " 120 = sha1($salt.$pass)",
530 " 130 = sha1(unicode($pass).$salt)",
531 " 140 = sha1($salt.unicode($pass))",
532 " 4500 = sha1(sha1($pass)",
533 " 4700 = sha1(md5($pass))",
534 " 4900 = sha1($salt.$pass.$salt)",
535 " 1410 = sha256($pass.$salt)",
536 " 1420 = sha256($salt.$pass)",
537 " 1430 = sha256(unicode($pass).$salt)",
538 " 1440 = sha256($salt.unicode($pass))",
539 " 1710 = sha512($pass.$salt)",
540 " 1720 = sha512($salt.$pass)",
541 " 1730 = sha512(unicode($pass).$salt)",
542 " 1740 = sha512($salt.unicode($pass))",
543 "",
544 "[[ Roll-your-own: Authenticated Hashes ]]",
545 "",
546 " 50 = HMAC-MD5 (key = $pass)",
547 " 60 = HMAC-MD5 (key = $salt)",
548 " 150 = HMAC-SHA1 (key = $pass)",
549 " 160 = HMAC-SHA1 (key = $salt)",
550 " 1450 = HMAC-SHA256 (key = $pass)",
551 " 1460 = HMAC-SHA256 (key = $salt)",
552 " 1750 = HMAC-SHA512 (key = $pass)",
553 " 1760 = HMAC-SHA512 (key = $salt)",
554 "",
555 "[[ Generic KDF ]]",
556 "",
557 " 400 = phpass",
558 " 8900 = scrypt",
559 " 11900 = PBKDF2-HMAC-MD5",
560 " 12000 = PBKDF2-HMAC-SHA1",
561 " 10900 = PBKDF2-HMAC-SHA256",
562 " 12100 = PBKDF2-HMAC-SHA512",
563 "",
564 "[[ Network protocols, Challenge-Response ]]",
565 "",
566 " 23 = Skype",
567 " 2500 = WPA/WPA2",
568 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
569 " 5300 = IKE-PSK MD5",
570 " 5400 = IKE-PSK SHA1",
571 " 5500 = NetNTLMv1",
572 " 5500 = NetNTLMv1 + ESS",
573 " 5600 = NetNTLMv2",
574 " 7300 = IPMI2 RAKP HMAC-SHA1",
575 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
576 " 8300 = DNSSEC (NSEC3)",
577 " 10200 = Cram MD5",
578 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
579 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
580 " 11400 = SIP digest authentication (MD5)",
581 " 13100 = Kerberos 5 TGS-REP etype 23",
582 "",
583 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
584 "",
585 " 121 = SMF (Simple Machines Forum)",
586 " 400 = phpBB3",
587 " 2611 = vBulletin < v3.8.5",
588 " 2711 = vBulletin > v3.8.5",
589 " 2811 = MyBB",
590 " 2811 = IPB (Invison Power Board)",
591 " 8400 = WBB3 (Woltlab Burning Board)",
592 " 11 = Joomla < 2.5.18",
593 " 400 = Joomla > 2.5.18",
594 " 400 = Wordpress",
595 " 2612 = PHPS",
596 " 7900 = Drupal7",
597 " 21 = osCommerce",
598 " 21 = xt:Commerce",
599 " 11000 = PrestaShop",
600 " 124 = Django (SHA-1)",
601 " 10000 = Django (PBKDF2-SHA256)",
602 " 3711 = Mediawiki B type",
603 " 7600 = Redmine",
604 "",
605 "[[ Database Server ]]",
606 "",
607 " 12 = PostgreSQL",
608 " 131 = MSSQL(2000)",
609 " 132 = MSSQL(2005)",
610 " 1731 = MSSQL(2012)",
611 " 1731 = MSSQL(2014)",
612 " 200 = MySQL323",
613 " 300 = MySQL4.1/MySQL5",
614 " 3100 = Oracle H: Type (Oracle 7+)",
615 " 112 = Oracle S: Type (Oracle 11+)",
616 " 12300 = Oracle T: Type (Oracle 12+)",
617 " 8000 = Sybase ASE",
618 "",
619 "[[ HTTP, SMTP, LDAP Server ]]",
620 "",
621 " 141 = EPiServer 6.x < v4",
622 " 1441 = EPiServer 6.x > v4",
623 " 1600 = Apache $apr1$",
624 " 12600 = ColdFusion 10+",
625 " 1421 = hMailServer",
626 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
627 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
628 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
629 "",
630 "[[ Checksums ]]",
631 "",
632 " 11500 = CRC32",
633 "",
634 "[[ Operating-Systems ]]",
635 "",
636 " 3000 = LM",
637 " 1000 = NTLM",
638 " 1100 = Domain Cached Credentials (DCC), MS Cache",
639 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
640 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
641 " 1500 = descrypt, DES(Unix), Traditional DES",
642 " 12400 = BSDiCrypt, Extended DES",
643 " 500 = md5crypt $1$, MD5(Unix)",
644 " 3200 = bcrypt $2*$, Blowfish(Unix)",
645 " 7400 = sha256crypt $5$, SHA256(Unix)",
646 " 1800 = sha512crypt $6$, SHA512(Unix)",
647 " 122 = OSX v10.4",
648 " 122 = OSX v10.5",
649 " 122 = OSX v10.6",
650 " 1722 = OSX v10.7",
651 " 7100 = OSX v10.8",
652 " 7100 = OSX v10.9",
653 " 7100 = OSX v10.10",
654 " 6300 = AIX {smd5}",
655 " 6700 = AIX {ssha1}",
656 " 6400 = AIX {ssha256}",
657 " 6500 = AIX {ssha512}",
658 " 2400 = Cisco-PIX",
659 " 2410 = Cisco-ASA",
660 " 500 = Cisco-IOS $1$",
661 " 5700 = Cisco-IOS $4$",
662 " 9200 = Cisco-IOS $8$",
663 " 9300 = Cisco-IOS $9$",
664 " 22 = Juniper Netscreen/SSG (ScreenOS)",
665 " 501 = Juniper IVE",
666 " 5800 = Android PIN",
667 " 8100 = Citrix Netscaler",
668 " 8500 = RACF",
669 " 7200 = GRUB 2",
670 " 9900 = Radmin2",
671 "",
672 "[[ Enterprise Application Software (EAS) ]]",
673 "",
674 " 7700 = SAP CODVN B (BCODE)",
675 " 7800 = SAP CODVN F/G (PASSCODE)",
676 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
677 " 8600 = Lotus Notes/Domino 5",
678 " 8700 = Lotus Notes/Domino 6",
679 " 9100 = Lotus Notes/Domino 8",
680 " 133 = PeopleSoft",
681 "",
682 "[[ Archives ]]",
683 "",
684 " 11600 = 7-Zip",
685 " 12500 = RAR3-hp",
686 " 13000 = RAR5",
687 "",
688 "[[ Full-Disk encryptions (FDE) ]]",
689 "",
690 " 62XY = TrueCrypt 5.0+",
691 " X = 1 = PBKDF2-HMAC-RipeMD160",
692 " X = 2 = PBKDF2-HMAC-SHA512",
693 " X = 3 = PBKDF2-HMAC-Whirlpool",
694 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
695 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
696 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
697 " Y = 3 = XTS 1536 bit (Ciphers: All)",
698 " 8800 = Android FDE < v4.3",
699 " 12900 = Android FDE (Samsung DEK)",
700 " 12200 = eCryptfs",
701 "",
702 "[[ Documents ]]",
703 "",
704 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
705 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
706 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
707 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
708 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
709 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
710 " 9400 = MS Office 2007",
711 " 9500 = MS Office 2010",
712 " 9600 = MS Office 2013",
713 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
714 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
715 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
716 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
717 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
718 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
719 "",
720 "[[ Password Managers ]]",
721 "",
722 " 9000 = Password Safe v2",
723 " 5200 = Password Safe v3",
724 " 6800 = Lastpass",
725 " 6600 = 1Password, agilekeychain",
726 " 8200 = 1Password, cloudkeychain",
727 " 11300 = Bitcoin/Litecoin wallet.dat",
728 " 12700 = Blockchain, My Wallet",
729 "",
730 NULL
731 };
732
733 /**
734 * oclHashcat specific functions
735 */
736
737 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
738 {
739 int exec_pos = (int) device_param->exec_pos - last_num_entries;
740
741 if (exec_pos < 0) exec_pos += EXEC_CACHE;
742
743 double exec_ms_sum = 0;
744
745 int exec_ms_cnt = 0;
746
747 for (int i = 0; i < last_num_entries; i++)
748 {
749 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
750
751 if (exec_ms)
752 {
753 exec_ms_sum += exec_ms;
754
755 exec_ms_cnt++;
756 }
757 }
758
759 if (exec_ms_cnt == 0) return 0;
760
761 return exec_ms_sum / exec_ms_cnt;
762 }
763
764 void status_display_automat ()
765 {
766 FILE *out = stdout;
767
768 fprintf (out, "STATUS\t%u\t", data.devices_status);
769
770 /**
771 * speed new
772 */
773
774 fprintf (out, "SPEED\t");
775
776 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
777 {
778 hc_device_param_t *device_param = &data.devices_param[device_id];
779
780 if (device_param->skipped) continue;
781
782 u64 speed_cnt = 0;
783 float speed_ms = 0;
784
785 for (int i = 0; i < SPEED_CACHE; i++)
786 {
787 float rec_ms;
788
789 hc_timer_get (device_param->speed_rec[i], rec_ms);
790
791 if (rec_ms > SPEED_MAXAGE) continue;
792
793 speed_cnt += device_param->speed_cnt[i];
794 speed_ms += device_param->speed_ms[i];
795 }
796
797 speed_cnt /= SPEED_CACHE;
798 speed_ms /= SPEED_CACHE;
799
800 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
801 }
802
803 /**
804 * exec time
805 */
806
807 fprintf (out, "EXEC_RUNTIME\t");
808
809 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
810 {
811 hc_device_param_t *device_param = &data.devices_param[device_id];
812
813 if (device_param->skipped) continue;
814
815 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
816
817 fprintf (out, "%f\t", exec_ms_avg);
818 }
819
820 /**
821 * words_cur
822 */
823
824 u64 words_cur = get_lowest_words_done ();
825
826 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
827
828 /**
829 * counter
830 */
831
832 uint salts_left = data.salts_cnt - data.salts_done;
833
834 if (salts_left == 0) salts_left = 1;
835
836 u64 progress_total = data.words_cnt * salts_left;
837
838 u64 all_done = 0;
839 u64 all_rejected = 0;
840 u64 all_restored = 0;
841
842 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
843 {
844 if (salts_left > 1)
845 {
846 // otherwise the final cracked status shows 0/XXX progress
847
848 if (data.salts_shown[salt_pos] == 1) continue;
849 }
850
851 all_done += data.words_progress_done[salt_pos];
852 all_rejected += data.words_progress_rejected[salt_pos];
853 all_restored += data.words_progress_restored[salt_pos];
854 }
855
856 u64 progress_cur = all_restored + all_done + all_rejected;
857 u64 progress_end = progress_total;
858
859 u64 progress_skip = 0;
860
861 if (data.skip)
862 {
863 progress_skip = MIN (data.skip, data.words_base) * salts_left;
864
865 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
866 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
867 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
868 }
869
870 if (data.limit)
871 {
872 progress_end = MIN (data.limit, data.words_base) * salts_left;
873
874 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
875 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
876 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
877 }
878
879 u64 progress_cur_relative_skip = progress_cur - progress_skip;
880 u64 progress_end_relative_skip = progress_end - progress_skip;
881
882 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
883
884 /**
885 * cracks
886 */
887
888 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
889 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
890
891 /**
892 * temperature
893 */
894
895 #ifdef HAVE_HWMON
896 if (data.gpu_temp_disable == 0)
897 {
898 fprintf (out, "TEMP\t");
899
900 hc_thread_mutex_lock (mux_adl);
901
902 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
903 {
904 hc_device_param_t *device_param = &data.devices_param[device_id];
905
906 if (device_param->skipped) continue;
907
908 int temp = hm_get_temperature_with_device_id (device_id);
909
910 fprintf (out, "%d\t", temp);
911 }
912
913 hc_thread_mutex_unlock (mux_adl);
914 }
915 #endif // HAVE_HWMON
916
917 /**
918 * flush
919 */
920
921 #ifdef _WIN
922 fputc ('\r', out);
923 fputc ('\n', out);
924 #endif
925
926 #ifdef _POSIX
927 fputc ('\n', out);
928 #endif
929
930 fflush (out);
931 }
932
933 void status_display ()
934 {
935 if (data.devices_status == STATUS_INIT) return;
936 if (data.devices_status == STATUS_STARTING) return;
937 if (data.devices_status == STATUS_BYPASS) return;
938
939 if (data.status_automat == 1)
940 {
941 status_display_automat ();
942
943 return;
944 }
945
946 char tmp_buf[1000] = { 0 };
947
948 uint tmp_len = 0;
949
950 log_info ("Session.Name...: %s", data.session);
951
952 char *status_type = strstatus (data.devices_status);
953
954 uint hash_mode = data.hash_mode;
955
956 char *hash_type = strhashtype (hash_mode); // not a bug
957
958 log_info ("Status.........: %s", status_type);
959
960 /**
961 * show rules
962 */
963
964 if (data.rp_files_cnt)
965 {
966 uint i;
967
968 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
969 {
970 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
971 }
972
973 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
974
975 log_info ("Rules.Type.....: %s", tmp_buf);
976
977 tmp_len = 0;
978 }
979
980 if (data.rp_gen)
981 {
982 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
983
984 if (data.rp_gen_seed)
985 {
986 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
987 }
988 }
989
990 /**
991 * show input
992 */
993
994 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
995 {
996 if (data.wordlist_mode == WL_MODE_FILE)
997 {
998 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
999 }
1000 else if (data.wordlist_mode == WL_MODE_STDIN)
1001 {
1002 log_info ("Input.Mode.....: Pipe");
1003 }
1004 }
1005 else if (data.attack_mode == ATTACK_MODE_COMBI)
1006 {
1007 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1008 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1009 }
1010 else if (data.attack_mode == ATTACK_MODE_BF)
1011 {
1012 char *mask = data.mask;
1013
1014 if (mask != NULL)
1015 {
1016 uint mask_len = data.css_cnt;
1017
1018 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1019
1020 if (mask_len > 0)
1021 {
1022 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1023 {
1024 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1025 {
1026 mask_len -= data.salts_buf[0].salt_len;
1027 }
1028 }
1029
1030 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1031
1032 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1033 }
1034
1035 if (data.maskcnt > 1)
1036 {
1037 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1038
1039 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1040 }
1041
1042 log_info ("Input.Mode.....: %s", tmp_buf);
1043 }
1044
1045 tmp_len = 0;
1046 }
1047 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1048 {
1049 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1050 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1051 }
1052 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1053 {
1054 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1055 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1056 }
1057
1058 if (data.digests_cnt == 1)
1059 {
1060 if (data.hash_mode == 2500)
1061 {
1062 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1063
1064 uint pke[25] = { 0 };
1065
1066 char *pke_ptr = (char *) pke;
1067
1068 for (uint i = 0; i < 25; i++)
1069 {
1070 pke[i] = byte_swap_32 (wpa->pke[i]);
1071 }
1072
1073 char mac1[6] = { 0 };
1074 char mac2[6] = { 0 };
1075
1076 memcpy (mac1, pke_ptr + 23, 6);
1077 memcpy (mac2, pke_ptr + 29, 6);
1078
1079 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1080 (char *) data.salts_buf[0].salt_buf,
1081 mac1[0] & 0xff,
1082 mac1[1] & 0xff,
1083 mac1[2] & 0xff,
1084 mac1[3] & 0xff,
1085 mac1[4] & 0xff,
1086 mac1[5] & 0xff,
1087 mac2[0] & 0xff,
1088 mac2[1] & 0xff,
1089 mac2[2] & 0xff,
1090 mac2[3] & 0xff,
1091 mac2[4] & 0xff,
1092 mac2[5] & 0xff);
1093 }
1094 else if (data.hash_mode == 5200)
1095 {
1096 log_info ("Hash.Target....: File (%s)", data.hashfile);
1097 }
1098 else if (data.hash_mode == 9000)
1099 {
1100 log_info ("Hash.Target....: File (%s)", data.hashfile);
1101 }
1102 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1103 {
1104 log_info ("Hash.Target....: File (%s)", data.hashfile);
1105 }
1106 else
1107 {
1108 char out_buf[4096] = { 0 };
1109
1110 ascii_digest (out_buf, 0, 0);
1111
1112 // limit length
1113 if (strlen (out_buf) > 40)
1114 {
1115 out_buf[41] = '.';
1116 out_buf[42] = '.';
1117 out_buf[43] = '.';
1118 out_buf[44] = 0;
1119 }
1120
1121 log_info ("Hash.Target....: %s", out_buf);
1122 }
1123 }
1124 else
1125 {
1126 if (data.hash_mode == 3000)
1127 {
1128 char out_buf1[4096] = { 0 };
1129 char out_buf2[4096] = { 0 };
1130
1131 ascii_digest (out_buf1, 0, 0);
1132 ascii_digest (out_buf2, 0, 1);
1133
1134 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1135 }
1136 else
1137 {
1138 log_info ("Hash.Target....: File (%s)", data.hashfile);
1139 }
1140 }
1141
1142 log_info ("Hash.Type......: %s", hash_type);
1143
1144 /**
1145 * speed new
1146 */
1147
1148 u64 speed_cnt[DEVICES_MAX] = { 0 };
1149 float speed_ms[DEVICES_MAX] = { 0 };
1150
1151 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1152 {
1153 hc_device_param_t *device_param = &data.devices_param[device_id];
1154
1155 if (device_param->skipped) continue;
1156
1157 // we need to clear values (set to 0) because in case the device does
1158 // not get new candidates it idles around but speed display would
1159 // show it as working.
1160 // if we instantly set it to 0 after reading it happens that the
1161 // speed can be shown as zero if the users refreshes too fast.
1162 // therefore, we add a timestamp when a stat was recorded and if its
1163 // too old we will not use it
1164
1165 speed_cnt[device_id] = 0;
1166 speed_ms[device_id] = 0;
1167
1168 for (int i = 0; i < SPEED_CACHE; i++)
1169 {
1170 float rec_ms;
1171
1172 hc_timer_get (device_param->speed_rec[i], rec_ms);
1173
1174 if (rec_ms > SPEED_MAXAGE) continue;
1175
1176 speed_cnt[device_id] += device_param->speed_cnt[i];
1177 speed_ms[device_id] += device_param->speed_ms[i];
1178 }
1179
1180 speed_cnt[device_id] /= SPEED_CACHE;
1181 speed_ms[device_id] /= SPEED_CACHE;
1182 }
1183
1184 float hashes_all_ms = 0;
1185
1186 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1187
1188 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1189 {
1190 hc_device_param_t *device_param = &data.devices_param[device_id];
1191
1192 if (device_param->skipped) continue;
1193
1194 hashes_dev_ms[device_id] = 0;
1195
1196 if (speed_ms[device_id])
1197 {
1198 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1199
1200 hashes_all_ms += hashes_dev_ms[device_id];
1201 }
1202 }
1203
1204 /**
1205 * exec time
1206 */
1207
1208 double exec_all_ms[DEVICES_MAX] = { 0 };
1209
1210 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1211 {
1212 hc_device_param_t *device_param = &data.devices_param[device_id];
1213
1214 if (device_param->skipped) continue;
1215
1216 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1217
1218 exec_all_ms[device_id] = exec_ms_avg;
1219 }
1220
1221 /**
1222 * timers
1223 */
1224
1225 float ms_running = 0;
1226
1227 hc_timer_get (data.timer_running, ms_running);
1228
1229 float ms_paused = data.ms_paused;
1230
1231 if (data.devices_status == STATUS_PAUSED)
1232 {
1233 float ms_paused_tmp = 0;
1234
1235 hc_timer_get (data.timer_paused, ms_paused_tmp);
1236
1237 ms_paused += ms_paused_tmp;
1238 }
1239
1240 #ifdef WIN
1241
1242 __time64_t sec_run = ms_running / 1000;
1243
1244 #else
1245
1246 time_t sec_run = ms_running / 1000;
1247
1248 #endif
1249
1250 if (sec_run)
1251 {
1252 char display_run[32] = { 0 };
1253
1254 struct tm tm_run;
1255
1256 struct tm *tmp = NULL;
1257
1258 #ifdef WIN
1259
1260 tmp = _gmtime64 (&sec_run);
1261
1262 #else
1263
1264 tmp = gmtime (&sec_run);
1265
1266 #endif
1267
1268 if (tmp != NULL)
1269 {
1270 memset (&tm_run, 0, sizeof (tm_run));
1271
1272 memcpy (&tm_run, tmp, sizeof (tm_run));
1273
1274 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1275
1276 char *start = ctime (&data.proc_start);
1277
1278 size_t start_len = strlen (start);
1279
1280 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1281 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1282
1283 log_info ("Time.Started...: %s (%s)", start, display_run);
1284 }
1285 }
1286 else
1287 {
1288 log_info ("Time.Started...: 0 secs");
1289 }
1290
1291 /**
1292 * counters
1293 */
1294
1295 uint salts_left = data.salts_cnt - data.salts_done;
1296
1297 if (salts_left == 0) salts_left = 1;
1298
1299 u64 progress_total = data.words_cnt * salts_left;
1300
1301 u64 all_done = 0;
1302 u64 all_rejected = 0;
1303 u64 all_restored = 0;
1304
1305 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1306 {
1307 if (salts_left > 1)
1308 {
1309 // otherwise the final cracked status shows 0/XXX progress
1310
1311 if (data.salts_shown[salt_pos] == 1) continue;
1312 }
1313
1314 all_done += data.words_progress_done[salt_pos];
1315 all_rejected += data.words_progress_rejected[salt_pos];
1316 all_restored += data.words_progress_restored[salt_pos];
1317 }
1318
1319 u64 progress_cur = all_restored + all_done + all_rejected;
1320 u64 progress_end = progress_total;
1321
1322 u64 progress_skip = 0;
1323
1324 if (data.skip)
1325 {
1326 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1327
1328 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1329 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1330 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1331 }
1332
1333 if (data.limit)
1334 {
1335 progress_end = MIN (data.limit, data.words_base) * salts_left;
1336
1337 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1338 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1339 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1340 }
1341
1342 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1343 u64 progress_end_relative_skip = progress_end - progress_skip;
1344
1345 float speed_ms_real = ms_running - ms_paused;
1346 u64 speed_plains_real = all_done;
1347
1348 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1349 {
1350 if (data.devices_status != STATUS_CRACKED)
1351 {
1352 u64 words_per_ms = 0;
1353
1354 if (speed_plains_real && speed_ms_real)
1355 {
1356 words_per_ms = speed_plains_real / speed_ms_real;
1357 }
1358
1359 #ifdef WIN
1360 __time64_t sec_etc = 0;
1361 #else
1362 time_t sec_etc = 0;
1363 #endif
1364
1365 if (words_per_ms)
1366 {
1367 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1368
1369 u64 ms_left = progress_left_relative_skip / words_per_ms;
1370
1371 sec_etc = ms_left / 1000;
1372 }
1373
1374 if (sec_etc == 0)
1375 {
1376 log_info ("Time.Estimated.: 0 secs");
1377 }
1378 else if ((u64) sec_etc > ETC_MAX)
1379 {
1380 log_info ("Time.Estimated.: > 10 Years");
1381 }
1382 else
1383 {
1384 char display_etc[32] = { 0 };
1385
1386 struct tm tm_etc;
1387
1388 struct tm *tmp = NULL;
1389
1390 #ifdef WIN
1391
1392 tmp = _gmtime64 (&sec_etc);
1393
1394 #else
1395
1396 tmp = gmtime (&sec_etc);
1397
1398 #endif
1399
1400 if (tmp != NULL)
1401 {
1402 memset (&tm_etc, 0, sizeof (tm_etc));
1403
1404 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1405
1406 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1407
1408 time_t now;
1409
1410 time (&now);
1411
1412 now += sec_etc;
1413
1414 char *etc = ctime (&now);
1415
1416 size_t etc_len = strlen (etc);
1417
1418 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1419 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1420
1421 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1422 }
1423 }
1424 }
1425 }
1426
1427 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1428 {
1429 hc_device_param_t *device_param = &data.devices_param[device_id];
1430
1431 if (device_param->skipped) continue;
1432
1433 char display_dev_cur[16] = { 0 };
1434
1435 strncpy (display_dev_cur, "0.00", 4);
1436
1437 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1438
1439 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1440 }
1441
1442 char display_all_cur[16] = { 0 };
1443
1444 strncpy (display_all_cur, "0.00", 4);
1445
1446 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1447
1448 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1449
1450 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1451 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1452
1453 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);
1454
1455 // crack-per-time
1456
1457 if (data.digests_cnt > 100)
1458 {
1459 time_t now = time (NULL);
1460
1461 int cpt_cur_min = 0;
1462 int cpt_cur_hour = 0;
1463 int cpt_cur_day = 0;
1464
1465 for (int i = 0; i < CPT_BUF; i++)
1466 {
1467 const uint cracked = data.cpt_buf[i].cracked;
1468 const time_t timestamp = data.cpt_buf[i].timestamp;
1469
1470 if ((timestamp + 60) > now)
1471 {
1472 cpt_cur_min += cracked;
1473 }
1474
1475 if ((timestamp + 3600) > now)
1476 {
1477 cpt_cur_hour += cracked;
1478 }
1479
1480 if ((timestamp + 86400) > now)
1481 {
1482 cpt_cur_day += cracked;
1483 }
1484 }
1485
1486 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1487 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1488 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1489
1490 if ((data.cpt_start + 86400) < now)
1491 {
1492 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1493 cpt_cur_min,
1494 cpt_cur_hour,
1495 cpt_cur_day,
1496 cpt_avg_min,
1497 cpt_avg_hour,
1498 cpt_avg_day);
1499 }
1500 else if ((data.cpt_start + 3600) < now)
1501 {
1502 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1503 cpt_cur_min,
1504 cpt_cur_hour,
1505 cpt_avg_min,
1506 cpt_avg_hour,
1507 cpt_avg_day);
1508 }
1509 else if ((data.cpt_start + 60) < now)
1510 {
1511 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1512 cpt_cur_min,
1513 cpt_avg_min,
1514 cpt_avg_hour,
1515 cpt_avg_day);
1516 }
1517 else
1518 {
1519 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1520 cpt_avg_min,
1521 cpt_avg_hour,
1522 cpt_avg_day);
1523 }
1524 }
1525
1526 // Restore point
1527
1528 u64 restore_point = get_lowest_words_done ();
1529
1530 u64 restore_total = data.words_base;
1531
1532 float percent_restore = 0;
1533
1534 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1535
1536 if (progress_end_relative_skip)
1537 {
1538 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1539 {
1540 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1541 float percent_rejected = 0.0;
1542
1543 if (progress_cur)
1544 {
1545 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1546 }
1547
1548 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);
1549 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1550
1551 if (data.restore_disable == 0)
1552 {
1553 if (percent_finished != 1)
1554 {
1555 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1556 }
1557 }
1558 }
1559 }
1560 else
1561 {
1562 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1563 {
1564 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1565 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1566
1567 if (data.restore_disable == 0)
1568 {
1569 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1570 }
1571 }
1572 else
1573 {
1574 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1575 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1576
1577 // --restore not allowed if stdin is used -- really? why?
1578
1579 //if (data.restore_disable == 0)
1580 //{
1581 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1582 //}
1583 }
1584 }
1585
1586 #ifdef HAVE_HWMON
1587 if (data.gpu_temp_disable == 0)
1588 {
1589 hc_thread_mutex_lock (mux_adl);
1590
1591 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1592 {
1593 hc_device_param_t *device_param = &data.devices_param[device_id];
1594
1595 if (device_param->skipped) continue;
1596
1597 #define HM_STR_BUF_SIZE 255
1598
1599 if (data.hm_device[device_id].fan_supported == 1)
1600 {
1601 char utilization[HM_STR_BUF_SIZE] = { 0 };
1602 char temperature[HM_STR_BUF_SIZE] = { 0 };
1603 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1604
1605 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1606 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1607
1608 if (device_param->vendor_id == VENDOR_ID_AMD)
1609 {
1610 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1611 }
1612 else if (device_param->vendor_id == VENDOR_ID_NV)
1613 {
1614 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1615 }
1616
1617 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1618 }
1619 else
1620 {
1621 char utilization[HM_STR_BUF_SIZE] = { 0 };
1622 char temperature[HM_STR_BUF_SIZE] = { 0 };
1623
1624 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1625 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1626
1627 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1628 }
1629 }
1630
1631 hc_thread_mutex_unlock (mux_adl);
1632 }
1633 #endif // HAVE_HWMON
1634 }
1635
1636 static void status_benchmark ()
1637 {
1638 if (data.devices_status == STATUS_INIT) return;
1639 if (data.devices_status == STATUS_STARTING) return;
1640
1641 if (data.words_cnt == 0) return;
1642
1643 u64 speed_cnt[DEVICES_MAX] = { 0 };
1644 float speed_ms[DEVICES_MAX] = { 0 };
1645
1646 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1647 {
1648 hc_device_param_t *device_param = &data.devices_param[device_id];
1649
1650 if (device_param->skipped) continue;
1651
1652 speed_cnt[device_id] = 0;
1653 speed_ms[device_id] = 0;
1654
1655 for (int i = 0; i < SPEED_CACHE; i++)
1656 {
1657 speed_cnt[device_id] += device_param->speed_cnt[i];
1658 speed_ms[device_id] += device_param->speed_ms[i];
1659 }
1660
1661 speed_cnt[device_id] /= SPEED_CACHE;
1662 speed_ms[device_id] /= SPEED_CACHE;
1663 }
1664
1665 float hashes_all_ms = 0;
1666
1667 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1668
1669 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1670 {
1671 hc_device_param_t *device_param = &data.devices_param[device_id];
1672
1673 if (device_param->skipped) continue;
1674
1675 hashes_dev_ms[device_id] = 0;
1676
1677 if (speed_ms[device_id])
1678 {
1679 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1680
1681 hashes_all_ms += hashes_dev_ms[device_id];
1682 }
1683 }
1684
1685 /**
1686 * exec time
1687 */
1688
1689 double exec_all_ms[DEVICES_MAX] = { 0 };
1690
1691 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1692 {
1693 hc_device_param_t *device_param = &data.devices_param[device_id];
1694
1695 if (device_param->skipped) continue;
1696
1697 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1698
1699 exec_all_ms[device_id] = exec_ms_avg;
1700 }
1701
1702 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1703 {
1704 hc_device_param_t *device_param = &data.devices_param[device_id];
1705
1706 if (device_param->skipped) continue;
1707
1708 char display_dev_cur[16] = { 0 };
1709
1710 strncpy (display_dev_cur, "0.00", 4);
1711
1712 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1713
1714 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1715 }
1716
1717 char display_all_cur[16] = { 0 };
1718
1719 strncpy (display_all_cur, "0.00", 4);
1720
1721 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1722
1723 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1724 }
1725
1726 /**
1727 * oclHashcat -only- functions
1728 */
1729
1730 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1731 {
1732 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1733 {
1734 if (attack_kern == ATTACK_KERN_STRAIGHT)
1735 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1736 else if (attack_kern == ATTACK_KERN_COMBI)
1737 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1738 else if (attack_kern == ATTACK_KERN_BF)
1739 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1740 }
1741 else
1742 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1743 }
1744
1745 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)
1746 {
1747 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1748 {
1749 if (attack_kern == ATTACK_KERN_STRAIGHT)
1750 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1751 else if (attack_kern == ATTACK_KERN_COMBI)
1752 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1753 else if (attack_kern == ATTACK_KERN_BF)
1754 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1755 }
1756 else
1757 {
1758 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1759 }
1760 }
1761
1762 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1763 {
1764 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1765 {
1766 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1767 }
1768 else
1769 {
1770 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1771 }
1772 }
1773
1774 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)
1775 {
1776 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1777 {
1778 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1779 }
1780 else
1781 {
1782 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1783 }
1784 }
1785
1786 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1787 {
1788 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1789 }
1790
1791 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1792 {
1793 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1794 }
1795
1796 static uint convert_from_hex (char *line_buf, const uint line_len)
1797 {
1798 if (line_len & 1) return (line_len); // not in hex
1799
1800 if (data.hex_wordlist == 1)
1801 {
1802 uint i;
1803 uint j;
1804
1805 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1806 {
1807 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1808 }
1809
1810 memset (line_buf + i, 0, line_len - i);
1811
1812 return (i);
1813 }
1814 else if (line_len >= 6) // $HEX[] = 6
1815 {
1816 if (line_buf[0] != '$') return (line_len);
1817 if (line_buf[1] != 'H') return (line_len);
1818 if (line_buf[2] != 'E') return (line_len);
1819 if (line_buf[3] != 'X') return (line_len);
1820 if (line_buf[4] != '[') return (line_len);
1821 if (line_buf[line_len - 1] != ']') return (line_len);
1822
1823 uint i;
1824 uint j;
1825
1826 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1827 {
1828 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1829 }
1830
1831 memset (line_buf + i, 0, line_len - i);
1832
1833 return (i);
1834 }
1835
1836 return (line_len);
1837 }
1838
1839 static void clear_prompt ()
1840 {
1841 fputc ('\r', stdout);
1842
1843 for (size_t i = 0; i < strlen (PROMPT); i++)
1844 {
1845 fputc (' ', stdout);
1846 }
1847
1848 fputc ('\r', stdout);
1849
1850 fflush (stdout);
1851 }
1852
1853 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1854 {
1855 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);
1856 }
1857
1858 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1859 {
1860 char *outfile = data.outfile;
1861 uint quiet = data.quiet;
1862 FILE *pot_fp = data.pot_fp;
1863 uint loopback = data.loopback;
1864 uint debug_mode = data.debug_mode;
1865 char *debug_file = data.debug_file;
1866
1867 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1868 int debug_rule_len = 0; // -1 error
1869 uint debug_plain_len = 0;
1870
1871 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1872
1873 // hash
1874
1875 char out_buf[4096] = { 0 };
1876
1877 ascii_digest (out_buf, salt_pos, digest_pos);
1878
1879 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1880
1881 // plain
1882
1883 plain_t plain;
1884
1885 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);
1886
1887 uint gidvid = plain.gidvid;
1888 uint il_pos = plain.il_pos;
1889
1890 u64 crackpos = device_param->words_off;
1891
1892 uint plain_buf[16] = { 0 };
1893
1894 u8 *plain_ptr = (u8 *) plain_buf;
1895 unsigned int plain_len = 0;
1896
1897 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1898 {
1899 u64 gidd = gidvid;
1900 u64 gidm = 0;
1901
1902 pw_t pw;
1903
1904 gidd_to_pw_t (device_param, gidd, &pw);
1905
1906 for (int i = 0, j = gidm; i < 16; i++, j++)
1907 {
1908 plain_buf[i] = pw.h.hi1[0][j];
1909 }
1910
1911 plain_len = pw.pw_len;
1912
1913 const uint off = device_param->innerloop_pos + il_pos;
1914
1915 if (debug_mode > 0)
1916 {
1917 debug_rule_len = 0;
1918
1919 // save rule
1920 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1921 {
1922 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1923
1924 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1925 }
1926
1927 // save plain
1928 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1929 {
1930 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1931
1932 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1933
1934 debug_plain_len = plain_len;
1935 }
1936 }
1937
1938 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1939
1940 crackpos += gidvid;
1941 crackpos *= data.kernel_rules_cnt;
1942 crackpos += device_param->innerloop_pos + il_pos;
1943
1944 if (plain_len > data.pw_max) plain_len = data.pw_max;
1945 }
1946 else if (data.attack_mode == ATTACK_MODE_COMBI)
1947 {
1948 u64 gidd = gidvid;
1949 u64 gidm = 0;
1950
1951 pw_t pw;
1952
1953 gidd_to_pw_t (device_param, gidd, &pw);
1954
1955 for (int i = 0, j = gidm; i < 16; i++, j++)
1956 {
1957 plain_buf[i] = pw.h.hi1[0][j];
1958 }
1959
1960 plain_len = pw.pw_len;
1961
1962 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1963 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1964
1965 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1966 {
1967 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1968 }
1969 else
1970 {
1971 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1972
1973 memcpy (plain_ptr, comb_buf, comb_len);
1974 }
1975
1976 plain_len += comb_len;
1977
1978 crackpos += gidvid;
1979 crackpos *= data.combs_cnt;
1980 crackpos += device_param->innerloop_pos + il_pos;
1981
1982 if (data.pw_max != PW_DICTMAX1)
1983 {
1984 if (plain_len > data.pw_max) plain_len = data.pw_max;
1985 }
1986 }
1987 else if (data.attack_mode == ATTACK_MODE_BF)
1988 {
1989 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1990 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1991
1992 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1993 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1994
1995 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1996 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1997
1998 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1999 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2000
2001 plain_len = data.css_cnt;
2002
2003 crackpos += gidvid;
2004 crackpos *= data.bfs_cnt;
2005 crackpos += device_param->innerloop_pos + il_pos;
2006 }
2007 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2008 {
2009 u64 gidd = gidvid;
2010 u64 gidm = 0;
2011
2012 pw_t pw;
2013
2014 gidd_to_pw_t (device_param, gidd, &pw);
2015
2016 for (int i = 0, j = gidm; i < 16; i++, j++)
2017 {
2018 plain_buf[i] = pw.h.hi1[0][j];
2019 }
2020
2021 plain_len = pw.pw_len;
2022
2023 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2024
2025 uint start = 0;
2026 uint stop = device_param->kernel_params_mp_buf32[4];
2027
2028 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2029
2030 plain_len += start + stop;
2031
2032 crackpos += gidvid;
2033 crackpos *= data.combs_cnt;
2034 crackpos += device_param->innerloop_pos + il_pos;
2035
2036 if (data.pw_max != PW_DICTMAX1)
2037 {
2038 if (plain_len > data.pw_max) plain_len = data.pw_max;
2039 }
2040 }
2041 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2042 {
2043 u64 gidd = gidvid;
2044 u64 gidm = 0;
2045
2046 pw_t pw;
2047
2048 gidd_to_pw_t (device_param, gidd, &pw);
2049
2050 for (int i = 0, j = gidm; i < 16; i++, j++)
2051 {
2052 plain_buf[i] = pw.h.hi1[0][j];
2053 }
2054
2055 plain_len = pw.pw_len;
2056
2057 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2058
2059 uint start = 0;
2060 uint stop = device_param->kernel_params_mp_buf32[4];
2061
2062 memmove (plain_ptr + stop, plain_ptr, plain_len);
2063
2064 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2065
2066 plain_len += start + stop;
2067
2068 crackpos += gidvid;
2069 crackpos *= data.combs_cnt;
2070 crackpos += device_param->innerloop_pos + il_pos;
2071
2072 if (data.pw_max != PW_DICTMAX1)
2073 {
2074 if (plain_len > data.pw_max) plain_len = data.pw_max;
2075 }
2076 }
2077
2078 if (data.attack_mode == ATTACK_MODE_BF)
2079 {
2080 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2081 {
2082 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2083 {
2084 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2085 {
2086 plain_len = plain_len - data.salts_buf[0].salt_len;
2087 }
2088 }
2089
2090 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2091 {
2092 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2093 {
2094 plain_ptr[j] = plain_ptr[i];
2095 }
2096
2097 plain_len = plain_len / 2;
2098 }
2099 }
2100 }
2101
2102 // if enabled, update also the potfile
2103
2104 if (pot_fp)
2105 {
2106 lock_file (pot_fp);
2107
2108 fprintf (pot_fp, "%s:", out_buf);
2109
2110 format_plain (pot_fp, plain_ptr, plain_len, 1);
2111
2112 fputc ('\n', pot_fp);
2113
2114 fflush (pot_fp);
2115
2116 unlock_file (pot_fp);
2117 }
2118
2119 // outfile
2120
2121 FILE *out_fp = NULL;
2122
2123 if (outfile != NULL)
2124 {
2125 if ((out_fp = fopen (outfile, "ab")) == NULL)
2126 {
2127 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2128
2129 out_fp = stdout;
2130 }
2131 lock_file (out_fp);
2132 }
2133 else
2134 {
2135 out_fp = stdout;
2136
2137 if (quiet == 0) clear_prompt ();
2138 }
2139
2140 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2141
2142 if (outfile != NULL)
2143 {
2144 if (out_fp != stdout)
2145 {
2146 fclose (out_fp);
2147 }
2148 }
2149 else
2150 {
2151 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2152 {
2153 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2154 {
2155 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2156 if (quiet == 0) fflush (stdout);
2157 }
2158 }
2159 }
2160
2161 // loopback
2162
2163 if (loopback)
2164 {
2165 char *loopback_file = data.loopback_file;
2166
2167 FILE *fb_fp = NULL;
2168
2169 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2170 {
2171 lock_file (fb_fp);
2172
2173 format_plain (fb_fp, plain_ptr, plain_len, 1);
2174
2175 fputc ('\n', fb_fp);
2176
2177 fclose (fb_fp);
2178 }
2179 }
2180
2181 // (rule) debug mode
2182
2183 // the next check implies that:
2184 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2185 // - debug_mode > 0
2186
2187 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2188 {
2189 if (debug_rule_len < 0) debug_rule_len = 0;
2190
2191 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2192
2193 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2194
2195 if ((quiet == 0) && (debug_file == NULL))
2196 {
2197 fprintf (stdout, "%s", PROMPT);
2198 fflush (stdout);
2199 }
2200 }
2201 }
2202
2203 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2204 {
2205 salt_t *salt_buf = &data.salts_buf[salt_pos];
2206
2207 int found = 0;
2208
2209 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);
2210
2211 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2212
2213 if (found == 1)
2214 {
2215 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2216
2217 log_info_nn ("");
2218
2219 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);
2220
2221 uint cpt_cracked = 0;
2222
2223 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2224 {
2225 uint idx = salt_buf->digests_offset + digest_pos;
2226
2227 if (data.digests_shown_tmp[idx] == 0) continue;
2228
2229 if (data.digests_shown[idx] == 1) continue;
2230
2231 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2232 {
2233 data.digests_shown[idx] = 1;
2234
2235 data.digests_done++;
2236
2237 cpt_cracked++;
2238
2239 salt_buf->digests_done++;
2240
2241 if (salt_buf->digests_done == salt_buf->digests_cnt)
2242 {
2243 data.salts_shown[salt_pos] = 1;
2244
2245 data.salts_done++;
2246 }
2247 }
2248
2249 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2250
2251 check_hash (device_param, salt_pos, digest_pos);
2252 }
2253
2254 if (cpt_cracked > 0)
2255 {
2256 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2257 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2258
2259 data.cpt_pos++;
2260
2261 data.cpt_total += cpt_cracked;
2262
2263 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2264 }
2265
2266 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2267 {
2268 // we need to reset cracked state on the device
2269 // otherwise host thinks again and again the hash was cracked
2270 // and returns invalid password each time
2271
2272 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2273
2274 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);
2275 }
2276
2277 memset (device_param->result, 0, device_param->size_results);
2278
2279 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);
2280 }
2281 }
2282
2283 static void save_hash ()
2284 {
2285 char *hashfile = data.hashfile;
2286
2287 char new_hashfile[256] = { 0 };
2288 char old_hashfile[256] = { 0 };
2289
2290 snprintf (new_hashfile, 255, "%s.new", hashfile);
2291 snprintf (old_hashfile, 255, "%s.old", hashfile);
2292
2293 unlink (new_hashfile);
2294
2295 char separator = data.separator;
2296
2297 FILE *fp = fopen (new_hashfile, "wb");
2298
2299 if (fp == NULL)
2300 {
2301 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2302
2303 exit (-1);
2304 }
2305
2306 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2307 {
2308 if (data.salts_shown[salt_pos] == 1) continue;
2309
2310 salt_t *salt_buf = &data.salts_buf[salt_pos];
2311
2312 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2313 {
2314 uint idx = salt_buf->digests_offset + digest_pos;
2315
2316 if (data.digests_shown[idx] == 1) continue;
2317
2318 if (data.hash_mode != 2500)
2319 {
2320 char out_buf[4096] = { 0 };
2321
2322 if (data.username == 1)
2323 {
2324 user_t *user = data.hash_info[idx]->user;
2325
2326 uint i;
2327
2328 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2329
2330 fputc (separator, fp);
2331 }
2332
2333 ascii_digest (out_buf, salt_pos, digest_pos);
2334
2335 fputs (out_buf, fp);
2336
2337 log_out (fp, "");
2338 }
2339 else
2340 {
2341 hccap_t hccap;
2342
2343 to_hccap_t (&hccap, salt_pos, digest_pos);
2344
2345 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2346 }
2347 }
2348 }
2349
2350 fflush (fp);
2351
2352 fclose (fp);
2353
2354 unlink (old_hashfile);
2355
2356 if (rename (hashfile, old_hashfile) != 0)
2357 {
2358 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2359
2360 exit (-1);
2361 }
2362
2363 unlink (hashfile);
2364
2365 if (rename (new_hashfile, hashfile) != 0)
2366 {
2367 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2368
2369 exit (-1);
2370 }
2371
2372 unlink (old_hashfile);
2373 }
2374
2375 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2376 {
2377 // function called only in case kernel_power_all > words_left
2378
2379 float kernel_power_div = (float) (total_left) / kernel_power_all;
2380
2381 kernel_power_div += kernel_power_div / 100;
2382
2383 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2384
2385 while (kernel_power_new < total_left)
2386 {
2387 kernel_power_div += kernel_power_div / 100;
2388
2389 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2390 }
2391
2392 if (data.quiet == 0)
2393 {
2394 clear_prompt ();
2395
2396 log_info ("");
2397
2398 log_info ("INFO: approaching final keyspace, workload adjusted");
2399
2400 log_info ("");
2401
2402 fprintf (stdout, "%s", PROMPT);
2403
2404 fflush (stdout);
2405 }
2406
2407 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2408
2409 return kernel_power_div;
2410 }
2411
2412 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2413 {
2414 uint num_elements = num;
2415
2416 device_param->kernel_params_buf32[30] = data.combs_mode;
2417 device_param->kernel_params_buf32[31] = num;
2418
2419 uint kernel_threads = device_param->kernel_threads;
2420
2421 while (num_elements % kernel_threads) num_elements++;
2422
2423 cl_kernel kernel = NULL;
2424
2425 switch (kern_run)
2426 {
2427 case KERN_RUN_1: kernel = device_param->kernel1; break;
2428 case KERN_RUN_12: kernel = device_param->kernel12; break;
2429 case KERN_RUN_2: kernel = device_param->kernel2; break;
2430 case KERN_RUN_23: kernel = device_param->kernel23; break;
2431 case KERN_RUN_3: kernel = device_param->kernel3; break;
2432 }
2433
2434 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2435 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2436 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2437 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2438 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2439 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2440 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2441 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2442 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2443 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2444 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2445
2446 hc_timer_t timer;
2447
2448 hc_timer_set (&timer);
2449
2450 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2451 {
2452 const size_t global_work_size[3] = { num_elements, 32, 1 };
2453 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2454
2455 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2456 }
2457 else
2458 {
2459 size_t workgroup_size = 0;
2460
2461 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2462
2463 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2464
2465 const size_t global_work_size[3] = { num_elements, 1, 1 };
2466 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2467
2468 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2469 }
2470
2471 hc_clFlush (data.ocl, device_param->command_queue);
2472
2473 hc_clFinish (data.ocl, device_param->command_queue);
2474
2475 if (event_update)
2476 {
2477 float exec_time;
2478
2479 hc_timer_get (timer, exec_time);
2480
2481 uint exec_pos = device_param->exec_pos;
2482
2483 device_param->exec_ms[exec_pos] = exec_time;
2484
2485 exec_pos++;
2486
2487 if (exec_pos == EXEC_CACHE)
2488 {
2489 exec_pos = 0;
2490 }
2491
2492 device_param->exec_pos = exec_pos;
2493 }
2494 }
2495
2496 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2497 {
2498 uint num_elements = num;
2499
2500 switch (kern_run)
2501 {
2502 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2503 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2504 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2505 }
2506
2507 // causes problems with special threads like in bcrypt
2508 // const uint kernel_threads = device_param->kernel_threads;
2509
2510 uint kernel_threads = KERNEL_THREADS;
2511
2512 while (num_elements % kernel_threads) num_elements++;
2513
2514 cl_kernel kernel = NULL;
2515
2516 switch (kern_run)
2517 {
2518 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2519 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2520 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2521 }
2522
2523 switch (kern_run)
2524 {
2525 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2526 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2527 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2528 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2529 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2530 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2531 break;
2532 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2533 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2534 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2535 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2536 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2537 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2538 break;
2539 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2540 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2541 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2542 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2543 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2544 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2545 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2546 break;
2547 }
2548
2549 size_t workgroup_size = 0;
2550 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2551 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2552
2553 const size_t global_work_size[3] = { num_elements, 1, 1 };
2554 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2555
2556 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2557
2558 hc_clFlush (data.ocl, device_param->command_queue);
2559
2560 hc_clFinish (data.ocl, device_param->command_queue);
2561 }
2562
2563 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2564 {
2565 uint num_elements = num;
2566
2567 uint kernel_threads = device_param->kernel_threads;
2568
2569 while (num_elements % kernel_threads) num_elements++;
2570
2571 cl_kernel kernel = device_param->kernel_tb;
2572
2573 size_t workgroup_size = 0;
2574 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2575 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2576
2577 const size_t global_work_size[3] = { num_elements, 1, 1 };
2578 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2579
2580 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2581
2582 hc_clFlush (data.ocl, device_param->command_queue);
2583
2584 hc_clFinish (data.ocl, device_param->command_queue);
2585 }
2586
2587 static void run_kernel_tm (hc_device_param_t *device_param)
2588 {
2589 const uint num_elements = 1024; // fixed
2590
2591 uint kernel_threads = 32;
2592
2593 cl_kernel kernel = device_param->kernel_tm;
2594
2595 size_t workgroup_size = 0;
2596 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2597 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2598
2599 const size_t global_work_size[3] = { num_elements, 1, 1 };
2600 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2601
2602 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2603
2604 hc_clFlush (data.ocl, device_param->command_queue);
2605
2606 hc_clFinish (data.ocl, device_param->command_queue);
2607 }
2608
2609 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2610 {
2611 uint num_elements = num;
2612
2613 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2614 device_param->kernel_params_amp_buf32[6] = num_elements;
2615
2616 // causes problems with special threads like in bcrypt
2617 // const uint kernel_threads = device_param->kernel_threads;
2618
2619 uint kernel_threads = KERNEL_THREADS;
2620
2621 while (num_elements % kernel_threads) num_elements++;
2622
2623 cl_kernel kernel = device_param->kernel_amp;
2624
2625 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2626 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2627
2628 size_t workgroup_size = 0;
2629 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2630 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2631
2632 const size_t global_work_size[3] = { num_elements, 1, 1 };
2633 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2634
2635 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2636
2637 hc_clFlush (data.ocl, device_param->command_queue);
2638
2639 hc_clFinish (data.ocl, device_param->command_queue);
2640 }
2641
2642 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2643 {
2644 int rc = -1;
2645
2646 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2647 {
2648 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2649
2650 const cl_uchar zero = 0;
2651
2652 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2653 }
2654
2655 if (rc != 0)
2656 {
2657 // NOTE: clEnqueueFillBuffer () always fails with -59
2658 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2659 // How's that possible, OpenCL 1.2 support is advertised??
2660 // We need to workaround...
2661
2662 #define FILLSZ 0x100000
2663
2664 char *tmp = (char *) mymalloc (FILLSZ);
2665
2666 for (uint i = 0; i < size; i += FILLSZ)
2667 {
2668 const int left = size - i;
2669
2670 const int fillsz = MIN (FILLSZ, left);
2671
2672 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2673 }
2674
2675 myfree (tmp);
2676 }
2677 }
2678
2679 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)
2680 {
2681 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2682 {
2683 if (attack_mode == ATTACK_MODE_BF)
2684 {
2685 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2686 {
2687 const uint size_tm = 32 * sizeof (bs_word_t);
2688
2689 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2690
2691 run_kernel_tm (device_param);
2692
2693 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);
2694 }
2695 }
2696
2697 if (highest_pw_len < 16)
2698 {
2699 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2700 }
2701 else if (highest_pw_len < 32)
2702 {
2703 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2704 }
2705 else
2706 {
2707 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2708 }
2709 }
2710 else
2711 {
2712 run_kernel_amp (device_param, pws_cnt);
2713
2714 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2715
2716 if (opts_type & OPTS_TYPE_HOOK12)
2717 {
2718 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2719 }
2720
2721 uint iter = salt_buf->salt_iter;
2722
2723 uint loop_step = device_param->kernel_loops;
2724
2725 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2726 {
2727 uint loop_left = iter - loop_pos;
2728
2729 loop_left = MIN (loop_left, loop_step);
2730
2731 device_param->kernel_params_buf32[25] = loop_pos;
2732 device_param->kernel_params_buf32[26] = loop_left;
2733
2734 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2735
2736 if (data.devices_status == STATUS_CRACKED) break;
2737 if (data.devices_status == STATUS_ABORTED) break;
2738 if (data.devices_status == STATUS_QUIT) break;
2739 }
2740
2741 if (opts_type & OPTS_TYPE_HOOK23)
2742 {
2743 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2744
2745 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);
2746
2747 // do something with data
2748
2749 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);
2750 }
2751
2752 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2753 }
2754 }
2755
2756 static int run_rule_engine (const int rule_len, const char *rule_buf)
2757 {
2758 if (rule_len == 0)
2759 {
2760 return 0;
2761 }
2762 else if (rule_len == 1)
2763 {
2764 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2765 }
2766
2767 return 1;
2768 }
2769
2770 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2771 {
2772 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2773 {
2774 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);
2775 }
2776 else if (data.attack_kern == ATTACK_KERN_COMBI)
2777 {
2778 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);
2779 }
2780 else if (data.attack_kern == ATTACK_KERN_BF)
2781 {
2782 const u64 off = device_param->words_off;
2783
2784 device_param->kernel_params_mp_l_buf64[3] = off;
2785
2786 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2787 }
2788 }
2789
2790 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2791 {
2792 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2793
2794 device_param->kernel_params_buf32[26] = kernel_loops;
2795 device_param->kernel_params_buf32[27] = kernel_loops;
2796
2797 // caching run
2798
2799 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2800 {
2801 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2802 }
2803 else
2804 {
2805 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2806 }
2807
2808 // now user repeats
2809
2810 for (int i = 0; i < repeat; i++)
2811 {
2812 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2813 {
2814 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2815 }
2816 else
2817 {
2818 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2819 }
2820 }
2821
2822 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2823
2824 return exec_ms_prev;
2825 }
2826
2827 static void autotune (hc_device_param_t *device_param)
2828 {
2829 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2830
2831 u32 kernel_loops_min = device_param->kernel_loops_min;
2832 u32 kernel_loops_max = device_param->kernel_loops_max;
2833
2834 u32 kernel_accel_min = device_param->kernel_accel_min;
2835 u32 kernel_accel_max = device_param->kernel_accel_max;
2836
2837 u32 kernel_loops = kernel_loops_min;
2838 u32 kernel_accel = kernel_accel_min;
2839
2840 // init some fake words
2841
2842 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel_max;
2843
2844 for (u32 i = 0; i < kernel_power_max; i++)
2845 {
2846 device_param->pws_buf[i].pw_len = 8;
2847 }
2848
2849 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);
2850 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);
2851
2852 // steps for loops
2853
2854 #define STEPS_LOOPS_CNT 15
2855
2856 u32 steps_loops[STEPS_LOOPS_CNT];
2857
2858 steps_loops[ 0] = 1;
2859 steps_loops[ 1] = 2;
2860 steps_loops[ 2] = 4;
2861 steps_loops[ 3] = 8;
2862 steps_loops[ 4] = 16;
2863 steps_loops[ 5] = 32;
2864 steps_loops[ 6] = 64;
2865 steps_loops[ 7] = 100;
2866 steps_loops[ 8] = 128;
2867 steps_loops[ 9] = 200;
2868 steps_loops[10] = 256;
2869 steps_loops[11] = 500;
2870 steps_loops[12] = 512;
2871 steps_loops[13] = 1000;
2872 steps_loops[14] = 1024;
2873
2874 // steps for accel
2875
2876 #define STEPS_ACCEL_CNT 13
2877
2878 u32 steps_accel[STEPS_ACCEL_CNT];
2879
2880 steps_accel[ 0] = 1;
2881 steps_accel[ 1] = 2;
2882 steps_accel[ 2] = 4;
2883 steps_accel[ 3] = 8;
2884 steps_accel[ 4] = 16;
2885 steps_accel[ 5] = 32;
2886 steps_accel[ 6] = 64;
2887 steps_accel[ 7] = 128;
2888 steps_accel[ 8] = 256;
2889 steps_accel[ 9] = 384;
2890 steps_accel[10] = 512;
2891 steps_accel[11] = 768;
2892 steps_accel[12] = 1024;
2893
2894 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2895
2896 u32 kernel_loops_tmp;
2897
2898 for (kernel_loops_tmp = MIN (kernel_loops_max, 200); kernel_loops_tmp >= kernel_loops_min; kernel_loops_tmp >>= 1)
2899 {
2900 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2901
2902 if (exec_ms < target_ms) break;
2903
2904 if (kernel_loops_tmp == kernel_loops_min) break;
2905 }
2906
2907 // kernel-accel
2908
2909 double e_best = 0;
2910
2911 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2912 {
2913 const u32 kernel_accel_try = steps_accel[i];
2914
2915 if (kernel_accel_try < kernel_accel_min) continue;
2916 if (kernel_accel_try > kernel_accel_max) break;
2917
2918 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2919
2920 if (exec_ms > target_ms) break;
2921
2922 const double e = kernel_accel_try / exec_ms;
2923
2924 if (e > e_best)
2925 {
2926 kernel_accel = kernel_accel_try;
2927
2928 e_best = e;
2929 }
2930 }
2931
2932 // kernel-loops final
2933
2934 e_best = 0;
2935
2936 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2937 {
2938 const u32 kernel_loops_try = steps_loops[i];
2939
2940 if (kernel_loops_try < kernel_loops_min) continue;
2941 if (kernel_loops_try > kernel_loops_max) break;
2942
2943 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2944
2945 if (exec_ms > target_ms) break;
2946
2947 const double e = kernel_loops_try / exec_ms;
2948
2949 if (e > e_best)
2950 {
2951 kernel_loops = kernel_loops_try;
2952
2953 e_best = e;
2954 }
2955 }
2956
2957 // final balance
2958
2959 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops, 1);
2960
2961 e_best = exec_ms;
2962
2963 u32 kernel_accel_try = kernel_accel;
2964 u32 kernel_loops_try = kernel_loops;
2965
2966 for (int i = 0; i < 2; i++)
2967 {
2968 kernel_accel_try >>= 1;
2969 kernel_loops_try <<= 1;
2970
2971 if (kernel_accel_try < kernel_accel_min) break;
2972 if (kernel_loops_try > kernel_loops_max) break;
2973
2974 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2975
2976 if (exec_ms > e_best) break;
2977
2978 kernel_accel = kernel_accel_try;
2979 kernel_loops = kernel_loops_try;
2980
2981 e_best = exec_ms;
2982 }
2983
2984 kernel_accel_try = kernel_accel;
2985 kernel_loops_try = kernel_loops;
2986
2987 for (int i = 0; i < 2; i++)
2988 {
2989 kernel_accel_try <<= 1;
2990 kernel_loops_try >>= 1;
2991
2992 if (kernel_accel_try > kernel_accel_max) break;
2993 if (kernel_loops_try < kernel_loops_min) break;
2994
2995 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2996
2997 if (exec_ms > e_best) break;
2998
2999 kernel_accel = kernel_accel_try;
3000 kernel_loops = kernel_loops_try;
3001
3002 e_best = exec_ms;
3003 }
3004
3005 // reset timer
3006
3007 device_param->exec_pos = 0;
3008
3009 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3010
3011 // reset fake words
3012
3013 for (u32 i = 0; i < kernel_power_max; i++)
3014 {
3015 device_param->pws_buf[i].pw_len = 0;
3016 }
3017
3018 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);
3019 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);
3020
3021 // store
3022
3023 device_param->kernel_loops = kernel_loops;
3024 device_param->kernel_accel = kernel_accel;
3025
3026 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3027
3028 device_param->kernel_power = kernel_power;
3029
3030 log_info ("Device #%u: autotuned kernel-accel to %u", device_param->device_id + 1, kernel_accel);
3031 log_info ("Device #%u: autotuned kernel-loops to %u", device_param->device_id + 1, kernel_loops);
3032 log_info ("");
3033 }
3034
3035 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
3036 {
3037 // init speed timer
3038
3039 uint speed_pos = device_param->speed_pos;
3040
3041 #ifdef _POSIX
3042 if (device_param->timer_speed.tv_sec == 0)
3043 {
3044 hc_timer_set (&device_param->timer_speed);
3045 }
3046 #endif
3047
3048 #ifdef _WIN
3049 if (device_param->timer_speed.QuadPart == 0)
3050 {
3051 hc_timer_set (&device_param->timer_speed);
3052 }
3053 #endif
3054
3055 // find higest password length, this is for optimization stuff
3056
3057 uint highest_pw_len = 0;
3058
3059 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3060 {
3061 }
3062 else if (data.attack_kern == ATTACK_KERN_COMBI)
3063 {
3064 }
3065 else if (data.attack_kern == ATTACK_KERN_BF)
3066 {
3067 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3068 + device_param->kernel_params_mp_l_buf32[5];
3069 }
3070
3071 // bitslice optimization stuff
3072
3073 if (data.attack_mode == ATTACK_MODE_BF)
3074 {
3075 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
3076 {
3077 run_kernel_tb (device_param, pws_cnt);
3078 }
3079 }
3080
3081 // iteration type
3082
3083 uint innerloop_step = 0;
3084 uint innerloop_cnt = 0;
3085
3086 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3087 else innerloop_step = 1;
3088
3089 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3090 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3091 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3092
3093 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3094
3095 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3096 {
3097 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3098
3099 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3100
3101 if (data.devices_status == STATUS_CRACKED) break;
3102 if (data.devices_status == STATUS_ABORTED) break;
3103 if (data.devices_status == STATUS_QUIT) break;
3104 if (data.devices_status == STATUS_BYPASS) break;
3105
3106 if (data.salts_shown[salt_pos] == 1) continue;
3107
3108 salt_t *salt_buf = &data.salts_buf[salt_pos];
3109
3110 device_param->kernel_params_buf32[24] = salt_pos;
3111 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3112 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3113
3114 FILE *combs_fp = device_param->combs_fp;
3115
3116 if (data.attack_mode == ATTACK_MODE_COMBI)
3117 {
3118 rewind (combs_fp);
3119 }
3120
3121 // innerloops
3122
3123 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3124 {
3125 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3126
3127 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3128
3129 if (data.devices_status == STATUS_CRACKED) break;
3130 if (data.devices_status == STATUS_ABORTED) break;
3131 if (data.devices_status == STATUS_QUIT) break;
3132 if (data.devices_status == STATUS_BYPASS) break;
3133
3134 uint innerloop_left = innerloop_cnt - innerloop_pos;
3135
3136 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3137
3138 device_param->innerloop_pos = innerloop_pos;
3139 device_param->innerloop_left = innerloop_left;
3140
3141 device_param->kernel_params_buf32[27] = innerloop_left;
3142
3143 // i think we can get rid of this
3144 if (innerloop_left == 0)
3145 {
3146 puts ("bug, how should this happen????\n");
3147
3148 continue;
3149 }
3150
3151 // initialize amplifiers
3152
3153 if (data.attack_mode == ATTACK_MODE_COMBI)
3154 {
3155 char line_buf[BUFSIZ] = { 0 };
3156
3157 uint i = 0;
3158
3159 while (i < innerloop_left)
3160 {
3161 if (feof (combs_fp)) break;
3162
3163 int line_len = fgetl (combs_fp, line_buf);
3164
3165 if (line_len >= PW_MAX1) continue;
3166
3167 line_len = convert_from_hex (line_buf, line_len);
3168
3169 char *line_buf_new = line_buf;
3170
3171 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3172 {
3173 char rule_buf_out[BLOCK_SIZE] = { 0 };
3174
3175 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3176
3177 if (rule_len_out < 0)
3178 {
3179 data.words_progress_rejected[salt_pos] += pw_cnt;
3180
3181 continue;
3182 }
3183
3184 line_len = rule_len_out;
3185
3186 line_buf_new = rule_buf_out;
3187 }
3188
3189 line_len = MIN (line_len, PW_DICTMAX);
3190
3191 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3192
3193 memcpy (ptr, line_buf_new, line_len);
3194
3195 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3196
3197 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3198 {
3199 uppercase (ptr, line_len);
3200 }
3201
3202 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3203 {
3204 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3205 {
3206 ptr[line_len] = 0x80;
3207 }
3208
3209 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3210 {
3211 ptr[line_len] = 0x01;
3212 }
3213 }
3214
3215 device_param->combs_buf[i].pw_len = line_len;
3216
3217 i++;
3218 }
3219
3220 for (uint j = i; j < innerloop_left; j++)
3221 {
3222 device_param->combs_buf[j].i[0] = 0;
3223 device_param->combs_buf[j].i[1] = 0;
3224 device_param->combs_buf[j].i[2] = 0;
3225 device_param->combs_buf[j].i[3] = 0;
3226 device_param->combs_buf[j].i[4] = 0;
3227 device_param->combs_buf[j].i[5] = 0;
3228 device_param->combs_buf[j].i[6] = 0;
3229 device_param->combs_buf[j].i[7] = 0;
3230
3231 device_param->combs_buf[j].pw_len = 0;
3232 }
3233
3234 innerloop_left = i;
3235 }
3236 else if (data.attack_mode == ATTACK_MODE_BF)
3237 {
3238 u64 off = innerloop_pos;
3239
3240 device_param->kernel_params_mp_r_buf64[3] = off;
3241
3242 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3243 }
3244 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3245 {
3246 u64 off = innerloop_pos;
3247
3248 device_param->kernel_params_mp_buf64[3] = off;
3249
3250 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3251 }
3252 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3253 {
3254 u64 off = innerloop_pos;
3255
3256 device_param->kernel_params_mp_buf64[3] = off;
3257
3258 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3259 }
3260
3261 // copy amplifiers
3262
3263 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3264 {
3265 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);
3266 }
3267 else if (data.attack_mode == ATTACK_MODE_COMBI)
3268 {
3269 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);
3270 }
3271 else if (data.attack_mode == ATTACK_MODE_BF)
3272 {
3273 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);
3274 }
3275 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3276 {
3277 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);
3278 }
3279 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3280 {
3281 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);
3282 }
3283
3284 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3285
3286 if (data.benchmark == 1)
3287 {
3288 for (u32 i = 0; i < data.benchmark_repeats; i++)
3289 {
3290 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3291 }
3292 }
3293
3294 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3295
3296 if (data.devices_status == STATUS_CRACKED) break;
3297 if (data.devices_status == STATUS_ABORTED) break;
3298 if (data.devices_status == STATUS_QUIT) break;
3299
3300 /**
3301 * result
3302 */
3303
3304 hc_thread_mutex_lock (mux_display);
3305
3306 check_cracked (device_param, salt_pos);
3307
3308 hc_thread_mutex_unlock (mux_display);
3309
3310 /**
3311 * progress
3312 */
3313
3314 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
3315
3316 if (data.benchmark == 1)
3317 {
3318 perf_sum_all = (perf_sum_all * data.benchmark_repeats) + perf_sum_all;
3319 }
3320
3321 hc_thread_mutex_lock (mux_counter);
3322
3323 data.words_progress_done[salt_pos] += perf_sum_all;
3324
3325 hc_thread_mutex_unlock (mux_counter);
3326
3327 /**
3328 * speed
3329 */
3330
3331 float speed_ms;
3332
3333 hc_timer_get (device_param->timer_speed, speed_ms);
3334
3335 hc_timer_set (&device_param->timer_speed);
3336
3337 hc_thread_mutex_lock (mux_display);
3338
3339 device_param->speed_cnt[speed_pos] = perf_sum_all;
3340
3341 device_param->speed_ms[speed_pos] = speed_ms;
3342
3343 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3344
3345 hc_thread_mutex_unlock (mux_display);
3346
3347 speed_pos++;
3348
3349 if (speed_pos == SPEED_CACHE)
3350 {
3351 speed_pos = 0;
3352 }
3353
3354 /**
3355 * benchmark
3356 */
3357
3358 if (data.benchmark == 1) break;
3359 }
3360 }
3361
3362 device_param->speed_pos = speed_pos;
3363 }
3364
3365 static void load_segment (wl_data_t *wl_data, FILE *fd)
3366 {
3367 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3368
3369 wl_data->pos = 0;
3370
3371 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3372
3373 wl_data->buf[wl_data->cnt] = 0;
3374
3375 if (wl_data->cnt == 0) return;
3376
3377 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3378
3379 while (!feof (fd))
3380 {
3381 if (wl_data->cnt == wl_data->avail)
3382 {
3383 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3384
3385 wl_data->avail += wl_data->incr;
3386 }
3387
3388 const int c = fgetc (fd);
3389
3390 if (c == EOF) break;
3391
3392 wl_data->buf[wl_data->cnt] = (char) c;
3393
3394 wl_data->cnt++;
3395
3396 if (c == '\n') break;
3397 }
3398
3399 // ensure stream ends with a newline
3400
3401 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3402 {
3403 wl_data->cnt++;
3404
3405 wl_data->buf[wl_data->cnt - 1] = '\n';
3406 }
3407
3408 return;
3409 }
3410
3411 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3412 {
3413 char *ptr = buf;
3414
3415 for (u32 i = 0; i < sz; i++, ptr++)
3416 {
3417 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3418
3419 if (i == 7)
3420 {
3421 *off = i;
3422 *len = i;
3423
3424 return;
3425 }
3426
3427 if (*ptr != '\n') continue;
3428
3429 *off = i + 1;
3430
3431 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3432
3433 *len = i;
3434
3435 return;
3436 }
3437
3438 *off = sz;
3439 *len = sz;
3440 }
3441
3442 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3443 {
3444 char *ptr = buf;
3445
3446 for (u32 i = 0; i < sz; i++, ptr++)
3447 {
3448 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3449
3450 if (*ptr != '\n') continue;
3451
3452 *off = i + 1;
3453
3454 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3455
3456 *len = i;
3457
3458 return;
3459 }
3460
3461 *off = sz;
3462 *len = sz;
3463 }
3464
3465 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3466 {
3467 char *ptr = buf;
3468
3469 for (u32 i = 0; i < sz; i++, ptr++)
3470 {
3471 if (*ptr != '\n') continue;
3472
3473 *off = i + 1;
3474
3475 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3476
3477 *len = i;
3478
3479 return;
3480 }
3481
3482 *off = sz;
3483 *len = sz;
3484 }
3485
3486 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3487 {
3488 while (wl_data->pos < wl_data->cnt)
3489 {
3490 uint off;
3491 uint len;
3492
3493 char *ptr = wl_data->buf + wl_data->pos;
3494
3495 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3496
3497 wl_data->pos += off;
3498
3499 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3500 {
3501 char rule_buf_out[BLOCK_SIZE] = { 0 };
3502
3503 int rule_len_out = -1;
3504
3505 if (len < BLOCK_SIZE)
3506 {
3507 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3508 }
3509
3510 if (rule_len_out < 0)
3511 {
3512 continue;
3513 }
3514
3515 if (rule_len_out > PW_MAX)
3516 {
3517 continue;
3518 }
3519 }
3520 else
3521 {
3522 if (len > PW_MAX)
3523 {
3524 continue;
3525 }
3526 }
3527
3528 *out_buf = ptr;
3529 *out_len = len;
3530
3531 return;
3532 }
3533
3534 if (feof (fd))
3535 {
3536 fprintf (stderr, "bug!!\n");
3537
3538 return;
3539 }
3540
3541 load_segment (wl_data, fd);
3542
3543 get_next_word (wl_data, fd, out_buf, out_len);
3544 }
3545
3546 #ifdef _POSIX
3547 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3548 #endif
3549
3550 #ifdef _WIN
3551 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3552 #endif
3553 {
3554 hc_signal (NULL);
3555
3556 dictstat_t d;
3557
3558 d.cnt = 0;
3559
3560 #ifdef _POSIX
3561 fstat (fileno (fd), &d.stat);
3562 #endif
3563
3564 #ifdef _WIN
3565 _fstat64 (fileno (fd), &d.stat);
3566 #endif
3567
3568 d.stat.st_mode = 0;
3569 d.stat.st_nlink = 0;
3570 d.stat.st_uid = 0;
3571 d.stat.st_gid = 0;
3572 d.stat.st_rdev = 0;
3573 d.stat.st_atime = 0;
3574
3575 #ifdef _POSIX
3576 d.stat.st_blksize = 0;
3577 d.stat.st_blocks = 0;
3578 #endif
3579
3580 if (d.stat.st_size == 0) return 0;
3581
3582 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3583
3584 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3585 {
3586 if (d_cache)
3587 {
3588 u64 cnt = d_cache->cnt;
3589
3590 u64 keyspace = cnt;
3591
3592 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3593 {
3594 keyspace *= data.kernel_rules_cnt;
3595 }
3596 else if (data.attack_kern == ATTACK_KERN_COMBI)
3597 {
3598 keyspace *= data.combs_cnt;
3599 }
3600
3601 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);
3602 if (data.quiet == 0) log_info ("");
3603
3604 hc_signal (sigHandler_default);
3605
3606 return (keyspace);
3607 }
3608 }
3609
3610 time_t now = 0;
3611 time_t prev = 0;
3612
3613 u64 comp = 0;
3614 u64 cnt = 0;
3615 u64 cnt2 = 0;
3616
3617 while (!feof (fd))
3618 {
3619 load_segment (wl_data, fd);
3620
3621 comp += wl_data->cnt;
3622
3623 u32 i = 0;
3624
3625 while (i < wl_data->cnt)
3626 {
3627 u32 len;
3628 u32 off;
3629
3630 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3631
3632 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3633 {
3634 char rule_buf_out[BLOCK_SIZE] = { 0 };
3635
3636 int rule_len_out = -1;
3637
3638 if (len < BLOCK_SIZE)
3639 {
3640 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3641 }
3642
3643 if (rule_len_out < 0)
3644 {
3645 len = PW_MAX1;
3646 }
3647 else
3648 {
3649 len = rule_len_out;
3650 }
3651 }
3652
3653 if (len < PW_MAX1)
3654 {
3655 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3656 {
3657 cnt += data.kernel_rules_cnt;
3658 }
3659 else if (data.attack_kern == ATTACK_KERN_COMBI)
3660 {
3661 cnt += data.combs_cnt;
3662 }
3663
3664 d.cnt++;
3665 }
3666
3667 i += off;
3668
3669 cnt2++;
3670 }
3671
3672 time (&now);
3673
3674 if ((now - prev) == 0) continue;
3675
3676 float percent = (float) comp / (float) d.stat.st_size;
3677
3678 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);
3679
3680 time (&prev);
3681 }
3682
3683 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);
3684 if (data.quiet == 0) log_info ("");
3685
3686 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3687
3688 hc_signal (sigHandler_default);
3689
3690 return (cnt);
3691 }
3692
3693 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3694 {
3695 memcpy (p2->h.hi1, p1->h.hi1, 64 * sizeof (uint));
3696 }
3697
3698 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3699 {
3700 if (data.devices_status == STATUS_BYPASS) return 0;
3701
3702 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3703
3704 uint cache_cnt = pw_cache->cnt;
3705
3706 u8 *pw_hc1 = pw_cache->pw_buf.h.hc1[cache_cnt];
3707
3708 memcpy (pw_hc1, pw_buf, pw_len);
3709
3710 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3711
3712 uint pws_cnt = device_param->pws_cnt;
3713
3714 cache_cnt++;
3715
3716 pw_t *pw = device_param->pws_buf + pws_cnt;
3717
3718 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3719
3720 pw->pw_len = pw_len;
3721
3722 pws_cnt++;
3723
3724 device_param->pws_cnt = pws_cnt;
3725 device_param->pw_cnt = pws_cnt * 1;
3726
3727 cache_cnt = 0;
3728
3729 pw_cache->cnt = cache_cnt;
3730
3731 return pws_cnt;
3732 }
3733
3734 static void *thread_monitor (void *p)
3735 {
3736 uint runtime_check = 0;
3737 uint remove_check = 0;
3738 uint status_check = 0;
3739 uint restore_check = 0;
3740
3741 uint restore_left = data.restore_timer;
3742 uint remove_left = data.remove_timer;
3743 uint status_left = data.status_timer;
3744
3745 #ifdef HAVE_HWMON
3746 uint hwmon_check = 0;
3747
3748 // these variables are mainly used for fan control (AMD only)
3749
3750 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3751
3752 // temperature controller "loopback" values
3753
3754 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3755 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3756
3757 #ifdef HAVE_ADL
3758 int temp_threshold = 1; // degrees celcius
3759
3760 int fan_speed_min = 15; // in percentage
3761 int fan_speed_max = 100;
3762 #endif // HAVE_ADL
3763
3764 time_t last_temp_check_time;
3765 #endif // HAVE_HWMON
3766
3767 uint sleep_time = 1;
3768
3769 if (data.runtime)
3770 {
3771 runtime_check = 1;
3772 }
3773
3774 if (data.restore_timer)
3775 {
3776 restore_check = 1;
3777 }
3778
3779 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3780 {
3781 remove_check = 1;
3782 }
3783
3784 if (data.status == 1)
3785 {
3786 status_check = 1;
3787 }
3788
3789 #ifdef HAVE_HWMON
3790 if (data.gpu_temp_disable == 0)
3791 {
3792 time (&last_temp_check_time);
3793
3794 hwmon_check = 1;
3795 }
3796 #endif
3797
3798 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3799 {
3800 #ifdef HAVE_HWMON
3801 if (hwmon_check == 0)
3802 #endif
3803 return (p);
3804 }
3805
3806 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3807 {
3808 hc_sleep (sleep_time);
3809
3810 if (data.devices_status != STATUS_RUNNING) continue;
3811
3812 #ifdef HAVE_HWMON
3813 if (hwmon_check == 1)
3814 {
3815 hc_thread_mutex_lock (mux_adl);
3816
3817 time_t temp_check_time;
3818
3819 time (&temp_check_time);
3820
3821 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3822
3823 if (Ta == 0) Ta = 1;
3824
3825 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3826 {
3827 hc_device_param_t *device_param = &data.devices_param[device_id];
3828
3829 if (device_param->skipped) continue;
3830
3831 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3832
3833 const int temperature = hm_get_temperature_with_device_id (device_id);
3834
3835 if (temperature > (int) data.gpu_temp_abort)
3836 {
3837 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3838
3839 if (data.devices_status != STATUS_QUIT) myabort ();
3840
3841 break;
3842 }
3843
3844 #ifdef HAVE_ADL
3845 const int gpu_temp_retain = data.gpu_temp_retain;
3846
3847 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3848 {
3849 if (data.hm_device[device_id].fan_supported == 1)
3850 {
3851 int temp_cur = temperature;
3852
3853 int temp_diff_new = gpu_temp_retain - temp_cur;
3854
3855 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3856
3857 // calculate Ta value (time difference in seconds between the last check and this check)
3858
3859 last_temp_check_time = temp_check_time;
3860
3861 float Kp = 1.8;
3862 float Ki = 0.005;
3863 float Kd = 6;
3864
3865 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3866
3867 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);
3868
3869 if (abs (fan_diff_required) >= temp_threshold)
3870 {
3871 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3872
3873 int fan_speed_level = fan_speed_cur;
3874
3875 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3876
3877 int fan_speed_new = fan_speed_level - fan_diff_required;
3878
3879 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3880 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3881
3882 if (fan_speed_new != fan_speed_cur)
3883 {
3884 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3885 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3886
3887 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3888 {
3889 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3890
3891 fan_speed_chgd[device_id] = 1;
3892 }
3893
3894 temp_diff_old[device_id] = temp_diff_new;
3895 }
3896 }
3897 }
3898 }
3899 #endif // HAVE_ADL
3900 }
3901
3902 hc_thread_mutex_unlock (mux_adl);
3903 }
3904 #endif // HAVE_HWMON
3905
3906 if (restore_check == 1)
3907 {
3908 restore_left--;
3909
3910 if (restore_left == 0)
3911 {
3912 if (data.restore_disable == 0) cycle_restore ();
3913
3914 restore_left = data.restore_timer;
3915 }
3916 }
3917
3918 if ((runtime_check == 1) && (data.runtime_start > 0))
3919 {
3920 time_t runtime_cur;
3921
3922 time (&runtime_cur);
3923
3924 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3925
3926 if (runtime_left <= 0)
3927 {
3928 if (data.benchmark == 0)
3929 {
3930 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3931 }
3932
3933 if (data.devices_status != STATUS_QUIT) myabort ();
3934 }
3935 }
3936
3937 if (remove_check == 1)
3938 {
3939 remove_left--;
3940
3941 if (remove_left == 0)
3942 {
3943 if (data.digests_saved != data.digests_done)
3944 {
3945 data.digests_saved = data.digests_done;
3946
3947 save_hash ();
3948 }
3949
3950 remove_left = data.remove_timer;
3951 }
3952 }
3953
3954 if (status_check == 1)
3955 {
3956 status_left--;
3957
3958 if (status_left == 0)
3959 {
3960 hc_thread_mutex_lock (mux_display);
3961
3962 if (data.quiet == 0) clear_prompt ();
3963
3964 if (data.quiet == 0) log_info ("");
3965
3966 status_display ();
3967
3968 if (data.quiet == 0) log_info ("");
3969
3970 hc_thread_mutex_unlock (mux_display);
3971
3972 status_left = data.status_timer;
3973 }
3974 }
3975 }
3976
3977 #ifdef HAVE_HWMON
3978 myfree (fan_speed_chgd);
3979
3980 myfree (temp_diff_old);
3981 myfree (temp_diff_sum);
3982 #endif
3983
3984 p = NULL;
3985
3986 return (p);
3987 }
3988
3989 static void *thread_outfile_remove (void *p)
3990 {
3991 // some hash-dependent constants
3992 char *outfile_dir = data.outfile_check_directory;
3993 uint dgst_size = data.dgst_size;
3994 uint isSalted = data.isSalted;
3995 uint esalt_size = data.esalt_size;
3996 uint hash_mode = data.hash_mode;
3997
3998 uint outfile_check_timer = data.outfile_check_timer;
3999
4000 char separator = data.separator;
4001
4002 // some hash-dependent functions
4003 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4004 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4005
4006 // buffers
4007 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4008
4009 hash_buf.digest = mymalloc (dgst_size);
4010
4011 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4012
4013 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4014
4015 uint digest_buf[64] = { 0 };
4016
4017 outfile_data_t *out_info = NULL;
4018
4019 char **out_files = NULL;
4020
4021 time_t folder_mtime = 0;
4022
4023 int out_cnt = 0;
4024
4025 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4026
4027 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4028 {
4029 hc_sleep (1);
4030
4031 if (data.devices_status != STATUS_RUNNING) continue;
4032
4033 check_left--;
4034
4035 if (check_left == 0)
4036 {
4037 struct stat outfile_check_stat;
4038
4039 if (stat (outfile_dir, &outfile_check_stat) == 0)
4040 {
4041 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4042
4043 if (is_dir == 1)
4044 {
4045 if (outfile_check_stat.st_mtime > folder_mtime)
4046 {
4047 char **out_files_new = scan_directory (outfile_dir);
4048
4049 int out_cnt_new = count_dictionaries (out_files_new);
4050
4051 outfile_data_t *out_info_new = NULL;
4052
4053 if (out_cnt_new > 0)
4054 {
4055 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4056
4057 for (int i = 0; i < out_cnt_new; i++)
4058 {
4059 out_info_new[i].file_name = out_files_new[i];
4060
4061 // check if there are files that we have seen/checked before (and not changed)
4062
4063 for (int j = 0; j < out_cnt; j++)
4064 {
4065 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4066 {
4067 struct stat outfile_stat;
4068
4069 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4070 {
4071 if (outfile_stat.st_ctime == out_info[j].ctime)
4072 {
4073 out_info_new[i].ctime = out_info[j].ctime;
4074 out_info_new[i].seek = out_info[j].seek;
4075 }
4076 }
4077 }
4078 }
4079 }
4080 }
4081
4082 local_free (out_info);
4083 local_free (out_files);
4084
4085 out_files = out_files_new;
4086 out_cnt = out_cnt_new;
4087 out_info = out_info_new;
4088
4089 folder_mtime = outfile_check_stat.st_mtime;
4090 }
4091
4092 for (int j = 0; j < out_cnt; j++)
4093 {
4094 FILE *fp = fopen (out_info[j].file_name, "rb");
4095
4096 if (fp != NULL)
4097 {
4098 //hc_thread_mutex_lock (mux_display);
4099
4100 #ifdef _POSIX
4101 struct stat outfile_stat;
4102
4103 fstat (fileno (fp), &outfile_stat);
4104 #endif
4105
4106 #ifdef _WIN
4107 struct stat64 outfile_stat;
4108
4109 _fstat64 (fileno (fp), &outfile_stat);
4110 #endif
4111
4112 if (outfile_stat.st_ctime > out_info[j].ctime)
4113 {
4114 out_info[j].ctime = outfile_stat.st_ctime;
4115 out_info[j].seek = 0;
4116 }
4117
4118 fseek (fp, out_info[j].seek, SEEK_SET);
4119
4120 while (!feof (fp))
4121 {
4122 char line_buf[BUFSIZ] = { 0 };
4123
4124 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
4125
4126 if (ptr == NULL) break;
4127
4128 int line_len = strlen (line_buf);
4129
4130 if (line_len <= 0) continue;
4131
4132 int iter = MAX_CUT_TRIES;
4133
4134 for (uint i = line_len - 1; i && iter; i--, line_len--)
4135 {
4136 if (line_buf[i] != separator) continue;
4137
4138 int parser_status = PARSER_OK;
4139
4140 if ((hash_mode != 2500) && (hash_mode != 6800))
4141 {
4142 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4143 }
4144
4145 uint found = 0;
4146
4147 if (parser_status == PARSER_OK)
4148 {
4149 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4150 {
4151 if (data.salts_shown[salt_pos] == 1) continue;
4152
4153 salt_t *salt_buf = &data.salts_buf[salt_pos];
4154
4155 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4156 {
4157 uint idx = salt_buf->digests_offset + digest_pos;
4158
4159 if (data.digests_shown[idx] == 1) continue;
4160
4161 uint cracked = 0;
4162
4163 if (hash_mode == 6800)
4164 {
4165 if (i == salt_buf->salt_len)
4166 {
4167 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4168 }
4169 }
4170 else if (hash_mode == 2500)
4171 {
4172 // BSSID : MAC1 : MAC2 (:plain)
4173 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4174 {
4175 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4176
4177 if (!cracked) continue;
4178
4179 // now compare MAC1 and MAC2 too, since we have this additional info
4180 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4181 char *mac2_pos = mac1_pos + 12 + 1;
4182
4183 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4184 wpa_t *wpa = &wpas[salt_pos];
4185
4186 uint pke[25] = { 0 };
4187
4188 char *pke_ptr = (char *) pke;
4189
4190 for (uint i = 0; i < 25; i++)
4191 {
4192 pke[i] = byte_swap_32 (wpa->pke[i]);
4193 }
4194
4195 u8 mac1[6] = { 0 };
4196 u8 mac2[6] = { 0 };
4197
4198 memcpy (mac1, pke_ptr + 23, 6);
4199 memcpy (mac2, pke_ptr + 29, 6);
4200
4201 // compare hex string(s) vs binary MAC address(es)
4202
4203 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4204 {
4205 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4206 {
4207 cracked = 0;
4208 break;
4209 }
4210 }
4211
4212 // early skip ;)
4213 if (!cracked) continue;
4214
4215 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4216 {
4217 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4218 {
4219 cracked = 0;
4220 break;
4221 }
4222 }
4223 }
4224 }
4225 else
4226 {
4227 char *digests_buf_ptr = (char *) data.digests_buf;
4228
4229 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4230
4231 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4232 }
4233
4234 if (cracked == 1)
4235 {
4236 found = 1;
4237
4238 data.digests_shown[idx] = 1;
4239
4240 data.digests_done++;
4241
4242 salt_buf->digests_done++;
4243
4244 if (salt_buf->digests_done == salt_buf->digests_cnt)
4245 {
4246 data.salts_shown[salt_pos] = 1;
4247
4248 data.salts_done++;
4249
4250 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4251 }
4252 }
4253 }
4254
4255 if (data.devices_status == STATUS_CRACKED) break;
4256 }
4257 }
4258
4259 if (found) break;
4260
4261 if (data.devices_status == STATUS_CRACKED) break;
4262
4263 iter--;
4264 }
4265
4266 if (data.devices_status == STATUS_CRACKED) break;
4267 }
4268
4269 out_info[j].seek = ftell (fp);
4270
4271 //hc_thread_mutex_unlock (mux_display);
4272
4273 fclose (fp);
4274 }
4275 }
4276 }
4277 }
4278
4279 check_left = outfile_check_timer;
4280 }
4281 }
4282
4283 if (esalt_size) local_free (hash_buf.esalt);
4284
4285 if (isSalted) local_free (hash_buf.salt);
4286
4287 local_free (hash_buf.digest);
4288
4289 local_free (out_info);
4290
4291 local_free (out_files);
4292
4293 p = NULL;
4294
4295 return (p);
4296 }
4297
4298 static uint get_work (hc_device_param_t *device_param, const u64 max)
4299 {
4300 hc_thread_mutex_lock (mux_dispatcher);
4301
4302 const u64 words_cur = data.words_cur;
4303 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4304
4305 device_param->words_off = words_cur;
4306
4307 const u64 words_left = words_base - words_cur;
4308
4309 if (data.kernel_power_all > words_left)
4310 {
4311 if (data.kernel_power_div == 0)
4312 {
4313 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4314 }
4315 }
4316
4317 if (data.kernel_power_div)
4318 {
4319 if (device_param->kernel_power == device_param->kernel_power_user)
4320 {
4321 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4322
4323 if (kernel_power_new < device_param->kernel_power)
4324 {
4325 device_param->kernel_power = kernel_power_new;
4326 }
4327 }
4328 }
4329
4330 const uint kernel_power = device_param->kernel_power;
4331
4332 uint work = MIN (words_left, kernel_power);
4333
4334 work = MIN (work, max);
4335
4336 data.words_cur += work;
4337
4338 hc_thread_mutex_unlock (mux_dispatcher);
4339
4340 return work;
4341 }
4342
4343 static void *thread_calc_stdin (void *p)
4344 {
4345 hc_device_param_t *device_param = (hc_device_param_t *) p;
4346
4347 if (device_param->skipped) return NULL;
4348
4349 const bool run_autotune = ((device_param->kernel_accel == 0) && (device_param->kernel_loops == 0));
4350
4351 if (run_autotune)
4352 {
4353 autotune (device_param);
4354 }
4355
4356 const uint attack_kern = data.attack_kern;
4357
4358 const uint kernel_power = device_param->kernel_power;
4359
4360 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4361 {
4362 hc_thread_mutex_lock (mux_dispatcher);
4363
4364 if (feof (stdin) != 0)
4365 {
4366 hc_thread_mutex_unlock (mux_dispatcher);
4367
4368 break;
4369 }
4370
4371 uint words_cur = 0;
4372
4373 while (words_cur < kernel_power)
4374 {
4375 char buf[BUFSIZ] = { 0 };
4376
4377 char *line_buf = fgets (buf, sizeof (buf), stdin);
4378
4379 if (line_buf == NULL) break;
4380
4381 uint line_len = in_superchop (line_buf);
4382
4383 line_len = convert_from_hex (line_buf, line_len);
4384
4385 // post-process rule engine
4386
4387 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4388 {
4389 char rule_buf_out[BLOCK_SIZE] = { 0 };
4390
4391 int rule_len_out = -1;
4392
4393 if (line_len < BLOCK_SIZE)
4394 {
4395 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4396 }
4397
4398 if (rule_len_out < 0) continue;
4399
4400 line_buf = rule_buf_out;
4401 line_len = rule_len_out;
4402 }
4403
4404 if (line_len > PW_MAX)
4405 {
4406 continue;
4407 }
4408
4409 if (attack_kern == ATTACK_KERN_STRAIGHT)
4410 {
4411 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4412 {
4413 hc_thread_mutex_lock (mux_counter);
4414
4415 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4416 {
4417 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4418 }
4419
4420 hc_thread_mutex_unlock (mux_counter);
4421
4422 continue;
4423 }
4424 }
4425 else if (attack_kern == ATTACK_KERN_COMBI)
4426 {
4427 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4428 // since we still need to combine the plains
4429
4430 if (line_len > data.pw_max)
4431 {
4432 hc_thread_mutex_lock (mux_counter);
4433
4434 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4435 {
4436 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4437 }
4438
4439 hc_thread_mutex_unlock (mux_counter);
4440
4441 continue;
4442 }
4443 }
4444
4445 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4446
4447 words_cur++;
4448
4449 if (data.devices_status == STATUS_CRACKED) break;
4450 if (data.devices_status == STATUS_ABORTED) break;
4451 if (data.devices_status == STATUS_QUIT) break;
4452 if (data.devices_status == STATUS_BYPASS) break;
4453 }
4454
4455 hc_thread_mutex_unlock (mux_dispatcher);
4456
4457 if (data.devices_status == STATUS_CRACKED) break;
4458 if (data.devices_status == STATUS_ABORTED) break;
4459 if (data.devices_status == STATUS_QUIT) break;
4460 if (data.devices_status == STATUS_BYPASS) break;
4461
4462 // we need 2 flushing because we have two independant caches and it can occur
4463 // that one buffer is already at threshold plus for that length also exists
4464 // more data in the 2nd buffer so it would overflow
4465
4466 // flush session 1
4467
4468 {
4469 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4470 {
4471 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4472
4473 const uint pw_cache_cnt = pw_cache->cnt;
4474
4475 if (pw_cache_cnt == 0) continue;
4476
4477 pw_cache->cnt = 0;
4478
4479 uint pws_cnt = device_param->pws_cnt;
4480
4481 pw_t *pw = device_param->pws_buf + pws_cnt;
4482
4483 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4484
4485 pw->pw_len = pw_len;
4486
4487 uint pw_cnt = device_param->pw_cnt;
4488
4489 pw_cnt += pw_cache_cnt;
4490
4491 device_param->pw_cnt = pw_cnt;
4492
4493 pws_cnt++;
4494
4495 device_param->pws_cnt = pws_cnt;
4496
4497 if (pws_cnt == device_param->kernel_power_user) break;
4498 }
4499
4500 const uint pw_cnt = device_param->pw_cnt;
4501 const uint pws_cnt = device_param->pws_cnt;
4502
4503 if (pws_cnt)
4504 {
4505 run_copy (device_param, pws_cnt);
4506
4507 run_cracker (device_param, pw_cnt, pws_cnt);
4508
4509 device_param->pw_cnt = 0;
4510 device_param->pws_cnt = 0;
4511 }
4512 }
4513
4514 // flush session 2
4515
4516 {
4517 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4518 {
4519 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4520
4521 const uint pw_cache_cnt = pw_cache->cnt;
4522
4523 if (pw_cache_cnt == 0) continue;
4524
4525 pw_cache->cnt = 0;
4526
4527 uint pws_cnt = device_param->pws_cnt;
4528
4529 pw_t *pw = device_param->pws_buf + pws_cnt;
4530
4531 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4532
4533 pw->pw_len = pw_len;
4534
4535 uint pw_cnt = device_param->pw_cnt;
4536
4537 pw_cnt += pw_cache_cnt;
4538
4539 device_param->pw_cnt = pw_cnt;
4540
4541 pws_cnt++;
4542
4543 device_param->pws_cnt = pws_cnt;
4544 }
4545
4546 const uint pw_cnt = device_param->pw_cnt;
4547 const uint pws_cnt = device_param->pws_cnt;
4548
4549 if (pws_cnt)
4550 {
4551 run_copy (device_param, pws_cnt);
4552
4553 run_cracker (device_param, pw_cnt, pws_cnt);
4554
4555 device_param->pw_cnt = 0;
4556 device_param->pws_cnt = 0;
4557 }
4558 }
4559 }
4560
4561 if (run_autotune)
4562 {
4563 device_param->kernel_accel = 0;
4564 device_param->kernel_loops = 0;
4565 }
4566
4567 return NULL;
4568 }
4569
4570 static void *thread_calc (void *p)
4571 {
4572 hc_device_param_t *device_param = (hc_device_param_t *) p;
4573
4574 if (device_param->skipped) return NULL;
4575
4576 const bool run_autotune = ((device_param->kernel_accel == 0) && (device_param->kernel_loops == 0));
4577
4578 if (run_autotune)
4579 {
4580 autotune (device_param);
4581 }
4582
4583 const uint attack_mode = data.attack_mode;
4584 const uint attack_kern = data.attack_kern;
4585
4586 if (attack_mode == ATTACK_MODE_BF)
4587 {
4588 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4589 {
4590 const uint work = get_work (device_param, -1);
4591
4592 if (work == 0) break;
4593
4594 const u64 words_off = device_param->words_off;
4595 const u64 words_fin = words_off + work;
4596
4597 const uint pw_cnt = work;
4598 const uint pws_cnt = work;
4599
4600 device_param->pw_cnt = pw_cnt;
4601 device_param->pws_cnt = pws_cnt;
4602
4603 if (pws_cnt)
4604 {
4605 run_copy (device_param, pws_cnt);
4606
4607 run_cracker (device_param, pw_cnt, pws_cnt);
4608
4609 device_param->pw_cnt = 0;
4610 device_param->pws_cnt = 0;
4611 }
4612
4613 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4614
4615 if (data.devices_status == STATUS_CRACKED) break;
4616 if (data.devices_status == STATUS_ABORTED) break;
4617 if (data.devices_status == STATUS_QUIT) break;
4618 if (data.devices_status == STATUS_BYPASS) break;
4619
4620 if (data.benchmark == 1) break;
4621
4622 device_param->words_done = words_fin;
4623 }
4624 }
4625 else
4626 {
4627 const uint segment_size = data.segment_size;
4628
4629 char *dictfile = data.dictfile;
4630
4631 if (attack_mode == ATTACK_MODE_COMBI)
4632 {
4633 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4634 {
4635 dictfile = data.dictfile2;
4636 }
4637 }
4638
4639 FILE *fd = fopen (dictfile, "rb");
4640
4641 if (fd == NULL)
4642 {
4643 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4644
4645 return NULL;
4646 }
4647
4648 if (attack_mode == ATTACK_MODE_COMBI)
4649 {
4650 const uint combs_mode = data.combs_mode;
4651
4652 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4653 {
4654 const char *dictfilec = data.dictfile2;
4655
4656 FILE *combs_fp = fopen (dictfilec, "rb");
4657
4658 if (combs_fp == NULL)
4659 {
4660 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4661
4662 fclose (fd);
4663
4664 return NULL;
4665 }
4666
4667 device_param->combs_fp = combs_fp;
4668 }
4669 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4670 {
4671 const char *dictfilec = data.dictfile;
4672
4673 FILE *combs_fp = fopen (dictfilec, "rb");
4674
4675 if (combs_fp == NULL)
4676 {
4677 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4678
4679 fclose (fd);
4680
4681 return NULL;
4682 }
4683
4684 device_param->combs_fp = combs_fp;
4685 }
4686 }
4687
4688 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4689
4690 wl_data->buf = (char *) mymalloc (segment_size);
4691 wl_data->avail = segment_size;
4692 wl_data->incr = segment_size;
4693 wl_data->cnt = 0;
4694 wl_data->pos = 0;
4695
4696 u64 words_cur = 0;
4697
4698 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4699 {
4700 u64 words_off = 0;
4701 u64 words_fin = 0;
4702
4703 u64 max = -1;
4704
4705 while (max)
4706 {
4707 const uint work = get_work (device_param, max);
4708
4709 if (work == 0) break;
4710
4711 words_off = device_param->words_off;
4712 words_fin = words_off + work;
4713
4714 char *line_buf;
4715 uint line_len;
4716
4717 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4718
4719 max = 0;
4720
4721 for ( ; words_cur < words_fin; words_cur++)
4722 {
4723 get_next_word (wl_data, fd, &line_buf, &line_len);
4724
4725 line_len = convert_from_hex (line_buf, line_len);
4726
4727 // post-process rule engine
4728
4729 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4730 {
4731 char rule_buf_out[BLOCK_SIZE] = { 0 };
4732
4733 int rule_len_out = -1;
4734
4735 if (line_len < BLOCK_SIZE)
4736 {
4737 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4738 }
4739
4740 if (rule_len_out < 0) continue;
4741
4742 line_buf = rule_buf_out;
4743 line_len = rule_len_out;
4744 }
4745
4746 if (attack_kern == ATTACK_KERN_STRAIGHT)
4747 {
4748 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4749 {
4750 max++;
4751
4752 hc_thread_mutex_lock (mux_counter);
4753
4754 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4755 {
4756 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4757 }
4758
4759 hc_thread_mutex_unlock (mux_counter);
4760
4761 continue;
4762 }
4763 }
4764 else if (attack_kern == ATTACK_KERN_COMBI)
4765 {
4766 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4767 // since we still need to combine the plains
4768
4769 if (line_len > data.pw_max)
4770 {
4771 max++;
4772
4773 hc_thread_mutex_lock (mux_counter);
4774
4775 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4776 {
4777 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4778 }
4779
4780 hc_thread_mutex_unlock (mux_counter);
4781
4782 continue;
4783 }
4784 }
4785
4786 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4787
4788 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4789
4790 if (data.devices_status == STATUS_CRACKED) break;
4791 if (data.devices_status == STATUS_ABORTED) break;
4792 if (data.devices_status == STATUS_QUIT) break;
4793 if (data.devices_status == STATUS_BYPASS) break;
4794 }
4795
4796 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4797
4798 if (data.devices_status == STATUS_CRACKED) break;
4799 if (data.devices_status == STATUS_ABORTED) break;
4800 if (data.devices_status == STATUS_QUIT) break;
4801 if (data.devices_status == STATUS_BYPASS) break;
4802 }
4803
4804 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4805
4806 if (data.devices_status == STATUS_CRACKED) break;
4807 if (data.devices_status == STATUS_ABORTED) break;
4808 if (data.devices_status == STATUS_QUIT) break;
4809 if (data.devices_status == STATUS_BYPASS) break;
4810
4811 // we need 2 flushing because we have two independant caches and it can occur
4812 // that one buffer is already at threshold plus for that length also exists
4813 // more data in the 2nd buffer so it would overflow
4814
4815 //
4816 // flush session 1
4817 //
4818
4819 {
4820 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4821 {
4822 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4823
4824 const uint pw_cache_cnt = pw_cache->cnt;
4825
4826 if (pw_cache_cnt == 0) continue;
4827
4828 pw_cache->cnt = 0;
4829
4830 uint pws_cnt = device_param->pws_cnt;
4831
4832 pw_t *pw = device_param->pws_buf + pws_cnt;
4833
4834 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4835
4836 pw->pw_len = pw_len;
4837
4838 uint pw_cnt = device_param->pw_cnt;
4839
4840 pw_cnt += pw_cache_cnt;
4841
4842 device_param->pw_cnt = pw_cnt;
4843
4844 pws_cnt++;
4845
4846 device_param->pws_cnt = pws_cnt;
4847
4848 if (pws_cnt == device_param->kernel_power_user) break;
4849 }
4850
4851 const uint pw_cnt = device_param->pw_cnt;
4852 const uint pws_cnt = device_param->pws_cnt;
4853
4854 if (pws_cnt)
4855 {
4856 run_copy (device_param, pws_cnt);
4857
4858 run_cracker (device_param, pw_cnt, pws_cnt);
4859
4860 device_param->pw_cnt = 0;
4861 device_param->pws_cnt = 0;
4862 }
4863
4864 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4865
4866 if (data.devices_status == STATUS_CRACKED) break;
4867 if (data.devices_status == STATUS_ABORTED) break;
4868 if (data.devices_status == STATUS_QUIT) break;
4869 if (data.devices_status == STATUS_BYPASS) break;
4870 }
4871
4872 //
4873 // flush session 2
4874 //
4875
4876 {
4877 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4878 {
4879 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4880
4881 const uint pw_cache_cnt = pw_cache->cnt;
4882
4883 if (pw_cache_cnt == 0) continue;
4884
4885 pw_cache->cnt = 0;
4886
4887 uint pws_cnt = device_param->pws_cnt;
4888
4889 pw_t *pw = device_param->pws_buf + pws_cnt;
4890
4891 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4892
4893 pw->pw_len = pw_len;
4894
4895 uint pw_cnt = device_param->pw_cnt;
4896
4897 pw_cnt += pw_cache_cnt;
4898
4899 device_param->pw_cnt = pw_cnt;
4900
4901 pws_cnt++;
4902
4903 device_param->pws_cnt = pws_cnt;
4904 }
4905
4906 const uint pw_cnt = device_param->pw_cnt;
4907 const uint pws_cnt = device_param->pws_cnt;
4908
4909 if (pws_cnt)
4910 {
4911 run_copy (device_param, pws_cnt);
4912
4913 run_cracker (device_param, pw_cnt, pws_cnt);
4914
4915 device_param->pw_cnt = 0;
4916 device_param->pws_cnt = 0;
4917 }
4918
4919 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4920
4921 if (data.devices_status == STATUS_CRACKED) break;
4922 if (data.devices_status == STATUS_ABORTED) break;
4923 if (data.devices_status == STATUS_QUIT) break;
4924 if (data.devices_status == STATUS_BYPASS) break;
4925 }
4926
4927 if (words_fin == 0) break;
4928
4929 device_param->words_done = words_fin;
4930 }
4931
4932 if (attack_mode == ATTACK_MODE_COMBI)
4933 {
4934 fclose (device_param->combs_fp);
4935 }
4936
4937 free (wl_data->buf);
4938 free (wl_data);
4939
4940 fclose (fd);
4941 }
4942
4943 if (run_autotune)
4944 {
4945 device_param->kernel_accel = 0;
4946 device_param->kernel_loops = 0;
4947 }
4948
4949 return NULL;
4950 }
4951
4952 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4953 {
4954 if (!device_param)
4955 {
4956 log_error ("ERROR: %s : Invalid argument", __func__);
4957
4958 exit (-1);
4959 }
4960
4961 salt_t *salt_buf = &data.salts_buf[salt_pos];
4962
4963 device_param->kernel_params_buf32[24] = salt_pos;
4964 device_param->kernel_params_buf32[27] = 1;
4965 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4966 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4967 device_param->kernel_params_buf32[30] = 0;
4968 device_param->kernel_params_buf32[31] = 1;
4969
4970 char *dictfile_old = data.dictfile;
4971
4972 const char *weak_hash_check = "weak-hash-check";
4973
4974 data.dictfile = (char *) weak_hash_check;
4975
4976 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4977
4978 data.kernel_rules_buf[0].cmds[0] = 0;
4979
4980 /**
4981 * run the kernel
4982 */
4983
4984 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4985 {
4986 run_kernel (KERN_RUN_1, device_param, 1, false);
4987 }
4988 else
4989 {
4990 run_kernel (KERN_RUN_1, device_param, 1, false);
4991
4992 uint loop_step = 16;
4993
4994 const uint iter = salt_buf->salt_iter;
4995
4996 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4997 {
4998 uint loop_left = iter - loop_pos;
4999
5000 loop_left = MIN (loop_left, loop_step);
5001
5002 device_param->kernel_params_buf32[25] = loop_pos;
5003 device_param->kernel_params_buf32[26] = loop_left;
5004
5005 run_kernel (KERN_RUN_2, device_param, 1, false);
5006 }
5007
5008 run_kernel (KERN_RUN_3, device_param, 1, false);
5009 }
5010
5011 /**
5012 * result
5013 */
5014
5015 check_cracked (device_param, salt_pos);
5016
5017 /**
5018 * cleanup
5019 */
5020
5021 device_param->kernel_params_buf32[24] = 0;
5022 device_param->kernel_params_buf32[25] = 0;
5023 device_param->kernel_params_buf32[26] = 0;
5024 device_param->kernel_params_buf32[27] = 0;
5025 device_param->kernel_params_buf32[28] = 0;
5026 device_param->kernel_params_buf32[29] = 0;
5027 device_param->kernel_params_buf32[30] = 0;
5028 device_param->kernel_params_buf32[31] = 0;
5029
5030 data.dictfile = dictfile_old;
5031
5032 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5033 }
5034
5035 // hlfmt hashcat
5036
5037 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5038 {
5039 if (data.username == 0)
5040 {
5041 *hashbuf_pos = line_buf;
5042 *hashbuf_len = line_len;
5043 }
5044 else
5045 {
5046 char *pos = line_buf;
5047 int len = line_len;
5048
5049 for (int i = 0; i < line_len; i++, pos++, len--)
5050 {
5051 if (line_buf[i] == data.separator)
5052 {
5053 pos++;
5054
5055 len--;
5056
5057 break;
5058 }
5059 }
5060
5061 *hashbuf_pos = pos;
5062 *hashbuf_len = len;
5063 }
5064 }
5065
5066 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5067 {
5068 char *pos = NULL;
5069 int len = 0;
5070
5071 int sep_cnt = 0;
5072
5073 for (int i = 0; i < line_len; i++)
5074 {
5075 if (line_buf[i] == data.separator)
5076 {
5077 sep_cnt++;
5078
5079 continue;
5080 }
5081
5082 if (sep_cnt == 0)
5083 {
5084 if (pos == NULL) pos = line_buf + i;
5085
5086 len++;
5087 }
5088 }
5089
5090 *userbuf_pos = pos;
5091 *userbuf_len = len;
5092 }
5093
5094 // hlfmt pwdump
5095
5096 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
5097 {
5098 int sep_cnt = 0;
5099
5100 int sep2_len = 0;
5101 int sep3_len = 0;
5102
5103 for (int i = 0; i < line_len; i++)
5104 {
5105 if (line_buf[i] == ':')
5106 {
5107 sep_cnt++;
5108
5109 continue;
5110 }
5111
5112 if (sep_cnt == 2) sep2_len++;
5113 if (sep_cnt == 3) sep3_len++;
5114 }
5115
5116 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5117
5118 return 0;
5119 }
5120
5121 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5122 {
5123 char *pos = NULL;
5124 int len = 0;
5125
5126 int sep_cnt = 0;
5127
5128 for (int i = 0; i < line_len; i++)
5129 {
5130 if (line_buf[i] == ':')
5131 {
5132 sep_cnt++;
5133
5134 continue;
5135 }
5136
5137 if (data.hash_mode == 1000)
5138 {
5139 if (sep_cnt == 3)
5140 {
5141 if (pos == NULL) pos = line_buf + i;
5142
5143 len++;
5144 }
5145 }
5146 else if (data.hash_mode == 3000)
5147 {
5148 if (sep_cnt == 2)
5149 {
5150 if (pos == NULL) pos = line_buf + i;
5151
5152 len++;
5153 }
5154 }
5155 }
5156
5157 *hashbuf_pos = pos;
5158 *hashbuf_len = len;
5159 }
5160
5161 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5162 {
5163 char *pos = NULL;
5164 int len = 0;
5165
5166 int sep_cnt = 0;
5167
5168 for (int i = 0; i < line_len; i++)
5169 {
5170 if (line_buf[i] == ':')
5171 {
5172 sep_cnt++;
5173
5174 continue;
5175 }
5176
5177 if (sep_cnt == 0)
5178 {
5179 if (pos == NULL) pos = line_buf + i;
5180
5181 len++;
5182 }
5183 }
5184
5185 *userbuf_pos = pos;
5186 *userbuf_len = len;
5187 }
5188
5189 // hlfmt passwd
5190
5191 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
5192 {
5193 int sep_cnt = 0;
5194
5195 char sep5_first = 0;
5196 char sep6_first = 0;
5197
5198 for (int i = 0; i < line_len; i++)
5199 {
5200 if (line_buf[i] == ':')
5201 {
5202 sep_cnt++;
5203
5204 continue;
5205 }
5206
5207 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5208 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5209 }
5210
5211 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5212
5213 return 0;
5214 }
5215
5216 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5217 {
5218 char *pos = NULL;
5219 int len = 0;
5220
5221 int sep_cnt = 0;
5222
5223 for (int i = 0; i < line_len; i++)
5224 {
5225 if (line_buf[i] == ':')
5226 {
5227 sep_cnt++;
5228
5229 continue;
5230 }
5231
5232 if (sep_cnt == 1)
5233 {
5234 if (pos == NULL) pos = line_buf + i;
5235
5236 len++;
5237 }
5238 }
5239
5240 *hashbuf_pos = pos;
5241 *hashbuf_len = len;
5242 }
5243
5244 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5245 {
5246 char *pos = NULL;
5247 int len = 0;
5248
5249 int sep_cnt = 0;
5250
5251 for (int i = 0; i < line_len; i++)
5252 {
5253 if (line_buf[i] == ':')
5254 {
5255 sep_cnt++;
5256
5257 continue;
5258 }
5259
5260 if (sep_cnt == 0)
5261 {
5262 if (pos == NULL) pos = line_buf + i;
5263
5264 len++;
5265 }
5266 }
5267
5268 *userbuf_pos = pos;
5269 *userbuf_len = len;
5270 }
5271
5272 // hlfmt shadow
5273
5274 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
5275 {
5276 int sep_cnt = 0;
5277
5278 for (int i = 0; i < line_len; i++)
5279 {
5280 if (line_buf[i] == ':') sep_cnt++;
5281 }
5282
5283 if (sep_cnt == 8) return 1;
5284
5285 return 0;
5286 }
5287
5288 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5289 {
5290 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5291 }
5292
5293 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5294 {
5295 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5296 }
5297
5298 // hlfmt main
5299
5300 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5301 {
5302 switch (hashfile_format)
5303 {
5304 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5305 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5306 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5307 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5308 }
5309 }
5310
5311 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5312 {
5313 switch (hashfile_format)
5314 {
5315 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5316 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5317 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5318 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5319 }
5320 }
5321
5322 static uint hlfmt_detect (FILE *fp, uint max_check)
5323 {
5324 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5325
5326 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5327 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5328
5329 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5330
5331 uint num_check = 0;
5332
5333 while (!feof (fp))
5334 {
5335 char line_buf[BUFSIZ] = { 0 };
5336
5337 int line_len = fgetl (fp, line_buf);
5338
5339 if (line_len == 0) continue;
5340
5341 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5342 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5343 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5344
5345 if (num_check == max_check) break;
5346
5347 num_check++;
5348 }
5349
5350 uint hashlist_format = HLFMT_HASHCAT;
5351
5352 for (int i = 1; i < HLFMTS_CNT; i++)
5353 {
5354 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5355
5356 hashlist_format = i;
5357 }
5358
5359 free (formats_cnt);
5360
5361 return hashlist_format;
5362 }
5363
5364 /**
5365 * some further helper function
5366 */
5367
5368 // wrapper around mymalloc for ADL
5369
5370 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5371 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5372 {
5373 return mymalloc (iSize);
5374 }
5375 #endif
5376
5377 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)
5378 {
5379 u64 collisions = 0;
5380
5381 const uint dgst_pos0 = data.dgst_pos0;
5382 const uint dgst_pos1 = data.dgst_pos1;
5383 const uint dgst_pos2 = data.dgst_pos2;
5384 const uint dgst_pos3 = data.dgst_pos3;
5385
5386 memset (bitmap_a, 0, bitmap_size);
5387 memset (bitmap_b, 0, bitmap_size);
5388 memset (bitmap_c, 0, bitmap_size);
5389 memset (bitmap_d, 0, bitmap_size);
5390
5391 for (uint i = 0; i < digests_cnt; i++)
5392 {
5393 uint *digest_ptr = (uint *) digests_buf_ptr;
5394
5395 digests_buf_ptr += dgst_size;
5396
5397 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5398 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5399 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5400 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5401
5402 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5403 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5404 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5405 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5406
5407 if (bitmap_a[idx0] & val0) collisions++;
5408 if (bitmap_b[idx1] & val1) collisions++;
5409 if (bitmap_c[idx2] & val2) collisions++;
5410 if (bitmap_d[idx3] & val3) collisions++;
5411
5412 bitmap_a[idx0] |= val0;
5413 bitmap_b[idx1] |= val1;
5414 bitmap_c[idx2] |= val2;
5415 bitmap_d[idx3] |= val3;
5416
5417 if (collisions >= collisions_max) return 0x7fffffff;
5418 }
5419
5420 return collisions;
5421 }
5422
5423 /**
5424 * main
5425 */
5426
5427 int main (int argc, char **argv)
5428 {
5429 /**
5430 * To help users a bit
5431 */
5432
5433 char *compute = getenv ("COMPUTE");
5434
5435 if (compute)
5436 {
5437 static char display[100];
5438
5439 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5440
5441 putenv (display);
5442 }
5443 else
5444 {
5445 if (getenv ("DISPLAY") == NULL)
5446 putenv ((char *) "DISPLAY=:0");
5447 }
5448
5449 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5450 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5451
5452 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5453 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5454
5455 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5456 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5457
5458 /**
5459 * Real init
5460 */
5461
5462 memset (&data, 0, sizeof (hc_global_data_t));
5463
5464 time_t proc_start;
5465
5466 time (&proc_start);
5467
5468 data.proc_start = proc_start;
5469
5470 int myargc = argc;
5471 char **myargv = argv;
5472
5473 hc_thread_mutex_init (mux_dispatcher);
5474 hc_thread_mutex_init (mux_counter);
5475 hc_thread_mutex_init (mux_display);
5476 hc_thread_mutex_init (mux_adl);
5477
5478 /**
5479 * commandline parameters
5480 */
5481
5482 uint usage = USAGE;
5483 uint version = VERSION;
5484 uint quiet = QUIET;
5485 uint benchmark = BENCHMARK;
5486 uint benchmark_repeats = BENCHMARK_REPEATS;
5487 uint show = SHOW;
5488 uint left = LEFT;
5489 uint username = USERNAME;
5490 uint remove = REMOVE;
5491 uint remove_timer = REMOVE_TIMER;
5492 u64 skip = SKIP;
5493 u64 limit = LIMIT;
5494 uint keyspace = KEYSPACE;
5495 uint potfile_disable = POTFILE_DISABLE;
5496 uint debug_mode = DEBUG_MODE;
5497 char *debug_file = NULL;
5498 char *induction_dir = NULL;
5499 char *outfile_check_dir = NULL;
5500 uint force = FORCE;
5501 uint runtime = RUNTIME;
5502 uint hash_mode = HASH_MODE;
5503 uint attack_mode = ATTACK_MODE;
5504 uint markov_disable = MARKOV_DISABLE;
5505 uint markov_classic = MARKOV_CLASSIC;
5506 uint markov_threshold = MARKOV_THRESHOLD;
5507 char *markov_hcstat = NULL;
5508 char *outfile = NULL;
5509 uint outfile_format = OUTFILE_FORMAT;
5510 uint outfile_autohex = OUTFILE_AUTOHEX;
5511 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5512 uint restore = RESTORE;
5513 uint restore_timer = RESTORE_TIMER;
5514 uint restore_disable = RESTORE_DISABLE;
5515 uint status = STATUS;
5516 uint status_timer = STATUS_TIMER;
5517 uint status_automat = STATUS_AUTOMAT;
5518 uint loopback = LOOPBACK;
5519 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5520 char *session = NULL;
5521 uint hex_charset = HEX_CHARSET;
5522 uint hex_salt = HEX_SALT;
5523 uint hex_wordlist = HEX_WORDLIST;
5524 uint rp_gen = RP_GEN;
5525 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5526 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5527 uint rp_gen_seed = RP_GEN_SEED;
5528 char *rule_buf_l = (char *) RULE_BUF_L;
5529 char *rule_buf_r = (char *) RULE_BUF_R;
5530 uint increment = INCREMENT;
5531 uint increment_min = INCREMENT_MIN;
5532 uint increment_max = INCREMENT_MAX;
5533 char *cpu_affinity = NULL;
5534 OCL_PTR *ocl = NULL;
5535 char *opencl_devices = NULL;
5536 char *opencl_platforms = NULL;
5537 char *opencl_device_types = NULL;
5538 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5539 char *truecrypt_keyfiles = NULL;
5540 uint workload_profile = WORKLOAD_PROFILE;
5541 uint kernel_accel = KERNEL_ACCEL;
5542 uint kernel_loops = KERNEL_LOOPS;
5543 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5544 #ifdef HAVE_HWMON
5545 uint gpu_temp_abort = GPU_TEMP_ABORT;
5546 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5547 #ifdef HAVE_ADL
5548 uint powertune_enable = POWERTUNE_ENABLE;
5549 #endif
5550 #endif
5551 uint logfile_disable = LOGFILE_DISABLE;
5552 uint segment_size = SEGMENT_SIZE;
5553 uint scrypt_tmto = SCRYPT_TMTO;
5554 char separator = SEPARATOR;
5555 uint bitmap_min = BITMAP_MIN;
5556 uint bitmap_max = BITMAP_MAX;
5557 char *custom_charset_1 = NULL;
5558 char *custom_charset_2 = NULL;
5559 char *custom_charset_3 = NULL;
5560 char *custom_charset_4 = NULL;
5561
5562 #define IDX_HELP 'h'
5563 #define IDX_VERSION 'V'
5564 #define IDX_VERSION_LOWER 'v'
5565 #define IDX_QUIET 0xff02
5566 #define IDX_SHOW 0xff03
5567 #define IDX_LEFT 0xff04
5568 #define IDX_REMOVE 0xff05
5569 #define IDX_REMOVE_TIMER 0xff37
5570 #define IDX_SKIP 's'
5571 #define IDX_LIMIT 'l'
5572 #define IDX_KEYSPACE 0xff35
5573 #define IDX_POTFILE_DISABLE 0xff06
5574 #define IDX_DEBUG_MODE 0xff43
5575 #define IDX_DEBUG_FILE 0xff44
5576 #define IDX_INDUCTION_DIR 0xff46
5577 #define IDX_OUTFILE_CHECK_DIR 0xff47
5578 #define IDX_USERNAME 0xff07
5579 #define IDX_FORCE 0xff08
5580 #define IDX_RUNTIME 0xff09
5581 #define IDX_BENCHMARK 'b'
5582 #define IDX_BENCHMARK_REPEATS 0xff78
5583 #define IDX_HASH_MODE 'm'
5584 #define IDX_ATTACK_MODE 'a'
5585 #define IDX_RP_FILE 'r'
5586 #define IDX_RP_GEN 'g'
5587 #define IDX_RP_GEN_FUNC_MIN 0xff10
5588 #define IDX_RP_GEN_FUNC_MAX 0xff11
5589 #define IDX_RP_GEN_SEED 0xff34
5590 #define IDX_RULE_BUF_L 'j'
5591 #define IDX_RULE_BUF_R 'k'
5592 #define IDX_INCREMENT 'i'
5593 #define IDX_INCREMENT_MIN 0xff12
5594 #define IDX_INCREMENT_MAX 0xff13
5595 #define IDX_OUTFILE 'o'
5596 #define IDX_OUTFILE_FORMAT 0xff14
5597 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5598 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5599 #define IDX_RESTORE 0xff15
5600 #define IDX_RESTORE_DISABLE 0xff27
5601 #define IDX_STATUS 0xff17
5602 #define IDX_STATUS_TIMER 0xff18
5603 #define IDX_STATUS_AUTOMAT 0xff50
5604 #define IDX_LOOPBACK 0xff38
5605 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5606 #define IDX_SESSION 0xff19
5607 #define IDX_HEX_CHARSET 0xff20
5608 #define IDX_HEX_SALT 0xff21
5609 #define IDX_HEX_WORDLIST 0xff40
5610 #define IDX_MARKOV_DISABLE 0xff22
5611 #define IDX_MARKOV_CLASSIC 0xff23
5612 #define IDX_MARKOV_THRESHOLD 't'
5613 #define IDX_MARKOV_HCSTAT 0xff24
5614 #define IDX_CPU_AFFINITY 0xff25
5615 #define IDX_OPENCL_DEVICES 'd'
5616 #define IDX_OPENCL_PLATFORMS 0xff72
5617 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5618 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5619 #define IDX_WORKLOAD_PROFILE 'w'
5620 #define IDX_KERNEL_ACCEL 'n'
5621 #define IDX_KERNEL_LOOPS 'u'
5622 #define IDX_GPU_TEMP_DISABLE 0xff29
5623 #define IDX_GPU_TEMP_ABORT 0xff30
5624 #define IDX_GPU_TEMP_RETAIN 0xff31
5625 #define IDX_POWERTUNE_ENABLE 0xff41
5626 #define IDX_LOGFILE_DISABLE 0xff51
5627 #define IDX_TRUECRYPT_KEYFILES 0xff52
5628 #define IDX_SCRYPT_TMTO 0xff61
5629 #define IDX_SEGMENT_SIZE 'c'
5630 #define IDX_SEPARATOR 'p'
5631 #define IDX_BITMAP_MIN 0xff70
5632 #define IDX_BITMAP_MAX 0xff71
5633 #define IDX_CUSTOM_CHARSET_1 '1'
5634 #define IDX_CUSTOM_CHARSET_2 '2'
5635 #define IDX_CUSTOM_CHARSET_3 '3'
5636 #define IDX_CUSTOM_CHARSET_4 '4'
5637
5638 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5639
5640 struct option long_options[] =
5641 {
5642 {"help", no_argument, 0, IDX_HELP},
5643 {"version", no_argument, 0, IDX_VERSION},
5644 {"quiet", no_argument, 0, IDX_QUIET},
5645 {"show", no_argument, 0, IDX_SHOW},
5646 {"left", no_argument, 0, IDX_LEFT},
5647 {"username", no_argument, 0, IDX_USERNAME},
5648 {"remove", no_argument, 0, IDX_REMOVE},
5649 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5650 {"skip", required_argument, 0, IDX_SKIP},
5651 {"limit", required_argument, 0, IDX_LIMIT},
5652 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5653 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5654 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5655 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5656 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5657 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5658 {"force", no_argument, 0, IDX_FORCE},
5659 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5660 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5661 {"restore", no_argument, 0, IDX_RESTORE},
5662 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5663 {"status", no_argument, 0, IDX_STATUS},
5664 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5665 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5666 {"loopback", no_argument, 0, IDX_LOOPBACK},
5667 {"weak-hash-threshold",
5668 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5669 {"session", required_argument, 0, IDX_SESSION},
5670 {"runtime", required_argument, 0, IDX_RUNTIME},
5671 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5672 {"generate-rules-func-min",
5673 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5674 {"generate-rules-func-max",
5675 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5676 {"generate-rules-seed",
5677 required_argument, 0, IDX_RP_GEN_SEED},
5678 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5679 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5680 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5681 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5682 {"rules-file", required_argument, 0, IDX_RP_FILE},
5683 {"outfile", required_argument, 0, IDX_OUTFILE},
5684 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5685 {"outfile-autohex-disable",
5686 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5687 {"outfile-check-timer",
5688 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5689 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5690 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5691 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5692 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5693 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5694 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5695 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5696 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5697 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5698 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5699 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5700 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5701 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5702 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5703 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5704 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5705 #ifdef HAVE_HWMON
5706 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5707 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5708 #ifdef HAVE_ADL
5709 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5710 #endif
5711 #endif // HAVE_HWMON
5712 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5713 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5714 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5715 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5716 // deprecated
5717 {"seperator", required_argument, 0, IDX_SEPARATOR},
5718 {"separator", required_argument, 0, IDX_SEPARATOR},
5719 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5720 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5721 {"increment", no_argument, 0, IDX_INCREMENT},
5722 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5723 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5724 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5725 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5726 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5727 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5728
5729 {0, 0, 0, 0}
5730 };
5731
5732 uint rp_files_cnt = 0;
5733
5734 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5735
5736 int option_index = 0;
5737 int c = -1;
5738
5739 optind = 1;
5740 optopt = 0;
5741
5742 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5743 {
5744 switch (c)
5745 {
5746 case IDX_HELP: usage = 1; break;
5747 case IDX_VERSION:
5748 case IDX_VERSION_LOWER: version = 1; break;
5749 case IDX_RESTORE: restore = 1; break;
5750 case IDX_SESSION: session = optarg; break;
5751 case IDX_SHOW: show = 1; break;
5752 case IDX_LEFT: left = 1; break;
5753 case '?': return (-1);
5754 }
5755 }
5756
5757 if (optopt != 0)
5758 {
5759 log_error ("ERROR: Invalid argument specified");
5760
5761 return (-1);
5762 }
5763
5764 /**
5765 * exit functions
5766 */
5767
5768 if (version)
5769 {
5770 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5771
5772 return (0);
5773 }
5774
5775 if (usage)
5776 {
5777 usage_big_print (PROGNAME);
5778
5779 return (0);
5780 }
5781
5782 /**
5783 * session needs to be set, always!
5784 */
5785
5786 if (session == NULL) session = (char *) PROGNAME;
5787
5788 /**
5789 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5790 */
5791
5792 char *exec_path = get_exec_path ();
5793
5794 #ifdef LINUX
5795
5796 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5797 char *resolved_exec_path = realpath (exec_path, NULL);
5798
5799 char *install_dir = get_install_dir (resolved_exec_path);
5800 char *profile_dir = NULL;
5801 char *session_dir = NULL;
5802 char *shared_dir = NULL;
5803
5804 if (strcmp (install_dir, resolved_install_folder) == 0)
5805 {
5806 struct passwd *pw = getpwuid (getuid ());
5807
5808 const char *homedir = pw->pw_dir;
5809
5810 profile_dir = get_profile_dir (homedir);
5811 session_dir = get_session_dir (profile_dir);
5812 shared_dir = strdup (SHARED_FOLDER);
5813
5814 mkdir (profile_dir, 0700);
5815 mkdir (session_dir, 0700);
5816 }
5817 else
5818 {
5819 profile_dir = install_dir;
5820 session_dir = install_dir;
5821 shared_dir = install_dir;
5822 }
5823
5824 myfree (resolved_install_folder);
5825 myfree (resolved_exec_path);
5826
5827 #else
5828
5829 char *install_dir = get_install_dir (exec_path);
5830 char *profile_dir = install_dir;
5831 char *session_dir = install_dir;
5832 char *shared_dir = install_dir;
5833
5834 #endif
5835
5836 data.install_dir = install_dir;
5837 data.profile_dir = profile_dir;
5838 data.session_dir = session_dir;
5839 data.shared_dir = shared_dir;
5840
5841 myfree (exec_path);
5842
5843 /**
5844 * kernel cache, we need to make sure folder exist
5845 */
5846
5847 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5848
5849 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5850
5851 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5852
5853 mkdir (kernels_folder, 0700);
5854
5855 myfree (kernels_folder);
5856
5857 /**
5858 * session
5859 */
5860
5861 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5862
5863 data.session = session;
5864
5865 char *eff_restore_file = (char *) mymalloc (session_size);
5866 char *new_restore_file = (char *) mymalloc (session_size);
5867
5868 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5869 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5870
5871 data.eff_restore_file = eff_restore_file;
5872 data.new_restore_file = new_restore_file;
5873
5874 if (((show == 1) || (left == 1)) && (restore == 1))
5875 {
5876 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5877 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5878
5879 return (-1);
5880 }
5881
5882 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5883 if ((show == 1) || (left == 1))
5884 {
5885 restore_disable = 1;
5886
5887 restore = 0;
5888 }
5889
5890 data.restore_disable = restore_disable;
5891
5892 restore_data_t *rd = init_restore (argc, argv);
5893
5894 data.rd = rd;
5895
5896 /**
5897 * restore file
5898 */
5899
5900 if (restore == 1)
5901 {
5902 read_restore (eff_restore_file, rd);
5903
5904 if (rd->version_bin < RESTORE_MIN)
5905 {
5906 log_error ("ERROR: Incompatible restore-file version");
5907
5908 return (-1);
5909 }
5910
5911 myargc = rd->argc;
5912 myargv = rd->argv;
5913
5914 #ifdef _POSIX
5915 rd->pid = getpid ();
5916 #elif _WIN
5917 rd->pid = GetCurrentProcessId ();
5918 #endif
5919 }
5920
5921 uint hash_mode_chgd = 0;
5922 uint runtime_chgd = 0;
5923 uint kernel_loops_chgd = 0;
5924 uint kernel_accel_chgd = 0;
5925 uint attack_mode_chgd = 0;
5926 uint outfile_format_chgd = 0;
5927 uint rp_gen_seed_chgd = 0;
5928 uint remove_timer_chgd = 0;
5929 uint increment_min_chgd = 0;
5930 uint increment_max_chgd = 0;
5931 uint workload_profile_chgd = 0;
5932 uint opencl_vector_width_chgd = 0;
5933
5934 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5935 uint gpu_temp_retain_chgd = 0;
5936 uint gpu_temp_abort_chgd = 0;
5937 #endif
5938
5939 optind = 1;
5940 optopt = 0;
5941 option_index = 0;
5942
5943 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5944 {
5945 switch (c)
5946 {
5947 //case IDX_HELP: usage = 1; break;
5948 //case IDX_VERSION: version = 1; break;
5949 //case IDX_RESTORE: restore = 1; break;
5950 case IDX_QUIET: quiet = 1; break;
5951 //case IDX_SHOW: show = 1; break;
5952 case IDX_SHOW: break;
5953 //case IDX_LEFT: left = 1; break;
5954 case IDX_LEFT: break;
5955 case IDX_USERNAME: username = 1; break;
5956 case IDX_REMOVE: remove = 1; break;
5957 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5958 remove_timer_chgd = 1; break;
5959 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5960 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5961 case IDX_DEBUG_FILE: debug_file = optarg; break;
5962 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5963 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5964 case IDX_FORCE: force = 1; break;
5965 case IDX_SKIP: skip = atoll (optarg); break;
5966 case IDX_LIMIT: limit = atoll (optarg); break;
5967 case IDX_KEYSPACE: keyspace = 1; break;
5968 case IDX_BENCHMARK: benchmark = 1; break;
5969 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5970 case IDX_RESTORE: break;
5971 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5972 case IDX_STATUS: status = 1; break;
5973 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5974 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5975 case IDX_LOOPBACK: loopback = 1; break;
5976 case IDX_WEAK_HASH_THRESHOLD:
5977 weak_hash_threshold = atoi (optarg); break;
5978 //case IDX_SESSION: session = optarg; break;
5979 case IDX_SESSION: break;
5980 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5981 hash_mode_chgd = 1; break;
5982 case IDX_RUNTIME: runtime = atoi (optarg);
5983 runtime_chgd = 1; break;
5984 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5985 attack_mode_chgd = 1; break;
5986 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5987 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5988 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5989 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5990 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5991 rp_gen_seed_chgd = 1; break;
5992 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5993 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5994 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5995 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5996 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5997 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5998 case IDX_OUTFILE: outfile = optarg; break;
5999 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6000 outfile_format_chgd = 1; break;
6001 case IDX_OUTFILE_AUTOHEX_DISABLE:
6002 outfile_autohex = 0; break;
6003 case IDX_OUTFILE_CHECK_TIMER:
6004 outfile_check_timer = atoi (optarg); break;
6005 case IDX_HEX_CHARSET: hex_charset = 1; break;
6006 case IDX_HEX_SALT: hex_salt = 1; break;
6007 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6008 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6009 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6010 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6011 case IDX_OPENCL_DEVICE_TYPES:
6012 opencl_device_types = optarg; break;
6013 case IDX_OPENCL_VECTOR_WIDTH:
6014 opencl_vector_width = atoi (optarg);
6015 opencl_vector_width_chgd = 1; break;
6016 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6017 workload_profile_chgd = 1; break;
6018 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6019 kernel_accel_chgd = 1; break;
6020 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6021 kernel_loops_chgd = 1; break;
6022 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6023 #ifdef HAVE_HWMON
6024 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
6025 #ifdef HAVE_ADL
6026 gpu_temp_abort_chgd = 1;
6027 #endif
6028 break;
6029 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
6030 #ifdef HAVE_ADL
6031 gpu_temp_retain_chgd = 1;
6032 #endif
6033 break;
6034 #ifdef HAVE_ADL
6035 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6036 #endif
6037 #endif // HAVE_HWMON
6038 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6039 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6040 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6041 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6042 case IDX_SEPARATOR: separator = optarg[0]; break;
6043 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6044 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6045 case IDX_INCREMENT: increment = 1; break;
6046 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6047 increment_min_chgd = 1; break;
6048 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6049 increment_max_chgd = 1; break;
6050 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6051 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6052 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6053 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6054
6055 default:
6056 log_error ("ERROR: Invalid argument specified");
6057 return (-1);
6058 }
6059 }
6060
6061 if (optopt != 0)
6062 {
6063 log_error ("ERROR: Invalid argument specified");
6064
6065 return (-1);
6066 }
6067
6068 /**
6069 * Inform user things getting started,
6070 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6071 * - we do not need to check algorithm_pos
6072 */
6073
6074 if (quiet == 0)
6075 {
6076 if (benchmark == 1)
6077 {
6078 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
6079
6080 log_info ("");
6081 }
6082 else if (restore == 1)
6083 {
6084 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
6085
6086 log_info ("");
6087 }
6088 else
6089 {
6090 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
6091
6092 log_info ("");
6093 }
6094 }
6095
6096 /**
6097 * sanity check
6098 */
6099
6100 if (attack_mode > 7)
6101 {
6102 log_error ("ERROR: Invalid attack-mode specified");
6103
6104 return (-1);
6105 }
6106
6107 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6108 {
6109 log_error ("ERROR: Invalid runtime specified");
6110
6111 return (-1);
6112 }
6113
6114 if (hash_mode_chgd && hash_mode > 13100) // just added to remove compiler warnings for hash_mode_chgd
6115 {
6116 log_error ("ERROR: Invalid hash-type specified");
6117
6118 return (-1);
6119 }
6120
6121 // renamed hash modes
6122
6123 if (hash_mode_chgd)
6124 {
6125 int n = -1;
6126
6127 switch (hash_mode)
6128 {
6129 case 123: n = 124;
6130 break;
6131 }
6132
6133 if (n >= 0)
6134 {
6135 log_error ("Old -m specified, use -m %d instead", n);
6136
6137 return (-1);
6138 }
6139 }
6140
6141 if (username == 1)
6142 {
6143 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
6144 {
6145 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6146
6147 return (-1);
6148 }
6149 }
6150
6151 if (outfile_format > 16)
6152 {
6153 log_error ("ERROR: Invalid outfile-format specified");
6154
6155 return (-1);
6156 }
6157
6158 if (left == 1)
6159 {
6160 if (outfile_format_chgd == 1)
6161 {
6162 if (outfile_format > 1)
6163 {
6164 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6165
6166 return (-1);
6167 }
6168 }
6169 else
6170 {
6171 outfile_format = OUTFILE_FMT_HASH;
6172 }
6173 }
6174
6175 if (show == 1)
6176 {
6177 if (outfile_format_chgd == 1)
6178 {
6179 if ((outfile_format > 7) && (outfile_format < 16))
6180 {
6181 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6182
6183 return (-1);
6184 }
6185 }
6186 }
6187
6188 if (increment_min < INCREMENT_MIN)
6189 {
6190 log_error ("ERROR: Invalid increment-min specified");
6191
6192 return (-1);
6193 }
6194
6195 if (increment_max > INCREMENT_MAX)
6196 {
6197 log_error ("ERROR: Invalid increment-max specified");
6198
6199 return (-1);
6200 }
6201
6202 if (increment_min > increment_max)
6203 {
6204 log_error ("ERROR: Invalid increment-min specified");
6205
6206 return (-1);
6207 }
6208
6209 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6210 {
6211 log_error ("ERROR: increment is not allowed in attack-mode 0");
6212
6213 return (-1);
6214 }
6215
6216 if ((increment == 0) && (increment_min_chgd == 1))
6217 {
6218 log_error ("ERROR: increment-min is only supported together with increment switch");
6219
6220 return (-1);
6221 }
6222
6223 if ((increment == 0) && (increment_max_chgd == 1))
6224 {
6225 log_error ("ERROR: increment-max is only supported together with increment switch");
6226
6227 return (-1);
6228 }
6229
6230 if (rp_files_cnt && rp_gen)
6231 {
6232 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6233
6234 return (-1);
6235 }
6236
6237 if (rp_files_cnt || rp_gen)
6238 {
6239 if (attack_mode != ATTACK_MODE_STRAIGHT)
6240 {
6241 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6242
6243 return (-1);
6244 }
6245 }
6246
6247 if (rp_gen_func_min > rp_gen_func_max)
6248 {
6249 log_error ("ERROR: Invalid rp-gen-func-min specified");
6250
6251 return (-1);
6252 }
6253
6254 if (kernel_accel_chgd == 1 && kernel_loops_chgd == 0)
6255 {
6256 log_error ("ERROR: If kernel-accel is specified, kernel-loops need to be specified as well");
6257
6258 return (-1);
6259 }
6260
6261 if (kernel_loops_chgd == 1 && kernel_accel_chgd == 0)
6262 {
6263 log_error ("ERROR: If kernel-loops is specified, kernel-accel need to be specified as well");
6264
6265 return (-1);
6266 }
6267
6268 if (kernel_accel_chgd == 1)
6269 {
6270 if (kernel_accel < 1)
6271 {
6272 log_error ("ERROR: Invalid kernel-accel specified");
6273
6274 return (-1);
6275 }
6276
6277 if (kernel_accel > 1024)
6278 {
6279 log_error ("ERROR: Invalid kernel-accel specified");
6280
6281 return (-1);
6282 }
6283 }
6284
6285 if (kernel_loops_chgd == 1)
6286 {
6287 if (kernel_loops < 1)
6288 {
6289 log_error ("ERROR: Invalid kernel-loops specified");
6290
6291 return (-1);
6292 }
6293
6294 if (kernel_loops > 1024)
6295 {
6296 log_error ("ERROR: Invalid kernel-loops specified");
6297
6298 return (-1);
6299 }
6300 }
6301
6302 if ((workload_profile < 1) || (workload_profile > 3))
6303 {
6304 log_error ("ERROR: workload-profile %i not available", workload_profile);
6305
6306 return (-1);
6307 }
6308
6309 if ((opencl_vector_width != 0) && (opencl_vector_width != 1) && (opencl_vector_width != 2) && (opencl_vector_width != 4) && (opencl_vector_width != 8))
6310 {
6311 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6312
6313 return (-1);
6314 }
6315
6316 if (show == 1 || left == 1)
6317 {
6318 attack_mode = ATTACK_MODE_NONE;
6319
6320 if (remove == 1)
6321 {
6322 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6323
6324 return (-1);
6325 }
6326
6327 if (potfile_disable == 1)
6328 {
6329 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6330
6331 return (-1);
6332 }
6333 }
6334
6335 uint attack_kern = ATTACK_KERN_NONE;
6336
6337 switch (attack_mode)
6338 {
6339 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6340 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6341 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6342 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6343 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6344 }
6345
6346 if (benchmark == 0)
6347 {
6348 if (keyspace == 1)
6349 {
6350 int num_additional_params = 1;
6351
6352 if (attack_kern == ATTACK_KERN_COMBI)
6353 {
6354 num_additional_params = 2;
6355 }
6356
6357 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6358
6359 if (keyspace_wordlist_specified == 0) optind--;
6360 }
6361
6362 if (attack_kern == ATTACK_KERN_NONE)
6363 {
6364 if ((optind + 1) != myargc)
6365 {
6366 usage_mini_print (myargv[0]);
6367
6368 return (-1);
6369 }
6370 }
6371 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6372 {
6373 if ((optind + 1) > myargc)
6374 {
6375 usage_mini_print (myargv[0]);
6376
6377 return (-1);
6378 }
6379 }
6380 else if (attack_kern == ATTACK_KERN_COMBI)
6381 {
6382 if ((optind + 3) != myargc)
6383 {
6384 usage_mini_print (myargv[0]);
6385
6386 return (-1);
6387 }
6388 }
6389 else if (attack_kern == ATTACK_KERN_BF)
6390 {
6391 if ((optind + 1) > myargc)
6392 {
6393 usage_mini_print (myargv[0]);
6394
6395 return (-1);
6396 }
6397 }
6398 else
6399 {
6400 usage_mini_print (myargv[0]);
6401
6402 return (-1);
6403 }
6404 }
6405 else
6406 {
6407 if (myargv[optind] != 0)
6408 {
6409 log_error ("ERROR: Invalid argument for benchmark mode specified");
6410
6411 return (-1);
6412 }
6413
6414 if (attack_mode_chgd == 1)
6415 {
6416 if (attack_mode != ATTACK_MODE_BF)
6417 {
6418 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6419
6420 return (-1);
6421 }
6422 }
6423 }
6424
6425 if (skip != 0 && limit != 0)
6426 {
6427 limit += skip;
6428 }
6429
6430 if (keyspace == 1)
6431 {
6432 if (show == 1)
6433 {
6434 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6435
6436 return (-1);
6437 }
6438 else if (left == 1)
6439 {
6440 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6441
6442 return (-1);
6443 }
6444
6445 potfile_disable = 1;
6446
6447 restore_disable = 1;
6448
6449 restore = 0;
6450
6451 weak_hash_threshold = 0;
6452
6453 quiet = 1;
6454 }
6455
6456 if (remove_timer_chgd == 1)
6457 {
6458 if (remove == 0)
6459 {
6460 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6461
6462 return (-1);
6463 }
6464
6465 if (remove_timer < 1)
6466 {
6467 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6468
6469 return (-1);
6470 }
6471 }
6472
6473 if (loopback == 1)
6474 {
6475 if (attack_mode == ATTACK_MODE_BF)
6476 {
6477 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6478
6479 return (-1);
6480 }
6481 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6482 {
6483 if ((rp_files_cnt == 0) && (rp_gen == 0))
6484 {
6485 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6486
6487 return (-1);
6488 }
6489 }
6490 }
6491
6492 if (debug_mode > 0)
6493 {
6494 if (attack_mode != ATTACK_MODE_STRAIGHT)
6495 {
6496 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6497
6498 return (-1);
6499 }
6500
6501 if ((rp_files_cnt == 0) && (rp_gen == 0))
6502 {
6503 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6504
6505 return (-1);
6506 }
6507 }
6508
6509 if (debug_mode > 4)
6510 {
6511 log_error ("ERROR: Invalid debug-mode specified");
6512
6513 return (-1);
6514 }
6515
6516 if (debug_file != NULL)
6517 {
6518 if (debug_mode < 1)
6519 {
6520 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6521
6522 return (-1);
6523 }
6524 }
6525
6526 if (induction_dir != NULL)
6527 {
6528 if (attack_mode == ATTACK_MODE_BF)
6529 {
6530 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6531
6532 return (-1);
6533 }
6534 }
6535
6536 if (attack_mode != ATTACK_MODE_STRAIGHT)
6537 {
6538 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6539 {
6540 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6541
6542 return (-1);
6543 }
6544
6545 weak_hash_threshold = 0;
6546 }
6547
6548 /**
6549 * induction directory
6550 */
6551
6552 char *induction_directory = NULL;
6553
6554 if (attack_mode != ATTACK_MODE_BF)
6555 {
6556 if (induction_dir == NULL)
6557 {
6558 induction_directory = (char *) mymalloc (session_size);
6559
6560 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6561
6562 // create induction folder if it does not already exist
6563
6564 if (keyspace == 0)
6565 {
6566 if (rmdir (induction_directory) == -1)
6567 {
6568 if (errno == ENOENT)
6569 {
6570 // good, we can ignore
6571 }
6572 else if (errno == ENOTEMPTY)
6573 {
6574 char *induction_directory_mv = (char *) mymalloc (session_size);
6575
6576 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6577
6578 if (rename (induction_directory, induction_directory_mv) != 0)
6579 {
6580 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6581
6582 return (-1);
6583 }
6584 }
6585 else
6586 {
6587 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6588
6589 return (-1);
6590 }
6591 }
6592
6593 if (mkdir (induction_directory, 0700) == -1)
6594 {
6595 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6596
6597 return (-1);
6598 }
6599 }
6600 }
6601 else
6602 {
6603 induction_directory = induction_dir;
6604 }
6605 }
6606
6607 data.induction_directory = induction_directory;
6608
6609 /**
6610 * loopback
6611 */
6612
6613 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6614
6615 char *loopback_file = (char *) mymalloc (loopback_size);
6616
6617 /**
6618 * tuning db
6619 */
6620
6621 char tuning_db_file[256] = { 0 };
6622
6623 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6624
6625 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6626
6627 /**
6628 * outfile-check directory
6629 */
6630
6631 char *outfile_check_directory = NULL;
6632
6633 if (outfile_check_dir == NULL)
6634 {
6635 outfile_check_directory = (char *) mymalloc (session_size);
6636
6637 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6638 }
6639 else
6640 {
6641 outfile_check_directory = outfile_check_dir;
6642 }
6643
6644 data.outfile_check_directory = outfile_check_directory;
6645
6646 if (keyspace == 0)
6647 {
6648 struct stat outfile_check_stat;
6649
6650 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6651 {
6652 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6653
6654 if (is_dir == 0)
6655 {
6656 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6657
6658 return (-1);
6659 }
6660 }
6661 else if (outfile_check_dir == NULL)
6662 {
6663 if (mkdir (outfile_check_directory, 0700) == -1)
6664 {
6665 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6666
6667 return (-1);
6668 }
6669 }
6670 }
6671
6672 /**
6673 * special other stuff
6674 */
6675
6676 if (hash_mode == 9710)
6677 {
6678 outfile_format = 5;
6679 outfile_format_chgd = 1;
6680 }
6681
6682 if (hash_mode == 9810)
6683 {
6684 outfile_format = 5;
6685 outfile_format_chgd = 1;
6686 }
6687
6688 if (hash_mode == 10410)
6689 {
6690 outfile_format = 5;
6691 outfile_format_chgd = 1;
6692 }
6693
6694 /**
6695 * store stuff
6696 */
6697
6698 data.hash_mode = hash_mode;
6699 data.restore = restore;
6700 data.restore_timer = restore_timer;
6701 data.restore_disable = restore_disable;
6702 data.status = status;
6703 data.status_timer = status_timer;
6704 data.status_automat = status_automat;
6705 data.loopback = loopback;
6706 data.runtime = runtime;
6707 data.remove = remove;
6708 data.remove_timer = remove_timer;
6709 data.debug_mode = debug_mode;
6710 data.debug_file = debug_file;
6711 data.username = username;
6712 data.quiet = quiet;
6713 data.outfile = outfile;
6714 data.outfile_format = outfile_format;
6715 data.outfile_autohex = outfile_autohex;
6716 data.hex_charset = hex_charset;
6717 data.hex_salt = hex_salt;
6718 data.hex_wordlist = hex_wordlist;
6719 data.separator = separator;
6720 data.rp_files = rp_files;
6721 data.rp_files_cnt = rp_files_cnt;
6722 data.rp_gen = rp_gen;
6723 data.rp_gen_seed = rp_gen_seed;
6724 data.force = force;
6725 data.benchmark = benchmark;
6726 data.benchmark_repeats = benchmark_repeats;
6727 data.skip = skip;
6728 data.limit = limit;
6729 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6730 data.powertune_enable = powertune_enable;
6731 #endif
6732 data.logfile_disable = logfile_disable;
6733 data.truecrypt_keyfiles = truecrypt_keyfiles;
6734 data.scrypt_tmto = scrypt_tmto;
6735 data.workload_profile = workload_profile;
6736
6737 /**
6738 * cpu affinity
6739 */
6740
6741 if (cpu_affinity)
6742 {
6743 set_cpu_affinity (cpu_affinity);
6744 }
6745
6746 if (rp_gen_seed_chgd == 0)
6747 {
6748 srand (proc_start);
6749 }
6750 else
6751 {
6752 srand (rp_gen_seed);
6753 }
6754
6755 /**
6756 * logfile init
6757 */
6758
6759 if (logfile_disable == 0)
6760 {
6761 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6762
6763 char *logfile = (char *) mymalloc (logfile_size);
6764
6765 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6766
6767 data.logfile = logfile;
6768
6769 char *topid = logfile_generate_topid ();
6770
6771 data.topid = topid;
6772 }
6773
6774 // logfile_append() checks for logfile_disable internally to make it easier from here
6775
6776 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6777 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6778 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6779 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6780 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6781 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6782 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6783 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6784 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6785 #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));
6786
6787 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6788 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6789 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6790 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6791 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6792 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6793 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6794 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6795
6796 logfile_top_msg ("START");
6797
6798 logfile_top_uint (attack_mode);
6799 logfile_top_uint (attack_kern);
6800 logfile_top_uint (benchmark);
6801 logfile_top_uint (benchmark_repeats);
6802 logfile_top_uint (bitmap_min);
6803 logfile_top_uint (bitmap_max);
6804 logfile_top_uint (debug_mode);
6805 logfile_top_uint (force);
6806 logfile_top_uint (kernel_accel);
6807 logfile_top_uint (kernel_loops);
6808 logfile_top_uint (gpu_temp_disable);
6809 #ifdef HAVE_HWMON
6810 logfile_top_uint (gpu_temp_abort);
6811 logfile_top_uint (gpu_temp_retain);
6812 #endif
6813 logfile_top_uint (hash_mode);
6814 logfile_top_uint (hex_charset);
6815 logfile_top_uint (hex_salt);
6816 logfile_top_uint (hex_wordlist);
6817 logfile_top_uint (increment);
6818 logfile_top_uint (increment_max);
6819 logfile_top_uint (increment_min);
6820 logfile_top_uint (keyspace);
6821 logfile_top_uint (left);
6822 logfile_top_uint (logfile_disable);
6823 logfile_top_uint (loopback);
6824 logfile_top_uint (markov_classic);
6825 logfile_top_uint (markov_disable);
6826 logfile_top_uint (markov_threshold);
6827 logfile_top_uint (outfile_autohex);
6828 logfile_top_uint (outfile_check_timer);
6829 logfile_top_uint (outfile_format);
6830 logfile_top_uint (potfile_disable);
6831 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6832 logfile_top_uint (powertune_enable);
6833 #endif
6834 logfile_top_uint (scrypt_tmto);
6835 logfile_top_uint (quiet);
6836 logfile_top_uint (remove);
6837 logfile_top_uint (remove_timer);
6838 logfile_top_uint (restore);
6839 logfile_top_uint (restore_disable);
6840 logfile_top_uint (restore_timer);
6841 logfile_top_uint (rp_gen);
6842 logfile_top_uint (rp_gen_func_max);
6843 logfile_top_uint (rp_gen_func_min);
6844 logfile_top_uint (rp_gen_seed);
6845 logfile_top_uint (runtime);
6846 logfile_top_uint (segment_size);
6847 logfile_top_uint (show);
6848 logfile_top_uint (status);
6849 logfile_top_uint (status_automat);
6850 logfile_top_uint (status_timer);
6851 logfile_top_uint (usage);
6852 logfile_top_uint (username);
6853 logfile_top_uint (version);
6854 logfile_top_uint (weak_hash_threshold);
6855 logfile_top_uint (workload_profile);
6856 logfile_top_uint64 (limit);
6857 logfile_top_uint64 (skip);
6858 logfile_top_char (separator);
6859 logfile_top_string (cpu_affinity);
6860 logfile_top_string (custom_charset_1);
6861 logfile_top_string (custom_charset_2);
6862 logfile_top_string (custom_charset_3);
6863 logfile_top_string (custom_charset_4);
6864 logfile_top_string (debug_file);
6865 logfile_top_string (opencl_devices);
6866 logfile_top_string (opencl_platforms);
6867 logfile_top_string (opencl_device_types);
6868 logfile_top_uint (opencl_vector_width);
6869 logfile_top_string (induction_dir);
6870 logfile_top_string (markov_hcstat);
6871 logfile_top_string (outfile);
6872 logfile_top_string (outfile_check_dir);
6873 logfile_top_string (rule_buf_l);
6874 logfile_top_string (rule_buf_r);
6875 logfile_top_string (session);
6876 logfile_top_string (truecrypt_keyfiles);
6877
6878 /**
6879 * Init OpenCL library loader
6880 */
6881
6882 if (keyspace == 0)
6883 {
6884 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6885
6886 ocl_init (ocl);
6887
6888 data.ocl = ocl;
6889 }
6890
6891 /**
6892 * OpenCL platform selection
6893 */
6894
6895 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6896
6897 /**
6898 * OpenCL device selection
6899 */
6900
6901 u32 devices_filter = setup_devices_filter (opencl_devices);
6902
6903 /**
6904 * OpenCL device type selection
6905 */
6906
6907 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6908
6909 /**
6910 * benchmark
6911 */
6912
6913 if (benchmark == 1)
6914 {
6915 /**
6916 * disable useless stuff for benchmark
6917 */
6918
6919 status_timer = 0;
6920 restore_timer = 0;
6921 restore_disable = 1;
6922 potfile_disable = 1;
6923 weak_hash_threshold = 0;
6924 gpu_temp_disable = 1;
6925
6926 data.status_timer = status_timer;
6927 data.restore_timer = restore_timer;
6928 data.restore_disable = restore_disable;
6929
6930 /**
6931 * force attack mode to be bruteforce
6932 */
6933
6934 attack_mode = ATTACK_MODE_BF;
6935 attack_kern = ATTACK_KERN_BF;
6936
6937 if (workload_profile_chgd == 0)
6938 {
6939 workload_profile = 3;
6940
6941 data.workload_profile = workload_profile;
6942 }
6943 }
6944
6945 /**
6946 * config
6947 */
6948
6949 uint hash_type = 0;
6950 uint salt_type = 0;
6951 uint attack_exec = 0;
6952 uint opts_type = 0;
6953 uint kern_type = 0;
6954 uint dgst_size = 0;
6955 uint esalt_size = 0;
6956 uint opti_type = 0;
6957 uint dgst_pos0 = -1;
6958 uint dgst_pos1 = -1;
6959 uint dgst_pos2 = -1;
6960 uint dgst_pos3 = -1;
6961
6962 int (*parse_func) (char *, uint, hash_t *);
6963 int (*sort_by_digest) (const void *, const void *);
6964
6965 uint algorithm_pos = 0;
6966 uint algorithm_max = 1;
6967
6968 uint *algorithms = default_benchmark_algorithms;
6969
6970 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6971
6972 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6973 {
6974 /*
6975 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6976 * the following algos are skipped entirely
6977 */
6978
6979 if (algorithm_pos > 0)
6980 {
6981 local_free (rd);
6982
6983 rd = init_restore (argc, argv);
6984
6985 data.rd = rd;
6986 }
6987
6988 /**
6989 * update hash_mode in case of multihash benchmark
6990 */
6991
6992 if (benchmark == 1)
6993 {
6994 if (hash_mode_chgd == 0)
6995 {
6996 hash_mode = algorithms[algorithm_pos];
6997
6998 data.hash_mode = hash_mode;
6999 }
7000
7001 quiet = 1;
7002
7003 data.quiet = quiet;
7004 }
7005
7006 switch (hash_mode)
7007 {
7008 case 0: hash_type = HASH_TYPE_MD5;
7009 salt_type = SALT_TYPE_NONE;
7010 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7011 opts_type = OPTS_TYPE_PT_GENERATE_LE
7012 | OPTS_TYPE_PT_ADD80
7013 | OPTS_TYPE_PT_ADDBITS14;
7014 kern_type = KERN_TYPE_MD5;
7015 dgst_size = DGST_SIZE_4_4;
7016 parse_func = md5_parse_hash;
7017 sort_by_digest = sort_by_digest_4_4;
7018 opti_type = OPTI_TYPE_ZERO_BYTE
7019 | OPTI_TYPE_PRECOMPUTE_INIT
7020 | OPTI_TYPE_PRECOMPUTE_MERKLE
7021 | OPTI_TYPE_MEET_IN_MIDDLE
7022 | OPTI_TYPE_EARLY_SKIP
7023 | OPTI_TYPE_NOT_ITERATED
7024 | OPTI_TYPE_NOT_SALTED
7025 | OPTI_TYPE_RAW_HASH;
7026 dgst_pos0 = 0;
7027 dgst_pos1 = 3;
7028 dgst_pos2 = 2;
7029 dgst_pos3 = 1;
7030 break;
7031
7032 case 10: hash_type = HASH_TYPE_MD5;
7033 salt_type = SALT_TYPE_INTERN;
7034 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7035 opts_type = OPTS_TYPE_PT_GENERATE_LE
7036 | OPTS_TYPE_ST_ADD80
7037 | OPTS_TYPE_ST_ADDBITS14;
7038 kern_type = KERN_TYPE_MD5_PWSLT;
7039 dgst_size = DGST_SIZE_4_4;
7040 parse_func = md5s_parse_hash;
7041 sort_by_digest = sort_by_digest_4_4;
7042 opti_type = OPTI_TYPE_ZERO_BYTE
7043 | OPTI_TYPE_PRECOMPUTE_INIT
7044 | OPTI_TYPE_PRECOMPUTE_MERKLE
7045 | OPTI_TYPE_MEET_IN_MIDDLE
7046 | OPTI_TYPE_EARLY_SKIP
7047 | OPTI_TYPE_NOT_ITERATED
7048 | OPTI_TYPE_APPENDED_SALT
7049 | OPTI_TYPE_RAW_HASH;
7050 dgst_pos0 = 0;
7051 dgst_pos1 = 3;
7052 dgst_pos2 = 2;
7053 dgst_pos3 = 1;
7054 break;
7055
7056 case 11: hash_type = HASH_TYPE_MD5;
7057 salt_type = SALT_TYPE_INTERN;
7058 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7059 opts_type = OPTS_TYPE_PT_GENERATE_LE
7060 | OPTS_TYPE_ST_ADD80
7061 | OPTS_TYPE_ST_ADDBITS14;
7062 kern_type = KERN_TYPE_MD5_PWSLT;
7063 dgst_size = DGST_SIZE_4_4;
7064 parse_func = joomla_parse_hash;
7065 sort_by_digest = sort_by_digest_4_4;
7066 opti_type = OPTI_TYPE_ZERO_BYTE
7067 | OPTI_TYPE_PRECOMPUTE_INIT
7068 | OPTI_TYPE_PRECOMPUTE_MERKLE
7069 | OPTI_TYPE_MEET_IN_MIDDLE
7070 | OPTI_TYPE_EARLY_SKIP
7071 | OPTI_TYPE_NOT_ITERATED
7072 | OPTI_TYPE_APPENDED_SALT
7073 | OPTI_TYPE_RAW_HASH;
7074 dgst_pos0 = 0;
7075 dgst_pos1 = 3;
7076 dgst_pos2 = 2;
7077 dgst_pos3 = 1;
7078 break;
7079
7080 case 12: hash_type = HASH_TYPE_MD5;
7081 salt_type = SALT_TYPE_INTERN;
7082 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7083 opts_type = OPTS_TYPE_PT_GENERATE_LE
7084 | OPTS_TYPE_ST_ADD80
7085 | OPTS_TYPE_ST_ADDBITS14;
7086 kern_type = KERN_TYPE_MD5_PWSLT;
7087 dgst_size = DGST_SIZE_4_4;
7088 parse_func = postgresql_parse_hash;
7089 sort_by_digest = sort_by_digest_4_4;
7090 opti_type = OPTI_TYPE_ZERO_BYTE
7091 | OPTI_TYPE_PRECOMPUTE_INIT
7092 | OPTI_TYPE_PRECOMPUTE_MERKLE
7093 | OPTI_TYPE_MEET_IN_MIDDLE
7094 | OPTI_TYPE_EARLY_SKIP
7095 | OPTI_TYPE_NOT_ITERATED
7096 | OPTI_TYPE_APPENDED_SALT
7097 | OPTI_TYPE_RAW_HASH;
7098 dgst_pos0 = 0;
7099 dgst_pos1 = 3;
7100 dgst_pos2 = 2;
7101 dgst_pos3 = 1;
7102 break;
7103
7104 case 20: hash_type = HASH_TYPE_MD5;
7105 salt_type = SALT_TYPE_INTERN;
7106 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7107 opts_type = OPTS_TYPE_PT_GENERATE_LE
7108 | OPTS_TYPE_PT_ADD80
7109 | OPTS_TYPE_PT_ADDBITS14;
7110 kern_type = KERN_TYPE_MD5_SLTPW;
7111 dgst_size = DGST_SIZE_4_4;
7112 parse_func = md5s_parse_hash;
7113 sort_by_digest = sort_by_digest_4_4;
7114 opti_type = OPTI_TYPE_ZERO_BYTE
7115 | OPTI_TYPE_PRECOMPUTE_INIT
7116 | OPTI_TYPE_PRECOMPUTE_MERKLE
7117 | OPTI_TYPE_EARLY_SKIP
7118 | OPTI_TYPE_NOT_ITERATED
7119 | OPTI_TYPE_PREPENDED_SALT
7120 | OPTI_TYPE_RAW_HASH;
7121 dgst_pos0 = 0;
7122 dgst_pos1 = 3;
7123 dgst_pos2 = 2;
7124 dgst_pos3 = 1;
7125 break;
7126
7127 case 21: hash_type = HASH_TYPE_MD5;
7128 salt_type = SALT_TYPE_INTERN;
7129 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7130 opts_type = OPTS_TYPE_PT_GENERATE_LE
7131 | OPTS_TYPE_PT_ADD80
7132 | OPTS_TYPE_PT_ADDBITS14;
7133 kern_type = KERN_TYPE_MD5_SLTPW;
7134 dgst_size = DGST_SIZE_4_4;
7135 parse_func = osc_parse_hash;
7136 sort_by_digest = sort_by_digest_4_4;
7137 opti_type = OPTI_TYPE_ZERO_BYTE
7138 | OPTI_TYPE_PRECOMPUTE_INIT
7139 | OPTI_TYPE_PRECOMPUTE_MERKLE
7140 | OPTI_TYPE_EARLY_SKIP
7141 | OPTI_TYPE_NOT_ITERATED
7142 | OPTI_TYPE_PREPENDED_SALT
7143 | OPTI_TYPE_RAW_HASH;
7144 dgst_pos0 = 0;
7145 dgst_pos1 = 3;
7146 dgst_pos2 = 2;
7147 dgst_pos3 = 1;
7148 break;
7149
7150 case 22: hash_type = HASH_TYPE_MD5;
7151 salt_type = SALT_TYPE_EMBEDDED;
7152 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7153 opts_type = OPTS_TYPE_PT_GENERATE_LE
7154 | OPTS_TYPE_PT_ADD80
7155 | OPTS_TYPE_PT_ADDBITS14;
7156 kern_type = KERN_TYPE_MD5_SLTPW;
7157 dgst_size = DGST_SIZE_4_4;
7158 parse_func = netscreen_parse_hash;
7159 sort_by_digest = sort_by_digest_4_4;
7160 opti_type = OPTI_TYPE_ZERO_BYTE
7161 | OPTI_TYPE_PRECOMPUTE_INIT
7162 | OPTI_TYPE_PRECOMPUTE_MERKLE
7163 | OPTI_TYPE_EARLY_SKIP
7164 | OPTI_TYPE_NOT_ITERATED
7165 | OPTI_TYPE_PREPENDED_SALT
7166 | OPTI_TYPE_RAW_HASH;
7167 dgst_pos0 = 0;
7168 dgst_pos1 = 3;
7169 dgst_pos2 = 2;
7170 dgst_pos3 = 1;
7171 break;
7172
7173 case 23: hash_type = HASH_TYPE_MD5;
7174 salt_type = SALT_TYPE_EMBEDDED;
7175 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7176 opts_type = OPTS_TYPE_PT_GENERATE_LE
7177 | OPTS_TYPE_PT_ADD80
7178 | OPTS_TYPE_PT_ADDBITS14;
7179 kern_type = KERN_TYPE_MD5_SLTPW;
7180 dgst_size = DGST_SIZE_4_4;
7181 parse_func = skype_parse_hash;
7182 sort_by_digest = sort_by_digest_4_4;
7183 opti_type = OPTI_TYPE_ZERO_BYTE
7184 | OPTI_TYPE_PRECOMPUTE_INIT
7185 | OPTI_TYPE_PRECOMPUTE_MERKLE
7186 | OPTI_TYPE_EARLY_SKIP
7187 | OPTI_TYPE_NOT_ITERATED
7188 | OPTI_TYPE_PREPENDED_SALT
7189 | OPTI_TYPE_RAW_HASH;
7190 dgst_pos0 = 0;
7191 dgst_pos1 = 3;
7192 dgst_pos2 = 2;
7193 dgst_pos3 = 1;
7194 break;
7195
7196 case 30: hash_type = HASH_TYPE_MD5;
7197 salt_type = SALT_TYPE_INTERN;
7198 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7199 opts_type = OPTS_TYPE_PT_GENERATE_LE
7200 | OPTS_TYPE_PT_UNICODE
7201 | OPTS_TYPE_ST_ADD80
7202 | OPTS_TYPE_ST_ADDBITS14;
7203 kern_type = KERN_TYPE_MD5_PWUSLT;
7204 dgst_size = DGST_SIZE_4_4;
7205 parse_func = md5s_parse_hash;
7206 sort_by_digest = sort_by_digest_4_4;
7207 opti_type = OPTI_TYPE_ZERO_BYTE
7208 | OPTI_TYPE_PRECOMPUTE_INIT
7209 | OPTI_TYPE_PRECOMPUTE_MERKLE
7210 | OPTI_TYPE_MEET_IN_MIDDLE
7211 | OPTI_TYPE_EARLY_SKIP
7212 | OPTI_TYPE_NOT_ITERATED
7213 | OPTI_TYPE_APPENDED_SALT
7214 | OPTI_TYPE_RAW_HASH;
7215 dgst_pos0 = 0;
7216 dgst_pos1 = 3;
7217 dgst_pos2 = 2;
7218 dgst_pos3 = 1;
7219 break;
7220
7221 case 40: hash_type = HASH_TYPE_MD5;
7222 salt_type = SALT_TYPE_INTERN;
7223 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7224 opts_type = OPTS_TYPE_PT_GENERATE_LE
7225 | OPTS_TYPE_PT_ADD80
7226 | OPTS_TYPE_PT_ADDBITS14
7227 | OPTS_TYPE_PT_UNICODE;
7228 kern_type = KERN_TYPE_MD5_SLTPWU;
7229 dgst_size = DGST_SIZE_4_4;
7230 parse_func = md5s_parse_hash;
7231 sort_by_digest = sort_by_digest_4_4;
7232 opti_type = OPTI_TYPE_ZERO_BYTE
7233 | OPTI_TYPE_PRECOMPUTE_INIT
7234 | OPTI_TYPE_PRECOMPUTE_MERKLE
7235 | OPTI_TYPE_EARLY_SKIP
7236 | OPTI_TYPE_NOT_ITERATED
7237 | OPTI_TYPE_PREPENDED_SALT
7238 | OPTI_TYPE_RAW_HASH;
7239 dgst_pos0 = 0;
7240 dgst_pos1 = 3;
7241 dgst_pos2 = 2;
7242 dgst_pos3 = 1;
7243 break;
7244
7245 case 50: hash_type = HASH_TYPE_MD5;
7246 salt_type = SALT_TYPE_INTERN;
7247 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7248 opts_type = OPTS_TYPE_PT_GENERATE_LE
7249 | OPTS_TYPE_ST_ADD80
7250 | OPTS_TYPE_ST_ADDBITS14;
7251 kern_type = KERN_TYPE_HMACMD5_PW;
7252 dgst_size = DGST_SIZE_4_4;
7253 parse_func = hmacmd5_parse_hash;
7254 sort_by_digest = sort_by_digest_4_4;
7255 opti_type = OPTI_TYPE_ZERO_BYTE
7256 | OPTI_TYPE_NOT_ITERATED;
7257 dgst_pos0 = 0;
7258 dgst_pos1 = 3;
7259 dgst_pos2 = 2;
7260 dgst_pos3 = 1;
7261 break;
7262
7263 case 60: hash_type = HASH_TYPE_MD5;
7264 salt_type = SALT_TYPE_INTERN;
7265 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7266 opts_type = OPTS_TYPE_PT_GENERATE_LE
7267 | OPTS_TYPE_PT_ADD80
7268 | OPTS_TYPE_PT_ADDBITS14;
7269 kern_type = KERN_TYPE_HMACMD5_SLT;
7270 dgst_size = DGST_SIZE_4_4;
7271 parse_func = hmacmd5_parse_hash;
7272 sort_by_digest = sort_by_digest_4_4;
7273 opti_type = OPTI_TYPE_ZERO_BYTE
7274 | OPTI_TYPE_NOT_ITERATED;
7275 dgst_pos0 = 0;
7276 dgst_pos1 = 3;
7277 dgst_pos2 = 2;
7278 dgst_pos3 = 1;
7279 break;
7280
7281 case 100: hash_type = HASH_TYPE_SHA1;
7282 salt_type = SALT_TYPE_NONE;
7283 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7284 opts_type = OPTS_TYPE_PT_GENERATE_BE
7285 | OPTS_TYPE_PT_ADD80
7286 | OPTS_TYPE_PT_ADDBITS15;
7287 kern_type = KERN_TYPE_SHA1;
7288 dgst_size = DGST_SIZE_4_5;
7289 parse_func = sha1_parse_hash;
7290 sort_by_digest = sort_by_digest_4_5;
7291 opti_type = OPTI_TYPE_ZERO_BYTE
7292 | OPTI_TYPE_PRECOMPUTE_INIT
7293 | OPTI_TYPE_PRECOMPUTE_MERKLE
7294 | OPTI_TYPE_EARLY_SKIP
7295 | OPTI_TYPE_NOT_ITERATED
7296 | OPTI_TYPE_NOT_SALTED
7297 | OPTI_TYPE_RAW_HASH;
7298 dgst_pos0 = 3;
7299 dgst_pos1 = 4;
7300 dgst_pos2 = 2;
7301 dgst_pos3 = 1;
7302 break;
7303
7304 case 101: hash_type = HASH_TYPE_SHA1;
7305 salt_type = SALT_TYPE_NONE;
7306 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7307 opts_type = OPTS_TYPE_PT_GENERATE_BE
7308 | OPTS_TYPE_PT_ADD80
7309 | OPTS_TYPE_PT_ADDBITS15;
7310 kern_type = KERN_TYPE_SHA1;
7311 dgst_size = DGST_SIZE_4_5;
7312 parse_func = sha1b64_parse_hash;
7313 sort_by_digest = sort_by_digest_4_5;
7314 opti_type = OPTI_TYPE_ZERO_BYTE
7315 | OPTI_TYPE_PRECOMPUTE_INIT
7316 | OPTI_TYPE_PRECOMPUTE_MERKLE
7317 | OPTI_TYPE_EARLY_SKIP
7318 | OPTI_TYPE_NOT_ITERATED
7319 | OPTI_TYPE_NOT_SALTED
7320 | OPTI_TYPE_RAW_HASH;
7321 dgst_pos0 = 3;
7322 dgst_pos1 = 4;
7323 dgst_pos2 = 2;
7324 dgst_pos3 = 1;
7325 break;
7326
7327 case 110: hash_type = HASH_TYPE_SHA1;
7328 salt_type = SALT_TYPE_INTERN;
7329 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7330 opts_type = OPTS_TYPE_PT_GENERATE_BE
7331 | OPTS_TYPE_ST_ADD80
7332 | OPTS_TYPE_ST_ADDBITS15;
7333 kern_type = KERN_TYPE_SHA1_PWSLT;
7334 dgst_size = DGST_SIZE_4_5;
7335 parse_func = sha1s_parse_hash;
7336 sort_by_digest = sort_by_digest_4_5;
7337 opti_type = OPTI_TYPE_ZERO_BYTE
7338 | OPTI_TYPE_PRECOMPUTE_INIT
7339 | OPTI_TYPE_PRECOMPUTE_MERKLE
7340 | OPTI_TYPE_EARLY_SKIP
7341 | OPTI_TYPE_NOT_ITERATED
7342 | OPTI_TYPE_APPENDED_SALT
7343 | OPTI_TYPE_RAW_HASH;
7344 dgst_pos0 = 3;
7345 dgst_pos1 = 4;
7346 dgst_pos2 = 2;
7347 dgst_pos3 = 1;
7348 break;
7349
7350 case 111: hash_type = HASH_TYPE_SHA1;
7351 salt_type = SALT_TYPE_EMBEDDED;
7352 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7353 opts_type = OPTS_TYPE_PT_GENERATE_BE
7354 | OPTS_TYPE_ST_ADD80
7355 | OPTS_TYPE_ST_ADDBITS15;
7356 kern_type = KERN_TYPE_SHA1_PWSLT;
7357 dgst_size = DGST_SIZE_4_5;
7358 parse_func = sha1b64s_parse_hash;
7359 sort_by_digest = sort_by_digest_4_5;
7360 opti_type = OPTI_TYPE_ZERO_BYTE
7361 | OPTI_TYPE_PRECOMPUTE_INIT
7362 | OPTI_TYPE_PRECOMPUTE_MERKLE
7363 | OPTI_TYPE_EARLY_SKIP
7364 | OPTI_TYPE_NOT_ITERATED
7365 | OPTI_TYPE_APPENDED_SALT
7366 | OPTI_TYPE_RAW_HASH;
7367 dgst_pos0 = 3;
7368 dgst_pos1 = 4;
7369 dgst_pos2 = 2;
7370 dgst_pos3 = 1;
7371 break;
7372
7373 case 112: hash_type = HASH_TYPE_SHA1;
7374 salt_type = SALT_TYPE_INTERN;
7375 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7376 opts_type = OPTS_TYPE_PT_GENERATE_BE
7377 | OPTS_TYPE_ST_ADD80
7378 | OPTS_TYPE_ST_ADDBITS15
7379 | OPTS_TYPE_ST_HEX;
7380 kern_type = KERN_TYPE_SHA1_PWSLT;
7381 dgst_size = DGST_SIZE_4_5;
7382 parse_func = oracles_parse_hash;
7383 sort_by_digest = sort_by_digest_4_5;
7384 opti_type = OPTI_TYPE_ZERO_BYTE
7385 | OPTI_TYPE_PRECOMPUTE_INIT
7386 | OPTI_TYPE_PRECOMPUTE_MERKLE
7387 | OPTI_TYPE_EARLY_SKIP
7388 | OPTI_TYPE_NOT_ITERATED
7389 | OPTI_TYPE_APPENDED_SALT
7390 | OPTI_TYPE_RAW_HASH;
7391 dgst_pos0 = 3;
7392 dgst_pos1 = 4;
7393 dgst_pos2 = 2;
7394 dgst_pos3 = 1;
7395 break;
7396
7397 case 120: hash_type = HASH_TYPE_SHA1;
7398 salt_type = SALT_TYPE_INTERN;
7399 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7400 opts_type = OPTS_TYPE_PT_GENERATE_BE
7401 | OPTS_TYPE_PT_ADD80
7402 | OPTS_TYPE_PT_ADDBITS15;
7403 kern_type = KERN_TYPE_SHA1_SLTPW;
7404 dgst_size = DGST_SIZE_4_5;
7405 parse_func = sha1s_parse_hash;
7406 sort_by_digest = sort_by_digest_4_5;
7407 opti_type = OPTI_TYPE_ZERO_BYTE
7408 | OPTI_TYPE_PRECOMPUTE_INIT
7409 | OPTI_TYPE_PRECOMPUTE_MERKLE
7410 | OPTI_TYPE_EARLY_SKIP
7411 | OPTI_TYPE_NOT_ITERATED
7412 | OPTI_TYPE_PREPENDED_SALT
7413 | OPTI_TYPE_RAW_HASH;
7414 dgst_pos0 = 3;
7415 dgst_pos1 = 4;
7416 dgst_pos2 = 2;
7417 dgst_pos3 = 1;
7418 break;
7419
7420 case 121: hash_type = HASH_TYPE_SHA1;
7421 salt_type = SALT_TYPE_INTERN;
7422 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7423 opts_type = OPTS_TYPE_PT_GENERATE_BE
7424 | OPTS_TYPE_PT_ADD80
7425 | OPTS_TYPE_PT_ADDBITS15
7426 | OPTS_TYPE_ST_LOWER;
7427 kern_type = KERN_TYPE_SHA1_SLTPW;
7428 dgst_size = DGST_SIZE_4_5;
7429 parse_func = smf_parse_hash;
7430 sort_by_digest = sort_by_digest_4_5;
7431 opti_type = OPTI_TYPE_ZERO_BYTE
7432 | OPTI_TYPE_PRECOMPUTE_INIT
7433 | OPTI_TYPE_PRECOMPUTE_MERKLE
7434 | OPTI_TYPE_EARLY_SKIP
7435 | OPTI_TYPE_NOT_ITERATED
7436 | OPTI_TYPE_PREPENDED_SALT
7437 | OPTI_TYPE_RAW_HASH;
7438 dgst_pos0 = 3;
7439 dgst_pos1 = 4;
7440 dgst_pos2 = 2;
7441 dgst_pos3 = 1;
7442 break;
7443
7444 case 122: hash_type = HASH_TYPE_SHA1;
7445 salt_type = SALT_TYPE_EMBEDDED;
7446 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7447 opts_type = OPTS_TYPE_PT_GENERATE_BE
7448 | OPTS_TYPE_PT_ADD80
7449 | OPTS_TYPE_PT_ADDBITS15
7450 | OPTS_TYPE_ST_HEX;
7451 kern_type = KERN_TYPE_SHA1_SLTPW;
7452 dgst_size = DGST_SIZE_4_5;
7453 parse_func = osx1_parse_hash;
7454 sort_by_digest = sort_by_digest_4_5;
7455 opti_type = OPTI_TYPE_ZERO_BYTE
7456 | OPTI_TYPE_PRECOMPUTE_INIT
7457 | OPTI_TYPE_PRECOMPUTE_MERKLE
7458 | OPTI_TYPE_EARLY_SKIP
7459 | OPTI_TYPE_NOT_ITERATED
7460 | OPTI_TYPE_PREPENDED_SALT
7461 | OPTI_TYPE_RAW_HASH;
7462 dgst_pos0 = 3;
7463 dgst_pos1 = 4;
7464 dgst_pos2 = 2;
7465 dgst_pos3 = 1;
7466 break;
7467
7468 case 124: hash_type = HASH_TYPE_SHA1;
7469 salt_type = SALT_TYPE_EMBEDDED;
7470 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7471 opts_type = OPTS_TYPE_PT_GENERATE_BE
7472 | OPTS_TYPE_PT_ADD80
7473 | OPTS_TYPE_PT_ADDBITS15;
7474 kern_type = KERN_TYPE_SHA1_SLTPW;
7475 dgst_size = DGST_SIZE_4_5;
7476 parse_func = djangosha1_parse_hash;
7477 sort_by_digest = sort_by_digest_4_5;
7478 opti_type = OPTI_TYPE_ZERO_BYTE
7479 | OPTI_TYPE_PRECOMPUTE_INIT
7480 | OPTI_TYPE_PRECOMPUTE_MERKLE
7481 | OPTI_TYPE_EARLY_SKIP
7482 | OPTI_TYPE_NOT_ITERATED
7483 | OPTI_TYPE_PREPENDED_SALT
7484 | OPTI_TYPE_RAW_HASH;
7485 dgst_pos0 = 3;
7486 dgst_pos1 = 4;
7487 dgst_pos2 = 2;
7488 dgst_pos3 = 1;
7489 break;
7490
7491 case 130: hash_type = HASH_TYPE_SHA1;
7492 salt_type = SALT_TYPE_INTERN;
7493 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7494 opts_type = OPTS_TYPE_PT_GENERATE_BE
7495 | OPTS_TYPE_PT_UNICODE
7496 | OPTS_TYPE_ST_ADD80
7497 | OPTS_TYPE_ST_ADDBITS15;
7498 kern_type = KERN_TYPE_SHA1_PWUSLT;
7499 dgst_size = DGST_SIZE_4_5;
7500 parse_func = sha1s_parse_hash;
7501 sort_by_digest = sort_by_digest_4_5;
7502 opti_type = OPTI_TYPE_ZERO_BYTE
7503 | OPTI_TYPE_PRECOMPUTE_INIT
7504 | OPTI_TYPE_PRECOMPUTE_MERKLE
7505 | OPTI_TYPE_EARLY_SKIP
7506 | OPTI_TYPE_NOT_ITERATED
7507 | OPTI_TYPE_APPENDED_SALT
7508 | OPTI_TYPE_RAW_HASH;
7509 dgst_pos0 = 3;
7510 dgst_pos1 = 4;
7511 dgst_pos2 = 2;
7512 dgst_pos3 = 1;
7513 break;
7514
7515 case 131: hash_type = HASH_TYPE_SHA1;
7516 salt_type = SALT_TYPE_EMBEDDED;
7517 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7518 opts_type = OPTS_TYPE_PT_GENERATE_BE
7519 | OPTS_TYPE_PT_UNICODE
7520 | OPTS_TYPE_PT_UPPER
7521 | OPTS_TYPE_ST_ADD80
7522 | OPTS_TYPE_ST_ADDBITS15
7523 | OPTS_TYPE_ST_HEX;
7524 kern_type = KERN_TYPE_SHA1_PWUSLT;
7525 dgst_size = DGST_SIZE_4_5;
7526 parse_func = mssql2000_parse_hash;
7527 sort_by_digest = sort_by_digest_4_5;
7528 opti_type = OPTI_TYPE_ZERO_BYTE
7529 | OPTI_TYPE_PRECOMPUTE_INIT
7530 | OPTI_TYPE_PRECOMPUTE_MERKLE
7531 | OPTI_TYPE_EARLY_SKIP
7532 | OPTI_TYPE_NOT_ITERATED
7533 | OPTI_TYPE_APPENDED_SALT
7534 | OPTI_TYPE_RAW_HASH;
7535 dgst_pos0 = 3;
7536 dgst_pos1 = 4;
7537 dgst_pos2 = 2;
7538 dgst_pos3 = 1;
7539 break;
7540
7541 case 132: hash_type = HASH_TYPE_SHA1;
7542 salt_type = SALT_TYPE_EMBEDDED;
7543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7544 opts_type = OPTS_TYPE_PT_GENERATE_BE
7545 | OPTS_TYPE_PT_UNICODE
7546 | OPTS_TYPE_ST_ADD80
7547 | OPTS_TYPE_ST_ADDBITS15
7548 | OPTS_TYPE_ST_HEX;
7549 kern_type = KERN_TYPE_SHA1_PWUSLT;
7550 dgst_size = DGST_SIZE_4_5;
7551 parse_func = mssql2005_parse_hash;
7552 sort_by_digest = sort_by_digest_4_5;
7553 opti_type = OPTI_TYPE_ZERO_BYTE
7554 | OPTI_TYPE_PRECOMPUTE_INIT
7555 | OPTI_TYPE_PRECOMPUTE_MERKLE
7556 | OPTI_TYPE_EARLY_SKIP
7557 | OPTI_TYPE_NOT_ITERATED
7558 | OPTI_TYPE_APPENDED_SALT
7559 | OPTI_TYPE_RAW_HASH;
7560 dgst_pos0 = 3;
7561 dgst_pos1 = 4;
7562 dgst_pos2 = 2;
7563 dgst_pos3 = 1;
7564 break;
7565
7566 case 133: hash_type = HASH_TYPE_SHA1;
7567 salt_type = SALT_TYPE_EMBEDDED;
7568 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7569 opts_type = OPTS_TYPE_PT_GENERATE_BE
7570 | OPTS_TYPE_PT_UNICODE
7571 | OPTS_TYPE_ST_ADD80
7572 | OPTS_TYPE_ST_ADDBITS15;
7573 kern_type = KERN_TYPE_SHA1_PWUSLT;
7574 dgst_size = DGST_SIZE_4_5;
7575 parse_func = peoplesoft_parse_hash;
7576 sort_by_digest = sort_by_digest_4_5;
7577 opti_type = OPTI_TYPE_ZERO_BYTE
7578 | OPTI_TYPE_PRECOMPUTE_INIT
7579 | OPTI_TYPE_PRECOMPUTE_MERKLE
7580 | OPTI_TYPE_EARLY_SKIP
7581 | OPTI_TYPE_NOT_ITERATED
7582 | OPTI_TYPE_APPENDED_SALT
7583 | OPTI_TYPE_RAW_HASH;
7584 dgst_pos0 = 3;
7585 dgst_pos1 = 4;
7586 dgst_pos2 = 2;
7587 dgst_pos3 = 1;
7588 break;
7589
7590 case 140: hash_type = HASH_TYPE_SHA1;
7591 salt_type = SALT_TYPE_INTERN;
7592 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7593 opts_type = OPTS_TYPE_PT_GENERATE_BE
7594 | OPTS_TYPE_PT_ADD80
7595 | OPTS_TYPE_PT_ADDBITS15
7596 | OPTS_TYPE_PT_UNICODE;
7597 kern_type = KERN_TYPE_SHA1_SLTPWU;
7598 dgst_size = DGST_SIZE_4_5;
7599 parse_func = sha1s_parse_hash;
7600 sort_by_digest = sort_by_digest_4_5;
7601 opti_type = OPTI_TYPE_ZERO_BYTE
7602 | OPTI_TYPE_PRECOMPUTE_INIT
7603 | OPTI_TYPE_PRECOMPUTE_MERKLE
7604 | OPTI_TYPE_EARLY_SKIP
7605 | OPTI_TYPE_NOT_ITERATED
7606 | OPTI_TYPE_PREPENDED_SALT
7607 | OPTI_TYPE_RAW_HASH;
7608 dgst_pos0 = 3;
7609 dgst_pos1 = 4;
7610 dgst_pos2 = 2;
7611 dgst_pos3 = 1;
7612 break;
7613
7614 case 141: hash_type = HASH_TYPE_SHA1;
7615 salt_type = SALT_TYPE_EMBEDDED;
7616 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7617 opts_type = OPTS_TYPE_PT_GENERATE_BE
7618 | OPTS_TYPE_PT_ADD80
7619 | OPTS_TYPE_PT_ADDBITS15
7620 | OPTS_TYPE_PT_UNICODE
7621 | OPTS_TYPE_ST_BASE64;
7622 kern_type = KERN_TYPE_SHA1_SLTPWU;
7623 dgst_size = DGST_SIZE_4_5;
7624 parse_func = episerver_parse_hash;
7625 sort_by_digest = sort_by_digest_4_5;
7626 opti_type = OPTI_TYPE_ZERO_BYTE
7627 | OPTI_TYPE_PRECOMPUTE_INIT
7628 | OPTI_TYPE_PRECOMPUTE_MERKLE
7629 | OPTI_TYPE_EARLY_SKIP
7630 | OPTI_TYPE_NOT_ITERATED
7631 | OPTI_TYPE_PREPENDED_SALT
7632 | OPTI_TYPE_RAW_HASH;
7633 dgst_pos0 = 3;
7634 dgst_pos1 = 4;
7635 dgst_pos2 = 2;
7636 dgst_pos3 = 1;
7637 break;
7638
7639 case 150: hash_type = HASH_TYPE_SHA1;
7640 salt_type = SALT_TYPE_INTERN;
7641 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7642 opts_type = OPTS_TYPE_PT_GENERATE_BE
7643 | OPTS_TYPE_ST_ADD80
7644 | OPTS_TYPE_ST_ADDBITS15;
7645 kern_type = KERN_TYPE_HMACSHA1_PW;
7646 dgst_size = DGST_SIZE_4_5;
7647 parse_func = hmacsha1_parse_hash;
7648 sort_by_digest = sort_by_digest_4_5;
7649 opti_type = OPTI_TYPE_ZERO_BYTE
7650 | OPTI_TYPE_NOT_ITERATED;
7651 dgst_pos0 = 3;
7652 dgst_pos1 = 4;
7653 dgst_pos2 = 2;
7654 dgst_pos3 = 1;
7655 break;
7656
7657 case 160: hash_type = HASH_TYPE_SHA1;
7658 salt_type = SALT_TYPE_INTERN;
7659 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7660 opts_type = OPTS_TYPE_PT_GENERATE_BE
7661 | OPTS_TYPE_PT_ADD80
7662 | OPTS_TYPE_PT_ADDBITS15;
7663 kern_type = KERN_TYPE_HMACSHA1_SLT;
7664 dgst_size = DGST_SIZE_4_5;
7665 parse_func = hmacsha1_parse_hash;
7666 sort_by_digest = sort_by_digest_4_5;
7667 opti_type = OPTI_TYPE_ZERO_BYTE
7668 | OPTI_TYPE_NOT_ITERATED;
7669 dgst_pos0 = 3;
7670 dgst_pos1 = 4;
7671 dgst_pos2 = 2;
7672 dgst_pos3 = 1;
7673 break;
7674
7675 case 190: hash_type = HASH_TYPE_SHA1;
7676 salt_type = SALT_TYPE_NONE;
7677 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7678 opts_type = OPTS_TYPE_PT_GENERATE_BE
7679 | OPTS_TYPE_PT_ADD80
7680 | OPTS_TYPE_PT_ADDBITS15;
7681 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7682 dgst_size = DGST_SIZE_4_5;
7683 parse_func = sha1linkedin_parse_hash;
7684 sort_by_digest = sort_by_digest_4_5;
7685 opti_type = OPTI_TYPE_ZERO_BYTE
7686 | OPTI_TYPE_PRECOMPUTE_INIT
7687 | OPTI_TYPE_EARLY_SKIP
7688 | OPTI_TYPE_NOT_ITERATED
7689 | OPTI_TYPE_NOT_SALTED;
7690 dgst_pos0 = 0;
7691 dgst_pos1 = 4;
7692 dgst_pos2 = 3;
7693 dgst_pos3 = 2;
7694 break;
7695
7696 case 200: hash_type = HASH_TYPE_MYSQL;
7697 salt_type = SALT_TYPE_NONE;
7698 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7699 opts_type = 0;
7700 kern_type = KERN_TYPE_MYSQL;
7701 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7702 parse_func = mysql323_parse_hash;
7703 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7704 opti_type = OPTI_TYPE_ZERO_BYTE;
7705 dgst_pos0 = 0;
7706 dgst_pos1 = 1;
7707 dgst_pos2 = 2;
7708 dgst_pos3 = 3;
7709 break;
7710
7711 case 300: hash_type = HASH_TYPE_SHA1;
7712 salt_type = SALT_TYPE_NONE;
7713 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7714 opts_type = OPTS_TYPE_PT_GENERATE_BE
7715 | OPTS_TYPE_PT_ADD80
7716 | OPTS_TYPE_PT_ADDBITS15;
7717 kern_type = KERN_TYPE_MYSQL41;
7718 dgst_size = DGST_SIZE_4_5;
7719 parse_func = sha1_parse_hash;
7720 sort_by_digest = sort_by_digest_4_5;
7721 opti_type = OPTI_TYPE_ZERO_BYTE
7722 | OPTI_TYPE_PRECOMPUTE_INIT
7723 | OPTI_TYPE_PRECOMPUTE_MERKLE
7724 | OPTI_TYPE_EARLY_SKIP
7725 | OPTI_TYPE_NOT_ITERATED
7726 | OPTI_TYPE_NOT_SALTED;
7727 dgst_pos0 = 3;
7728 dgst_pos1 = 4;
7729 dgst_pos2 = 2;
7730 dgst_pos3 = 1;
7731 break;
7732
7733 case 400: hash_type = HASH_TYPE_MD5;
7734 salt_type = SALT_TYPE_EMBEDDED;
7735 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7736 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7737 kern_type = KERN_TYPE_PHPASS;
7738 dgst_size = DGST_SIZE_4_4;
7739 parse_func = phpass_parse_hash;
7740 sort_by_digest = sort_by_digest_4_4;
7741 opti_type = OPTI_TYPE_ZERO_BYTE;
7742 dgst_pos0 = 0;
7743 dgst_pos1 = 1;
7744 dgst_pos2 = 2;
7745 dgst_pos3 = 3;
7746 break;
7747
7748 case 500: hash_type = HASH_TYPE_MD5;
7749 salt_type = SALT_TYPE_EMBEDDED;
7750 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7751 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7752 kern_type = KERN_TYPE_MD5CRYPT;
7753 dgst_size = DGST_SIZE_4_4;
7754 parse_func = md5crypt_parse_hash;
7755 sort_by_digest = sort_by_digest_4_4;
7756 opti_type = OPTI_TYPE_ZERO_BYTE;
7757 dgst_pos0 = 0;
7758 dgst_pos1 = 1;
7759 dgst_pos2 = 2;
7760 dgst_pos3 = 3;
7761 break;
7762
7763 case 501: hash_type = HASH_TYPE_MD5;
7764 salt_type = SALT_TYPE_EMBEDDED;
7765 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7766 opts_type = OPTS_TYPE_PT_GENERATE_LE
7767 | OPTS_TYPE_HASH_COPY;
7768 kern_type = KERN_TYPE_MD5CRYPT;
7769 dgst_size = DGST_SIZE_4_4;
7770 parse_func = juniper_parse_hash;
7771 sort_by_digest = sort_by_digest_4_4;
7772 opti_type = OPTI_TYPE_ZERO_BYTE;
7773 dgst_pos0 = 0;
7774 dgst_pos1 = 1;
7775 dgst_pos2 = 2;
7776 dgst_pos3 = 3;
7777 break;
7778
7779 case 900: hash_type = HASH_TYPE_MD4;
7780 salt_type = SALT_TYPE_NONE;
7781 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7782 opts_type = OPTS_TYPE_PT_GENERATE_LE
7783 | OPTS_TYPE_PT_ADD80
7784 | OPTS_TYPE_PT_ADDBITS14;
7785 kern_type = KERN_TYPE_MD4;
7786 dgst_size = DGST_SIZE_4_4;
7787 parse_func = md4_parse_hash;
7788 sort_by_digest = sort_by_digest_4_4;
7789 opti_type = OPTI_TYPE_ZERO_BYTE
7790 | OPTI_TYPE_PRECOMPUTE_INIT
7791 | OPTI_TYPE_PRECOMPUTE_MERKLE
7792 | OPTI_TYPE_MEET_IN_MIDDLE
7793 | OPTI_TYPE_EARLY_SKIP
7794 | OPTI_TYPE_NOT_ITERATED
7795 | OPTI_TYPE_NOT_SALTED
7796 | OPTI_TYPE_RAW_HASH;
7797 dgst_pos0 = 0;
7798 dgst_pos1 = 3;
7799 dgst_pos2 = 2;
7800 dgst_pos3 = 1;
7801 break;
7802
7803 case 1000: hash_type = HASH_TYPE_MD4;
7804 salt_type = SALT_TYPE_NONE;
7805 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7806 opts_type = OPTS_TYPE_PT_GENERATE_LE
7807 | OPTS_TYPE_PT_ADD80
7808 | OPTS_TYPE_PT_ADDBITS14
7809 | OPTS_TYPE_PT_UNICODE;
7810 kern_type = KERN_TYPE_MD4_PWU;
7811 dgst_size = DGST_SIZE_4_4;
7812 parse_func = md4_parse_hash;
7813 sort_by_digest = sort_by_digest_4_4;
7814 opti_type = OPTI_TYPE_ZERO_BYTE
7815 | OPTI_TYPE_PRECOMPUTE_INIT
7816 | OPTI_TYPE_PRECOMPUTE_MERKLE
7817 | OPTI_TYPE_MEET_IN_MIDDLE
7818 | OPTI_TYPE_EARLY_SKIP
7819 | OPTI_TYPE_NOT_ITERATED
7820 | OPTI_TYPE_NOT_SALTED
7821 | OPTI_TYPE_RAW_HASH;
7822 dgst_pos0 = 0;
7823 dgst_pos1 = 3;
7824 dgst_pos2 = 2;
7825 dgst_pos3 = 1;
7826 break;
7827
7828 case 1100: hash_type = HASH_TYPE_MD4;
7829 salt_type = SALT_TYPE_INTERN;
7830 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7831 opts_type = OPTS_TYPE_PT_GENERATE_LE
7832 | OPTS_TYPE_PT_ADD80
7833 | OPTS_TYPE_PT_ADDBITS14
7834 | OPTS_TYPE_PT_UNICODE
7835 | OPTS_TYPE_ST_ADD80
7836 | OPTS_TYPE_ST_UNICODE
7837 | OPTS_TYPE_ST_LOWER;
7838 kern_type = KERN_TYPE_MD44_PWUSLT;
7839 dgst_size = DGST_SIZE_4_4;
7840 parse_func = dcc_parse_hash;
7841 sort_by_digest = sort_by_digest_4_4;
7842 opti_type = OPTI_TYPE_ZERO_BYTE
7843 | OPTI_TYPE_PRECOMPUTE_INIT
7844 | OPTI_TYPE_PRECOMPUTE_MERKLE
7845 | OPTI_TYPE_EARLY_SKIP
7846 | OPTI_TYPE_NOT_ITERATED;
7847 dgst_pos0 = 0;
7848 dgst_pos1 = 3;
7849 dgst_pos2 = 2;
7850 dgst_pos3 = 1;
7851 break;
7852
7853 case 1400: hash_type = HASH_TYPE_SHA256;
7854 salt_type = SALT_TYPE_NONE;
7855 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7856 opts_type = OPTS_TYPE_PT_GENERATE_BE
7857 | OPTS_TYPE_PT_ADD80
7858 | OPTS_TYPE_PT_ADDBITS15;
7859 kern_type = KERN_TYPE_SHA256;
7860 dgst_size = DGST_SIZE_4_8;
7861 parse_func = sha256_parse_hash;
7862 sort_by_digest = sort_by_digest_4_8;
7863 opti_type = OPTI_TYPE_ZERO_BYTE
7864 | OPTI_TYPE_PRECOMPUTE_INIT
7865 | OPTI_TYPE_PRECOMPUTE_MERKLE
7866 | OPTI_TYPE_EARLY_SKIP
7867 | OPTI_TYPE_NOT_ITERATED
7868 | OPTI_TYPE_NOT_SALTED
7869 | OPTI_TYPE_RAW_HASH;
7870 dgst_pos0 = 3;
7871 dgst_pos1 = 7;
7872 dgst_pos2 = 2;
7873 dgst_pos3 = 6;
7874 break;
7875
7876 case 1410: hash_type = HASH_TYPE_SHA256;
7877 salt_type = SALT_TYPE_INTERN;
7878 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7879 opts_type = OPTS_TYPE_PT_GENERATE_BE
7880 | OPTS_TYPE_ST_ADD80
7881 | OPTS_TYPE_ST_ADDBITS15;
7882 kern_type = KERN_TYPE_SHA256_PWSLT;
7883 dgst_size = DGST_SIZE_4_8;
7884 parse_func = sha256s_parse_hash;
7885 sort_by_digest = sort_by_digest_4_8;
7886 opti_type = OPTI_TYPE_ZERO_BYTE
7887 | OPTI_TYPE_PRECOMPUTE_INIT
7888 | OPTI_TYPE_PRECOMPUTE_MERKLE
7889 | OPTI_TYPE_EARLY_SKIP
7890 | OPTI_TYPE_NOT_ITERATED
7891 | OPTI_TYPE_APPENDED_SALT
7892 | OPTI_TYPE_RAW_HASH;
7893 dgst_pos0 = 3;
7894 dgst_pos1 = 7;
7895 dgst_pos2 = 2;
7896 dgst_pos3 = 6;
7897 break;
7898
7899 case 1420: hash_type = HASH_TYPE_SHA256;
7900 salt_type = SALT_TYPE_INTERN;
7901 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7902 opts_type = OPTS_TYPE_PT_GENERATE_BE
7903 | OPTS_TYPE_PT_ADD80
7904 | OPTS_TYPE_PT_ADDBITS15;
7905 kern_type = KERN_TYPE_SHA256_SLTPW;
7906 dgst_size = DGST_SIZE_4_8;
7907 parse_func = sha256s_parse_hash;
7908 sort_by_digest = sort_by_digest_4_8;
7909 opti_type = OPTI_TYPE_ZERO_BYTE
7910 | OPTI_TYPE_PRECOMPUTE_INIT
7911 | OPTI_TYPE_PRECOMPUTE_MERKLE
7912 | OPTI_TYPE_EARLY_SKIP
7913 | OPTI_TYPE_NOT_ITERATED
7914 | OPTI_TYPE_PREPENDED_SALT
7915 | OPTI_TYPE_RAW_HASH;
7916 dgst_pos0 = 3;
7917 dgst_pos1 = 7;
7918 dgst_pos2 = 2;
7919 dgst_pos3 = 6;
7920 break;
7921
7922 case 1421: hash_type = HASH_TYPE_SHA256;
7923 salt_type = SALT_TYPE_EMBEDDED;
7924 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7925 opts_type = OPTS_TYPE_PT_GENERATE_BE
7926 | OPTS_TYPE_PT_ADD80
7927 | OPTS_TYPE_PT_ADDBITS15;
7928 kern_type = KERN_TYPE_SHA256_SLTPW;
7929 dgst_size = DGST_SIZE_4_8;
7930 parse_func = hmailserver_parse_hash;
7931 sort_by_digest = sort_by_digest_4_8;
7932 opti_type = OPTI_TYPE_ZERO_BYTE
7933 | OPTI_TYPE_PRECOMPUTE_INIT
7934 | OPTI_TYPE_PRECOMPUTE_MERKLE
7935 | OPTI_TYPE_EARLY_SKIP
7936 | OPTI_TYPE_NOT_ITERATED
7937 | OPTI_TYPE_PREPENDED_SALT
7938 | OPTI_TYPE_RAW_HASH;
7939 dgst_pos0 = 3;
7940 dgst_pos1 = 7;
7941 dgst_pos2 = 2;
7942 dgst_pos3 = 6;
7943 break;
7944
7945 case 1430: hash_type = HASH_TYPE_SHA256;
7946 salt_type = SALT_TYPE_INTERN;
7947 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7948 opts_type = OPTS_TYPE_PT_GENERATE_BE
7949 | OPTS_TYPE_PT_UNICODE
7950 | OPTS_TYPE_ST_ADD80
7951 | OPTS_TYPE_ST_ADDBITS15;
7952 kern_type = KERN_TYPE_SHA256_PWUSLT;
7953 dgst_size = DGST_SIZE_4_8;
7954 parse_func = sha256s_parse_hash;
7955 sort_by_digest = sort_by_digest_4_8;
7956 opti_type = OPTI_TYPE_ZERO_BYTE
7957 | OPTI_TYPE_PRECOMPUTE_INIT
7958 | OPTI_TYPE_PRECOMPUTE_MERKLE
7959 | OPTI_TYPE_EARLY_SKIP
7960 | OPTI_TYPE_NOT_ITERATED
7961 | OPTI_TYPE_APPENDED_SALT
7962 | OPTI_TYPE_RAW_HASH;
7963 dgst_pos0 = 3;
7964 dgst_pos1 = 7;
7965 dgst_pos2 = 2;
7966 dgst_pos3 = 6;
7967 break;
7968
7969 case 1440: hash_type = HASH_TYPE_SHA256;
7970 salt_type = SALT_TYPE_INTERN;
7971 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7972 opts_type = OPTS_TYPE_PT_GENERATE_BE
7973 | OPTS_TYPE_PT_ADD80
7974 | OPTS_TYPE_PT_ADDBITS15
7975 | OPTS_TYPE_PT_UNICODE;
7976 kern_type = KERN_TYPE_SHA256_SLTPWU;
7977 dgst_size = DGST_SIZE_4_8;
7978 parse_func = sha256s_parse_hash;
7979 sort_by_digest = sort_by_digest_4_8;
7980 opti_type = OPTI_TYPE_ZERO_BYTE
7981 | OPTI_TYPE_PRECOMPUTE_INIT
7982 | OPTI_TYPE_PRECOMPUTE_MERKLE
7983 | OPTI_TYPE_EARLY_SKIP
7984 | OPTI_TYPE_NOT_ITERATED
7985 | OPTI_TYPE_PREPENDED_SALT
7986 | OPTI_TYPE_RAW_HASH;
7987 dgst_pos0 = 3;
7988 dgst_pos1 = 7;
7989 dgst_pos2 = 2;
7990 dgst_pos3 = 6;
7991 break;
7992
7993 case 1441: hash_type = HASH_TYPE_SHA256;
7994 salt_type = SALT_TYPE_EMBEDDED;
7995 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7996 opts_type = OPTS_TYPE_PT_GENERATE_BE
7997 | OPTS_TYPE_PT_ADD80
7998 | OPTS_TYPE_PT_ADDBITS15
7999 | OPTS_TYPE_PT_UNICODE
8000 | OPTS_TYPE_ST_BASE64;
8001 kern_type = KERN_TYPE_SHA256_SLTPWU;
8002 dgst_size = DGST_SIZE_4_8;
8003 parse_func = episerver4_parse_hash;
8004 sort_by_digest = sort_by_digest_4_8;
8005 opti_type = OPTI_TYPE_ZERO_BYTE
8006 | OPTI_TYPE_PRECOMPUTE_INIT
8007 | OPTI_TYPE_PRECOMPUTE_MERKLE
8008 | OPTI_TYPE_EARLY_SKIP
8009 | OPTI_TYPE_NOT_ITERATED
8010 | OPTI_TYPE_PREPENDED_SALT
8011 | OPTI_TYPE_RAW_HASH;
8012 dgst_pos0 = 3;
8013 dgst_pos1 = 7;
8014 dgst_pos2 = 2;
8015 dgst_pos3 = 6;
8016 break;
8017
8018 case 1450: hash_type = HASH_TYPE_SHA256;
8019 salt_type = SALT_TYPE_INTERN;
8020 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8021 opts_type = OPTS_TYPE_PT_GENERATE_BE
8022 | OPTS_TYPE_ST_ADD80;
8023 kern_type = KERN_TYPE_HMACSHA256_PW;
8024 dgst_size = DGST_SIZE_4_8;
8025 parse_func = hmacsha256_parse_hash;
8026 sort_by_digest = sort_by_digest_4_8;
8027 opti_type = OPTI_TYPE_ZERO_BYTE
8028 | OPTI_TYPE_NOT_ITERATED;
8029 dgst_pos0 = 3;
8030 dgst_pos1 = 7;
8031 dgst_pos2 = 2;
8032 dgst_pos3 = 6;
8033 break;
8034
8035 case 1460: hash_type = HASH_TYPE_SHA256;
8036 salt_type = SALT_TYPE_INTERN;
8037 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8038 opts_type = OPTS_TYPE_PT_GENERATE_BE
8039 | OPTS_TYPE_PT_ADD80
8040 | OPTS_TYPE_PT_ADDBITS15;
8041 kern_type = KERN_TYPE_HMACSHA256_SLT;
8042 dgst_size = DGST_SIZE_4_8;
8043 parse_func = hmacsha256_parse_hash;
8044 sort_by_digest = sort_by_digest_4_8;
8045 opti_type = OPTI_TYPE_ZERO_BYTE
8046 | OPTI_TYPE_NOT_ITERATED;
8047 dgst_pos0 = 3;
8048 dgst_pos1 = 7;
8049 dgst_pos2 = 2;
8050 dgst_pos3 = 6;
8051 break;
8052
8053 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8054 salt_type = SALT_TYPE_EMBEDDED;
8055 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8056 opts_type = OPTS_TYPE_PT_GENERATE_LE
8057 | OPTS_TYPE_PT_BITSLICE;
8058 kern_type = KERN_TYPE_DESCRYPT;
8059 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8060 parse_func = descrypt_parse_hash;
8061 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8062 opti_type = OPTI_TYPE_ZERO_BYTE
8063 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8064 dgst_pos0 = 0;
8065 dgst_pos1 = 1;
8066 dgst_pos2 = 2;
8067 dgst_pos3 = 3;
8068 break;
8069
8070 case 1600: hash_type = HASH_TYPE_MD5;
8071 salt_type = SALT_TYPE_EMBEDDED;
8072 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8073 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8074 kern_type = KERN_TYPE_APR1CRYPT;
8075 dgst_size = DGST_SIZE_4_4;
8076 parse_func = md5apr1_parse_hash;
8077 sort_by_digest = sort_by_digest_4_4;
8078 opti_type = OPTI_TYPE_ZERO_BYTE;
8079 dgst_pos0 = 0;
8080 dgst_pos1 = 1;
8081 dgst_pos2 = 2;
8082 dgst_pos3 = 3;
8083 break;
8084
8085 case 1700: hash_type = HASH_TYPE_SHA512;
8086 salt_type = SALT_TYPE_NONE;
8087 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8088 opts_type = OPTS_TYPE_PT_GENERATE_BE
8089 | OPTS_TYPE_PT_ADD80
8090 | OPTS_TYPE_PT_ADDBITS15;
8091 kern_type = KERN_TYPE_SHA512;
8092 dgst_size = DGST_SIZE_8_8;
8093 parse_func = sha512_parse_hash;
8094 sort_by_digest = sort_by_digest_8_8;
8095 opti_type = OPTI_TYPE_ZERO_BYTE
8096 | OPTI_TYPE_PRECOMPUTE_INIT
8097 | OPTI_TYPE_PRECOMPUTE_MERKLE
8098 | OPTI_TYPE_EARLY_SKIP
8099 | OPTI_TYPE_NOT_ITERATED
8100 | OPTI_TYPE_NOT_SALTED
8101 | OPTI_TYPE_USES_BITS_64
8102 | OPTI_TYPE_RAW_HASH;
8103 dgst_pos0 = 14;
8104 dgst_pos1 = 15;
8105 dgst_pos2 = 6;
8106 dgst_pos3 = 7;
8107 break;
8108
8109 case 1710: hash_type = HASH_TYPE_SHA512;
8110 salt_type = SALT_TYPE_INTERN;
8111 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8112 opts_type = OPTS_TYPE_PT_GENERATE_BE
8113 | OPTS_TYPE_ST_ADD80
8114 | OPTS_TYPE_ST_ADDBITS15;
8115 kern_type = KERN_TYPE_SHA512_PWSLT;
8116 dgst_size = DGST_SIZE_8_8;
8117 parse_func = sha512s_parse_hash;
8118 sort_by_digest = sort_by_digest_8_8;
8119 opti_type = OPTI_TYPE_ZERO_BYTE
8120 | OPTI_TYPE_PRECOMPUTE_INIT
8121 | OPTI_TYPE_PRECOMPUTE_MERKLE
8122 | OPTI_TYPE_EARLY_SKIP
8123 | OPTI_TYPE_NOT_ITERATED
8124 | OPTI_TYPE_APPENDED_SALT
8125 | OPTI_TYPE_USES_BITS_64
8126 | OPTI_TYPE_RAW_HASH;
8127 dgst_pos0 = 14;
8128 dgst_pos1 = 15;
8129 dgst_pos2 = 6;
8130 dgst_pos3 = 7;
8131 break;
8132
8133 case 1711: hash_type = HASH_TYPE_SHA512;
8134 salt_type = SALT_TYPE_EMBEDDED;
8135 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8136 opts_type = OPTS_TYPE_PT_GENERATE_BE
8137 | OPTS_TYPE_ST_ADD80
8138 | OPTS_TYPE_ST_ADDBITS15;
8139 kern_type = KERN_TYPE_SHA512_PWSLT;
8140 dgst_size = DGST_SIZE_8_8;
8141 parse_func = sha512b64s_parse_hash;
8142 sort_by_digest = sort_by_digest_8_8;
8143 opti_type = OPTI_TYPE_ZERO_BYTE
8144 | OPTI_TYPE_PRECOMPUTE_INIT
8145 | OPTI_TYPE_PRECOMPUTE_MERKLE
8146 | OPTI_TYPE_EARLY_SKIP
8147 | OPTI_TYPE_NOT_ITERATED
8148 | OPTI_TYPE_APPENDED_SALT
8149 | OPTI_TYPE_USES_BITS_64
8150 | OPTI_TYPE_RAW_HASH;
8151 dgst_pos0 = 14;
8152 dgst_pos1 = 15;
8153 dgst_pos2 = 6;
8154 dgst_pos3 = 7;
8155 break;
8156
8157 case 1720: hash_type = HASH_TYPE_SHA512;
8158 salt_type = SALT_TYPE_INTERN;
8159 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8160 opts_type = OPTS_TYPE_PT_GENERATE_BE
8161 | OPTS_TYPE_PT_ADD80
8162 | OPTS_TYPE_PT_ADDBITS15;
8163 kern_type = KERN_TYPE_SHA512_SLTPW;
8164 dgst_size = DGST_SIZE_8_8;
8165 parse_func = sha512s_parse_hash;
8166 sort_by_digest = sort_by_digest_8_8;
8167 opti_type = OPTI_TYPE_ZERO_BYTE
8168 | OPTI_TYPE_PRECOMPUTE_INIT
8169 | OPTI_TYPE_PRECOMPUTE_MERKLE
8170 | OPTI_TYPE_EARLY_SKIP
8171 | OPTI_TYPE_NOT_ITERATED
8172 | OPTI_TYPE_PREPENDED_SALT
8173 | OPTI_TYPE_USES_BITS_64
8174 | OPTI_TYPE_RAW_HASH;
8175 dgst_pos0 = 14;
8176 dgst_pos1 = 15;
8177 dgst_pos2 = 6;
8178 dgst_pos3 = 7;
8179 break;
8180
8181 case 1722: hash_type = HASH_TYPE_SHA512;
8182 salt_type = SALT_TYPE_EMBEDDED;
8183 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8184 opts_type = OPTS_TYPE_PT_GENERATE_BE
8185 | OPTS_TYPE_PT_ADD80
8186 | OPTS_TYPE_PT_ADDBITS15
8187 | OPTS_TYPE_ST_HEX;
8188 kern_type = KERN_TYPE_SHA512_SLTPW;
8189 dgst_size = DGST_SIZE_8_8;
8190 parse_func = osx512_parse_hash;
8191 sort_by_digest = sort_by_digest_8_8;
8192 opti_type = OPTI_TYPE_ZERO_BYTE
8193 | OPTI_TYPE_PRECOMPUTE_INIT
8194 | OPTI_TYPE_PRECOMPUTE_MERKLE
8195 | OPTI_TYPE_EARLY_SKIP
8196 | OPTI_TYPE_NOT_ITERATED
8197 | OPTI_TYPE_PREPENDED_SALT
8198 | OPTI_TYPE_USES_BITS_64
8199 | OPTI_TYPE_RAW_HASH;
8200 dgst_pos0 = 14;
8201 dgst_pos1 = 15;
8202 dgst_pos2 = 6;
8203 dgst_pos3 = 7;
8204 break;
8205
8206 case 1730: hash_type = HASH_TYPE_SHA512;
8207 salt_type = SALT_TYPE_INTERN;
8208 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8209 opts_type = OPTS_TYPE_PT_GENERATE_BE
8210 | OPTS_TYPE_PT_UNICODE
8211 | OPTS_TYPE_ST_ADD80
8212 | OPTS_TYPE_ST_ADDBITS15;
8213 kern_type = KERN_TYPE_SHA512_PWSLTU;
8214 dgst_size = DGST_SIZE_8_8;
8215 parse_func = sha512s_parse_hash;
8216 sort_by_digest = sort_by_digest_8_8;
8217 opti_type = OPTI_TYPE_ZERO_BYTE
8218 | OPTI_TYPE_PRECOMPUTE_INIT
8219 | OPTI_TYPE_PRECOMPUTE_MERKLE
8220 | OPTI_TYPE_EARLY_SKIP
8221 | OPTI_TYPE_NOT_ITERATED
8222 | OPTI_TYPE_APPENDED_SALT
8223 | OPTI_TYPE_USES_BITS_64
8224 | OPTI_TYPE_RAW_HASH;
8225 dgst_pos0 = 14;
8226 dgst_pos1 = 15;
8227 dgst_pos2 = 6;
8228 dgst_pos3 = 7;
8229 break;
8230
8231 case 1731: hash_type = HASH_TYPE_SHA512;
8232 salt_type = SALT_TYPE_EMBEDDED;
8233 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8234 opts_type = OPTS_TYPE_PT_GENERATE_BE
8235 | OPTS_TYPE_PT_UNICODE
8236 | OPTS_TYPE_ST_ADD80
8237 | OPTS_TYPE_ST_ADDBITS15
8238 | OPTS_TYPE_ST_HEX;
8239 kern_type = KERN_TYPE_SHA512_PWSLTU;
8240 dgst_size = DGST_SIZE_8_8;
8241 parse_func = mssql2012_parse_hash;
8242 sort_by_digest = sort_by_digest_8_8;
8243 opti_type = OPTI_TYPE_ZERO_BYTE
8244 | OPTI_TYPE_PRECOMPUTE_INIT
8245 | OPTI_TYPE_PRECOMPUTE_MERKLE
8246 | OPTI_TYPE_EARLY_SKIP
8247 | OPTI_TYPE_NOT_ITERATED
8248 | OPTI_TYPE_APPENDED_SALT
8249 | OPTI_TYPE_USES_BITS_64
8250 | OPTI_TYPE_RAW_HASH;
8251 dgst_pos0 = 14;
8252 dgst_pos1 = 15;
8253 dgst_pos2 = 6;
8254 dgst_pos3 = 7;
8255 break;
8256
8257 case 1740: hash_type = HASH_TYPE_SHA512;
8258 salt_type = SALT_TYPE_INTERN;
8259 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8260 opts_type = OPTS_TYPE_PT_GENERATE_BE
8261 | OPTS_TYPE_PT_ADD80
8262 | OPTS_TYPE_PT_ADDBITS15
8263 | OPTS_TYPE_PT_UNICODE;
8264 kern_type = KERN_TYPE_SHA512_SLTPWU;
8265 dgst_size = DGST_SIZE_8_8;
8266 parse_func = sha512s_parse_hash;
8267 sort_by_digest = sort_by_digest_8_8;
8268 opti_type = OPTI_TYPE_ZERO_BYTE
8269 | OPTI_TYPE_PRECOMPUTE_INIT
8270 | OPTI_TYPE_PRECOMPUTE_MERKLE
8271 | OPTI_TYPE_EARLY_SKIP
8272 | OPTI_TYPE_NOT_ITERATED
8273 | OPTI_TYPE_PREPENDED_SALT
8274 | OPTI_TYPE_USES_BITS_64
8275 | OPTI_TYPE_RAW_HASH;
8276 dgst_pos0 = 14;
8277 dgst_pos1 = 15;
8278 dgst_pos2 = 6;
8279 dgst_pos3 = 7;
8280 break;
8281
8282 case 1750: hash_type = HASH_TYPE_SHA512;
8283 salt_type = SALT_TYPE_INTERN;
8284 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8285 opts_type = OPTS_TYPE_PT_GENERATE_BE
8286 | OPTS_TYPE_ST_ADD80;
8287 kern_type = KERN_TYPE_HMACSHA512_PW;
8288 dgst_size = DGST_SIZE_8_8;
8289 parse_func = hmacsha512_parse_hash;
8290 sort_by_digest = sort_by_digest_8_8;
8291 opti_type = OPTI_TYPE_ZERO_BYTE
8292 | OPTI_TYPE_USES_BITS_64
8293 | OPTI_TYPE_NOT_ITERATED;
8294 dgst_pos0 = 14;
8295 dgst_pos1 = 15;
8296 dgst_pos2 = 6;
8297 dgst_pos3 = 7;
8298 break;
8299
8300 case 1760: hash_type = HASH_TYPE_SHA512;
8301 salt_type = SALT_TYPE_INTERN;
8302 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8303 opts_type = OPTS_TYPE_PT_GENERATE_BE
8304 | OPTS_TYPE_PT_ADD80
8305 | OPTS_TYPE_PT_ADDBITS15;
8306 kern_type = KERN_TYPE_HMACSHA512_SLT;
8307 dgst_size = DGST_SIZE_8_8;
8308 parse_func = hmacsha512_parse_hash;
8309 sort_by_digest = sort_by_digest_8_8;
8310 opti_type = OPTI_TYPE_ZERO_BYTE
8311 | OPTI_TYPE_USES_BITS_64
8312 | OPTI_TYPE_NOT_ITERATED;
8313 dgst_pos0 = 14;
8314 dgst_pos1 = 15;
8315 dgst_pos2 = 6;
8316 dgst_pos3 = 7;
8317 break;
8318
8319 case 1800: hash_type = HASH_TYPE_SHA512;
8320 salt_type = SALT_TYPE_EMBEDDED;
8321 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8322 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8323 kern_type = KERN_TYPE_SHA512CRYPT;
8324 dgst_size = DGST_SIZE_8_8;
8325 parse_func = sha512crypt_parse_hash;
8326 sort_by_digest = sort_by_digest_8_8;
8327 opti_type = OPTI_TYPE_ZERO_BYTE
8328 | OPTI_TYPE_USES_BITS_64;
8329 dgst_pos0 = 0;
8330 dgst_pos1 = 1;
8331 dgst_pos2 = 2;
8332 dgst_pos3 = 3;
8333 break;
8334
8335 case 2100: hash_type = HASH_TYPE_DCC2;
8336 salt_type = SALT_TYPE_EMBEDDED;
8337 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8338 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8339 | OPTS_TYPE_ST_LOWER
8340 | OPTS_TYPE_ST_UNICODE;
8341 kern_type = KERN_TYPE_DCC2;
8342 dgst_size = DGST_SIZE_4_4;
8343 parse_func = dcc2_parse_hash;
8344 sort_by_digest = sort_by_digest_4_4;
8345 opti_type = OPTI_TYPE_ZERO_BYTE;
8346 dgst_pos0 = 0;
8347 dgst_pos1 = 1;
8348 dgst_pos2 = 2;
8349 dgst_pos3 = 3;
8350 break;
8351
8352 case 2400: hash_type = HASH_TYPE_MD5;
8353 salt_type = SALT_TYPE_NONE;
8354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8355 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8356 kern_type = KERN_TYPE_MD5PIX;
8357 dgst_size = DGST_SIZE_4_4;
8358 parse_func = md5pix_parse_hash;
8359 sort_by_digest = sort_by_digest_4_4;
8360 opti_type = OPTI_TYPE_ZERO_BYTE
8361 | OPTI_TYPE_PRECOMPUTE_INIT
8362 | OPTI_TYPE_PRECOMPUTE_MERKLE
8363 | OPTI_TYPE_EARLY_SKIP
8364 | OPTI_TYPE_NOT_ITERATED
8365 | OPTI_TYPE_NOT_SALTED;
8366 dgst_pos0 = 0;
8367 dgst_pos1 = 3;
8368 dgst_pos2 = 2;
8369 dgst_pos3 = 1;
8370 break;
8371
8372 case 2410: hash_type = HASH_TYPE_MD5;
8373 salt_type = SALT_TYPE_INTERN;
8374 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8375 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8376 kern_type = KERN_TYPE_MD5ASA;
8377 dgst_size = DGST_SIZE_4_4;
8378 parse_func = md5asa_parse_hash;
8379 sort_by_digest = sort_by_digest_4_4;
8380 opti_type = OPTI_TYPE_ZERO_BYTE
8381 | OPTI_TYPE_PRECOMPUTE_INIT
8382 | OPTI_TYPE_PRECOMPUTE_MERKLE
8383 | OPTI_TYPE_EARLY_SKIP
8384 | OPTI_TYPE_NOT_ITERATED;
8385 dgst_pos0 = 0;
8386 dgst_pos1 = 3;
8387 dgst_pos2 = 2;
8388 dgst_pos3 = 1;
8389 break;
8390
8391 case 2500: hash_type = HASH_TYPE_WPA;
8392 salt_type = SALT_TYPE_EMBEDDED;
8393 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8394 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8395 kern_type = KERN_TYPE_WPA;
8396 dgst_size = DGST_SIZE_4_4;
8397 parse_func = wpa_parse_hash;
8398 sort_by_digest = sort_by_digest_4_4;
8399 opti_type = OPTI_TYPE_ZERO_BYTE;
8400 dgst_pos0 = 0;
8401 dgst_pos1 = 1;
8402 dgst_pos2 = 2;
8403 dgst_pos3 = 3;
8404 break;
8405
8406 case 2600: hash_type = HASH_TYPE_MD5;
8407 salt_type = SALT_TYPE_VIRTUAL;
8408 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8409 opts_type = OPTS_TYPE_PT_GENERATE_LE
8410 | OPTS_TYPE_PT_ADD80
8411 | OPTS_TYPE_PT_ADDBITS14
8412 | OPTS_TYPE_ST_ADD80;
8413 kern_type = KERN_TYPE_MD55_PWSLT1;
8414 dgst_size = DGST_SIZE_4_4;
8415 parse_func = md5md5_parse_hash;
8416 sort_by_digest = sort_by_digest_4_4;
8417 opti_type = OPTI_TYPE_ZERO_BYTE
8418 | OPTI_TYPE_PRECOMPUTE_INIT
8419 | OPTI_TYPE_PRECOMPUTE_MERKLE
8420 | OPTI_TYPE_EARLY_SKIP;
8421 dgst_pos0 = 0;
8422 dgst_pos1 = 3;
8423 dgst_pos2 = 2;
8424 dgst_pos3 = 1;
8425 break;
8426
8427 case 2611: hash_type = HASH_TYPE_MD5;
8428 salt_type = SALT_TYPE_INTERN;
8429 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8430 opts_type = OPTS_TYPE_PT_GENERATE_LE
8431 | OPTS_TYPE_PT_ADD80
8432 | OPTS_TYPE_PT_ADDBITS14
8433 | OPTS_TYPE_ST_ADD80;
8434 kern_type = KERN_TYPE_MD55_PWSLT1;
8435 dgst_size = DGST_SIZE_4_4;
8436 parse_func = vb3_parse_hash;
8437 sort_by_digest = sort_by_digest_4_4;
8438 opti_type = OPTI_TYPE_ZERO_BYTE
8439 | OPTI_TYPE_PRECOMPUTE_INIT
8440 | OPTI_TYPE_PRECOMPUTE_MERKLE
8441 | OPTI_TYPE_EARLY_SKIP;
8442 dgst_pos0 = 0;
8443 dgst_pos1 = 3;
8444 dgst_pos2 = 2;
8445 dgst_pos3 = 1;
8446 break;
8447
8448 case 2612: hash_type = HASH_TYPE_MD5;
8449 salt_type = SALT_TYPE_EMBEDDED;
8450 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8451 opts_type = OPTS_TYPE_PT_GENERATE_LE
8452 | OPTS_TYPE_PT_ADD80
8453 | OPTS_TYPE_PT_ADDBITS14
8454 | OPTS_TYPE_ST_ADD80
8455 | OPTS_TYPE_ST_HEX;
8456 kern_type = KERN_TYPE_MD55_PWSLT1;
8457 dgst_size = DGST_SIZE_4_4;
8458 parse_func = phps_parse_hash;
8459 sort_by_digest = sort_by_digest_4_4;
8460 opti_type = OPTI_TYPE_ZERO_BYTE
8461 | OPTI_TYPE_PRECOMPUTE_INIT
8462 | OPTI_TYPE_PRECOMPUTE_MERKLE
8463 | OPTI_TYPE_EARLY_SKIP;
8464 dgst_pos0 = 0;
8465 dgst_pos1 = 3;
8466 dgst_pos2 = 2;
8467 dgst_pos3 = 1;
8468 break;
8469
8470 case 2711: hash_type = HASH_TYPE_MD5;
8471 salt_type = SALT_TYPE_INTERN;
8472 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8473 opts_type = OPTS_TYPE_PT_GENERATE_LE
8474 | OPTS_TYPE_PT_ADD80
8475 | OPTS_TYPE_PT_ADDBITS14
8476 | OPTS_TYPE_ST_ADD80;
8477 kern_type = KERN_TYPE_MD55_PWSLT2;
8478 dgst_size = DGST_SIZE_4_4;
8479 parse_func = vb30_parse_hash;
8480 sort_by_digest = sort_by_digest_4_4;
8481 opti_type = OPTI_TYPE_ZERO_BYTE
8482 | OPTI_TYPE_PRECOMPUTE_INIT
8483 | OPTI_TYPE_EARLY_SKIP;
8484 dgst_pos0 = 0;
8485 dgst_pos1 = 3;
8486 dgst_pos2 = 2;
8487 dgst_pos3 = 1;
8488 break;
8489
8490 case 2811: hash_type = HASH_TYPE_MD5;
8491 salt_type = SALT_TYPE_INTERN;
8492 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8493 opts_type = OPTS_TYPE_PT_GENERATE_LE
8494 | OPTS_TYPE_PT_ADD80
8495 | OPTS_TYPE_PT_ADDBITS14;
8496 kern_type = KERN_TYPE_MD55_SLTPW;
8497 dgst_size = DGST_SIZE_4_4;
8498 parse_func = ipb2_parse_hash;
8499 sort_by_digest = sort_by_digest_4_4;
8500 opti_type = OPTI_TYPE_ZERO_BYTE
8501 | OPTI_TYPE_PRECOMPUTE_INIT
8502 | OPTI_TYPE_EARLY_SKIP;
8503 dgst_pos0 = 0;
8504 dgst_pos1 = 3;
8505 dgst_pos2 = 2;
8506 dgst_pos3 = 1;
8507 break;
8508
8509 case 3000: hash_type = HASH_TYPE_LM;
8510 salt_type = SALT_TYPE_NONE;
8511 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8512 opts_type = OPTS_TYPE_PT_GENERATE_LE
8513 | OPTS_TYPE_PT_UPPER
8514 | OPTS_TYPE_PT_BITSLICE;
8515 kern_type = KERN_TYPE_LM;
8516 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8517 parse_func = lm_parse_hash;
8518 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8519 opti_type = OPTI_TYPE_ZERO_BYTE
8520 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8521 dgst_pos0 = 0;
8522 dgst_pos1 = 1;
8523 dgst_pos2 = 2;
8524 dgst_pos3 = 3;
8525 break;
8526
8527 case 3100: hash_type = HASH_TYPE_ORACLEH;
8528 salt_type = SALT_TYPE_INTERN;
8529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8530 opts_type = OPTS_TYPE_PT_GENERATE_LE
8531 | OPTS_TYPE_PT_UPPER
8532 | OPTS_TYPE_ST_UPPER;
8533 kern_type = KERN_TYPE_ORACLEH;
8534 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8535 parse_func = oracleh_parse_hash;
8536 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8537 opti_type = OPTI_TYPE_ZERO_BYTE;
8538 dgst_pos0 = 0;
8539 dgst_pos1 = 1;
8540 dgst_pos2 = 2;
8541 dgst_pos3 = 3;
8542 break;
8543
8544 case 3200: hash_type = HASH_TYPE_BCRYPT;
8545 salt_type = SALT_TYPE_EMBEDDED;
8546 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8547 opts_type = OPTS_TYPE_PT_GENERATE_LE
8548 | OPTS_TYPE_ST_GENERATE_LE;
8549 kern_type = KERN_TYPE_BCRYPT;
8550 dgst_size = DGST_SIZE_4_6;
8551 parse_func = bcrypt_parse_hash;
8552 sort_by_digest = sort_by_digest_4_6;
8553 opti_type = OPTI_TYPE_ZERO_BYTE;
8554 dgst_pos0 = 0;
8555 dgst_pos1 = 1;
8556 dgst_pos2 = 2;
8557 dgst_pos3 = 3;
8558 break;
8559
8560 case 3710: hash_type = HASH_TYPE_MD5;
8561 salt_type = SALT_TYPE_INTERN;
8562 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8563 opts_type = OPTS_TYPE_PT_GENERATE_LE
8564 | OPTS_TYPE_PT_ADD80
8565 | OPTS_TYPE_PT_ADDBITS14;
8566 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8567 dgst_size = DGST_SIZE_4_4;
8568 parse_func = md5s_parse_hash;
8569 sort_by_digest = sort_by_digest_4_4;
8570 opti_type = OPTI_TYPE_ZERO_BYTE
8571 | OPTI_TYPE_PRECOMPUTE_INIT
8572 | OPTI_TYPE_PRECOMPUTE_MERKLE
8573 | OPTI_TYPE_EARLY_SKIP;
8574 dgst_pos0 = 0;
8575 dgst_pos1 = 3;
8576 dgst_pos2 = 2;
8577 dgst_pos3 = 1;
8578 break;
8579
8580 case 3711: hash_type = HASH_TYPE_MD5;
8581 salt_type = SALT_TYPE_EMBEDDED;
8582 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8583 opts_type = OPTS_TYPE_PT_GENERATE_LE
8584 | OPTS_TYPE_PT_ADD80
8585 | OPTS_TYPE_PT_ADDBITS14;
8586 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8587 dgst_size = DGST_SIZE_4_4;
8588 parse_func = mediawiki_b_parse_hash;
8589 sort_by_digest = sort_by_digest_4_4;
8590 opti_type = OPTI_TYPE_ZERO_BYTE
8591 | OPTI_TYPE_PRECOMPUTE_INIT
8592 | OPTI_TYPE_PRECOMPUTE_MERKLE
8593 | OPTI_TYPE_EARLY_SKIP;
8594 dgst_pos0 = 0;
8595 dgst_pos1 = 3;
8596 dgst_pos2 = 2;
8597 dgst_pos3 = 1;
8598 break;
8599
8600 case 3800: hash_type = HASH_TYPE_MD5;
8601 salt_type = SALT_TYPE_INTERN;
8602 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8603 opts_type = OPTS_TYPE_PT_GENERATE_LE
8604 | OPTS_TYPE_ST_ADDBITS14;
8605 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8606 dgst_size = DGST_SIZE_4_4;
8607 parse_func = md5s_parse_hash;
8608 sort_by_digest = sort_by_digest_4_4;
8609 opti_type = OPTI_TYPE_ZERO_BYTE
8610 | OPTI_TYPE_PRECOMPUTE_INIT
8611 | OPTI_TYPE_PRECOMPUTE_MERKLE
8612 | OPTI_TYPE_EARLY_SKIP
8613 | OPTI_TYPE_NOT_ITERATED
8614 | OPTI_TYPE_RAW_HASH;
8615 dgst_pos0 = 0;
8616 dgst_pos1 = 3;
8617 dgst_pos2 = 2;
8618 dgst_pos3 = 1;
8619 break;
8620
8621 case 4300: hash_type = HASH_TYPE_MD5;
8622 salt_type = SALT_TYPE_VIRTUAL;
8623 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8624 opts_type = OPTS_TYPE_PT_GENERATE_LE
8625 | OPTS_TYPE_PT_ADD80
8626 | OPTS_TYPE_PT_ADDBITS14
8627 | OPTS_TYPE_ST_ADD80;
8628 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8629 dgst_size = DGST_SIZE_4_4;
8630 parse_func = md5md5_parse_hash;
8631 sort_by_digest = sort_by_digest_4_4;
8632 opti_type = OPTI_TYPE_ZERO_BYTE
8633 | OPTI_TYPE_PRECOMPUTE_INIT
8634 | OPTI_TYPE_PRECOMPUTE_MERKLE
8635 | OPTI_TYPE_EARLY_SKIP;
8636 dgst_pos0 = 0;
8637 dgst_pos1 = 3;
8638 dgst_pos2 = 2;
8639 dgst_pos3 = 1;
8640 break;
8641
8642
8643 case 4400: hash_type = HASH_TYPE_MD5;
8644 salt_type = SALT_TYPE_NONE;
8645 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8646 opts_type = OPTS_TYPE_PT_GENERATE_BE
8647 | OPTS_TYPE_PT_ADD80
8648 | OPTS_TYPE_PT_ADDBITS15;
8649 kern_type = KERN_TYPE_MD5_SHA1;
8650 dgst_size = DGST_SIZE_4_4;
8651 parse_func = md5_parse_hash;
8652 sort_by_digest = sort_by_digest_4_4;
8653 opti_type = OPTI_TYPE_ZERO_BYTE
8654 | OPTI_TYPE_PRECOMPUTE_INIT
8655 | OPTI_TYPE_PRECOMPUTE_MERKLE
8656 | OPTI_TYPE_EARLY_SKIP
8657 | OPTI_TYPE_NOT_ITERATED
8658 | OPTI_TYPE_NOT_SALTED
8659 | OPTI_TYPE_RAW_HASH;
8660 dgst_pos0 = 0;
8661 dgst_pos1 = 3;
8662 dgst_pos2 = 2;
8663 dgst_pos3 = 1;
8664 break;
8665
8666 case 4500: hash_type = HASH_TYPE_SHA1;
8667 salt_type = SALT_TYPE_NONE;
8668 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8669 opts_type = OPTS_TYPE_PT_GENERATE_BE
8670 | OPTS_TYPE_PT_ADD80
8671 | OPTS_TYPE_PT_ADDBITS15;
8672 kern_type = KERN_TYPE_SHA11;
8673 dgst_size = DGST_SIZE_4_5;
8674 parse_func = sha1_parse_hash;
8675 sort_by_digest = sort_by_digest_4_5;
8676 opti_type = OPTI_TYPE_ZERO_BYTE
8677 | OPTI_TYPE_PRECOMPUTE_INIT
8678 | OPTI_TYPE_PRECOMPUTE_MERKLE
8679 | OPTI_TYPE_EARLY_SKIP
8680 | OPTI_TYPE_NOT_SALTED;
8681 dgst_pos0 = 3;
8682 dgst_pos1 = 4;
8683 dgst_pos2 = 2;
8684 dgst_pos3 = 1;
8685 break;
8686
8687 case 4700: hash_type = HASH_TYPE_SHA1;
8688 salt_type = SALT_TYPE_NONE;
8689 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8690 opts_type = OPTS_TYPE_PT_GENERATE_LE
8691 | OPTS_TYPE_PT_ADD80
8692 | OPTS_TYPE_PT_ADDBITS14;
8693 kern_type = KERN_TYPE_SHA1_MD5;
8694 dgst_size = DGST_SIZE_4_5;
8695 parse_func = sha1_parse_hash;
8696 sort_by_digest = sort_by_digest_4_5;
8697 opti_type = OPTI_TYPE_ZERO_BYTE
8698 | OPTI_TYPE_PRECOMPUTE_INIT
8699 | OPTI_TYPE_PRECOMPUTE_MERKLE
8700 | OPTI_TYPE_EARLY_SKIP
8701 | OPTI_TYPE_NOT_ITERATED
8702 | OPTI_TYPE_NOT_SALTED
8703 | OPTI_TYPE_RAW_HASH;
8704 dgst_pos0 = 3;
8705 dgst_pos1 = 4;
8706 dgst_pos2 = 2;
8707 dgst_pos3 = 1;
8708 break;
8709
8710 case 4800: hash_type = HASH_TYPE_MD5;
8711 salt_type = SALT_TYPE_EMBEDDED;
8712 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8713 opts_type = OPTS_TYPE_PT_GENERATE_LE
8714 | OPTS_TYPE_PT_ADDBITS14;
8715 kern_type = KERN_TYPE_MD5_CHAP;
8716 dgst_size = DGST_SIZE_4_4;
8717 parse_func = chap_parse_hash;
8718 sort_by_digest = sort_by_digest_4_4;
8719 opti_type = OPTI_TYPE_ZERO_BYTE
8720 | OPTI_TYPE_PRECOMPUTE_INIT
8721 | OPTI_TYPE_PRECOMPUTE_MERKLE
8722 | OPTI_TYPE_MEET_IN_MIDDLE
8723 | OPTI_TYPE_EARLY_SKIP
8724 | OPTI_TYPE_NOT_ITERATED
8725 | OPTI_TYPE_RAW_HASH;
8726 dgst_pos0 = 0;
8727 dgst_pos1 = 3;
8728 dgst_pos2 = 2;
8729 dgst_pos3 = 1;
8730 break;
8731
8732 case 4900: hash_type = HASH_TYPE_SHA1;
8733 salt_type = SALT_TYPE_INTERN;
8734 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8735 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8736 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8737 dgst_size = DGST_SIZE_4_5;
8738 parse_func = sha1s_parse_hash;
8739 sort_by_digest = sort_by_digest_4_5;
8740 opti_type = OPTI_TYPE_ZERO_BYTE
8741 | OPTI_TYPE_PRECOMPUTE_INIT
8742 | OPTI_TYPE_PRECOMPUTE_MERKLE
8743 | OPTI_TYPE_EARLY_SKIP;
8744 dgst_pos0 = 3;
8745 dgst_pos1 = 4;
8746 dgst_pos2 = 2;
8747 dgst_pos3 = 1;
8748 break;
8749
8750 case 5000: hash_type = HASH_TYPE_KECCAK;
8751 salt_type = SALT_TYPE_EMBEDDED;
8752 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8753 opts_type = OPTS_TYPE_PT_GENERATE_LE
8754 | OPTS_TYPE_PT_ADD01;
8755 kern_type = KERN_TYPE_KECCAK;
8756 dgst_size = DGST_SIZE_8_25;
8757 parse_func = keccak_parse_hash;
8758 sort_by_digest = sort_by_digest_8_25;
8759 opti_type = OPTI_TYPE_ZERO_BYTE
8760 | OPTI_TYPE_USES_BITS_64
8761 | OPTI_TYPE_RAW_HASH;
8762 dgst_pos0 = 2;
8763 dgst_pos1 = 3;
8764 dgst_pos2 = 4;
8765 dgst_pos3 = 5;
8766 break;
8767
8768 case 5100: hash_type = HASH_TYPE_MD5H;
8769 salt_type = SALT_TYPE_NONE;
8770 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8771 opts_type = OPTS_TYPE_PT_GENERATE_LE
8772 | OPTS_TYPE_PT_ADD80
8773 | OPTS_TYPE_PT_ADDBITS14;
8774 kern_type = KERN_TYPE_MD5H;
8775 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8776 parse_func = md5half_parse_hash;
8777 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8778 opti_type = OPTI_TYPE_ZERO_BYTE
8779 | OPTI_TYPE_RAW_HASH;
8780 dgst_pos0 = 0;
8781 dgst_pos1 = 1;
8782 dgst_pos2 = 2;
8783 dgst_pos3 = 3;
8784 break;
8785
8786 case 5200: hash_type = HASH_TYPE_SHA256;
8787 salt_type = SALT_TYPE_EMBEDDED;
8788 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8789 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8790 kern_type = KERN_TYPE_PSAFE3;
8791 dgst_size = DGST_SIZE_4_8;
8792 parse_func = psafe3_parse_hash;
8793 sort_by_digest = sort_by_digest_4_8;
8794 opti_type = OPTI_TYPE_ZERO_BYTE;
8795 dgst_pos0 = 0;
8796 dgst_pos1 = 1;
8797 dgst_pos2 = 2;
8798 dgst_pos3 = 3;
8799 break;
8800
8801 case 5300: hash_type = HASH_TYPE_MD5;
8802 salt_type = SALT_TYPE_EMBEDDED;
8803 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8804 opts_type = OPTS_TYPE_PT_GENERATE_LE
8805 | OPTS_TYPE_ST_ADD80;
8806 kern_type = KERN_TYPE_IKEPSK_MD5;
8807 dgst_size = DGST_SIZE_4_4;
8808 parse_func = ikepsk_md5_parse_hash;
8809 sort_by_digest = sort_by_digest_4_4;
8810 opti_type = OPTI_TYPE_ZERO_BYTE;
8811 dgst_pos0 = 0;
8812 dgst_pos1 = 3;
8813 dgst_pos2 = 2;
8814 dgst_pos3 = 1;
8815 break;
8816
8817 case 5400: hash_type = HASH_TYPE_SHA1;
8818 salt_type = SALT_TYPE_EMBEDDED;
8819 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8820 opts_type = OPTS_TYPE_PT_GENERATE_BE
8821 | OPTS_TYPE_ST_ADD80;
8822 kern_type = KERN_TYPE_IKEPSK_SHA1;
8823 dgst_size = DGST_SIZE_4_5;
8824 parse_func = ikepsk_sha1_parse_hash;
8825 sort_by_digest = sort_by_digest_4_5;
8826 opti_type = OPTI_TYPE_ZERO_BYTE;
8827 dgst_pos0 = 3;
8828 dgst_pos1 = 4;
8829 dgst_pos2 = 2;
8830 dgst_pos3 = 1;
8831 break;
8832
8833 case 5500: hash_type = HASH_TYPE_NETNTLM;
8834 salt_type = SALT_TYPE_EMBEDDED;
8835 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8836 opts_type = OPTS_TYPE_PT_GENERATE_LE
8837 | OPTS_TYPE_PT_ADD80
8838 | OPTS_TYPE_PT_ADDBITS14
8839 | OPTS_TYPE_PT_UNICODE
8840 | OPTS_TYPE_ST_HEX;
8841 kern_type = KERN_TYPE_NETNTLMv1;
8842 dgst_size = DGST_SIZE_4_4;
8843 parse_func = netntlmv1_parse_hash;
8844 sort_by_digest = sort_by_digest_4_4;
8845 opti_type = OPTI_TYPE_ZERO_BYTE
8846 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8847 dgst_pos0 = 0;
8848 dgst_pos1 = 1;
8849 dgst_pos2 = 2;
8850 dgst_pos3 = 3;
8851 break;
8852
8853 case 5600: hash_type = HASH_TYPE_MD5;
8854 salt_type = SALT_TYPE_EMBEDDED;
8855 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8856 opts_type = OPTS_TYPE_PT_GENERATE_LE
8857 | OPTS_TYPE_PT_ADD80
8858 | OPTS_TYPE_PT_ADDBITS14
8859 | OPTS_TYPE_PT_UNICODE;
8860 kern_type = KERN_TYPE_NETNTLMv2;
8861 dgst_size = DGST_SIZE_4_4;
8862 parse_func = netntlmv2_parse_hash;
8863 sort_by_digest = sort_by_digest_4_4;
8864 opti_type = OPTI_TYPE_ZERO_BYTE;
8865 dgst_pos0 = 0;
8866 dgst_pos1 = 3;
8867 dgst_pos2 = 2;
8868 dgst_pos3 = 1;
8869 break;
8870
8871 case 5700: hash_type = HASH_TYPE_SHA256;
8872 salt_type = SALT_TYPE_NONE;
8873 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8874 opts_type = OPTS_TYPE_PT_GENERATE_BE
8875 | OPTS_TYPE_PT_ADD80
8876 | OPTS_TYPE_PT_ADDBITS15;
8877 kern_type = KERN_TYPE_SHA256;
8878 dgst_size = DGST_SIZE_4_8;
8879 parse_func = cisco4_parse_hash;
8880 sort_by_digest = sort_by_digest_4_8;
8881 opti_type = OPTI_TYPE_ZERO_BYTE
8882 | OPTI_TYPE_PRECOMPUTE_INIT
8883 | OPTI_TYPE_PRECOMPUTE_MERKLE
8884 | OPTI_TYPE_EARLY_SKIP
8885 | OPTI_TYPE_NOT_ITERATED
8886 | OPTI_TYPE_NOT_SALTED
8887 | OPTI_TYPE_RAW_HASH;
8888 dgst_pos0 = 3;
8889 dgst_pos1 = 7;
8890 dgst_pos2 = 2;
8891 dgst_pos3 = 6;
8892 break;
8893
8894 case 5800: hash_type = HASH_TYPE_SHA1;
8895 salt_type = SALT_TYPE_INTERN;
8896 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8897 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8898 | OPTS_TYPE_ST_ADD80;
8899 kern_type = KERN_TYPE_ANDROIDPIN;
8900 dgst_size = DGST_SIZE_4_5;
8901 parse_func = androidpin_parse_hash;
8902 sort_by_digest = sort_by_digest_4_5;
8903 opti_type = OPTI_TYPE_ZERO_BYTE;
8904 dgst_pos0 = 0;
8905 dgst_pos1 = 1;
8906 dgst_pos2 = 2;
8907 dgst_pos3 = 3;
8908 break;
8909
8910 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8911 salt_type = SALT_TYPE_NONE;
8912 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8913 opts_type = OPTS_TYPE_PT_GENERATE_LE
8914 | OPTS_TYPE_PT_ADD80;
8915 kern_type = KERN_TYPE_RIPEMD160;
8916 dgst_size = DGST_SIZE_4_5;
8917 parse_func = ripemd160_parse_hash;
8918 sort_by_digest = sort_by_digest_4_5;
8919 opti_type = OPTI_TYPE_ZERO_BYTE;
8920 dgst_pos0 = 0;
8921 dgst_pos1 = 1;
8922 dgst_pos2 = 2;
8923 dgst_pos3 = 3;
8924 break;
8925
8926 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8927 salt_type = SALT_TYPE_NONE;
8928 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8929 opts_type = OPTS_TYPE_PT_GENERATE_BE
8930 | OPTS_TYPE_PT_ADD80;
8931 kern_type = KERN_TYPE_WHIRLPOOL;
8932 dgst_size = DGST_SIZE_4_16;
8933 parse_func = whirlpool_parse_hash;
8934 sort_by_digest = sort_by_digest_4_16;
8935 opti_type = OPTI_TYPE_ZERO_BYTE;
8936 dgst_pos0 = 0;
8937 dgst_pos1 = 1;
8938 dgst_pos2 = 2;
8939 dgst_pos3 = 3;
8940 break;
8941
8942 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8943 salt_type = SALT_TYPE_EMBEDDED;
8944 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8945 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8946 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8947 dgst_size = DGST_SIZE_4_5;
8948 parse_func = truecrypt_parse_hash_2k;
8949 sort_by_digest = sort_by_digest_4_5;
8950 opti_type = OPTI_TYPE_ZERO_BYTE;
8951 dgst_pos0 = 0;
8952 dgst_pos1 = 1;
8953 dgst_pos2 = 2;
8954 dgst_pos3 = 3;
8955 break;
8956
8957 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8958 salt_type = SALT_TYPE_EMBEDDED;
8959 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8960 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8961 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8962 dgst_size = DGST_SIZE_4_5;
8963 parse_func = truecrypt_parse_hash_2k;
8964 sort_by_digest = sort_by_digest_4_5;
8965 opti_type = OPTI_TYPE_ZERO_BYTE;
8966 dgst_pos0 = 0;
8967 dgst_pos1 = 1;
8968 dgst_pos2 = 2;
8969 dgst_pos3 = 3;
8970 break;
8971
8972 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8973 salt_type = SALT_TYPE_EMBEDDED;
8974 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8975 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8976 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8977 dgst_size = DGST_SIZE_4_5;
8978 parse_func = truecrypt_parse_hash_2k;
8979 sort_by_digest = sort_by_digest_4_5;
8980 opti_type = OPTI_TYPE_ZERO_BYTE;
8981 dgst_pos0 = 0;
8982 dgst_pos1 = 1;
8983 dgst_pos2 = 2;
8984 dgst_pos3 = 3;
8985 break;
8986
8987 case 6221: hash_type = HASH_TYPE_SHA512;
8988 salt_type = SALT_TYPE_EMBEDDED;
8989 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8990 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8991 kern_type = KERN_TYPE_TCSHA512_XTS512;
8992 dgst_size = DGST_SIZE_8_8;
8993 parse_func = truecrypt_parse_hash_1k;
8994 sort_by_digest = sort_by_digest_8_8;
8995 opti_type = OPTI_TYPE_ZERO_BYTE
8996 | OPTI_TYPE_USES_BITS_64;
8997 dgst_pos0 = 0;
8998 dgst_pos1 = 1;
8999 dgst_pos2 = 2;
9000 dgst_pos3 = 3;
9001 break;
9002
9003 case 6222: hash_type = HASH_TYPE_SHA512;
9004 salt_type = SALT_TYPE_EMBEDDED;
9005 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9006 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9007 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9008 dgst_size = DGST_SIZE_8_8;
9009 parse_func = truecrypt_parse_hash_1k;
9010 sort_by_digest = sort_by_digest_8_8;
9011 opti_type = OPTI_TYPE_ZERO_BYTE
9012 | OPTI_TYPE_USES_BITS_64;
9013 dgst_pos0 = 0;
9014 dgst_pos1 = 1;
9015 dgst_pos2 = 2;
9016 dgst_pos3 = 3;
9017 break;
9018
9019 case 6223: hash_type = HASH_TYPE_SHA512;
9020 salt_type = SALT_TYPE_EMBEDDED;
9021 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9022 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9023 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9024 dgst_size = DGST_SIZE_8_8;
9025 parse_func = truecrypt_parse_hash_1k;
9026 sort_by_digest = sort_by_digest_8_8;
9027 opti_type = OPTI_TYPE_ZERO_BYTE
9028 | OPTI_TYPE_USES_BITS_64;
9029 dgst_pos0 = 0;
9030 dgst_pos1 = 1;
9031 dgst_pos2 = 2;
9032 dgst_pos3 = 3;
9033 break;
9034
9035 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9036 salt_type = SALT_TYPE_EMBEDDED;
9037 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9038 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9039 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9040 dgst_size = DGST_SIZE_4_8;
9041 parse_func = truecrypt_parse_hash_1k;
9042 sort_by_digest = sort_by_digest_4_8;
9043 opti_type = OPTI_TYPE_ZERO_BYTE;
9044 dgst_pos0 = 0;
9045 dgst_pos1 = 1;
9046 dgst_pos2 = 2;
9047 dgst_pos3 = 3;
9048 break;
9049
9050 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9051 salt_type = SALT_TYPE_EMBEDDED;
9052 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9053 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9054 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9055 dgst_size = DGST_SIZE_4_8;
9056 parse_func = truecrypt_parse_hash_1k;
9057 sort_by_digest = sort_by_digest_4_8;
9058 opti_type = OPTI_TYPE_ZERO_BYTE;
9059 dgst_pos0 = 0;
9060 dgst_pos1 = 1;
9061 dgst_pos2 = 2;
9062 dgst_pos3 = 3;
9063 break;
9064
9065 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9066 salt_type = SALT_TYPE_EMBEDDED;
9067 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9068 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9069 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9070 dgst_size = DGST_SIZE_4_8;
9071 parse_func = truecrypt_parse_hash_1k;
9072 sort_by_digest = sort_by_digest_4_8;
9073 opti_type = OPTI_TYPE_ZERO_BYTE;
9074 dgst_pos0 = 0;
9075 dgst_pos1 = 1;
9076 dgst_pos2 = 2;
9077 dgst_pos3 = 3;
9078 break;
9079
9080 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9081 salt_type = SALT_TYPE_EMBEDDED;
9082 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9083 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9084 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9085 dgst_size = DGST_SIZE_4_5;
9086 parse_func = truecrypt_parse_hash_1k;
9087 sort_by_digest = sort_by_digest_4_5;
9088 opti_type = OPTI_TYPE_ZERO_BYTE;
9089 dgst_pos0 = 0;
9090 dgst_pos1 = 1;
9091 dgst_pos2 = 2;
9092 dgst_pos3 = 3;
9093 break;
9094
9095 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9096 salt_type = SALT_TYPE_EMBEDDED;
9097 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9098 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9099 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9100 dgst_size = DGST_SIZE_4_5;
9101 parse_func = truecrypt_parse_hash_1k;
9102 sort_by_digest = sort_by_digest_4_5;
9103 opti_type = OPTI_TYPE_ZERO_BYTE;
9104 dgst_pos0 = 0;
9105 dgst_pos1 = 1;
9106 dgst_pos2 = 2;
9107 dgst_pos3 = 3;
9108 break;
9109
9110 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9111 salt_type = SALT_TYPE_EMBEDDED;
9112 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9113 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9114 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9115 dgst_size = DGST_SIZE_4_5;
9116 parse_func = truecrypt_parse_hash_1k;
9117 sort_by_digest = sort_by_digest_4_5;
9118 opti_type = OPTI_TYPE_ZERO_BYTE;
9119 dgst_pos0 = 0;
9120 dgst_pos1 = 1;
9121 dgst_pos2 = 2;
9122 dgst_pos3 = 3;
9123 break;
9124
9125 case 6300: hash_type = HASH_TYPE_MD5;
9126 salt_type = SALT_TYPE_EMBEDDED;
9127 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9128 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9129 kern_type = KERN_TYPE_MD5AIX;
9130 dgst_size = DGST_SIZE_4_4;
9131 parse_func = md5aix_parse_hash;
9132 sort_by_digest = sort_by_digest_4_4;
9133 opti_type = OPTI_TYPE_ZERO_BYTE;
9134 dgst_pos0 = 0;
9135 dgst_pos1 = 1;
9136 dgst_pos2 = 2;
9137 dgst_pos3 = 3;
9138 break;
9139
9140 case 6400: hash_type = HASH_TYPE_SHA256;
9141 salt_type = SALT_TYPE_EMBEDDED;
9142 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9143 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9144 kern_type = KERN_TYPE_SHA256AIX;
9145 dgst_size = DGST_SIZE_4_8;
9146 parse_func = sha256aix_parse_hash;
9147 sort_by_digest = sort_by_digest_4_8;
9148 opti_type = OPTI_TYPE_ZERO_BYTE;
9149 dgst_pos0 = 0;
9150 dgst_pos1 = 1;
9151 dgst_pos2 = 2;
9152 dgst_pos3 = 3;
9153 break;
9154
9155 case 6500: hash_type = HASH_TYPE_SHA512;
9156 salt_type = SALT_TYPE_EMBEDDED;
9157 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9158 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9159 kern_type = KERN_TYPE_SHA512AIX;
9160 dgst_size = DGST_SIZE_8_8;
9161 parse_func = sha512aix_parse_hash;
9162 sort_by_digest = sort_by_digest_8_8;
9163 opti_type = OPTI_TYPE_ZERO_BYTE
9164 | OPTI_TYPE_USES_BITS_64;
9165 dgst_pos0 = 0;
9166 dgst_pos1 = 1;
9167 dgst_pos2 = 2;
9168 dgst_pos3 = 3;
9169 break;
9170
9171 case 6600: hash_type = HASH_TYPE_AES;
9172 salt_type = SALT_TYPE_EMBEDDED;
9173 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9174 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9175 kern_type = KERN_TYPE_AGILEKEY;
9176 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9177 parse_func = agilekey_parse_hash;
9178 sort_by_digest = sort_by_digest_4_5;
9179 opti_type = OPTI_TYPE_ZERO_BYTE;
9180 dgst_pos0 = 0;
9181 dgst_pos1 = 1;
9182 dgst_pos2 = 2;
9183 dgst_pos3 = 3;
9184 break;
9185
9186 case 6700: hash_type = HASH_TYPE_SHA1;
9187 salt_type = SALT_TYPE_EMBEDDED;
9188 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9189 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9190 kern_type = KERN_TYPE_SHA1AIX;
9191 dgst_size = DGST_SIZE_4_5;
9192 parse_func = sha1aix_parse_hash;
9193 sort_by_digest = sort_by_digest_4_5;
9194 opti_type = OPTI_TYPE_ZERO_BYTE;
9195 dgst_pos0 = 0;
9196 dgst_pos1 = 1;
9197 dgst_pos2 = 2;
9198 dgst_pos3 = 3;
9199 break;
9200
9201 case 6800: hash_type = HASH_TYPE_AES;
9202 salt_type = SALT_TYPE_EMBEDDED;
9203 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9204 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9205 kern_type = KERN_TYPE_LASTPASS;
9206 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9207 parse_func = lastpass_parse_hash;
9208 sort_by_digest = sort_by_digest_4_8;
9209 opti_type = OPTI_TYPE_ZERO_BYTE;
9210 dgst_pos0 = 0;
9211 dgst_pos1 = 1;
9212 dgst_pos2 = 2;
9213 dgst_pos3 = 3;
9214 break;
9215
9216 case 6900: hash_type = HASH_TYPE_GOST;
9217 salt_type = SALT_TYPE_NONE;
9218 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9219 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9220 kern_type = KERN_TYPE_GOST;
9221 dgst_size = DGST_SIZE_4_8;
9222 parse_func = gost_parse_hash;
9223 sort_by_digest = sort_by_digest_4_8;
9224 opti_type = OPTI_TYPE_ZERO_BYTE;
9225 dgst_pos0 = 0;
9226 dgst_pos1 = 1;
9227 dgst_pos2 = 2;
9228 dgst_pos3 = 3;
9229 break;
9230
9231 case 7100: hash_type = HASH_TYPE_SHA512;
9232 salt_type = SALT_TYPE_EMBEDDED;
9233 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9234 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9235 kern_type = KERN_TYPE_PBKDF2_SHA512;
9236 dgst_size = DGST_SIZE_8_16;
9237 parse_func = sha512osx_parse_hash;
9238 sort_by_digest = sort_by_digest_8_16;
9239 opti_type = OPTI_TYPE_ZERO_BYTE
9240 | OPTI_TYPE_USES_BITS_64;
9241 dgst_pos0 = 0;
9242 dgst_pos1 = 1;
9243 dgst_pos2 = 2;
9244 dgst_pos3 = 3;
9245 break;
9246
9247 case 7200: hash_type = HASH_TYPE_SHA512;
9248 salt_type = SALT_TYPE_EMBEDDED;
9249 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9250 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9251 kern_type = KERN_TYPE_PBKDF2_SHA512;
9252 dgst_size = DGST_SIZE_8_16;
9253 parse_func = sha512grub_parse_hash;
9254 sort_by_digest = sort_by_digest_8_16;
9255 opti_type = OPTI_TYPE_ZERO_BYTE
9256 | OPTI_TYPE_USES_BITS_64;
9257 dgst_pos0 = 0;
9258 dgst_pos1 = 1;
9259 dgst_pos2 = 2;
9260 dgst_pos3 = 3;
9261 break;
9262
9263 case 7300: hash_type = HASH_TYPE_SHA1;
9264 salt_type = SALT_TYPE_EMBEDDED;
9265 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9266 opts_type = OPTS_TYPE_PT_GENERATE_BE
9267 | OPTS_TYPE_ST_ADD80
9268 | OPTS_TYPE_ST_ADDBITS15;
9269 kern_type = KERN_TYPE_RAKP;
9270 dgst_size = DGST_SIZE_4_5;
9271 parse_func = rakp_parse_hash;
9272 sort_by_digest = sort_by_digest_4_5;
9273 opti_type = OPTI_TYPE_ZERO_BYTE
9274 | OPTI_TYPE_NOT_ITERATED;
9275 dgst_pos0 = 3;
9276 dgst_pos1 = 4;
9277 dgst_pos2 = 2;
9278 dgst_pos3 = 1;
9279 break;
9280
9281 case 7400: hash_type = HASH_TYPE_SHA256;
9282 salt_type = SALT_TYPE_EMBEDDED;
9283 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9284 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9285 kern_type = KERN_TYPE_SHA256CRYPT;
9286 dgst_size = DGST_SIZE_4_8;
9287 parse_func = sha256crypt_parse_hash;
9288 sort_by_digest = sort_by_digest_4_8;
9289 opti_type = OPTI_TYPE_ZERO_BYTE;
9290 dgst_pos0 = 0;
9291 dgst_pos1 = 1;
9292 dgst_pos2 = 2;
9293 dgst_pos3 = 3;
9294 break;
9295
9296 case 7500: hash_type = HASH_TYPE_KRB5PA;
9297 salt_type = SALT_TYPE_EMBEDDED;
9298 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9299 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9300 kern_type = KERN_TYPE_KRB5PA;
9301 dgst_size = DGST_SIZE_4_4;
9302 parse_func = krb5pa_parse_hash;
9303 sort_by_digest = sort_by_digest_4_4;
9304 opti_type = OPTI_TYPE_ZERO_BYTE
9305 | OPTI_TYPE_NOT_ITERATED;
9306 dgst_pos0 = 0;
9307 dgst_pos1 = 1;
9308 dgst_pos2 = 2;
9309 dgst_pos3 = 3;
9310 break;
9311
9312 case 7600: hash_type = HASH_TYPE_SHA1;
9313 salt_type = SALT_TYPE_INTERN;
9314 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9315 opts_type = OPTS_TYPE_PT_GENERATE_BE
9316 | OPTS_TYPE_PT_ADD80
9317 | OPTS_TYPE_PT_ADDBITS15;
9318 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9319 dgst_size = DGST_SIZE_4_5;
9320 parse_func = redmine_parse_hash;
9321 sort_by_digest = sort_by_digest_4_5;
9322 opti_type = OPTI_TYPE_ZERO_BYTE
9323 | OPTI_TYPE_PRECOMPUTE_INIT
9324 | OPTI_TYPE_EARLY_SKIP
9325 | OPTI_TYPE_NOT_ITERATED
9326 | OPTI_TYPE_PREPENDED_SALT;
9327 dgst_pos0 = 3;
9328 dgst_pos1 = 4;
9329 dgst_pos2 = 2;
9330 dgst_pos3 = 1;
9331 break;
9332
9333 case 7700: hash_type = HASH_TYPE_SAPB;
9334 salt_type = SALT_TYPE_EMBEDDED;
9335 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9336 opts_type = OPTS_TYPE_PT_GENERATE_LE
9337 | OPTS_TYPE_PT_UPPER
9338 | OPTS_TYPE_ST_UPPER;
9339 kern_type = KERN_TYPE_SAPB;
9340 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9341 parse_func = sapb_parse_hash;
9342 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9343 opti_type = OPTI_TYPE_ZERO_BYTE
9344 | OPTI_TYPE_PRECOMPUTE_INIT
9345 | OPTI_TYPE_NOT_ITERATED;
9346 dgst_pos0 = 0;
9347 dgst_pos1 = 1;
9348 dgst_pos2 = 2;
9349 dgst_pos3 = 3;
9350 break;
9351
9352 case 7800: hash_type = HASH_TYPE_SAPG;
9353 salt_type = SALT_TYPE_EMBEDDED;
9354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9355 opts_type = OPTS_TYPE_PT_GENERATE_BE
9356 | OPTS_TYPE_ST_ADD80
9357 | OPTS_TYPE_ST_UPPER;
9358 kern_type = KERN_TYPE_SAPG;
9359 dgst_size = DGST_SIZE_4_5;
9360 parse_func = sapg_parse_hash;
9361 sort_by_digest = sort_by_digest_4_5;
9362 opti_type = OPTI_TYPE_ZERO_BYTE
9363 | OPTI_TYPE_PRECOMPUTE_INIT
9364 | OPTI_TYPE_NOT_ITERATED;
9365 dgst_pos0 = 3;
9366 dgst_pos1 = 4;
9367 dgst_pos2 = 2;
9368 dgst_pos3 = 1;
9369 break;
9370
9371 case 7900: hash_type = HASH_TYPE_SHA512;
9372 salt_type = SALT_TYPE_EMBEDDED;
9373 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9374 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9375 kern_type = KERN_TYPE_DRUPAL7;
9376 dgst_size = DGST_SIZE_8_8;
9377 parse_func = drupal7_parse_hash;
9378 sort_by_digest = sort_by_digest_8_8;
9379 opti_type = OPTI_TYPE_ZERO_BYTE
9380 | OPTI_TYPE_USES_BITS_64;
9381 dgst_pos0 = 0;
9382 dgst_pos1 = 1;
9383 dgst_pos2 = 2;
9384 dgst_pos3 = 3;
9385 break;
9386
9387 case 8000: hash_type = HASH_TYPE_SHA256;
9388 salt_type = SALT_TYPE_EMBEDDED;
9389 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9390 opts_type = OPTS_TYPE_PT_GENERATE_BE
9391 | OPTS_TYPE_PT_UNICODE
9392 | OPTS_TYPE_ST_ADD80
9393 | OPTS_TYPE_ST_HEX;
9394 kern_type = KERN_TYPE_SYBASEASE;
9395 dgst_size = DGST_SIZE_4_8;
9396 parse_func = sybasease_parse_hash;
9397 sort_by_digest = sort_by_digest_4_8;
9398 opti_type = OPTI_TYPE_ZERO_BYTE
9399 | OPTI_TYPE_PRECOMPUTE_INIT
9400 | OPTI_TYPE_EARLY_SKIP
9401 | OPTI_TYPE_NOT_ITERATED
9402 | OPTI_TYPE_RAW_HASH;
9403 dgst_pos0 = 3;
9404 dgst_pos1 = 7;
9405 dgst_pos2 = 2;
9406 dgst_pos3 = 6;
9407 break;
9408
9409 case 8100: hash_type = HASH_TYPE_SHA1;
9410 salt_type = SALT_TYPE_EMBEDDED;
9411 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9412 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9413 kern_type = KERN_TYPE_NETSCALER;
9414 dgst_size = DGST_SIZE_4_5;
9415 parse_func = netscaler_parse_hash;
9416 sort_by_digest = sort_by_digest_4_5;
9417 opti_type = OPTI_TYPE_ZERO_BYTE
9418 | OPTI_TYPE_PRECOMPUTE_INIT
9419 | OPTI_TYPE_PRECOMPUTE_MERKLE
9420 | OPTI_TYPE_EARLY_SKIP
9421 | OPTI_TYPE_NOT_ITERATED
9422 | OPTI_TYPE_PREPENDED_SALT
9423 | OPTI_TYPE_RAW_HASH;
9424 dgst_pos0 = 3;
9425 dgst_pos1 = 4;
9426 dgst_pos2 = 2;
9427 dgst_pos3 = 1;
9428 break;
9429
9430 case 8200: hash_type = HASH_TYPE_SHA256;
9431 salt_type = SALT_TYPE_EMBEDDED;
9432 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9433 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9434 kern_type = KERN_TYPE_CLOUDKEY;
9435 dgst_size = DGST_SIZE_4_8;
9436 parse_func = cloudkey_parse_hash;
9437 sort_by_digest = sort_by_digest_4_8;
9438 opti_type = OPTI_TYPE_ZERO_BYTE;
9439 dgst_pos0 = 0;
9440 dgst_pos1 = 1;
9441 dgst_pos2 = 2;
9442 dgst_pos3 = 3;
9443 break;
9444
9445 case 8300: hash_type = HASH_TYPE_SHA1;
9446 salt_type = SALT_TYPE_EMBEDDED;
9447 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9448 opts_type = OPTS_TYPE_PT_GENERATE_LE
9449 | OPTS_TYPE_ST_HEX
9450 | OPTS_TYPE_ST_ADD80;
9451 kern_type = KERN_TYPE_NSEC3;
9452 dgst_size = DGST_SIZE_4_5;
9453 parse_func = nsec3_parse_hash;
9454 sort_by_digest = sort_by_digest_4_5;
9455 opti_type = OPTI_TYPE_ZERO_BYTE;
9456 dgst_pos0 = 3;
9457 dgst_pos1 = 4;
9458 dgst_pos2 = 2;
9459 dgst_pos3 = 1;
9460 break;
9461
9462 case 8400: hash_type = HASH_TYPE_SHA1;
9463 salt_type = SALT_TYPE_INTERN;
9464 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9465 opts_type = OPTS_TYPE_PT_GENERATE_BE
9466 | OPTS_TYPE_PT_ADD80
9467 | OPTS_TYPE_PT_ADDBITS15;
9468 kern_type = KERN_TYPE_WBB3;
9469 dgst_size = DGST_SIZE_4_5;
9470 parse_func = wbb3_parse_hash;
9471 sort_by_digest = sort_by_digest_4_5;
9472 opti_type = OPTI_TYPE_ZERO_BYTE
9473 | OPTI_TYPE_PRECOMPUTE_INIT
9474 | OPTI_TYPE_NOT_ITERATED;
9475 dgst_pos0 = 3;
9476 dgst_pos1 = 4;
9477 dgst_pos2 = 2;
9478 dgst_pos3 = 1;
9479 break;
9480
9481 case 8500: hash_type = HASH_TYPE_DESRACF;
9482 salt_type = SALT_TYPE_EMBEDDED;
9483 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9484 opts_type = OPTS_TYPE_PT_GENERATE_LE
9485 | OPTS_TYPE_ST_UPPER;
9486 kern_type = KERN_TYPE_RACF;
9487 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9488 parse_func = racf_parse_hash;
9489 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9490 opti_type = OPTI_TYPE_ZERO_BYTE
9491 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9492 dgst_pos0 = 0;
9493 dgst_pos1 = 1;
9494 dgst_pos2 = 2;
9495 dgst_pos3 = 3;
9496 break;
9497
9498 case 8600: hash_type = HASH_TYPE_LOTUS5;
9499 salt_type = SALT_TYPE_NONE;
9500 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9501 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9502 kern_type = KERN_TYPE_LOTUS5;
9503 dgst_size = DGST_SIZE_4_4;
9504 parse_func = lotus5_parse_hash;
9505 sort_by_digest = sort_by_digest_4_4;
9506 opti_type = OPTI_TYPE_EARLY_SKIP
9507 | OPTI_TYPE_NOT_ITERATED
9508 | OPTI_TYPE_NOT_SALTED
9509 | OPTI_TYPE_RAW_HASH;
9510 dgst_pos0 = 0;
9511 dgst_pos1 = 1;
9512 dgst_pos2 = 2;
9513 dgst_pos3 = 3;
9514 break;
9515
9516 case 8700: hash_type = HASH_TYPE_LOTUS6;
9517 salt_type = SALT_TYPE_EMBEDDED;
9518 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9519 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9520 kern_type = KERN_TYPE_LOTUS6;
9521 dgst_size = DGST_SIZE_4_4;
9522 parse_func = lotus6_parse_hash;
9523 sort_by_digest = sort_by_digest_4_4;
9524 opti_type = OPTI_TYPE_EARLY_SKIP
9525 | OPTI_TYPE_NOT_ITERATED
9526 | OPTI_TYPE_RAW_HASH;
9527 dgst_pos0 = 0;
9528 dgst_pos1 = 1;
9529 dgst_pos2 = 2;
9530 dgst_pos3 = 3;
9531 break;
9532
9533 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9534 salt_type = SALT_TYPE_EMBEDDED;
9535 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9536 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9537 kern_type = KERN_TYPE_ANDROIDFDE;
9538 dgst_size = DGST_SIZE_4_4;
9539 parse_func = androidfde_parse_hash;
9540 sort_by_digest = sort_by_digest_4_4;
9541 opti_type = OPTI_TYPE_ZERO_BYTE;
9542 dgst_pos0 = 0;
9543 dgst_pos1 = 1;
9544 dgst_pos2 = 2;
9545 dgst_pos3 = 3;
9546 break;
9547
9548 case 8900: hash_type = HASH_TYPE_SCRYPT;
9549 salt_type = SALT_TYPE_EMBEDDED;
9550 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9551 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9552 kern_type = KERN_TYPE_SCRYPT;
9553 dgst_size = DGST_SIZE_4_8;
9554 parse_func = scrypt_parse_hash;
9555 sort_by_digest = sort_by_digest_4_8;
9556 opti_type = OPTI_TYPE_ZERO_BYTE;
9557 dgst_pos0 = 0;
9558 dgst_pos1 = 1;
9559 dgst_pos2 = 2;
9560 dgst_pos3 = 3;
9561 break;
9562
9563 case 9000: hash_type = HASH_TYPE_SHA1;
9564 salt_type = SALT_TYPE_EMBEDDED;
9565 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9566 opts_type = OPTS_TYPE_PT_GENERATE_LE
9567 | OPTS_TYPE_ST_GENERATE_LE;
9568 kern_type = KERN_TYPE_PSAFE2;
9569 dgst_size = DGST_SIZE_4_5;
9570 parse_func = psafe2_parse_hash;
9571 sort_by_digest = sort_by_digest_4_5;
9572 opti_type = OPTI_TYPE_ZERO_BYTE;
9573 dgst_pos0 = 0;
9574 dgst_pos1 = 1;
9575 dgst_pos2 = 2;
9576 dgst_pos3 = 3;
9577 break;
9578
9579 case 9100: hash_type = HASH_TYPE_LOTUS8;
9580 salt_type = SALT_TYPE_EMBEDDED;
9581 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9582 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9583 kern_type = KERN_TYPE_LOTUS8;
9584 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9585 parse_func = lotus8_parse_hash;
9586 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9587 opti_type = OPTI_TYPE_ZERO_BYTE;
9588 dgst_pos0 = 0;
9589 dgst_pos1 = 1;
9590 dgst_pos2 = 2;
9591 dgst_pos3 = 3;
9592 break;
9593
9594 case 9200: hash_type = HASH_TYPE_SHA256;
9595 salt_type = SALT_TYPE_EMBEDDED;
9596 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9597 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9598 kern_type = KERN_TYPE_PBKDF2_SHA256;
9599 dgst_size = DGST_SIZE_4_32;
9600 parse_func = cisco8_parse_hash;
9601 sort_by_digest = sort_by_digest_4_32;
9602 opti_type = OPTI_TYPE_ZERO_BYTE;
9603 dgst_pos0 = 0;
9604 dgst_pos1 = 1;
9605 dgst_pos2 = 2;
9606 dgst_pos3 = 3;
9607 break;
9608
9609 case 9300: hash_type = HASH_TYPE_SCRYPT;
9610 salt_type = SALT_TYPE_EMBEDDED;
9611 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9612 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9613 kern_type = KERN_TYPE_SCRYPT;
9614 dgst_size = DGST_SIZE_4_8;
9615 parse_func = cisco9_parse_hash;
9616 sort_by_digest = sort_by_digest_4_8;
9617 opti_type = OPTI_TYPE_ZERO_BYTE;
9618 dgst_pos0 = 0;
9619 dgst_pos1 = 1;
9620 dgst_pos2 = 2;
9621 dgst_pos3 = 3;
9622 break;
9623
9624 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9625 salt_type = SALT_TYPE_EMBEDDED;
9626 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9627 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9628 kern_type = KERN_TYPE_OFFICE2007;
9629 dgst_size = DGST_SIZE_4_4;
9630 parse_func = office2007_parse_hash;
9631 sort_by_digest = sort_by_digest_4_4;
9632 opti_type = OPTI_TYPE_ZERO_BYTE;
9633 dgst_pos0 = 0;
9634 dgst_pos1 = 1;
9635 dgst_pos2 = 2;
9636 dgst_pos3 = 3;
9637 break;
9638
9639 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9640 salt_type = SALT_TYPE_EMBEDDED;
9641 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9642 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9643 kern_type = KERN_TYPE_OFFICE2010;
9644 dgst_size = DGST_SIZE_4_4;
9645 parse_func = office2010_parse_hash;
9646 sort_by_digest = sort_by_digest_4_4;
9647 opti_type = OPTI_TYPE_ZERO_BYTE;
9648 dgst_pos0 = 0;
9649 dgst_pos1 = 1;
9650 dgst_pos2 = 2;
9651 dgst_pos3 = 3;
9652 break;
9653
9654 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9655 salt_type = SALT_TYPE_EMBEDDED;
9656 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9657 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9658 kern_type = KERN_TYPE_OFFICE2013;
9659 dgst_size = DGST_SIZE_4_4;
9660 parse_func = office2013_parse_hash;
9661 sort_by_digest = sort_by_digest_4_4;
9662 opti_type = OPTI_TYPE_ZERO_BYTE;
9663 dgst_pos0 = 0;
9664 dgst_pos1 = 1;
9665 dgst_pos2 = 2;
9666 dgst_pos3 = 3;
9667 break;
9668
9669 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9670 salt_type = SALT_TYPE_EMBEDDED;
9671 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9672 opts_type = OPTS_TYPE_PT_GENERATE_LE
9673 | OPTS_TYPE_PT_ADD80
9674 | OPTS_TYPE_PT_UNICODE;
9675 kern_type = KERN_TYPE_OLDOFFICE01;
9676 dgst_size = DGST_SIZE_4_4;
9677 parse_func = oldoffice01_parse_hash;
9678 sort_by_digest = sort_by_digest_4_4;
9679 opti_type = OPTI_TYPE_ZERO_BYTE
9680 | OPTI_TYPE_PRECOMPUTE_INIT
9681 | OPTI_TYPE_NOT_ITERATED;
9682 dgst_pos0 = 0;
9683 dgst_pos1 = 1;
9684 dgst_pos2 = 2;
9685 dgst_pos3 = 3;
9686 break;
9687
9688 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9689 salt_type = SALT_TYPE_EMBEDDED;
9690 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9691 opts_type = OPTS_TYPE_PT_GENERATE_LE
9692 | OPTS_TYPE_PT_ADD80;
9693 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9694 dgst_size = DGST_SIZE_4_4;
9695 parse_func = oldoffice01cm1_parse_hash;
9696 sort_by_digest = sort_by_digest_4_4;
9697 opti_type = OPTI_TYPE_ZERO_BYTE
9698 | OPTI_TYPE_PRECOMPUTE_INIT
9699 | OPTI_TYPE_NOT_ITERATED;
9700 dgst_pos0 = 0;
9701 dgst_pos1 = 1;
9702 dgst_pos2 = 2;
9703 dgst_pos3 = 3;
9704 break;
9705
9706 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9707 salt_type = SALT_TYPE_EMBEDDED;
9708 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9709 opts_type = OPTS_TYPE_PT_GENERATE_LE
9710 | OPTS_TYPE_PT_ADD80
9711 | OPTS_TYPE_PT_UNICODE
9712 | OPTS_TYPE_PT_NEVERCRACK;
9713 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9714 dgst_size = DGST_SIZE_4_4;
9715 parse_func = oldoffice01cm2_parse_hash;
9716 sort_by_digest = sort_by_digest_4_4;
9717 opti_type = OPTI_TYPE_ZERO_BYTE
9718 | OPTI_TYPE_PRECOMPUTE_INIT
9719 | OPTI_TYPE_NOT_ITERATED;
9720 dgst_pos0 = 0;
9721 dgst_pos1 = 1;
9722 dgst_pos2 = 2;
9723 dgst_pos3 = 3;
9724 break;
9725
9726 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9727 salt_type = SALT_TYPE_EMBEDDED;
9728 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9729 opts_type = OPTS_TYPE_PT_GENERATE_BE
9730 | OPTS_TYPE_PT_ADD80
9731 | OPTS_TYPE_PT_UNICODE;
9732 kern_type = KERN_TYPE_OLDOFFICE34;
9733 dgst_size = DGST_SIZE_4_4;
9734 parse_func = oldoffice34_parse_hash;
9735 sort_by_digest = sort_by_digest_4_4;
9736 opti_type = OPTI_TYPE_ZERO_BYTE
9737 | OPTI_TYPE_PRECOMPUTE_INIT
9738 | OPTI_TYPE_NOT_ITERATED;
9739 dgst_pos0 = 0;
9740 dgst_pos1 = 1;
9741 dgst_pos2 = 2;
9742 dgst_pos3 = 3;
9743 break;
9744
9745 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9746 salt_type = SALT_TYPE_EMBEDDED;
9747 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9748 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9749 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9750 dgst_size = DGST_SIZE_4_4;
9751 parse_func = oldoffice34cm1_parse_hash;
9752 sort_by_digest = sort_by_digest_4_4;
9753 opti_type = OPTI_TYPE_ZERO_BYTE
9754 | OPTI_TYPE_PRECOMPUTE_INIT
9755 | OPTI_TYPE_NOT_ITERATED;
9756 dgst_pos0 = 0;
9757 dgst_pos1 = 1;
9758 dgst_pos2 = 2;
9759 dgst_pos3 = 3;
9760 break;
9761
9762 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9763 salt_type = SALT_TYPE_EMBEDDED;
9764 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9765 opts_type = OPTS_TYPE_PT_GENERATE_BE
9766 | OPTS_TYPE_PT_ADD80
9767 | OPTS_TYPE_PT_UNICODE
9768 | OPTS_TYPE_PT_NEVERCRACK;
9769 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9770 dgst_size = DGST_SIZE_4_4;
9771 parse_func = oldoffice34cm2_parse_hash;
9772 sort_by_digest = sort_by_digest_4_4;
9773 opti_type = OPTI_TYPE_ZERO_BYTE
9774 | OPTI_TYPE_PRECOMPUTE_INIT
9775 | OPTI_TYPE_NOT_ITERATED;
9776 dgst_pos0 = 0;
9777 dgst_pos1 = 1;
9778 dgst_pos2 = 2;
9779 dgst_pos3 = 3;
9780 break;
9781
9782 case 9900: hash_type = HASH_TYPE_MD5;
9783 salt_type = SALT_TYPE_NONE;
9784 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9785 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9786 kern_type = KERN_TYPE_RADMIN2;
9787 dgst_size = DGST_SIZE_4_4;
9788 parse_func = radmin2_parse_hash;
9789 sort_by_digest = sort_by_digest_4_4;
9790 opti_type = OPTI_TYPE_ZERO_BYTE
9791 | OPTI_TYPE_PRECOMPUTE_INIT
9792 | OPTI_TYPE_EARLY_SKIP
9793 | OPTI_TYPE_NOT_ITERATED
9794 | OPTI_TYPE_NOT_SALTED;
9795 dgst_pos0 = 0;
9796 dgst_pos1 = 3;
9797 dgst_pos2 = 2;
9798 dgst_pos3 = 1;
9799 break;
9800
9801 case 10000: hash_type = HASH_TYPE_SHA256;
9802 salt_type = SALT_TYPE_EMBEDDED;
9803 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9804 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9805 kern_type = KERN_TYPE_PBKDF2_SHA256;
9806 dgst_size = DGST_SIZE_4_32;
9807 parse_func = djangopbkdf2_parse_hash;
9808 sort_by_digest = sort_by_digest_4_32;
9809 opti_type = OPTI_TYPE_ZERO_BYTE;
9810 dgst_pos0 = 0;
9811 dgst_pos1 = 1;
9812 dgst_pos2 = 2;
9813 dgst_pos3 = 3;
9814 break;
9815
9816 case 10100: hash_type = HASH_TYPE_SIPHASH;
9817 salt_type = SALT_TYPE_EMBEDDED;
9818 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9819 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9820 kern_type = KERN_TYPE_SIPHASH;
9821 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9822 parse_func = siphash_parse_hash;
9823 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9824 opti_type = OPTI_TYPE_ZERO_BYTE
9825 | OPTI_TYPE_NOT_ITERATED
9826 | OPTI_TYPE_RAW_HASH;
9827 dgst_pos0 = 0;
9828 dgst_pos1 = 1;
9829 dgst_pos2 = 2;
9830 dgst_pos3 = 3;
9831 break;
9832
9833 case 10200: hash_type = HASH_TYPE_MD5;
9834 salt_type = SALT_TYPE_EMBEDDED;
9835 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9836 opts_type = OPTS_TYPE_PT_GENERATE_LE
9837 | OPTS_TYPE_ST_ADD80
9838 | OPTS_TYPE_ST_ADDBITS14;
9839 kern_type = KERN_TYPE_HMACMD5_PW;
9840 dgst_size = DGST_SIZE_4_4;
9841 parse_func = crammd5_parse_hash;
9842 sort_by_digest = sort_by_digest_4_4;
9843 opti_type = OPTI_TYPE_ZERO_BYTE
9844 | OPTI_TYPE_NOT_ITERATED;
9845 dgst_pos0 = 0;
9846 dgst_pos1 = 3;
9847 dgst_pos2 = 2;
9848 dgst_pos3 = 1;
9849 break;
9850
9851 case 10300: hash_type = HASH_TYPE_SHA1;
9852 salt_type = SALT_TYPE_EMBEDDED;
9853 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9854 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9855 kern_type = KERN_TYPE_SAPH_SHA1;
9856 dgst_size = DGST_SIZE_4_5;
9857 parse_func = saph_sha1_parse_hash;
9858 sort_by_digest = sort_by_digest_4_5;
9859 opti_type = OPTI_TYPE_ZERO_BYTE;
9860 dgst_pos0 = 0;
9861 dgst_pos1 = 1;
9862 dgst_pos2 = 2;
9863 dgst_pos3 = 3;
9864 break;
9865
9866 case 10400: hash_type = HASH_TYPE_PDFU16;
9867 salt_type = SALT_TYPE_EMBEDDED;
9868 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9869 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9870 kern_type = KERN_TYPE_PDF11;
9871 dgst_size = DGST_SIZE_4_4;
9872 parse_func = pdf11_parse_hash;
9873 sort_by_digest = sort_by_digest_4_4;
9874 opti_type = OPTI_TYPE_ZERO_BYTE
9875 | OPTI_TYPE_NOT_ITERATED;
9876 dgst_pos0 = 0;
9877 dgst_pos1 = 1;
9878 dgst_pos2 = 2;
9879 dgst_pos3 = 3;
9880 break;
9881
9882 case 10410: hash_type = HASH_TYPE_PDFU16;
9883 salt_type = SALT_TYPE_EMBEDDED;
9884 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9885 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9886 kern_type = KERN_TYPE_PDF11CM1;
9887 dgst_size = DGST_SIZE_4_4;
9888 parse_func = pdf11cm1_parse_hash;
9889 sort_by_digest = sort_by_digest_4_4;
9890 opti_type = OPTI_TYPE_ZERO_BYTE
9891 | OPTI_TYPE_NOT_ITERATED;
9892 dgst_pos0 = 0;
9893 dgst_pos1 = 1;
9894 dgst_pos2 = 2;
9895 dgst_pos3 = 3;
9896 break;
9897
9898 case 10420: hash_type = HASH_TYPE_PDFU16;
9899 salt_type = SALT_TYPE_EMBEDDED;
9900 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9901 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9902 kern_type = KERN_TYPE_PDF11CM2;
9903 dgst_size = DGST_SIZE_4_4;
9904 parse_func = pdf11cm2_parse_hash;
9905 sort_by_digest = sort_by_digest_4_4;
9906 opti_type = OPTI_TYPE_ZERO_BYTE
9907 | OPTI_TYPE_NOT_ITERATED;
9908 dgst_pos0 = 0;
9909 dgst_pos1 = 1;
9910 dgst_pos2 = 2;
9911 dgst_pos3 = 3;
9912 break;
9913
9914 case 10500: hash_type = HASH_TYPE_PDFU16;
9915 salt_type = SALT_TYPE_EMBEDDED;
9916 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9917 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9918 kern_type = KERN_TYPE_PDF14;
9919 dgst_size = DGST_SIZE_4_4;
9920 parse_func = pdf14_parse_hash;
9921 sort_by_digest = sort_by_digest_4_4;
9922 opti_type = OPTI_TYPE_ZERO_BYTE
9923 | OPTI_TYPE_NOT_ITERATED;
9924 dgst_pos0 = 0;
9925 dgst_pos1 = 1;
9926 dgst_pos2 = 2;
9927 dgst_pos3 = 3;
9928 break;
9929
9930 case 10600: hash_type = HASH_TYPE_SHA256;
9931 salt_type = SALT_TYPE_EMBEDDED;
9932 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9933 opts_type = OPTS_TYPE_PT_GENERATE_BE
9934 | OPTS_TYPE_ST_ADD80
9935 | OPTS_TYPE_ST_ADDBITS15
9936 | OPTS_TYPE_HASH_COPY;
9937 kern_type = KERN_TYPE_SHA256_PWSLT;
9938 dgst_size = DGST_SIZE_4_8;
9939 parse_func = pdf17l3_parse_hash;
9940 sort_by_digest = sort_by_digest_4_8;
9941 opti_type = OPTI_TYPE_ZERO_BYTE
9942 | OPTI_TYPE_PRECOMPUTE_INIT
9943 | OPTI_TYPE_PRECOMPUTE_MERKLE
9944 | OPTI_TYPE_EARLY_SKIP
9945 | OPTI_TYPE_NOT_ITERATED
9946 | OPTI_TYPE_APPENDED_SALT
9947 | OPTI_TYPE_RAW_HASH;
9948 dgst_pos0 = 3;
9949 dgst_pos1 = 7;
9950 dgst_pos2 = 2;
9951 dgst_pos3 = 6;
9952 break;
9953
9954 case 10700: hash_type = HASH_TYPE_PDFU32;
9955 salt_type = SALT_TYPE_EMBEDDED;
9956 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9957 opts_type = OPTS_TYPE_PT_GENERATE_LE
9958 | OPTS_TYPE_HASH_COPY;
9959 kern_type = KERN_TYPE_PDF17L8;
9960 dgst_size = DGST_SIZE_4_8;
9961 parse_func = pdf17l8_parse_hash;
9962 sort_by_digest = sort_by_digest_4_8;
9963 opti_type = OPTI_TYPE_ZERO_BYTE
9964 | OPTI_TYPE_NOT_ITERATED;
9965 dgst_pos0 = 0;
9966 dgst_pos1 = 1;
9967 dgst_pos2 = 2;
9968 dgst_pos3 = 3;
9969 break;
9970
9971 case 10800: hash_type = HASH_TYPE_SHA384;
9972 salt_type = SALT_TYPE_NONE;
9973 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9974 opts_type = OPTS_TYPE_PT_GENERATE_BE
9975 | OPTS_TYPE_PT_ADD80
9976 | OPTS_TYPE_PT_ADDBITS15;
9977 kern_type = KERN_TYPE_SHA384;
9978 dgst_size = DGST_SIZE_8_8;
9979 parse_func = sha384_parse_hash;
9980 sort_by_digest = sort_by_digest_8_8;
9981 opti_type = OPTI_TYPE_ZERO_BYTE
9982 | OPTI_TYPE_PRECOMPUTE_INIT
9983 | OPTI_TYPE_PRECOMPUTE_MERKLE
9984 | OPTI_TYPE_EARLY_SKIP
9985 | OPTI_TYPE_NOT_ITERATED
9986 | OPTI_TYPE_NOT_SALTED
9987 | OPTI_TYPE_USES_BITS_64
9988 | OPTI_TYPE_RAW_HASH;
9989 dgst_pos0 = 6;
9990 dgst_pos1 = 7;
9991 dgst_pos2 = 4;
9992 dgst_pos3 = 5;
9993 break;
9994
9995 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9996 salt_type = SALT_TYPE_EMBEDDED;
9997 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9998 opts_type = OPTS_TYPE_PT_GENERATE_LE
9999 | OPTS_TYPE_ST_BASE64
10000 | OPTS_TYPE_HASH_COPY;
10001 kern_type = KERN_TYPE_PBKDF2_SHA256;
10002 dgst_size = DGST_SIZE_4_32;
10003 parse_func = pbkdf2_sha256_parse_hash;
10004 sort_by_digest = sort_by_digest_4_32;
10005 opti_type = OPTI_TYPE_ZERO_BYTE;
10006 dgst_pos0 = 0;
10007 dgst_pos1 = 1;
10008 dgst_pos2 = 2;
10009 dgst_pos3 = 3;
10010 break;
10011
10012 case 11000: hash_type = HASH_TYPE_MD5;
10013 salt_type = SALT_TYPE_INTERN;
10014 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10015 opts_type = OPTS_TYPE_PT_GENERATE_LE
10016 | OPTS_TYPE_PT_ADD80;
10017 kern_type = KERN_TYPE_PRESTASHOP;
10018 dgst_size = DGST_SIZE_4_4;
10019 parse_func = prestashop_parse_hash;
10020 sort_by_digest = sort_by_digest_4_4;
10021 opti_type = OPTI_TYPE_ZERO_BYTE
10022 | OPTI_TYPE_PRECOMPUTE_INIT
10023 | OPTI_TYPE_NOT_ITERATED
10024 | OPTI_TYPE_PREPENDED_SALT;
10025 dgst_pos0 = 0;
10026 dgst_pos1 = 3;
10027 dgst_pos2 = 2;
10028 dgst_pos3 = 1;
10029 break;
10030
10031 case 11100: hash_type = HASH_TYPE_MD5;
10032 salt_type = SALT_TYPE_EMBEDDED;
10033 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10034 opts_type = OPTS_TYPE_PT_GENERATE_LE
10035 | OPTS_TYPE_ST_ADD80;
10036 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10037 dgst_size = DGST_SIZE_4_4;
10038 parse_func = postgresql_auth_parse_hash;
10039 sort_by_digest = sort_by_digest_4_4;
10040 opti_type = OPTI_TYPE_ZERO_BYTE
10041 | OPTI_TYPE_PRECOMPUTE_INIT
10042 | OPTI_TYPE_PRECOMPUTE_MERKLE
10043 | OPTI_TYPE_EARLY_SKIP;
10044 dgst_pos0 = 0;
10045 dgst_pos1 = 3;
10046 dgst_pos2 = 2;
10047 dgst_pos3 = 1;
10048 break;
10049
10050 case 11200: hash_type = HASH_TYPE_SHA1;
10051 salt_type = SALT_TYPE_EMBEDDED;
10052 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10053 opts_type = OPTS_TYPE_PT_GENERATE_BE
10054 | OPTS_TYPE_PT_ADD80
10055 | OPTS_TYPE_ST_HEX;
10056 kern_type = KERN_TYPE_MYSQL_AUTH;
10057 dgst_size = DGST_SIZE_4_5;
10058 parse_func = mysql_auth_parse_hash;
10059 sort_by_digest = sort_by_digest_4_5;
10060 opti_type = OPTI_TYPE_ZERO_BYTE
10061 | OPTI_TYPE_EARLY_SKIP;
10062 dgst_pos0 = 3;
10063 dgst_pos1 = 4;
10064 dgst_pos2 = 2;
10065 dgst_pos3 = 1;
10066 break;
10067
10068 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10069 salt_type = SALT_TYPE_EMBEDDED;
10070 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10071 opts_type = OPTS_TYPE_PT_GENERATE_LE
10072 | OPTS_TYPE_ST_HEX
10073 | OPTS_TYPE_ST_ADD80;
10074 kern_type = KERN_TYPE_BITCOIN_WALLET;
10075 dgst_size = DGST_SIZE_4_4;
10076 parse_func = bitcoin_wallet_parse_hash;
10077 sort_by_digest = sort_by_digest_4_4;
10078 opti_type = OPTI_TYPE_ZERO_BYTE;
10079 dgst_pos0 = 0;
10080 dgst_pos1 = 1;
10081 dgst_pos2 = 2;
10082 dgst_pos3 = 3;
10083 break;
10084
10085 case 11400: hash_type = HASH_TYPE_MD5;
10086 salt_type = SALT_TYPE_EMBEDDED;
10087 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10088 opts_type = OPTS_TYPE_PT_GENERATE_LE
10089 | OPTS_TYPE_PT_ADD80
10090 | OPTS_TYPE_HASH_COPY;
10091 kern_type = KERN_TYPE_SIP_AUTH;
10092 dgst_size = DGST_SIZE_4_4;
10093 parse_func = sip_auth_parse_hash;
10094 sort_by_digest = sort_by_digest_4_4;
10095 opti_type = OPTI_TYPE_ZERO_BYTE;
10096 dgst_pos0 = 0;
10097 dgst_pos1 = 3;
10098 dgst_pos2 = 2;
10099 dgst_pos3 = 1;
10100 break;
10101
10102 case 11500: hash_type = HASH_TYPE_CRC32;
10103 salt_type = SALT_TYPE_INTERN;
10104 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10105 opts_type = OPTS_TYPE_PT_GENERATE_LE
10106 | OPTS_TYPE_ST_GENERATE_LE
10107 | OPTS_TYPE_ST_HEX;
10108 kern_type = KERN_TYPE_CRC32;
10109 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10110 parse_func = crc32_parse_hash;
10111 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10112 opti_type = OPTI_TYPE_ZERO_BYTE;
10113 dgst_pos0 = 0;
10114 dgst_pos1 = 1;
10115 dgst_pos2 = 2;
10116 dgst_pos3 = 3;
10117 break;
10118
10119 case 11600: hash_type = HASH_TYPE_AES;
10120 salt_type = SALT_TYPE_EMBEDDED;
10121 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10122 opts_type = OPTS_TYPE_PT_GENERATE_LE
10123 | OPTS_TYPE_PT_NEVERCRACK;
10124 kern_type = KERN_TYPE_SEVEN_ZIP;
10125 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10126 parse_func = seven_zip_parse_hash;
10127 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10128 opti_type = OPTI_TYPE_ZERO_BYTE;
10129 dgst_pos0 = 0;
10130 dgst_pos1 = 1;
10131 dgst_pos2 = 2;
10132 dgst_pos3 = 3;
10133 break;
10134
10135 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10136 salt_type = SALT_TYPE_NONE;
10137 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10138 opts_type = OPTS_TYPE_PT_GENERATE_LE
10139 | OPTS_TYPE_PT_ADD01;
10140 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10141 dgst_size = DGST_SIZE_4_8;
10142 parse_func = gost2012sbog_256_parse_hash;
10143 sort_by_digest = sort_by_digest_4_8;
10144 opti_type = OPTI_TYPE_ZERO_BYTE;
10145 dgst_pos0 = 0;
10146 dgst_pos1 = 1;
10147 dgst_pos2 = 2;
10148 dgst_pos3 = 3;
10149 break;
10150
10151 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10152 salt_type = SALT_TYPE_NONE;
10153 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10154 opts_type = OPTS_TYPE_PT_GENERATE_LE
10155 | OPTS_TYPE_PT_ADD01;
10156 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10157 dgst_size = DGST_SIZE_4_16;
10158 parse_func = gost2012sbog_512_parse_hash;
10159 sort_by_digest = sort_by_digest_4_16;
10160 opti_type = OPTI_TYPE_ZERO_BYTE;
10161 dgst_pos0 = 0;
10162 dgst_pos1 = 1;
10163 dgst_pos2 = 2;
10164 dgst_pos3 = 3;
10165 break;
10166
10167 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10168 salt_type = SALT_TYPE_EMBEDDED;
10169 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10170 opts_type = OPTS_TYPE_PT_GENERATE_LE
10171 | OPTS_TYPE_ST_BASE64
10172 | OPTS_TYPE_HASH_COPY;
10173 kern_type = KERN_TYPE_PBKDF2_MD5;
10174 dgst_size = DGST_SIZE_4_32;
10175 parse_func = pbkdf2_md5_parse_hash;
10176 sort_by_digest = sort_by_digest_4_32;
10177 opti_type = OPTI_TYPE_ZERO_BYTE;
10178 dgst_pos0 = 0;
10179 dgst_pos1 = 1;
10180 dgst_pos2 = 2;
10181 dgst_pos3 = 3;
10182 break;
10183
10184 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10185 salt_type = SALT_TYPE_EMBEDDED;
10186 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10187 opts_type = OPTS_TYPE_PT_GENERATE_LE
10188 | OPTS_TYPE_ST_BASE64
10189 | OPTS_TYPE_HASH_COPY;
10190 kern_type = KERN_TYPE_PBKDF2_SHA1;
10191 dgst_size = DGST_SIZE_4_32;
10192 parse_func = pbkdf2_sha1_parse_hash;
10193 sort_by_digest = sort_by_digest_4_32;
10194 opti_type = OPTI_TYPE_ZERO_BYTE;
10195 dgst_pos0 = 0;
10196 dgst_pos1 = 1;
10197 dgst_pos2 = 2;
10198 dgst_pos3 = 3;
10199 break;
10200
10201 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10202 salt_type = SALT_TYPE_EMBEDDED;
10203 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10204 opts_type = OPTS_TYPE_PT_GENERATE_LE
10205 | OPTS_TYPE_ST_BASE64
10206 | OPTS_TYPE_HASH_COPY;
10207 kern_type = KERN_TYPE_PBKDF2_SHA512;
10208 dgst_size = DGST_SIZE_8_16;
10209 parse_func = pbkdf2_sha512_parse_hash;
10210 sort_by_digest = sort_by_digest_8_16;
10211 opti_type = OPTI_TYPE_ZERO_BYTE
10212 | OPTI_TYPE_USES_BITS_64;
10213 dgst_pos0 = 0;
10214 dgst_pos1 = 1;
10215 dgst_pos2 = 2;
10216 dgst_pos3 = 3;
10217 break;
10218
10219 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10220 salt_type = SALT_TYPE_EMBEDDED;
10221 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10222 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10223 kern_type = KERN_TYPE_ECRYPTFS;
10224 dgst_size = DGST_SIZE_8_8;
10225 parse_func = ecryptfs_parse_hash;
10226 sort_by_digest = sort_by_digest_8_8;
10227 opti_type = OPTI_TYPE_ZERO_BYTE
10228 | OPTI_TYPE_USES_BITS_64;
10229 dgst_pos0 = 0;
10230 dgst_pos1 = 1;
10231 dgst_pos2 = 2;
10232 dgst_pos3 = 3;
10233 break;
10234
10235 case 12300: hash_type = HASH_TYPE_ORACLET;
10236 salt_type = SALT_TYPE_EMBEDDED;
10237 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10238 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10239 kern_type = KERN_TYPE_ORACLET;
10240 dgst_size = DGST_SIZE_8_16;
10241 parse_func = oraclet_parse_hash;
10242 sort_by_digest = sort_by_digest_8_16;
10243 opti_type = OPTI_TYPE_ZERO_BYTE
10244 | OPTI_TYPE_USES_BITS_64;
10245 dgst_pos0 = 0;
10246 dgst_pos1 = 1;
10247 dgst_pos2 = 2;
10248 dgst_pos3 = 3;
10249 break;
10250
10251 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10252 salt_type = SALT_TYPE_EMBEDDED;
10253 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10254 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10255 kern_type = KERN_TYPE_BSDICRYPT;
10256 dgst_size = DGST_SIZE_4_4;
10257 parse_func = bsdicrypt_parse_hash;
10258 sort_by_digest = sort_by_digest_4_4;
10259 opti_type = OPTI_TYPE_ZERO_BYTE
10260 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10261 dgst_pos0 = 0;
10262 dgst_pos1 = 1;
10263 dgst_pos2 = 2;
10264 dgst_pos3 = 3;
10265 break;
10266
10267 case 12500: hash_type = HASH_TYPE_RAR3HP;
10268 salt_type = SALT_TYPE_EMBEDDED;
10269 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10270 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10271 kern_type = KERN_TYPE_RAR3;
10272 dgst_size = DGST_SIZE_4_4;
10273 parse_func = rar3hp_parse_hash;
10274 sort_by_digest = sort_by_digest_4_4;
10275 opti_type = OPTI_TYPE_ZERO_BYTE;
10276 dgst_pos0 = 0;
10277 dgst_pos1 = 1;
10278 dgst_pos2 = 2;
10279 dgst_pos3 = 3;
10280 break;
10281
10282 case 12600: hash_type = HASH_TYPE_SHA256;
10283 salt_type = SALT_TYPE_INTERN;
10284 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10285 opts_type = OPTS_TYPE_PT_GENERATE_BE
10286 | OPTS_TYPE_PT_ADD80;
10287 kern_type = KERN_TYPE_CF10;
10288 dgst_size = DGST_SIZE_4_8;
10289 parse_func = cf10_parse_hash;
10290 sort_by_digest = sort_by_digest_4_8;
10291 opti_type = OPTI_TYPE_ZERO_BYTE
10292 | OPTI_TYPE_PRECOMPUTE_INIT
10293 | OPTI_TYPE_EARLY_SKIP
10294 | OPTI_TYPE_NOT_ITERATED;
10295 dgst_pos0 = 3;
10296 dgst_pos1 = 7;
10297 dgst_pos2 = 2;
10298 dgst_pos3 = 6;
10299 break;
10300
10301 case 12700: hash_type = HASH_TYPE_AES;
10302 salt_type = SALT_TYPE_EMBEDDED;
10303 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10304 opts_type = OPTS_TYPE_PT_GENERATE_LE
10305 | OPTS_TYPE_HASH_COPY;
10306 kern_type = KERN_TYPE_MYWALLET;
10307 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10308 parse_func = mywallet_parse_hash;
10309 sort_by_digest = sort_by_digest_4_5;
10310 opti_type = OPTI_TYPE_ZERO_BYTE;
10311 dgst_pos0 = 0;
10312 dgst_pos1 = 1;
10313 dgst_pos2 = 2;
10314 dgst_pos3 = 3;
10315 break;
10316
10317 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10318 salt_type = SALT_TYPE_EMBEDDED;
10319 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10320 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10321 kern_type = KERN_TYPE_MS_DRSR;
10322 dgst_size = DGST_SIZE_4_8;
10323 parse_func = ms_drsr_parse_hash;
10324 sort_by_digest = sort_by_digest_4_8;
10325 opti_type = OPTI_TYPE_ZERO_BYTE;
10326 dgst_pos0 = 0;
10327 dgst_pos1 = 1;
10328 dgst_pos2 = 2;
10329 dgst_pos3 = 3;
10330 break;
10331
10332 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10333 salt_type = SALT_TYPE_EMBEDDED;
10334 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10335 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10336 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10337 dgst_size = DGST_SIZE_4_8;
10338 parse_func = androidfde_samsung_parse_hash;
10339 sort_by_digest = sort_by_digest_4_8;
10340 opti_type = OPTI_TYPE_ZERO_BYTE;
10341 dgst_pos0 = 0;
10342 dgst_pos1 = 1;
10343 dgst_pos2 = 2;
10344 dgst_pos3 = 3;
10345 break;
10346
10347 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10348 salt_type = SALT_TYPE_EMBEDDED;
10349 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10350 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10351 kern_type = KERN_TYPE_RAR5;
10352 dgst_size = DGST_SIZE_4_4;
10353 parse_func = rar5_parse_hash;
10354 sort_by_digest = sort_by_digest_4_4;
10355 opti_type = OPTI_TYPE_ZERO_BYTE;
10356 dgst_pos0 = 0;
10357 dgst_pos1 = 1;
10358 dgst_pos2 = 2;
10359 dgst_pos3 = 3;
10360 break;
10361
10362 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10363 salt_type = SALT_TYPE_EMBEDDED;
10364 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10365 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10366 kern_type = KERN_TYPE_KRB5TGS;
10367 dgst_size = DGST_SIZE_4_4;
10368 parse_func = krb5tgs_parse_hash;
10369 sort_by_digest = sort_by_digest_4_4;
10370 opti_type = OPTI_TYPE_ZERO_BYTE
10371 | OPTI_TYPE_NOT_ITERATED;
10372 dgst_pos0 = 0;
10373 dgst_pos1 = 1;
10374 dgst_pos2 = 2;
10375 dgst_pos3 = 3;
10376 break;
10377
10378 default: usage_mini_print (PROGNAME); return (-1);
10379 }
10380
10381 /**
10382 * transpose
10383 */
10384
10385 data.parse_func = parse_func;
10386
10387 /**
10388 * misc stuff
10389 */
10390
10391 if (hex_salt)
10392 {
10393 if (salt_type == SALT_TYPE_INTERN)
10394 {
10395 opts_type |= OPTS_TYPE_ST_HEX;
10396 }
10397 else
10398 {
10399 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10400
10401 return (-1);
10402 }
10403 }
10404
10405 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10406 | (salt_type == SALT_TYPE_EXTERN)
10407 | (salt_type == SALT_TYPE_EMBEDDED)
10408 | (salt_type == SALT_TYPE_VIRTUAL));
10409
10410 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10411
10412 data.hash_type = hash_type;
10413 data.attack_mode = attack_mode;
10414 data.attack_kern = attack_kern;
10415 data.attack_exec = attack_exec;
10416 data.kern_type = kern_type;
10417 data.opts_type = opts_type;
10418 data.dgst_size = dgst_size;
10419 data.salt_type = salt_type;
10420 data.isSalted = isSalted;
10421 data.sort_by_digest = sort_by_digest;
10422 data.dgst_pos0 = dgst_pos0;
10423 data.dgst_pos1 = dgst_pos1;
10424 data.dgst_pos2 = dgst_pos2;
10425 data.dgst_pos3 = dgst_pos3;
10426
10427 esalt_size = 0;
10428
10429 switch (hash_mode)
10430 {
10431 case 2500: esalt_size = sizeof (wpa_t); break;
10432 case 5300: esalt_size = sizeof (ikepsk_t); break;
10433 case 5400: esalt_size = sizeof (ikepsk_t); break;
10434 case 5500: esalt_size = sizeof (netntlm_t); break;
10435 case 5600: esalt_size = sizeof (netntlm_t); break;
10436 case 6211: esalt_size = sizeof (tc_t); break;
10437 case 6212: esalt_size = sizeof (tc_t); break;
10438 case 6213: esalt_size = sizeof (tc_t); break;
10439 case 6221: esalt_size = sizeof (tc_t); break;
10440 case 6222: esalt_size = sizeof (tc_t); break;
10441 case 6223: esalt_size = sizeof (tc_t); break;
10442 case 6231: esalt_size = sizeof (tc_t); break;
10443 case 6232: esalt_size = sizeof (tc_t); break;
10444 case 6233: esalt_size = sizeof (tc_t); break;
10445 case 6241: esalt_size = sizeof (tc_t); break;
10446 case 6242: esalt_size = sizeof (tc_t); break;
10447 case 6243: esalt_size = sizeof (tc_t); break;
10448 case 6600: esalt_size = sizeof (agilekey_t); break;
10449 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10450 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10451 case 7300: esalt_size = sizeof (rakp_t); break;
10452 case 7500: esalt_size = sizeof (krb5pa_t); break;
10453 case 8200: esalt_size = sizeof (cloudkey_t); break;
10454 case 8800: esalt_size = sizeof (androidfde_t); break;
10455 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10456 case 9400: esalt_size = sizeof (office2007_t); break;
10457 case 9500: esalt_size = sizeof (office2010_t); break;
10458 case 9600: esalt_size = sizeof (office2013_t); break;
10459 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10460 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10461 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10462 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10463 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10464 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10465 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10466 case 10200: esalt_size = sizeof (cram_md5_t); break;
10467 case 10400: esalt_size = sizeof (pdf_t); break;
10468 case 10410: esalt_size = sizeof (pdf_t); break;
10469 case 10420: esalt_size = sizeof (pdf_t); break;
10470 case 10500: esalt_size = sizeof (pdf_t); break;
10471 case 10600: esalt_size = sizeof (pdf_t); break;
10472 case 10700: esalt_size = sizeof (pdf_t); break;
10473 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10474 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10475 case 11400: esalt_size = sizeof (sip_t); break;
10476 case 11600: esalt_size = sizeof (seven_zip_t); break;
10477 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10478 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10479 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10480 case 13000: esalt_size = sizeof (rar5_t); break;
10481 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10482 }
10483
10484 data.esalt_size = esalt_size;
10485
10486 /**
10487 * choose dictionary parser
10488 */
10489
10490 if (hash_type == HASH_TYPE_LM)
10491 {
10492 get_next_word_func = get_next_word_lm;
10493 }
10494 else if (opts_type & OPTS_TYPE_PT_UPPER)
10495 {
10496 get_next_word_func = get_next_word_uc;
10497 }
10498 else
10499 {
10500 get_next_word_func = get_next_word_std;
10501 }
10502
10503 /**
10504 * dictstat
10505 */
10506
10507 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10508
10509 #ifdef _POSIX
10510 size_t dictstat_nmemb = 0;
10511 #endif
10512
10513 #ifdef _WIN
10514 uint dictstat_nmemb = 0;
10515 #endif
10516
10517 char dictstat[256] = { 0 };
10518
10519 FILE *dictstat_fp = NULL;
10520
10521 if (keyspace == 0)
10522 {
10523 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10524
10525 dictstat_fp = fopen (dictstat, "rb");
10526
10527 if (dictstat_fp)
10528 {
10529 #ifdef _POSIX
10530 struct stat tmpstat;
10531
10532 fstat (fileno (dictstat_fp), &tmpstat);
10533 #endif
10534
10535 #ifdef _WIN
10536 struct stat64 tmpstat;
10537
10538 _fstat64 (fileno (dictstat_fp), &tmpstat);
10539 #endif
10540
10541 if (tmpstat.st_mtime < COMPTIME)
10542 {
10543 /* with v0.15 the format changed so we have to ensure user is using a good version
10544 since there is no version-header in the dictstat file */
10545
10546 fclose (dictstat_fp);
10547
10548 unlink (dictstat);
10549 }
10550 else
10551 {
10552 while (!feof (dictstat_fp))
10553 {
10554 dictstat_t d;
10555
10556 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10557
10558 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10559
10560 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10561 {
10562 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10563
10564 return -1;
10565 }
10566 }
10567
10568 fclose (dictstat_fp);
10569 }
10570 }
10571 }
10572
10573 /**
10574 * potfile
10575 */
10576
10577 char potfile[256] = { 0 };
10578
10579 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10580
10581 data.pot_fp = NULL;
10582
10583 FILE *out_fp = NULL;
10584 FILE *pot_fp = NULL;
10585
10586 if (show == 1 || left == 1)
10587 {
10588 pot_fp = fopen (potfile, "rb");
10589
10590 if (pot_fp == NULL)
10591 {
10592 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10593
10594 return (-1);
10595 }
10596
10597 if (outfile != NULL)
10598 {
10599 if ((out_fp = fopen (outfile, "ab")) == NULL)
10600 {
10601 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10602
10603 fclose (pot_fp);
10604
10605 return (-1);
10606 }
10607 }
10608 else
10609 {
10610 out_fp = stdout;
10611 }
10612 }
10613 else
10614 {
10615 if (potfile_disable == 0)
10616 {
10617 pot_fp = fopen (potfile, "ab");
10618
10619 if (pot_fp == NULL)
10620 {
10621 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10622
10623 return (-1);
10624 }
10625
10626 data.pot_fp = pot_fp;
10627 }
10628 }
10629
10630 pot_t *pot = NULL;
10631
10632 uint pot_cnt = 0;
10633 uint pot_avail = 0;
10634
10635 if (show == 1 || left == 1)
10636 {
10637 SUPPRESS_OUTPUT = 1;
10638
10639 pot_avail = count_lines (pot_fp);
10640
10641 rewind (pot_fp);
10642
10643 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10644
10645 uint pot_hashes_avail = 0;
10646
10647 uint line_num = 0;
10648
10649 while (!feof (pot_fp))
10650 {
10651 line_num++;
10652
10653 char line_buf[BUFSIZ] = { 0 };
10654
10655 int line_len = fgetl (pot_fp, line_buf);
10656
10657 if (line_len == 0) continue;
10658
10659 char *plain_buf = line_buf + line_len;
10660
10661 pot_t *pot_ptr = &pot[pot_cnt];
10662
10663 hash_t *hashes_buf = &pot_ptr->hash;
10664
10665 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10666 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10667
10668 if (pot_cnt == pot_hashes_avail)
10669 {
10670 uint pos = 0;
10671
10672 for (pos = 0; pos < INCR_POT; pos++)
10673 {
10674 if ((pot_cnt + pos) >= pot_avail) break;
10675
10676 pot_t *tmp_pot = &pot[pot_cnt + pos];
10677
10678 hash_t *tmp_hash = &tmp_pot->hash;
10679
10680 tmp_hash->digest = mymalloc (dgst_size);
10681
10682 if (isSalted)
10683 {
10684 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10685 }
10686
10687 if (esalt_size)
10688 {
10689 tmp_hash->esalt = mymalloc (esalt_size);
10690 }
10691
10692 pot_hashes_avail++;
10693 }
10694 }
10695
10696 int plain_len = 0;
10697
10698 int parser_status;
10699
10700 int iter = MAX_CUT_TRIES;
10701
10702 do
10703 {
10704 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10705 {
10706 if (line_buf[i] == ':')
10707 {
10708 line_len--;
10709
10710 break;
10711 }
10712 }
10713
10714 if (data.hash_mode != 2500)
10715 {
10716 parser_status = parse_func (line_buf, line_len, hashes_buf);
10717 }
10718 else
10719 {
10720 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10721
10722 if (line_len > max_salt_size)
10723 {
10724 parser_status = PARSER_GLOBAL_LENGTH;
10725 }
10726 else
10727 {
10728 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10729
10730 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10731
10732 hashes_buf->salt->salt_len = line_len;
10733
10734 parser_status = PARSER_OK;
10735 }
10736 }
10737
10738 // if NOT parsed without error, we add the ":" to the plain
10739
10740 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10741 {
10742 plain_len++;
10743 plain_buf--;
10744 }
10745
10746 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10747
10748 if (parser_status < PARSER_GLOBAL_ZERO)
10749 {
10750 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10751
10752 continue;
10753 }
10754
10755 if (plain_len >= 255) continue;
10756
10757 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10758
10759 pot_ptr->plain_len = plain_len;
10760
10761 pot_cnt++;
10762 }
10763
10764 fclose (pot_fp);
10765
10766 SUPPRESS_OUTPUT = 0;
10767
10768 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10769 }
10770
10771 /**
10772 * word len
10773 */
10774
10775 uint pw_min = PW_MIN;
10776 uint pw_max = PW_MAX;
10777
10778 switch (hash_mode)
10779 {
10780 case 400: if (pw_max > 40) pw_max = 40;
10781 break;
10782 case 500: if (pw_max > 16) pw_max = 16;
10783 break;
10784 case 1500: if (pw_max > 8) pw_max = 8;
10785 break;
10786 case 1600: if (pw_max > 16) pw_max = 16;
10787 break;
10788 case 1800: if (pw_max > 16) pw_max = 16;
10789 break;
10790 case 2100: if (pw_max > 16) pw_max = 16;
10791 break;
10792 case 2500: if (pw_min < 8) pw_min = 8;
10793 break;
10794 case 3000: if (pw_max > 7) pw_max = 7;
10795 break;
10796 case 5200: if (pw_max > 24) pw_max = 24;
10797 break;
10798 case 5800: if (pw_max > 16) pw_max = 16;
10799 break;
10800 case 6300: if (pw_max > 16) pw_max = 16;
10801 break;
10802 case 7400: if (pw_max > 16) pw_max = 16;
10803 break;
10804 case 7900: if (pw_max > 48) pw_max = 48;
10805 break;
10806 case 8500: if (pw_max > 8) pw_max = 8;
10807 break;
10808 case 8600: if (pw_max > 16) pw_max = 16;
10809 break;
10810 case 9710: pw_min = 5;
10811 pw_max = 5;
10812 break;
10813 case 9810: pw_min = 5;
10814 pw_max = 5;
10815 break;
10816 case 10410: pw_min = 5;
10817 pw_max = 5;
10818 break;
10819 case 10300: if (pw_max < 3) pw_min = 3;
10820 if (pw_max > 40) pw_max = 40;
10821 break;
10822 case 10500: if (pw_max < 3) pw_min = 3;
10823 if (pw_max > 40) pw_max = 40;
10824 break;
10825 case 10700: if (pw_max > 16) pw_max = 16;
10826 break;
10827 case 11300: if (pw_max > 40) pw_max = 40;
10828 break;
10829 case 12500: if (pw_max > 20) pw_max = 20;
10830 break;
10831 case 12800: if (pw_max > 24) pw_max = 24;
10832 break;
10833 }
10834
10835 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10836 {
10837 switch (attack_kern)
10838 {
10839 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10840 break;
10841 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10842 break;
10843 }
10844 }
10845
10846 /**
10847 * charsets : keep them together for more easy maintainnce
10848 */
10849
10850 cs_t mp_sys[6] = { { { 0 }, 0 } };
10851 cs_t mp_usr[4] = { { { 0 }, 0 } };
10852
10853 mp_setup_sys (mp_sys);
10854
10855 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10856 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10857 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10858 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10859
10860 /**
10861 * load hashes, part I: find input mode, count hashes
10862 */
10863
10864 uint hashlist_mode = 0;
10865 uint hashlist_format = HLFMT_HASHCAT;
10866
10867 uint hashes_avail = 0;
10868
10869 if (benchmark == 0)
10870 {
10871 struct stat f;
10872
10873 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10874
10875 if ((hash_mode == 2500) ||
10876 (hash_mode == 5200) ||
10877 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10878 (hash_mode == 9000))
10879 {
10880 hashlist_mode = HL_MODE_ARG;
10881
10882 char *hashfile = myargv[optind];
10883
10884 data.hashfile = hashfile;
10885
10886 logfile_top_var_string ("target", hashfile);
10887 }
10888
10889 if (hashlist_mode == HL_MODE_ARG)
10890 {
10891 if (hash_mode == 2500)
10892 {
10893 struct stat st;
10894
10895 if (stat (data.hashfile, &st) == -1)
10896 {
10897 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10898
10899 return (-1);
10900 }
10901
10902 hashes_avail = st.st_size / sizeof (hccap_t);
10903 }
10904 else
10905 {
10906 hashes_avail = 1;
10907 }
10908 }
10909 else if (hashlist_mode == HL_MODE_FILE)
10910 {
10911 char *hashfile = myargv[optind];
10912
10913 data.hashfile = hashfile;
10914
10915 logfile_top_var_string ("target", hashfile);
10916
10917 FILE *fp = NULL;
10918
10919 if ((fp = fopen (hashfile, "rb")) == NULL)
10920 {
10921 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10922
10923 return (-1);
10924 }
10925
10926 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10927
10928 hashes_avail = count_lines (fp);
10929
10930 rewind (fp);
10931
10932 if (hashes_avail == 0)
10933 {
10934 log_error ("ERROR: hashfile is empty or corrupt");
10935
10936 fclose (fp);
10937
10938 return (-1);
10939 }
10940
10941 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10942
10943 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10944 {
10945 log_error ("ERROR: remove not supported in native hashfile-format mode");
10946
10947 fclose (fp);
10948
10949 return (-1);
10950 }
10951
10952 fclose (fp);
10953 }
10954 }
10955 else
10956 {
10957 hashlist_mode = HL_MODE_ARG;
10958
10959 hashes_avail = 1;
10960 }
10961
10962 if (hash_mode == 3000) hashes_avail *= 2;
10963
10964 data.hashlist_mode = hashlist_mode;
10965 data.hashlist_format = hashlist_format;
10966
10967 logfile_top_uint (hashlist_mode);
10968 logfile_top_uint (hashlist_format);
10969
10970 /**
10971 * load hashes, part II: allocate required memory, set pointers
10972 */
10973
10974 hash_t *hashes_buf = NULL;
10975 void *digests_buf = NULL;
10976 salt_t *salts_buf = NULL;
10977 void *esalts_buf = NULL;
10978
10979 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10980
10981 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10982
10983 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10984 {
10985 u32 hash_pos;
10986
10987 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10988 {
10989 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10990
10991 hashes_buf[hash_pos].hash_info = hash_info;
10992
10993 if (username && (remove || show || left))
10994 {
10995 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10996 }
10997
10998 if (benchmark)
10999 {
11000 hash_info->orighash = (char *) mymalloc (256);
11001 }
11002 }
11003 }
11004
11005 if (isSalted)
11006 {
11007 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11008
11009 if (esalt_size)
11010 {
11011 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11012 }
11013 }
11014 else
11015 {
11016 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11017 }
11018
11019 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11020 {
11021 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11022
11023 if (isSalted)
11024 {
11025 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11026
11027 if (esalt_size)
11028 {
11029 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11030 }
11031 }
11032 else
11033 {
11034 hashes_buf[hash_pos].salt = &salts_buf[0];
11035 }
11036 }
11037
11038 /**
11039 * load hashes, part III: parse hashes or generate them if benchmark
11040 */
11041
11042 uint hashes_cnt = 0;
11043
11044 if (benchmark == 0)
11045 {
11046 if (keyspace == 1)
11047 {
11048 // useless to read hash file for keyspace, cheat a little bit w/ optind
11049 }
11050 else if (hashes_avail == 0)
11051 {
11052 }
11053 else if (hashlist_mode == HL_MODE_ARG)
11054 {
11055 char *input_buf = myargv[optind];
11056
11057 uint input_len = strlen (input_buf);
11058
11059 logfile_top_var_string ("target", input_buf);
11060
11061 char *hash_buf = NULL;
11062 int hash_len = 0;
11063
11064 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11065
11066 if (hash_len)
11067 {
11068 if (opts_type & OPTS_TYPE_HASH_COPY)
11069 {
11070 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11071
11072 hash_info_tmp->orighash = mystrdup (hash_buf);
11073 }
11074
11075 if (isSalted)
11076 {
11077 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11078 }
11079
11080 int parser_status = PARSER_OK;
11081
11082 if (hash_mode == 2500)
11083 {
11084 if (hash_len == 0)
11085 {
11086 log_error ("ERROR: hccap file not specified");
11087
11088 return (-1);
11089 }
11090
11091 hashlist_mode = HL_MODE_FILE;
11092
11093 data.hashlist_mode = hashlist_mode;
11094
11095 FILE *fp = fopen (hash_buf, "rb");
11096
11097 if (fp == NULL)
11098 {
11099 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11100
11101 return (-1);
11102 }
11103
11104 if (hashes_avail < 1)
11105 {
11106 log_error ("ERROR: hccap file is empty or corrupt");
11107
11108 fclose (fp);
11109
11110 return (-1);
11111 }
11112
11113 uint hccap_size = sizeof (hccap_t);
11114
11115 char *in = (char *) mymalloc (hccap_size);
11116
11117 while (!feof (fp))
11118 {
11119 int n = fread (in, hccap_size, 1, fp);
11120
11121 if (n != 1)
11122 {
11123 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11124
11125 break;
11126 }
11127
11128 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11129
11130 if (parser_status != PARSER_OK)
11131 {
11132 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11133
11134 continue;
11135 }
11136
11137 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11138
11139 if ((show == 1) || (left == 1))
11140 {
11141 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11142
11143 char *salt_ptr = (char *) tmp_salt->salt_buf;
11144
11145 int cur_pos = tmp_salt->salt_len;
11146 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11147
11148 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11149
11150 u8 *pke_ptr = (u8 *) wpa->pke;
11151
11152 // do the appending task
11153
11154 snprintf (salt_ptr + cur_pos,
11155 rem_len,
11156 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11157 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
11158 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
11159
11160
11161 // memset () the remaining part of the salt
11162
11163 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11164 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11165
11166 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11167
11168 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11169 }
11170
11171 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);
11172 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);
11173
11174 hashes_cnt++;
11175 }
11176
11177 fclose (fp);
11178
11179 myfree (in);
11180 }
11181 else if (hash_mode == 3000)
11182 {
11183 if (hash_len == 32)
11184 {
11185 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11186
11187 hash_t *lm_hash_left = NULL;
11188
11189 if (parser_status == PARSER_OK)
11190 {
11191 lm_hash_left = &hashes_buf[hashes_cnt];
11192
11193 hashes_cnt++;
11194 }
11195 else
11196 {
11197 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11198 }
11199
11200 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11201
11202 hash_t *lm_hash_right = NULL;
11203
11204 if (parser_status == PARSER_OK)
11205 {
11206 lm_hash_right = &hashes_buf[hashes_cnt];
11207
11208 hashes_cnt++;
11209 }
11210 else
11211 {
11212 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11213 }
11214
11215 // show / left
11216
11217 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11218 {
11219 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);
11220 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);
11221 }
11222 }
11223 else
11224 {
11225 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11226
11227 if (parser_status == PARSER_OK)
11228 {
11229 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11230 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11231 }
11232
11233 if (parser_status == PARSER_OK)
11234 {
11235 hashes_cnt++;
11236 }
11237 else
11238 {
11239 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11240 }
11241 }
11242 }
11243 else
11244 {
11245 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11246
11247 if (parser_status == PARSER_OK)
11248 {
11249 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11250 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11251 }
11252
11253 if (parser_status == PARSER_OK)
11254 {
11255 hashes_cnt++;
11256 }
11257 else
11258 {
11259 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11260 }
11261 }
11262 }
11263 }
11264 else if (hashlist_mode == HL_MODE_FILE)
11265 {
11266 char *hashfile = data.hashfile;
11267
11268 FILE *fp;
11269
11270 if ((fp = fopen (hashfile, "rb")) == NULL)
11271 {
11272 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11273
11274 return (-1);
11275 }
11276
11277 uint line_num = 0;
11278
11279 while (!feof (fp))
11280 {
11281 line_num++;
11282
11283 char line_buf[BUFSIZ] = { 0 };
11284
11285 int line_len = fgetl (fp, line_buf);
11286
11287 if (line_len == 0) continue;
11288
11289 char *hash_buf = NULL;
11290 int hash_len = 0;
11291
11292 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11293
11294 if (username)
11295 {
11296 char *user_buf = NULL;
11297 int user_len = 0;
11298
11299 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11300
11301 if (remove || show)
11302 {
11303 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11304
11305 *user = (user_t *) mymalloc (sizeof (user_t));
11306
11307 user_t *user_ptr = *user;
11308
11309 if (user_buf != NULL)
11310 {
11311 user_ptr->user_name = mystrdup (user_buf);
11312 }
11313 else
11314 {
11315 user_ptr->user_name = mystrdup ("");
11316 }
11317
11318 user_ptr->user_len = user_len;
11319 }
11320 }
11321
11322 if (opts_type & OPTS_TYPE_HASH_COPY)
11323 {
11324 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11325
11326 hash_info_tmp->orighash = mystrdup (hash_buf);
11327 }
11328
11329 if (isSalted)
11330 {
11331 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11332 }
11333
11334 if (hash_mode == 3000)
11335 {
11336 if (hash_len == 32)
11337 {
11338 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11339
11340 if (parser_status < PARSER_GLOBAL_ZERO)
11341 {
11342 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11343
11344 continue;
11345 }
11346
11347 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11348
11349 hashes_cnt++;
11350
11351 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11352
11353 if (parser_status < PARSER_GLOBAL_ZERO)
11354 {
11355 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11356
11357 continue;
11358 }
11359
11360 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11361
11362 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);
11363
11364 hashes_cnt++;
11365
11366 // show / left
11367
11368 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);
11369 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);
11370 }
11371 else
11372 {
11373 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11374
11375 if (parser_status < PARSER_GLOBAL_ZERO)
11376 {
11377 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11378
11379 continue;
11380 }
11381
11382 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);
11383
11384 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11385 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11386
11387 hashes_cnt++;
11388 }
11389 }
11390 else
11391 {
11392 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11393
11394 if (parser_status < PARSER_GLOBAL_ZERO)
11395 {
11396 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11397
11398 continue;
11399 }
11400
11401 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);
11402
11403 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11404 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11405
11406 hashes_cnt++;
11407 }
11408 }
11409
11410 fclose (fp);
11411
11412 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11413
11414 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11415 }
11416 }
11417 else
11418 {
11419 if (isSalted)
11420 {
11421 hashes_buf[0].salt->salt_len = 8;
11422
11423 // special salt handling
11424
11425 switch (hash_mode)
11426 {
11427 case 1500: hashes_buf[0].salt->salt_len = 2;
11428 break;
11429 case 1731: hashes_buf[0].salt->salt_len = 4;
11430 break;
11431 case 2410: hashes_buf[0].salt->salt_len = 4;
11432 break;
11433 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11434 break;
11435 case 3100: hashes_buf[0].salt->salt_len = 1;
11436 break;
11437 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11438 break;
11439 case 5800: hashes_buf[0].salt->salt_len = 16;
11440 break;
11441 case 6800: hashes_buf[0].salt->salt_len = 32;
11442 break;
11443 case 8400: hashes_buf[0].salt->salt_len = 40;
11444 break;
11445 case 8800: hashes_buf[0].salt->salt_len = 16;
11446 break;
11447 case 8900: hashes_buf[0].salt->salt_len = 16;
11448 hashes_buf[0].salt->scrypt_N = 1024;
11449 hashes_buf[0].salt->scrypt_r = 1;
11450 hashes_buf[0].salt->scrypt_p = 1;
11451 break;
11452 case 9100: hashes_buf[0].salt->salt_len = 16;
11453 break;
11454 case 9300: hashes_buf[0].salt->salt_len = 14;
11455 hashes_buf[0].salt->scrypt_N = 16384;
11456 hashes_buf[0].salt->scrypt_r = 1;
11457 hashes_buf[0].salt->scrypt_p = 1;
11458 break;
11459 case 9400: hashes_buf[0].salt->salt_len = 16;
11460 break;
11461 case 9500: hashes_buf[0].salt->salt_len = 16;
11462 break;
11463 case 9600: hashes_buf[0].salt->salt_len = 16;
11464 break;
11465 case 9700: hashes_buf[0].salt->salt_len = 16;
11466 break;
11467 case 9710: hashes_buf[0].salt->salt_len = 16;
11468 break;
11469 case 9720: hashes_buf[0].salt->salt_len = 16;
11470 break;
11471 case 9800: hashes_buf[0].salt->salt_len = 16;
11472 break;
11473 case 9810: hashes_buf[0].salt->salt_len = 16;
11474 break;
11475 case 9820: hashes_buf[0].salt->salt_len = 16;
11476 break;
11477 case 10300: hashes_buf[0].salt->salt_len = 12;
11478 break;
11479 case 11500: hashes_buf[0].salt->salt_len = 4;
11480 break;
11481 case 11600: hashes_buf[0].salt->salt_len = 4;
11482 break;
11483 case 12400: hashes_buf[0].salt->salt_len = 4;
11484 break;
11485 case 12500: hashes_buf[0].salt->salt_len = 8;
11486 break;
11487 case 12600: hashes_buf[0].salt->salt_len = 64;
11488 break;
11489 }
11490
11491 // special esalt handling
11492
11493 switch (hash_mode)
11494 {
11495 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11496 break;
11497 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11498 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11499 break;
11500 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11501 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11502 break;
11503 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11504 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11505 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11506 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11507 break;
11508 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11509 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11510 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11511 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11512 break;
11513 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11514 break;
11515 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11516 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11517 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11518 break;
11519 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11520 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11521 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11522 break;
11523 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11524 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11525 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11526 break;
11527 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11528 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11529 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11530 break;
11531 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11532 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11533 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11534 break;
11535 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11536 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11537 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11538 break;
11539 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11540 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11541 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11542 break;
11543 }
11544 }
11545
11546 // set hashfile
11547
11548 switch (hash_mode)
11549 {
11550 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11551 break;
11552 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11553 break;
11554 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11555 break;
11556 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11557 break;
11558 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11559 break;
11560 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11561 break;
11562 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11563 break;
11564 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11565 break;
11566 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11567 break;
11568 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11569 break;
11570 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11571 break;
11572 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11573 break;
11574 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11575 break;
11576 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11577 break;
11578 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11579 break;
11580 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11581 break;
11582 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11583 break;
11584 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11585 break;
11586 }
11587
11588 // set default iterations
11589
11590 switch (hash_mode)
11591 {
11592 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11593 break;
11594 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11595 break;
11596 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11597 break;
11598 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11599 break;
11600 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11601 break;
11602 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11603 break;
11604 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11605 break;
11606 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11607 break;
11608 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11609 break;
11610 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11611 break;
11612 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11613 break;
11614 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11615 break;
11616 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11617 break;
11618 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11619 break;
11620 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11621 break;
11622 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11623 break;
11624 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11625 break;
11626 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11627 break;
11628 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11629 break;
11630 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11631 break;
11632 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11633 break;
11634 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11635 break;
11636 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11637 break;
11638 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11639 break;
11640 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11641 break;
11642 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11643 break;
11644 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11645 break;
11646 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11647 break;
11648 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11649 break;
11650 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11651 break;
11652 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11653 break;
11654 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11655 break;
11656 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11657 break;
11658 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11659 break;
11660 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11661 break;
11662 case 8900: hashes_buf[0].salt->salt_iter = 1;
11663 break;
11664 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11665 break;
11666 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11667 break;
11668 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11669 break;
11670 case 9300: hashes_buf[0].salt->salt_iter = 1;
11671 break;
11672 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11673 break;
11674 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11675 break;
11676 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11677 break;
11678 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11679 break;
11680 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11681 break;
11682 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11683 break;
11684 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11685 break;
11686 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11687 break;
11688 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11689 break;
11690 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11691 break;
11692 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11693 break;
11694 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11695 break;
11696 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11697 break;
11698 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11699 break;
11700 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11701 break;
11702 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11703 break;
11704 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11705 break;
11706 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11707 break;
11708 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11709 break;
11710 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11711 break;
11712 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11713 break;
11714 }
11715
11716 hashes_cnt = 1;
11717 }
11718
11719 if (show == 1 || left == 1)
11720 {
11721 for (uint i = 0; i < pot_cnt; i++)
11722 {
11723 pot_t *pot_ptr = &pot[i];
11724
11725 hash_t *hashes_buf = &pot_ptr->hash;
11726
11727 local_free (hashes_buf->digest);
11728
11729 if (isSalted)
11730 {
11731 local_free (hashes_buf->salt);
11732 }
11733 }
11734
11735 local_free (pot);
11736
11737 if (data.quiet == 0) log_info_nn ("");
11738
11739 return (0);
11740 }
11741
11742 if (keyspace == 0)
11743 {
11744 if (hashes_cnt == 0)
11745 {
11746 log_error ("ERROR: No hashes loaded");
11747
11748 return (-1);
11749 }
11750 }
11751
11752 /**
11753 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11754 */
11755
11756 if (data.outfile != NULL)
11757 {
11758 if (data.hashfile != NULL)
11759 {
11760 #ifdef _POSIX
11761 struct stat tmpstat_outfile;
11762 struct stat tmpstat_hashfile;
11763 #endif
11764
11765 #ifdef _WIN
11766 struct stat64 tmpstat_outfile;
11767 struct stat64 tmpstat_hashfile;
11768 #endif
11769
11770 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11771
11772 if (tmp_outfile_fp)
11773 {
11774 #ifdef _POSIX
11775 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11776 #endif
11777
11778 #ifdef _WIN
11779 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11780 #endif
11781
11782 fclose (tmp_outfile_fp);
11783 }
11784
11785 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11786
11787 if (tmp_hashfile_fp)
11788 {
11789 #ifdef _POSIX
11790 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11791 #endif
11792
11793 #ifdef _WIN
11794 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11795 #endif
11796
11797 fclose (tmp_hashfile_fp);
11798 }
11799
11800 if (tmp_outfile_fp && tmp_outfile_fp)
11801 {
11802 tmpstat_outfile.st_mode = 0;
11803 tmpstat_outfile.st_nlink = 0;
11804 tmpstat_outfile.st_uid = 0;
11805 tmpstat_outfile.st_gid = 0;
11806 tmpstat_outfile.st_rdev = 0;
11807 tmpstat_outfile.st_atime = 0;
11808
11809 tmpstat_hashfile.st_mode = 0;
11810 tmpstat_hashfile.st_nlink = 0;
11811 tmpstat_hashfile.st_uid = 0;
11812 tmpstat_hashfile.st_gid = 0;
11813 tmpstat_hashfile.st_rdev = 0;
11814 tmpstat_hashfile.st_atime = 0;
11815
11816 #ifdef _POSIX
11817 tmpstat_outfile.st_blksize = 0;
11818 tmpstat_outfile.st_blocks = 0;
11819
11820 tmpstat_hashfile.st_blksize = 0;
11821 tmpstat_hashfile.st_blocks = 0;
11822 #endif
11823
11824 #ifdef _POSIX
11825 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11826 {
11827 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11828
11829 return (-1);
11830 }
11831 #endif
11832
11833 #ifdef _WIN
11834 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11835 {
11836 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11837
11838 return (-1);
11839 }
11840 #endif
11841 }
11842 }
11843 }
11844
11845 /**
11846 * Remove duplicates
11847 */
11848
11849 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11850
11851 if (isSalted)
11852 {
11853 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11854 }
11855 else
11856 {
11857 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11858 }
11859
11860 uint hashes_cnt_orig = hashes_cnt;
11861
11862 hashes_cnt = 1;
11863
11864 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11865 {
11866 if (isSalted)
11867 {
11868 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11869 {
11870 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11871 }
11872 }
11873 else
11874 {
11875 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11876 }
11877
11878 if (hashes_pos > hashes_cnt)
11879 {
11880 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11881 }
11882
11883 hashes_cnt++;
11884 }
11885
11886 /**
11887 * Potfile removes
11888 */
11889
11890 uint potfile_remove_cracks = 0;
11891
11892 if (potfile_disable == 0)
11893 {
11894 hash_t hash_buf;
11895
11896 hash_buf.digest = mymalloc (dgst_size);
11897 hash_buf.salt = NULL;
11898 hash_buf.esalt = NULL;
11899 hash_buf.hash_info = NULL;
11900 hash_buf.cracked = 0;
11901
11902 if (isSalted)
11903 {
11904 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11905 }
11906
11907 if (esalt_size)
11908 {
11909 hash_buf.esalt = mymalloc (esalt_size);
11910 }
11911
11912 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11913
11914 // no solution for these special hash types (for instane because they use hashfile in output etc)
11915 if ((hash_mode != 5200) &&
11916 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11917 (hash_mode != 9000))
11918 {
11919 FILE *fp = fopen (potfile, "rb");
11920
11921 if (fp != NULL)
11922 {
11923 while (!feof (fp))
11924 {
11925 char line_buf[BUFSIZ] = { 0 };
11926
11927 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11928
11929 if (ptr == NULL) break;
11930
11931 int line_len = strlen (line_buf);
11932
11933 if (line_len == 0) continue;
11934
11935 int iter = MAX_CUT_TRIES;
11936
11937 for (int i = line_len - 1; i && iter; i--, line_len--)
11938 {
11939 if (line_buf[i] != ':') continue;
11940
11941 if (isSalted)
11942 {
11943 memset (hash_buf.salt, 0, sizeof (salt_t));
11944 }
11945
11946 hash_t *found = NULL;
11947
11948 if (hash_mode == 6800)
11949 {
11950 if (i < 64) // 64 = 16 * uint in salt_buf[]
11951 {
11952 // manipulate salt_buf
11953 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11954
11955 hash_buf.salt->salt_len = i;
11956
11957 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11958 }
11959 }
11960 else if (hash_mode == 2500)
11961 {
11962 if (i < 64) // 64 = 16 * uint in salt_buf[]
11963 {
11964 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11965 // manipulate salt_buf
11966
11967 // to be safe work with a copy (because of line_len loop, i etc)
11968
11969 char line_buf_cpy[BUFSIZ] = { 0 };
11970
11971 memcpy (line_buf_cpy, line_buf, i);
11972
11973 char *mac2_pos = strrchr (line_buf_cpy, ':');
11974
11975 if (mac2_pos == NULL) continue;
11976
11977 mac2_pos[0] = 0;
11978 mac2_pos++;
11979
11980 if (strlen (mac2_pos) != 12) continue;
11981
11982 char *mac1_pos = strrchr (line_buf_cpy, ':');
11983
11984 if (mac1_pos == NULL) continue;
11985
11986 mac1_pos[0] = 0;
11987 mac1_pos++;
11988
11989 if (strlen (mac1_pos) != 12) continue;
11990
11991 uint essid_length = mac1_pos - line_buf_cpy - 1;
11992
11993 // here we need the ESSID
11994 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11995
11996 hash_buf.salt->salt_len = essid_length;
11997
11998 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11999
12000 if (found)
12001 {
12002 wpa_t *wpa = (wpa_t *) found->esalt;
12003
12004 uint pke[25] = { 0 };
12005
12006 char *pke_ptr = (char *) pke;
12007
12008 for (uint i = 0; i < 25; i++)
12009 {
12010 pke[i] = byte_swap_32 (wpa->pke[i]);
12011 }
12012
12013 u8 mac1[6] = { 0 };
12014 u8 mac2[6] = { 0 };
12015
12016 memcpy (mac1, pke_ptr + 23, 6);
12017 memcpy (mac2, pke_ptr + 29, 6);
12018
12019 // compare hex string(s) vs binary MAC address(es)
12020
12021 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12022 {
12023 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12024 {
12025 found = NULL;
12026 break;
12027 }
12028 }
12029
12030 // early skip ;)
12031 if (!found) continue;
12032
12033 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12034 {
12035 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12036 {
12037 found = NULL;
12038 break;
12039 }
12040 }
12041 }
12042 }
12043 }
12044 else
12045 {
12046 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12047
12048 if (parser_status == PARSER_OK)
12049 {
12050 if (isSalted)
12051 {
12052 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12053 }
12054 else
12055 {
12056 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12057 }
12058 }
12059 }
12060
12061 if (found == NULL) continue;
12062
12063 if (!found->cracked) potfile_remove_cracks++;
12064
12065 found->cracked = 1;
12066
12067 if (found) break;
12068
12069 iter--;
12070 }
12071 }
12072
12073 fclose (fp);
12074 }
12075 }
12076
12077 if (esalt_size)
12078 {
12079 local_free (hash_buf.esalt);
12080 }
12081
12082 if (isSalted)
12083 {
12084 local_free (hash_buf.salt);
12085 }
12086
12087 local_free (hash_buf.digest);
12088 }
12089
12090 /**
12091 * Now generate all the buffers required for later
12092 */
12093
12094 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12095
12096 salt_t *salts_buf_new = NULL;
12097 void *esalts_buf_new = NULL;
12098
12099 if (isSalted)
12100 {
12101 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12102
12103 if (esalt_size)
12104 {
12105 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12106 }
12107 }
12108 else
12109 {
12110 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12111 }
12112
12113 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12114
12115 uint digests_cnt = hashes_cnt;
12116 uint digests_done = 0;
12117
12118 uint size_digests = digests_cnt * dgst_size;
12119 uint size_shown = digests_cnt * sizeof (uint);
12120
12121 uint *digests_shown = (uint *) mymalloc (size_shown);
12122 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12123
12124 uint salts_cnt = 0;
12125 uint salts_done = 0;
12126
12127 hashinfo_t **hash_info = NULL;
12128
12129 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12130 {
12131 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12132
12133 if (username && (remove || show))
12134 {
12135 uint user_pos;
12136
12137 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12138 {
12139 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12140
12141 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12142 }
12143 }
12144 }
12145
12146 uint *salts_shown = (uint *) mymalloc (size_shown);
12147
12148 salt_t *salt_buf;
12149
12150 {
12151 // copied from inner loop
12152
12153 salt_buf = &salts_buf_new[salts_cnt];
12154
12155 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12156
12157 if (esalt_size)
12158 {
12159 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12160 }
12161
12162 salt_buf->digests_cnt = 0;
12163 salt_buf->digests_done = 0;
12164 salt_buf->digests_offset = 0;
12165
12166 salts_cnt++;
12167 }
12168
12169 if (hashes_buf[0].cracked == 1)
12170 {
12171 digests_shown[0] = 1;
12172
12173 digests_done++;
12174
12175 salt_buf->digests_done++;
12176 }
12177
12178 salt_buf->digests_cnt++;
12179
12180 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12181
12182 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12183 {
12184 hash_info[0] = hashes_buf[0].hash_info;
12185 }
12186
12187 // copy from inner loop
12188
12189 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12190 {
12191 if (isSalted)
12192 {
12193 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12194 {
12195 salt_buf = &salts_buf_new[salts_cnt];
12196
12197 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12198
12199 if (esalt_size)
12200 {
12201 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12202 }
12203
12204 salt_buf->digests_cnt = 0;
12205 salt_buf->digests_done = 0;
12206 salt_buf->digests_offset = hashes_pos;
12207
12208 salts_cnt++;
12209 }
12210 }
12211
12212 if (hashes_buf[hashes_pos].cracked == 1)
12213 {
12214 digests_shown[hashes_pos] = 1;
12215
12216 digests_done++;
12217
12218 salt_buf->digests_done++;
12219 }
12220
12221 salt_buf->digests_cnt++;
12222
12223 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12224
12225 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12226 {
12227 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12228 }
12229 }
12230
12231 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12232 {
12233 salt_t *salt_buf = &salts_buf_new[salt_pos];
12234
12235 if (salt_buf->digests_done == salt_buf->digests_cnt)
12236 {
12237 salts_shown[salt_pos] = 1;
12238
12239 salts_done++;
12240 }
12241
12242 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12243 }
12244
12245 local_free (digests_buf);
12246 local_free (salts_buf);
12247 local_free (esalts_buf);
12248
12249 digests_buf = digests_buf_new;
12250 salts_buf = salts_buf_new;
12251 esalts_buf = esalts_buf_new;
12252
12253 local_free (hashes_buf);
12254
12255 /**
12256 * special modification not set from parser
12257 */
12258
12259 switch (hash_mode)
12260 {
12261 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12262 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12263 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12264 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12265 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12266 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12267 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12268 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12269 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12270 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12271 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12272 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12273 }
12274
12275 if (truecrypt_keyfiles)
12276 {
12277 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12278
12279 char *keyfiles = strdup (truecrypt_keyfiles);
12280
12281 char *keyfile = strtok (keyfiles, ",");
12282
12283 do
12284 {
12285 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12286
12287 } while ((keyfile = strtok (NULL, ",")) != NULL);
12288
12289 free (keyfiles);
12290 }
12291
12292 data.digests_cnt = digests_cnt;
12293 data.digests_done = digests_done;
12294 data.digests_buf = digests_buf;
12295 data.digests_shown = digests_shown;
12296 data.digests_shown_tmp = digests_shown_tmp;
12297
12298 data.salts_cnt = salts_cnt;
12299 data.salts_done = salts_done;
12300 data.salts_buf = salts_buf;
12301 data.salts_shown = salts_shown;
12302
12303 data.esalts_buf = esalts_buf;
12304 data.hash_info = hash_info;
12305
12306 /**
12307 * Automatic Optimizers
12308 */
12309
12310 if (salts_cnt == 1)
12311 opti_type |= OPTI_TYPE_SINGLE_SALT;
12312
12313 if (digests_cnt == 1)
12314 opti_type |= OPTI_TYPE_SINGLE_HASH;
12315
12316 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12317 opti_type |= OPTI_TYPE_NOT_ITERATED;
12318
12319 if (attack_mode == ATTACK_MODE_BF)
12320 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12321
12322 data.opti_type = opti_type;
12323
12324 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12325 {
12326 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12327 {
12328 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12329 {
12330 if (opts_type & OPTS_TYPE_ST_ADD80)
12331 {
12332 opts_type &= ~OPTS_TYPE_ST_ADD80;
12333 opts_type |= OPTS_TYPE_PT_ADD80;
12334 }
12335
12336 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12337 {
12338 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12339 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12340 }
12341
12342 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12343 {
12344 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12345 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12346 }
12347 }
12348 }
12349 }
12350
12351 /**
12352 * Some algorithm, like descrypt, can benefit from JIT compilation
12353 */
12354
12355 int force_jit_compilation = -1;
12356
12357 if (hash_mode == 8900)
12358 {
12359 force_jit_compilation = 8900;
12360 }
12361 else if (hash_mode == 9300)
12362 {
12363 force_jit_compilation = 8900;
12364 }
12365 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12366 {
12367 force_jit_compilation = 1500;
12368 }
12369
12370 /**
12371 * generate bitmap tables
12372 */
12373
12374 const uint bitmap_shift1 = 5;
12375 const uint bitmap_shift2 = 13;
12376
12377 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12378
12379 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12380 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12381 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12382 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12383 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12384 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12385 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12386 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12387
12388 uint bitmap_bits;
12389 uint bitmap_nums;
12390 uint bitmap_mask;
12391 uint bitmap_size;
12392
12393 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12394 {
12395 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12396
12397 bitmap_nums = 1 << bitmap_bits;
12398
12399 bitmap_mask = bitmap_nums - 1;
12400
12401 bitmap_size = bitmap_nums * sizeof (uint);
12402
12403 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12404
12405 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;
12406 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;
12407
12408 break;
12409 }
12410
12411 bitmap_nums = 1 << bitmap_bits;
12412
12413 bitmap_mask = bitmap_nums - 1;
12414
12415 bitmap_size = bitmap_nums * sizeof (uint);
12416
12417 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);
12418 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);
12419
12420 /**
12421 * prepare quick rule
12422 */
12423
12424 data.rule_buf_l = rule_buf_l;
12425 data.rule_buf_r = rule_buf_r;
12426
12427 int rule_len_l = (int) strlen (rule_buf_l);
12428 int rule_len_r = (int) strlen (rule_buf_r);
12429
12430 data.rule_len_l = rule_len_l;
12431 data.rule_len_r = rule_len_r;
12432
12433 /**
12434 * load rules
12435 */
12436
12437 uint *all_kernel_rules_cnt = NULL;
12438
12439 kernel_rule_t **all_kernel_rules_buf = NULL;
12440
12441 if (rp_files_cnt)
12442 {
12443 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12444
12445 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12446 }
12447
12448 char rule_buf[BUFSIZ] = { 0 };
12449
12450 int rule_len = 0;
12451
12452 for (uint i = 0; i < rp_files_cnt; i++)
12453 {
12454 uint kernel_rules_avail = 0;
12455
12456 uint kernel_rules_cnt = 0;
12457
12458 kernel_rule_t *kernel_rules_buf = NULL;
12459
12460 char *rp_file = rp_files[i];
12461
12462 char in[BLOCK_SIZE] = { 0 };
12463 char out[BLOCK_SIZE] = { 0 };
12464
12465 FILE *fp = NULL;
12466
12467 uint rule_line = 0;
12468
12469 if ((fp = fopen (rp_file, "rb")) == NULL)
12470 {
12471 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12472
12473 return (-1);
12474 }
12475
12476 while (!feof (fp))
12477 {
12478 memset (rule_buf, 0, BUFSIZ);
12479
12480 rule_len = fgetl (fp, rule_buf);
12481
12482 rule_line++;
12483
12484 if (rule_len == 0) continue;
12485
12486 if (rule_buf[0] == '#') continue;
12487
12488 if (kernel_rules_avail == kernel_rules_cnt)
12489 {
12490 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12491
12492 kernel_rules_avail += INCR_RULES;
12493 }
12494
12495 memset (in, 0, BLOCK_SIZE);
12496 memset (out, 0, BLOCK_SIZE);
12497
12498 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12499
12500 if (result == -1)
12501 {
12502 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12503
12504 continue;
12505 }
12506
12507 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12508 {
12509 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12510
12511 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12512
12513 continue;
12514 }
12515
12516 /* its so slow
12517 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12518 {
12519 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12520
12521 continue;
12522 }
12523 */
12524
12525 kernel_rules_cnt++;
12526 }
12527
12528 fclose (fp);
12529
12530 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12531
12532 all_kernel_rules_buf[i] = kernel_rules_buf;
12533 }
12534
12535 /**
12536 * merge rules or automatic rule generator
12537 */
12538
12539 uint kernel_rules_cnt = 0;
12540
12541 kernel_rule_t *kernel_rules_buf = NULL;
12542
12543 if (attack_mode == ATTACK_MODE_STRAIGHT)
12544 {
12545 if (rp_files_cnt)
12546 {
12547 kernel_rules_cnt = 1;
12548
12549 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12550
12551 repeats[0] = kernel_rules_cnt;
12552
12553 for (uint i = 0; i < rp_files_cnt; i++)
12554 {
12555 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12556
12557 repeats[i + 1] = kernel_rules_cnt;
12558 }
12559
12560 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12561
12562 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12563
12564 for (uint i = 0; i < kernel_rules_cnt; i++)
12565 {
12566 uint out_pos = 0;
12567
12568 kernel_rule_t *out = &kernel_rules_buf[i];
12569
12570 for (uint j = 0; j < rp_files_cnt; j++)
12571 {
12572 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12573 uint in_pos;
12574
12575 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12576
12577 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12578 {
12579 if (out_pos == RULES_MAX - 1)
12580 {
12581 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12582
12583 break;
12584 }
12585
12586 out->cmds[out_pos] = in->cmds[in_pos];
12587 }
12588 }
12589 }
12590
12591 local_free (repeats);
12592 }
12593 else if (rp_gen)
12594 {
12595 uint kernel_rules_avail = 0;
12596
12597 while (kernel_rules_cnt < rp_gen)
12598 {
12599 if (kernel_rules_avail == kernel_rules_cnt)
12600 {
12601 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12602
12603 kernel_rules_avail += INCR_RULES;
12604 }
12605
12606 memset (rule_buf, 0, BLOCK_SIZE);
12607
12608 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12609
12610 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12611
12612 kernel_rules_cnt++;
12613 }
12614 }
12615 }
12616
12617 /**
12618 * generate NOP rules
12619 */
12620
12621 if (kernel_rules_cnt == 0)
12622 {
12623 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12624
12625 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12626
12627 kernel_rules_cnt++;
12628 }
12629
12630 data.kernel_rules_cnt = kernel_rules_cnt;
12631 data.kernel_rules_buf = kernel_rules_buf;
12632
12633 /**
12634 * OpenCL platforms: detect
12635 */
12636
12637 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12638 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12639
12640 cl_uint platforms_cnt = 0;
12641 cl_uint platform_devices_cnt = 0;
12642
12643 if (keyspace == 0)
12644 {
12645 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12646
12647 if (platforms_cnt == 0)
12648 {
12649 log_error ("ERROR: No OpenCL compatible platform found");
12650
12651 return (-1);
12652 }
12653 }
12654
12655 /**
12656 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12657 */
12658
12659 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12660 {
12661 cl_platform_id platform = platforms[platform_id];
12662
12663 char platform_vendor[INFOSZ] = { 0 };
12664
12665 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12666
12667 #ifdef HAVE_HWMON
12668 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12669 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12670 {
12671 // make sure that we do not directly control the fan for NVidia
12672
12673 gpu_temp_retain = 0;
12674
12675 data.gpu_temp_retain = gpu_temp_retain;
12676 }
12677 #endif // HAVE_NVML || HAVE_NVAPI
12678 #endif
12679 }
12680
12681 /**
12682 * OpenCL devices: simply push all devices from all platforms into the same device array
12683 */
12684
12685 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12686
12687 data.devices_param = devices_param;
12688
12689 uint devices_cnt = 0;
12690
12691 uint devices_active = 0;
12692
12693 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12694 {
12695 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12696
12697 cl_platform_id platform = platforms[platform_id];
12698
12699 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12700
12701 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12702 {
12703 size_t param_value_size = 0;
12704
12705 const uint device_id = devices_cnt;
12706
12707 hc_device_param_t *device_param = &data.devices_param[device_id];
12708
12709 device_param->device = platform_devices[platform_devices_id];
12710
12711 device_param->device_id = device_id;
12712
12713 device_param->platform_devices_id = platform_devices_id;
12714
12715 // device_type
12716
12717 cl_device_type device_type;
12718
12719 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12720
12721 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12722
12723 device_param->device_type = device_type;
12724
12725 // vendor_id
12726
12727 cl_uint vendor_id = 0;
12728
12729 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12730
12731 device_param->vendor_id = vendor_id;
12732
12733 // device_name
12734
12735 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12736
12737 char *device_name = (char *) mymalloc (param_value_size);
12738
12739 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12740
12741 device_param->device_name = device_name;
12742
12743 // tuning db
12744
12745 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param->device_name, attack_mode, hash_mode);
12746
12747 // device_version
12748
12749 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12750
12751 char *device_version = (char *) mymalloc (param_value_size);
12752
12753 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12754
12755 device_param->device_version = device_version;
12756
12757 // device_opencl_version
12758
12759 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12760
12761 char *device_opencl_version = (char *) mymalloc (param_value_size);
12762
12763 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12764
12765 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12766
12767 myfree (device_opencl_version);
12768
12769 if (strstr (device_version, "pocl"))
12770 {
12771 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12772 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12773
12774 cl_uint vendor_id = VENDOR_ID_GENERIC;
12775
12776 device_param->vendor_id = vendor_id;
12777 }
12778
12779 // vector_width
12780
12781 cl_uint vector_width;
12782
12783 if (opencl_vector_width_chgd == 0)
12784 {
12785 if (tuningdb_entry == NULL)
12786 {
12787 if (opti_type & OPTI_TYPE_USES_BITS_64)
12788 {
12789 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12790 }
12791 else
12792 {
12793 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12794 }
12795 }
12796 else
12797 {
12798 if (tuningdb_entry->vector_width == -1)
12799 {
12800 if (opti_type & OPTI_TYPE_USES_BITS_64)
12801 {
12802 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12803 }
12804 else
12805 {
12806 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12807 }
12808 }
12809 else
12810 {
12811 vector_width = (cl_uint) tuningdb_entry->vector_width;
12812 }
12813 }
12814 }
12815 else
12816 {
12817 vector_width = opencl_vector_width;
12818 }
12819
12820 if (vector_width > 8) vector_width = 8;
12821
12822 device_param->vector_width = vector_width;
12823
12824 // max_compute_units
12825
12826 cl_uint device_processors;
12827
12828 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12829
12830 device_param->device_processors = device_processors;
12831
12832 // max_mem_alloc_size
12833
12834 cl_ulong device_maxmem_alloc;
12835
12836 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12837
12838 device_param->device_maxmem_alloc = device_maxmem_alloc;
12839
12840 // max_mem_alloc_size
12841
12842 cl_ulong device_global_mem;
12843
12844 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12845
12846 device_param->device_global_mem = device_global_mem;
12847
12848 // max_clock_frequency
12849
12850 cl_uint device_maxclock_frequency;
12851
12852 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12853
12854 device_param->device_maxclock_frequency = device_maxclock_frequency;
12855
12856 // skipped
12857
12858 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12859 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12860
12861 device_param->skipped = (skipped1 || skipped2);
12862
12863 // driver_version
12864 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12865
12866 char *driver_version = (char *) mymalloc (param_value_size);
12867
12868 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12869
12870 device_param->driver_version = driver_version;
12871
12872 // device_name_chksum
12873
12874 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12875
12876 #if __x86_64__
12877 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);
12878 #else
12879 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);
12880 #endif
12881
12882 uint device_name_digest[4] = { 0 };
12883
12884 md5_64 ((uint *) device_name_chksum, device_name_digest);
12885
12886 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12887
12888 device_param->device_name_chksum = device_name_chksum;
12889
12890 // device_processor_cores
12891
12892 if (device_type & CL_DEVICE_TYPE_CPU)
12893 {
12894 cl_uint device_processor_cores = 1;
12895
12896 device_param->device_processor_cores = device_processor_cores;
12897 }
12898
12899 if (device_type & CL_DEVICE_TYPE_GPU)
12900 {
12901 if (vendor_id == VENDOR_ID_AMD)
12902 {
12903 cl_uint device_processor_cores = 0;
12904
12905 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12906
12907 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12908
12909 device_param->device_processor_cores = device_processor_cores;
12910 }
12911 else if (vendor_id == VENDOR_ID_NV)
12912 {
12913 cl_uint kernel_exec_timeout = 0;
12914
12915 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12916
12917 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12918
12919 device_param->kernel_exec_timeout = kernel_exec_timeout;
12920
12921 cl_uint device_processor_cores = 0;
12922
12923 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12924
12925 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12926
12927 device_param->device_processor_cores = device_processor_cores;
12928
12929 cl_uint sm_minor = 0;
12930 cl_uint sm_major = 0;
12931
12932 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12933 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12934
12935 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12936 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12937
12938 device_param->sm_minor = sm_minor;
12939 device_param->sm_major = sm_major;
12940 }
12941 else
12942 {
12943 cl_uint device_processor_cores = 1;
12944
12945 device_param->device_processor_cores = device_processor_cores;
12946 }
12947 }
12948
12949 // display results
12950
12951 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12952 {
12953 if (device_param->skipped == 0)
12954 {
12955 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12956 device_id + 1,
12957 device_name,
12958 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12959 (unsigned int) (device_global_mem / 1024 / 1024),
12960 (unsigned int) (device_maxclock_frequency),
12961 (unsigned int) device_processors);
12962 }
12963 else
12964 {
12965 log_info ("Device #%u: %s, skipped",
12966 device_id + 1,
12967 device_name);
12968 }
12969 }
12970
12971 // common driver check
12972
12973 if (device_param->skipped == 0)
12974 {
12975 if (strstr (device_version, "pocl"))
12976 {
12977 if (force == 0)
12978 {
12979 log_info ("");
12980 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12981 log_info ("You are STRONGLY encouraged not to use it");
12982 log_info ("You can use --force to override this but do not post error reports if you do so");
12983 log_info ("");
12984
12985 return (-1);
12986 }
12987 }
12988
12989 if (device_type & CL_DEVICE_TYPE_GPU)
12990 {
12991 if (vendor_id == VENDOR_ID_NV)
12992 {
12993 if (device_param->kernel_exec_timeout != 0)
12994 {
12995 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);
12996 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12997 }
12998 }
12999 else if (vendor_id == VENDOR_ID_AMD)
13000 {
13001 int catalyst_check = (force == 1) ? 0 : 1;
13002
13003 int catalyst_warn = 0;
13004
13005 int catalyst_broken = 0;
13006
13007 if (catalyst_check == 1)
13008 {
13009 catalyst_warn = 1;
13010
13011 // v14.9 and higher
13012 if (atoi (device_param->driver_version) >= 1573)
13013 {
13014 catalyst_warn = 0;
13015 }
13016
13017 catalyst_check = 0;
13018 }
13019
13020 if (catalyst_broken == 1)
13021 {
13022 log_info ("");
13023 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13024 log_info ("It will pass over cracked hashes and does not report them as cracked");
13025 log_info ("You are STRONGLY encouraged not to use it");
13026 log_info ("You can use --force to override this but do not post error reports if you do so");
13027 log_info ("");
13028
13029 return (-1);
13030 }
13031
13032 if (catalyst_warn == 1)
13033 {
13034 log_info ("");
13035 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13036 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13037 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
13038 #ifdef _WIN
13039 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13040 #endif
13041 log_info ("You can use --force to override this but do not post error reports if you do so");
13042 log_info ("");
13043
13044 return (-1);
13045 }
13046 }
13047 }
13048
13049 /**
13050 * kernel accel and loops tuning db adjustment
13051 */
13052
13053 uint _kernel_accel = kernel_accel;
13054 uint _kernel_loops = kernel_loops;
13055
13056 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param->device_name, attack_mode, hash_mode);
13057
13058 if (kernel_accel_chgd == 0)
13059 {
13060 if (tuningdb_entry)
13061 {
13062 _kernel_accel = tuningdb_entry->kernel_accel;
13063 }
13064 }
13065
13066 if (kernel_loops_chgd == 0)
13067 {
13068 if (tuningdb_entry)
13069 {
13070 _kernel_loops = tuningdb_entry->kernel_loops;
13071
13072 if (workload_profile == 1)
13073 {
13074 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13075 }
13076 else if (workload_profile == 2)
13077 {
13078 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13079 }
13080 }
13081 }
13082
13083 device_param->kernel_accel = _kernel_accel;
13084 device_param->kernel_loops = _kernel_loops;
13085
13086 devices_active++;
13087 }
13088
13089 // next please
13090
13091 devices_cnt++;
13092 }
13093 }
13094
13095 if (keyspace == 0 && devices_active == 0)
13096 {
13097 log_error ("ERROR: No devices found/left");
13098
13099 return (-1);
13100 }
13101
13102 data.devices_cnt = devices_cnt;
13103
13104 data.devices_active = devices_active;
13105
13106 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13107 {
13108 log_info ("");
13109 }
13110
13111 /**
13112 * HM devices: init
13113 */
13114
13115 #ifdef HAVE_HWMON
13116 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13117 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13118 #endif
13119
13120 #ifdef HAVE_ADL
13121 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13122 #endif
13123
13124 if (gpu_temp_disable == 0)
13125 {
13126 #if defined(WIN) && defined(HAVE_NVAPI)
13127 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13128
13129 if (nvapi_init (nvapi) == 0)
13130 data.hm_nv = nvapi;
13131
13132 if (data.hm_nv)
13133 {
13134 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13135 {
13136 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13137
13138 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13139
13140 int tmp_out = 0;
13141
13142 for (int i = 0; i < tmp_in; i++)
13143 {
13144 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13145 }
13146
13147 for (int i = 0; i < tmp_out; i++)
13148 {
13149 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13150
13151 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13152
13153 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;
13154 }
13155 }
13156 }
13157 #endif // WIN && HAVE_NVAPI
13158
13159 #if defined(LINUX) && defined(HAVE_NVML)
13160 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13161
13162 if (nvml_init (nvml) == 0)
13163 data.hm_nv = nvml;
13164
13165 if (data.hm_nv)
13166 {
13167 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13168 {
13169 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13170
13171 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13172
13173 int tmp_out = 0;
13174
13175 for (int i = 0; i < tmp_in; i++)
13176 {
13177 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13178 }
13179
13180 for (int i = 0; i < tmp_out; i++)
13181 {
13182 unsigned int speed;
13183
13184 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;
13185 }
13186 }
13187 }
13188 #endif // LINUX && HAVE_NVML
13189
13190 data.hm_amd = NULL;
13191
13192 #ifdef HAVE_ADL
13193 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13194
13195 if (adl_init (adl) == 0)
13196 data.hm_amd = adl;
13197
13198 if (data.hm_amd)
13199 {
13200 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13201 {
13202 // total number of adapters
13203
13204 int hm_adapters_num;
13205
13206 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13207
13208 // adapter info
13209
13210 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13211
13212 if (lpAdapterInfo == NULL) return (-1);
13213
13214 // get a list (of ids of) valid/usable adapters
13215
13216 int num_adl_adapters = 0;
13217
13218 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13219
13220 if (num_adl_adapters > 0)
13221 {
13222 hc_thread_mutex_lock (mux_adl);
13223
13224 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13225
13226 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13227
13228 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13229 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13230
13231 hc_thread_mutex_unlock (mux_adl);
13232 }
13233
13234 myfree (valid_adl_device_list);
13235 myfree (lpAdapterInfo);
13236 }
13237 }
13238 #endif // HAVE_ADL
13239
13240 if (data.hm_amd == NULL && data.hm_nv == NULL)
13241 {
13242 gpu_temp_disable = 1;
13243 }
13244 }
13245
13246 /**
13247 * OpenCL devices: allocate buffer for device specific information
13248 */
13249
13250 #ifdef HAVE_HWMON
13251 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13252
13253 #ifdef HAVE_ADL
13254 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13255
13256 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13257 #endif // ADL
13258 #endif
13259
13260 /**
13261 * enable custom signal handler(s)
13262 */
13263
13264 if (benchmark == 0)
13265 {
13266 hc_signal (sigHandler_default);
13267 }
13268 else
13269 {
13270 hc_signal (sigHandler_benchmark);
13271 }
13272
13273 /**
13274 * User-defined GPU temp handling
13275 */
13276
13277 #ifdef HAVE_HWMON
13278 if (gpu_temp_disable == 1)
13279 {
13280 gpu_temp_abort = 0;
13281 gpu_temp_retain = 0;
13282 }
13283
13284 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13285 {
13286 if (gpu_temp_abort < gpu_temp_retain)
13287 {
13288 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13289
13290 return (-1);
13291 }
13292 }
13293
13294 data.gpu_temp_disable = gpu_temp_disable;
13295 data.gpu_temp_abort = gpu_temp_abort;
13296 data.gpu_temp_retain = gpu_temp_retain;
13297 #endif
13298
13299 /**
13300 * inform the user
13301 */
13302
13303 if (data.quiet == 0)
13304 {
13305 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13306
13307 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);
13308
13309 if (attack_mode == ATTACK_MODE_STRAIGHT)
13310 {
13311 log_info ("Rules: %u", kernel_rules_cnt);
13312 }
13313
13314 if (opti_type)
13315 {
13316 log_info ("Applicable Optimizers:");
13317
13318 for (uint i = 0; i < 32; i++)
13319 {
13320 const uint opti_bit = 1u << i;
13321
13322 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13323 }
13324 }
13325
13326 /**
13327 * Watchdog and Temperature balance
13328 */
13329
13330 #ifdef HAVE_HWMON
13331 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13332 {
13333 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13334 }
13335
13336 if (gpu_temp_abort == 0)
13337 {
13338 log_info ("Watchdog: Temperature abort trigger disabled");
13339 }
13340 else
13341 {
13342 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13343 }
13344
13345 if (gpu_temp_retain == 0)
13346 {
13347 log_info ("Watchdog: Temperature retain trigger disabled");
13348 }
13349 else
13350 {
13351 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13352 }
13353 #endif
13354 }
13355
13356 if (data.quiet == 0) log_info ("");
13357
13358 /**
13359 * HM devices: copy
13360 */
13361
13362 if (gpu_temp_disable == 0)
13363 {
13364 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13365 {
13366 hc_device_param_t *device_param = &data.devices_param[device_id];
13367
13368 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13369
13370 if (device_param->skipped) continue;
13371
13372 const uint platform_devices_id = device_param->platform_devices_id;
13373
13374 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13375 if (device_param->vendor_id == VENDOR_ID_NV)
13376 {
13377 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13378 }
13379 #endif
13380
13381 #ifdef HAVE_ADL
13382 if (device_param->vendor_id == VENDOR_ID_AMD)
13383 {
13384 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13385 }
13386 #endif
13387 }
13388 }
13389
13390 /*
13391 * Temporary fix:
13392 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13393 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13394 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13395 * Driver / ADL bug?
13396 */
13397
13398 #ifdef HAVE_ADL
13399 if (powertune_enable == 1)
13400 {
13401 hc_thread_mutex_lock (mux_adl);
13402
13403 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13404 {
13405 hc_device_param_t *device_param = &data.devices_param[device_id];
13406
13407 if (device_param->skipped) continue;
13408
13409 if (data.hm_device[device_id].od_version == 6)
13410 {
13411 // set powertune value only
13412
13413 int powertune_supported = 0;
13414
13415 int ADL_rc = 0;
13416
13417 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13418 {
13419 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13420
13421 return (-1);
13422 }
13423
13424 if (powertune_supported != 0)
13425 {
13426 // powertune set
13427 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13428
13429 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13430 {
13431 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13432
13433 return (-1);
13434 }
13435
13436 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13437 {
13438 log_error ("ERROR: Failed to set new ADL PowerControl values");
13439
13440 return (-1);
13441 }
13442 }
13443 }
13444 }
13445
13446 hc_thread_mutex_unlock (mux_adl);
13447 }
13448 #endif // HAVE_ADK
13449 #endif // HAVE_HWMON
13450
13451 #ifdef OSX
13452 if (hash_mode == 3000 || hash_mode == 1500 || hash_mode == 10700)
13453 {
13454 if (force == 0)
13455 {
13456 log_info ("");
13457 log_info ("Warning: Hash mode %d is not stable with OSX.", hash_mode);
13458 log_info ("You can use --force to override this but do not post error reports if you do so");
13459 log_info ("");
13460
13461 continue;
13462 }
13463 }
13464 #endif
13465
13466 #ifdef DEBUG
13467 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13468 #endif
13469
13470 uint kernel_power_all = 0;
13471
13472 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13473 {
13474 /**
13475 * host buffer
13476 */
13477
13478 hc_device_param_t *device_param = &data.devices_param[device_id];
13479
13480 if (device_param->skipped) continue;
13481
13482 /**
13483 * device properties
13484 */
13485
13486 const char *device_name_chksum = device_param->device_name_chksum;
13487 const u32 device_processors = device_param->device_processors;
13488 const u32 device_processor_cores = device_param->device_processor_cores;
13489
13490 /**
13491 * create context for each device
13492 */
13493
13494 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13495
13496 /**
13497 * create command-queue
13498 */
13499
13500 // not supported with NV
13501 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13502
13503 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13504
13505 /**
13506 * create input buffers on device : calculate size of fixed memory buffers
13507 */
13508
13509 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13510 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13511
13512 device_param->size_root_css = size_root_css;
13513 device_param->size_markov_css = size_markov_css;
13514
13515 uint size_results = KERNEL_THREADS * sizeof (uint);
13516
13517 device_param->size_results = size_results;
13518
13519 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13520 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13521
13522 uint size_plains = digests_cnt * sizeof (plain_t);
13523 uint size_salts = salts_cnt * sizeof (salt_t);
13524 uint size_esalts = salts_cnt * esalt_size;
13525
13526 device_param->size_plains = size_plains;
13527 device_param->size_digests = size_digests;
13528 device_param->size_shown = size_shown;
13529 device_param->size_salts = size_salts;
13530
13531 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13532 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13533 uint size_tm = 32 * sizeof (bs_word_t);
13534
13535 // scryptV stuff
13536
13537 u64 size_scryptV = 1;
13538
13539 if ((hash_mode == 8900) || (hash_mode == 9300))
13540 {
13541 uint tmto_start = 0;
13542 uint tmto_stop = 10;
13543
13544 if (scrypt_tmto)
13545 {
13546 tmto_start = scrypt_tmto;
13547 }
13548 else
13549 {
13550 // in case the user did not specify the tmto manually
13551 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13552 // but set the lower end only in case the user has a device with too less memory
13553
13554 if (hash_mode == 8900)
13555 {
13556 if (device_param->vendor_id == VENDOR_ID_AMD)
13557 {
13558 tmto_start = 1;
13559 }
13560 else if (device_param->vendor_id == VENDOR_ID_NV)
13561 {
13562 tmto_start = 3;
13563 }
13564 }
13565 else if (hash_mode == 9300)
13566 {
13567 if (device_param->vendor_id == VENDOR_ID_AMD)
13568 {
13569 tmto_start = 3;
13570 }
13571 else if (device_param->vendor_id == VENDOR_ID_NV)
13572 {
13573 tmto_start = 5;
13574 }
13575 }
13576 }
13577
13578 if (quiet == 0) log_info ("");
13579
13580 uint shader_per_mp = 1;
13581
13582 if (device_param->vendor_id == VENDOR_ID_AMD)
13583 {
13584 shader_per_mp = 8;
13585 }
13586 else if (device_param->vendor_id == VENDOR_ID_NV)
13587 {
13588 shader_per_mp = 32;
13589 }
13590
13591 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13592 {
13593 // TODO: in theory the following calculation needs to be done per salt, not global
13594 // we assume all hashes have the same scrypt settings
13595
13596 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13597
13598 size_scryptV /= 1 << tmto;
13599
13600 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13601
13602 if (size_scryptV > device_param->device_maxmem_alloc)
13603 {
13604 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13605
13606 continue;
13607 }
13608
13609 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13610 {
13611 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13612 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13613 }
13614
13615 break;
13616 }
13617
13618 if (data.salts_buf[0].scrypt_phy == 0)
13619 {
13620 log_error ("ERROR: can't allocate enough device memory");
13621
13622 return -1;
13623 }
13624
13625 if (quiet == 0) log_info ("");
13626 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13627 }
13628
13629 /**
13630 * create input buffers on device : calculate size of dynamic size memory buffers
13631 */
13632
13633 uint kernel_threads = KERNEL_THREADS;
13634
13635 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13636
13637 if (hash_mode == 3200) kernel_threads = 8;
13638 if (hash_mode == 9000) kernel_threads = 8;
13639
13640 /**
13641 * some algorithms need a fixed kernel-loops count
13642 */
13643
13644 u32 kernel_loops_min = 1;
13645 u32 kernel_loops_max = 1024;
13646
13647 if (hash_mode == 1500)
13648 {
13649 const u32 kernel_loops_fixed = 1024;
13650
13651 kernel_loops_min = kernel_loops_fixed;
13652 kernel_loops_max = kernel_loops_fixed;
13653 }
13654
13655 if (hash_mode == 3000)
13656 {
13657 const u32 kernel_loops_fixed = 1024;
13658
13659 kernel_loops_min = kernel_loops_fixed;
13660 kernel_loops_max = kernel_loops_fixed;
13661 }
13662
13663 if (hash_mode == 8900)
13664 {
13665 const u32 kernel_loops_fixed = 1;
13666
13667 kernel_loops_min = kernel_loops_fixed;
13668 kernel_loops_max = kernel_loops_fixed;
13669 }
13670
13671 if (hash_mode == 9300)
13672 {
13673 const u32 kernel_loops_fixed = 1;
13674
13675 kernel_loops_min = kernel_loops_fixed;
13676 kernel_loops_max = kernel_loops_fixed;
13677 }
13678
13679 if (hash_mode == 12500)
13680 {
13681 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13682
13683 kernel_loops_min = kernel_loops_fixed;
13684 kernel_loops_max = kernel_loops_fixed;
13685 }
13686
13687 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13688 {
13689 if (data.salts_buf[0].salt_iter < kernel_loops_max)
13690 {
13691 kernel_loops_max = data.salts_buf[0].salt_iter;
13692 }
13693 }
13694
13695 device_param->kernel_loops_min = kernel_loops_min;
13696 device_param->kernel_loops_max = kernel_loops_max;
13697
13698 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13699
13700 uint size_pws = 4;
13701 uint size_tmps = 4;
13702 uint size_hooks = 4;
13703
13704 uint kernel_accel_min = 1;
13705 uint kernel_accel_max = 1024;
13706
13707 /**
13708 * some algorithms need a special kernel-accel
13709 */
13710
13711 if (hash_mode == 8900)
13712 {
13713 kernel_accel_max = 64;
13714 }
13715
13716 if (hash_mode == 9300)
13717 {
13718 kernel_accel_max = 64;
13719 }
13720
13721 while (kernel_accel_max)
13722 {
13723 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13724
13725 // size_pws
13726
13727 size_pws = kernel_power_max * sizeof (pw_t);
13728
13729 // size_tmps
13730
13731 switch (hash_mode)
13732 {
13733 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13734 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13735 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13736 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13737 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13738 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13739 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13740 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13741 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13742 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13743 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13744 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13745 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13746 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13747 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13748 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13749 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13750 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13751 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13752 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13753 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13754 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13755 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13756 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13757 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13758 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13759 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13760 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13761 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13762 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13763 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13764 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13765 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13766 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13767 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13768 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13769 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13770 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13771 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13772 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13773 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13774 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13775 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13776 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13777 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13778 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13779 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13780 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13781 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13782 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13783 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13784 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13785 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13786 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13787 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13788 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13789 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13790 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13791 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13792 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13793 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13794 };
13795
13796 // size_hooks
13797
13798 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13799 {
13800 // none yet
13801 }
13802
13803 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13804 // if not, decrease amplifier and try again
13805
13806 int skip = 0;
13807
13808 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13809 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13810 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13811
13812 if (( bitmap_size
13813 + bitmap_size
13814 + bitmap_size
13815 + bitmap_size
13816 + bitmap_size
13817 + bitmap_size
13818 + bitmap_size
13819 + bitmap_size
13820 + size_bfs
13821 + size_combs
13822 + size_digests
13823 + size_esalts
13824 + size_hooks
13825 + size_markov_css
13826 + size_plains
13827 + size_pws
13828 + size_results
13829 + size_root_css
13830 + size_rules
13831 + size_rules_c
13832 + size_salts
13833 + size_scryptV
13834 + size_shown
13835 + size_tm
13836 + size_tmps) > device_param->device_global_mem) skip = 1;
13837
13838 if (skip == 1)
13839 {
13840 kernel_accel_max--;
13841
13842 continue;
13843 }
13844
13845 break;
13846 }
13847
13848 if (kernel_accel_max == 0)
13849 {
13850 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13851
13852 return -1;
13853 }
13854
13855 device_param->kernel_accel_min = kernel_accel_min;
13856 device_param->kernel_accel_max = kernel_accel_max;
13857
13858 if (kernel_accel_max < kernel_accel)
13859 {
13860 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13861
13862 device_param->kernel_accel = kernel_accel_max;
13863 }
13864
13865 const u32 kernel_accel = device_param->kernel_accel;
13866
13867 device_param->size_pws = size_pws;
13868 device_param->size_tmps = size_tmps;
13869 device_param->size_hooks = size_hooks;
13870
13871 // do not confuse kernel_accel_max with kernel_accel here
13872
13873 const u32 kernel_power = device_processors * kernel_threads * kernel_accel;
13874
13875 device_param->kernel_threads = kernel_threads;
13876 device_param->kernel_power_user = kernel_power;
13877
13878 kernel_power_all += kernel_power;
13879
13880 /**
13881 * default building options
13882 */
13883
13884 char build_opts[1024] = { 0 };
13885
13886 // we don't have sm_* on vendors not NV but it doesn't matter
13887
13888 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);
13889
13890 /**
13891 * main kernel
13892 */
13893
13894 {
13895 /**
13896 * kernel source filename
13897 */
13898
13899 char source_file[256] = { 0 };
13900
13901 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13902
13903 struct stat sst;
13904
13905 if (stat (source_file, &sst) == -1)
13906 {
13907 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13908
13909 return -1;
13910 }
13911
13912 /**
13913 * kernel cached filename
13914 */
13915
13916 char cached_file[256] = { 0 };
13917
13918 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13919
13920 int cached = 1;
13921
13922 struct stat cst;
13923
13924 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13925 {
13926 cached = 0;
13927 }
13928
13929 /**
13930 * kernel compile or load
13931 */
13932
13933 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13934
13935 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13936
13937 if (force_jit_compilation == -1)
13938 {
13939 if (cached == 0)
13940 {
13941 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13942
13943 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13944
13945 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13946
13947 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13948
13949 if (rc != 0)
13950 {
13951 device_param->skipped = true;
13952 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13953 continue;
13954 }
13955
13956 size_t binary_size;
13957
13958 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13959
13960 u8 *binary = (u8 *) mymalloc (binary_size);
13961
13962 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13963
13964 writeProgramBin (cached_file, binary, binary_size);
13965
13966 local_free (binary);
13967 }
13968 else
13969 {
13970 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13971
13972 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13973
13974 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13975
13976 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13977 }
13978 }
13979 else
13980 {
13981 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13982
13983 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13984
13985 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13986
13987 char build_opts_update[1024] = { 0 };
13988
13989 if (force_jit_compilation == 1500)
13990 {
13991 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13992 }
13993 else if (force_jit_compilation == 8900)
13994 {
13995 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);
13996 }
13997
13998 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13999
14000 if (rc != 0)
14001 {
14002 device_param->skipped = true;
14003 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14004 }
14005 }
14006
14007 local_free (kernel_lengths);
14008 local_free (kernel_sources[0]);
14009 local_free (kernel_sources);
14010 }
14011
14012 /**
14013 * word generator kernel
14014 */
14015
14016 if (attack_mode != ATTACK_MODE_STRAIGHT)
14017 {
14018 /**
14019 * kernel mp source filename
14020 */
14021
14022 char source_file[256] = { 0 };
14023
14024 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14025
14026 struct stat sst;
14027
14028 if (stat (source_file, &sst) == -1)
14029 {
14030 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14031
14032 return -1;
14033 }
14034
14035 /**
14036 * kernel mp cached filename
14037 */
14038
14039 char cached_file[256] = { 0 };
14040
14041 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14042
14043 int cached = 1;
14044
14045 struct stat cst;
14046
14047 if (stat (cached_file, &cst) == -1)
14048 {
14049 cached = 0;
14050 }
14051
14052 /**
14053 * kernel compile or load
14054 */
14055
14056 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14057
14058 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14059
14060 if (cached == 0)
14061 {
14062 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14063
14064 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14065
14066 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14067
14068 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14069
14070 if (rc != 0)
14071 {
14072 device_param->skipped = true;
14073 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14074 continue;
14075 }
14076
14077 size_t binary_size;
14078
14079 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14080
14081 u8 *binary = (u8 *) mymalloc (binary_size);
14082
14083 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14084
14085 writeProgramBin (cached_file, binary, binary_size);
14086
14087 local_free (binary);
14088 }
14089 else
14090 {
14091 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14092
14093 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14094
14095 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14096
14097 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14098 }
14099
14100 local_free (kernel_lengths);
14101 local_free (kernel_sources[0]);
14102 local_free (kernel_sources);
14103 }
14104
14105 /**
14106 * amplifier kernel
14107 */
14108
14109 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14110 {
14111
14112 }
14113 else
14114 {
14115 /**
14116 * kernel amp source filename
14117 */
14118
14119 char source_file[256] = { 0 };
14120
14121 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14122
14123 struct stat sst;
14124
14125 if (stat (source_file, &sst) == -1)
14126 {
14127 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14128
14129 return -1;
14130 }
14131
14132 /**
14133 * kernel amp cached filename
14134 */
14135
14136 char cached_file[256] = { 0 };
14137
14138 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14139
14140 int cached = 1;
14141
14142 struct stat cst;
14143
14144 if (stat (cached_file, &cst) == -1)
14145 {
14146 cached = 0;
14147 }
14148
14149 /**
14150 * kernel compile or load
14151 */
14152
14153 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14154
14155 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14156
14157 if (cached == 0)
14158 {
14159 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14160
14161 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14162
14163 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14164
14165 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14166
14167 if (rc != 0)
14168 {
14169 device_param->skipped = true;
14170 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14171 continue;
14172 }
14173
14174 size_t binary_size;
14175
14176 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14177
14178 u8 *binary = (u8 *) mymalloc (binary_size);
14179
14180 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14181
14182 writeProgramBin (cached_file, binary, binary_size);
14183
14184 local_free (binary);
14185 }
14186 else
14187 {
14188 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14189
14190 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14191
14192 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14193
14194 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14195 }
14196
14197 local_free (kernel_lengths);
14198 local_free (kernel_sources[0]);
14199 local_free (kernel_sources);
14200 }
14201
14202 // some algorithm collide too fast, make that impossible
14203
14204 if (benchmark == 1)
14205 {
14206 ((uint *) digests_buf)[0] = -1;
14207 ((uint *) digests_buf)[1] = -1;
14208 ((uint *) digests_buf)[2] = -1;
14209 ((uint *) digests_buf)[3] = -1;
14210 }
14211
14212 /**
14213 * global buffers
14214 */
14215
14216 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14217 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14218 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14219 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14220 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14221 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14222 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14223 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14224 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14225 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14226 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14227 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14228 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14229 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14230 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14231 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14232 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14233 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14234
14235 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);
14236 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);
14237 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);
14238 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);
14239 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);
14240 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);
14241 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);
14242 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);
14243 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14244 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14245 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14246
14247 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14248 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14249 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14250 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14251 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14252 run_kernel_bzero (device_param, device_param->d_result, size_results);
14253
14254 /**
14255 * special buffers
14256 */
14257
14258 if (attack_kern == ATTACK_KERN_STRAIGHT)
14259 {
14260 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14261 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14262
14263 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14264
14265 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14266 }
14267 else if (attack_kern == ATTACK_KERN_COMBI)
14268 {
14269 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14270 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14271 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14272 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14273
14274 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14275 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14276 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14277 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14278 }
14279 else if (attack_kern == ATTACK_KERN_BF)
14280 {
14281 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14282 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14283 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14284 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14285 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14286
14287 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14288 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14289 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14290 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14291 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14292 }
14293
14294 if (size_esalts)
14295 {
14296 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14297
14298 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14299 }
14300
14301 /**
14302 * main host data
14303 */
14304
14305 uint *result = (uint *) mymalloc (size_results);
14306
14307 device_param->result = result;
14308
14309 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14310
14311 device_param->pws_buf = pws_buf;
14312
14313 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
14314
14315 for (int i = 0; i < 64; i++)
14316 {
14317 pw_caches[i].pw_buf.pw_len = i;
14318 pw_caches[i].cnt = 0;
14319 }
14320
14321 device_param->pw_caches = pw_caches;
14322
14323 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14324
14325 device_param->combs_buf = combs_buf;
14326
14327 void *hooks_buf = mymalloc (size_hooks);
14328
14329 device_param->hooks_buf = hooks_buf;
14330
14331 device_param->pw_transpose = pw_transpose_to_hi1;
14332 device_param->pw_add = pw_add_to_hc1;
14333
14334 /**
14335 * kernel args
14336 */
14337
14338 device_param->kernel_params_buf32[21] = bitmap_mask;
14339 device_param->kernel_params_buf32[22] = bitmap_shift1;
14340 device_param->kernel_params_buf32[23] = bitmap_shift2;
14341 device_param->kernel_params_buf32[24] = 0; // salt_pos
14342 device_param->kernel_params_buf32[25] = 0; // loop_pos
14343 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14344 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14345 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14346 device_param->kernel_params_buf32[29] = 0; // digests_offset
14347 device_param->kernel_params_buf32[30] = 0; // combs_mode
14348 device_param->kernel_params_buf32[31] = 0; // gid_max
14349
14350 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14351 ? &device_param->d_pws_buf
14352 : &device_param->d_pws_amp_buf;
14353 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14354 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14355 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14356 device_param->kernel_params[ 4] = &device_param->d_tmps;
14357 device_param->kernel_params[ 5] = &device_param->d_hooks;
14358 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14359 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14360 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14361 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14362 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14363 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14364 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14365 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14366 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14367 device_param->kernel_params[15] = &device_param->d_digests_buf;
14368 device_param->kernel_params[16] = &device_param->d_digests_shown;
14369 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14370 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14371 device_param->kernel_params[19] = &device_param->d_result;
14372 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14373 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14374 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14375 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14376 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14377 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14378 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14379 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14380 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14381 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14382 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14383 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14384
14385 device_param->kernel_params_mp_buf64[3] = 0;
14386 device_param->kernel_params_mp_buf32[4] = 0;
14387 device_param->kernel_params_mp_buf32[5] = 0;
14388 device_param->kernel_params_mp_buf32[6] = 0;
14389 device_param->kernel_params_mp_buf32[7] = 0;
14390 device_param->kernel_params_mp_buf32[8] = 0;
14391
14392 device_param->kernel_params_mp[0] = NULL;
14393 device_param->kernel_params_mp[1] = NULL;
14394 device_param->kernel_params_mp[2] = NULL;
14395 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14396 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14397 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14398 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14399 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14400 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14401
14402 device_param->kernel_params_mp_l_buf64[3] = 0;
14403 device_param->kernel_params_mp_l_buf32[4] = 0;
14404 device_param->kernel_params_mp_l_buf32[5] = 0;
14405 device_param->kernel_params_mp_l_buf32[6] = 0;
14406 device_param->kernel_params_mp_l_buf32[7] = 0;
14407 device_param->kernel_params_mp_l_buf32[8] = 0;
14408 device_param->kernel_params_mp_l_buf32[9] = 0;
14409
14410 device_param->kernel_params_mp_l[0] = NULL;
14411 device_param->kernel_params_mp_l[1] = NULL;
14412 device_param->kernel_params_mp_l[2] = NULL;
14413 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14414 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14415 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14416 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14417 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14418 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14419 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14420
14421 device_param->kernel_params_mp_r_buf64[3] = 0;
14422 device_param->kernel_params_mp_r_buf32[4] = 0;
14423 device_param->kernel_params_mp_r_buf32[5] = 0;
14424 device_param->kernel_params_mp_r_buf32[6] = 0;
14425 device_param->kernel_params_mp_r_buf32[7] = 0;
14426 device_param->kernel_params_mp_r_buf32[8] = 0;
14427
14428 device_param->kernel_params_mp_r[0] = NULL;
14429 device_param->kernel_params_mp_r[1] = NULL;
14430 device_param->kernel_params_mp_r[2] = NULL;
14431 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14432 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14433 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14434 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14435 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14436 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14437
14438 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14439 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14440
14441 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14442 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14443 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14444 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14445 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14446 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14447 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14448
14449 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14450
14451 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14452 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14453
14454 /**
14455 * kernel name
14456 */
14457
14458 char kernel_name[64] = { 0 };
14459
14460 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14461 {
14462 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14463 {
14464 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14465
14466 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14467
14468 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14469
14470 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14471
14472 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14473
14474 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14475 }
14476 else
14477 {
14478 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14479
14480 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14481
14482 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14483
14484 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14485
14486 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14487
14488 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14489 }
14490
14491 if (data.attack_mode == ATTACK_MODE_BF)
14492 {
14493 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14494 {
14495 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14496
14497 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14498
14499 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14500
14501 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14502 }
14503 }
14504 }
14505 else
14506 {
14507 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14508
14509 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14510
14511 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14512
14513 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14514
14515 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14516
14517 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14518
14519 if (opts_type & OPTS_TYPE_HOOK12)
14520 {
14521 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14522
14523 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14524 }
14525
14526 if (opts_type & OPTS_TYPE_HOOK23)
14527 {
14528 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14529
14530 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14531 }
14532 }
14533
14534 for (uint i = 0; i <= 20; i++)
14535 {
14536 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14537 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14538 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14539
14540 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14541 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14542 }
14543
14544 for (uint i = 21; i <= 31; i++)
14545 {
14546 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14547 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14548 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14549
14550 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14551 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14552 }
14553
14554 if (attack_mode == ATTACK_MODE_BF)
14555 {
14556 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14557 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14558
14559 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14560 {
14561 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14562
14563 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14564 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14565 }
14566 }
14567 else if (attack_mode == ATTACK_MODE_HYBRID1)
14568 {
14569 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14570 }
14571 else if (attack_mode == ATTACK_MODE_HYBRID2)
14572 {
14573 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14574 }
14575
14576 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14577 {
14578 // nothing to do
14579 }
14580 else
14581 {
14582 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14583 }
14584
14585 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14586 {
14587 // nothing to do
14588 }
14589 else
14590 {
14591 for (uint i = 0; i < 5; i++)
14592 {
14593 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14594 }
14595
14596 for (uint i = 5; i < 7; i++)
14597 {
14598 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14599 }
14600 }
14601
14602 /**
14603 * Store initial fanspeed if gpu_temp_retain is enabled
14604 */
14605
14606 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14607 int gpu_temp_retain_set = 0;
14608
14609 if (gpu_temp_disable == 0)
14610 {
14611 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14612 {
14613 hc_thread_mutex_lock (mux_adl);
14614
14615 if (data.hm_device[device_id].fan_supported == 1)
14616 {
14617 if (gpu_temp_retain_chgd == 0)
14618 {
14619 uint cur_temp = 0;
14620 uint default_temp = 0;
14621
14622 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);
14623
14624 if (ADL_rc == ADL_OK)
14625 {
14626 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14627
14628 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14629
14630 // special case with multi gpu setups: always use minimum retain
14631
14632 if (gpu_temp_retain_set == 0)
14633 {
14634 gpu_temp_retain = gpu_temp_retain_target;
14635 gpu_temp_retain_set = 1;
14636 }
14637 else
14638 {
14639 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14640 }
14641
14642 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14643 }
14644 }
14645
14646 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14647
14648 temp_retain_fanspeed_value[device_id] = fan_speed;
14649
14650 if (fan_speed == -1)
14651 {
14652 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14653
14654 temp_retain_fanspeed_value[device_id] = 0;
14655 }
14656 }
14657
14658 hc_thread_mutex_unlock (mux_adl);
14659 }
14660 }
14661
14662 /**
14663 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14664 */
14665
14666 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14667 {
14668 hc_thread_mutex_lock (mux_adl);
14669
14670 if (data.hm_device[device_id].od_version == 6)
14671 {
14672 int ADL_rc;
14673
14674 // check powertune capabilities first, if not available then skip device
14675
14676 int powertune_supported = 0;
14677
14678 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14679 {
14680 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14681
14682 return (-1);
14683 }
14684
14685 if (powertune_supported != 0)
14686 {
14687 // powercontrol settings
14688
14689 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14690
14691 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14692 {
14693 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14694 }
14695
14696 if (ADL_rc != ADL_OK)
14697 {
14698 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14699
14700 return (-1);
14701 }
14702
14703 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14704 {
14705 log_error ("ERROR: Failed to set new ADL PowerControl values");
14706
14707 return (-1);
14708 }
14709
14710 // clocks
14711
14712 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14713
14714 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14715
14716 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)
14717 {
14718 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14719
14720 return (-1);
14721 }
14722
14723 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14724
14725 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14726
14727 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14728 {
14729 log_error ("ERROR: Failed to get ADL device capabilities");
14730
14731 return (-1);
14732 }
14733
14734 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14735 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14736
14737 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14738 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14739
14740 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14741 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14742
14743 // warning if profile has too low max values
14744
14745 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14746 {
14747 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14748 }
14749
14750 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14751 {
14752 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14753 }
14754
14755 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14756
14757 performance_state->iNumberOfPerformanceLevels = 2;
14758
14759 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14760 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14761 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14762 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14763
14764 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)
14765 {
14766 log_info ("ERROR: Failed to set ADL performance state");
14767
14768 return (-1);
14769 }
14770
14771 local_free (performance_state);
14772 }
14773 }
14774
14775 hc_thread_mutex_unlock (mux_adl);
14776 }
14777 #endif // HAVE_HWMON && HAVE_ADL
14778 }
14779
14780 data.kernel_power_all = kernel_power_all;
14781
14782 if (data.quiet == 0) log_info ("");
14783
14784 /**
14785 * Inform user which algorithm is checked and at which workload setting
14786 */
14787
14788 if (benchmark == 1)
14789 {
14790 quiet = 0;
14791
14792 data.quiet = quiet;
14793
14794 char *hash_type = strhashtype (data.hash_mode); // not a bug
14795
14796 log_info ("Hashtype: %s", hash_type);
14797 log_info ("");
14798 }
14799
14800 /**
14801 * keep track of the progress
14802 */
14803
14804 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14805 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14806 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14807
14808 /**
14809 * open filehandles
14810 */
14811
14812 #if _WIN
14813 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14814 {
14815 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14816
14817 return (-1);
14818 }
14819
14820 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14821 {
14822 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14823
14824 return (-1);
14825 }
14826
14827 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14828 {
14829 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14830
14831 return (-1);
14832 }
14833 #endif
14834
14835 /**
14836 * dictionary pad
14837 */
14838
14839 segment_size *= (1024 * 1024);
14840
14841 data.segment_size = segment_size;
14842
14843 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14844
14845 wl_data->buf = (char *) mymalloc (segment_size);
14846 wl_data->avail = segment_size;
14847 wl_data->incr = segment_size;
14848 wl_data->cnt = 0;
14849 wl_data->pos = 0;
14850
14851 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14852
14853 data.wordlist_mode = wordlist_mode;
14854
14855 cs_t *css_buf = NULL;
14856 uint css_cnt = 0;
14857 uint dictcnt = 0;
14858 uint maskcnt = 1;
14859 char **masks = NULL;
14860 char **dictfiles = NULL;
14861
14862 uint mask_from_file = 0;
14863
14864 if (attack_mode == ATTACK_MODE_STRAIGHT)
14865 {
14866 if (wordlist_mode == WL_MODE_FILE)
14867 {
14868 int wls_left = myargc - (optind + 1);
14869
14870 for (int i = 0; i < wls_left; i++)
14871 {
14872 char *l0_filename = myargv[optind + 1 + i];
14873
14874 struct stat l0_stat;
14875
14876 if (stat (l0_filename, &l0_stat) == -1)
14877 {
14878 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14879
14880 return (-1);
14881 }
14882
14883 uint is_dir = S_ISDIR (l0_stat.st_mode);
14884
14885 if (is_dir == 0)
14886 {
14887 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14888
14889 dictcnt++;
14890
14891 dictfiles[dictcnt - 1] = l0_filename;
14892 }
14893 else
14894 {
14895 // do not allow --keyspace w/ a directory
14896
14897 if (keyspace == 1)
14898 {
14899 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14900
14901 return (-1);
14902 }
14903
14904 char **dictionary_files = NULL;
14905
14906 dictionary_files = scan_directory (l0_filename);
14907
14908 if (dictionary_files != NULL)
14909 {
14910 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14911
14912 for (int d = 0; dictionary_files[d] != NULL; d++)
14913 {
14914 char *l1_filename = dictionary_files[d];
14915
14916 struct stat l1_stat;
14917
14918 if (stat (l1_filename, &l1_stat) == -1)
14919 {
14920 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14921
14922 return (-1);
14923 }
14924
14925 if (S_ISREG (l1_stat.st_mode))
14926 {
14927 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14928
14929 dictcnt++;
14930
14931 dictfiles[dictcnt - 1] = strdup (l1_filename);
14932 }
14933 }
14934 }
14935
14936 local_free (dictionary_files);
14937 }
14938 }
14939
14940 if (dictcnt < 1)
14941 {
14942 log_error ("ERROR: No usable dictionary file found.");
14943
14944 return (-1);
14945 }
14946 }
14947 else if (wordlist_mode == WL_MODE_STDIN)
14948 {
14949 dictcnt = 1;
14950 }
14951 }
14952 else if (attack_mode == ATTACK_MODE_COMBI)
14953 {
14954 // display
14955
14956 char *dictfile1 = myargv[optind + 1 + 0];
14957 char *dictfile2 = myargv[optind + 1 + 1];
14958
14959 // find the bigger dictionary and use as base
14960
14961 FILE *fp1 = NULL;
14962 FILE *fp2 = NULL;
14963
14964 struct stat tmp_stat;
14965
14966 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14967 {
14968 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14969
14970 return (-1);
14971 }
14972
14973 if (stat (dictfile1, &tmp_stat) == -1)
14974 {
14975 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14976
14977 fclose (fp1);
14978
14979 return (-1);
14980 }
14981
14982 if (S_ISDIR (tmp_stat.st_mode))
14983 {
14984 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14985
14986 fclose (fp1);
14987
14988 return (-1);
14989 }
14990
14991 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14992 {
14993 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14994
14995 fclose (fp1);
14996
14997 return (-1);
14998 }
14999
15000 if (stat (dictfile2, &tmp_stat) == -1)
15001 {
15002 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15003
15004 fclose (fp1);
15005 fclose (fp2);
15006
15007 return (-1);
15008 }
15009
15010 if (S_ISDIR (tmp_stat.st_mode))
15011 {
15012 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15013
15014 fclose (fp1);
15015 fclose (fp2);
15016
15017 return (-1);
15018 }
15019
15020 data.combs_cnt = 1;
15021
15022 data.quiet = 1;
15023
15024 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15025
15026 data.quiet = quiet;
15027
15028 if (words1_cnt == 0)
15029 {
15030 log_error ("ERROR: %s: empty file", dictfile1);
15031
15032 fclose (fp1);
15033 fclose (fp2);
15034
15035 return (-1);
15036 }
15037
15038 data.combs_cnt = 1;
15039
15040 data.quiet = 1;
15041
15042 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15043
15044 data.quiet = quiet;
15045
15046 if (words2_cnt == 0)
15047 {
15048 log_error ("ERROR: %s: empty file", dictfile2);
15049
15050 fclose (fp1);
15051 fclose (fp2);
15052
15053 return (-1);
15054 }
15055
15056 fclose (fp1);
15057 fclose (fp2);
15058
15059 data.dictfile = dictfile1;
15060 data.dictfile2 = dictfile2;
15061
15062 if (words1_cnt >= words2_cnt)
15063 {
15064 data.combs_cnt = words2_cnt;
15065 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15066
15067 dictfiles = &data.dictfile;
15068
15069 dictcnt = 1;
15070 }
15071 else
15072 {
15073 data.combs_cnt = words1_cnt;
15074 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15075
15076 dictfiles = &data.dictfile2;
15077
15078 dictcnt = 1;
15079
15080 // we also have to switch wordlist related rules!
15081
15082 char *tmpc = data.rule_buf_l;
15083
15084 data.rule_buf_l = data.rule_buf_r;
15085 data.rule_buf_r = tmpc;
15086
15087 int tmpi = data.rule_len_l;
15088
15089 data.rule_len_l = data.rule_len_r;
15090 data.rule_len_r = tmpi;
15091 }
15092 }
15093 else if (attack_mode == ATTACK_MODE_BF)
15094 {
15095 char *mask = NULL;
15096
15097 maskcnt = 0;
15098
15099 if (benchmark == 0)
15100 {
15101 mask = myargv[optind + 1];
15102
15103 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15104
15105 if ((optind + 2) <= myargc)
15106 {
15107 struct stat file_stat;
15108
15109 if (stat (mask, &file_stat) == -1)
15110 {
15111 maskcnt = 1;
15112
15113 masks[maskcnt - 1] = mystrdup (mask);
15114 }
15115 else
15116 {
15117 int wls_left = myargc - (optind + 1);
15118
15119 uint masks_avail = INCR_MASKS;
15120
15121 for (int i = 0; i < wls_left; i++)
15122 {
15123 if (i != 0)
15124 {
15125 mask = myargv[optind + 1 + i];
15126
15127 if (stat (mask, &file_stat) == -1)
15128 {
15129 log_error ("ERROR: %s: %s", mask, strerror (errno));
15130
15131 return (-1);
15132 }
15133 }
15134
15135 uint is_file = S_ISREG (file_stat.st_mode);
15136
15137 if (is_file == 1)
15138 {
15139 FILE *mask_fp;
15140
15141 if ((mask_fp = fopen (mask, "r")) == NULL)
15142 {
15143 log_error ("ERROR: %s: %s", mask, strerror (errno));
15144
15145 return (-1);
15146 }
15147
15148 char line_buf[BUFSIZ] = { 0 };
15149
15150 while (!feof (mask_fp))
15151 {
15152 memset (line_buf, 0, BUFSIZ);
15153
15154 int line_len = fgetl (mask_fp, line_buf);
15155
15156 if (line_len == 0) continue;
15157
15158 if (line_buf[0] == '#') continue;
15159
15160 if (masks_avail == maskcnt)
15161 {
15162 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15163
15164 masks_avail += INCR_MASKS;
15165 }
15166
15167 masks[maskcnt] = mystrdup (line_buf);
15168
15169 maskcnt++;
15170 }
15171
15172 fclose (mask_fp);
15173 }
15174 else
15175 {
15176 log_error ("ERROR: %s: unsupported file-type", mask);
15177
15178 return (-1);
15179 }
15180 }
15181
15182 mask_from_file = 1;
15183 }
15184 }
15185 else
15186 {
15187 custom_charset_1 = (char *) "?l?d?u";
15188 custom_charset_2 = (char *) "?l?d";
15189 custom_charset_3 = (char *) "?l?d*!$@_";
15190
15191 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15192 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15193 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15194
15195 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15196
15197 wordlist_mode = WL_MODE_MASK;
15198
15199 data.wordlist_mode = wordlist_mode;
15200
15201 increment = 1;
15202
15203 maskcnt = 1;
15204 }
15205 }
15206 else
15207 {
15208 /**
15209 * generate full masks and charsets
15210 */
15211
15212 masks = (char **) mymalloc (sizeof (char *));
15213
15214 switch (hash_mode)
15215 {
15216 case 1731: pw_min = 5;
15217 pw_max = 5;
15218 mask = mystrdup ("?b?b?b?b?b");
15219 break;
15220 case 12500: pw_min = 5;
15221 pw_max = 5;
15222 mask = mystrdup ("?b?b?b?b?b");
15223 break;
15224 default: pw_min = 7;
15225 pw_max = 7;
15226 mask = mystrdup ("?b?b?b?b?b?b?b");
15227 break;
15228 }
15229
15230 maskcnt = 1;
15231
15232 masks[maskcnt - 1] = mystrdup (mask);
15233
15234 wordlist_mode = WL_MODE_MASK;
15235
15236 data.wordlist_mode = wordlist_mode;
15237
15238 increment = 1;
15239 }
15240
15241 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15242
15243 if (increment)
15244 {
15245 if (increment_min > pw_min) pw_min = increment_min;
15246
15247 if (increment_max < pw_max) pw_max = increment_max;
15248 }
15249 }
15250 else if (attack_mode == ATTACK_MODE_HYBRID1)
15251 {
15252 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15253
15254 // display
15255
15256 char *mask = myargv[myargc - 1];
15257
15258 maskcnt = 0;
15259
15260 masks = (char **) mymalloc (1 * sizeof (char *));
15261
15262 // mod
15263
15264 struct stat file_stat;
15265
15266 if (stat (mask, &file_stat) == -1)
15267 {
15268 maskcnt = 1;
15269
15270 masks[maskcnt - 1] = mystrdup (mask);
15271 }
15272 else
15273 {
15274 uint is_file = S_ISREG (file_stat.st_mode);
15275
15276 if (is_file == 1)
15277 {
15278 FILE *mask_fp;
15279
15280 if ((mask_fp = fopen (mask, "r")) == NULL)
15281 {
15282 log_error ("ERROR: %s: %s", mask, strerror (errno));
15283
15284 return (-1);
15285 }
15286
15287 char line_buf[BUFSIZ] = { 0 };
15288
15289 uint masks_avail = 1;
15290
15291 while (!feof (mask_fp))
15292 {
15293 memset (line_buf, 0, BUFSIZ);
15294
15295 int line_len = fgetl (mask_fp, line_buf);
15296
15297 if (line_len == 0) continue;
15298
15299 if (line_buf[0] == '#') continue;
15300
15301 if (masks_avail == maskcnt)
15302 {
15303 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15304
15305 masks_avail += INCR_MASKS;
15306 }
15307
15308 masks[maskcnt] = mystrdup (line_buf);
15309
15310 maskcnt++;
15311 }
15312
15313 fclose (mask_fp);
15314
15315 mask_from_file = 1;
15316 }
15317 else
15318 {
15319 maskcnt = 1;
15320
15321 masks[maskcnt - 1] = mystrdup (mask);
15322 }
15323 }
15324
15325 // base
15326
15327 int wls_left = myargc - (optind + 2);
15328
15329 for (int i = 0; i < wls_left; i++)
15330 {
15331 char *filename = myargv[optind + 1 + i];
15332
15333 struct stat file_stat;
15334
15335 if (stat (filename, &file_stat) == -1)
15336 {
15337 log_error ("ERROR: %s: %s", filename, strerror (errno));
15338
15339 return (-1);
15340 }
15341
15342 uint is_dir = S_ISDIR (file_stat.st_mode);
15343
15344 if (is_dir == 0)
15345 {
15346 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15347
15348 dictcnt++;
15349
15350 dictfiles[dictcnt - 1] = filename;
15351 }
15352 else
15353 {
15354 // do not allow --keyspace w/ a directory
15355
15356 if (keyspace == 1)
15357 {
15358 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15359
15360 return (-1);
15361 }
15362
15363 char **dictionary_files = NULL;
15364
15365 dictionary_files = scan_directory (filename);
15366
15367 if (dictionary_files != NULL)
15368 {
15369 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15370
15371 for (int d = 0; dictionary_files[d] != NULL; d++)
15372 {
15373 char *l1_filename = dictionary_files[d];
15374
15375 struct stat l1_stat;
15376
15377 if (stat (l1_filename, &l1_stat) == -1)
15378 {
15379 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15380
15381 return (-1);
15382 }
15383
15384 if (S_ISREG (l1_stat.st_mode))
15385 {
15386 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15387
15388 dictcnt++;
15389
15390 dictfiles[dictcnt - 1] = strdup (l1_filename);
15391 }
15392 }
15393 }
15394
15395 local_free (dictionary_files);
15396 }
15397 }
15398
15399 if (dictcnt < 1)
15400 {
15401 log_error ("ERROR: No usable dictionary file found.");
15402
15403 return (-1);
15404 }
15405
15406 if (increment)
15407 {
15408 maskcnt = 0;
15409
15410 uint mask_min = increment_min; // we can't reject smaller masks here
15411 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15412
15413 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15414 {
15415 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15416
15417 if (cur_mask == NULL) break;
15418
15419 masks[maskcnt] = cur_mask;
15420
15421 maskcnt++;
15422
15423 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15424 }
15425 }
15426 }
15427 else if (attack_mode == ATTACK_MODE_HYBRID2)
15428 {
15429 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15430
15431 // display
15432
15433 char *mask = myargv[optind + 1 + 0];
15434
15435 maskcnt = 0;
15436
15437 masks = (char **) mymalloc (1 * sizeof (char *));
15438
15439 // mod
15440
15441 struct stat file_stat;
15442
15443 if (stat (mask, &file_stat) == -1)
15444 {
15445 maskcnt = 1;
15446
15447 masks[maskcnt - 1] = mystrdup (mask);
15448 }
15449 else
15450 {
15451 uint is_file = S_ISREG (file_stat.st_mode);
15452
15453 if (is_file == 1)
15454 {
15455 FILE *mask_fp;
15456
15457 if ((mask_fp = fopen (mask, "r")) == NULL)
15458 {
15459 log_error ("ERROR: %s: %s", mask, strerror (errno));
15460
15461 return (-1);
15462 }
15463
15464 char line_buf[BUFSIZ] = { 0 };
15465
15466 uint masks_avail = 1;
15467
15468 while (!feof (mask_fp))
15469 {
15470 memset (line_buf, 0, BUFSIZ);
15471
15472 int line_len = fgetl (mask_fp, line_buf);
15473
15474 if (line_len == 0) continue;
15475
15476 if (line_buf[0] == '#') continue;
15477
15478 if (masks_avail == maskcnt)
15479 {
15480 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15481
15482 masks_avail += INCR_MASKS;
15483 }
15484
15485 masks[maskcnt] = mystrdup (line_buf);
15486
15487 maskcnt++;
15488 }
15489
15490 fclose (mask_fp);
15491
15492 mask_from_file = 1;
15493 }
15494 else
15495 {
15496 maskcnt = 1;
15497
15498 masks[maskcnt - 1] = mystrdup (mask);
15499 }
15500 }
15501
15502 // base
15503
15504 int wls_left = myargc - (optind + 2);
15505
15506 for (int i = 0; i < wls_left; i++)
15507 {
15508 char *filename = myargv[optind + 2 + i];
15509
15510 struct stat file_stat;
15511
15512 if (stat (filename, &file_stat) == -1)
15513 {
15514 log_error ("ERROR: %s: %s", filename, strerror (errno));
15515
15516 return (-1);
15517 }
15518
15519 uint is_dir = S_ISDIR (file_stat.st_mode);
15520
15521 if (is_dir == 0)
15522 {
15523 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15524
15525 dictcnt++;
15526
15527 dictfiles[dictcnt - 1] = filename;
15528 }
15529 else
15530 {
15531 // do not allow --keyspace w/ a directory
15532
15533 if (keyspace == 1)
15534 {
15535 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15536
15537 return (-1);
15538 }
15539
15540 char **dictionary_files = NULL;
15541
15542 dictionary_files = scan_directory (filename);
15543
15544 if (dictionary_files != NULL)
15545 {
15546 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15547
15548 for (int d = 0; dictionary_files[d] != NULL; d++)
15549 {
15550 char *l1_filename = dictionary_files[d];
15551
15552 struct stat l1_stat;
15553
15554 if (stat (l1_filename, &l1_stat) == -1)
15555 {
15556 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15557
15558 return (-1);
15559 }
15560
15561 if (S_ISREG (l1_stat.st_mode))
15562 {
15563 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15564
15565 dictcnt++;
15566
15567 dictfiles[dictcnt - 1] = strdup (l1_filename);
15568 }
15569 }
15570 }
15571
15572 local_free (dictionary_files);
15573 }
15574 }
15575
15576 if (dictcnt < 1)
15577 {
15578 log_error ("ERROR: No usable dictionary file found.");
15579
15580 return (-1);
15581 }
15582
15583 if (increment)
15584 {
15585 maskcnt = 0;
15586
15587 uint mask_min = increment_min; // we can't reject smaller masks here
15588 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15589
15590 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15591 {
15592 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15593
15594 if (cur_mask == NULL) break;
15595
15596 masks[maskcnt] = cur_mask;
15597
15598 maskcnt++;
15599
15600 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15601 }
15602 }
15603 }
15604
15605 data.pw_min = pw_min;
15606 data.pw_max = pw_max;
15607
15608 /**
15609 * weak hash check
15610 */
15611
15612 if (weak_hash_threshold >= salts_cnt)
15613 {
15614 hc_device_param_t *device_param = NULL;
15615
15616 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15617 {
15618 device_param = &data.devices_param[device_id];
15619
15620 if (device_param->skipped) continue;
15621
15622 break;
15623 }
15624
15625 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15626
15627 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15628 {
15629 weak_hash_check (device_param, salt_pos);
15630 }
15631 }
15632
15633 // Display hack, guarantee that there is at least one \r before real start
15634
15635 if (data.quiet == 0) log_info_nn ("");
15636
15637 /**
15638 * status and monitor threads
15639 */
15640
15641 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15642
15643 hc_thread_t i_thread = 0;
15644
15645 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15646 {
15647 hc_thread_create (i_thread, thread_keypress, &benchmark);
15648 }
15649
15650 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15651
15652 uint ni_threads_cnt = 0;
15653
15654 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15655
15656 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15657
15658 ni_threads_cnt++;
15659
15660 /**
15661 * Outfile remove
15662 */
15663
15664 if (keyspace == 0)
15665 {
15666 if (outfile_check_timer != 0)
15667 {
15668 if (data.outfile_check_directory != NULL)
15669 {
15670 if ((hash_mode != 5200) &&
15671 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15672 (hash_mode != 9000))
15673 {
15674 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15675
15676 ni_threads_cnt++;
15677 }
15678 else
15679 {
15680 outfile_check_timer = 0;
15681 }
15682 }
15683 else
15684 {
15685 outfile_check_timer = 0;
15686 }
15687 }
15688 }
15689
15690 /**
15691 * Inform the user if we got some hashes remove because of the pot file remove feature
15692 */
15693
15694 if (data.quiet == 0)
15695 {
15696 if (potfile_remove_cracks > 0)
15697 {
15698 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15699 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15700 }
15701 }
15702
15703 data.outfile_check_timer = outfile_check_timer;
15704
15705 /**
15706 * main loop
15707 */
15708
15709 char **induction_dictionaries = NULL;
15710
15711 int induction_dictionaries_cnt = 0;
15712
15713 hcstat_table_t *root_table_buf = NULL;
15714 hcstat_table_t *markov_table_buf = NULL;
15715
15716 uint initial_restore_done = 0;
15717
15718 data.maskcnt = maskcnt;
15719
15720 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15721 {
15722 if (data.devices_status == STATUS_CRACKED) break;
15723
15724 data.devices_status = STATUS_INIT;
15725
15726 if (maskpos > rd->maskpos)
15727 {
15728 rd->dictpos = 0;
15729 }
15730
15731 rd->maskpos = maskpos;
15732 data.maskpos = maskpos;
15733
15734 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15735 {
15736 char *mask = masks[maskpos];
15737
15738 if (mask_from_file == 1)
15739 {
15740 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15741
15742 char *str_ptr;
15743 uint str_pos;
15744
15745 uint mask_offset = 0;
15746
15747 uint separator_cnt;
15748
15749 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15750 {
15751 str_ptr = strstr (mask + mask_offset, ",");
15752
15753 if (str_ptr == NULL) break;
15754
15755 str_pos = str_ptr - mask;
15756
15757 // escaped separator, i.e. "\,"
15758
15759 if (str_pos > 0)
15760 {
15761 if (mask[str_pos - 1] == '\\')
15762 {
15763 separator_cnt --;
15764
15765 mask_offset = str_pos + 1;
15766
15767 continue;
15768 }
15769 }
15770
15771 // reset the offset
15772
15773 mask_offset = 0;
15774
15775 mask[str_pos] = '\0';
15776
15777 switch (separator_cnt)
15778 {
15779 case 0:
15780 mp_reset_usr (mp_usr, 0);
15781
15782 custom_charset_1 = mask;
15783 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15784 break;
15785
15786 case 1:
15787 mp_reset_usr (mp_usr, 1);
15788
15789 custom_charset_2 = mask;
15790 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15791 break;
15792
15793 case 2:
15794 mp_reset_usr (mp_usr, 2);
15795
15796 custom_charset_3 = mask;
15797 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15798 break;
15799
15800 case 3:
15801 mp_reset_usr (mp_usr, 3);
15802
15803 custom_charset_4 = mask;
15804 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15805 break;
15806 }
15807
15808 mask = mask + str_pos + 1;
15809 }
15810 }
15811
15812 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15813 {
15814 if (maskpos > 0)
15815 {
15816 local_free (css_buf);
15817 local_free (data.root_css_buf);
15818 local_free (data.markov_css_buf);
15819
15820 local_free (masks[maskpos - 1]);
15821 }
15822
15823 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15824
15825 data.mask = mask;
15826 data.css_cnt = css_cnt;
15827 data.css_buf = css_buf;
15828
15829 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15830
15831 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15832
15833 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15834 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15835
15836 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15837
15838 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15839
15840 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15841 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15842
15843 data.root_css_buf = root_css_buf;
15844 data.markov_css_buf = markov_css_buf;
15845
15846 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15847
15848 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15849
15850 local_free (root_table_buf);
15851 local_free (markov_table_buf);
15852
15853 // args
15854
15855 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15856 {
15857 hc_device_param_t *device_param = &data.devices_param[device_id];
15858
15859 if (device_param->skipped) continue;
15860
15861 device_param->kernel_params_mp[0] = &device_param->d_combs;
15862 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15863 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15864
15865 device_param->kernel_params_mp_buf64[3] = 0;
15866 device_param->kernel_params_mp_buf32[4] = css_cnt;
15867 device_param->kernel_params_mp_buf32[5] = 0;
15868 device_param->kernel_params_mp_buf32[6] = 0;
15869 device_param->kernel_params_mp_buf32[7] = 0;
15870
15871 if (attack_mode == ATTACK_MODE_HYBRID1)
15872 {
15873 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15874 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15875 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15876 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15877 }
15878 else if (attack_mode == ATTACK_MODE_HYBRID2)
15879 {
15880 device_param->kernel_params_mp_buf32[5] = 0;
15881 device_param->kernel_params_mp_buf32[6] = 0;
15882 device_param->kernel_params_mp_buf32[7] = 0;
15883 }
15884
15885 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]);
15886 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]);
15887 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]);
15888
15889 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);
15890 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);
15891 }
15892 }
15893 else if (attack_mode == ATTACK_MODE_BF)
15894 {
15895 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15896
15897 if (increment)
15898 {
15899 for (uint i = 0; i < dictcnt; i++)
15900 {
15901 local_free (dictfiles[i]);
15902 }
15903
15904 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15905 {
15906 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15907
15908 if (l1_filename == NULL) break;
15909
15910 dictcnt++;
15911
15912 dictfiles[dictcnt - 1] = l1_filename;
15913 }
15914 }
15915 else
15916 {
15917 dictcnt++;
15918
15919 dictfiles[dictcnt - 1] = mask;
15920 }
15921
15922 if (dictcnt == 0)
15923 {
15924 log_error ("ERROR: Mask is too small");
15925
15926 return (-1);
15927 }
15928 }
15929 }
15930
15931 free (induction_dictionaries);
15932
15933 // induction_dictionaries_cnt = 0; // implied
15934
15935 if (attack_mode != ATTACK_MODE_BF)
15936 {
15937 if (keyspace == 0)
15938 {
15939 induction_dictionaries = scan_directory (induction_directory);
15940
15941 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15942 }
15943 }
15944
15945 if (induction_dictionaries_cnt)
15946 {
15947 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15948 }
15949
15950 /**
15951 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15952 */
15953 if (keyspace == 1)
15954 {
15955 if ((maskcnt > 1) || (dictcnt > 1))
15956 {
15957 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15958
15959 return (-1);
15960 }
15961 }
15962
15963 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15964 {
15965 char *subid = logfile_generate_subid ();
15966
15967 data.subid = subid;
15968
15969 logfile_sub_msg ("START");
15970
15971 data.devices_status = STATUS_INIT;
15972
15973 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15974 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15975 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15976
15977 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15978
15979 data.cpt_pos = 0;
15980
15981 data.cpt_start = time (NULL);
15982
15983 data.cpt_total = 0;
15984
15985 if (data.restore == 0)
15986 {
15987 rd->words_cur = skip;
15988
15989 skip = 0;
15990
15991 data.skip = 0;
15992 }
15993
15994 data.ms_paused = 0;
15995
15996 data.words_cur = rd->words_cur;
15997
15998 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15999 {
16000 hc_device_param_t *device_param = &data.devices_param[device_id];
16001
16002 if (device_param->skipped) continue;
16003
16004 device_param->speed_pos = 0;
16005
16006 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16007 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
16008 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
16009
16010 device_param->exec_pos = 0;
16011
16012 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16013
16014 device_param->kernel_power = device_param->kernel_power_user;
16015
16016 device_param->outerloop_pos = 0;
16017 device_param->outerloop_left = 0;
16018 device_param->innerloop_pos = 0;
16019 device_param->innerloop_left = 0;
16020
16021 // some more resets:
16022
16023 if (device_param->pw_caches) memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
16024
16025 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16026
16027 device_param->pw_cnt = 0;
16028 device_param->pws_cnt = 0;
16029
16030 device_param->words_off = 0;
16031 device_param->words_done = 0;
16032 }
16033
16034 data.kernel_power_div = 0;
16035
16036 // figure out some workload
16037
16038 if (attack_mode == ATTACK_MODE_STRAIGHT)
16039 {
16040 if (data.wordlist_mode == WL_MODE_FILE)
16041 {
16042 char *dictfile = NULL;
16043
16044 if (induction_dictionaries_cnt)
16045 {
16046 dictfile = induction_dictionaries[0];
16047 }
16048 else
16049 {
16050 dictfile = dictfiles[dictpos];
16051 }
16052
16053 data.dictfile = dictfile;
16054
16055 logfile_sub_string (dictfile);
16056
16057 for (uint i = 0; i < rp_files_cnt; i++)
16058 {
16059 logfile_sub_var_string ("rulefile", rp_files[i]);
16060 }
16061
16062 FILE *fd2 = fopen (dictfile, "rb");
16063
16064 if (fd2 == NULL)
16065 {
16066 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16067
16068 return (-1);
16069 }
16070
16071 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16072
16073 fclose (fd2);
16074
16075 if (data.words_cnt == 0)
16076 {
16077 if (data.devices_status == STATUS_CRACKED) break;
16078 if (data.devices_status == STATUS_ABORTED) break;
16079
16080 dictpos++;
16081
16082 continue;
16083 }
16084 }
16085 }
16086 else if (attack_mode == ATTACK_MODE_COMBI)
16087 {
16088 char *dictfile = data.dictfile;
16089 char *dictfile2 = data.dictfile2;
16090
16091 logfile_sub_string (dictfile);
16092 logfile_sub_string (dictfile2);
16093
16094 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16095 {
16096 FILE *fd2 = fopen (dictfile, "rb");
16097
16098 if (fd2 == NULL)
16099 {
16100 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16101
16102 return (-1);
16103 }
16104
16105 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16106
16107 fclose (fd2);
16108 }
16109 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16110 {
16111 FILE *fd2 = fopen (dictfile2, "rb");
16112
16113 if (fd2 == NULL)
16114 {
16115 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16116
16117 return (-1);
16118 }
16119
16120 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16121
16122 fclose (fd2);
16123 }
16124
16125 if (data.words_cnt == 0)
16126 {
16127 if (data.devices_status == STATUS_CRACKED) break;
16128 if (data.devices_status == STATUS_ABORTED) break;
16129
16130 dictpos++;
16131
16132 continue;
16133 }
16134 }
16135 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16136 {
16137 char *dictfile = NULL;
16138
16139 if (induction_dictionaries_cnt)
16140 {
16141 dictfile = induction_dictionaries[0];
16142 }
16143 else
16144 {
16145 dictfile = dictfiles[dictpos];
16146 }
16147
16148 data.dictfile = dictfile;
16149
16150 char *mask = data.mask;
16151
16152 logfile_sub_string (dictfile);
16153 logfile_sub_string (mask);
16154
16155 FILE *fd2 = fopen (dictfile, "rb");
16156
16157 if (fd2 == NULL)
16158 {
16159 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16160
16161 return (-1);
16162 }
16163
16164 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16165
16166 fclose (fd2);
16167
16168 if (data.words_cnt == 0)
16169 {
16170 if (data.devices_status == STATUS_CRACKED) break;
16171 if (data.devices_status == STATUS_ABORTED) break;
16172
16173 dictpos++;
16174
16175 continue;
16176 }
16177 }
16178 else if (attack_mode == ATTACK_MODE_BF)
16179 {
16180 local_free (css_buf);
16181 local_free (data.root_css_buf);
16182 local_free (data.markov_css_buf);
16183
16184 char *mask = dictfiles[dictpos];
16185
16186 logfile_sub_string (mask);
16187
16188 // base
16189
16190 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16191
16192 if (opts_type & OPTS_TYPE_PT_UNICODE)
16193 {
16194 uint css_cnt_unicode = css_cnt * 2;
16195
16196 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16197
16198 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16199 {
16200 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16201
16202 css_buf_unicode[j + 1].cs_buf[0] = 0;
16203 css_buf_unicode[j + 1].cs_len = 1;
16204 }
16205
16206 free (css_buf);
16207
16208 css_buf = css_buf_unicode;
16209 css_cnt = css_cnt_unicode;
16210 }
16211
16212 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16213
16214 uint mask_min = pw_min;
16215 uint mask_max = pw_max;
16216
16217 if (opts_type & OPTS_TYPE_PT_UNICODE)
16218 {
16219 mask_min *= 2;
16220 mask_max *= 2;
16221 }
16222
16223 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16224 {
16225 if (css_cnt < mask_min)
16226 {
16227 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16228 }
16229
16230 if (css_cnt > mask_max)
16231 {
16232 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16233 }
16234
16235 // skip to next mask
16236
16237 dictpos++;
16238
16239 rd->dictpos = dictpos;
16240
16241 logfile_sub_msg ("STOP");
16242
16243 continue;
16244 }
16245
16246 uint save_css_cnt = css_cnt;
16247
16248 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16249 {
16250 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16251 {
16252 uint salt_len = (uint) data.salts_buf[0].salt_len;
16253 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16254
16255 uint css_cnt_salt = css_cnt + salt_len;
16256
16257 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16258
16259 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16260
16261 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16262 {
16263 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16264 css_buf_salt[j].cs_len = 1;
16265 }
16266
16267 free (css_buf);
16268
16269 css_buf = css_buf_salt;
16270 css_cnt = css_cnt_salt;
16271 }
16272 }
16273
16274 data.mask = mask;
16275 data.css_cnt = css_cnt;
16276 data.css_buf = css_buf;
16277
16278 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16279
16280 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16281
16282 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16283
16284 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16285 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16286
16287 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16288
16289 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16290
16291 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16292 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16293
16294 data.root_css_buf = root_css_buf;
16295 data.markov_css_buf = markov_css_buf;
16296
16297 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16298
16299 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16300
16301 local_free (root_table_buf);
16302 local_free (markov_table_buf);
16303
16304 // copy + args
16305
16306 uint css_cnt_l = css_cnt;
16307 uint css_cnt_r;
16308
16309 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16310 {
16311 if (save_css_cnt < 6)
16312 {
16313 css_cnt_r = 1;
16314 }
16315 else if (save_css_cnt == 6)
16316 {
16317 css_cnt_r = 2;
16318 }
16319 else
16320 {
16321 if (opts_type & OPTS_TYPE_PT_UNICODE)
16322 {
16323 if (save_css_cnt == 8 || save_css_cnt == 10)
16324 {
16325 css_cnt_r = 2;
16326 }
16327 else
16328 {
16329 css_cnt_r = 4;
16330 }
16331 }
16332 else
16333 {
16334 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16335 {
16336 css_cnt_r = 3;
16337 }
16338 else
16339 {
16340 css_cnt_r = 4;
16341 }
16342 }
16343 }
16344 }
16345 else
16346 {
16347 css_cnt_r = 1;
16348
16349 /* unfinished code?
16350 int sum = css_buf[css_cnt_r - 1].cs_len;
16351
16352 for (uint i = 1; i < 4 && i < css_cnt; i++)
16353 {
16354 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16355
16356 css_cnt_r++;
16357
16358 sum *= css_buf[css_cnt_r - 1].cs_len;
16359 }
16360 */
16361 }
16362
16363 css_cnt_l -= css_cnt_r;
16364
16365 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16366
16367 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16368 {
16369 hc_device_param_t *device_param = &data.devices_param[device_id];
16370
16371 if (device_param->skipped) continue;
16372
16373 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16374 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16375 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16376
16377 device_param->kernel_params_mp_l_buf64[3] = 0;
16378 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16379 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16380 device_param->kernel_params_mp_l_buf32[6] = 0;
16381 device_param->kernel_params_mp_l_buf32[7] = 0;
16382 device_param->kernel_params_mp_l_buf32[8] = 0;
16383
16384 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16385 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16386 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16387 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16388
16389 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16390 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16391 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16392
16393 device_param->kernel_params_mp_r_buf64[3] = 0;
16394 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16395 device_param->kernel_params_mp_r_buf32[5] = 0;
16396 device_param->kernel_params_mp_r_buf32[6] = 0;
16397 device_param->kernel_params_mp_r_buf32[7] = 0;
16398
16399 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]);
16400 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]);
16401 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]);
16402
16403 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]);
16404 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]);
16405 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]);
16406
16407 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);
16408 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);
16409 }
16410 }
16411
16412 u64 words_base = data.words_cnt;
16413
16414 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16415 {
16416 if (data.kernel_rules_cnt)
16417 {
16418 words_base /= data.kernel_rules_cnt;
16419 }
16420 }
16421 else if (data.attack_kern == ATTACK_KERN_COMBI)
16422 {
16423 if (data.combs_cnt)
16424 {
16425 words_base /= data.combs_cnt;
16426 }
16427 }
16428 else if (data.attack_kern == ATTACK_KERN_BF)
16429 {
16430 if (data.bfs_cnt)
16431 {
16432 words_base /= data.bfs_cnt;
16433 }
16434 }
16435
16436 data.words_base = words_base;
16437
16438 if (keyspace == 1)
16439 {
16440 log_info ("%llu", (unsigned long long int) words_base);
16441
16442 return (0);
16443 }
16444
16445 if (data.words_cur > data.words_base)
16446 {
16447 log_error ("ERROR: restore value greater keyspace");
16448
16449 return (-1);
16450 }
16451
16452 if (data.words_cur)
16453 {
16454 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16455 {
16456 for (uint i = 0; i < data.salts_cnt; i++)
16457 {
16458 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16459 }
16460 }
16461 else if (data.attack_kern == ATTACK_KERN_COMBI)
16462 {
16463 for (uint i = 0; i < data.salts_cnt; i++)
16464 {
16465 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16466 }
16467 }
16468 else if (data.attack_kern == ATTACK_KERN_BF)
16469 {
16470 for (uint i = 0; i < data.salts_cnt; i++)
16471 {
16472 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16473 }
16474 }
16475 }
16476
16477 /*
16478 * Inform user about possible slow speeds
16479 */
16480
16481 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16482 {
16483 if (data.words_base < kernel_power_all)
16484 {
16485 if (quiet == 0)
16486 {
16487 log_info ("");
16488 log_info ("ATTENTION!");
16489 log_info (" The wordlist or mask you are using is too small.");
16490 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16491 log_info (" The cracking speed will drop.");
16492 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16493 log_info ("");
16494 }
16495 }
16496 }
16497
16498 /*
16499 * Update loopback file
16500 */
16501
16502 if (loopback == 1)
16503 {
16504 time_t now;
16505
16506 time (&now);
16507
16508 uint random_num = get_random_num (0, 9999);
16509
16510 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16511
16512 data.loopback_file = loopback_file;
16513 }
16514
16515 /*
16516 * Update dictionary statistic
16517 */
16518
16519 if (keyspace == 0)
16520 {
16521 dictstat_fp = fopen (dictstat, "wb");
16522
16523 if (dictstat_fp)
16524 {
16525 lock_file (dictstat_fp);
16526
16527 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16528
16529 fclose (dictstat_fp);
16530 }
16531 }
16532
16533 data.devices_status = STATUS_RUNNING;
16534
16535 if (initial_restore_done == 0)
16536 {
16537 if (data.restore_disable == 0) cycle_restore ();
16538
16539 initial_restore_done = 1;
16540 }
16541
16542 hc_timer_set (&data.timer_running);
16543
16544 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16545 {
16546 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16547 {
16548 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16549 if (quiet == 0) fflush (stdout);
16550 }
16551 }
16552 else if (wordlist_mode == WL_MODE_STDIN)
16553 {
16554 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16555 if (data.quiet == 0) log_info ("");
16556 }
16557
16558 time_t runtime_start;
16559
16560 time (&runtime_start);
16561
16562 data.runtime_start = runtime_start;
16563
16564 /**
16565 * create cracker threads
16566 */
16567
16568 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16569
16570 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16571 {
16572 hc_device_param_t *device_param = &devices_param[device_id];
16573
16574 if (wordlist_mode == WL_MODE_STDIN)
16575 {
16576 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16577 }
16578 else
16579 {
16580 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16581 }
16582 }
16583
16584 // wait for crack threads to exit
16585
16586 hc_thread_wait (data.devices_cnt, c_threads);
16587
16588 local_free (c_threads);
16589
16590 data.restore = 0;
16591
16592 // finalize task
16593
16594 logfile_sub_var_uint ("status-after-work", data.devices_status);
16595
16596 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16597
16598 if (data.devices_status == STATUS_CRACKED) break;
16599 if (data.devices_status == STATUS_ABORTED) break;
16600
16601 if (data.devices_status == STATUS_BYPASS)
16602 {
16603 data.devices_status = STATUS_RUNNING;
16604 }
16605
16606 if (induction_dictionaries_cnt)
16607 {
16608 unlink (induction_dictionaries[0]);
16609 }
16610
16611 free (induction_dictionaries);
16612
16613 if (attack_mode != ATTACK_MODE_BF)
16614 {
16615 induction_dictionaries = scan_directory (induction_directory);
16616
16617 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16618 }
16619
16620 if (benchmark == 0)
16621 {
16622 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16623 {
16624 if (quiet == 0) clear_prompt ();
16625
16626 if (quiet == 0) log_info ("");
16627
16628 if (status == 1)
16629 {
16630 status_display ();
16631 }
16632 else
16633 {
16634 if (quiet == 0) status_display ();
16635 }
16636
16637 if (quiet == 0) log_info ("");
16638 }
16639 }
16640
16641 if (attack_mode == ATTACK_MODE_BF)
16642 {
16643 dictpos++;
16644
16645 rd->dictpos = dictpos;
16646 }
16647 else
16648 {
16649 if (induction_dictionaries_cnt)
16650 {
16651 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16652 }
16653 else
16654 {
16655 dictpos++;
16656
16657 rd->dictpos = dictpos;
16658 }
16659 }
16660
16661 time_t runtime_stop;
16662
16663 time (&runtime_stop);
16664
16665 data.runtime_stop = runtime_stop;
16666
16667 logfile_sub_uint (runtime_start);
16668 logfile_sub_uint (runtime_stop);
16669
16670 logfile_sub_msg ("STOP");
16671
16672 global_free (subid);
16673 }
16674
16675 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16676
16677 if (data.devices_status == STATUS_CRACKED) break;
16678 if (data.devices_status == STATUS_ABORTED) break;
16679 if (data.devices_status == STATUS_QUIT) break;
16680
16681 if (data.devices_status == STATUS_BYPASS)
16682 {
16683 data.devices_status = STATUS_RUNNING;
16684 }
16685 }
16686
16687 // 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
16688
16689 if (attack_mode == ATTACK_MODE_STRAIGHT)
16690 {
16691 if (data.wordlist_mode == WL_MODE_FILE)
16692 {
16693 if (data.dictfile == NULL)
16694 {
16695 if (dictfiles != NULL)
16696 {
16697 data.dictfile = dictfiles[0];
16698
16699 hc_timer_set (&data.timer_running);
16700 }
16701 }
16702 }
16703 }
16704 // NOTE: combi is okay because it is already set beforehand
16705 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16706 {
16707 if (data.dictfile == NULL)
16708 {
16709 if (dictfiles != NULL)
16710 {
16711 hc_timer_set (&data.timer_running);
16712
16713 data.dictfile = dictfiles[0];
16714 }
16715 }
16716 }
16717 else if (attack_mode == ATTACK_MODE_BF)
16718 {
16719 if (data.mask == NULL)
16720 {
16721 hc_timer_set (&data.timer_running);
16722
16723 data.mask = masks[0];
16724 }
16725 }
16726
16727 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16728 {
16729 data.devices_status = STATUS_EXHAUSTED;
16730 }
16731
16732 // if cracked / aborted remove last induction dictionary
16733
16734 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16735 {
16736 struct stat induct_stat;
16737
16738 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16739 {
16740 unlink (induction_dictionaries[file_pos]);
16741 }
16742 }
16743
16744 // wait for non-interactive threads
16745
16746 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16747 {
16748 hc_thread_wait (1, &ni_threads[thread_idx]);
16749 }
16750
16751 local_free (ni_threads);
16752
16753 // wait for interactive threads
16754
16755 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16756 {
16757 hc_thread_wait (1, &i_thread);
16758 }
16759
16760 // we dont need restore file anymore
16761 if (data.restore_disable == 0)
16762 {
16763 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16764 {
16765 unlink (eff_restore_file);
16766 unlink (new_restore_file);
16767 }
16768 else
16769 {
16770 cycle_restore ();
16771 }
16772 }
16773
16774 // finally save left hashes
16775
16776 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16777 {
16778 save_hash ();
16779 }
16780
16781 /**
16782 * Clean up
16783 */
16784
16785 if (benchmark == 1)
16786 {
16787 status_benchmark ();
16788
16789 log_info ("");
16790 }
16791 else
16792 {
16793 if (quiet == 0) clear_prompt ();
16794
16795 if (quiet == 0) log_info ("");
16796
16797 if (status == 1)
16798 {
16799 status_display ();
16800 }
16801 else
16802 {
16803 if (quiet == 0) status_display ();
16804 }
16805
16806 if (quiet == 0) log_info ("");
16807 }
16808
16809 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16810 {
16811 hc_device_param_t *device_param = &data.devices_param[device_id];
16812
16813 if (device_param->skipped) continue;
16814
16815 local_free (device_param->result);
16816
16817 local_free (device_param->pw_caches);
16818
16819 local_free (device_param->combs_buf);
16820
16821 local_free (device_param->hooks_buf);
16822
16823 local_free (device_param->device_name);
16824
16825 local_free (device_param->device_name_chksum);
16826
16827 local_free (device_param->device_version);
16828
16829 local_free (device_param->driver_version);
16830
16831 if (device_param->pws_buf) myfree (device_param->pws_buf);
16832 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16833 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16834 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16835 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16836 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16837 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16838 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16839 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16840 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16841 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16842 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16843 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16844 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16845 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16846 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16847 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16848 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16849 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16850 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16851 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16852 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16853 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16854 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16855 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16856 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16857 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16858 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16859 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16860
16861 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16862 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16863 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16864 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16865 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16866 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16867 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16868 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16869 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16870 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16871 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16872
16873 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16874 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16875 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16876
16877 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16878 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16879 }
16880
16881 // reset default fan speed
16882
16883 #ifdef HAVE_HWMON
16884 if (gpu_temp_disable == 0)
16885 {
16886 #ifdef HAVE_ADL
16887 if (gpu_temp_retain != 0) // 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].fan_supported == 1)
16898 {
16899 int fanspeed = temp_retain_fanspeed_value[device_id];
16900
16901 if (fanspeed == -1) continue;
16902
16903 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16904
16905 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16906 }
16907 }
16908
16909 hc_thread_mutex_unlock (mux_adl);
16910 }
16911 #endif // HAVE_ADL
16912 }
16913
16914 #ifdef HAVE_ADL
16915 // reset power tuning
16916
16917 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16918 {
16919 hc_thread_mutex_lock (mux_adl);
16920
16921 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16922 {
16923 hc_device_param_t *device_param = &data.devices_param[device_id];
16924
16925 if (device_param->skipped) continue;
16926
16927 if (data.hm_device[device_id].od_version == 6)
16928 {
16929 // check powertune capabilities first, if not available then skip device
16930
16931 int powertune_supported = 0;
16932
16933 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16934 {
16935 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16936
16937 return (-1);
16938 }
16939
16940 if (powertune_supported != 0)
16941 {
16942 // powercontrol settings
16943
16944 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)
16945 {
16946 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16947
16948 return (-1);
16949 }
16950
16951 // clocks
16952
16953 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16954
16955 performance_state->iNumberOfPerformanceLevels = 2;
16956
16957 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16958 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16959 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16960 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16961
16962 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)
16963 {
16964 log_info ("ERROR: Failed to restore ADL performance state");
16965
16966 return (-1);
16967 }
16968
16969 local_free (performance_state);
16970 }
16971 }
16972 }
16973
16974 hc_thread_mutex_unlock (mux_adl);
16975 }
16976 #endif // HAVE_ADL
16977
16978 if (gpu_temp_disable == 0)
16979 {
16980 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16981 if (data.hm_nv)
16982 {
16983 #if defined(LINUX) && defined(HAVE_NVML)
16984
16985 hm_NVML_nvmlShutdown (data.hm_nv);
16986
16987 nvml_close (data.hm_nv);
16988
16989 #elif defined(WIN) && (HAVE_NVAPI)
16990
16991 hm_NvAPI_Unload (data.hm_nv);
16992
16993 nvapi_close (data.hm_nv);
16994
16995 #endif
16996
16997 data.hm_nv = NULL;
16998 }
16999 #endif
17000
17001 #ifdef HAVE_ADL
17002 if (data.hm_amd)
17003 {
17004 hm_ADL_Main_Control_Destroy (data.hm_amd);
17005
17006 adl_close (data.hm_amd);
17007 data.hm_amd = NULL;
17008 }
17009 #endif
17010 }
17011 #endif // HAVE_HWMON
17012
17013 // free memory
17014
17015 local_free (masks);
17016
17017 local_free (dictstat_base);
17018
17019 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17020 {
17021 pot_t *pot_ptr = &pot[pot_pos];
17022
17023 hash_t *hash = &pot_ptr->hash;
17024
17025 local_free (hash->digest);
17026
17027 if (isSalted)
17028 {
17029 local_free (hash->salt);
17030 }
17031 }
17032
17033 local_free (pot);
17034
17035 local_free (all_kernel_rules_cnt);
17036 local_free (all_kernel_rules_buf);
17037
17038 local_free (wl_data->buf);
17039 local_free (wl_data);
17040
17041 local_free (bitmap_s1_a);
17042 local_free (bitmap_s1_b);
17043 local_free (bitmap_s1_c);
17044 local_free (bitmap_s1_d);
17045 local_free (bitmap_s2_a);
17046 local_free (bitmap_s2_b);
17047 local_free (bitmap_s2_c);
17048 local_free (bitmap_s2_d);
17049
17050 #ifdef HAVE_HWMON
17051 local_free (temp_retain_fanspeed_value);
17052 #ifdef HAVE_ADL
17053 local_free (od_clock_mem_status);
17054 local_free (od_power_control_status);
17055 #endif // ADL
17056 #endif
17057
17058 global_free (devices_param);
17059
17060 global_free (kernel_rules_buf);
17061
17062 global_free (root_css_buf);
17063 global_free (markov_css_buf);
17064
17065 global_free (digests_buf);
17066 global_free (digests_shown);
17067 global_free (digests_shown_tmp);
17068
17069 global_free (salts_buf);
17070 global_free (salts_shown);
17071
17072 global_free (esalts_buf);
17073
17074 global_free (words_progress_done);
17075 global_free (words_progress_rejected);
17076 global_free (words_progress_restored);
17077
17078 if (pot_fp) fclose (pot_fp);
17079
17080 if (data.devices_status == STATUS_QUIT) break;
17081 }
17082
17083 // destroy others mutex
17084
17085 hc_thread_mutex_delete (mux_dispatcher);
17086 hc_thread_mutex_delete (mux_counter);
17087 hc_thread_mutex_delete (mux_display);
17088 hc_thread_mutex_delete (mux_adl);
17089
17090 // free memory
17091
17092 local_free (eff_restore_file);
17093 local_free (new_restore_file);
17094
17095 local_free (rd);
17096
17097 // tuning db
17098
17099 tuning_db_destroy (tuning_db);
17100
17101 // loopback
17102
17103 local_free (loopback_file);
17104
17105 if (loopback == 1) unlink (loopback_file);
17106
17107 // induction directory
17108
17109 if (induction_dir == NULL)
17110 {
17111 if (attack_mode != ATTACK_MODE_BF)
17112 {
17113 if (rmdir (induction_directory) == -1)
17114 {
17115 if (errno == ENOENT)
17116 {
17117 // good, we can ignore
17118 }
17119 else if (errno == ENOTEMPTY)
17120 {
17121 // good, we can ignore
17122 }
17123 else
17124 {
17125 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17126
17127 return (-1);
17128 }
17129 }
17130
17131 local_free (induction_directory);
17132 }
17133 }
17134
17135 // outfile-check directory
17136
17137 if (outfile_check_dir == NULL)
17138 {
17139 if (rmdir (outfile_check_directory) == -1)
17140 {
17141 if (errno == ENOENT)
17142 {
17143 // good, we can ignore
17144 }
17145 else if (errno == ENOTEMPTY)
17146 {
17147 // good, we can ignore
17148 }
17149 else
17150 {
17151 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17152
17153 return (-1);
17154 }
17155 }
17156
17157 local_free (outfile_check_directory);
17158 }
17159
17160 time_t proc_stop;
17161
17162 time (&proc_stop);
17163
17164 logfile_top_uint (proc_start);
17165 logfile_top_uint (proc_stop);
17166
17167 logfile_top_msg ("STOP");
17168
17169 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17170 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17171
17172 if (data.ocl) ocl_close (data.ocl);
17173
17174 if (data.devices_status == STATUS_ABORTED) return 2;
17175 if (data.devices_status == STATUS_QUIT) return 2;
17176 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17177 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17178 if (data.devices_status == STATUS_CRACKED) return 0;
17179
17180 return -1;
17181 }
Hashcat additions to support pwdhash