projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fix bsdicrypt for NV
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Author......: Jens Steube <jens.steube@gmail.com>
3 * License.....: MIT
4 */
5
6 #include <common.h>
7 #include <shared.h>
8 #include <rp_gpu_on_cpu.h>
9 #include <getopt.h>
10
11 const char *PROGNAME = "oclHashcat";
12 const char *VERSION_TXT = "2.01";
13 const uint VERSION_BIN = 201;
14 const uint RESTORE_MIN = 201;
15
16 #define INCR_RULES 10000
17 #define INCR_SALTS 100000
18 #define INCR_MASKS 1000
19 #define INCR_POT 1000
20
21 // comment-out for kernel source mode
22
23 //#define BINARY_KERNEL
24
25 #define USAGE 0
26 #define VERSION 0
27 #define QUIET 0
28 #define MARKOV_THRESHOLD 0
29 #define MARKOV_DISABLE 0
30 #define MARKOV_CLASSIC 0
31 #define BENCHMARK 0
32 #define BENCHMARK_MODE 1
33 #define RESTORE 0
34 #define RESTORE_TIMER 60
35 #define RESTORE_DISABLE 0
36 #define STATUS 0
37 #define STATUS_TIMER 10
38 #define STATUS_AUTOMAT 0
39 #define LOOPBACK 0
40 #define WEAK_HASH_THRESHOLD 100
41 #define SHOW 0
42 #define LEFT 0
43 #define USERNAME 0
44 #define REMOVE 0
45 #define REMOVE_TIMER 60
46 #define SKIP 0
47 #define LIMIT 0
48 #define KEYSPACE 0
49 #define POTFILE_DISABLE 0
50 #define DEBUG_MODE 0
51 #define RP_GEN 0
52 #define RP_GEN_FUNC_MIN 1
53 #define RP_GEN_FUNC_MAX 4
54 #define RP_GEN_SEED 0
55 #define RULE_BUF_L ":"
56 #define RULE_BUF_R ":"
57 #define FORCE 0
58 #define RUNTIME 0
59 #define HEX_CHARSET 0
60 #define HEX_SALT 0
61 #define HEX_WORDLIST 0
62 #define OUTFILE_FORMAT 3
63 #define OUTFILE_AUTOHEX 1
64 #define OUTFILE_CHECK_TIMER 5
65 #define ATTACK_MODE 0
66 #define HASH_MODE 0
67 #define SEGMENT_SIZE 32
68 #define INCREMENT 0
69 #define INCREMENT_MIN 1
70 #define INCREMENT_MAX PW_MAX
71 #define SEPARATOR ':'
72 #define BITMAP_MIN 16
73 #define BITMAP_MAX 24
74 #define GPU_TEMP_DISABLE 0
75 #define GPU_TEMP_ABORT 90
76 #define GPU_TEMP_RETAIN 80
77 #define WORKLOAD_PROFILE 2
78 #define GPU_ACCEL 0
79 #define GPU_LOOPS 0
80 #define GPU_RULES 1024
81 #define GPU_COMBS 1024
82 #define GPU_BFS 1024
83 #define GPU_THREADS 64
84 #define POWERTUNE_ENABLE 0
85 #define LOGFILE_DISABLE 0
86 #define SCRYPT_TMTO 0
87
88 #define WL_MODE_STDIN 1
89 #define WL_MODE_FILE 2
90 #define WL_MODE_MASK 3
91
92 #define HL_MODE_FILE 4
93 #define HL_MODE_ARG 5
94
95 #define HLFMT_HASHCAT 0
96 #define HLFMT_PWDUMP 1
97 #define HLFMT_PASSWD 2
98 #define HLFMT_SHADOW 3
99 #define HLFMT_DCC 4
100 #define HLFMT_DCC2 5
101 #define HLFMT_NETNTLM1 7
102 #define HLFMT_NETNTLM2 8
103 #define HLFMT_NSLDAP 9
104 #define HLFMT_NSLDAPS 10
105 #define HLFMTS_CNT 11
106
107 #define ATTACK_MODE_STRAIGHT 0
108 #define ATTACK_MODE_COMBI 1
109 #define ATTACK_MODE_TOGGLE 2
110 #define ATTACK_MODE_BF 3
111 #define ATTACK_MODE_PERM 4
112 #define ATTACK_MODE_TABLE 5
113 #define ATTACK_MODE_HYBRID1 6
114 #define ATTACK_MODE_HYBRID2 7
115 #define ATTACK_MODE_NONE 100
116
117 #define ATTACK_KERN_STRAIGHT 0
118 #define ATTACK_KERN_COMBI 1
119 #define ATTACK_KERN_BF 3
120 #define ATTACK_KERN_NONE 100
121
122 #define ATTACK_EXEC_ON_CPU 10
123 #define ATTACK_EXEC_ON_GPU 11
124
125 #define COMBINATOR_MODE_BASE_LEFT 10001
126 #define COMBINATOR_MODE_BASE_RIGHT 10002
127
128 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
129 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
130
131 #define MAX_CUT_TRIES 4
132
133 #define MAX_DICTSTAT 10000
134
135 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 58
136
137 #define global_free(attr) \
138 { \
139 myfree ((void *) data.attr); \
140 \
141 data.attr = NULL; \
142 }
143
144 #define local_free(attr) \
145 { \
146 myfree ((void *) attr); \
147 \
148 attr = NULL; \
149 }
150
151 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
152 {
153 12400,
154 500,
155 3200,
156 7400,
157 1800,
158 122,
159 1722,
160 7100,
161 6300,
162 6700,
163 6400,
164 6500,
165 2400,
166 2410,
167 5700,
168 9200,
169 9300,
170 22,
171 501,
172 5800,
173 8100,
174 8500,
175 7200,
176 9900,
177 7700,
178 7800,
179 10300,
180 8600,
181 8700,
182 9100,
183 133,
184 11600,
185 12500,
186 6211,
187 6221,
188 6231,
189 6241,
190 8800,
191 12200,
192 9700,
193 9710,
194 9800,
195 9810,
196 9400,
197 9500,
198 9600,
199 10400,
200 10410,
201 10500,
202 10600,
203 10700,
204 9000,
205 5200,
206 6800,
207 6600,
208 8200,
209 11300,
210 12700
211 };
212
213 /**
214 * types
215 */
216
217 static void (*get_next_word_func) (char *, uint32_t, uint32_t *, uint32_t *);
218
219 /**
220 * globals
221 */
222
223 static unsigned int full01 = 0x01010101;
224 static unsigned int full80 = 0x80808080;
225
226 int SUPPRESS_OUTPUT = 0;
227
228 hc_thread_mutex_t mux_adl;
229 hc_thread_mutex_t mux_counter;
230 hc_thread_mutex_t mux_dispatcher;
231 hc_thread_mutex_t mux_display;
232
233 hc_global_data_t data;
234
235 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
236
237 const char *USAGE_MINI[] =
238 {
239 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
240 "",
241 "Try --help for more help.",
242 NULL
243 };
244
245 const char *USAGE_BIG[] =
246 {
247 "%s, advanced password recovery",
248 "",
249 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
250 "",
251 "=======",
252 "Options",
253 "=======",
254 "",
255 "* General:",
256 "",
257 " -m, --hash-type=NUM Hash-type, see references below",
258 " -a, --attack-mode=NUM Attack-mode, see references below",
259 " -V, --version Print version",
260 " -h, --help Print help",
261 " --quiet Suppress output",
262 "",
263 "* Benchmark:",
264 "",
265 " -b, --benchmark Run benchmark",
266 " --benchmark-mode=NUM Benchmark-mode, see references below",
267 "",
268 "* Misc:",
269 "",
270 " --hex-charset Assume charset is given in hex",
271 " --hex-salt Assume salt is given in hex",
272 " --hex-wordlist Assume words in wordlist is given in hex",
273 " --force Ignore warnings",
274 " --status Enable automatic update of the status-screen",
275 " --status-timer=NUM Seconds between status-screen update",
276 " --status-automat Display the status view in a machine readable format",
277 " --loopback Add new plains to induct directory",
278 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
279 "",
280 "* Markov:",
281 "",
282 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
283 " --markov-disable Disables markov-chains, emulates classic brute-force",
284 " --markov-classic Enables classic markov-chains, no per-position enhancement",
285 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
286 "",
287 "* Session:",
288 "",
289 " --runtime=NUM Abort session after NUM seconds of runtime",
290 " --session=STR Define specific session name",
291 " --restore Restore session from --session",
292 " --restore-disable Do not write restore file",
293 "",
294 "* Files:",
295 "",
296 " -o, --outfile=FILE Define outfile for recovered hash",
297 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
298 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
299 " --outfile-check-timer=NUM Seconds between outfile checks",
300 " -p, --separator=CHAR Separator char for hashlists and outfile",
301 " --show Show cracked passwords only",
302 " --left Show un-cracked passwords only",
303 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
304 " --remove Enable remove of hash once it is cracked",
305 " --remove-timer=NUM Update input hash file each NUM seconds",
306 " --potfile-disable Do not write potfile",
307 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
308 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
309 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
310 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
311 " --logfile-disable Disable the logfile",
312 " --truecrypt-keyfiles=FILE Keyfiles used, seperate with comma",
313 "",
314 "* Resources:",
315 "",
316 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
317 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
318 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
319 " --cpu-affinity=STR Locks to CPU devices, seperate with comma",
320 " -d, --gpu-devices=STR Devices to use, separate with comma",
321 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
322 " -n, --gpu-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
323 " -u, --gpu-loops=NUM Workload fine-tuning: 8 - 1024",
324 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
325 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
326 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
327 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
328 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
329 "",
330 "* Distributed:",
331 "",
332 " -s, --skip=NUM Skip number of words",
333 " -l, --limit=NUM Limit number of words",
334 " --keyspace Show keyspace base:mod values and quit",
335 "",
336 "* Rules:",
337 "",
338 " -j, --rule-left=RULE Single rule applied to each word from left dict",
339 " -k, --rule-right=RULE Single rule applied to each word from right dict",
340 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
341 " -g, --generate-rules=NUM Generate NUM random rules",
342 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
343 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
344 " --generate-rules-seed=NUM Force RNG seed to NUM",
345 "",
346 "* Custom charsets:",
347 "",
348 " -1, --custom-charset1=CS User-defined charsets",
349 " -2, --custom-charset2=CS Example:",
350 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
351 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
352 "",
353 "* Increment:",
354 "",
355 " -i, --increment Enable increment mode",
356 " --increment-min=NUM Start incrementing at NUM",
357 " --increment-max=NUM Stop incrementing at NUM",
358 "",
359 "==========",
360 "References",
361 "==========",
362 "",
363 "* Workload Profile:",
364 "",
365 " 1 = Reduced performance profile (low latency desktop)",
366 " 2 = Default performance profile",
367 " 3 = Tuned performance profile (high latency desktop)",
368 "",
369 "* Benchmark Settings:",
370 "",
371 " 0 = Manual Tuning",
372 " 1 = Performance Tuning, default",
373 "",
374 "* Outfile Formats:",
375 "",
376 " 1 = hash[:salt]",
377 " 2 = plain",
378 " 3 = hash[:salt]:plain",
379 " 4 = hex_plain",
380 " 5 = hash[:salt]:hex_plain",
381 " 6 = plain:hex_plain",
382 " 7 = hash[:salt]:plain:hex_plain",
383 " 8 = crackpos",
384 " 9 = hash[:salt]:crackpos",
385 " 10 = plain:crackpos",
386 " 11 = hash[:salt]:plain:crackpos",
387 " 12 = hex_plain:crackpos",
388 " 13 = hash[:salt]:hex_plain:crackpos",
389 " 14 = plain:hex_plain:crackpos",
390 " 15 = hash[:salt]:plain:hex_plain:crackpos",
391 "",
392 "* Debug mode output formats (for hybrid mode only, by using rules):",
393 "",
394 " 1 = save finding rule",
395 " 2 = save original word",
396 " 3 = save original word and finding rule",
397 " 4 = save original word, finding rule and modified plain",
398 "",
399 "* Built-in charsets:",
400 "",
401 " ?l = abcdefghijklmnopqrstuvwxyz",
402 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
403 " ?d = 0123456789",
404 " ?s = !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
405 " ?a = ?l?u?d?s",
406 " ?b = 0x00 - 0xff",
407 "",
408 "* Attack modes:",
409 "",
410 " 0 = Straight",
411 " 1 = Combination",
412 " 3 = Brute-force",
413 " 6 = Hybrid dict + mask",
414 " 7 = Hybrid mask + dict",
415 "",
416 "* Hash types:",
417 "",
418 "[[ Roll-your-own: Raw Hashes ]]",
419 "",
420 " 900 = MD4",
421 " 0 = MD5",
422 " 5100 = Half MD5",
423 " 100 = SHA1",
424 " 10800 = SHA-384",
425 " 1400 = SHA-256",
426 " 1700 = SHA-512",
427 " 5000 = SHA-3(Keccak)",
428 " 10100 = SipHash",
429 " 6000 = RipeMD160",
430 " 6100 = Whirlpool",
431 " 6900 = GOST R 34.11-94",
432 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
433 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
434 "",
435 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
436 "",
437 " 10 = md5($pass.$salt)",
438 " 20 = md5($salt.$pass)",
439 " 30 = md5(unicode($pass).$salt)",
440 " 40 = md5($salt.unicode($pass))",
441 " 3800 = md5($salt.$pass.$salt)",
442 " 3710 = md5($salt.md5($pass))",
443 " 2600 = md5(md5($pass)",
444 " 4300 = md5(strtoupper(md5($pass)))",
445 " 4400 = md5(sha1($pass))",
446 " 110 = sha1($pass.$salt)",
447 " 120 = sha1($salt.$pass)",
448 " 130 = sha1(unicode($pass).$salt)",
449 " 140 = sha1($salt.unicode($pass))",
450 " 4500 = sha1(sha1($pass)",
451 " 4700 = sha1(md5($pass))",
452 " 4900 = sha1($salt.$pass.$salt)",
453 " 1410 = sha256($pass.$salt)",
454 " 1420 = sha256($salt.$pass)",
455 " 1430 = sha256(unicode($pass).$salt)",
456 " 1440 = sha256($salt.unicode($pass))",
457 " 1710 = sha512($pass.$salt)",
458 " 1720 = sha512($salt.$pass)",
459 " 1730 = sha512(unicode($pass).$salt)",
460 " 1740 = sha512($salt.unicode($pass))",
461 "",
462 "[[ Roll-your-own: Authenticated Hashes ]]",
463 "",
464 " 50 = HMAC-MD5 (key = $pass)",
465 " 60 = HMAC-MD5 (key = $salt)",
466 " 150 = HMAC-SHA1 (key = $pass)",
467 " 160 = HMAC-SHA1 (key = $salt)",
468 " 1450 = HMAC-SHA256 (key = $pass)",
469 " 1460 = HMAC-SHA256 (key = $salt)",
470 " 1750 = HMAC-SHA512 (key = $pass)",
471 " 1760 = HMAC-SHA512 (key = $salt)",
472 "",
473 "[[ Generic KDF ]]",
474 "",
475 " 400 = phpass",
476 " 8900 = scrypt",
477 " 11900 = PBKDF2-HMAC-MD5",
478 " 12000 = PBKDF2-HMAC-SHA1",
479 " 10900 = PBKDF2-HMAC-SHA256",
480 " 12100 = PBKDF2-HMAC-SHA512",
481 "",
482 "[[ Network protocols, Challenge-Response ]]",
483 "",
484 " 23 = Skype",
485 " 2500 = WPA/WPA2",
486 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
487 " 5300 = IKE-PSK MD5",
488 " 5400 = IKE-PSK SHA1",
489 " 5500 = NetNTLMv1",
490 " 5500 = NetNTLMv1 + ESS",
491 " 5600 = NetNTLMv2",
492 " 7300 = IPMI2 RAKP HMAC-SHA1",
493 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
494 " 8300 = DNSSEC (NSEC3)",
495 " 10200 = Cram MD5",
496 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
497 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
498 " 11400 = SIP digest authentication (MD5)",
499 "",
500 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
501 "",
502 " 121 = SMF (Simple Machines Forum)",
503 " 400 = phpBB3",
504 " 2611 = vBulletin < v3.8.5",
505 " 2711 = vBulletin > v3.8.5",
506 " 2811 = MyBB",
507 " 2811 = IPB (Invison Power Board)",
508 " 8400 = WBB3 (Woltlab Burning Board)",
509 " 11 = Joomla < 2.5.18",
510 " 400 = Joomla > 2.5.18",
511 " 400 = Wordpress",
512 " 2612 = PHPS",
513 " 7900 = Drupal7",
514 " 21 = osCommerce",
515 " 21 = xt:Commerce",
516 " 11000 = PrestaShop",
517 " 124 = Django (SHA-1)",
518 " 10000 = Django (PBKDF2-SHA256)",
519 " 3711 = Mediawiki B type",
520 " 7600 = Redmine",
521 "",
522 "[[ Database Server ]]",
523 "",
524 " 12 = PostgreSQL",
525 " 131 = MSSQL(2000)",
526 " 132 = MSSQL(2005)",
527 " 1731 = MSSQL(2012)",
528 " 1731 = MSSQL(2014)",
529 " 200 = MySQL323",
530 " 300 = MySQL4.1/MySQL5",
531 " 3100 = Oracle H: Type (Oracle 7+)",
532 " 112 = Oracle S: Type (Oracle 11+)",
533 " 12300 = Oracle T: Type (Oracle 12+)",
534 " 8000 = Sybase ASE",
535 "",
536 "[[ HTTP, SMTP, LDAP Server]]",
537 "",
538 " 141 = EPiServer 6.x < v4",
539 " 1441 = EPiServer 6.x > v4",
540 " 1600 = Apache $apr1$",
541 " 12600 = ColdFusion 10+",
542 " 1421 = hMailServer",
543 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
544 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
545 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
546 "",
547 "[[ Checksums ]]",
548 "",
549 " 11500 = CRC32",
550 "",
551 "[[ Operating-Systems ]]",
552 "",
553 " 3000 = LM",
554 " 1000 = NTLM",
555 " 1100 = Domain Cached Credentials (DCC), MS Cache",
556 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
557 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
558 " 1500 = descrypt, DES(Unix), Traditional DES",
559 " 12400 = BSDiCrypt, Extended DES",
560 " 500 = md5crypt $1$, MD5(Unix)",
561 " 3200 = bcrypt $2*$, Blowfish(Unix)",
562 " 7400 = sha256crypt $5$, SHA256(Unix)",
563 " 1800 = sha512crypt $6$, SHA512(Unix)",
564 " 122 = OSX v10.4",
565 " 122 = OSX v10.5",
566 " 122 = OSX v10.6",
567 " 1722 = OSX v10.7",
568 " 7100 = OSX v10.8",
569 " 7100 = OSX v10.9",
570 " 7100 = OSX v10.10",
571 " 6300 = AIX {smd5}",
572 " 6700 = AIX {ssha1}",
573 " 6400 = AIX {ssha256}",
574 " 6500 = AIX {ssha512}",
575 " 2400 = Cisco-PIX",
576 " 2410 = Cisco-ASA",
577 " 500 = Cisco-IOS $1$",
578 " 5700 = Cisco-IOS $4$",
579 " 9200 = Cisco-IOS $8$",
580 " 9300 = Cisco-IOS $9$",
581 " 22 = Juniper Netscreen/SSG (ScreenOS)",
582 " 501 = Juniper IVE",
583 " 5800 = Android PIN",
584 " 8100 = Citrix Netscaler",
585 " 8500 = RACF",
586 " 7200 = GRUB 2",
587 " 9900 = Radmin2",
588 "",
589 "[[ Enterprise Application Software (EAS) ]]",
590 "",
591 " 7700 = SAP CODVN B (BCODE)",
592 " 7800 = SAP CODVN F/G (PASSCODE)",
593 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
594 " 8600 = Lotus Notes/Domino 5",
595 " 8700 = Lotus Notes/Domino 6",
596 " 9100 = Lotus Notes/Domino 8",
597 " 133 = PeopleSoft",
598 "",
599 "[[ Archives ]]",
600 "",
601 " 11600 = 7-Zip",
602 " 12500 = RAR3-hp",
603 "",
604 "[[ Full-Disk encryptions (FDE) ]]",
605 "",
606 " 62XY = TrueCrypt 5.0+",
607 " X = 1 = PBKDF2-HMAC-RipeMD160",
608 " X = 2 = PBKDF2-HMAC-SHA512",
609 " X = 3 = PBKDF2-HMAC-Whirlpool",
610 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
611 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
612 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
613 " Y = 3 = XTS 1536 bit (Ciphers: All)",
614 " 8800 = Android FDE < v4.3",
615 " 12200 = eCryptfs",
616 "",
617 "[[ Documents ]]",
618 "",
619 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
620 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
621 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
622 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
623 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
624 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
625 " 9400 = MS Office 2007",
626 " 9500 = MS Office 2010",
627 " 9600 = MS Office 2013",
628 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
629 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
630 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
631 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
632 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
633 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
634 "",
635 "[[ Password Managers ]]",
636 "",
637 " 9000 = Password Safe v2",
638 " 5200 = Password Safe v3",
639 " 6800 = Lastpass",
640 " 6600 = 1Password, agilekeychain",
641 " 8200 = 1Password, cloudkeychain",
642 " 11300 = Bitcoin/Litecoin wallet.dat",
643 " 12700 = Blockchain, My Wallet",
644 "",
645 NULL
646 };
647
648 /**
649 * oclHashcat specific functions
650 */
651
652 void status_display_automat ()
653 {
654 FILE *out = stdout;
655
656 fprintf (out, "STATUS\t%u\t", data.devices_status);
657
658 /**
659 * speed new
660 */
661
662 fprintf (out, "SPEED\t");
663
664 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
665 {
666 hc_device_param_t *device_param = &data.devices_param[device_id];
667
668 uint64_t speed_cnt = 0;
669 float speed_ms = 0;
670
671 for (int i = 0; i < SPEED_CACHE; i++)
672 {
673 float rec_ms;
674
675 hc_timer_get (device_param->speed_rec[i], rec_ms);
676
677 if (rec_ms > SPEED_MAXAGE) continue;
678
679 speed_cnt += device_param->speed_cnt[i];
680 speed_ms += device_param->speed_ms[i];
681 }
682
683 speed_cnt /= SPEED_CACHE;
684 speed_ms /= SPEED_CACHE;
685
686 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
687 }
688
689 /**
690 * words_cur
691 */
692
693 uint64_t words_cur = get_lowest_words_done ();
694
695 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
696
697 /**
698 * counter
699 */
700
701 uint salts_left = data.salts_cnt - data.salts_done;
702
703 if (salts_left == 0) salts_left = 1;
704
705 uint64_t progress_total = data.words_cnt * salts_left;
706
707 uint64_t all_done = 0;
708 uint64_t all_rejected = 0;
709 uint64_t all_restored = 0;
710
711 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
712 {
713 if (salts_left > 1)
714 {
715 // otherwise the final cracked status shows 0/XXX progress
716
717 if (data.salts_shown[salt_pos] == 1) continue;
718 }
719
720 all_done += data.words_progress_done[salt_pos];
721 all_rejected += data.words_progress_rejected[salt_pos];
722 all_restored += data.words_progress_restored[salt_pos];
723 }
724
725 uint64_t progress_cur = all_restored + all_done + all_rejected;
726 uint64_t progress_end = progress_total;
727
728 uint64_t progress_skip = 0;
729
730 if (data.skip)
731 {
732 progress_skip = MIN (data.skip, data.words_base) * salts_left;
733
734 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.gpu_rules_cnt;
735 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
736 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
737 }
738
739 if (data.limit)
740 {
741 progress_end = MIN (data.limit, data.words_base) * salts_left;
742
743 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.gpu_rules_cnt;
744 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
745 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
746 }
747
748 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
749 uint64_t progress_end_relative_skip = progress_end - progress_skip;
750
751 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
752
753 /**
754 * cracks
755 */
756
757 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
758 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
759
760 /**
761 * temperature
762 */
763
764 if (data.gpu_temp_disable == 0)
765 {
766 fprintf (out, "TEMP\t");
767
768 hc_thread_mutex_lock (mux_adl);
769
770 for (uint i = 0; i < data.devices_cnt; i++)
771 {
772 int temp = hm_get_temperature_with_device_id (i);
773
774 fprintf (out, "%d\t", temp);
775 }
776
777 hc_thread_mutex_unlock (mux_adl);
778 }
779
780 #ifdef _WIN
781 fputc ('\r', out);
782 fputc ('\n', out);
783 #endif
784
785 #ifdef _POSIX
786 fputc ('\n', out);
787 #endif
788
789 fflush (out);
790 }
791
792 void status_display ()
793 {
794 if (data.devices_status == STATUS_INIT) return;
795 if (data.devices_status == STATUS_STARTING) return;
796 if (data.devices_status == STATUS_BYPASS) return;
797
798 if (data.status_automat == 1)
799 {
800 status_display_automat ();
801
802 return;
803 }
804
805 char tmp_buf[1000];
806
807 uint tmp_len = 0;
808
809 log_info ("Session.Name...: %s", data.session);
810
811 char *status_type = strstatus (data.devices_status);
812
813 uint hash_mode = data.hash_mode;
814
815 char *hash_type = strhashtype (hash_mode); // not a bug
816
817 log_info ("Status.........: %s", status_type);
818
819 /**
820 * show rules
821 */
822
823 if (data.rp_files_cnt)
824 {
825 uint i;
826
827 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
828 {
829 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
830 }
831
832 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
833
834 log_info ("Rules.Type.....: %s", tmp_buf);
835
836 tmp_len = 0;
837 }
838
839 if (data.rp_gen)
840 {
841 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
842
843 if (data.rp_gen_seed)
844 {
845 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
846 }
847 }
848
849 /**
850 * show input
851 */
852
853 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
854 {
855 if (data.wordlist_mode == WL_MODE_FILE)
856 {
857 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
858 }
859 else if (data.wordlist_mode == WL_MODE_STDIN)
860 {
861 log_info ("Input.Mode.....: Pipe");
862 }
863 }
864 else if (data.attack_mode == ATTACK_MODE_COMBI)
865 {
866 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
867 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
868 }
869 else if (data.attack_mode == ATTACK_MODE_BF)
870 {
871 char *mask = data.mask;
872
873 if (mask != NULL)
874 {
875 uint mask_len = data.css_cnt;
876
877 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
878
879 if (mask_len > 0)
880 {
881 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
882 {
883 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
884 {
885 mask_len -= data.salts_buf[0].salt_len;
886 }
887 }
888
889 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
890
891 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
892 }
893
894 if (data.maskcnt > 1)
895 {
896 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
897
898 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
899 }
900
901 log_info ("Input.Mode.....: %s", tmp_buf);
902 }
903
904 tmp_len = 0;
905 }
906 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
907 {
908 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
909 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
910 }
911 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
912 {
913 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
914 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
915 }
916
917 if (data.digests_cnt == 1)
918 {
919 if (data.hash_mode == 2500)
920 {
921 wpa_t *wpa = (wpa_t *) data.esalts_buf;
922
923 uint pke[25];
924
925 char *pke_ptr = (char *) pke;
926
927 for (uint i = 0; i < 25; i++)
928 {
929 pke[i] = byte_swap_32 (wpa->pke[i]);
930 }
931
932 char mac1[6];
933 char mac2[6];
934
935 memcpy (mac1, pke_ptr + 23, 6);
936 memcpy (mac2, pke_ptr + 29, 6);
937
938 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
939 (char *) data.salts_buf[0].salt_buf,
940 mac1[0] & 0xff,
941 mac1[1] & 0xff,
942 mac1[2] & 0xff,
943 mac1[3] & 0xff,
944 mac1[4] & 0xff,
945 mac1[5] & 0xff,
946 mac2[0] & 0xff,
947 mac2[1] & 0xff,
948 mac2[2] & 0xff,
949 mac2[3] & 0xff,
950 mac2[4] & 0xff,
951 mac2[5] & 0xff);
952 }
953 else if (data.hash_mode == 5200)
954 {
955 log_info ("Hash.Target....: File (%s)", data.hashfile);
956 }
957 else if (data.hash_mode == 9000)
958 {
959 log_info ("Hash.Target....: File (%s)", data.hashfile);
960 }
961 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
962 {
963 log_info ("Hash.Target....: File (%s)", data.hashfile);
964 }
965 else
966 {
967 char out_buf[4096];
968
969 ascii_digest (out_buf, 0, 0);
970
971 // limit length
972 if (strlen (out_buf) > 40)
973 {
974 out_buf[41] = '.';
975 out_buf[42] = '.';
976 out_buf[43] = '.';
977 out_buf[44] = 0;
978 }
979
980 log_info ("Hash.Target....: %s", out_buf);
981 }
982 }
983 else
984 {
985 if (data.hash_mode == 3000)
986 {
987 char out_buf1[4096];
988 char out_buf2[4096];
989
990 ascii_digest (out_buf1, 0, 0);
991 ascii_digest (out_buf2, 0, 1);
992
993 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
994 }
995 else
996 {
997 log_info ("Hash.Target....: File (%s)", data.hashfile);
998 }
999 }
1000
1001 log_info ("Hash.Type......: %s", hash_type);
1002
1003 /**
1004 * speed new
1005 */
1006
1007 uint64_t speed_cnt[DEVICES_MAX];
1008 float speed_ms[DEVICES_MAX];
1009
1010 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1011 {
1012 hc_device_param_t *device_param = &data.devices_param[device_id];
1013
1014 // we need to clear values (set to 0) because in case the gpu does
1015 // not get new candidates it idles around but speed display would
1016 // show it as working.
1017 // if we instantly set it to 0 after reading it happens that the
1018 // speed can be shown as zero if the users refreshs to fast.
1019 // therefore, we add a timestamp when a stat was recorded and if its
1020 // to old we will not use it
1021
1022 speed_cnt[device_id] = 0;
1023 speed_ms[device_id] = 0;
1024
1025 for (int i = 0; i < SPEED_CACHE; i++)
1026 {
1027 float rec_ms;
1028
1029 hc_timer_get (device_param->speed_rec[i], rec_ms);
1030
1031 if (rec_ms > SPEED_MAXAGE) continue;
1032
1033 speed_cnt[device_id] += device_param->speed_cnt[i];
1034 speed_ms[device_id] += device_param->speed_ms[i];
1035 }
1036
1037 speed_cnt[device_id] /= SPEED_CACHE;
1038 speed_ms[device_id] /= SPEED_CACHE;
1039 }
1040
1041 float hashes_all_ms = 0;
1042
1043 float hashes_dev_ms[DEVICES_MAX];
1044
1045 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1046 {
1047 hashes_dev_ms[device_id] = 0;
1048
1049 if (speed_ms[device_id])
1050 {
1051 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1052
1053 hashes_all_ms += hashes_dev_ms[device_id];
1054 }
1055 }
1056
1057 /**
1058 * timers
1059 */
1060
1061 float ms_running = 0;
1062
1063 hc_timer_get (data.timer_running, ms_running);
1064
1065 float ms_paused = data.ms_paused;
1066
1067 if (data.devices_status == STATUS_PAUSED)
1068 {
1069 float ms_paused_tmp = 0;
1070
1071 hc_timer_get (data.timer_paused, ms_paused_tmp);
1072
1073 ms_paused += ms_paused_tmp;
1074 }
1075
1076 #ifdef WIN
1077
1078 __time64_t sec_run = ms_running / 1000;
1079
1080 #else
1081
1082 time_t sec_run = ms_running / 1000;
1083
1084 #endif
1085
1086 if (sec_run)
1087 {
1088 char display_run[32];
1089
1090 struct tm tm_run;
1091
1092 struct tm *tmp;
1093
1094 #ifdef WIN
1095
1096 tmp = _gmtime64 (&sec_run);
1097
1098 #else
1099
1100 tmp = gmtime (&sec_run);
1101
1102 #endif
1103
1104 if (tmp != NULL)
1105 {
1106 memcpy (&tm_run, tmp, sizeof (struct tm));
1107
1108 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1109
1110 char *start = ctime (&data.proc_start);
1111
1112 size_t start_len = strlen (start);
1113
1114 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1115 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1116
1117 log_info ("Time.Started...: %s (%s)", start, display_run);
1118 }
1119 }
1120 else
1121 {
1122 log_info ("Time.Started...: 0 secs");
1123 }
1124
1125 /**
1126 * counters
1127 */
1128
1129 uint salts_left = data.salts_cnt - data.salts_done;
1130
1131 if (salts_left == 0) salts_left = 1;
1132
1133 uint64_t progress_total = data.words_cnt * salts_left;
1134
1135 uint64_t all_done = 0;
1136 uint64_t all_rejected = 0;
1137 uint64_t all_restored = 0;
1138
1139 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1140 {
1141 if (salts_left > 1)
1142 {
1143 // otherwise the final cracked status shows 0/XXX progress
1144
1145 if (data.salts_shown[salt_pos] == 1) continue;
1146 }
1147
1148 all_done += data.words_progress_done[salt_pos];
1149 all_rejected += data.words_progress_rejected[salt_pos];
1150 all_restored += data.words_progress_restored[salt_pos];
1151 }
1152
1153 uint64_t progress_cur = all_restored + all_done + all_rejected;
1154 uint64_t progress_end = progress_total;
1155
1156 uint64_t progress_skip = 0;
1157
1158 if (data.skip)
1159 {
1160 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1161
1162 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.gpu_rules_cnt;
1163 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1164 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1165 }
1166
1167 if (data.limit)
1168 {
1169 progress_end = MIN (data.limit, data.words_base) * salts_left;
1170
1171 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.gpu_rules_cnt;
1172 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1173 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1174 }
1175
1176 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
1177 uint64_t progress_end_relative_skip = progress_end - progress_skip;
1178
1179 float speed_ms_real = ms_running - ms_paused;
1180 uint64_t speed_plains_real = all_done;
1181
1182 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1183 {
1184 if (data.devices_status != STATUS_CRACKED)
1185 {
1186 uint64_t words_per_ms = 0;
1187
1188 if (speed_plains_real && speed_ms_real)
1189 {
1190 words_per_ms = speed_plains_real / speed_ms_real;
1191 }
1192
1193 #ifdef WIN
1194 __time64_t sec_etc = 0;
1195 #else
1196 time_t sec_etc = 0;
1197 #endif
1198
1199 if (words_per_ms)
1200 {
1201 uint64_t progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1202
1203 uint64_t ms_left = progress_left_relative_skip / words_per_ms;
1204
1205 sec_etc = ms_left / 1000;
1206 }
1207
1208 if (sec_etc == 0)
1209 {
1210 log_info ("Time.Estimated.: 0 secs");
1211 }
1212 else if ((uint64_t) sec_etc > ETC_MAX)
1213 {
1214 log_info ("Time.Estimated.: > 10 Years");
1215 }
1216 else
1217 {
1218 char display_etc[32];
1219
1220 struct tm tm_etc;
1221
1222 struct tm *tmp;
1223
1224 #ifdef WIN
1225
1226 tmp = _gmtime64 (&sec_etc);
1227
1228 #else
1229
1230 tmp = gmtime (&sec_etc);
1231
1232 #endif
1233
1234 if (tmp != NULL)
1235 {
1236 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1237
1238 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1239
1240 time_t now;
1241
1242 time (&now);
1243
1244 now += sec_etc;
1245
1246 char *etc = ctime (&now);
1247
1248 size_t etc_len = strlen (etc);
1249
1250 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1251 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1252
1253 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1254 }
1255 }
1256 }
1257 }
1258
1259 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1260 {
1261 char display_dev_cur[16];
1262
1263 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1264
1265 strncpy (display_dev_cur, "0.00", 4);
1266
1267 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1268
1269 log_info ("Speed.GPU.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1270 }
1271
1272 char display_all_cur[16];
1273
1274 memset (display_all_cur, 0, sizeof (display_all_cur));
1275
1276 strncpy (display_all_cur, "0.00", 4);
1277
1278 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1279
1280 if (data.devices_cnt > 1) log_info ("Speed.GPU.#*...: %9sH/s", display_all_cur);
1281
1282 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1283 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1284
1285 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);
1286
1287 // crack-per-time
1288
1289 if (data.digests_cnt > 100)
1290 {
1291 time_t now = time (NULL);
1292
1293 int cpt_cur_min = 0;
1294 int cpt_cur_hour = 0;
1295 int cpt_cur_day = 0;
1296
1297 for (int i = 0; i < CPT_BUF; i++)
1298 {
1299 const uint cracked = data.cpt_buf[i].cracked;
1300 const time_t timestamp = data.cpt_buf[i].timestamp;
1301
1302 if ((timestamp + 60) > now)
1303 {
1304 cpt_cur_min += cracked;
1305 }
1306
1307 if ((timestamp + 3600) > now)
1308 {
1309 cpt_cur_hour += cracked;
1310 }
1311
1312 if ((timestamp + 86400) > now)
1313 {
1314 cpt_cur_day += cracked;
1315 }
1316 }
1317
1318 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1319 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1320 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1321
1322 if ((data.cpt_start + 86400) < now)
1323 {
1324 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1325 cpt_cur_min,
1326 cpt_cur_hour,
1327 cpt_cur_day,
1328 cpt_avg_min,
1329 cpt_avg_hour,
1330 cpt_avg_day);
1331 }
1332 else if ((data.cpt_start + 3600) < now)
1333 {
1334 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1335 cpt_cur_min,
1336 cpt_cur_hour,
1337 cpt_avg_min,
1338 cpt_avg_hour,
1339 cpt_avg_day);
1340 }
1341 else if ((data.cpt_start + 60) < now)
1342 {
1343 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1344 cpt_cur_min,
1345 cpt_avg_min,
1346 cpt_avg_hour,
1347 cpt_avg_day);
1348 }
1349 else
1350 {
1351 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1352 cpt_avg_min,
1353 cpt_avg_hour,
1354 cpt_avg_day);
1355 }
1356 }
1357
1358 // Restore point
1359
1360 uint64_t restore_point = get_lowest_words_done ();
1361
1362 uint64_t restore_total = data.words_base;
1363
1364 float percent_restore = 0;
1365
1366 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1367
1368 if (progress_end_relative_skip)
1369 {
1370 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1371 {
1372 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1373 float percent_rejected = 0.0;
1374
1375 if (progress_cur)
1376 {
1377 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1378 }
1379
1380 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);
1381 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1382
1383 if (data.restore_disable == 0)
1384 {
1385 if (percent_finished != 1)
1386 {
1387 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1388 }
1389 }
1390 }
1391 }
1392 else
1393 {
1394 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1395 {
1396 log_info ("Progress.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1397 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1398
1399 if (data.restore_disable == 0)
1400 {
1401 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1402 }
1403 }
1404 else
1405 {
1406 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1407 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1408
1409 // --restore not allowed if stdin is used -- really? why?
1410
1411 //if (data.restore_disable == 0)
1412 //{
1413 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1414 //}
1415 }
1416 }
1417
1418 if (data.gpu_temp_disable == 0)
1419 {
1420 hc_thread_mutex_lock (mux_adl);
1421
1422 for (uint i = 0; i < data.devices_cnt; i++)
1423 {
1424 if (data.hm_device[i].fan_supported == 1)
1425 {
1426 const int temperature = hm_get_temperature_with_device_id (i);
1427 const int utilization = hm_get_utilization_with_device_id (i);
1428 const int fanspeed = hm_get_fanspeed_with_device_id (i);
1429
1430 if (data.vendor_id == VENDOR_ID_AMD)
1431 {
1432 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1433 }
1434
1435 if (data.vendor_id == VENDOR_ID_NV)
1436 {
1437 #ifdef LINUX
1438 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1439 #else
1440 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2drpm Fan", i + 1, utilization, temperature, fanspeed);
1441 #endif
1442 }
1443 }
1444 else
1445 {
1446 const int temperature = hm_get_temperature_with_device_id (i);
1447 const int utilization = hm_get_utilization_with_device_id (i);
1448
1449 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, N/A Fan", i + 1, utilization, temperature);
1450 }
1451 }
1452
1453 hc_thread_mutex_unlock (mux_adl);
1454 }
1455 }
1456
1457 static void status_benchmark ()
1458 {
1459 if (data.devices_status == STATUS_INIT) return;
1460 if (data.devices_status == STATUS_STARTING) return;
1461
1462 if (data.words_cnt == 0) return;
1463
1464 uint64_t speed_cnt[DEVICES_MAX];
1465 float speed_ms[DEVICES_MAX];
1466
1467 uint device_id;
1468
1469 for (device_id = 0; device_id < data.devices_cnt; device_id++)
1470 {
1471 hc_device_param_t *device_param = &data.devices_param[device_id];
1472
1473 speed_cnt[device_id] = 0;
1474 speed_ms[device_id] = 0;
1475
1476 for (int i = 0; i < SPEED_CACHE; i++)
1477 {
1478 speed_cnt[device_id] += device_param->speed_cnt[i];
1479 speed_ms[device_id] += device_param->speed_ms[i];
1480 }
1481
1482 speed_cnt[device_id] /= SPEED_CACHE;
1483 speed_ms[device_id] /= SPEED_CACHE;
1484 }
1485
1486 float hashes_all_ms = 0;
1487
1488 float hashes_dev_ms[DEVICES_MAX];
1489
1490 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1491 {
1492 hashes_dev_ms[device_id] = 0;
1493
1494 if (speed_ms[device_id])
1495 {
1496 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1497
1498 hashes_all_ms += hashes_dev_ms[device_id];
1499 }
1500 }
1501
1502 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1503 {
1504 char display_dev_cur[16];
1505
1506 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1507
1508 strncpy (display_dev_cur, "0.00", 4);
1509
1510 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1511
1512 log_info ("Speed.GPU.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1513 }
1514
1515 char display_all_cur[16];
1516
1517 memset (display_all_cur, 0, sizeof (display_all_cur));
1518
1519 strncpy (display_all_cur, "0.00", 4);
1520
1521 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1522
1523 if (data.devices_cnt > 1) log_info ("Speed.GPU.#*.: %9sH/s", display_all_cur);
1524 }
1525
1526 /**
1527 * oclHashcat -only- functions
1528 */
1529
1530 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *install_dir, char *kernel_file)
1531 {
1532 if (attack_exec == ATTACK_EXEC_ON_GPU)
1533 {
1534 if (attack_kern == ATTACK_KERN_STRAIGHT)
1535 snprintf (kernel_file, 255, "%s/OpenCL/m%05d_a0.cl", install_dir, (int) kern_type);
1536 else if (attack_kern == ATTACK_KERN_COMBI)
1537 snprintf (kernel_file, 255, "%s/OpenCL/m%05d_a1.cl", install_dir, (int) kern_type);
1538 else if (attack_kern == ATTACK_KERN_BF)
1539 snprintf (kernel_file, 255, "%s/OpenCL/m%05d_a3.cl", install_dir, (int) kern_type);
1540 }
1541 else
1542 snprintf (kernel_file, 255, "%s/OpenCL/m%05d.cl", install_dir, (int) kern_type);
1543 }
1544
1545 static uint convert_from_hex (char *line_buf, const uint line_len)
1546 {
1547 if (line_len & 1) return (line_len); // not in hex
1548
1549 if (data.hex_wordlist == 1)
1550 {
1551 uint i;
1552 uint j;
1553
1554 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1555 {
1556 line_buf[i] = hex_to_char (&line_buf[j]);
1557 }
1558
1559 memset (line_buf + i, 0, line_len - i);
1560
1561 return (i);
1562 }
1563 else if (line_len >= 6) // $HEX[] = 6
1564 {
1565 if (line_buf[0] != '$') return (line_len);
1566 if (line_buf[1] != 'H') return (line_len);
1567 if (line_buf[2] != 'E') return (line_len);
1568 if (line_buf[3] != 'X') return (line_len);
1569 if (line_buf[4] != '[') return (line_len);
1570 if (line_buf[line_len - 1] != ']') return (line_len);
1571
1572 uint i;
1573 uint j;
1574
1575 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1576 {
1577 line_buf[i] = hex_to_char (&line_buf[j]);
1578 }
1579
1580 memset (line_buf + i, 0, line_len - i);
1581
1582 return (i);
1583 }
1584
1585 return (line_len);
1586 }
1587
1588 static uint count_lines (FILE *fd)
1589 {
1590 uint cnt = 0;
1591
1592 char *buf = (char *) mymalloc (BUFSIZ);
1593
1594 size_t nread_tmp = 0;
1595
1596 char *ptr = buf;
1597
1598 while (!feof (fd))
1599 {
1600 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1601 nread_tmp = nread;
1602
1603 if (nread < 1) continue;
1604
1605 ptr = buf;
1606
1607 do
1608 {
1609 if (*ptr++ == '\n') cnt++;
1610
1611 } while (nread--);
1612 }
1613
1614 // special case (if last line did not contain a newline char ... at the very end of the file)
1615
1616 if (nread_tmp > 3)
1617 {
1618 ptr -= 2;
1619
1620 if (*ptr != '\n')
1621 {
1622 ptr--;
1623
1624 if (*ptr != '\n') // needed ? different on windows systems?
1625 {
1626 cnt++;
1627 }
1628 }
1629 }
1630
1631 myfree (buf);
1632
1633 return cnt;
1634 }
1635
1636 static void clear_prompt ()
1637 {
1638 fputc ('\r', stdout);
1639
1640 for (size_t i = 0; i < strlen (PROMPT); i++)
1641 {
1642 fputc (' ', stdout);
1643 }
1644
1645 fputc ('\r', stdout);
1646
1647 fflush (stdout);
1648 }
1649
1650 static void gidd_to_pw_t (hc_device_param_t *device_param, const uint64_t gidd, pw_t *pw)
1651 {
1652 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1653 }
1654
1655 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1656 {
1657 char *outfile = data.outfile;
1658 uint quiet = data.quiet;
1659 FILE *pot_fp = data.pot_fp;
1660 uint loopback = data.loopback;
1661 uint debug_mode = data.debug_mode;
1662 char *debug_file = data.debug_file;
1663
1664 char debug_rule_buf[BLOCK_SIZE];
1665 int debug_rule_len = 0; // -1 error
1666 uint debug_plain_len = 0;
1667
1668 unsigned char debug_plain_ptr[BLOCK_SIZE];
1669
1670 // hash
1671
1672 char out_buf[4096]; memset (out_buf, 0, sizeof (out_buf));
1673
1674 ascii_digest (out_buf, salt_pos, digest_pos);
1675
1676 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1677
1678 // plain
1679
1680 plain_t plain;
1681
1682 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1683
1684 uint gidvid = plain.gidvid;
1685 uint il_pos = plain.il_pos;
1686
1687 uint64_t crackpos = device_param->words_off;
1688
1689 uint plain_buf[16];
1690
1691 unsigned char *plain_ptr = (unsigned char *) plain_buf;
1692 unsigned int plain_len = 0;
1693
1694 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1695 {
1696 uint64_t gidd = gidvid;
1697 uint64_t gidm = 0;
1698
1699 pw_t pw;
1700
1701 gidd_to_pw_t (device_param, gidd, &pw);
1702
1703 for (int i = 0, j = gidm; i < 16; i++, j++)
1704 {
1705 plain_buf[i] = pw.hi1[0][j];
1706 }
1707
1708 plain_len = pw.pw_len;
1709
1710 const uint off = device_param->innerloop_pos + il_pos;
1711
1712 if (debug_mode > 0)
1713 {
1714 debug_rule_len = 0;
1715
1716 // save rule
1717 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1718 {
1719 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1720
1721 debug_rule_len = gpu_rule_to_cpu_rule (debug_rule_buf, &data.gpu_rules_buf[off]);
1722 }
1723
1724 // save plain
1725 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1726 {
1727 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1728
1729 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1730
1731 debug_plain_len = plain_len;
1732 }
1733 }
1734
1735 plain_len = apply_rules (data.gpu_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1736
1737 crackpos += gidvid;
1738 crackpos *= data.gpu_rules_cnt;
1739 crackpos += device_param->innerloop_pos + il_pos;
1740
1741 if (plain_len > data.pw_max) plain_len = data.pw_max;
1742 }
1743 else if (data.attack_mode == ATTACK_MODE_COMBI)
1744 {
1745 uint64_t gidd = gidvid;
1746 uint64_t gidm = 0;
1747
1748 pw_t pw;
1749
1750 gidd_to_pw_t (device_param, gidd, &pw);
1751
1752 for (int i = 0, j = gidm; i < 16; i++, j++)
1753 {
1754 plain_buf[i] = pw.hi1[0][j];
1755 }
1756
1757 plain_len = pw.pw_len;
1758
1759 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1760 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1761
1762 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1763 {
1764 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1765 }
1766 else
1767 {
1768 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1769
1770 memcpy (plain_ptr, comb_buf, comb_len);
1771 }
1772
1773 plain_len += comb_len;
1774
1775 crackpos += gidvid;
1776 crackpos *= data.combs_cnt;
1777 crackpos += device_param->innerloop_pos + il_pos;
1778
1779 if (data.pw_max != PW_DICTMAX1)
1780 {
1781 if (plain_len > data.pw_max) plain_len = data.pw_max;
1782 }
1783 }
1784 else if (data.attack_mode == ATTACK_MODE_BF)
1785 {
1786 uint64_t l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1787 uint64_t r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1788
1789 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1790 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1791
1792 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1793 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1794
1795 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1796 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1797
1798 plain_len = data.css_cnt;
1799
1800 crackpos += gidvid;
1801 crackpos *= data.bfs_cnt;
1802 crackpos += device_param->innerloop_pos + il_pos;
1803 }
1804 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1805 {
1806 uint64_t gidd = gidvid;
1807 uint64_t gidm = 0;
1808
1809 pw_t pw;
1810
1811 gidd_to_pw_t (device_param, gidd, &pw);
1812
1813 for (int i = 0, j = gidm; i < 16; i++, j++)
1814 {
1815 plain_buf[i] = pw.hi1[0][j];
1816 }
1817
1818 plain_len = pw.pw_len;
1819
1820 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1821
1822 uint start = 0;
1823 uint stop = device_param->kernel_params_mp_buf32[4];
1824
1825 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1826
1827 plain_len += start + stop;
1828
1829 crackpos += gidvid;
1830 crackpos *= data.combs_cnt;
1831 crackpos += device_param->innerloop_pos + il_pos;
1832
1833 if (data.pw_max != PW_DICTMAX1)
1834 {
1835 if (plain_len > data.pw_max) plain_len = data.pw_max;
1836 }
1837 }
1838 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1839 {
1840 uint64_t gidd = gidvid;
1841 uint64_t gidm = 0;
1842
1843 pw_t pw;
1844
1845 gidd_to_pw_t (device_param, gidd, &pw);
1846
1847 for (int i = 0, j = gidm; i < 16; i++, j++)
1848 {
1849 plain_buf[i] = pw.hi1[0][j];
1850 }
1851
1852 plain_len = pw.pw_len;
1853
1854 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1855
1856 uint start = 0;
1857 uint stop = device_param->kernel_params_mp_buf32[4];
1858
1859 memmove (plain_ptr + stop, plain_ptr, plain_len);
1860
1861 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
1862
1863 plain_len += start + stop;
1864
1865 crackpos += gidvid;
1866 crackpos *= data.combs_cnt;
1867 crackpos += device_param->innerloop_pos + il_pos;
1868
1869 if (data.pw_max != PW_DICTMAX1)
1870 {
1871 if (plain_len > data.pw_max) plain_len = data.pw_max;
1872 }
1873 }
1874
1875 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
1876 {
1877 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1878 {
1879 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1880 {
1881 plain_len = plain_len - data.salts_buf[0].salt_len;
1882 }
1883 }
1884
1885 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
1886 {
1887 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
1888 {
1889 plain_ptr[j] = plain_ptr[i];
1890 }
1891
1892 plain_len = plain_len / 2;
1893 }
1894 }
1895
1896 // if enabled, update also the potfile
1897
1898 if (pot_fp)
1899 {
1900 fprintf (pot_fp, "%s:", out_buf);
1901
1902 format_plain (pot_fp, plain_ptr, plain_len, 1);
1903
1904 fputc ('\n', pot_fp);
1905
1906 fflush (pot_fp);
1907 }
1908
1909 // outfile
1910
1911 FILE *out_fp = NULL;
1912
1913 if (outfile != NULL)
1914 {
1915 if ((out_fp = fopen (outfile, "ab")) == NULL)
1916 {
1917 log_error ("ERROR: %s: %s", outfile, strerror (errno));
1918
1919 out_fp = stdout;
1920 }
1921 }
1922 else
1923 {
1924 out_fp = stdout;
1925
1926 if (quiet == 0) clear_prompt ();
1927 }
1928
1929 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
1930
1931 if (outfile != NULL)
1932 {
1933 if (out_fp != stdout)
1934 {
1935 fclose (out_fp);
1936 }
1937 }
1938 else
1939 {
1940 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1941 {
1942 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
1943 {
1944 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
1945 if (quiet == 0) fflush (stdout);
1946 }
1947 }
1948 }
1949
1950 // loopback
1951
1952 if (loopback)
1953 {
1954 char *loopback_file = data.loopback_file;
1955
1956 FILE *fb_fp = NULL;
1957
1958 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
1959 {
1960 format_plain (fb_fp, plain_ptr, plain_len, 1);
1961
1962 fputc ('\n', fb_fp);
1963
1964 fclose (fb_fp);
1965 }
1966 }
1967
1968 // (rule) debug mode
1969
1970 // the next check implies that:
1971 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
1972 // - debug_mode > 0
1973
1974 if ((debug_plain_len > 0) || (debug_rule_len > 0))
1975 {
1976 if (debug_rule_len < 0) debug_rule_len = 0;
1977
1978 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
1979
1980 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
1981
1982 if ((quiet == 0) && (debug_file == NULL))
1983 {
1984 fprintf (stdout, "%s", PROMPT);
1985 fflush (stdout);
1986 }
1987 }
1988 }
1989
1990 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
1991 {
1992 salt_t *salt_buf = &data.salts_buf[salt_pos];
1993
1994 int found = 0;
1995
1996 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
1997
1998 for (uint i = 0; i < GPU_THREADS; i++) if (device_param->result[i] == 1) found = 1;
1999
2000 if (found == 1)
2001 {
2002 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2003
2004 log_info_nn ("");
2005
2006 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2007
2008 uint cpt_cracked = 0;
2009
2010 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2011 {
2012 uint idx = salt_buf->digests_offset + digest_pos;
2013
2014 if (data.digests_shown_tmp[idx] == 0) continue;
2015
2016 if (data.digests_shown[idx] == 1) continue;
2017
2018 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2019 {
2020 data.digests_shown[idx] = 1;
2021
2022 data.digests_done++;
2023
2024 cpt_cracked++;
2025
2026 salt_buf->digests_done++;
2027
2028 if (salt_buf->digests_done == salt_buf->digests_cnt)
2029 {
2030 data.salts_shown[salt_pos] = 1;
2031
2032 data.salts_done++;
2033 }
2034 }
2035
2036 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2037
2038 check_hash (device_param, salt_pos, digest_pos);
2039 }
2040
2041 if (cpt_cracked > 0)
2042 {
2043 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2044 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2045
2046 data.cpt_pos++;
2047
2048 data.cpt_total += cpt_cracked;
2049
2050 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2051 }
2052
2053 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2054 {
2055 // we need to reset cracked state on the gpu
2056 // otherwise host thinks again and again the hash was cracked
2057 // and returns invalid password each time
2058
2059 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2060
2061 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2062 }
2063
2064 memset (device_param->result, 0, device_param->size_results);
2065
2066 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2067 }
2068 }
2069
2070 static void save_hash ()
2071 {
2072 char *hashfile = data.hashfile;
2073
2074 char new_hashfile[256];
2075 char old_hashfile[256];
2076
2077 memset (new_hashfile, 0, sizeof (new_hashfile));
2078 memset (old_hashfile, 0, sizeof (old_hashfile));
2079
2080 snprintf (new_hashfile, 255, "%s.new", hashfile);
2081 snprintf (old_hashfile, 255, "%s.old", hashfile);
2082
2083 unlink (new_hashfile);
2084
2085 char separator = data.separator;
2086
2087 FILE *fp = fopen (new_hashfile, "wb");
2088
2089 if (fp == NULL)
2090 {
2091 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2092
2093 exit (-1);
2094 }
2095
2096 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2097 {
2098 if (data.salts_shown[salt_pos] == 1) continue;
2099
2100 salt_t *salt_buf = &data.salts_buf[salt_pos];
2101
2102 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2103 {
2104 uint idx = salt_buf->digests_offset + digest_pos;
2105
2106 if (data.digests_shown[idx] == 1) continue;
2107
2108 if (data.hash_mode != 2500)
2109 {
2110 char out_buf[4096];
2111
2112 memset (out_buf, 0, sizeof (out_buf));
2113
2114 if (data.username == 1)
2115 {
2116 user_t *user = data.hash_info[idx]->user;
2117
2118 uint i;
2119
2120 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2121
2122 fputc (separator, fp);
2123 }
2124
2125 ascii_digest (out_buf, salt_pos, digest_pos);
2126
2127 fputs (out_buf, fp);
2128
2129 log_out (fp, "");
2130 }
2131 else
2132 {
2133 hccap_t hccap;
2134
2135 to_hccap_t (&hccap, salt_pos, digest_pos);
2136
2137 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2138 }
2139 }
2140 }
2141
2142 fflush (fp);
2143
2144 fclose (fp);
2145
2146 unlink (old_hashfile);
2147
2148 if (rename (hashfile, old_hashfile) != 0)
2149 {
2150 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2151
2152 exit (-1);
2153 }
2154
2155 unlink (hashfile);
2156
2157 if (rename (new_hashfile, hashfile) != 0)
2158 {
2159 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2160
2161 exit (-1);
2162 }
2163
2164 unlink (old_hashfile);
2165 }
2166
2167 static float find_gpu_blocks_div (const uint64_t total_left, const uint gpu_blocks_all)
2168 {
2169 // function called only in case gpu_blocks_all > words_left)
2170
2171 float gpu_blocks_div = (float) (total_left) / gpu_blocks_all;
2172
2173 gpu_blocks_div += gpu_blocks_div / 100;
2174
2175 uint32_t gpu_blocks_new = (uint32_t) (gpu_blocks_all * gpu_blocks_div);
2176
2177 while (gpu_blocks_new < total_left)
2178 {
2179 gpu_blocks_div += gpu_blocks_div / 100;
2180
2181 gpu_blocks_new = (uint32_t) (gpu_blocks_all * gpu_blocks_div);
2182 }
2183
2184 if (data.quiet == 0)
2185 {
2186 clear_prompt ();
2187
2188 log_info ("");
2189
2190 log_info ("INFO: approaching final keyspace, workload adjusted");
2191
2192 log_info ("");
2193
2194 fprintf (stdout, "%s", PROMPT);
2195
2196 fflush (stdout);
2197 }
2198
2199 if ((gpu_blocks_all * gpu_blocks_div) < 8) return 1;
2200
2201 return gpu_blocks_div;
2202 }
2203
2204 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2205 {
2206 uint num_elements = num;
2207
2208 device_param->kernel_params_buf32[30] = data.combs_mode;
2209 device_param->kernel_params_buf32[31] = num;
2210
2211 uint gpu_threads = device_param->gpu_threads;
2212
2213 while (num_elements % gpu_threads) num_elements++;
2214
2215 cl_kernel kernel = NULL;
2216
2217 switch (kern_run)
2218 {
2219 case KERN_RUN_1: kernel = device_param->kernel1; break;
2220 case KERN_RUN_12: kernel = device_param->kernel12; break;
2221 case KERN_RUN_2: kernel = device_param->kernel2; break;
2222 case KERN_RUN_23: kernel = device_param->kernel23; break;
2223 case KERN_RUN_3: kernel = device_param->kernel3; break;
2224 }
2225
2226 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2227 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2228 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2229 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2230 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2231 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2232 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2233 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2234 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2235 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2236 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2237
2238 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2239 {
2240 const size_t global_work_size[3] = { num_elements, 32, 1 };
2241 const size_t local_work_size[3] = { gpu_threads / 32, 32, 1 };
2242
2243 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2244 }
2245 else
2246 {
2247 const size_t global_work_size[3] = { num_elements, 1, 1 };
2248 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2249
2250 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2251 }
2252
2253 hc_clFlush (device_param->command_queue);
2254
2255 hc_clFinish (device_param->command_queue);
2256 }
2257
2258 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2259 {
2260 uint num_elements = num;
2261
2262 switch (kern_run)
2263 {
2264 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2265 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2266 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2267 }
2268
2269 // causes problems with special threads like in bcrypt
2270 // const uint gpu_threads = device_param->gpu_threads;
2271
2272 const uint gpu_threads = GPU_THREADS;
2273
2274 while (num_elements % gpu_threads) num_elements++;
2275
2276 cl_kernel kernel = NULL;
2277
2278 switch (kern_run)
2279 {
2280 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2281 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2282 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2283 }
2284
2285 switch (kern_run)
2286 {
2287 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2288 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2289 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2290 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2291 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2292 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2293 break;
2294 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2295 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2296 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2297 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2298 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2299 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2300 break;
2301 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2302 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2303 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2304 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2305 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2306 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2307 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2308 break;
2309 }
2310
2311 const size_t global_work_size[3] = { num_elements, 1, 1 };
2312 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2313
2314 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2315
2316 hc_clFlush (device_param->command_queue);
2317
2318 hc_clFinish (device_param->command_queue);
2319 }
2320
2321 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2322 {
2323 uint num_elements = num;
2324
2325 uint gpu_threads = device_param->gpu_threads;
2326
2327 while (num_elements % gpu_threads) num_elements++;
2328
2329 cl_kernel kernel = device_param->kernel_tb;
2330
2331 const size_t global_work_size[3] = { num_elements, 1, 1 };
2332 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2333
2334 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2335
2336 hc_clFlush (device_param->command_queue);
2337
2338 hc_clFinish (device_param->command_queue);
2339 }
2340
2341 static void run_kernel_tm (hc_device_param_t *device_param)
2342 {
2343 const uint num_elements = 1024; // fixed
2344
2345 const uint gpu_threads = 32;
2346
2347 cl_kernel kernel = device_param->kernel_tm;
2348
2349 const size_t global_work_size[3] = { num_elements, 1, 1 };
2350 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2351
2352 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2353
2354 hc_clFlush (device_param->command_queue);
2355
2356 hc_clFinish (device_param->command_queue);
2357 }
2358
2359 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2360 {
2361 uint num_elements = num;
2362
2363 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2364 device_param->kernel_params_amp_buf32[6] = num_elements;
2365
2366 // causes problems with special threads like in bcrypt
2367 // const uint gpu_threads = device_param->gpu_threads;
2368
2369 const uint gpu_threads = GPU_THREADS;
2370
2371 while (num_elements % gpu_threads) num_elements++;
2372
2373 cl_kernel kernel = device_param->kernel_amp;
2374
2375 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2376 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2377
2378 const size_t global_work_size[3] = { num_elements, 1, 1 };
2379 const size_t local_work_size[3] = { gpu_threads, 1, 1 };
2380
2381 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2382
2383 hc_clFlush (device_param->command_queue);
2384
2385 hc_clFinish (device_param->command_queue);
2386 }
2387
2388 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2389 {
2390 // not supported with Nvidia
2391 // hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2392
2393 char *tmp = (char *) mymalloc (size);
2394
2395 memset (tmp, 0, size);
2396
2397 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, 0, size, tmp, 0, NULL, NULL);
2398
2399 free (tmp);
2400 }
2401
2402 static int run_rule_engine (const int rule_len, const char *rule_buf)
2403 {
2404 if (rule_len == 0)
2405 {
2406 return 0;
2407 }
2408 else if (rule_len == 1)
2409 {
2410 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2411 }
2412
2413 return 1;
2414 }
2415
2416 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2417 {
2418 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2419 {
2420 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2421 }
2422 else if (data.attack_kern == ATTACK_KERN_COMBI)
2423 {
2424 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2425 }
2426 else if (data.attack_kern == ATTACK_KERN_BF)
2427 {
2428 const uint64_t off = device_param->words_off;
2429
2430 device_param->kernel_params_mp_l_buf64[3] = off;
2431
2432 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2433 }
2434 }
2435
2436 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2437 {
2438 const uint gpu_loops = data.gpu_loops;
2439
2440 // init speed timer
2441
2442 uint speed_pos = device_param->speed_pos;
2443
2444 #ifdef _POSIX
2445 if (device_param->timer_speed.tv_sec == 0)
2446 {
2447 hc_timer_set (&device_param->timer_speed);
2448 }
2449 #endif
2450
2451 #ifdef _WIN
2452 if (device_param->timer_speed.QuadPart == 0)
2453 {
2454 hc_timer_set (&device_param->timer_speed);
2455 }
2456 #endif
2457
2458 // find higest password length, this is for optimization stuff
2459
2460 uint highest_pw_len = 0;
2461
2462 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2463 {
2464 }
2465 else if (data.attack_kern == ATTACK_KERN_COMBI)
2466 {
2467 }
2468 else if (data.attack_kern == ATTACK_KERN_BF)
2469 {
2470 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2471 + device_param->kernel_params_mp_l_buf32[5];
2472 }
2473
2474 // bitslice optimization stuff
2475
2476 if (data.attack_mode == ATTACK_MODE_BF)
2477 {
2478 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2479 {
2480 run_kernel_tb (device_param, pws_cnt);
2481 }
2482 }
2483
2484 // iteration type
2485
2486 uint innerloop_step = 0;
2487 uint innerloop_cnt = 0;
2488
2489 if (data.attack_exec == ATTACK_EXEC_ON_GPU) innerloop_step = gpu_loops;
2490 else innerloop_step = 1;
2491
2492 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.gpu_rules_cnt;
2493 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2494 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2495
2496 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2497
2498 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2499 {
2500 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2501
2502 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2503
2504 if (data.devices_status == STATUS_CRACKED) break;
2505 if (data.devices_status == STATUS_ABORTED) break;
2506 if (data.devices_status == STATUS_QUIT) break;
2507 if (data.devices_status == STATUS_BYPASS) break;
2508
2509 if (data.salts_shown[salt_pos] == 1) continue;
2510
2511 salt_t *salt_buf = &data.salts_buf[salt_pos];
2512
2513 device_param->kernel_params_buf32[24] = salt_pos;
2514 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2515 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2516
2517 FILE *combs_fp = device_param->combs_fp;
2518
2519 if (data.attack_mode == ATTACK_MODE_COMBI)
2520 {
2521 rewind (combs_fp);
2522 }
2523
2524 // innerloops
2525
2526 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2527 {
2528 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2529
2530 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2531
2532 if (data.devices_status == STATUS_CRACKED) break;
2533 if (data.devices_status == STATUS_ABORTED) break;
2534 if (data.devices_status == STATUS_QUIT) break;
2535 if (data.devices_status == STATUS_BYPASS) break;
2536
2537 uint innerloop_left = innerloop_cnt - innerloop_pos;
2538
2539 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2540
2541 device_param->innerloop_pos = innerloop_pos;
2542 device_param->innerloop_left = innerloop_left;
2543
2544 device_param->kernel_params_buf32[27] = innerloop_left;
2545
2546 if (innerloop_left == 0) continue;
2547
2548 // initialize amplifiers
2549
2550 if (data.attack_mode == ATTACK_MODE_COMBI)
2551 {
2552 char line_buf[BUFSIZ];
2553
2554 uint i = 0;
2555
2556 while (i < innerloop_left)
2557 {
2558 if (feof (combs_fp)) break;
2559
2560 int line_len = fgetl (combs_fp, line_buf);
2561
2562 if (line_len >= PW_MAX1) continue;
2563
2564 line_len = convert_from_hex (line_buf, line_len);
2565
2566 char *line_buf_new = line_buf;
2567
2568 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2569 {
2570 char rule_buf_out[BLOCK_SIZE];
2571
2572 memset (rule_buf_out, 0, sizeof (rule_buf_out));
2573
2574 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2575
2576 if (rule_len_out < 0)
2577 {
2578 data.words_progress_rejected[salt_pos] += pw_cnt;
2579
2580 continue;
2581 }
2582
2583 line_len = rule_len_out;
2584
2585 line_buf_new = rule_buf_out;
2586 }
2587
2588 line_len = MIN (line_len, PW_DICTMAX);
2589
2590 char *ptr = (char *) device_param->combs_buf[i].i;
2591
2592 memcpy (ptr, line_buf_new, line_len);
2593
2594 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2595
2596 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2597 {
2598 uppercase (ptr, line_len);
2599 }
2600
2601 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2602 {
2603 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2604 {
2605 ptr[line_len] = 0x80;
2606 }
2607
2608 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2609 {
2610 ptr[line_len] = 0x01;
2611 }
2612 }
2613
2614 device_param->combs_buf[i].pw_len = line_len;
2615
2616 i++;
2617 }
2618
2619 for (uint j = i; j < innerloop_left; j++)
2620 {
2621 device_param->combs_buf[j].i[0] = 0;
2622 device_param->combs_buf[j].i[1] = 0;
2623 device_param->combs_buf[j].i[2] = 0;
2624 device_param->combs_buf[j].i[3] = 0;
2625 device_param->combs_buf[j].i[4] = 0;
2626 device_param->combs_buf[j].i[5] = 0;
2627 device_param->combs_buf[j].i[6] = 0;
2628 device_param->combs_buf[j].i[7] = 0;
2629
2630 device_param->combs_buf[j].pw_len = 0;
2631 }
2632
2633 innerloop_left = i;
2634 }
2635 else if (data.attack_mode == ATTACK_MODE_BF)
2636 {
2637 uint64_t off = innerloop_pos;
2638
2639 device_param->kernel_params_mp_r_buf64[3] = off;
2640
2641 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2642 }
2643 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2644 {
2645 uint64_t off = innerloop_pos;
2646
2647 device_param->kernel_params_mp_buf64[3] = off;
2648
2649 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2650 }
2651 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2652 {
2653 uint64_t off = innerloop_pos;
2654
2655 device_param->kernel_params_mp_buf64[3] = off;
2656
2657 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2658 }
2659
2660 // copy amplifiers
2661
2662 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2663 {
2664 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (gpu_rule_t), 0, innerloop_left * sizeof (gpu_rule_t), 0, NULL, NULL);
2665 }
2666 else if (data.attack_mode == ATTACK_MODE_COMBI)
2667 {
2668 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
2669 }
2670 else if (data.attack_mode == ATTACK_MODE_BF)
2671 {
2672 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
2673 }
2674 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2675 {
2676 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2677 }
2678 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2679 {
2680 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2681 }
2682
2683 if (data.attack_exec == ATTACK_EXEC_ON_GPU)
2684 {
2685 if (data.attack_mode == ATTACK_MODE_BF)
2686 {
2687 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2688 {
2689 const uint size_tm = 32 * sizeof (bs_word_t);
2690
2691 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2692
2693 run_kernel_tm (device_param);
2694
2695 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2696 }
2697 }
2698
2699 if (highest_pw_len < 16)
2700 {
2701 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2702 }
2703 else if (highest_pw_len < 32)
2704 {
2705 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2706 }
2707 else
2708 {
2709 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2710 }
2711 }
2712 else
2713 {
2714 run_kernel_amp (device_param, pws_cnt);
2715
2716 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2717
2718 if (data.opts_type & OPTS_TYPE_HOOK12)
2719 {
2720 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2721 }
2722
2723 uint iter = salt_buf->salt_iter;
2724
2725 for (uint loop_pos = 0; loop_pos < iter; loop_pos += gpu_loops)
2726 {
2727 uint loop_left = iter - loop_pos;
2728
2729 loop_left = MIN (loop_left, gpu_loops);
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);
2735
2736 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2737
2738 if (data.devices_status == STATUS_CRACKED) break;
2739 if (data.devices_status == STATUS_ABORTED) break;
2740 if (data.devices_status == STATUS_QUIT) break;
2741 }
2742
2743 if (data.opts_type & OPTS_TYPE_HOOK23)
2744 {
2745 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2746
2747 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2748
2749 // do something with data
2750
2751 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2752 }
2753
2754 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2755 }
2756
2757 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2758
2759 if (data.devices_status == STATUS_CRACKED) break;
2760 if (data.devices_status == STATUS_ABORTED) break;
2761 if (data.devices_status == STATUS_QUIT) break;
2762
2763 /**
2764 * result
2765 */
2766
2767 hc_thread_mutex_lock (mux_display);
2768
2769 check_cracked (device_param, salt_pos);
2770
2771 hc_thread_mutex_unlock (mux_display);
2772
2773 /**
2774 * progress
2775 */
2776
2777 uint64_t perf_sum_all = (uint64_t) pw_cnt * (uint64_t) innerloop_left;
2778
2779 hc_thread_mutex_lock (mux_counter);
2780
2781 data.words_progress_done[salt_pos] += perf_sum_all;
2782
2783 hc_thread_mutex_unlock (mux_counter);
2784
2785 /**
2786 * speed
2787 */
2788
2789 float speed_ms;
2790
2791 hc_timer_get (device_param->timer_speed, speed_ms);
2792
2793 hc_timer_set (&device_param->timer_speed);
2794
2795 hc_thread_mutex_lock (mux_display);
2796
2797 device_param->speed_cnt[speed_pos] = perf_sum_all;
2798
2799 device_param->speed_ms[speed_pos] = speed_ms;
2800
2801 device_param->speed_rec[speed_pos] = device_param->timer_speed;
2802
2803 hc_thread_mutex_unlock (mux_display);
2804
2805 speed_pos++;
2806
2807 if (speed_pos == SPEED_CACHE)
2808 {
2809 speed_pos = 0;
2810 }
2811 }
2812 }
2813
2814 device_param->speed_pos = speed_pos;
2815 }
2816
2817 static void load_segment (wl_data_t *wl_data, FILE *fd)
2818 {
2819 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
2820
2821 wl_data->pos = 0;
2822
2823 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
2824
2825 wl_data->buf[wl_data->cnt] = 0;
2826
2827 if (wl_data->cnt == 0) return;
2828
2829 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
2830
2831 while (!feof (fd))
2832 {
2833 if (wl_data->cnt == wl_data->avail)
2834 {
2835 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
2836
2837 wl_data->avail += wl_data->incr;
2838 }
2839
2840 const int c = fgetc (fd);
2841
2842 if (c == EOF) break;
2843
2844 wl_data->buf[wl_data->cnt] = (char) c;
2845
2846 wl_data->cnt++;
2847
2848 if (c == '\n') break;
2849 }
2850
2851 // ensure stream ends with a newline
2852
2853 if (wl_data->buf[wl_data->cnt - 1] != '\n')
2854 {
2855 wl_data->cnt++;
2856
2857 wl_data->buf[wl_data->cnt - 1] = '\n';
2858 }
2859
2860 return;
2861 }
2862
2863 static void get_next_word_lm (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
2864 {
2865 char *ptr = buf;
2866
2867 for (uint32_t i = 0; i < sz; i++, ptr++)
2868 {
2869 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
2870
2871 if (i == 7)
2872 {
2873 *off = i;
2874 *len = i;
2875
2876 return;
2877 }
2878
2879 if (*ptr != '\n') continue;
2880
2881 *off = i + 1;
2882
2883 if ((i > 0) && (buf[i - 1] == '\r')) i--;
2884
2885 *len = i;
2886
2887 return;
2888 }
2889
2890 *off = sz;
2891 *len = sz;
2892 }
2893
2894 static void get_next_word_uc (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
2895 {
2896 char *ptr = buf;
2897
2898 for (uint32_t i = 0; i < sz; i++, ptr++)
2899 {
2900 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
2901
2902 if (*ptr != '\n') continue;
2903
2904 *off = i + 1;
2905
2906 if ((i > 0) && (buf[i - 1] == '\r')) i--;
2907
2908 *len = i;
2909
2910 return;
2911 }
2912
2913 *off = sz;
2914 *len = sz;
2915 }
2916
2917 static void get_next_word_std (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
2918 {
2919 char *ptr = buf;
2920
2921 for (uint32_t i = 0; i < sz; i++, ptr++)
2922 {
2923 if (*ptr != '\n') continue;
2924
2925 *off = i + 1;
2926
2927 if ((i > 0) && (buf[i - 1] == '\r')) i--;
2928
2929 *len = i;
2930
2931 return;
2932 }
2933
2934 *off = sz;
2935 *len = sz;
2936 }
2937
2938 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
2939 {
2940 while (wl_data->pos < wl_data->cnt)
2941 {
2942 uint off;
2943 uint len;
2944
2945 char *ptr = wl_data->buf + wl_data->pos;
2946
2947 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
2948
2949 wl_data->pos += off;
2950
2951 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
2952 {
2953 char rule_buf_out[BLOCK_SIZE];
2954
2955 memset (rule_buf_out, 0, sizeof (rule_buf_out));
2956
2957 int rule_len_out = -1;
2958
2959 if (len < BLOCK_SIZE)
2960 {
2961 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
2962 }
2963
2964 if (rule_len_out < 0)
2965 {
2966 continue;
2967 }
2968
2969 if (rule_len_out > PW_MAX)
2970 {
2971 continue;
2972 }
2973 }
2974 else
2975 {
2976 if (len > PW_MAX)
2977 {
2978 continue;
2979 }
2980 }
2981
2982 *out_buf = ptr;
2983 *out_len = len;
2984
2985 return;
2986 }
2987
2988 if (feof (fd))
2989 {
2990 fprintf (stderr, "bug!!\n");
2991
2992 return;
2993 }
2994
2995 load_segment (wl_data, fd);
2996
2997 get_next_word (wl_data, fd, out_buf, out_len);
2998 }
2999
3000 #ifdef _POSIX
3001 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3002 #endif
3003
3004 #ifdef _WIN
3005 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3006 #endif
3007 {
3008 hc_signal (NULL);
3009
3010 dictstat_t d;
3011
3012 d.cnt = 0;
3013
3014 #ifdef _POSIX
3015 fstat (fileno (fd), &d.stat);
3016 #endif
3017
3018 #ifdef _WIN
3019 _fstat64 (fileno (fd), &d.stat);
3020 #endif
3021
3022 d.stat.st_mode = 0;
3023 d.stat.st_nlink = 0;
3024 d.stat.st_uid = 0;
3025 d.stat.st_gid = 0;
3026 d.stat.st_rdev = 0;
3027 d.stat.st_atime = 0;
3028
3029 #ifdef _POSIX
3030 d.stat.st_blksize = 0;
3031 d.stat.st_blocks = 0;
3032 #endif
3033
3034 if (d.stat.st_size == 0) return 0;
3035
3036 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3037
3038 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3039 {
3040 if (d_cache)
3041 {
3042 uint64_t cnt = d_cache->cnt;
3043
3044 uint64_t keyspace = cnt;
3045
3046 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3047 {
3048 keyspace *= data.gpu_rules_cnt;
3049 }
3050 else if (data.attack_kern == ATTACK_KERN_COMBI)
3051 {
3052 keyspace *= data.combs_cnt;
3053 }
3054
3055 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);
3056 if (data.quiet == 0) log_info ("");
3057
3058 hc_signal (sigHandler_default);
3059
3060 return (keyspace);
3061 }
3062 }
3063
3064 time_t now = 0;
3065 time_t prev = 0;
3066
3067 uint64_t comp = 0;
3068 uint64_t cnt = 0;
3069 uint64_t cnt2 = 0;
3070
3071 while (!feof (fd))
3072 {
3073 load_segment (wl_data, fd);
3074
3075 comp += wl_data->cnt;
3076
3077 uint32_t i = 0;
3078
3079 while (i < wl_data->cnt)
3080 {
3081 uint32_t len;
3082 uint32_t off;
3083
3084 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3085
3086 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3087 {
3088 char rule_buf_out[BLOCK_SIZE];
3089
3090 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3091
3092 int rule_len_out = -1;
3093
3094 if (len < BLOCK_SIZE)
3095 {
3096 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3097 }
3098
3099 if (rule_len_out < 0)
3100 {
3101 len = PW_MAX1;
3102 }
3103 else
3104 {
3105 len = rule_len_out;
3106 }
3107 }
3108
3109 if (len < PW_MAX1)
3110 {
3111 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3112 {
3113 cnt += data.gpu_rules_cnt;
3114 }
3115 else if (data.attack_kern == ATTACK_KERN_COMBI)
3116 {
3117 cnt += data.combs_cnt;
3118 }
3119
3120 d.cnt++;
3121 }
3122
3123 i += off;
3124
3125 cnt2++;
3126 }
3127
3128 time (&now);
3129
3130 if ((now - prev) == 0) continue;
3131
3132 float percent = (float) comp / (float) d.stat.st_size;
3133
3134 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);
3135
3136 time (&prev);
3137 }
3138
3139 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);
3140 if (data.quiet == 0) log_info ("");
3141
3142 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3143
3144 hc_signal (sigHandler_default);
3145
3146 return (cnt);
3147 }
3148
3149 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3150 {
3151 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3152 }
3153
3154 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const uint8_t *pw_buf, const uint pw_len)
3155 {
3156 if (data.devices_status == STATUS_BYPASS) return 0;
3157
3158 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3159
3160 uint cache_cnt = pw_cache->cnt;
3161
3162 uint8_t *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
3163
3164 memcpy (pw_hc1, pw_buf, pw_len);
3165
3166 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3167
3168 uint pws_cnt = device_param->pws_cnt;
3169
3170 cache_cnt++;
3171
3172 pw_t *pw = device_param->pws_buf + pws_cnt;
3173
3174 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3175
3176 pw->pw_len = pw_len;
3177
3178 pws_cnt++;
3179
3180 device_param->pws_cnt = pws_cnt;
3181 device_param->pw_cnt = pws_cnt * 1;
3182
3183 cache_cnt = 0;
3184
3185 pw_cache->cnt = cache_cnt;
3186
3187 return pws_cnt;
3188 }
3189
3190 static void *thread_monitor (void *p)
3191 {
3192 uint runtime_check = 0;
3193 uint remove_check = 0;
3194 uint status_check = 0;
3195 uint hwmon_check = 0;
3196 uint restore_check = 0;
3197
3198 uint restore_left = data.restore_timer;
3199 uint remove_left = data.remove_timer;
3200 uint status_left = data.status_timer;
3201
3202 // these variables are mainly used for fan control (AMD only)
3203
3204 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3205
3206 // temperature controller "loopback" values
3207
3208 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3209 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3210
3211 int temp_threshold = 1; // degrees celcius
3212
3213 int fan_speed_min = 15; // in percentage
3214 int fan_speed_max = 100;
3215
3216 time_t last_temp_check_time;
3217
3218 uint sleep_time = 1;
3219
3220 if (data.runtime)
3221 {
3222 runtime_check = 1;
3223 }
3224
3225 if (data.restore_timer)
3226 {
3227 restore_check = 1;
3228 }
3229
3230 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3231 {
3232 remove_check = 1;
3233 }
3234
3235 if (data.status == 1)
3236 {
3237 status_check = 1;
3238 }
3239
3240 if (data.gpu_temp_disable == 0)
3241 {
3242 time (&last_temp_check_time);
3243
3244 hwmon_check = 1;
3245 }
3246
3247 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (hwmon_check == 0) && (restore_check == 0))
3248 {
3249 return (p);
3250 }
3251
3252 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3253 {
3254 hc_sleep (sleep_time);
3255
3256 if (data.devices_status != STATUS_RUNNING) continue;
3257
3258 if (hwmon_check == 1)
3259 {
3260 hc_thread_mutex_lock (mux_adl);
3261
3262 time_t temp_check_time;
3263
3264 time (&temp_check_time);
3265
3266 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3267
3268 if (Ta == 0) Ta = 1;
3269
3270 for (uint i = 0; i < data.devices_cnt; i++)
3271 {
3272 const int temperature = hm_get_temperature_with_device_id (i);
3273
3274 if (temperature > (int) data.gpu_temp_abort)
3275 {
3276 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", i + 1);
3277
3278 if (data.devices_status != STATUS_QUIT) myabort ();
3279
3280 break;
3281 }
3282
3283 const int gpu_temp_retain = data.gpu_temp_retain;
3284
3285 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3286 {
3287 if (data.hm_device[i].fan_supported == 1)
3288 {
3289 int temp_cur = temperature;
3290
3291 int temp_diff_new = gpu_temp_retain - temp_cur;
3292
3293 temp_diff_sum[i] = temp_diff_sum[i] + temp_diff_new;
3294
3295 // calculate Ta value (time difference in seconds between the last check and this check)
3296
3297 last_temp_check_time = temp_check_time;
3298
3299 float Kp = 1.8;
3300 float Ki = 0.005;
3301 float Kd = 6;
3302
3303 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3304
3305 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[i] + Kd * ((float)(temp_diff_new - temp_diff_old[i])) / Ta);
3306
3307 if (abs (fan_diff_required) >= temp_threshold)
3308 {
3309 const int fan_speed_cur = hm_get_fanspeed_with_device_id (i);
3310
3311 int fan_speed_level = fan_speed_cur;
3312
3313 if (fan_speed_chgd[i] == 0) fan_speed_level = temp_cur;
3314
3315 int fan_speed_new = fan_speed_level - fan_diff_required;
3316
3317 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3318 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3319
3320 if (fan_speed_new != fan_speed_cur)
3321 {
3322 int freely_change_fan_speed = (fan_speed_chgd[i] == 1);
3323 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3324
3325 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3326 {
3327 hm_set_fanspeed_with_device_id_amd (i, fan_speed_new);
3328
3329 fan_speed_chgd[i] = 1;
3330 }
3331
3332 temp_diff_old[i] = temp_diff_new;
3333 }
3334 }
3335 }
3336 }
3337 }
3338
3339 hc_thread_mutex_unlock (mux_adl);
3340 }
3341
3342 if (restore_check == 1)
3343 {
3344 restore_left--;
3345
3346 if (restore_left == 0)
3347 {
3348 if (data.restore_disable == 0) cycle_restore ();
3349
3350 restore_left = data.restore_timer;
3351 }
3352 }
3353
3354 if ((runtime_check == 1) && (data.runtime_start > 0))
3355 {
3356 time_t runtime_cur;
3357
3358 time (&runtime_cur);
3359
3360 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3361
3362 if (runtime_left <= 0)
3363 {
3364 if (data.benchmark == 0)
3365 {
3366 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3367 }
3368
3369 if (data.devices_status != STATUS_QUIT) myabort ();
3370 }
3371 }
3372
3373 if (remove_check == 1)
3374 {
3375 remove_left--;
3376
3377 if (remove_left == 0)
3378 {
3379 if (data.digests_saved != data.digests_done)
3380 {
3381 data.digests_saved = data.digests_done;
3382
3383 save_hash ();
3384 }
3385
3386 remove_left = data.remove_timer;
3387 }
3388 }
3389
3390 if (status_check == 1)
3391 {
3392 status_left--;
3393
3394 if (status_left == 0)
3395 {
3396 hc_thread_mutex_lock (mux_display);
3397
3398 if (data.quiet == 0) clear_prompt ();
3399
3400 if (data.quiet == 0) log_info ("");
3401
3402 status_display ();
3403
3404 if (data.quiet == 0) log_info ("");
3405
3406 hc_thread_mutex_unlock (mux_display);
3407
3408 status_left = data.status_timer;
3409 }
3410 }
3411 }
3412
3413 myfree (fan_speed_chgd);
3414
3415 myfree (temp_diff_old);
3416 myfree (temp_diff_sum);
3417
3418 p = NULL;
3419
3420 return (p);
3421 }
3422
3423 static void *thread_outfile_remove (void *p)
3424 {
3425 // some hash-dependent constants
3426 char *outfile_dir = data.outfile_check_directory;
3427 uint dgst_size = data.dgst_size;
3428 uint isSalted = data.isSalted;
3429 uint esalt_size = data.esalt_size;
3430 uint hash_mode = data.hash_mode;
3431
3432 uint outfile_check_timer = data.outfile_check_timer;
3433
3434 char separator = data.separator;
3435
3436 // some hash-dependent functions
3437 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3438 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3439
3440 // buffers
3441 hash_t hash_buf;
3442
3443 memset (&hash_buf, 0, sizeof (hash_buf));
3444
3445 hash_buf.digest = mymalloc (dgst_size);
3446
3447 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3448
3449 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3450
3451 uint digest_buf[64];
3452
3453 outfile_data_t *out_info = NULL;
3454
3455 char **out_files = NULL;
3456
3457 time_t folder_mtime = 0;
3458
3459 int out_cnt = 0;
3460
3461 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3462
3463 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3464 {
3465 hc_sleep (1);
3466
3467 if (data.devices_status != STATUS_RUNNING) continue;
3468
3469 check_left--;
3470
3471 if (check_left == 0)
3472 {
3473 struct stat outfile_check_stat;
3474
3475 if (stat (outfile_dir, &outfile_check_stat) == 0)
3476 {
3477 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3478
3479 if (is_dir == 1)
3480 {
3481 if (outfile_check_stat.st_mtime > folder_mtime)
3482 {
3483 char **out_files_new = scan_directory (outfile_dir);
3484
3485 int out_cnt_new = count_dictionaries (out_files_new);
3486
3487 outfile_data_t *out_info_new = NULL;
3488
3489 if (out_cnt_new > 0)
3490 {
3491 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3492
3493 for (int i = 0; i < out_cnt_new; i++)
3494 {
3495 out_info_new[i].file_name = out_files_new[i];
3496
3497 // check if there are files that we have seen/checked before (and not changed)
3498
3499 for (int j = 0; j < out_cnt; j++)
3500 {
3501 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3502 {
3503 struct stat outfile_stat;
3504
3505 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3506 {
3507 if (outfile_stat.st_ctime == out_info[j].ctime)
3508 {
3509 out_info_new[i].ctime = out_info[j].ctime;
3510 out_info_new[i].seek = out_info[j].seek;
3511 }
3512 }
3513 }
3514 }
3515 }
3516 }
3517
3518 local_free (out_info);
3519 local_free (out_files);
3520
3521 out_files = out_files_new;
3522 out_cnt = out_cnt_new;
3523 out_info = out_info_new;
3524
3525 folder_mtime = outfile_check_stat.st_mtime;
3526 }
3527
3528 for (int j = 0; j < out_cnt; j++)
3529 {
3530 FILE *fp = fopen (out_info[j].file_name, "rb");
3531
3532 if (fp != NULL)
3533 {
3534 //hc_thread_mutex_lock (mux_display);
3535
3536 #ifdef _POSIX
3537 struct stat outfile_stat;
3538
3539 fstat (fileno (fp), &outfile_stat);
3540 #endif
3541
3542 #ifdef _WIN
3543 struct stat64 outfile_stat;
3544
3545 _fstat64 (fileno (fp), &outfile_stat);
3546 #endif
3547
3548 if (outfile_stat.st_ctime > out_info[j].ctime)
3549 {
3550 out_info[j].ctime = outfile_stat.st_ctime;
3551 out_info[j].seek = 0;
3552 }
3553
3554 fseek (fp, out_info[j].seek, SEEK_SET);
3555
3556 while (!feof (fp))
3557 {
3558 char line_buf[BUFSIZ];
3559
3560 memset (line_buf, 0, BUFSIZ);
3561
3562 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3563
3564 if (ptr == NULL) break;
3565
3566 int line_len = strlen (line_buf);
3567
3568 if (line_len <= 0) continue;
3569
3570 int iter = MAX_CUT_TRIES;
3571
3572 for (uint i = line_len - 1; i && iter; i--, line_len--)
3573 {
3574 if (line_buf[i] != separator) continue;
3575
3576 int parser_status = PARSER_OK;
3577
3578 if ((hash_mode != 2500) && (hash_mode != 6800))
3579 {
3580 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3581 }
3582
3583 uint found = 0;
3584
3585 if (parser_status == PARSER_OK)
3586 {
3587 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3588 {
3589 if (data.salts_shown[salt_pos] == 1) continue;
3590
3591 salt_t *salt_buf = &data.salts_buf[salt_pos];
3592
3593 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3594 {
3595 uint idx = salt_buf->digests_offset + digest_pos;
3596
3597 if (data.digests_shown[idx] == 1) continue;
3598
3599 uint cracked = 0;
3600
3601 if (hash_mode == 6800)
3602 {
3603 if (i == salt_buf->salt_len)
3604 {
3605 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3606 }
3607 }
3608 else if (hash_mode == 2500)
3609 {
3610 // BSSID : MAC1 : MAC2 (:plain)
3611 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3612 {
3613 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3614
3615 if (!cracked) continue;
3616
3617 // now compare MAC1 and MAC2 too, since we have this additional info
3618 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3619 char *mac2_pos = mac1_pos + 12 + 1;
3620
3621 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3622 wpa_t *wpa = &wpas[salt_pos];
3623
3624 uint pke[25];
3625
3626 char *pke_ptr = (char *) pke;
3627
3628 for (uint i = 0; i < 25; i++)
3629 {
3630 pke[i] = byte_swap_32 (wpa->pke[i]);
3631 }
3632
3633 unsigned char mac1[6];
3634 unsigned char mac2[6];
3635
3636 memcpy (mac1, pke_ptr + 23, 6);
3637 memcpy (mac2, pke_ptr + 29, 6);
3638
3639 // compare hex string(s) vs binary MAC address(es)
3640
3641 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3642 {
3643 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
3644 {
3645 cracked = 0;
3646 break;
3647 }
3648 }
3649
3650 // early skip ;)
3651 if (!cracked) continue;
3652
3653 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3654 {
3655 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
3656 {
3657 cracked = 0;
3658 break;
3659 }
3660 }
3661 }
3662 }
3663 else
3664 {
3665 char *digests_buf_ptr = (char *) data.digests_buf;
3666
3667 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3668
3669 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3670 }
3671
3672 if (cracked == 1)
3673 {
3674 found = 1;
3675
3676 data.digests_shown[idx] = 1;
3677
3678 data.digests_done++;
3679
3680 salt_buf->digests_done++;
3681
3682 if (salt_buf->digests_done == salt_buf->digests_cnt)
3683 {
3684 data.salts_shown[salt_pos] = 1;
3685
3686 data.salts_done++;
3687
3688 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3689 }
3690 }
3691 }
3692
3693 if (data.devices_status == STATUS_CRACKED) break;
3694 }
3695 }
3696
3697 if (found) break;
3698
3699 if (data.devices_status == STATUS_CRACKED) break;
3700
3701 iter--;
3702 }
3703
3704 if (data.devices_status == STATUS_CRACKED) break;
3705 }
3706
3707 out_info[j].seek = ftell (fp);
3708
3709 //hc_thread_mutex_unlock (mux_display);
3710
3711 fclose (fp);
3712 }
3713 }
3714 }
3715 }
3716
3717 check_left = outfile_check_timer;
3718 }
3719 }
3720
3721 if (esalt_size) local_free (hash_buf.esalt);
3722
3723 if (isSalted) local_free (hash_buf.salt);
3724
3725 local_free (hash_buf.digest);
3726
3727 local_free (out_info);
3728
3729 local_free (out_files);
3730
3731 p = NULL;
3732
3733 return (p);
3734 }
3735
3736 static uint get_work (hc_device_param_t *device_param, const uint64_t max)
3737 {
3738 hc_thread_mutex_lock (mux_dispatcher);
3739
3740 const uint64_t words_cur = data.words_cur;
3741 const uint64_t words_base = (data.limit == 0) ? data.words_base : data.limit;
3742
3743 device_param->words_off = words_cur;
3744
3745 const uint64_t words_left = words_base - words_cur;
3746
3747 if (data.gpu_blocks_all > words_left)
3748 {
3749 if (data.gpu_blocks_div == 0)
3750 {
3751 data.gpu_blocks_div = find_gpu_blocks_div (words_left, data.gpu_blocks_all);
3752 }
3753 }
3754
3755 if (data.gpu_blocks_div)
3756 {
3757 if (device_param->gpu_blocks == device_param->gpu_blocks_user)
3758 {
3759 const uint32_t gpu_blocks_new = (float) device_param->gpu_blocks * data.gpu_blocks_div;
3760 const uint32_t gpu_power_new = gpu_blocks_new;
3761
3762 if (gpu_blocks_new < device_param->gpu_blocks)
3763 {
3764 device_param->gpu_blocks = gpu_blocks_new;
3765 device_param->gpu_power = gpu_power_new;
3766 }
3767 }
3768 }
3769
3770 const uint gpu_blocks = device_param->gpu_blocks;
3771
3772 uint work = MIN (words_left, gpu_blocks);
3773
3774 work = MIN (work, max);
3775
3776 data.words_cur += work;
3777
3778 hc_thread_mutex_unlock (mux_dispatcher);
3779
3780 return work;
3781 }
3782
3783 static void *thread_calc_stdin (void *p)
3784 {
3785 hc_device_param_t *device_param = (hc_device_param_t *) p;
3786
3787 const uint attack_kern = data.attack_kern;
3788
3789 const uint gpu_blocks = device_param->gpu_blocks;
3790
3791 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3792 {
3793 hc_thread_mutex_lock (mux_dispatcher);
3794
3795 if (feof (stdin) != 0)
3796 {
3797 hc_thread_mutex_unlock (mux_dispatcher);
3798
3799 break;
3800 }
3801
3802 uint words_cur = 0;
3803
3804 while (words_cur < gpu_blocks)
3805 {
3806 char buf[BUFSIZ];
3807
3808 char *line_buf = fgets (buf, sizeof (buf), stdin);
3809
3810 if (line_buf == NULL) break;
3811
3812 uint line_len = in_superchop (line_buf);
3813
3814 line_len = convert_from_hex (line_buf, line_len);
3815
3816 // post-process rule engine
3817
3818 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3819 {
3820 char rule_buf_out[BLOCK_SIZE];
3821
3822 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3823
3824 int rule_len_out = -1;
3825
3826 if (line_len < BLOCK_SIZE)
3827 {
3828 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
3829 }
3830
3831 if (rule_len_out < 0) continue;
3832
3833 line_buf = rule_buf_out;
3834 line_len = rule_len_out;
3835 }
3836
3837 if (line_len > PW_MAX)
3838 {
3839 continue;
3840 }
3841
3842 if (attack_kern == ATTACK_KERN_STRAIGHT)
3843 {
3844 if ((line_len < data.pw_min) || (line_len > data.pw_max))
3845 {
3846 hc_thread_mutex_lock (mux_counter);
3847
3848 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3849 {
3850 data.words_progress_rejected[salt_pos] += data.gpu_rules_cnt;
3851 }
3852
3853 hc_thread_mutex_unlock (mux_counter);
3854
3855 continue;
3856 }
3857 }
3858 else if (attack_kern == ATTACK_KERN_COMBI)
3859 {
3860 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
3861 // since we still need to combine the plains
3862
3863 if (line_len > data.pw_max)
3864 {
3865 hc_thread_mutex_lock (mux_counter);
3866
3867 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3868 {
3869 data.words_progress_rejected[salt_pos] += data.combs_cnt;
3870 }
3871
3872 hc_thread_mutex_unlock (mux_counter);
3873
3874 continue;
3875 }
3876 }
3877
3878 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
3879
3880 words_cur++;
3881
3882 if (data.devices_status == STATUS_CRACKED) break;
3883 if (data.devices_status == STATUS_ABORTED) break;
3884 if (data.devices_status == STATUS_QUIT) break;
3885 if (data.devices_status == STATUS_BYPASS) break;
3886 }
3887
3888 hc_thread_mutex_unlock (mux_dispatcher);
3889
3890 if (data.devices_status == STATUS_CRACKED) break;
3891 if (data.devices_status == STATUS_ABORTED) break;
3892 if (data.devices_status == STATUS_QUIT) break;
3893 if (data.devices_status == STATUS_BYPASS) break;
3894
3895 // we need 2 flushing because we have two independant caches and it can occur
3896 // that one buffer is already at threshold plus for that length also exists
3897 // more data in the 2nd buffer so it would overflow
3898
3899 // flush session 1
3900
3901 {
3902 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
3903 {
3904 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
3905
3906 const uint pw_cache_cnt = pw_cache->cnt;
3907
3908 if (pw_cache_cnt == 0) continue;
3909
3910 pw_cache->cnt = 0;
3911
3912 uint pws_cnt = device_param->pws_cnt;
3913
3914 pw_t *pw = device_param->pws_buf + pws_cnt;
3915
3916 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3917
3918 pw->pw_len = pw_len;
3919
3920 uint pw_cnt = device_param->pw_cnt;
3921
3922 pw_cnt += pw_cache_cnt;
3923
3924 device_param->pw_cnt = pw_cnt;
3925
3926 pws_cnt++;
3927
3928 device_param->pws_cnt = pws_cnt;
3929
3930 if (pws_cnt == device_param->gpu_power_user) break;
3931 }
3932
3933 const uint pw_cnt = device_param->pw_cnt;
3934 const uint pws_cnt = device_param->pws_cnt;
3935
3936 if (pws_cnt)
3937 {
3938 run_copy (device_param, pws_cnt);
3939
3940 run_cracker (device_param, pw_cnt, pws_cnt);
3941
3942 device_param->pw_cnt = 0;
3943 device_param->pws_cnt = 0;
3944 }
3945 }
3946
3947 // flush session 2
3948
3949 {
3950 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
3951 {
3952 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
3953
3954 const uint pw_cache_cnt = pw_cache->cnt;
3955
3956 if (pw_cache_cnt == 0) continue;
3957
3958 pw_cache->cnt = 0;
3959
3960 uint pws_cnt = device_param->pws_cnt;
3961
3962 pw_t *pw = device_param->pws_buf + pws_cnt;
3963
3964 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3965
3966 pw->pw_len = pw_len;
3967
3968 uint pw_cnt = device_param->pw_cnt;
3969
3970 pw_cnt += pw_cache_cnt;
3971
3972 device_param->pw_cnt = pw_cnt;
3973
3974 pws_cnt++;
3975
3976 device_param->pws_cnt = pws_cnt;
3977 }
3978
3979 const uint pw_cnt = device_param->pw_cnt;
3980 const uint pws_cnt = device_param->pws_cnt;
3981
3982 if (pws_cnt)
3983 {
3984 run_copy (device_param, pws_cnt);
3985
3986 run_cracker (device_param, pw_cnt, pws_cnt);
3987
3988 device_param->pw_cnt = 0;
3989 device_param->pws_cnt = 0;
3990 }
3991 }
3992 }
3993
3994 return NULL;
3995 }
3996
3997 static void *thread_calc (void *p)
3998 {
3999 hc_device_param_t *device_param = (hc_device_param_t *) p;
4000
4001 const uint attack_mode = data.attack_mode;
4002 const uint attack_kern = data.attack_kern;
4003
4004 if (attack_mode == ATTACK_MODE_BF)
4005 {
4006 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4007 {
4008 const uint work = get_work (device_param, -1);
4009
4010 if (work == 0) break;
4011
4012 const uint64_t words_off = device_param->words_off;
4013 const uint64_t words_fin = words_off + work;
4014
4015 const uint pw_cnt = work;
4016 const uint pws_cnt = work;
4017
4018 device_param->pw_cnt = pw_cnt;
4019 device_param->pws_cnt = pws_cnt;
4020
4021 if (pws_cnt)
4022 {
4023 run_copy (device_param, pws_cnt);
4024
4025 run_cracker (device_param, pw_cnt, pws_cnt);
4026
4027 device_param->pw_cnt = 0;
4028 device_param->pws_cnt = 0;
4029 }
4030
4031 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4032
4033 if (data.devices_status == STATUS_CRACKED) break;
4034 if (data.devices_status == STATUS_ABORTED) break;
4035 if (data.devices_status == STATUS_QUIT) break;
4036 if (data.devices_status == STATUS_BYPASS) break;
4037
4038 device_param->words_done = words_fin;
4039 }
4040 }
4041 else
4042 {
4043 const uint segment_size = data.segment_size;
4044
4045 char *dictfile = data.dictfile;
4046
4047 if (attack_mode == ATTACK_MODE_COMBI)
4048 {
4049 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4050 {
4051 dictfile = data.dictfile2;
4052 }
4053 }
4054
4055 FILE *fd = fopen (dictfile, "rb");
4056
4057 if (fd == NULL)
4058 {
4059 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4060
4061 return NULL;
4062 }
4063
4064 if (attack_mode == ATTACK_MODE_COMBI)
4065 {
4066 const uint combs_mode = data.combs_mode;
4067
4068 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4069 {
4070 const char *dictfilec = data.dictfile2;
4071
4072 FILE *combs_fp = fopen (dictfilec, "rb");
4073
4074 if (combs_fp == NULL)
4075 {
4076 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4077
4078 fclose (fd);
4079
4080 return NULL;
4081 }
4082
4083 device_param->combs_fp = combs_fp;
4084 }
4085 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4086 {
4087 const char *dictfilec = data.dictfile;
4088
4089 FILE *combs_fp = fopen (dictfilec, "rb");
4090
4091 if (combs_fp == NULL)
4092 {
4093 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4094
4095 fclose (fd);
4096
4097 return NULL;
4098 }
4099
4100 device_param->combs_fp = combs_fp;
4101 }
4102 }
4103
4104 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4105
4106 wl_data->buf = (char *) mymalloc (segment_size);
4107 wl_data->avail = segment_size;
4108 wl_data->incr = segment_size;
4109 wl_data->cnt = 0;
4110 wl_data->pos = 0;
4111
4112 uint64_t words_cur = 0;
4113
4114 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4115 {
4116 uint64_t words_off = 0;
4117 uint64_t words_fin = 0;
4118
4119 uint64_t max = -1;
4120
4121 while (max)
4122 {
4123 const uint work = get_work (device_param, max);
4124
4125 if (work == 0) break;
4126
4127 words_off = device_param->words_off;
4128 words_fin = words_off + work;
4129
4130 char *line_buf;
4131 uint line_len;
4132
4133 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4134
4135 max = 0;
4136
4137 for ( ; words_cur < words_fin; words_cur++)
4138 {
4139 get_next_word (wl_data, fd, &line_buf, &line_len);
4140
4141 line_len = convert_from_hex (line_buf, line_len);
4142
4143 // post-process rule engine
4144
4145 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4146 {
4147 char rule_buf_out[BLOCK_SIZE];
4148
4149 memset (rule_buf_out, 0, sizeof (rule_buf_out));
4150
4151 int rule_len_out = -1;
4152
4153 if (line_len < BLOCK_SIZE)
4154 {
4155 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4156 }
4157
4158 if (rule_len_out < 0) continue;
4159
4160 line_buf = rule_buf_out;
4161 line_len = rule_len_out;
4162 }
4163
4164 if (attack_kern == ATTACK_KERN_STRAIGHT)
4165 {
4166 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4167 {
4168 max++;
4169
4170 hc_thread_mutex_lock (mux_counter);
4171
4172 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4173 {
4174 data.words_progress_rejected[salt_pos] += data.gpu_rules_cnt;
4175 }
4176
4177 hc_thread_mutex_unlock (mux_counter);
4178
4179 continue;
4180 }
4181 }
4182 else if (attack_kern == ATTACK_KERN_COMBI)
4183 {
4184 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4185 // since we still need to combine the plains
4186
4187 if (line_len > data.pw_max)
4188 {
4189 max++;
4190
4191 hc_thread_mutex_lock (mux_counter);
4192
4193 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4194 {
4195 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4196 }
4197
4198 hc_thread_mutex_unlock (mux_counter);
4199
4200 continue;
4201 }
4202 }
4203
4204 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4205
4206 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4207
4208 if (data.devices_status == STATUS_CRACKED) break;
4209 if (data.devices_status == STATUS_ABORTED) break;
4210 if (data.devices_status == STATUS_QUIT) break;
4211 if (data.devices_status == STATUS_BYPASS) break;
4212 }
4213
4214 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4215
4216 if (data.devices_status == STATUS_CRACKED) break;
4217 if (data.devices_status == STATUS_ABORTED) break;
4218 if (data.devices_status == STATUS_QUIT) break;
4219 if (data.devices_status == STATUS_BYPASS) break;
4220 }
4221
4222 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4223
4224 if (data.devices_status == STATUS_CRACKED) break;
4225 if (data.devices_status == STATUS_ABORTED) break;
4226 if (data.devices_status == STATUS_QUIT) break;
4227 if (data.devices_status == STATUS_BYPASS) break;
4228
4229 // we need 2 flushing because we have two independant caches and it can occur
4230 // that one buffer is already at threshold plus for that length also exists
4231 // more data in the 2nd buffer so it would overflow
4232
4233 //
4234 // flush session 1
4235 //
4236
4237 {
4238 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4239 {
4240 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4241
4242 const uint pw_cache_cnt = pw_cache->cnt;
4243
4244 if (pw_cache_cnt == 0) continue;
4245
4246 pw_cache->cnt = 0;
4247
4248 uint pws_cnt = device_param->pws_cnt;
4249
4250 pw_t *pw = device_param->pws_buf + pws_cnt;
4251
4252 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4253
4254 pw->pw_len = pw_len;
4255
4256 uint pw_cnt = device_param->pw_cnt;
4257
4258 pw_cnt += pw_cache_cnt;
4259
4260 device_param->pw_cnt = pw_cnt;
4261
4262 pws_cnt++;
4263
4264 device_param->pws_cnt = pws_cnt;
4265
4266 if (pws_cnt == device_param->gpu_power_user) break;
4267 }
4268
4269 const uint pw_cnt = device_param->pw_cnt;
4270 const uint pws_cnt = device_param->pws_cnt;
4271
4272 if (pws_cnt)
4273 {
4274 run_copy (device_param, pws_cnt);
4275
4276 run_cracker (device_param, pw_cnt, pws_cnt);
4277
4278 device_param->pw_cnt = 0;
4279 device_param->pws_cnt = 0;
4280 }
4281
4282 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4283
4284 if (data.devices_status == STATUS_CRACKED) break;
4285 if (data.devices_status == STATUS_ABORTED) break;
4286 if (data.devices_status == STATUS_QUIT) break;
4287 if (data.devices_status == STATUS_BYPASS) break;
4288 }
4289
4290 //
4291 // flush session 2
4292 //
4293
4294 {
4295 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4296 {
4297 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4298
4299 const uint pw_cache_cnt = pw_cache->cnt;
4300
4301 if (pw_cache_cnt == 0) continue;
4302
4303 pw_cache->cnt = 0;
4304
4305 uint pws_cnt = device_param->pws_cnt;
4306
4307 pw_t *pw = device_param->pws_buf + pws_cnt;
4308
4309 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4310
4311 pw->pw_len = pw_len;
4312
4313 uint pw_cnt = device_param->pw_cnt;
4314
4315 pw_cnt += pw_cache_cnt;
4316
4317 device_param->pw_cnt = pw_cnt;
4318
4319 pws_cnt++;
4320
4321 device_param->pws_cnt = pws_cnt;
4322 }
4323
4324 const uint pw_cnt = device_param->pw_cnt;
4325 const uint pws_cnt = device_param->pws_cnt;
4326
4327 if (pws_cnt)
4328 {
4329 run_copy (device_param, pws_cnt);
4330
4331 run_cracker (device_param, pw_cnt, pws_cnt);
4332
4333 device_param->pw_cnt = 0;
4334 device_param->pws_cnt = 0;
4335 }
4336
4337 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4338
4339 if (data.devices_status == STATUS_CRACKED) break;
4340 if (data.devices_status == STATUS_ABORTED) break;
4341 if (data.devices_status == STATUS_QUIT) break;
4342 if (data.devices_status == STATUS_BYPASS) break;
4343 }
4344
4345 if (words_fin == 0) break;
4346
4347 device_param->words_done = words_fin;
4348 }
4349
4350 if (attack_mode == ATTACK_MODE_COMBI)
4351 {
4352 fclose (device_param->combs_fp);
4353 }
4354
4355 free (wl_data->buf);
4356 free (wl_data);
4357
4358 fclose (fd);
4359 }
4360
4361 return NULL;
4362 }
4363
4364 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint gpu_loops)
4365 {
4366 salt_t *salt_buf = &data.salts_buf[salt_pos];
4367
4368 device_param->kernel_params_buf32[24] = salt_pos;
4369 device_param->kernel_params_buf32[27] = 1;
4370 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4371 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4372 device_param->kernel_params_buf32[30] = 0;
4373 device_param->kernel_params_buf32[31] = 1;
4374
4375 char *dictfile_old = data.dictfile;
4376 char *dictfile2_old = data.dictfile2;
4377 char *mask_old = data.mask;
4378
4379 const char *weak_hash_check = "weak-hash-check";
4380
4381 data.dictfile = (char *) weak_hash_check;
4382 data.dictfile2 = (char *) weak_hash_check;
4383 data.mask = (char *) weak_hash_check;
4384
4385 /**
4386 * run the kernel
4387 */
4388
4389 if (data.attack_exec == ATTACK_EXEC_ON_GPU)
4390 {
4391 run_kernel (KERN_RUN_1, device_param, 1);
4392 }
4393 else
4394 {
4395 run_kernel (KERN_RUN_1, device_param, 1);
4396
4397 const uint iter = salt_buf->salt_iter;
4398
4399 for (uint loop_pos = 0; loop_pos < iter; loop_pos += gpu_loops)
4400 {
4401 uint loop_left = iter - loop_pos;
4402
4403 loop_left = MIN (loop_left, gpu_loops);
4404
4405 device_param->kernel_params_buf32[25] = loop_pos;
4406 device_param->kernel_params_buf32[26] = loop_left;
4407
4408 run_kernel (KERN_RUN_2, device_param, 1);
4409 }
4410
4411 run_kernel (KERN_RUN_3, device_param, 1);
4412 }
4413
4414 /**
4415 * result
4416 */
4417
4418 check_cracked (device_param, salt_pos);
4419
4420 /**
4421 * cleanup
4422 */
4423
4424 device_param->kernel_params_buf32[24] = 0;
4425 device_param->kernel_params_buf32[25] = 0;
4426 device_param->kernel_params_buf32[26] = 0;
4427 device_param->kernel_params_buf32[27] = 0;
4428 device_param->kernel_params_buf32[28] = 0;
4429 device_param->kernel_params_buf32[29] = 0;
4430 device_param->kernel_params_buf32[30] = 0;
4431 device_param->kernel_params_buf32[31] = 0;
4432
4433 data.dictfile = dictfile_old;
4434 data.dictfile2 = dictfile2_old;
4435 data.mask = mask_old;
4436 }
4437
4438 // hlfmt hashcat
4439
4440 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4441 {
4442 if (data.username == 0)
4443 {
4444 *hashbuf_pos = line_buf;
4445 *hashbuf_len = line_len;
4446 }
4447 else
4448 {
4449 char *pos = line_buf;
4450 int len = line_len;
4451
4452 for (int i = 0; i < line_len; i++, pos++, len--)
4453 {
4454 if (line_buf[i] == data.separator)
4455 {
4456 pos++;
4457
4458 len--;
4459
4460 break;
4461 }
4462 }
4463
4464 *hashbuf_pos = pos;
4465 *hashbuf_len = len;
4466 }
4467 }
4468
4469 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4470 {
4471 char *pos = NULL;
4472 int len = 0;
4473
4474 int sep_cnt = 0;
4475
4476 for (int i = 0; i < line_len; i++)
4477 {
4478 if (line_buf[i] == data.separator)
4479 {
4480 sep_cnt++;
4481
4482 continue;
4483 }
4484
4485 if (sep_cnt == 0)
4486 {
4487 if (pos == NULL) pos = line_buf + i;
4488
4489 len++;
4490 }
4491 }
4492
4493 *userbuf_pos = pos;
4494 *userbuf_len = len;
4495 }
4496
4497 // hlfmt pwdump
4498
4499 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4500 {
4501 int sep_cnt = 0;
4502
4503 int sep2_len = 0;
4504 int sep3_len = 0;
4505
4506 for (int i = 0; i < line_len; i++)
4507 {
4508 if (line_buf[i] == ':')
4509 {
4510 sep_cnt++;
4511
4512 continue;
4513 }
4514
4515 if (sep_cnt == 2) sep2_len++;
4516 if (sep_cnt == 3) sep3_len++;
4517 }
4518
4519 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4520
4521 return 0;
4522 }
4523
4524 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4525 {
4526 char *pos = NULL;
4527 int len = 0;
4528
4529 int sep_cnt = 0;
4530
4531 for (int i = 0; i < line_len; i++)
4532 {
4533 if (line_buf[i] == ':')
4534 {
4535 sep_cnt++;
4536
4537 continue;
4538 }
4539
4540 if (data.hash_mode == 1000)
4541 {
4542 if (sep_cnt == 3)
4543 {
4544 if (pos == NULL) pos = line_buf + i;
4545
4546 len++;
4547 }
4548 }
4549 else if (data.hash_mode == 3000)
4550 {
4551 if (sep_cnt == 2)
4552 {
4553 if (pos == NULL) pos = line_buf + i;
4554
4555 len++;
4556 }
4557 }
4558 }
4559
4560 *hashbuf_pos = pos;
4561 *hashbuf_len = len;
4562 }
4563
4564 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4565 {
4566 char *pos = NULL;
4567 int len = 0;
4568
4569 int sep_cnt = 0;
4570
4571 for (int i = 0; i < line_len; i++)
4572 {
4573 if (line_buf[i] == ':')
4574 {
4575 sep_cnt++;
4576
4577 continue;
4578 }
4579
4580 if (sep_cnt == 0)
4581 {
4582 if (pos == NULL) pos = line_buf + i;
4583
4584 len++;
4585 }
4586 }
4587
4588 *userbuf_pos = pos;
4589 *userbuf_len = len;
4590 }
4591
4592 // hlfmt passwd
4593
4594 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4595 {
4596 int sep_cnt = 0;
4597
4598 char sep5_first = 0;
4599 char sep6_first = 0;
4600
4601 for (int i = 0; i < line_len; i++)
4602 {
4603 if (line_buf[i] == ':')
4604 {
4605 sep_cnt++;
4606
4607 continue;
4608 }
4609
4610 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4611 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4612 }
4613
4614 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4615
4616 return 0;
4617 }
4618
4619 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4620 {
4621 char *pos = NULL;
4622 int len = 0;
4623
4624 int sep_cnt = 0;
4625
4626 for (int i = 0; i < line_len; i++)
4627 {
4628 if (line_buf[i] == ':')
4629 {
4630 sep_cnt++;
4631
4632 continue;
4633 }
4634
4635 if (sep_cnt == 1)
4636 {
4637 if (pos == NULL) pos = line_buf + i;
4638
4639 len++;
4640 }
4641 }
4642
4643 *hashbuf_pos = pos;
4644 *hashbuf_len = len;
4645 }
4646
4647 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4648 {
4649 char *pos = NULL;
4650 int len = 0;
4651
4652 int sep_cnt = 0;
4653
4654 for (int i = 0; i < line_len; i++)
4655 {
4656 if (line_buf[i] == ':')
4657 {
4658 sep_cnt++;
4659
4660 continue;
4661 }
4662
4663 if (sep_cnt == 0)
4664 {
4665 if (pos == NULL) pos = line_buf + i;
4666
4667 len++;
4668 }
4669 }
4670
4671 *userbuf_pos = pos;
4672 *userbuf_len = len;
4673 }
4674
4675 // hlfmt shadow
4676
4677 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4678 {
4679 int sep_cnt = 0;
4680
4681 for (int i = 0; i < line_len; i++)
4682 {
4683 if (line_buf[i] == ':') sep_cnt++;
4684 }
4685
4686 if (sep_cnt == 8) return 1;
4687
4688 return 0;
4689 }
4690
4691 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4692 {
4693 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4694 }
4695
4696 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4697 {
4698 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4699 }
4700
4701 // hlfmt main
4702
4703 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4704 {
4705 switch (hashfile_format)
4706 {
4707 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4708 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4709 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4710 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4711 }
4712 }
4713
4714 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4715 {
4716 switch (hashfile_format)
4717 {
4718 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4719 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4720 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4721 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4722 }
4723 }
4724
4725 static uint hlfmt_detect (FILE *fp, uint max_check)
4726 {
4727 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4728
4729 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4730 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4731
4732 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4733
4734 uint num_check = 0;
4735
4736 while (!feof (fp))
4737 {
4738 char line_buf[BUFSIZ];
4739
4740 int line_len = fgetl (fp, line_buf);
4741
4742 if (line_len == 0) continue;
4743
4744 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4745 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4746 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4747
4748 if (num_check == max_check) break;
4749
4750 num_check++;
4751 }
4752
4753 uint hashlist_format = HLFMT_HASHCAT;
4754
4755 for (int i = 1; i < HLFMTS_CNT; i++)
4756 {
4757 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4758
4759 hashlist_format = i;
4760 }
4761
4762 free (formats_cnt);
4763
4764 return hashlist_format;
4765 }
4766
4767 /**
4768 * some further helper function
4769 */
4770
4771 // wrapper around mymalloc for ADL
4772
4773 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4774 {
4775 return mymalloc (iSize);
4776 }
4777
4778 static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, const uint dgst_shifts, char *digests_buf_ptr, const uint bitmap_mask, const uint bitmap_size, uint *bitmap_a, uint *bitmap_b, uint *bitmap_c, uint *bitmap_d, const uint64_t collisions_max)
4779 {
4780 uint64_t collisions = 0;
4781
4782 const uint dgst_pos0 = data.dgst_pos0;
4783 const uint dgst_pos1 = data.dgst_pos1;
4784 const uint dgst_pos2 = data.dgst_pos2;
4785 const uint dgst_pos3 = data.dgst_pos3;
4786
4787 memset (bitmap_a, 0, bitmap_size);
4788 memset (bitmap_b, 0, bitmap_size);
4789 memset (bitmap_c, 0, bitmap_size);
4790 memset (bitmap_d, 0, bitmap_size);
4791
4792 for (uint i = 0; i < digests_cnt; i++)
4793 {
4794 uint *digest_ptr = (uint *) digests_buf_ptr;
4795
4796 digests_buf_ptr += dgst_size;
4797
4798 const uint val0 = 1 << (digest_ptr[dgst_pos0] & 0x1f);
4799 const uint val1 = 1 << (digest_ptr[dgst_pos1] & 0x1f);
4800 const uint val2 = 1 << (digest_ptr[dgst_pos2] & 0x1f);
4801 const uint val3 = 1 << (digest_ptr[dgst_pos3] & 0x1f);
4802
4803 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
4804 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
4805 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
4806 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
4807
4808 if (bitmap_a[idx0] & val0) collisions++;
4809 if (bitmap_b[idx1] & val1) collisions++;
4810 if (bitmap_c[idx2] & val2) collisions++;
4811 if (bitmap_d[idx3] & val3) collisions++;
4812
4813 bitmap_a[idx0] |= val0;
4814 bitmap_b[idx1] |= val1;
4815 bitmap_c[idx2] |= val2;
4816 bitmap_d[idx3] |= val3;
4817
4818 if (collisions >= collisions_max) return 0x7fffffff;
4819 }
4820
4821 return collisions;
4822 }
4823
4824 /**
4825 * main
4826 */
4827
4828 int main (int argc, char **argv)
4829 {
4830 /**
4831 * To help users a bit
4832 */
4833
4834 char *compute = getenv ("COMPUTE");
4835
4836 if (compute)
4837 {
4838 char display[100];
4839
4840 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
4841
4842 putenv (display);
4843 }
4844 else
4845 {
4846 if (getenv ("DISPLAY") == NULL)
4847 putenv ((char *) "DISPLAY=:0");
4848 }
4849
4850 /*
4851 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
4852 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
4853
4854 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
4855 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
4856 */
4857
4858 /**
4859 * Real init
4860 */
4861
4862 memset (&data, 0, sizeof (hc_global_data_t));
4863
4864 time_t proc_start;
4865
4866 time (&proc_start);
4867
4868 data.proc_start = proc_start;
4869
4870 int myargc = argc;
4871 char **myargv = argv;
4872
4873 hc_thread_mutex_init (mux_dispatcher);
4874 hc_thread_mutex_init (mux_counter);
4875 hc_thread_mutex_init (mux_display);
4876 hc_thread_mutex_init (mux_adl);
4877
4878 /**
4879 * commandline parameters
4880 */
4881
4882 uint usage = USAGE;
4883 uint version = VERSION;
4884 uint quiet = QUIET;
4885 uint benchmark = BENCHMARK;
4886 uint benchmark_mode = BENCHMARK_MODE;
4887 uint show = SHOW;
4888 uint left = LEFT;
4889 uint username = USERNAME;
4890 uint remove = REMOVE;
4891 uint remove_timer = REMOVE_TIMER;
4892 uint64_t skip = SKIP;
4893 uint64_t limit = LIMIT;
4894 uint keyspace = KEYSPACE;
4895 uint potfile_disable = POTFILE_DISABLE;
4896 uint debug_mode = DEBUG_MODE;
4897 char *debug_file = NULL;
4898 char *induction_dir = NULL;
4899 char *outfile_check_dir = NULL;
4900 uint force = FORCE;
4901 uint runtime = RUNTIME;
4902 uint hash_mode = HASH_MODE;
4903 uint attack_mode = ATTACK_MODE;
4904 uint markov_disable = MARKOV_DISABLE;
4905 uint markov_classic = MARKOV_CLASSIC;
4906 uint markov_threshold = MARKOV_THRESHOLD;
4907 char *markov_hcstat = NULL;
4908 char *outfile = NULL;
4909 uint outfile_format = OUTFILE_FORMAT;
4910 uint outfile_autohex = OUTFILE_AUTOHEX;
4911 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
4912 uint restore = RESTORE;
4913 uint restore_timer = RESTORE_TIMER;
4914 uint restore_disable = RESTORE_DISABLE;
4915 uint status = STATUS;
4916 uint status_timer = STATUS_TIMER;
4917 uint status_automat = STATUS_AUTOMAT;
4918 uint loopback = LOOPBACK;
4919 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
4920 char *session = NULL;
4921 uint hex_charset = HEX_CHARSET;
4922 uint hex_salt = HEX_SALT;
4923 uint hex_wordlist = HEX_WORDLIST;
4924 uint rp_gen = RP_GEN;
4925 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
4926 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
4927 uint rp_gen_seed = RP_GEN_SEED;
4928 char *rule_buf_l = (char *) RULE_BUF_L;
4929 char *rule_buf_r = (char *) RULE_BUF_R;
4930 uint increment = INCREMENT;
4931 uint increment_min = INCREMENT_MIN;
4932 uint increment_max = INCREMENT_MAX;
4933 char *cpu_affinity = NULL;
4934 char *gpu_devices = NULL;
4935 char *truecrypt_keyfiles = NULL;
4936 uint workload_profile = WORKLOAD_PROFILE;
4937 uint gpu_accel = GPU_ACCEL;
4938 uint gpu_loops = GPU_LOOPS;
4939 uint gpu_temp_disable = GPU_TEMP_DISABLE;
4940 uint gpu_temp_abort = GPU_TEMP_ABORT;
4941 uint gpu_temp_retain = GPU_TEMP_RETAIN;
4942 uint powertune_enable = POWERTUNE_ENABLE;
4943 uint logfile_disable = LOGFILE_DISABLE;
4944 uint segment_size = SEGMENT_SIZE;
4945 uint scrypt_tmto = SCRYPT_TMTO;
4946 char separator = SEPARATOR;
4947 uint bitmap_min = BITMAP_MIN;
4948 uint bitmap_max = BITMAP_MAX;
4949 char *custom_charset_1 = NULL;
4950 char *custom_charset_2 = NULL;
4951 char *custom_charset_3 = NULL;
4952 char *custom_charset_4 = NULL;
4953
4954 #define IDX_HELP 'h'
4955 #define IDX_VERSION 'V'
4956 #define IDX_VERSION_LOWER 'v'
4957 #define IDX_QUIET 0xff02
4958 #define IDX_SHOW 0xff03
4959 #define IDX_LEFT 0xff04
4960 #define IDX_REMOVE 0xff05
4961 #define IDX_REMOVE_TIMER 0xff37
4962 #define IDX_SKIP 's'
4963 #define IDX_LIMIT 'l'
4964 #define IDX_KEYSPACE 0xff35
4965 #define IDX_POTFILE_DISABLE 0xff06
4966 #define IDX_DEBUG_MODE 0xff43
4967 #define IDX_DEBUG_FILE 0xff44
4968 #define IDX_INDUCTION_DIR 0xff46
4969 #define IDX_OUTFILE_CHECK_DIR 0xff47
4970 #define IDX_USERNAME 0xff07
4971 #define IDX_FORCE 0xff08
4972 #define IDX_RUNTIME 0xff09
4973 #define IDX_BENCHMARK 'b'
4974 #define IDX_BENCHMARK_MODE 0xff32
4975 #define IDX_HASH_MODE 'm'
4976 #define IDX_ATTACK_MODE 'a'
4977 #define IDX_RP_FILE 'r'
4978 #define IDX_RP_GEN 'g'
4979 #define IDX_RP_GEN_FUNC_MIN 0xff10
4980 #define IDX_RP_GEN_FUNC_MAX 0xff11
4981 #define IDX_RP_GEN_SEED 0xff34
4982 #define IDX_RULE_BUF_L 'j'
4983 #define IDX_RULE_BUF_R 'k'
4984 #define IDX_INCREMENT 'i'
4985 #define IDX_INCREMENT_MIN 0xff12
4986 #define IDX_INCREMENT_MAX 0xff13
4987 #define IDX_OUTFILE 'o'
4988 #define IDX_OUTFILE_FORMAT 0xff14
4989 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
4990 #define IDX_OUTFILE_CHECK_TIMER 0xff45
4991 #define IDX_RESTORE 0xff15
4992 #define IDX_RESTORE_DISABLE 0xff27
4993 #define IDX_STATUS 0xff17
4994 #define IDX_STATUS_TIMER 0xff18
4995 #define IDX_STATUS_AUTOMAT 0xff50
4996 #define IDX_LOOPBACK 0xff38
4997 #define IDX_WEAK_HASH_THRESHOLD 0xff42
4998 #define IDX_SESSION 0xff19
4999 #define IDX_HEX_CHARSET 0xff20
5000 #define IDX_HEX_SALT 0xff21
5001 #define IDX_HEX_WORDLIST 0xff40
5002 #define IDX_MARKOV_DISABLE 0xff22
5003 #define IDX_MARKOV_CLASSIC 0xff23
5004 #define IDX_MARKOV_THRESHOLD 't'
5005 #define IDX_MARKOV_HCSTAT 0xff24
5006 #define IDX_CPU_AFFINITY 0xff25
5007 #define IDX_GPU_DEVICES 'd'
5008 #define IDX_WORKLOAD_PROFILE 'w'
5009 #define IDX_GPU_ACCEL 'n'
5010 #define IDX_GPU_LOOPS 'u'
5011 #define IDX_GPU_TEMP_DISABLE 0xff29
5012 #define IDX_GPU_TEMP_ABORT 0xff30
5013 #define IDX_GPU_TEMP_RETAIN 0xff31
5014 #define IDX_POWERTUNE_ENABLE 0xff41
5015 #define IDX_LOGFILE_DISABLE 0xff51
5016 #define IDX_TRUECRYPT_KEYFILES 0xff52
5017 #define IDX_SCRYPT_TMTO 0xff61
5018 #define IDX_SEGMENT_SIZE 'c'
5019 #define IDX_SEPARATOR 'p'
5020 #define IDX_BITMAP_MIN 0xff70
5021 #define IDX_BITMAP_MAX 0xff71
5022 #define IDX_CUSTOM_CHARSET_1 '1'
5023 #define IDX_CUSTOM_CHARSET_2 '2'
5024 #define IDX_CUSTOM_CHARSET_3 '3'
5025 #define IDX_CUSTOM_CHARSET_4 '4'
5026
5027 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5028
5029 struct option long_options[] =
5030 {
5031 {"help", no_argument, 0, IDX_HELP},
5032 {"version", no_argument, 0, IDX_VERSION},
5033 {"quiet", no_argument, 0, IDX_QUIET},
5034 {"show", no_argument, 0, IDX_SHOW},
5035 {"left", no_argument, 0, IDX_LEFT},
5036 {"username", no_argument, 0, IDX_USERNAME},
5037 {"remove", no_argument, 0, IDX_REMOVE},
5038 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5039 {"skip", required_argument, 0, IDX_SKIP},
5040 {"limit", required_argument, 0, IDX_LIMIT},
5041 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5042 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5043 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5044 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5045 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5046 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5047 {"force", no_argument, 0, IDX_FORCE},
5048 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5049 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5050 {"restore", no_argument, 0, IDX_RESTORE},
5051 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5052 {"status", no_argument, 0, IDX_STATUS},
5053 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5054 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5055 {"loopback", no_argument, 0, IDX_LOOPBACK},
5056 {"weak-hash-threshold",
5057 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5058 {"session", required_argument, 0, IDX_SESSION},
5059 {"runtime", required_argument, 0, IDX_RUNTIME},
5060 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5061 {"generate-rules-func-min",
5062 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5063 {"generate-rules-func-max",
5064 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5065 {"generate-rules-seed",
5066 required_argument, 0, IDX_RP_GEN_SEED},
5067 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5068 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5069 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5070 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5071 {"rules-file", required_argument, 0, IDX_RP_FILE},
5072 {"outfile", required_argument, 0, IDX_OUTFILE},
5073 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5074 {"outfile-autohex-disable",
5075 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5076 {"outfile-check-timer",
5077 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5078 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5079 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5080 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5081 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5082 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5083 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5084 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5085 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5086 {"gpu-devices", required_argument, 0, IDX_GPU_DEVICES},
5087 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5088 {"gpu-accel", required_argument, 0, IDX_GPU_ACCEL},
5089 {"gpu-loops", required_argument, 0, IDX_GPU_LOOPS},
5090 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5091 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5092 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5093 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5094 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5095 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5096 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5097 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5098 // deprecated
5099 {"seperator", required_argument, 0, IDX_SEPARATOR},
5100 {"separator", required_argument, 0, IDX_SEPARATOR},
5101 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5102 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5103 {"increment", no_argument, 0, IDX_INCREMENT},
5104 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5105 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5106 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5107 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5108 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5109 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5110
5111 {0, 0, 0, 0}
5112 };
5113
5114 uint rp_files_cnt = 0;
5115
5116 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5117
5118 int option_index;
5119 int c;
5120
5121 optind = 1;
5122 optopt = 0;
5123 option_index = 0;
5124
5125 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5126 {
5127 switch (c)
5128 {
5129 case IDX_HELP: usage = 1; break;
5130 case IDX_VERSION:
5131 case IDX_VERSION_LOWER: version = 1; break;
5132 case IDX_RESTORE: restore = 1; break;
5133 case IDX_SESSION: session = optarg; break;
5134 case IDX_SHOW: show = 1; break;
5135 case IDX_LEFT: left = 1; break;
5136 case '?': return (-1);
5137 }
5138 }
5139
5140 if (optopt != 0)
5141 {
5142 log_error ("ERROR: Invalid argument specified");
5143
5144 return (-1);
5145 }
5146
5147 /**
5148 * exit functions
5149 */
5150
5151 if (version)
5152 {
5153 log_info (VERSION_TXT);
5154
5155 return (0);
5156 }
5157
5158 if (usage)
5159 {
5160 usage_big_print (PROGNAME);
5161
5162 return (0);
5163 }
5164
5165 /**
5166 * session
5167 */
5168
5169 if (session == NULL) session = (char *) PROGNAME;
5170
5171 size_t session_size = strlen (session) + 32;
5172
5173 data.session = session;
5174
5175 char *eff_restore_file = (char *) mymalloc (session_size);
5176 char *new_restore_file = (char *) mymalloc (session_size);
5177
5178 snprintf (eff_restore_file, session_size - 1, "%s.restore", session);
5179 snprintf (new_restore_file, session_size - 1, "%s.restore.new", session);
5180
5181 data.eff_restore_file = eff_restore_file;
5182 data.new_restore_file = new_restore_file;
5183
5184 if (((show == 1) || (left == 1)) && (restore == 1))
5185 {
5186 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5187 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5188
5189 return (-1);
5190 }
5191
5192 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5193 if ((show == 1) || (left == 1))
5194 {
5195 restore_disable = 1;
5196
5197 restore = 0;
5198 }
5199
5200 data.restore_disable = restore_disable;
5201
5202 restore_data_t *rd = init_restore (argc, argv);
5203
5204 data.rd = rd;
5205
5206 /**
5207 * restore file
5208 */
5209
5210 if (restore == 1)
5211 {
5212 read_restore (eff_restore_file, rd);
5213
5214 if (rd->version_bin < RESTORE_MIN)
5215 {
5216 log_error ("ERROR: Incompatible restore-file version");
5217
5218 return (-1);
5219 }
5220
5221 myargc = rd->argc;
5222 myargv = rd->argv;
5223
5224 #ifdef _POSIX
5225 rd->pid = getpid ();
5226 #elif _WIN
5227 rd->pid = GetCurrentProcessId ();
5228 #endif
5229 }
5230
5231 uint hash_mode_chgd = 0;
5232 uint runtime_chgd = 0;
5233 uint gpu_loops_chgd = 0;
5234 uint gpu_accel_chgd = 0;
5235 uint attack_mode_chgd = 0;
5236 uint outfile_format_chgd = 0;
5237 uint rp_gen_seed_chgd = 0;
5238 uint remove_timer_chgd = 0;
5239 uint increment_min_chgd = 0;
5240 uint increment_max_chgd = 0;
5241 uint gpu_temp_abort_chgd = 0;
5242 uint gpu_temp_retain_chgd = 0;
5243
5244 optind = 1;
5245 optopt = 0;
5246 option_index = 0;
5247
5248 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5249 {
5250 switch (c)
5251 {
5252 //case IDX_HELP: usage = 1; break;
5253 //case IDX_VERSION: version = 1; break;
5254 //case IDX_RESTORE: restore = 1; break;
5255 case IDX_QUIET: quiet = 1; break;
5256 //case IDX_SHOW: show = 1; break;
5257 case IDX_SHOW: break;
5258 //case IDX_LEFT: left = 1; break;
5259 case IDX_LEFT: break;
5260 case IDX_USERNAME: username = 1; break;
5261 case IDX_REMOVE: remove = 1; break;
5262 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5263 remove_timer_chgd = 1; break;
5264 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5265 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5266 case IDX_DEBUG_FILE: debug_file = optarg; break;
5267 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5268 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5269 case IDX_FORCE: force = 1; break;
5270 case IDX_SKIP: skip = atoll (optarg); break;
5271 case IDX_LIMIT: limit = atoll (optarg); break;
5272 case IDX_KEYSPACE: keyspace = 1; break;
5273 case IDX_BENCHMARK: benchmark = 1; break;
5274 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5275 case IDX_RESTORE: break;
5276 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5277 case IDX_STATUS: status = 1; break;
5278 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5279 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5280 case IDX_LOOPBACK: loopback = 1; break;
5281 case IDX_WEAK_HASH_THRESHOLD:
5282 weak_hash_threshold = atoi (optarg); break;
5283 //case IDX_SESSION: session = optarg; break;
5284 case IDX_SESSION: break;
5285 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5286 hash_mode_chgd = 1; break;
5287 case IDX_RUNTIME: runtime = atoi (optarg);
5288 runtime_chgd = 1; break;
5289 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5290 attack_mode_chgd = 1; break;
5291 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5292 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5293 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5294 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5295 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5296 rp_gen_seed_chgd = 1; break;
5297 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5298 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5299 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5300 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5301 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5302 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5303 case IDX_OUTFILE: outfile = optarg; break;
5304 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5305 outfile_format_chgd = 1; break;
5306 case IDX_OUTFILE_AUTOHEX_DISABLE:
5307 outfile_autohex = 0; break;
5308 case IDX_OUTFILE_CHECK_TIMER:
5309 outfile_check_timer = atoi (optarg); break;
5310 case IDX_HEX_CHARSET: hex_charset = 1; break;
5311 case IDX_HEX_SALT: hex_salt = 1; break;
5312 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5313 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5314 case IDX_GPU_DEVICES: gpu_devices = optarg; break;
5315 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5316 case IDX_GPU_ACCEL: gpu_accel = atoi (optarg);
5317 gpu_accel_chgd = 1; break;
5318 case IDX_GPU_LOOPS: gpu_loops = atoi (optarg);
5319 gpu_loops_chgd = 1; break;
5320 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5321 case IDX_GPU_TEMP_ABORT: gpu_temp_abort_chgd = 1;
5322 gpu_temp_abort = atoi (optarg); break;
5323 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain_chgd = 1;
5324 gpu_temp_retain = atoi (optarg); break;
5325 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5326 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5327 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5328 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5329 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5330 case IDX_SEPARATOR: separator = optarg[0]; break;
5331 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5332 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5333 case IDX_INCREMENT: increment = 1; break;
5334 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5335 increment_min_chgd = 1; break;
5336 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5337 increment_max_chgd = 1; break;
5338 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5339 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5340 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5341 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5342
5343 default:
5344 log_error ("ERROR: Invalid argument specified");
5345 return (-1);
5346 }
5347 }
5348
5349 if (optopt != 0)
5350 {
5351 log_error ("ERROR: Invalid argument specified");
5352
5353 return (-1);
5354 }
5355
5356 /**
5357 * Inform user things getting started,
5358 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5359 * - we do not need to check algorithm_pos
5360 */
5361
5362 if (quiet == 0)
5363 {
5364 if (benchmark == 1)
5365 {
5366 log_info ("%s v%.2f starting in benchmark-mode...", PROGNAME, (float) VERSION_BIN / 100);
5367
5368 log_info ("");
5369 }
5370 else if (restore == 1)
5371 {
5372 log_info ("%s v%.2f starting in restore-mode...", PROGNAME, (float) VERSION_BIN / 100);
5373
5374 log_info ("");
5375 }
5376 else
5377 {
5378 log_info ("%s v%.2f starting...", PROGNAME, (float) VERSION_BIN / 100);
5379
5380 log_info ("");
5381 }
5382 }
5383
5384 /**
5385 * sanity check
5386 */
5387
5388 if (attack_mode > 7)
5389 {
5390 log_error ("ERROR: Invalid attack-mode specified");
5391
5392 return (-1);
5393 }
5394
5395 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5396 {
5397 log_error ("ERROR: Invalid runtime specified");
5398
5399 return (-1);
5400 }
5401
5402 if (hash_mode_chgd && hash_mode > 12800) // just added to remove compiler warnings for hash_mode_chgd
5403 {
5404 log_error ("ERROR: Invalid hash-type specified");
5405
5406 return (-1);
5407 }
5408
5409 // renamed hash modes
5410
5411 if (hash_mode_chgd)
5412 {
5413 int n = -1;
5414
5415 switch (hash_mode)
5416 {
5417 case 123: n = 124;
5418 break;
5419 }
5420
5421 if (n >= 0)
5422 {
5423 log_error ("Old -m specified, use -m %d instead", n);
5424
5425 return (-1);
5426 }
5427 }
5428
5429 if (username == 1)
5430 {
5431 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5432 {
5433 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5434
5435 return (-1);
5436 }
5437 }
5438
5439 if (outfile_format > 16)
5440 {
5441 log_error ("ERROR: Invalid outfile-format specified");
5442
5443 return (-1);
5444 }
5445
5446 if (left == 1)
5447 {
5448 if (outfile_format_chgd == 1)
5449 {
5450 if (outfile_format > 1)
5451 {
5452 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5453
5454 return (-1);
5455 }
5456 }
5457 else
5458 {
5459 outfile_format = OUTFILE_FMT_HASH;
5460 }
5461 }
5462
5463 if (show == 1)
5464 {
5465 if (outfile_format_chgd == 1)
5466 {
5467 if ((outfile_format > 7) && (outfile_format < 16))
5468 {
5469 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5470
5471 return (-1);
5472 }
5473 }
5474 }
5475
5476 if (increment_min < INCREMENT_MIN)
5477 {
5478 log_error ("ERROR: Invalid increment-min specified");
5479
5480 return (-1);
5481 }
5482
5483 if (increment_max > INCREMENT_MAX)
5484 {
5485 log_error ("ERROR: Invalid increment-max specified");
5486
5487 return (-1);
5488 }
5489
5490 if (increment_min > increment_max)
5491 {
5492 log_error ("ERROR: Invalid increment-min specified");
5493
5494 return (-1);
5495 }
5496
5497 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5498 {
5499 log_error ("ERROR: increment is not allowed in attack-mode 0");
5500
5501 return (-1);
5502 }
5503
5504 if ((increment == 0) && (increment_min_chgd == 1))
5505 {
5506 log_error ("ERROR: increment-min is only supported together with increment switch");
5507
5508 return (-1);
5509 }
5510
5511 if ((increment == 0) && (increment_max_chgd == 1))
5512 {
5513 log_error ("ERROR: increment-max is only supported together with increment switch");
5514
5515 return (-1);
5516 }
5517
5518 if (rp_files_cnt && rp_gen)
5519 {
5520 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5521
5522 return (-1);
5523 }
5524
5525 if (rp_files_cnt || rp_gen)
5526 {
5527 if (attack_mode != ATTACK_MODE_STRAIGHT)
5528 {
5529 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5530
5531 return (-1);
5532 }
5533 }
5534
5535 if (rp_gen_func_min > rp_gen_func_max)
5536 {
5537 log_error ("ERROR: Invalid rp-gen-func-min specified");
5538
5539 return (-1);
5540 }
5541
5542 if (gpu_accel_chgd == 1)
5543 {
5544 if (workload_profile != WORKLOAD_PROFILE)
5545 {
5546 log_error ("ERROR: gpu-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5547
5548 return (-1);
5549 }
5550
5551 if (gpu_accel < 1)
5552 {
5553 log_error ("ERROR: Invalid gpu-accel specified");
5554
5555 return (-1);
5556 }
5557
5558 if (gpu_accel > 800)
5559 {
5560 log_error ("ERROR: Invalid gpu-accel specified");
5561
5562 return (-1);
5563 }
5564 }
5565
5566 if (gpu_loops_chgd == 1)
5567 {
5568 if (workload_profile != WORKLOAD_PROFILE)
5569 {
5570 log_error ("ERROR: gpu-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5571
5572 return (-1);
5573 }
5574
5575 if (gpu_loops < 1)
5576 {
5577 log_error ("ERROR: Invalid gpu-loops specified");
5578
5579 return (-1);
5580 }
5581
5582 if (gpu_loops > 1024)
5583 {
5584 log_error ("ERROR: Invalid gpu-loops specified");
5585
5586 return (-1);
5587 }
5588 }
5589
5590 if (benchmark == 1)
5591 {
5592 if (workload_profile != WORKLOAD_PROFILE)
5593 {
5594 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5595
5596 return (-1);
5597 }
5598 }
5599
5600 if ((workload_profile < 1) || (workload_profile > 3))
5601 {
5602 log_error ("ERROR: workload-profile %i not available", workload_profile);
5603
5604 return (-1);
5605 }
5606
5607 if (show == 1 || left == 1)
5608 {
5609 attack_mode = ATTACK_MODE_NONE;
5610
5611 if (remove == 1)
5612 {
5613 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5614
5615 return (-1);
5616 }
5617
5618 if (potfile_disable == 1)
5619 {
5620 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5621
5622 return (-1);
5623 }
5624 }
5625
5626 uint attack_kern = ATTACK_KERN_NONE;
5627
5628 switch (attack_mode)
5629 {
5630 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5631 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5632 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5633 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5634 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5635 }
5636
5637 if (benchmark == 0)
5638 {
5639 if (keyspace == 1)
5640 {
5641 int num_additional_params = 1;
5642
5643 if (attack_kern == ATTACK_KERN_COMBI)
5644 {
5645 num_additional_params = 2;
5646 }
5647
5648 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5649
5650 if (keyspace_wordlist_specified == 0) optind--;
5651 }
5652
5653 if (attack_kern == ATTACK_KERN_NONE)
5654 {
5655 if ((optind + 1) != myargc)
5656 {
5657 usage_mini_print (myargv[0]);
5658
5659 return (-1);
5660 }
5661 }
5662 else if (attack_kern == ATTACK_KERN_STRAIGHT)
5663 {
5664 if ((optind + 1) > myargc)
5665 {
5666 usage_mini_print (myargv[0]);
5667
5668 return (-1);
5669 }
5670 }
5671 else if (attack_kern == ATTACK_KERN_COMBI)
5672 {
5673 if ((optind + 3) != myargc)
5674 {
5675 usage_mini_print (myargv[0]);
5676
5677 return (-1);
5678 }
5679 }
5680 else if (attack_kern == ATTACK_KERN_BF)
5681 {
5682 if ((optind + 1) > myargc)
5683 {
5684 usage_mini_print (myargv[0]);
5685
5686 return (-1);
5687 }
5688 }
5689 else
5690 {
5691 usage_mini_print (myargv[0]);
5692
5693 return (-1);
5694 }
5695 }
5696 else
5697 {
5698 if (myargv[optind] != 0)
5699 {
5700 log_error ("ERROR: Invalid argument for benchmark mode specified");
5701
5702 return (-1);
5703 }
5704
5705 if (attack_mode_chgd == 1)
5706 {
5707 if (attack_mode != ATTACK_MODE_BF)
5708 {
5709 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
5710
5711 return (-1);
5712 }
5713 }
5714
5715 if (benchmark_mode == 0)
5716 {
5717 // nothing to do
5718 }
5719 else if (benchmark_mode == 1)
5720 {
5721 if (gpu_accel_chgd == 1 || gpu_loops_chgd == 1)
5722 {
5723 log_error ("ERROR: Benchmark-mode 1 does not allow gpu-accel or gpu-loops changed");
5724
5725 return (-1);
5726 }
5727 }
5728 else
5729 {
5730 log_error ("ERROR: Benchmark-mode must be 0 or 1");
5731
5732 return (-1);
5733 }
5734 }
5735
5736 if (skip != 0 && limit != 0)
5737 {
5738 limit += skip;
5739 }
5740
5741 if (keyspace == 1)
5742 {
5743 if (show == 1)
5744 {
5745 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
5746
5747 return (-1);
5748 }
5749 else if (left == 1)
5750 {
5751 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
5752
5753 return (-1);
5754 }
5755
5756 potfile_disable = 1;
5757
5758 restore_disable = 1;
5759
5760 restore = 0;
5761
5762 weak_hash_threshold = 0;
5763
5764 quiet = 1;
5765 }
5766
5767 if (remove_timer_chgd == 1)
5768 {
5769 if (remove == 0)
5770 {
5771 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
5772
5773 return (-1);
5774 }
5775
5776 if (remove_timer < 1)
5777 {
5778 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
5779
5780 return (-1);
5781 }
5782 }
5783
5784 if (loopback == 1)
5785 {
5786 if (attack_mode == ATTACK_MODE_BF)
5787 {
5788 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
5789
5790 return (-1);
5791 }
5792 else if (attack_mode == ATTACK_MODE_STRAIGHT)
5793 {
5794 if ((rp_files_cnt == 0) && (rp_gen == 0))
5795 {
5796 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
5797
5798 return (-1);
5799 }
5800 }
5801 }
5802
5803 if (debug_mode > 0)
5804 {
5805 if (attack_mode != ATTACK_MODE_STRAIGHT)
5806 {
5807 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
5808
5809 return (-1);
5810 }
5811
5812 if ((rp_files_cnt == 0) && (rp_gen == 0))
5813 {
5814 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
5815
5816 return (-1);
5817 }
5818 }
5819
5820 if (debug_mode > 4)
5821 {
5822 log_error ("ERROR: Invalid debug-mode specified");
5823
5824 return (-1);
5825 }
5826
5827 if (debug_file != NULL)
5828 {
5829 if (debug_mode < 1)
5830 {
5831 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
5832
5833 return (-1);
5834 }
5835 }
5836
5837 if (induction_dir != NULL)
5838 {
5839 if (attack_mode == ATTACK_MODE_BF)
5840 {
5841 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
5842
5843 return (-1);
5844 }
5845 }
5846
5847 /**
5848 * induction directory
5849 */
5850
5851 char *induction_directory = NULL;
5852
5853 if (attack_mode != ATTACK_MODE_BF)
5854 {
5855 if (induction_dir == NULL)
5856 {
5857 induction_directory = (char *) mymalloc (session_size);
5858
5859 snprintf (induction_directory, session_size - 1, "%s.%s", session, INDUCT_DIR);
5860
5861 // create induction folder if it does not already exist
5862
5863 if (keyspace == 0)
5864 {
5865 if (rmdir (induction_directory) == -1)
5866 {
5867 if (errno == ENOENT)
5868 {
5869 // good, we can ignore
5870 }
5871 else if (errno == ENOTEMPTY)
5872 {
5873 char *induction_directory_mv = (char *) mymalloc (session_size);
5874
5875 snprintf (induction_directory_mv, session_size - 1, "%s.induct.%d", session, (int) proc_start);
5876
5877 if (rename (induction_directory, induction_directory_mv) != 0)
5878 {
5879 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
5880
5881 return (-1);
5882 }
5883 }
5884 else
5885 {
5886 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
5887
5888 return (-1);
5889 }
5890 }
5891
5892 #ifdef _WIN
5893 #define mkdir(name,mode) mkdir (name)
5894 #endif
5895
5896 if (mkdir (induction_directory, 0700) == -1)
5897 {
5898 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
5899
5900 return (-1);
5901 }
5902 }
5903 }
5904 else
5905 {
5906 induction_directory = induction_dir;
5907 }
5908 }
5909
5910 data.induction_directory = induction_directory;
5911
5912 /**
5913 * loopback
5914 */
5915
5916 size_t loopback_size = session_size + strlen (LOOPBACK_FILE) + 12;
5917
5918 char *loopback_file = (char *) mymalloc (loopback_size);
5919
5920 /**
5921 * outfile-check directory
5922 */
5923
5924 char *outfile_check_directory = NULL;
5925
5926 if (outfile_check_dir == NULL)
5927 {
5928 outfile_check_directory = (char *) mymalloc (session_size);
5929
5930 snprintf (outfile_check_directory, session_size - 1, "%s.%s", session, OUTFILES_DIR);
5931 }
5932 else
5933 {
5934 outfile_check_directory = outfile_check_dir;
5935 }
5936
5937 data.outfile_check_directory = outfile_check_directory;
5938
5939 if (keyspace == 0)
5940 {
5941 struct stat outfile_check_stat;
5942
5943 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
5944 {
5945 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
5946
5947 if (is_dir == 0)
5948 {
5949 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
5950
5951 return (-1);
5952 }
5953 }
5954 else if (outfile_check_dir == NULL)
5955 {
5956 #ifdef _WIN
5957 #define mkdir(name,mode) mkdir (name)
5958 #endif
5959
5960 if (mkdir (outfile_check_directory, 0700) == -1)
5961 {
5962 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
5963
5964 return (-1);
5965 }
5966 }
5967 }
5968
5969 /**
5970 * special other stuff
5971 */
5972
5973 if (hash_mode == 9710)
5974 {
5975 outfile_format = 5;
5976 outfile_format_chgd = 1;
5977 }
5978
5979 if (hash_mode == 9810)
5980 {
5981 outfile_format = 5;
5982 outfile_format_chgd = 1;
5983 }
5984
5985 if (hash_mode == 10410)
5986 {
5987 outfile_format = 5;
5988 outfile_format_chgd = 1;
5989 }
5990
5991 /**
5992 * store stuff
5993 */
5994
5995 data.hash_mode = hash_mode;
5996 data.restore = restore;
5997 data.restore_timer = restore_timer;
5998 data.restore_disable = restore_disable;
5999 data.status = status;
6000 data.status_timer = status_timer;
6001 data.status_automat = status_automat;
6002 data.loopback = loopback;
6003 data.runtime = runtime;
6004 data.remove = remove;
6005 data.remove_timer = remove_timer;
6006 data.debug_mode = debug_mode;
6007 data.debug_file = debug_file;
6008 data.username = username;
6009 data.quiet = quiet;
6010 data.outfile = outfile;
6011 data.outfile_format = outfile_format;
6012 data.outfile_autohex = outfile_autohex;
6013 data.hex_charset = hex_charset;
6014 data.hex_salt = hex_salt;
6015 data.hex_wordlist = hex_wordlist;
6016 data.separator = separator;
6017 data.rp_files = rp_files;
6018 data.rp_files_cnt = rp_files_cnt;
6019 data.rp_gen = rp_gen;
6020 data.rp_gen_seed = rp_gen_seed;
6021 data.force = force;
6022 data.benchmark = benchmark;
6023 data.skip = skip;
6024 data.limit = limit;
6025 data.powertune_enable = powertune_enable;
6026 data.logfile_disable = logfile_disable;
6027 data.truecrypt_keyfiles = truecrypt_keyfiles;
6028 data.scrypt_tmto = scrypt_tmto;
6029
6030 /**
6031 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
6032 */
6033
6034 #ifdef LINUX
6035
6036 char *resolved_path = realpath (myargv[0], NULL);
6037
6038 char *install_dir = get_install_dir (resolved_path);
6039 char *profile_dir = NULL;
6040 char *session_dir = NULL;
6041
6042 if (strcmp (install_dir, INSTALL_FOLDER) == 0)
6043 {
6044 struct passwd *pw = getpwuid (getuid ());
6045
6046 const char *homedir = pw->pw_dir;
6047
6048 profile_dir = get_profile_dir (homedir);
6049 session_dir = get_session_dir (profile_dir, session);
6050 }
6051 else
6052 {
6053 profile_dir = install_dir;
6054 session_dir = install_dir;
6055 }
6056
6057 myfree (resolved_path);
6058
6059 #else
6060
6061 char *install_dir = get_install_dir (myargv[0]);
6062 char *profile_dir = install_dir;
6063 char *session_dir = install_dir;
6064
6065 #endif
6066
6067 data.install_dir = install_dir;
6068 data.profile_dir = profile_dir;
6069 data.session_dir = session_dir;
6070
6071 /**
6072 * cpu affinity
6073 */
6074
6075 if (cpu_affinity)
6076 {
6077 set_cpu_affinity (cpu_affinity);
6078 }
6079
6080 if (rp_gen_seed_chgd == 0)
6081 {
6082 srand (proc_start);
6083 }
6084 else
6085 {
6086 srand (rp_gen_seed);
6087 }
6088
6089 /**
6090 * logfile init
6091 */
6092
6093 if (logfile_disable == 0)
6094 {
6095 size_t logfile_size = strlen (session) + 32;
6096
6097 char *logfile = (char *) mymalloc (logfile_size);
6098
6099 snprintf (logfile, logfile_size - 1, "%s.log", session);
6100
6101 data.logfile = logfile;
6102
6103 char *topid = logfile_generate_topid ();
6104
6105 data.topid = topid;
6106 }
6107
6108 // logfile_append() checks for logfile_disable internally to make it easier from here
6109
6110 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6111 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6112 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6113 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6114 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6115 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6116 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6117 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6118 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6119 #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));
6120
6121 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6122 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6123 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6124 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6125 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6126 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6127 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6128 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6129
6130 logfile_top_msg ("START");
6131
6132 logfile_top_uint (attack_mode);
6133 logfile_top_uint (attack_kern);
6134 logfile_top_uint (benchmark);
6135 logfile_top_uint (benchmark_mode);
6136 logfile_top_uint (bitmap_min);
6137 logfile_top_uint (bitmap_max);
6138 logfile_top_uint (debug_mode);
6139 logfile_top_uint (force);
6140 logfile_top_uint (gpu_accel);
6141 logfile_top_uint (gpu_loops);
6142 logfile_top_uint (gpu_temp_abort);
6143 logfile_top_uint (gpu_temp_disable);
6144 logfile_top_uint (gpu_temp_retain);
6145 logfile_top_uint (hash_mode);
6146 logfile_top_uint (hex_charset);
6147 logfile_top_uint (hex_salt);
6148 logfile_top_uint (hex_wordlist);
6149 logfile_top_uint (increment);
6150 logfile_top_uint (increment_max);
6151 logfile_top_uint (increment_min);
6152 logfile_top_uint (keyspace);
6153 logfile_top_uint (left);
6154 logfile_top_uint (logfile_disable);
6155 logfile_top_uint (loopback);
6156 logfile_top_uint (markov_classic);
6157 logfile_top_uint (markov_disable);
6158 logfile_top_uint (markov_threshold);
6159 logfile_top_uint (outfile_autohex);
6160 logfile_top_uint (outfile_check_timer);
6161 logfile_top_uint (outfile_format);
6162 logfile_top_uint (potfile_disable);
6163 logfile_top_uint (powertune_enable);
6164 logfile_top_uint (scrypt_tmto);
6165 logfile_top_uint (quiet);
6166 logfile_top_uint (remove);
6167 logfile_top_uint (remove_timer);
6168 logfile_top_uint (restore);
6169 logfile_top_uint (restore_disable);
6170 logfile_top_uint (restore_timer);
6171 logfile_top_uint (rp_gen);
6172 logfile_top_uint (rp_gen_func_max);
6173 logfile_top_uint (rp_gen_func_min);
6174 logfile_top_uint (rp_gen_seed);
6175 logfile_top_uint (runtime);
6176 logfile_top_uint (segment_size);
6177 logfile_top_uint (show);
6178 logfile_top_uint (status);
6179 logfile_top_uint (status_automat);
6180 logfile_top_uint (status_timer);
6181 logfile_top_uint (usage);
6182 logfile_top_uint (username);
6183 logfile_top_uint (version);
6184 logfile_top_uint (weak_hash_threshold);
6185 logfile_top_uint (workload_profile);
6186 logfile_top_uint64 (limit);
6187 logfile_top_uint64 (skip);
6188 logfile_top_char (separator);
6189 logfile_top_string (cpu_affinity);
6190 logfile_top_string (custom_charset_1);
6191 logfile_top_string (custom_charset_2);
6192 logfile_top_string (custom_charset_3);
6193 logfile_top_string (custom_charset_4);
6194 logfile_top_string (debug_file);
6195 logfile_top_string (gpu_devices);
6196 logfile_top_string (induction_dir);
6197 logfile_top_string (markov_hcstat);
6198 logfile_top_string (outfile);
6199 logfile_top_string (outfile_check_dir);
6200 logfile_top_string (rule_buf_l);
6201 logfile_top_string (rule_buf_r);
6202 logfile_top_string (session);
6203 logfile_top_string (truecrypt_keyfiles);
6204
6205 /**
6206 * devices
6207 */
6208
6209 uint gpu_devicemask = devices_to_devicemask (gpu_devices);
6210
6211 /**
6212 * benchmark
6213 */
6214
6215 if (benchmark == 1)
6216 {
6217 /**
6218 * disable useless stuff for benchmark
6219 */
6220
6221 restore_timer = 0;
6222 status_timer = 0;
6223 restore_disable = 1;
6224 potfile_disable = 1;
6225 weak_hash_threshold = 0;
6226
6227 data.restore_timer = restore_timer;
6228 data.status_timer = status_timer;
6229 data.restore_disable = restore_disable;
6230
6231 if (benchmark_mode == 1)
6232 {
6233 markov_disable = 1;
6234 }
6235
6236 /**
6237 * force attack mode to be bruteforce
6238 */
6239
6240 attack_mode = ATTACK_MODE_BF;
6241 attack_kern = ATTACK_KERN_BF;
6242
6243 if (runtime_chgd == 0)
6244 {
6245 runtime = 4;
6246
6247 if (benchmark_mode == 1) runtime = 17;
6248
6249 data.runtime = runtime;
6250 }
6251 }
6252
6253 /**
6254 * config
6255 */
6256
6257 uint hash_type = 0;
6258 uint salt_type = 0;
6259 uint attack_exec = 0;
6260 uint opts_type = 0;
6261 uint kern_type = 0;
6262 uint dgst_size = 0;
6263 uint esalt_size = 0;
6264 uint opti_type = 0;
6265 uint dgst_pos0 = -1;
6266 uint dgst_pos1 = -1;
6267 uint dgst_pos2 = -1;
6268 uint dgst_pos3 = -1;
6269
6270 int (*parse_func) (char *, uint, hash_t *);
6271 int (*sort_by_digest) (const void *, const void *);
6272
6273 uint algorithm_pos = 0;
6274 uint algorithm_max = 1;
6275
6276 uint *algorithms = default_benchmark_algorithms;
6277
6278 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6279
6280 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6281 {
6282 /*
6283 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6284 * the following algos are skipped entirely
6285 */
6286
6287 if (algorithm_pos > 0)
6288 {
6289 local_free (rd);
6290
6291 rd = init_restore (argc, argv);
6292
6293 data.rd = rd;
6294 }
6295
6296 /**
6297 * update hash_mode in case of multihash benchmark
6298 */
6299
6300 if (benchmark == 1)
6301 {
6302 if (hash_mode_chgd == 0)
6303 {
6304 hash_mode = algorithms[algorithm_pos];
6305
6306 data.hash_mode = hash_mode;
6307 }
6308
6309 quiet = 1;
6310
6311 data.quiet = quiet;
6312 }
6313
6314 switch (hash_mode)
6315 {
6316 case 0: hash_type = HASH_TYPE_MD5;
6317 salt_type = SALT_TYPE_NONE;
6318 attack_exec = ATTACK_EXEC_ON_GPU;
6319 opts_type = OPTS_TYPE_PT_GENERATE_LE
6320 | OPTS_TYPE_PT_ADD80
6321 | OPTS_TYPE_PT_ADDBITS14;
6322 kern_type = KERN_TYPE_MD5;
6323 dgst_size = DGST_SIZE_4_4;
6324 parse_func = md5_parse_hash;
6325 sort_by_digest = sort_by_digest_4_4;
6326 opti_type = OPTI_TYPE_ZERO_BYTE
6327 | OPTI_TYPE_PRECOMPUTE_INIT
6328 | OPTI_TYPE_PRECOMPUTE_MERKLE
6329 | OPTI_TYPE_MEET_IN_MIDDLE
6330 | OPTI_TYPE_EARLY_SKIP
6331 | OPTI_TYPE_NOT_ITERATED
6332 | OPTI_TYPE_NOT_SALTED
6333 | OPTI_TYPE_RAW_HASH;
6334 dgst_pos0 = 0;
6335 dgst_pos1 = 3;
6336 dgst_pos2 = 2;
6337 dgst_pos3 = 1;
6338 break;
6339
6340 case 10: hash_type = HASH_TYPE_MD5;
6341 salt_type = SALT_TYPE_INTERN;
6342 attack_exec = ATTACK_EXEC_ON_GPU;
6343 opts_type = OPTS_TYPE_PT_GENERATE_LE
6344 | OPTS_TYPE_ST_ADD80
6345 | OPTS_TYPE_ST_ADDBITS14;
6346 kern_type = KERN_TYPE_MD5_PWSLT;
6347 dgst_size = DGST_SIZE_4_4;
6348 parse_func = md5s_parse_hash;
6349 sort_by_digest = sort_by_digest_4_4;
6350 opti_type = OPTI_TYPE_ZERO_BYTE
6351 | OPTI_TYPE_PRECOMPUTE_INIT
6352 | OPTI_TYPE_PRECOMPUTE_MERKLE
6353 | OPTI_TYPE_MEET_IN_MIDDLE
6354 | OPTI_TYPE_EARLY_SKIP
6355 | OPTI_TYPE_NOT_ITERATED
6356 | OPTI_TYPE_APPENDED_SALT
6357 | OPTI_TYPE_RAW_HASH;
6358 dgst_pos0 = 0;
6359 dgst_pos1 = 3;
6360 dgst_pos2 = 2;
6361 dgst_pos3 = 1;
6362 break;
6363
6364 case 11: hash_type = HASH_TYPE_MD5;
6365 salt_type = SALT_TYPE_INTERN;
6366 attack_exec = ATTACK_EXEC_ON_GPU;
6367 opts_type = OPTS_TYPE_PT_GENERATE_LE
6368 | OPTS_TYPE_ST_ADD80
6369 | OPTS_TYPE_ST_ADDBITS14;
6370 kern_type = KERN_TYPE_MD5_PWSLT;
6371 dgst_size = DGST_SIZE_4_4;
6372 parse_func = joomla_parse_hash;
6373 sort_by_digest = sort_by_digest_4_4;
6374 opti_type = OPTI_TYPE_ZERO_BYTE
6375 | OPTI_TYPE_PRECOMPUTE_INIT
6376 | OPTI_TYPE_PRECOMPUTE_MERKLE
6377 | OPTI_TYPE_MEET_IN_MIDDLE
6378 | OPTI_TYPE_EARLY_SKIP
6379 | OPTI_TYPE_NOT_ITERATED
6380 | OPTI_TYPE_APPENDED_SALT
6381 | OPTI_TYPE_RAW_HASH;
6382 dgst_pos0 = 0;
6383 dgst_pos1 = 3;
6384 dgst_pos2 = 2;
6385 dgst_pos3 = 1;
6386 break;
6387
6388 case 12: hash_type = HASH_TYPE_MD5;
6389 salt_type = SALT_TYPE_INTERN;
6390 attack_exec = ATTACK_EXEC_ON_GPU;
6391 opts_type = OPTS_TYPE_PT_GENERATE_LE
6392 | OPTS_TYPE_ST_ADD80
6393 | OPTS_TYPE_ST_ADDBITS14;
6394 kern_type = KERN_TYPE_MD5_PWSLT;
6395 dgst_size = DGST_SIZE_4_4;
6396 parse_func = postgresql_parse_hash;
6397 sort_by_digest = sort_by_digest_4_4;
6398 opti_type = OPTI_TYPE_ZERO_BYTE
6399 | OPTI_TYPE_PRECOMPUTE_INIT
6400 | OPTI_TYPE_PRECOMPUTE_MERKLE
6401 | OPTI_TYPE_MEET_IN_MIDDLE
6402 | OPTI_TYPE_EARLY_SKIP
6403 | OPTI_TYPE_NOT_ITERATED
6404 | OPTI_TYPE_APPENDED_SALT
6405 | OPTI_TYPE_RAW_HASH;
6406 dgst_pos0 = 0;
6407 dgst_pos1 = 3;
6408 dgst_pos2 = 2;
6409 dgst_pos3 = 1;
6410 break;
6411
6412 case 20: hash_type = HASH_TYPE_MD5;
6413 salt_type = SALT_TYPE_INTERN;
6414 attack_exec = ATTACK_EXEC_ON_GPU;
6415 opts_type = OPTS_TYPE_PT_GENERATE_LE
6416 | OPTS_TYPE_PT_ADD80
6417 | OPTS_TYPE_PT_ADDBITS14;
6418 kern_type = KERN_TYPE_MD5_SLTPW;
6419 dgst_size = DGST_SIZE_4_4;
6420 parse_func = md5s_parse_hash;
6421 sort_by_digest = sort_by_digest_4_4;
6422 opti_type = OPTI_TYPE_ZERO_BYTE
6423 | OPTI_TYPE_PRECOMPUTE_INIT
6424 | OPTI_TYPE_PRECOMPUTE_MERKLE
6425 | OPTI_TYPE_EARLY_SKIP
6426 | OPTI_TYPE_NOT_ITERATED
6427 | OPTI_TYPE_PREPENDED_SALT
6428 | OPTI_TYPE_RAW_HASH;
6429 dgst_pos0 = 0;
6430 dgst_pos1 = 3;
6431 dgst_pos2 = 2;
6432 dgst_pos3 = 1;
6433 break;
6434
6435 case 21: hash_type = HASH_TYPE_MD5;
6436 salt_type = SALT_TYPE_INTERN;
6437 attack_exec = ATTACK_EXEC_ON_GPU;
6438 opts_type = OPTS_TYPE_PT_GENERATE_LE
6439 | OPTS_TYPE_PT_ADD80
6440 | OPTS_TYPE_PT_ADDBITS14;
6441 kern_type = KERN_TYPE_MD5_SLTPW;
6442 dgst_size = DGST_SIZE_4_4;
6443 parse_func = osc_parse_hash;
6444 sort_by_digest = sort_by_digest_4_4;
6445 opti_type = OPTI_TYPE_ZERO_BYTE
6446 | OPTI_TYPE_PRECOMPUTE_INIT
6447 | OPTI_TYPE_PRECOMPUTE_MERKLE
6448 | OPTI_TYPE_EARLY_SKIP
6449 | OPTI_TYPE_NOT_ITERATED
6450 | OPTI_TYPE_PREPENDED_SALT
6451 | OPTI_TYPE_RAW_HASH;
6452 dgst_pos0 = 0;
6453 dgst_pos1 = 3;
6454 dgst_pos2 = 2;
6455 dgst_pos3 = 1;
6456 break;
6457
6458 case 22: hash_type = HASH_TYPE_MD5;
6459 salt_type = SALT_TYPE_EMBEDDED;
6460 attack_exec = ATTACK_EXEC_ON_GPU;
6461 opts_type = OPTS_TYPE_PT_GENERATE_LE
6462 | OPTS_TYPE_PT_ADD80
6463 | OPTS_TYPE_PT_ADDBITS14;
6464 kern_type = KERN_TYPE_MD5_SLTPW;
6465 dgst_size = DGST_SIZE_4_4;
6466 parse_func = netscreen_parse_hash;
6467 sort_by_digest = sort_by_digest_4_4;
6468 opti_type = OPTI_TYPE_ZERO_BYTE
6469 | OPTI_TYPE_PRECOMPUTE_INIT
6470 | OPTI_TYPE_PRECOMPUTE_MERKLE
6471 | OPTI_TYPE_EARLY_SKIP
6472 | OPTI_TYPE_NOT_ITERATED
6473 | OPTI_TYPE_PREPENDED_SALT
6474 | OPTI_TYPE_RAW_HASH;
6475 dgst_pos0 = 0;
6476 dgst_pos1 = 3;
6477 dgst_pos2 = 2;
6478 dgst_pos3 = 1;
6479 break;
6480
6481 case 23: hash_type = HASH_TYPE_MD5;
6482 salt_type = SALT_TYPE_EMBEDDED;
6483 attack_exec = ATTACK_EXEC_ON_GPU;
6484 opts_type = OPTS_TYPE_PT_GENERATE_LE
6485 | OPTS_TYPE_PT_ADD80
6486 | OPTS_TYPE_PT_ADDBITS14;
6487 kern_type = KERN_TYPE_MD5_SLTPW;
6488 dgst_size = DGST_SIZE_4_4;
6489 parse_func = skype_parse_hash;
6490 sort_by_digest = sort_by_digest_4_4;
6491 opti_type = OPTI_TYPE_ZERO_BYTE
6492 | OPTI_TYPE_PRECOMPUTE_INIT
6493 | OPTI_TYPE_PRECOMPUTE_MERKLE
6494 | OPTI_TYPE_EARLY_SKIP
6495 | OPTI_TYPE_NOT_ITERATED
6496 | OPTI_TYPE_PREPENDED_SALT
6497 | OPTI_TYPE_RAW_HASH;
6498 dgst_pos0 = 0;
6499 dgst_pos1 = 3;
6500 dgst_pos2 = 2;
6501 dgst_pos3 = 1;
6502 break;
6503
6504 case 30: hash_type = HASH_TYPE_MD5;
6505 salt_type = SALT_TYPE_INTERN;
6506 attack_exec = ATTACK_EXEC_ON_GPU;
6507 opts_type = OPTS_TYPE_PT_GENERATE_LE
6508 | OPTS_TYPE_PT_UNICODE
6509 | OPTS_TYPE_ST_ADD80
6510 | OPTS_TYPE_ST_ADDBITS14;
6511 kern_type = KERN_TYPE_MD5_PWUSLT;
6512 dgst_size = DGST_SIZE_4_4;
6513 parse_func = md5s_parse_hash;
6514 sort_by_digest = sort_by_digest_4_4;
6515 opti_type = OPTI_TYPE_ZERO_BYTE
6516 | OPTI_TYPE_PRECOMPUTE_INIT
6517 | OPTI_TYPE_PRECOMPUTE_MERKLE
6518 | OPTI_TYPE_MEET_IN_MIDDLE
6519 | OPTI_TYPE_EARLY_SKIP
6520 | OPTI_TYPE_NOT_ITERATED
6521 | OPTI_TYPE_APPENDED_SALT
6522 | OPTI_TYPE_RAW_HASH;
6523 dgst_pos0 = 0;
6524 dgst_pos1 = 3;
6525 dgst_pos2 = 2;
6526 dgst_pos3 = 1;
6527 break;
6528
6529 case 40: hash_type = HASH_TYPE_MD5;
6530 salt_type = SALT_TYPE_INTERN;
6531 attack_exec = ATTACK_EXEC_ON_GPU;
6532 opts_type = OPTS_TYPE_PT_GENERATE_LE
6533 | OPTS_TYPE_PT_ADD80
6534 | OPTS_TYPE_PT_ADDBITS14
6535 | OPTS_TYPE_PT_UNICODE;
6536 kern_type = KERN_TYPE_MD5_SLTPWU;
6537 dgst_size = DGST_SIZE_4_4;
6538 parse_func = md5s_parse_hash;
6539 sort_by_digest = sort_by_digest_4_4;
6540 opti_type = OPTI_TYPE_ZERO_BYTE
6541 | OPTI_TYPE_PRECOMPUTE_INIT
6542 | OPTI_TYPE_PRECOMPUTE_MERKLE
6543 | OPTI_TYPE_EARLY_SKIP
6544 | OPTI_TYPE_NOT_ITERATED
6545 | OPTI_TYPE_PREPENDED_SALT
6546 | OPTI_TYPE_RAW_HASH;
6547 dgst_pos0 = 0;
6548 dgst_pos1 = 3;
6549 dgst_pos2 = 2;
6550 dgst_pos3 = 1;
6551 break;
6552
6553 case 50: hash_type = HASH_TYPE_MD5;
6554 salt_type = SALT_TYPE_INTERN;
6555 attack_exec = ATTACK_EXEC_ON_GPU;
6556 opts_type = OPTS_TYPE_PT_GENERATE_LE
6557 | OPTS_TYPE_ST_ADD80
6558 | OPTS_TYPE_ST_ADDBITS14;
6559 kern_type = KERN_TYPE_HMACMD5_PW;
6560 dgst_size = DGST_SIZE_4_4;
6561 parse_func = hmacmd5_parse_hash;
6562 sort_by_digest = sort_by_digest_4_4;
6563 opti_type = OPTI_TYPE_ZERO_BYTE
6564 | OPTI_TYPE_NOT_ITERATED;
6565 dgst_pos0 = 0;
6566 dgst_pos1 = 3;
6567 dgst_pos2 = 2;
6568 dgst_pos3 = 1;
6569 break;
6570
6571 case 60: hash_type = HASH_TYPE_MD5;
6572 salt_type = SALT_TYPE_INTERN;
6573 attack_exec = ATTACK_EXEC_ON_GPU;
6574 opts_type = OPTS_TYPE_PT_GENERATE_LE
6575 | OPTS_TYPE_PT_ADD80
6576 | OPTS_TYPE_PT_ADDBITS14;
6577 kern_type = KERN_TYPE_HMACMD5_SLT;
6578 dgst_size = DGST_SIZE_4_4;
6579 parse_func = hmacmd5_parse_hash;
6580 sort_by_digest = sort_by_digest_4_4;
6581 opti_type = OPTI_TYPE_ZERO_BYTE
6582 | OPTI_TYPE_NOT_ITERATED;
6583 dgst_pos0 = 0;
6584 dgst_pos1 = 3;
6585 dgst_pos2 = 2;
6586 dgst_pos3 = 1;
6587 break;
6588
6589 case 100: hash_type = HASH_TYPE_SHA1;
6590 salt_type = SALT_TYPE_NONE;
6591 attack_exec = ATTACK_EXEC_ON_GPU;
6592 opts_type = OPTS_TYPE_PT_GENERATE_BE
6593 | OPTS_TYPE_PT_ADD80
6594 | OPTS_TYPE_PT_ADDBITS15;
6595 kern_type = KERN_TYPE_SHA1;
6596 dgst_size = DGST_SIZE_4_5;
6597 parse_func = sha1_parse_hash;
6598 sort_by_digest = sort_by_digest_4_5;
6599 opti_type = OPTI_TYPE_ZERO_BYTE
6600 | OPTI_TYPE_PRECOMPUTE_INIT
6601 | OPTI_TYPE_PRECOMPUTE_MERKLE
6602 | OPTI_TYPE_EARLY_SKIP
6603 | OPTI_TYPE_NOT_ITERATED
6604 | OPTI_TYPE_NOT_SALTED
6605 | OPTI_TYPE_RAW_HASH;
6606 dgst_pos0 = 3;
6607 dgst_pos1 = 4;
6608 dgst_pos2 = 2;
6609 dgst_pos3 = 1;
6610 break;
6611
6612 case 101: hash_type = HASH_TYPE_SHA1;
6613 salt_type = SALT_TYPE_NONE;
6614 attack_exec = ATTACK_EXEC_ON_GPU;
6615 opts_type = OPTS_TYPE_PT_GENERATE_BE
6616 | OPTS_TYPE_PT_ADD80
6617 | OPTS_TYPE_PT_ADDBITS15;
6618 kern_type = KERN_TYPE_SHA1;
6619 dgst_size = DGST_SIZE_4_5;
6620 parse_func = sha1b64_parse_hash;
6621 sort_by_digest = sort_by_digest_4_5;
6622 opti_type = OPTI_TYPE_ZERO_BYTE
6623 | OPTI_TYPE_PRECOMPUTE_INIT
6624 | OPTI_TYPE_PRECOMPUTE_MERKLE
6625 | OPTI_TYPE_EARLY_SKIP
6626 | OPTI_TYPE_NOT_ITERATED
6627 | OPTI_TYPE_NOT_SALTED
6628 | OPTI_TYPE_RAW_HASH;
6629 dgst_pos0 = 3;
6630 dgst_pos1 = 4;
6631 dgst_pos2 = 2;
6632 dgst_pos3 = 1;
6633 break;
6634
6635 case 110: hash_type = HASH_TYPE_SHA1;
6636 salt_type = SALT_TYPE_INTERN;
6637 attack_exec = ATTACK_EXEC_ON_GPU;
6638 opts_type = OPTS_TYPE_PT_GENERATE_BE
6639 | OPTS_TYPE_ST_ADD80
6640 | OPTS_TYPE_ST_ADDBITS15;
6641 kern_type = KERN_TYPE_SHA1_PWSLT;
6642 dgst_size = DGST_SIZE_4_5;
6643 parse_func = sha1s_parse_hash;
6644 sort_by_digest = sort_by_digest_4_5;
6645 opti_type = OPTI_TYPE_ZERO_BYTE
6646 | OPTI_TYPE_PRECOMPUTE_INIT
6647 | OPTI_TYPE_PRECOMPUTE_MERKLE
6648 | OPTI_TYPE_EARLY_SKIP
6649 | OPTI_TYPE_NOT_ITERATED
6650 | OPTI_TYPE_APPENDED_SALT
6651 | OPTI_TYPE_RAW_HASH;
6652 dgst_pos0 = 3;
6653 dgst_pos1 = 4;
6654 dgst_pos2 = 2;
6655 dgst_pos3 = 1;
6656 break;
6657
6658 case 111: hash_type = HASH_TYPE_SHA1;
6659 salt_type = SALT_TYPE_EMBEDDED;
6660 attack_exec = ATTACK_EXEC_ON_GPU;
6661 opts_type = OPTS_TYPE_PT_GENERATE_BE
6662 | OPTS_TYPE_ST_ADD80
6663 | OPTS_TYPE_ST_ADDBITS15;
6664 kern_type = KERN_TYPE_SHA1_PWSLT;
6665 dgst_size = DGST_SIZE_4_5;
6666 parse_func = sha1b64s_parse_hash;
6667 sort_by_digest = sort_by_digest_4_5;
6668 opti_type = OPTI_TYPE_ZERO_BYTE
6669 | OPTI_TYPE_PRECOMPUTE_INIT
6670 | OPTI_TYPE_PRECOMPUTE_MERKLE
6671 | OPTI_TYPE_EARLY_SKIP
6672 | OPTI_TYPE_NOT_ITERATED
6673 | OPTI_TYPE_APPENDED_SALT
6674 | OPTI_TYPE_RAW_HASH;
6675 dgst_pos0 = 3;
6676 dgst_pos1 = 4;
6677 dgst_pos2 = 2;
6678 dgst_pos3 = 1;
6679 break;
6680
6681 case 112: hash_type = HASH_TYPE_SHA1;
6682 salt_type = SALT_TYPE_INTERN;
6683 attack_exec = ATTACK_EXEC_ON_GPU;
6684 opts_type = OPTS_TYPE_PT_GENERATE_BE
6685 | OPTS_TYPE_ST_ADD80
6686 | OPTS_TYPE_ST_ADDBITS15
6687 | OPTS_TYPE_ST_HEX;
6688 kern_type = KERN_TYPE_SHA1_PWSLT;
6689 dgst_size = DGST_SIZE_4_5;
6690 parse_func = oracles_parse_hash;
6691 sort_by_digest = sort_by_digest_4_5;
6692 opti_type = OPTI_TYPE_ZERO_BYTE
6693 | OPTI_TYPE_PRECOMPUTE_INIT
6694 | OPTI_TYPE_PRECOMPUTE_MERKLE
6695 | OPTI_TYPE_EARLY_SKIP
6696 | OPTI_TYPE_NOT_ITERATED
6697 | OPTI_TYPE_APPENDED_SALT
6698 | OPTI_TYPE_RAW_HASH;
6699 dgst_pos0 = 3;
6700 dgst_pos1 = 4;
6701 dgst_pos2 = 2;
6702 dgst_pos3 = 1;
6703 break;
6704
6705 case 120: hash_type = HASH_TYPE_SHA1;
6706 salt_type = SALT_TYPE_INTERN;
6707 attack_exec = ATTACK_EXEC_ON_GPU;
6708 opts_type = OPTS_TYPE_PT_GENERATE_BE
6709 | OPTS_TYPE_PT_ADD80
6710 | OPTS_TYPE_PT_ADDBITS15;
6711 kern_type = KERN_TYPE_SHA1_SLTPW;
6712 dgst_size = DGST_SIZE_4_5;
6713 parse_func = sha1s_parse_hash;
6714 sort_by_digest = sort_by_digest_4_5;
6715 opti_type = OPTI_TYPE_ZERO_BYTE
6716 | OPTI_TYPE_PRECOMPUTE_INIT
6717 | OPTI_TYPE_PRECOMPUTE_MERKLE
6718 | OPTI_TYPE_EARLY_SKIP
6719 | OPTI_TYPE_NOT_ITERATED
6720 | OPTI_TYPE_PREPENDED_SALT
6721 | OPTI_TYPE_RAW_HASH;
6722 dgst_pos0 = 3;
6723 dgst_pos1 = 4;
6724 dgst_pos2 = 2;
6725 dgst_pos3 = 1;
6726 break;
6727
6728 case 121: hash_type = HASH_TYPE_SHA1;
6729 salt_type = SALT_TYPE_INTERN;
6730 attack_exec = ATTACK_EXEC_ON_GPU;
6731 opts_type = OPTS_TYPE_PT_GENERATE_BE
6732 | OPTS_TYPE_PT_ADD80
6733 | OPTS_TYPE_PT_ADDBITS15
6734 | OPTS_TYPE_ST_LOWER;
6735 kern_type = KERN_TYPE_SHA1_SLTPW;
6736 dgst_size = DGST_SIZE_4_5;
6737 parse_func = smf_parse_hash;
6738 sort_by_digest = sort_by_digest_4_5;
6739 opti_type = OPTI_TYPE_ZERO_BYTE
6740 | OPTI_TYPE_PRECOMPUTE_INIT
6741 | OPTI_TYPE_PRECOMPUTE_MERKLE
6742 | OPTI_TYPE_EARLY_SKIP
6743 | OPTI_TYPE_NOT_ITERATED
6744 | OPTI_TYPE_PREPENDED_SALT
6745 | OPTI_TYPE_RAW_HASH;
6746 dgst_pos0 = 3;
6747 dgst_pos1 = 4;
6748 dgst_pos2 = 2;
6749 dgst_pos3 = 1;
6750 break;
6751
6752 case 122: hash_type = HASH_TYPE_SHA1;
6753 salt_type = SALT_TYPE_EMBEDDED;
6754 attack_exec = ATTACK_EXEC_ON_GPU;
6755 opts_type = OPTS_TYPE_PT_GENERATE_BE
6756 | OPTS_TYPE_PT_ADD80
6757 | OPTS_TYPE_PT_ADDBITS15
6758 | OPTS_TYPE_ST_HEX;
6759 kern_type = KERN_TYPE_SHA1_SLTPW;
6760 dgst_size = DGST_SIZE_4_5;
6761 parse_func = osx1_parse_hash;
6762 sort_by_digest = sort_by_digest_4_5;
6763 opti_type = OPTI_TYPE_ZERO_BYTE
6764 | OPTI_TYPE_PRECOMPUTE_INIT
6765 | OPTI_TYPE_PRECOMPUTE_MERKLE
6766 | OPTI_TYPE_EARLY_SKIP
6767 | OPTI_TYPE_NOT_ITERATED
6768 | OPTI_TYPE_PREPENDED_SALT
6769 | OPTI_TYPE_RAW_HASH;
6770 dgst_pos0 = 3;
6771 dgst_pos1 = 4;
6772 dgst_pos2 = 2;
6773 dgst_pos3 = 1;
6774 break;
6775
6776 case 124: hash_type = HASH_TYPE_SHA1;
6777 salt_type = SALT_TYPE_EMBEDDED;
6778 attack_exec = ATTACK_EXEC_ON_GPU;
6779 opts_type = OPTS_TYPE_PT_GENERATE_BE
6780 | OPTS_TYPE_PT_ADD80
6781 | OPTS_TYPE_PT_ADDBITS15;
6782 kern_type = KERN_TYPE_SHA1_SLTPW;
6783 dgst_size = DGST_SIZE_4_5;
6784 parse_func = djangosha1_parse_hash;
6785 sort_by_digest = sort_by_digest_4_5;
6786 opti_type = OPTI_TYPE_ZERO_BYTE
6787 | OPTI_TYPE_PRECOMPUTE_INIT
6788 | OPTI_TYPE_PRECOMPUTE_MERKLE
6789 | OPTI_TYPE_EARLY_SKIP
6790 | OPTI_TYPE_NOT_ITERATED
6791 | OPTI_TYPE_PREPENDED_SALT
6792 | OPTI_TYPE_RAW_HASH;
6793 dgst_pos0 = 3;
6794 dgst_pos1 = 4;
6795 dgst_pos2 = 2;
6796 dgst_pos3 = 1;
6797 break;
6798
6799 case 130: hash_type = HASH_TYPE_SHA1;
6800 salt_type = SALT_TYPE_INTERN;
6801 attack_exec = ATTACK_EXEC_ON_GPU;
6802 opts_type = OPTS_TYPE_PT_GENERATE_BE
6803 | OPTS_TYPE_PT_UNICODE
6804 | OPTS_TYPE_ST_ADD80
6805 | OPTS_TYPE_ST_ADDBITS15;
6806 kern_type = KERN_TYPE_SHA1_PWUSLT;
6807 dgst_size = DGST_SIZE_4_5;
6808 parse_func = sha1s_parse_hash;
6809 sort_by_digest = sort_by_digest_4_5;
6810 opti_type = OPTI_TYPE_ZERO_BYTE
6811 | OPTI_TYPE_PRECOMPUTE_INIT
6812 | OPTI_TYPE_PRECOMPUTE_MERKLE
6813 | OPTI_TYPE_EARLY_SKIP
6814 | OPTI_TYPE_NOT_ITERATED
6815 | OPTI_TYPE_APPENDED_SALT
6816 | OPTI_TYPE_RAW_HASH;
6817 dgst_pos0 = 3;
6818 dgst_pos1 = 4;
6819 dgst_pos2 = 2;
6820 dgst_pos3 = 1;
6821 break;
6822
6823 case 131: hash_type = HASH_TYPE_SHA1;
6824 salt_type = SALT_TYPE_EMBEDDED;
6825 attack_exec = ATTACK_EXEC_ON_GPU;
6826 opts_type = OPTS_TYPE_PT_GENERATE_BE
6827 | OPTS_TYPE_PT_UNICODE
6828 | OPTS_TYPE_PT_UPPER
6829 | OPTS_TYPE_ST_ADD80
6830 | OPTS_TYPE_ST_ADDBITS15
6831 | OPTS_TYPE_ST_HEX;
6832 kern_type = KERN_TYPE_SHA1_PWUSLT;
6833 dgst_size = DGST_SIZE_4_5;
6834 parse_func = mssql2000_parse_hash;
6835 sort_by_digest = sort_by_digest_4_5;
6836 opti_type = OPTI_TYPE_ZERO_BYTE
6837 | OPTI_TYPE_PRECOMPUTE_INIT
6838 | OPTI_TYPE_PRECOMPUTE_MERKLE
6839 | OPTI_TYPE_EARLY_SKIP
6840 | OPTI_TYPE_NOT_ITERATED
6841 | OPTI_TYPE_APPENDED_SALT
6842 | OPTI_TYPE_RAW_HASH;
6843 dgst_pos0 = 3;
6844 dgst_pos1 = 4;
6845 dgst_pos2 = 2;
6846 dgst_pos3 = 1;
6847 break;
6848
6849 case 132: hash_type = HASH_TYPE_SHA1;
6850 salt_type = SALT_TYPE_EMBEDDED;
6851 attack_exec = ATTACK_EXEC_ON_GPU;
6852 opts_type = OPTS_TYPE_PT_GENERATE_BE
6853 | OPTS_TYPE_PT_UNICODE
6854 | OPTS_TYPE_ST_ADD80
6855 | OPTS_TYPE_ST_ADDBITS15
6856 | OPTS_TYPE_ST_HEX;
6857 kern_type = KERN_TYPE_SHA1_PWUSLT;
6858 dgst_size = DGST_SIZE_4_5;
6859 parse_func = mssql2005_parse_hash;
6860 sort_by_digest = sort_by_digest_4_5;
6861 opti_type = OPTI_TYPE_ZERO_BYTE
6862 | OPTI_TYPE_PRECOMPUTE_INIT
6863 | OPTI_TYPE_PRECOMPUTE_MERKLE
6864 | OPTI_TYPE_EARLY_SKIP
6865 | OPTI_TYPE_NOT_ITERATED
6866 | OPTI_TYPE_APPENDED_SALT
6867 | OPTI_TYPE_RAW_HASH;
6868 dgst_pos0 = 3;
6869 dgst_pos1 = 4;
6870 dgst_pos2 = 2;
6871 dgst_pos3 = 1;
6872 break;
6873
6874 case 133: hash_type = HASH_TYPE_SHA1;
6875 salt_type = SALT_TYPE_EMBEDDED;
6876 attack_exec = ATTACK_EXEC_ON_GPU;
6877 opts_type = OPTS_TYPE_PT_GENERATE_BE
6878 | OPTS_TYPE_PT_UNICODE
6879 | OPTS_TYPE_ST_ADD80
6880 | OPTS_TYPE_ST_ADDBITS15;
6881 kern_type = KERN_TYPE_SHA1_PWUSLT;
6882 dgst_size = DGST_SIZE_4_5;
6883 parse_func = peoplesoft_parse_hash;
6884 sort_by_digest = sort_by_digest_4_5;
6885 opti_type = OPTI_TYPE_ZERO_BYTE
6886 | OPTI_TYPE_PRECOMPUTE_INIT
6887 | OPTI_TYPE_PRECOMPUTE_MERKLE
6888 | OPTI_TYPE_EARLY_SKIP
6889 | OPTI_TYPE_NOT_ITERATED
6890 | OPTI_TYPE_APPENDED_SALT
6891 | OPTI_TYPE_RAW_HASH;
6892 dgst_pos0 = 3;
6893 dgst_pos1 = 4;
6894 dgst_pos2 = 2;
6895 dgst_pos3 = 1;
6896 break;
6897
6898 case 140: hash_type = HASH_TYPE_SHA1;
6899 salt_type = SALT_TYPE_INTERN;
6900 attack_exec = ATTACK_EXEC_ON_GPU;
6901 opts_type = OPTS_TYPE_PT_GENERATE_BE
6902 | OPTS_TYPE_PT_ADD80
6903 | OPTS_TYPE_PT_ADDBITS15
6904 | OPTS_TYPE_PT_UNICODE;
6905 kern_type = KERN_TYPE_SHA1_SLTPWU;
6906 dgst_size = DGST_SIZE_4_5;
6907 parse_func = sha1s_parse_hash;
6908 sort_by_digest = sort_by_digest_4_5;
6909 opti_type = OPTI_TYPE_ZERO_BYTE
6910 | OPTI_TYPE_PRECOMPUTE_INIT
6911 | OPTI_TYPE_PRECOMPUTE_MERKLE
6912 | OPTI_TYPE_EARLY_SKIP
6913 | OPTI_TYPE_NOT_ITERATED
6914 | OPTI_TYPE_PREPENDED_SALT
6915 | OPTI_TYPE_RAW_HASH;
6916 dgst_pos0 = 3;
6917 dgst_pos1 = 4;
6918 dgst_pos2 = 2;
6919 dgst_pos3 = 1;
6920 break;
6921
6922 case 141: hash_type = HASH_TYPE_SHA1;
6923 salt_type = SALT_TYPE_EMBEDDED;
6924 attack_exec = ATTACK_EXEC_ON_GPU;
6925 opts_type = OPTS_TYPE_PT_GENERATE_BE
6926 | OPTS_TYPE_PT_ADD80
6927 | OPTS_TYPE_PT_ADDBITS15
6928 | OPTS_TYPE_PT_UNICODE
6929 | OPTS_TYPE_ST_BASE64;
6930 kern_type = KERN_TYPE_SHA1_SLTPWU;
6931 dgst_size = DGST_SIZE_4_5;
6932 parse_func = episerver_parse_hash;
6933 sort_by_digest = sort_by_digest_4_5;
6934 opti_type = OPTI_TYPE_ZERO_BYTE
6935 | OPTI_TYPE_PRECOMPUTE_INIT
6936 | OPTI_TYPE_PRECOMPUTE_MERKLE
6937 | OPTI_TYPE_EARLY_SKIP
6938 | OPTI_TYPE_NOT_ITERATED
6939 | OPTI_TYPE_PREPENDED_SALT
6940 | OPTI_TYPE_RAW_HASH;
6941 dgst_pos0 = 3;
6942 dgst_pos1 = 4;
6943 dgst_pos2 = 2;
6944 dgst_pos3 = 1;
6945 break;
6946
6947 case 150: hash_type = HASH_TYPE_SHA1;
6948 salt_type = SALT_TYPE_INTERN;
6949 attack_exec = ATTACK_EXEC_ON_GPU;
6950 opts_type = OPTS_TYPE_PT_GENERATE_BE
6951 | OPTS_TYPE_ST_ADD80
6952 | OPTS_TYPE_ST_ADDBITS15;
6953 kern_type = KERN_TYPE_HMACSHA1_PW;
6954 dgst_size = DGST_SIZE_4_5;
6955 parse_func = hmacsha1_parse_hash;
6956 sort_by_digest = sort_by_digest_4_5;
6957 opti_type = OPTI_TYPE_ZERO_BYTE
6958 | OPTI_TYPE_NOT_ITERATED;
6959 dgst_pos0 = 3;
6960 dgst_pos1 = 4;
6961 dgst_pos2 = 2;
6962 dgst_pos3 = 1;
6963 break;
6964
6965 case 160: hash_type = HASH_TYPE_SHA1;
6966 salt_type = SALT_TYPE_INTERN;
6967 attack_exec = ATTACK_EXEC_ON_GPU;
6968 opts_type = OPTS_TYPE_PT_GENERATE_BE
6969 | OPTS_TYPE_PT_ADD80
6970 | OPTS_TYPE_PT_ADDBITS15;
6971 kern_type = KERN_TYPE_HMACSHA1_SLT;
6972 dgst_size = DGST_SIZE_4_5;
6973 parse_func = hmacsha1_parse_hash;
6974 sort_by_digest = sort_by_digest_4_5;
6975 opti_type = OPTI_TYPE_ZERO_BYTE
6976 | OPTI_TYPE_NOT_ITERATED;
6977 dgst_pos0 = 3;
6978 dgst_pos1 = 4;
6979 dgst_pos2 = 2;
6980 dgst_pos3 = 1;
6981 break;
6982
6983 case 190: hash_type = HASH_TYPE_SHA1;
6984 salt_type = SALT_TYPE_NONE;
6985 attack_exec = ATTACK_EXEC_ON_GPU;
6986 opts_type = OPTS_TYPE_PT_GENERATE_BE
6987 | OPTS_TYPE_PT_ADD80
6988 | OPTS_TYPE_PT_ADDBITS15;
6989 kern_type = KERN_TYPE_SHA1_LINKEDIN;
6990 dgst_size = DGST_SIZE_4_5;
6991 parse_func = sha1linkedin_parse_hash;
6992 sort_by_digest = sort_by_digest_4_5;
6993 opti_type = OPTI_TYPE_ZERO_BYTE
6994 | OPTI_TYPE_PRECOMPUTE_INIT
6995 | OPTI_TYPE_EARLY_SKIP
6996 | OPTI_TYPE_NOT_ITERATED
6997 | OPTI_TYPE_NOT_SALTED;
6998 dgst_pos0 = 0;
6999 dgst_pos1 = 4;
7000 dgst_pos2 = 3;
7001 dgst_pos3 = 2;
7002 break;
7003
7004 case 200: hash_type = HASH_TYPE_MYSQL;
7005 salt_type = SALT_TYPE_NONE;
7006 attack_exec = ATTACK_EXEC_ON_GPU;
7007 opts_type = 0;
7008 kern_type = KERN_TYPE_MYSQL;
7009 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7010 parse_func = mysql323_parse_hash;
7011 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7012 opti_type = OPTI_TYPE_ZERO_BYTE;
7013 dgst_pos0 = 0;
7014 dgst_pos1 = 1;
7015 dgst_pos2 = 2;
7016 dgst_pos3 = 3;
7017 break;
7018
7019 case 300: hash_type = HASH_TYPE_SHA1;
7020 salt_type = SALT_TYPE_NONE;
7021 attack_exec = ATTACK_EXEC_ON_GPU;
7022 opts_type = OPTS_TYPE_PT_GENERATE_BE
7023 | OPTS_TYPE_PT_ADD80
7024 | OPTS_TYPE_PT_ADDBITS15;
7025 kern_type = KERN_TYPE_MYSQL41;
7026 dgst_size = DGST_SIZE_4_5;
7027 parse_func = sha1_parse_hash;
7028 sort_by_digest = sort_by_digest_4_5;
7029 opti_type = OPTI_TYPE_ZERO_BYTE
7030 | OPTI_TYPE_PRECOMPUTE_INIT
7031 | OPTI_TYPE_PRECOMPUTE_MERKLE
7032 | OPTI_TYPE_EARLY_SKIP
7033 | OPTI_TYPE_NOT_ITERATED
7034 | OPTI_TYPE_NOT_SALTED;
7035 dgst_pos0 = 3;
7036 dgst_pos1 = 4;
7037 dgst_pos2 = 2;
7038 dgst_pos3 = 1;
7039 break;
7040
7041 case 400: hash_type = HASH_TYPE_MD5;
7042 salt_type = SALT_TYPE_EMBEDDED;
7043 attack_exec = ATTACK_EXEC_ON_CPU;
7044 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7045 kern_type = KERN_TYPE_PHPASS;
7046 dgst_size = DGST_SIZE_4_4;
7047 parse_func = phpass_parse_hash;
7048 sort_by_digest = sort_by_digest_4_4;
7049 opti_type = OPTI_TYPE_ZERO_BYTE;
7050 dgst_pos0 = 0;
7051 dgst_pos1 = 1;
7052 dgst_pos2 = 2;
7053 dgst_pos3 = 3;
7054 break;
7055
7056 case 500: hash_type = HASH_TYPE_MD5;
7057 salt_type = SALT_TYPE_EMBEDDED;
7058 attack_exec = ATTACK_EXEC_ON_CPU;
7059 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7060 kern_type = KERN_TYPE_MD5CRYPT;
7061 dgst_size = DGST_SIZE_4_4;
7062 parse_func = md5crypt_parse_hash;
7063 sort_by_digest = sort_by_digest_4_4;
7064 opti_type = OPTI_TYPE_ZERO_BYTE;
7065 dgst_pos0 = 0;
7066 dgst_pos1 = 1;
7067 dgst_pos2 = 2;
7068 dgst_pos3 = 3;
7069 break;
7070
7071 case 501: hash_type = HASH_TYPE_MD5;
7072 salt_type = SALT_TYPE_EMBEDDED;
7073 attack_exec = ATTACK_EXEC_ON_CPU;
7074 opts_type = OPTS_TYPE_PT_GENERATE_LE
7075 | OPTS_TYPE_HASH_COPY;
7076 kern_type = KERN_TYPE_MD5CRYPT;
7077 dgst_size = DGST_SIZE_4_4;
7078 parse_func = juniper_parse_hash;
7079 sort_by_digest = sort_by_digest_4_4;
7080 opti_type = OPTI_TYPE_ZERO_BYTE;
7081 dgst_pos0 = 0;
7082 dgst_pos1 = 1;
7083 dgst_pos2 = 2;
7084 dgst_pos3 = 3;
7085 break;
7086
7087 case 900: hash_type = HASH_TYPE_MD4;
7088 salt_type = SALT_TYPE_NONE;
7089 attack_exec = ATTACK_EXEC_ON_GPU;
7090 opts_type = OPTS_TYPE_PT_GENERATE_LE
7091 | OPTS_TYPE_PT_ADD80
7092 | OPTS_TYPE_PT_ADDBITS14;
7093 kern_type = KERN_TYPE_MD4;
7094 dgst_size = DGST_SIZE_4_4;
7095 parse_func = md4_parse_hash;
7096 sort_by_digest = sort_by_digest_4_4;
7097 opti_type = OPTI_TYPE_ZERO_BYTE
7098 | OPTI_TYPE_PRECOMPUTE_INIT
7099 | OPTI_TYPE_PRECOMPUTE_MERKLE
7100 | OPTI_TYPE_MEET_IN_MIDDLE
7101 | OPTI_TYPE_EARLY_SKIP
7102 | OPTI_TYPE_NOT_ITERATED
7103 | OPTI_TYPE_NOT_SALTED
7104 | OPTI_TYPE_RAW_HASH;
7105 dgst_pos0 = 0;
7106 dgst_pos1 = 3;
7107 dgst_pos2 = 2;
7108 dgst_pos3 = 1;
7109 break;
7110
7111 case 1000: hash_type = HASH_TYPE_MD4;
7112 salt_type = SALT_TYPE_NONE;
7113 attack_exec = ATTACK_EXEC_ON_GPU;
7114 opts_type = OPTS_TYPE_PT_GENERATE_LE
7115 | OPTS_TYPE_PT_ADD80
7116 | OPTS_TYPE_PT_ADDBITS14
7117 | OPTS_TYPE_PT_UNICODE;
7118 kern_type = KERN_TYPE_MD4_PWU;
7119 dgst_size = DGST_SIZE_4_4;
7120 parse_func = md4_parse_hash;
7121 sort_by_digest = sort_by_digest_4_4;
7122 opti_type = OPTI_TYPE_ZERO_BYTE
7123 | OPTI_TYPE_PRECOMPUTE_INIT
7124 | OPTI_TYPE_PRECOMPUTE_MERKLE
7125 | OPTI_TYPE_MEET_IN_MIDDLE
7126 | OPTI_TYPE_EARLY_SKIP
7127 | OPTI_TYPE_NOT_ITERATED
7128 | OPTI_TYPE_NOT_SALTED
7129 | OPTI_TYPE_RAW_HASH;
7130 dgst_pos0 = 0;
7131 dgst_pos1 = 3;
7132 dgst_pos2 = 2;
7133 dgst_pos3 = 1;
7134 break;
7135
7136 case 1100: hash_type = HASH_TYPE_MD4;
7137 salt_type = SALT_TYPE_INTERN;
7138 attack_exec = ATTACK_EXEC_ON_GPU;
7139 opts_type = OPTS_TYPE_PT_GENERATE_LE
7140 | OPTS_TYPE_PT_ADD80
7141 | OPTS_TYPE_PT_ADDBITS14
7142 | OPTS_TYPE_PT_UNICODE
7143 | OPTS_TYPE_ST_ADD80
7144 | OPTS_TYPE_ST_UNICODE
7145 | OPTS_TYPE_ST_LOWER;
7146 kern_type = KERN_TYPE_MD44_PWUSLT;
7147 dgst_size = DGST_SIZE_4_4;
7148 parse_func = dcc_parse_hash;
7149 sort_by_digest = sort_by_digest_4_4;
7150 opti_type = OPTI_TYPE_ZERO_BYTE
7151 | OPTI_TYPE_PRECOMPUTE_INIT
7152 | OPTI_TYPE_PRECOMPUTE_MERKLE
7153 | OPTI_TYPE_EARLY_SKIP
7154 | OPTI_TYPE_NOT_ITERATED;
7155 dgst_pos0 = 0;
7156 dgst_pos1 = 3;
7157 dgst_pos2 = 2;
7158 dgst_pos3 = 1;
7159 break;
7160
7161 case 1400: hash_type = HASH_TYPE_SHA256;
7162 salt_type = SALT_TYPE_NONE;
7163 attack_exec = ATTACK_EXEC_ON_GPU;
7164 opts_type = OPTS_TYPE_PT_GENERATE_BE
7165 | OPTS_TYPE_PT_ADD80
7166 | OPTS_TYPE_PT_ADDBITS15;
7167 kern_type = KERN_TYPE_SHA256;
7168 dgst_size = DGST_SIZE_4_8;
7169 parse_func = sha256_parse_hash;
7170 sort_by_digest = sort_by_digest_4_8;
7171 opti_type = OPTI_TYPE_ZERO_BYTE
7172 | OPTI_TYPE_PRECOMPUTE_INIT
7173 | OPTI_TYPE_PRECOMPUTE_MERKLE
7174 | OPTI_TYPE_EARLY_SKIP
7175 | OPTI_TYPE_NOT_ITERATED
7176 | OPTI_TYPE_NOT_SALTED
7177 | OPTI_TYPE_RAW_HASH;
7178 dgst_pos0 = 3;
7179 dgst_pos1 = 7;
7180 dgst_pos2 = 2;
7181 dgst_pos3 = 6;
7182 break;
7183
7184 case 1410: hash_type = HASH_TYPE_SHA256;
7185 salt_type = SALT_TYPE_INTERN;
7186 attack_exec = ATTACK_EXEC_ON_GPU;
7187 opts_type = OPTS_TYPE_PT_GENERATE_BE
7188 | OPTS_TYPE_ST_ADD80
7189 | OPTS_TYPE_ST_ADDBITS15;
7190 kern_type = KERN_TYPE_SHA256_PWSLT;
7191 dgst_size = DGST_SIZE_4_8;
7192 parse_func = sha256s_parse_hash;
7193 sort_by_digest = sort_by_digest_4_8;
7194 opti_type = OPTI_TYPE_ZERO_BYTE
7195 | OPTI_TYPE_PRECOMPUTE_INIT
7196 | OPTI_TYPE_PRECOMPUTE_MERKLE
7197 | OPTI_TYPE_EARLY_SKIP
7198 | OPTI_TYPE_NOT_ITERATED
7199 | OPTI_TYPE_APPENDED_SALT
7200 | OPTI_TYPE_RAW_HASH;
7201 dgst_pos0 = 3;
7202 dgst_pos1 = 7;
7203 dgst_pos2 = 2;
7204 dgst_pos3 = 6;
7205 break;
7206
7207 case 1420: hash_type = HASH_TYPE_SHA256;
7208 salt_type = SALT_TYPE_INTERN;
7209 attack_exec = ATTACK_EXEC_ON_GPU;
7210 opts_type = OPTS_TYPE_PT_GENERATE_BE
7211 | OPTS_TYPE_PT_ADD80
7212 | OPTS_TYPE_PT_ADDBITS15;
7213 kern_type = KERN_TYPE_SHA256_SLTPW;
7214 dgst_size = DGST_SIZE_4_8;
7215 parse_func = sha256s_parse_hash;
7216 sort_by_digest = sort_by_digest_4_8;
7217 opti_type = OPTI_TYPE_ZERO_BYTE
7218 | OPTI_TYPE_PRECOMPUTE_INIT
7219 | OPTI_TYPE_PRECOMPUTE_MERKLE
7220 | OPTI_TYPE_EARLY_SKIP
7221 | OPTI_TYPE_NOT_ITERATED
7222 | OPTI_TYPE_PREPENDED_SALT
7223 | OPTI_TYPE_RAW_HASH;
7224 dgst_pos0 = 3;
7225 dgst_pos1 = 7;
7226 dgst_pos2 = 2;
7227 dgst_pos3 = 6;
7228 break;
7229
7230 case 1421: hash_type = HASH_TYPE_SHA256;
7231 salt_type = SALT_TYPE_EMBEDDED;
7232 attack_exec = ATTACK_EXEC_ON_GPU;
7233 opts_type = OPTS_TYPE_PT_GENERATE_BE
7234 | OPTS_TYPE_PT_ADD80
7235 | OPTS_TYPE_PT_ADDBITS15;
7236 kern_type = KERN_TYPE_SHA256_SLTPW;
7237 dgst_size = DGST_SIZE_4_8;
7238 parse_func = hmailserver_parse_hash;
7239 sort_by_digest = sort_by_digest_4_8;
7240 opti_type = OPTI_TYPE_ZERO_BYTE
7241 | OPTI_TYPE_PRECOMPUTE_INIT
7242 | OPTI_TYPE_PRECOMPUTE_MERKLE
7243 | OPTI_TYPE_EARLY_SKIP
7244 | OPTI_TYPE_NOT_ITERATED
7245 | OPTI_TYPE_PREPENDED_SALT
7246 | OPTI_TYPE_RAW_HASH;
7247 dgst_pos0 = 3;
7248 dgst_pos1 = 7;
7249 dgst_pos2 = 2;
7250 dgst_pos3 = 6;
7251 break;
7252
7253 case 1430: hash_type = HASH_TYPE_SHA256;
7254 salt_type = SALT_TYPE_INTERN;
7255 attack_exec = ATTACK_EXEC_ON_GPU;
7256 opts_type = OPTS_TYPE_PT_GENERATE_BE
7257 | OPTS_TYPE_PT_UNICODE
7258 | OPTS_TYPE_ST_ADD80
7259 | OPTS_TYPE_ST_ADDBITS15;
7260 kern_type = KERN_TYPE_SHA256_PWUSLT;
7261 dgst_size = DGST_SIZE_4_8;
7262 parse_func = sha256s_parse_hash;
7263 sort_by_digest = sort_by_digest_4_8;
7264 opti_type = OPTI_TYPE_ZERO_BYTE
7265 | OPTI_TYPE_PRECOMPUTE_INIT
7266 | OPTI_TYPE_PRECOMPUTE_MERKLE
7267 | OPTI_TYPE_EARLY_SKIP
7268 | OPTI_TYPE_NOT_ITERATED
7269 | OPTI_TYPE_APPENDED_SALT
7270 | OPTI_TYPE_RAW_HASH;
7271 dgst_pos0 = 3;
7272 dgst_pos1 = 7;
7273 dgst_pos2 = 2;
7274 dgst_pos3 = 6;
7275 break;
7276
7277 case 1440: hash_type = HASH_TYPE_SHA256;
7278 salt_type = SALT_TYPE_INTERN;
7279 attack_exec = ATTACK_EXEC_ON_GPU;
7280 opts_type = OPTS_TYPE_PT_GENERATE_BE
7281 | OPTS_TYPE_PT_ADD80
7282 | OPTS_TYPE_PT_ADDBITS15
7283 | OPTS_TYPE_PT_UNICODE;
7284 kern_type = KERN_TYPE_SHA256_SLTPWU;
7285 dgst_size = DGST_SIZE_4_8;
7286 parse_func = sha256s_parse_hash;
7287 sort_by_digest = sort_by_digest_4_8;
7288 opti_type = OPTI_TYPE_ZERO_BYTE
7289 | OPTI_TYPE_PRECOMPUTE_INIT
7290 | OPTI_TYPE_PRECOMPUTE_MERKLE
7291 | OPTI_TYPE_EARLY_SKIP
7292 | OPTI_TYPE_NOT_ITERATED
7293 | OPTI_TYPE_PREPENDED_SALT
7294 | OPTI_TYPE_RAW_HASH;
7295 dgst_pos0 = 3;
7296 dgst_pos1 = 7;
7297 dgst_pos2 = 2;
7298 dgst_pos3 = 6;
7299 break;
7300
7301 case 1441: hash_type = HASH_TYPE_SHA256;
7302 salt_type = SALT_TYPE_EMBEDDED;
7303 attack_exec = ATTACK_EXEC_ON_GPU;
7304 opts_type = OPTS_TYPE_PT_GENERATE_BE
7305 | OPTS_TYPE_PT_ADD80
7306 | OPTS_TYPE_PT_ADDBITS15
7307 | OPTS_TYPE_PT_UNICODE
7308 | OPTS_TYPE_ST_BASE64;
7309 kern_type = KERN_TYPE_SHA256_SLTPWU;
7310 dgst_size = DGST_SIZE_4_8;
7311 parse_func = episerver4_parse_hash;
7312 sort_by_digest = sort_by_digest_4_8;
7313 opti_type = OPTI_TYPE_ZERO_BYTE
7314 | OPTI_TYPE_PRECOMPUTE_INIT
7315 | OPTI_TYPE_PRECOMPUTE_MERKLE
7316 | OPTI_TYPE_EARLY_SKIP
7317 | OPTI_TYPE_NOT_ITERATED
7318 | OPTI_TYPE_PREPENDED_SALT
7319 | OPTI_TYPE_RAW_HASH;
7320 dgst_pos0 = 3;
7321 dgst_pos1 = 7;
7322 dgst_pos2 = 2;
7323 dgst_pos3 = 6;
7324 break;
7325
7326 case 1450: hash_type = HASH_TYPE_SHA256;
7327 salt_type = SALT_TYPE_INTERN;
7328 attack_exec = ATTACK_EXEC_ON_GPU;
7329 opts_type = OPTS_TYPE_PT_GENERATE_BE
7330 | OPTS_TYPE_ST_ADD80;
7331 kern_type = KERN_TYPE_HMACSHA256_PW;
7332 dgst_size = DGST_SIZE_4_8;
7333 parse_func = hmacsha256_parse_hash;
7334 sort_by_digest = sort_by_digest_4_8;
7335 opti_type = OPTI_TYPE_ZERO_BYTE
7336 | OPTI_TYPE_NOT_ITERATED;
7337 dgst_pos0 = 3;
7338 dgst_pos1 = 7;
7339 dgst_pos2 = 2;
7340 dgst_pos3 = 6;
7341 break;
7342
7343 case 1460: hash_type = HASH_TYPE_SHA256;
7344 salt_type = SALT_TYPE_INTERN;
7345 attack_exec = ATTACK_EXEC_ON_GPU;
7346 opts_type = OPTS_TYPE_PT_GENERATE_BE
7347 | OPTS_TYPE_PT_ADD80
7348 | OPTS_TYPE_PT_ADDBITS15;
7349 kern_type = KERN_TYPE_HMACSHA256_SLT;
7350 dgst_size = DGST_SIZE_4_8;
7351 parse_func = hmacsha256_parse_hash;
7352 sort_by_digest = sort_by_digest_4_8;
7353 opti_type = OPTI_TYPE_ZERO_BYTE
7354 | OPTI_TYPE_NOT_ITERATED;
7355 dgst_pos0 = 3;
7356 dgst_pos1 = 7;
7357 dgst_pos2 = 2;
7358 dgst_pos3 = 6;
7359 break;
7360
7361 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7362 salt_type = SALT_TYPE_EMBEDDED;
7363 attack_exec = ATTACK_EXEC_ON_GPU;
7364 opts_type = OPTS_TYPE_PT_GENERATE_LE
7365 | OPTS_TYPE_PT_BITSLICE;
7366 kern_type = KERN_TYPE_DESCRYPT;
7367 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7368 parse_func = descrypt_parse_hash;
7369 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7370 opti_type = OPTI_TYPE_ZERO_BYTE
7371 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7372 dgst_pos0 = 0;
7373 dgst_pos1 = 1;
7374 dgst_pos2 = 2;
7375 dgst_pos3 = 3;
7376 break;
7377
7378 case 1600: hash_type = HASH_TYPE_MD5;
7379 salt_type = SALT_TYPE_EMBEDDED;
7380 attack_exec = ATTACK_EXEC_ON_CPU;
7381 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7382 kern_type = KERN_TYPE_APR1CRYPT;
7383 dgst_size = DGST_SIZE_4_4;
7384 parse_func = md5apr1_parse_hash;
7385 sort_by_digest = sort_by_digest_4_4;
7386 opti_type = OPTI_TYPE_ZERO_BYTE;
7387 dgst_pos0 = 0;
7388 dgst_pos1 = 1;
7389 dgst_pos2 = 2;
7390 dgst_pos3 = 3;
7391 break;
7392
7393 case 1700: hash_type = HASH_TYPE_SHA512;
7394 salt_type = SALT_TYPE_NONE;
7395 attack_exec = ATTACK_EXEC_ON_GPU;
7396 opts_type = OPTS_TYPE_PT_GENERATE_BE
7397 | OPTS_TYPE_PT_ADD80
7398 | OPTS_TYPE_PT_ADDBITS15;
7399 kern_type = KERN_TYPE_SHA512;
7400 dgst_size = DGST_SIZE_8_8;
7401 parse_func = sha512_parse_hash;
7402 sort_by_digest = sort_by_digest_8_8;
7403 opti_type = OPTI_TYPE_ZERO_BYTE
7404 | OPTI_TYPE_PRECOMPUTE_INIT
7405 | OPTI_TYPE_PRECOMPUTE_MERKLE
7406 | OPTI_TYPE_EARLY_SKIP
7407 | OPTI_TYPE_NOT_ITERATED
7408 | OPTI_TYPE_NOT_SALTED
7409 | OPTI_TYPE_RAW_HASH;
7410 dgst_pos0 = 14;
7411 dgst_pos1 = 15;
7412 dgst_pos2 = 6;
7413 dgst_pos3 = 7;
7414 break;
7415
7416 case 1710: hash_type = HASH_TYPE_SHA512;
7417 salt_type = SALT_TYPE_INTERN;
7418 attack_exec = ATTACK_EXEC_ON_GPU;
7419 opts_type = OPTS_TYPE_PT_GENERATE_BE
7420 | OPTS_TYPE_ST_ADD80
7421 | OPTS_TYPE_ST_ADDBITS15;
7422 kern_type = KERN_TYPE_SHA512_PWSLT;
7423 dgst_size = DGST_SIZE_8_8;
7424 parse_func = sha512s_parse_hash;
7425 sort_by_digest = sort_by_digest_8_8;
7426 opti_type = OPTI_TYPE_ZERO_BYTE
7427 | OPTI_TYPE_PRECOMPUTE_INIT
7428 | OPTI_TYPE_PRECOMPUTE_MERKLE
7429 | OPTI_TYPE_EARLY_SKIP
7430 | OPTI_TYPE_NOT_ITERATED
7431 | OPTI_TYPE_APPENDED_SALT
7432 | OPTI_TYPE_RAW_HASH;
7433 dgst_pos0 = 14;
7434 dgst_pos1 = 15;
7435 dgst_pos2 = 6;
7436 dgst_pos3 = 7;
7437 break;
7438
7439 case 1711: hash_type = HASH_TYPE_SHA512;
7440 salt_type = SALT_TYPE_EMBEDDED;
7441 attack_exec = ATTACK_EXEC_ON_GPU;
7442 opts_type = OPTS_TYPE_PT_GENERATE_BE
7443 | OPTS_TYPE_ST_ADD80
7444 | OPTS_TYPE_ST_ADDBITS15;
7445 kern_type = KERN_TYPE_SHA512_PWSLT;
7446 dgst_size = DGST_SIZE_8_8;
7447 parse_func = sha512b64s_parse_hash;
7448 sort_by_digest = sort_by_digest_8_8;
7449 opti_type = OPTI_TYPE_ZERO_BYTE
7450 | OPTI_TYPE_PRECOMPUTE_INIT
7451 | OPTI_TYPE_PRECOMPUTE_MERKLE
7452 | OPTI_TYPE_EARLY_SKIP
7453 | OPTI_TYPE_NOT_ITERATED
7454 | OPTI_TYPE_APPENDED_SALT
7455 | OPTI_TYPE_RAW_HASH;
7456 dgst_pos0 = 14;
7457 dgst_pos1 = 15;
7458 dgst_pos2 = 6;
7459 dgst_pos3 = 7;
7460 break;
7461
7462 case 1720: hash_type = HASH_TYPE_SHA512;
7463 salt_type = SALT_TYPE_INTERN;
7464 attack_exec = ATTACK_EXEC_ON_GPU;
7465 opts_type = OPTS_TYPE_PT_GENERATE_BE
7466 | OPTS_TYPE_PT_ADD80
7467 | OPTS_TYPE_PT_ADDBITS15;
7468 kern_type = KERN_TYPE_SHA512_SLTPW;
7469 dgst_size = DGST_SIZE_8_8;
7470 parse_func = sha512s_parse_hash;
7471 sort_by_digest = sort_by_digest_8_8;
7472 opti_type = OPTI_TYPE_ZERO_BYTE
7473 | OPTI_TYPE_PRECOMPUTE_INIT
7474 | OPTI_TYPE_PRECOMPUTE_MERKLE
7475 | OPTI_TYPE_EARLY_SKIP
7476 | OPTI_TYPE_NOT_ITERATED
7477 | OPTI_TYPE_PREPENDED_SALT
7478 | OPTI_TYPE_RAW_HASH;
7479 dgst_pos0 = 14;
7480 dgst_pos1 = 15;
7481 dgst_pos2 = 6;
7482 dgst_pos3 = 7;
7483 break;
7484
7485 case 1722: hash_type = HASH_TYPE_SHA512;
7486 salt_type = SALT_TYPE_EMBEDDED;
7487 attack_exec = ATTACK_EXEC_ON_GPU;
7488 opts_type = OPTS_TYPE_PT_GENERATE_BE
7489 | OPTS_TYPE_PT_ADD80
7490 | OPTS_TYPE_PT_ADDBITS15
7491 | OPTS_TYPE_ST_HEX;
7492 kern_type = KERN_TYPE_SHA512_SLTPW;
7493 dgst_size = DGST_SIZE_8_8;
7494 parse_func = osx512_parse_hash;
7495 sort_by_digest = sort_by_digest_8_8;
7496 opti_type = OPTI_TYPE_ZERO_BYTE
7497 | OPTI_TYPE_PRECOMPUTE_INIT
7498 | OPTI_TYPE_PRECOMPUTE_MERKLE
7499 | OPTI_TYPE_EARLY_SKIP
7500 | OPTI_TYPE_NOT_ITERATED
7501 | OPTI_TYPE_PREPENDED_SALT
7502 | OPTI_TYPE_RAW_HASH;
7503 dgst_pos0 = 14;
7504 dgst_pos1 = 15;
7505 dgst_pos2 = 6;
7506 dgst_pos3 = 7;
7507 break;
7508
7509 case 1730: hash_type = HASH_TYPE_SHA512;
7510 salt_type = SALT_TYPE_INTERN;
7511 attack_exec = ATTACK_EXEC_ON_GPU;
7512 opts_type = OPTS_TYPE_PT_GENERATE_BE
7513 | OPTS_TYPE_PT_UNICODE
7514 | OPTS_TYPE_ST_ADD80
7515 | OPTS_TYPE_ST_ADDBITS15;
7516 kern_type = KERN_TYPE_SHA512_PWSLTU;
7517 dgst_size = DGST_SIZE_8_8;
7518 parse_func = sha512s_parse_hash;
7519 sort_by_digest = sort_by_digest_8_8;
7520 opti_type = OPTI_TYPE_ZERO_BYTE
7521 | OPTI_TYPE_PRECOMPUTE_INIT
7522 | OPTI_TYPE_PRECOMPUTE_MERKLE
7523 | OPTI_TYPE_EARLY_SKIP
7524 | OPTI_TYPE_NOT_ITERATED
7525 | OPTI_TYPE_APPENDED_SALT
7526 | OPTI_TYPE_RAW_HASH;
7527 dgst_pos0 = 14;
7528 dgst_pos1 = 15;
7529 dgst_pos2 = 6;
7530 dgst_pos3 = 7;
7531 break;
7532
7533 case 1731: hash_type = HASH_TYPE_SHA512;
7534 salt_type = SALT_TYPE_EMBEDDED;
7535 attack_exec = ATTACK_EXEC_ON_GPU;
7536 opts_type = OPTS_TYPE_PT_GENERATE_BE
7537 | OPTS_TYPE_PT_UNICODE
7538 | OPTS_TYPE_ST_ADD80
7539 | OPTS_TYPE_ST_ADDBITS15
7540 | OPTS_TYPE_ST_HEX;
7541 kern_type = KERN_TYPE_SHA512_PWSLTU;
7542 dgst_size = DGST_SIZE_8_8;
7543 parse_func = mssql2012_parse_hash;
7544 sort_by_digest = sort_by_digest_8_8;
7545 opti_type = OPTI_TYPE_ZERO_BYTE
7546 | OPTI_TYPE_PRECOMPUTE_INIT
7547 | OPTI_TYPE_PRECOMPUTE_MERKLE
7548 | OPTI_TYPE_EARLY_SKIP
7549 | OPTI_TYPE_NOT_ITERATED
7550 | OPTI_TYPE_APPENDED_SALT
7551 | OPTI_TYPE_RAW_HASH;
7552 dgst_pos0 = 14;
7553 dgst_pos1 = 15;
7554 dgst_pos2 = 6;
7555 dgst_pos3 = 7;
7556 break;
7557
7558 case 1740: hash_type = HASH_TYPE_SHA512;
7559 salt_type = SALT_TYPE_INTERN;
7560 attack_exec = ATTACK_EXEC_ON_GPU;
7561 opts_type = OPTS_TYPE_PT_GENERATE_BE
7562 | OPTS_TYPE_PT_ADD80
7563 | OPTS_TYPE_PT_ADDBITS15
7564 | OPTS_TYPE_PT_UNICODE;
7565 kern_type = KERN_TYPE_SHA512_SLTPWU;
7566 dgst_size = DGST_SIZE_8_8;
7567 parse_func = sha512s_parse_hash;
7568 sort_by_digest = sort_by_digest_8_8;
7569 opti_type = OPTI_TYPE_ZERO_BYTE
7570 | OPTI_TYPE_PRECOMPUTE_INIT
7571 | OPTI_TYPE_PRECOMPUTE_MERKLE
7572 | OPTI_TYPE_EARLY_SKIP
7573 | OPTI_TYPE_NOT_ITERATED
7574 | OPTI_TYPE_PREPENDED_SALT
7575 | OPTI_TYPE_RAW_HASH;
7576 dgst_pos0 = 14;
7577 dgst_pos1 = 15;
7578 dgst_pos2 = 6;
7579 dgst_pos3 = 7;
7580 break;
7581
7582 case 1750: hash_type = HASH_TYPE_SHA512;
7583 salt_type = SALT_TYPE_INTERN;
7584 attack_exec = ATTACK_EXEC_ON_GPU;
7585 opts_type = OPTS_TYPE_PT_GENERATE_BE
7586 | OPTS_TYPE_ST_ADD80;
7587 kern_type = KERN_TYPE_HMACSHA512_PW;
7588 dgst_size = DGST_SIZE_8_8;
7589 parse_func = hmacsha512_parse_hash;
7590 sort_by_digest = sort_by_digest_8_8;
7591 opti_type = OPTI_TYPE_ZERO_BYTE
7592 | OPTI_TYPE_NOT_ITERATED;
7593 dgst_pos0 = 14;
7594 dgst_pos1 = 15;
7595 dgst_pos2 = 6;
7596 dgst_pos3 = 7;
7597 break;
7598
7599 case 1760: hash_type = HASH_TYPE_SHA512;
7600 salt_type = SALT_TYPE_INTERN;
7601 attack_exec = ATTACK_EXEC_ON_GPU;
7602 opts_type = OPTS_TYPE_PT_GENERATE_BE
7603 | OPTS_TYPE_PT_ADD80
7604 | OPTS_TYPE_PT_ADDBITS15;
7605 kern_type = KERN_TYPE_HMACSHA512_SLT;
7606 dgst_size = DGST_SIZE_8_8;
7607 parse_func = hmacsha512_parse_hash;
7608 sort_by_digest = sort_by_digest_8_8;
7609 opti_type = OPTI_TYPE_ZERO_BYTE
7610 | OPTI_TYPE_NOT_ITERATED;
7611 dgst_pos0 = 14;
7612 dgst_pos1 = 15;
7613 dgst_pos2 = 6;
7614 dgst_pos3 = 7;
7615 break;
7616
7617 case 1800: hash_type = HASH_TYPE_SHA512;
7618 salt_type = SALT_TYPE_EMBEDDED;
7619 attack_exec = ATTACK_EXEC_ON_CPU;
7620 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7621 kern_type = KERN_TYPE_SHA512CRYPT;
7622 dgst_size = DGST_SIZE_8_8;
7623 parse_func = sha512crypt_parse_hash;
7624 sort_by_digest = sort_by_digest_8_8;
7625 opti_type = OPTI_TYPE_ZERO_BYTE;
7626 dgst_pos0 = 0;
7627 dgst_pos1 = 1;
7628 dgst_pos2 = 2;
7629 dgst_pos3 = 3;
7630 break;
7631
7632 case 2100: hash_type = HASH_TYPE_DCC2;
7633 salt_type = SALT_TYPE_EMBEDDED;
7634 attack_exec = ATTACK_EXEC_ON_CPU;
7635 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7636 | OPTS_TYPE_ST_LOWER
7637 | OPTS_TYPE_ST_UNICODE;
7638 kern_type = KERN_TYPE_DCC2;
7639 dgst_size = DGST_SIZE_4_4;
7640 parse_func = dcc2_parse_hash;
7641 sort_by_digest = sort_by_digest_4_4;
7642 opti_type = OPTI_TYPE_ZERO_BYTE;
7643 dgst_pos0 = 0;
7644 dgst_pos1 = 1;
7645 dgst_pos2 = 2;
7646 dgst_pos3 = 3;
7647 break;
7648
7649 case 2400: hash_type = HASH_TYPE_MD5;
7650 salt_type = SALT_TYPE_NONE;
7651 attack_exec = ATTACK_EXEC_ON_GPU;
7652 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7653 kern_type = KERN_TYPE_MD5PIX;
7654 dgst_size = DGST_SIZE_4_4;
7655 parse_func = md5pix_parse_hash;
7656 sort_by_digest = sort_by_digest_4_4;
7657 opti_type = OPTI_TYPE_ZERO_BYTE
7658 | OPTI_TYPE_PRECOMPUTE_INIT
7659 | OPTI_TYPE_PRECOMPUTE_MERKLE
7660 | OPTI_TYPE_EARLY_SKIP
7661 | OPTI_TYPE_NOT_ITERATED
7662 | OPTI_TYPE_NOT_SALTED;
7663 dgst_pos0 = 0;
7664 dgst_pos1 = 3;
7665 dgst_pos2 = 2;
7666 dgst_pos3 = 1;
7667 break;
7668
7669 case 2410: hash_type = HASH_TYPE_MD5;
7670 salt_type = SALT_TYPE_INTERN;
7671 attack_exec = ATTACK_EXEC_ON_GPU;
7672 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7673 kern_type = KERN_TYPE_MD5ASA;
7674 dgst_size = DGST_SIZE_4_4;
7675 parse_func = md5asa_parse_hash;
7676 sort_by_digest = sort_by_digest_4_4;
7677 opti_type = OPTI_TYPE_ZERO_BYTE
7678 | OPTI_TYPE_PRECOMPUTE_INIT
7679 | OPTI_TYPE_PRECOMPUTE_MERKLE
7680 | OPTI_TYPE_EARLY_SKIP
7681 | OPTI_TYPE_NOT_ITERATED;
7682 dgst_pos0 = 0;
7683 dgst_pos1 = 3;
7684 dgst_pos2 = 2;
7685 dgst_pos3 = 1;
7686 break;
7687
7688 case 2500: hash_type = HASH_TYPE_WPA;
7689 salt_type = SALT_TYPE_EMBEDDED;
7690 attack_exec = ATTACK_EXEC_ON_CPU;
7691 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7692 kern_type = KERN_TYPE_WPA;
7693 dgst_size = DGST_SIZE_4_4;
7694 parse_func = wpa_parse_hash;
7695 sort_by_digest = sort_by_digest_4_4;
7696 opti_type = OPTI_TYPE_ZERO_BYTE;
7697 dgst_pos0 = 0;
7698 dgst_pos1 = 1;
7699 dgst_pos2 = 2;
7700 dgst_pos3 = 3;
7701 break;
7702
7703 case 2600: hash_type = HASH_TYPE_MD5;
7704 salt_type = SALT_TYPE_VIRTUAL;
7705 attack_exec = ATTACK_EXEC_ON_GPU;
7706 opts_type = OPTS_TYPE_PT_GENERATE_LE
7707 | OPTS_TYPE_PT_ADD80
7708 | OPTS_TYPE_PT_ADDBITS14
7709 | OPTS_TYPE_ST_ADD80;
7710 kern_type = KERN_TYPE_MD55_PWSLT1;
7711 dgst_size = DGST_SIZE_4_4;
7712 parse_func = md5md5_parse_hash;
7713 sort_by_digest = sort_by_digest_4_4;
7714 opti_type = OPTI_TYPE_ZERO_BYTE
7715 | OPTI_TYPE_PRECOMPUTE_INIT
7716 | OPTI_TYPE_PRECOMPUTE_MERKLE
7717 | OPTI_TYPE_EARLY_SKIP;
7718 dgst_pos0 = 0;
7719 dgst_pos1 = 3;
7720 dgst_pos2 = 2;
7721 dgst_pos3 = 1;
7722 break;
7723
7724 case 2611: hash_type = HASH_TYPE_MD5;
7725 salt_type = SALT_TYPE_INTERN;
7726 attack_exec = ATTACK_EXEC_ON_GPU;
7727 opts_type = OPTS_TYPE_PT_GENERATE_LE
7728 | OPTS_TYPE_PT_ADD80
7729 | OPTS_TYPE_PT_ADDBITS14
7730 | OPTS_TYPE_ST_ADD80;
7731 kern_type = KERN_TYPE_MD55_PWSLT1;
7732 dgst_size = DGST_SIZE_4_4;
7733 parse_func = vb3_parse_hash;
7734 sort_by_digest = sort_by_digest_4_4;
7735 opti_type = OPTI_TYPE_ZERO_BYTE
7736 | OPTI_TYPE_PRECOMPUTE_INIT
7737 | OPTI_TYPE_PRECOMPUTE_MERKLE
7738 | OPTI_TYPE_EARLY_SKIP;
7739 dgst_pos0 = 0;
7740 dgst_pos1 = 3;
7741 dgst_pos2 = 2;
7742 dgst_pos3 = 1;
7743 break;
7744
7745 case 2612: hash_type = HASH_TYPE_MD5;
7746 salt_type = SALT_TYPE_EMBEDDED;
7747 attack_exec = ATTACK_EXEC_ON_GPU;
7748 opts_type = OPTS_TYPE_PT_GENERATE_LE
7749 | OPTS_TYPE_PT_ADD80
7750 | OPTS_TYPE_PT_ADDBITS14
7751 | OPTS_TYPE_ST_ADD80
7752 | OPTS_TYPE_ST_HEX;
7753 kern_type = KERN_TYPE_MD55_PWSLT1;
7754 dgst_size = DGST_SIZE_4_4;
7755 parse_func = phps_parse_hash;
7756 sort_by_digest = sort_by_digest_4_4;
7757 opti_type = OPTI_TYPE_ZERO_BYTE
7758 | OPTI_TYPE_PRECOMPUTE_INIT
7759 | OPTI_TYPE_PRECOMPUTE_MERKLE
7760 | OPTI_TYPE_EARLY_SKIP;
7761 dgst_pos0 = 0;
7762 dgst_pos1 = 3;
7763 dgst_pos2 = 2;
7764 dgst_pos3 = 1;
7765 break;
7766
7767 case 2711: hash_type = HASH_TYPE_MD5;
7768 salt_type = SALT_TYPE_INTERN;
7769 attack_exec = ATTACK_EXEC_ON_GPU;
7770 opts_type = OPTS_TYPE_PT_GENERATE_LE
7771 | OPTS_TYPE_PT_ADD80
7772 | OPTS_TYPE_PT_ADDBITS14
7773 | OPTS_TYPE_ST_ADD80;
7774 kern_type = KERN_TYPE_MD55_PWSLT2;
7775 dgst_size = DGST_SIZE_4_4;
7776 parse_func = vb30_parse_hash;
7777 sort_by_digest = sort_by_digest_4_4;
7778 opti_type = OPTI_TYPE_ZERO_BYTE
7779 | OPTI_TYPE_PRECOMPUTE_INIT
7780 | OPTI_TYPE_EARLY_SKIP;
7781 dgst_pos0 = 0;
7782 dgst_pos1 = 3;
7783 dgst_pos2 = 2;
7784 dgst_pos3 = 1;
7785 break;
7786
7787 case 2811: hash_type = HASH_TYPE_MD5;
7788 salt_type = SALT_TYPE_INTERN;
7789 attack_exec = ATTACK_EXEC_ON_GPU;
7790 opts_type = OPTS_TYPE_PT_GENERATE_LE
7791 | OPTS_TYPE_PT_ADD80
7792 | OPTS_TYPE_PT_ADDBITS14;
7793 kern_type = KERN_TYPE_MD55_SLTPW;
7794 dgst_size = DGST_SIZE_4_4;
7795 parse_func = ipb2_parse_hash;
7796 sort_by_digest = sort_by_digest_4_4;
7797 opti_type = OPTI_TYPE_ZERO_BYTE
7798 | OPTI_TYPE_PRECOMPUTE_INIT
7799 | OPTI_TYPE_EARLY_SKIP;
7800 dgst_pos0 = 0;
7801 dgst_pos1 = 3;
7802 dgst_pos2 = 2;
7803 dgst_pos3 = 1;
7804 break;
7805
7806 case 3000: hash_type = HASH_TYPE_LM;
7807 salt_type = SALT_TYPE_NONE;
7808 attack_exec = ATTACK_EXEC_ON_GPU;
7809 opts_type = OPTS_TYPE_PT_GENERATE_LE
7810 | OPTS_TYPE_PT_UPPER
7811 | OPTS_TYPE_PT_BITSLICE;
7812 kern_type = KERN_TYPE_LM;
7813 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7814 parse_func = lm_parse_hash;
7815 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7816 opti_type = OPTI_TYPE_ZERO_BYTE
7817 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7818 dgst_pos0 = 0;
7819 dgst_pos1 = 1;
7820 dgst_pos2 = 2;
7821 dgst_pos3 = 3;
7822 break;
7823
7824 case 3100: hash_type = HASH_TYPE_ORACLEH;
7825 salt_type = SALT_TYPE_INTERN;
7826 attack_exec = ATTACK_EXEC_ON_GPU;
7827 opts_type = OPTS_TYPE_PT_GENERATE_LE
7828 | OPTS_TYPE_PT_UPPER
7829 | OPTS_TYPE_ST_UPPER;
7830 kern_type = KERN_TYPE_ORACLEH;
7831 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7832 parse_func = oracleh_parse_hash;
7833 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7834 opti_type = OPTI_TYPE_ZERO_BYTE;
7835 dgst_pos0 = 0;
7836 dgst_pos1 = 1;
7837 dgst_pos2 = 2;
7838 dgst_pos3 = 3;
7839 break;
7840
7841 case 3200: hash_type = HASH_TYPE_BCRYPT;
7842 salt_type = SALT_TYPE_EMBEDDED;
7843 attack_exec = ATTACK_EXEC_ON_CPU;
7844 opts_type = OPTS_TYPE_PT_GENERATE_LE
7845 | OPTS_TYPE_ST_GENERATE_LE;
7846 kern_type = KERN_TYPE_BCRYPT;
7847 dgst_size = DGST_SIZE_4_6;
7848 parse_func = bcrypt_parse_hash;
7849 sort_by_digest = sort_by_digest_4_6;
7850 opti_type = OPTI_TYPE_ZERO_BYTE;
7851 dgst_pos0 = 0;
7852 dgst_pos1 = 1;
7853 dgst_pos2 = 2;
7854 dgst_pos3 = 3;
7855 break;
7856
7857 case 3710: hash_type = HASH_TYPE_MD5;
7858 salt_type = SALT_TYPE_INTERN;
7859 attack_exec = ATTACK_EXEC_ON_GPU;
7860 opts_type = OPTS_TYPE_PT_GENERATE_LE
7861 | OPTS_TYPE_PT_ADD80
7862 | OPTS_TYPE_PT_ADDBITS14;
7863 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
7864 dgst_size = DGST_SIZE_4_4;
7865 parse_func = md5s_parse_hash;
7866 sort_by_digest = sort_by_digest_4_4;
7867 opti_type = OPTI_TYPE_ZERO_BYTE
7868 | OPTI_TYPE_PRECOMPUTE_INIT
7869 | OPTI_TYPE_PRECOMPUTE_MERKLE
7870 | OPTI_TYPE_EARLY_SKIP;
7871 dgst_pos0 = 0;
7872 dgst_pos1 = 3;
7873 dgst_pos2 = 2;
7874 dgst_pos3 = 1;
7875 break;
7876
7877 case 3711: hash_type = HASH_TYPE_MD5;
7878 salt_type = SALT_TYPE_EMBEDDED;
7879 attack_exec = ATTACK_EXEC_ON_GPU;
7880 opts_type = OPTS_TYPE_PT_GENERATE_LE
7881 | OPTS_TYPE_PT_ADD80
7882 | OPTS_TYPE_PT_ADDBITS14;
7883 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
7884 dgst_size = DGST_SIZE_4_4;
7885 parse_func = mediawiki_b_parse_hash;
7886 sort_by_digest = sort_by_digest_4_4;
7887 opti_type = OPTI_TYPE_ZERO_BYTE
7888 | OPTI_TYPE_PRECOMPUTE_INIT
7889 | OPTI_TYPE_PRECOMPUTE_MERKLE
7890 | OPTI_TYPE_EARLY_SKIP;
7891 dgst_pos0 = 0;
7892 dgst_pos1 = 3;
7893 dgst_pos2 = 2;
7894 dgst_pos3 = 1;
7895 break;
7896
7897 case 3800: hash_type = HASH_TYPE_MD5;
7898 salt_type = SALT_TYPE_INTERN;
7899 attack_exec = ATTACK_EXEC_ON_GPU;
7900 opts_type = OPTS_TYPE_PT_GENERATE_LE
7901 | OPTS_TYPE_ST_ADDBITS14;
7902 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
7903 dgst_size = DGST_SIZE_4_4;
7904 parse_func = md5s_parse_hash;
7905 sort_by_digest = sort_by_digest_4_4;
7906 opti_type = OPTI_TYPE_ZERO_BYTE
7907 | OPTI_TYPE_PRECOMPUTE_INIT
7908 | OPTI_TYPE_PRECOMPUTE_MERKLE
7909 | OPTI_TYPE_EARLY_SKIP
7910 | OPTI_TYPE_NOT_ITERATED
7911 | OPTI_TYPE_RAW_HASH;
7912 dgst_pos0 = 0;
7913 dgst_pos1 = 3;
7914 dgst_pos2 = 2;
7915 dgst_pos3 = 1;
7916 break;
7917
7918 case 4300: hash_type = HASH_TYPE_MD5;
7919 salt_type = SALT_TYPE_VIRTUAL;
7920 attack_exec = ATTACK_EXEC_ON_GPU;
7921 opts_type = OPTS_TYPE_PT_GENERATE_LE
7922 | OPTS_TYPE_PT_ADD80
7923 | OPTS_TYPE_PT_ADDBITS14
7924 | OPTS_TYPE_ST_ADD80;
7925 kern_type = KERN_TYPE_MD5U5_PWSLT1;
7926 dgst_size = DGST_SIZE_4_4;
7927 parse_func = md5md5_parse_hash;
7928 sort_by_digest = sort_by_digest_4_4;
7929 opti_type = OPTI_TYPE_ZERO_BYTE
7930 | OPTI_TYPE_PRECOMPUTE_INIT
7931 | OPTI_TYPE_PRECOMPUTE_MERKLE
7932 | OPTI_TYPE_EARLY_SKIP;
7933 dgst_pos0 = 0;
7934 dgst_pos1 = 3;
7935 dgst_pos2 = 2;
7936 dgst_pos3 = 1;
7937 break;
7938
7939
7940 case 4400: hash_type = HASH_TYPE_MD5;
7941 salt_type = SALT_TYPE_NONE;
7942 attack_exec = ATTACK_EXEC_ON_GPU;
7943 opts_type = OPTS_TYPE_PT_GENERATE_BE
7944 | OPTS_TYPE_PT_ADD80
7945 | OPTS_TYPE_PT_ADDBITS15;
7946 kern_type = KERN_TYPE_MD5_SHA1;
7947 dgst_size = DGST_SIZE_4_4;
7948 parse_func = md5_parse_hash;
7949 sort_by_digest = sort_by_digest_4_4;
7950 opti_type = OPTI_TYPE_ZERO_BYTE
7951 | OPTI_TYPE_PRECOMPUTE_INIT
7952 | OPTI_TYPE_PRECOMPUTE_MERKLE
7953 | OPTI_TYPE_EARLY_SKIP
7954 | OPTI_TYPE_NOT_ITERATED
7955 | OPTI_TYPE_NOT_SALTED
7956 | OPTI_TYPE_RAW_HASH;
7957 dgst_pos0 = 0;
7958 dgst_pos1 = 3;
7959 dgst_pos2 = 2;
7960 dgst_pos3 = 1;
7961 break;
7962
7963 case 4500: hash_type = HASH_TYPE_SHA1;
7964 salt_type = SALT_TYPE_NONE;
7965 attack_exec = ATTACK_EXEC_ON_GPU;
7966 opts_type = OPTS_TYPE_PT_GENERATE_BE
7967 | OPTS_TYPE_PT_ADD80
7968 | OPTS_TYPE_PT_ADDBITS15;
7969 kern_type = KERN_TYPE_SHA11;
7970 dgst_size = DGST_SIZE_4_5;
7971 parse_func = sha1_parse_hash;
7972 sort_by_digest = sort_by_digest_4_5;
7973 opti_type = OPTI_TYPE_ZERO_BYTE
7974 | OPTI_TYPE_PRECOMPUTE_INIT
7975 | OPTI_TYPE_PRECOMPUTE_MERKLE
7976 | OPTI_TYPE_EARLY_SKIP
7977 | OPTI_TYPE_NOT_SALTED;
7978 dgst_pos0 = 3;
7979 dgst_pos1 = 4;
7980 dgst_pos2 = 2;
7981 dgst_pos3 = 1;
7982 break;
7983
7984 case 4700: hash_type = HASH_TYPE_SHA1;
7985 salt_type = SALT_TYPE_NONE;
7986 attack_exec = ATTACK_EXEC_ON_GPU;
7987 opts_type = OPTS_TYPE_PT_GENERATE_LE
7988 | OPTS_TYPE_PT_ADD80
7989 | OPTS_TYPE_PT_ADDBITS14;
7990 kern_type = KERN_TYPE_SHA1_MD5;
7991 dgst_size = DGST_SIZE_4_5;
7992 parse_func = sha1_parse_hash;
7993 sort_by_digest = sort_by_digest_4_5;
7994 opti_type = OPTI_TYPE_ZERO_BYTE
7995 | OPTI_TYPE_PRECOMPUTE_INIT
7996 | OPTI_TYPE_PRECOMPUTE_MERKLE
7997 | OPTI_TYPE_EARLY_SKIP
7998 | OPTI_TYPE_NOT_ITERATED
7999 | OPTI_TYPE_NOT_SALTED
8000 | OPTI_TYPE_RAW_HASH;
8001 dgst_pos0 = 3;
8002 dgst_pos1 = 4;
8003 dgst_pos2 = 2;
8004 dgst_pos3 = 1;
8005 break;
8006
8007 case 4800: hash_type = HASH_TYPE_MD5;
8008 salt_type = SALT_TYPE_EMBEDDED;
8009 attack_exec = ATTACK_EXEC_ON_GPU;
8010 opts_type = OPTS_TYPE_PT_GENERATE_LE
8011 | OPTS_TYPE_PT_ADDBITS14;
8012 kern_type = KERN_TYPE_MD5_CHAP;
8013 dgst_size = DGST_SIZE_4_4;
8014 parse_func = chap_parse_hash;
8015 sort_by_digest = sort_by_digest_4_4;
8016 opti_type = OPTI_TYPE_ZERO_BYTE
8017 | OPTI_TYPE_PRECOMPUTE_INIT
8018 | OPTI_TYPE_PRECOMPUTE_MERKLE
8019 | OPTI_TYPE_MEET_IN_MIDDLE
8020 | OPTI_TYPE_EARLY_SKIP
8021 | OPTI_TYPE_NOT_ITERATED
8022 | OPTI_TYPE_RAW_HASH;
8023 dgst_pos0 = 0;
8024 dgst_pos1 = 3;
8025 dgst_pos2 = 2;
8026 dgst_pos3 = 1;
8027 break;
8028
8029 case 4900: hash_type = HASH_TYPE_SHA1;
8030 salt_type = SALT_TYPE_INTERN;
8031 attack_exec = ATTACK_EXEC_ON_GPU;
8032 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8033 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8034 dgst_size = DGST_SIZE_4_5;
8035 parse_func = sha1s_parse_hash;
8036 sort_by_digest = sort_by_digest_4_5;
8037 opti_type = OPTI_TYPE_ZERO_BYTE
8038 | OPTI_TYPE_PRECOMPUTE_INIT
8039 | OPTI_TYPE_PRECOMPUTE_MERKLE
8040 | OPTI_TYPE_EARLY_SKIP;
8041 dgst_pos0 = 3;
8042 dgst_pos1 = 4;
8043 dgst_pos2 = 2;
8044 dgst_pos3 = 1;
8045 break;
8046
8047 case 5000: hash_type = HASH_TYPE_KECCAK;
8048 salt_type = SALT_TYPE_EMBEDDED;
8049 attack_exec = ATTACK_EXEC_ON_GPU;
8050 opts_type = OPTS_TYPE_PT_GENERATE_LE
8051 | OPTS_TYPE_PT_ADD01;
8052 kern_type = KERN_TYPE_KECCAK;
8053 dgst_size = DGST_SIZE_8_25;
8054 parse_func = keccak_parse_hash;
8055 sort_by_digest = sort_by_digest_8_25;
8056 opti_type = OPTI_TYPE_ZERO_BYTE
8057 | OPTI_TYPE_RAW_HASH;
8058 dgst_pos0 = 2;
8059 dgst_pos1 = 3;
8060 dgst_pos2 = 4;
8061 dgst_pos3 = 5;
8062 break;
8063
8064 case 5100: hash_type = HASH_TYPE_MD5H;
8065 salt_type = SALT_TYPE_NONE;
8066 attack_exec = ATTACK_EXEC_ON_GPU;
8067 opts_type = OPTS_TYPE_PT_GENERATE_LE
8068 | OPTS_TYPE_PT_ADD80
8069 | OPTS_TYPE_PT_ADDBITS14;
8070 kern_type = KERN_TYPE_MD5H;
8071 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8072 parse_func = md5half_parse_hash;
8073 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8074 opti_type = OPTI_TYPE_ZERO_BYTE
8075 | OPTI_TYPE_RAW_HASH;
8076 dgst_pos0 = 0;
8077 dgst_pos1 = 1;
8078 dgst_pos2 = 2;
8079 dgst_pos3 = 3;
8080 break;
8081
8082 case 5200: hash_type = HASH_TYPE_SHA256;
8083 salt_type = SALT_TYPE_EMBEDDED;
8084 attack_exec = ATTACK_EXEC_ON_CPU;
8085 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8086 kern_type = KERN_TYPE_PSAFE3;
8087 dgst_size = DGST_SIZE_4_8;
8088 parse_func = psafe3_parse_hash;
8089 sort_by_digest = sort_by_digest_4_8;
8090 opti_type = OPTI_TYPE_ZERO_BYTE;
8091 dgst_pos0 = 0;
8092 dgst_pos1 = 1;
8093 dgst_pos2 = 2;
8094 dgst_pos3 = 3;
8095 break;
8096
8097 case 5300: hash_type = HASH_TYPE_MD5;
8098 salt_type = SALT_TYPE_EMBEDDED;
8099 attack_exec = ATTACK_EXEC_ON_GPU;
8100 opts_type = OPTS_TYPE_PT_GENERATE_LE
8101 | OPTS_TYPE_ST_ADD80;
8102 kern_type = KERN_TYPE_IKEPSK_MD5;
8103 dgst_size = DGST_SIZE_4_4;
8104 parse_func = ikepsk_md5_parse_hash;
8105 sort_by_digest = sort_by_digest_4_4;
8106 opti_type = OPTI_TYPE_ZERO_BYTE;
8107 dgst_pos0 = 0;
8108 dgst_pos1 = 3;
8109 dgst_pos2 = 2;
8110 dgst_pos3 = 1;
8111 break;
8112
8113 case 5400: hash_type = HASH_TYPE_SHA1;
8114 salt_type = SALT_TYPE_EMBEDDED;
8115 attack_exec = ATTACK_EXEC_ON_GPU;
8116 opts_type = OPTS_TYPE_PT_GENERATE_BE
8117 | OPTS_TYPE_ST_ADD80;
8118 kern_type = KERN_TYPE_IKEPSK_SHA1;
8119 dgst_size = DGST_SIZE_4_5;
8120 parse_func = ikepsk_sha1_parse_hash;
8121 sort_by_digest = sort_by_digest_4_5;
8122 opti_type = OPTI_TYPE_ZERO_BYTE;
8123 dgst_pos0 = 3;
8124 dgst_pos1 = 4;
8125 dgst_pos2 = 2;
8126 dgst_pos3 = 1;
8127 break;
8128
8129 case 5500: hash_type = HASH_TYPE_NETNTLM;
8130 salt_type = SALT_TYPE_EMBEDDED;
8131 attack_exec = ATTACK_EXEC_ON_GPU;
8132 opts_type = OPTS_TYPE_PT_GENERATE_LE
8133 | OPTS_TYPE_PT_ADD80
8134 | OPTS_TYPE_PT_ADDBITS14
8135 | OPTS_TYPE_PT_UNICODE
8136 | OPTS_TYPE_ST_HEX;
8137 kern_type = KERN_TYPE_NETNTLMv1;
8138 dgst_size = DGST_SIZE_4_4;
8139 parse_func = netntlmv1_parse_hash;
8140 sort_by_digest = sort_by_digest_4_4;
8141 opti_type = OPTI_TYPE_ZERO_BYTE
8142 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8143 dgst_pos0 = 0;
8144 dgst_pos1 = 1;
8145 dgst_pos2 = 2;
8146 dgst_pos3 = 3;
8147 break;
8148
8149 case 5600: hash_type = HASH_TYPE_MD5;
8150 salt_type = SALT_TYPE_EMBEDDED;
8151 attack_exec = ATTACK_EXEC_ON_GPU;
8152 opts_type = OPTS_TYPE_PT_GENERATE_LE
8153 | OPTS_TYPE_PT_ADD80
8154 | OPTS_TYPE_PT_ADDBITS14
8155 | OPTS_TYPE_PT_UNICODE;
8156 kern_type = KERN_TYPE_NETNTLMv2;
8157 dgst_size = DGST_SIZE_4_4;
8158 parse_func = netntlmv2_parse_hash;
8159 sort_by_digest = sort_by_digest_4_4;
8160 opti_type = OPTI_TYPE_ZERO_BYTE;
8161 dgst_pos0 = 0;
8162 dgst_pos1 = 3;
8163 dgst_pos2 = 2;
8164 dgst_pos3 = 1;
8165 break;
8166
8167 case 5700: hash_type = HASH_TYPE_SHA256;
8168 salt_type = SALT_TYPE_NONE;
8169 attack_exec = ATTACK_EXEC_ON_GPU;
8170 opts_type = OPTS_TYPE_PT_GENERATE_BE
8171 | OPTS_TYPE_PT_ADD80
8172 | OPTS_TYPE_PT_ADDBITS15;
8173 kern_type = KERN_TYPE_SHA256;
8174 dgst_size = DGST_SIZE_4_8;
8175 parse_func = cisco4_parse_hash;
8176 sort_by_digest = sort_by_digest_4_8;
8177 opti_type = OPTI_TYPE_ZERO_BYTE
8178 | OPTI_TYPE_PRECOMPUTE_INIT
8179 | OPTI_TYPE_PRECOMPUTE_MERKLE
8180 | OPTI_TYPE_EARLY_SKIP
8181 | OPTI_TYPE_NOT_ITERATED
8182 | OPTI_TYPE_NOT_SALTED
8183 | OPTI_TYPE_RAW_HASH;
8184 dgst_pos0 = 3;
8185 dgst_pos1 = 7;
8186 dgst_pos2 = 2;
8187 dgst_pos3 = 6;
8188 break;
8189
8190 case 5800: hash_type = HASH_TYPE_SHA1;
8191 salt_type = SALT_TYPE_INTERN;
8192 attack_exec = ATTACK_EXEC_ON_CPU;
8193 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8194 | OPTS_TYPE_ST_ADD80;
8195 kern_type = KERN_TYPE_ANDROIDPIN;
8196 dgst_size = DGST_SIZE_4_5;
8197 parse_func = androidpin_parse_hash;
8198 sort_by_digest = sort_by_digest_4_5;
8199 opti_type = OPTI_TYPE_ZERO_BYTE;
8200 dgst_pos0 = 0;
8201 dgst_pos1 = 1;
8202 dgst_pos2 = 2;
8203 dgst_pos3 = 3;
8204 break;
8205
8206 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8207 salt_type = SALT_TYPE_NONE;
8208 attack_exec = ATTACK_EXEC_ON_GPU;
8209 opts_type = OPTS_TYPE_PT_GENERATE_LE
8210 | OPTS_TYPE_PT_ADD80;
8211 kern_type = KERN_TYPE_RIPEMD160;
8212 dgst_size = DGST_SIZE_4_5;
8213 parse_func = ripemd160_parse_hash;
8214 sort_by_digest = sort_by_digest_4_5;
8215 opti_type = OPTI_TYPE_ZERO_BYTE;
8216 dgst_pos0 = 0;
8217 dgst_pos1 = 1;
8218 dgst_pos2 = 2;
8219 dgst_pos3 = 3;
8220 break;
8221
8222 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8223 salt_type = SALT_TYPE_NONE;
8224 attack_exec = ATTACK_EXEC_ON_GPU;
8225 opts_type = OPTS_TYPE_PT_GENERATE_BE
8226 | OPTS_TYPE_PT_ADD80;
8227 kern_type = KERN_TYPE_WHIRLPOOL;
8228 dgst_size = DGST_SIZE_4_16;
8229 parse_func = whirlpool_parse_hash;
8230 sort_by_digest = sort_by_digest_4_16;
8231 opti_type = OPTI_TYPE_ZERO_BYTE;
8232 dgst_pos0 = 0;
8233 dgst_pos1 = 1;
8234 dgst_pos2 = 2;
8235 dgst_pos3 = 3;
8236 break;
8237
8238 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8239 salt_type = SALT_TYPE_EMBEDDED;
8240 attack_exec = ATTACK_EXEC_ON_CPU;
8241 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8242 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8243 dgst_size = DGST_SIZE_4_5;
8244 parse_func = truecrypt_parse_hash_2k;
8245 sort_by_digest = sort_by_digest_4_5;
8246 opti_type = OPTI_TYPE_ZERO_BYTE;
8247 dgst_pos0 = 0;
8248 dgst_pos1 = 1;
8249 dgst_pos2 = 2;
8250 dgst_pos3 = 3;
8251 break;
8252
8253 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8254 salt_type = SALT_TYPE_EMBEDDED;
8255 attack_exec = ATTACK_EXEC_ON_CPU;
8256 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8257 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8258 dgst_size = DGST_SIZE_4_5;
8259 parse_func = truecrypt_parse_hash_2k;
8260 sort_by_digest = sort_by_digest_4_5;
8261 opti_type = OPTI_TYPE_ZERO_BYTE;
8262 dgst_pos0 = 0;
8263 dgst_pos1 = 1;
8264 dgst_pos2 = 2;
8265 dgst_pos3 = 3;
8266 break;
8267
8268 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8269 salt_type = SALT_TYPE_EMBEDDED;
8270 attack_exec = ATTACK_EXEC_ON_CPU;
8271 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8272 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8273 dgst_size = DGST_SIZE_4_5;
8274 parse_func = truecrypt_parse_hash_2k;
8275 sort_by_digest = sort_by_digest_4_5;
8276 opti_type = OPTI_TYPE_ZERO_BYTE;
8277 dgst_pos0 = 0;
8278 dgst_pos1 = 1;
8279 dgst_pos2 = 2;
8280 dgst_pos3 = 3;
8281 break;
8282
8283 case 6221: hash_type = HASH_TYPE_SHA512;
8284 salt_type = SALT_TYPE_EMBEDDED;
8285 attack_exec = ATTACK_EXEC_ON_CPU;
8286 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8287 kern_type = KERN_TYPE_TCSHA512_XTS512;
8288 dgst_size = DGST_SIZE_8_8;
8289 parse_func = truecrypt_parse_hash_1k;
8290 sort_by_digest = sort_by_digest_8_8;
8291 opti_type = OPTI_TYPE_ZERO_BYTE;
8292 dgst_pos0 = 0;
8293 dgst_pos1 = 1;
8294 dgst_pos2 = 2;
8295 dgst_pos3 = 3;
8296 break;
8297
8298 case 6222: hash_type = HASH_TYPE_SHA512;
8299 salt_type = SALT_TYPE_EMBEDDED;
8300 attack_exec = ATTACK_EXEC_ON_CPU;
8301 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8302 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8303 dgst_size = DGST_SIZE_8_8;
8304 parse_func = truecrypt_parse_hash_1k;
8305 sort_by_digest = sort_by_digest_8_8;
8306 opti_type = OPTI_TYPE_ZERO_BYTE;
8307 dgst_pos0 = 0;
8308 dgst_pos1 = 1;
8309 dgst_pos2 = 2;
8310 dgst_pos3 = 3;
8311 break;
8312
8313 case 6223: hash_type = HASH_TYPE_SHA512;
8314 salt_type = SALT_TYPE_EMBEDDED;
8315 attack_exec = ATTACK_EXEC_ON_CPU;
8316 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8317 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8318 dgst_size = DGST_SIZE_8_8;
8319 parse_func = truecrypt_parse_hash_1k;
8320 sort_by_digest = sort_by_digest_8_8;
8321 opti_type = OPTI_TYPE_ZERO_BYTE;
8322 dgst_pos0 = 0;
8323 dgst_pos1 = 1;
8324 dgst_pos2 = 2;
8325 dgst_pos3 = 3;
8326 break;
8327
8328 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8329 salt_type = SALT_TYPE_EMBEDDED;
8330 attack_exec = ATTACK_EXEC_ON_CPU;
8331 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8332 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8333 dgst_size = DGST_SIZE_4_8;
8334 parse_func = truecrypt_parse_hash_1k;
8335 sort_by_digest = sort_by_digest_4_8;
8336 opti_type = OPTI_TYPE_ZERO_BYTE;
8337 dgst_pos0 = 0;
8338 dgst_pos1 = 1;
8339 dgst_pos2 = 2;
8340 dgst_pos3 = 3;
8341 break;
8342
8343 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8344 salt_type = SALT_TYPE_EMBEDDED;
8345 attack_exec = ATTACK_EXEC_ON_CPU;
8346 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8347 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8348 dgst_size = DGST_SIZE_4_8;
8349 parse_func = truecrypt_parse_hash_1k;
8350 sort_by_digest = sort_by_digest_4_8;
8351 opti_type = OPTI_TYPE_ZERO_BYTE;
8352 dgst_pos0 = 0;
8353 dgst_pos1 = 1;
8354 dgst_pos2 = 2;
8355 dgst_pos3 = 3;
8356 break;
8357
8358 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8359 salt_type = SALT_TYPE_EMBEDDED;
8360 attack_exec = ATTACK_EXEC_ON_CPU;
8361 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8362 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8363 dgst_size = DGST_SIZE_4_8;
8364 parse_func = truecrypt_parse_hash_1k;
8365 sort_by_digest = sort_by_digest_4_8;
8366 opti_type = OPTI_TYPE_ZERO_BYTE;
8367 dgst_pos0 = 0;
8368 dgst_pos1 = 1;
8369 dgst_pos2 = 2;
8370 dgst_pos3 = 3;
8371 break;
8372
8373 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8374 salt_type = SALT_TYPE_EMBEDDED;
8375 attack_exec = ATTACK_EXEC_ON_CPU;
8376 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8377 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8378 dgst_size = DGST_SIZE_4_5;
8379 parse_func = truecrypt_parse_hash_1k;
8380 sort_by_digest = sort_by_digest_4_5;
8381 opti_type = OPTI_TYPE_ZERO_BYTE;
8382 dgst_pos0 = 0;
8383 dgst_pos1 = 1;
8384 dgst_pos2 = 2;
8385 dgst_pos3 = 3;
8386 break;
8387
8388 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8389 salt_type = SALT_TYPE_EMBEDDED;
8390 attack_exec = ATTACK_EXEC_ON_CPU;
8391 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8392 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8393 dgst_size = DGST_SIZE_4_5;
8394 parse_func = truecrypt_parse_hash_1k;
8395 sort_by_digest = sort_by_digest_4_5;
8396 opti_type = OPTI_TYPE_ZERO_BYTE;
8397 dgst_pos0 = 0;
8398 dgst_pos1 = 1;
8399 dgst_pos2 = 2;
8400 dgst_pos3 = 3;
8401 break;
8402
8403 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8404 salt_type = SALT_TYPE_EMBEDDED;
8405 attack_exec = ATTACK_EXEC_ON_CPU;
8406 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8407 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8408 dgst_size = DGST_SIZE_4_5;
8409 parse_func = truecrypt_parse_hash_1k;
8410 sort_by_digest = sort_by_digest_4_5;
8411 opti_type = OPTI_TYPE_ZERO_BYTE;
8412 dgst_pos0 = 0;
8413 dgst_pos1 = 1;
8414 dgst_pos2 = 2;
8415 dgst_pos3 = 3;
8416 break;
8417
8418 case 6300: hash_type = HASH_TYPE_MD5;
8419 salt_type = SALT_TYPE_EMBEDDED;
8420 attack_exec = ATTACK_EXEC_ON_CPU;
8421 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8422 kern_type = KERN_TYPE_MD5AIX;
8423 dgst_size = DGST_SIZE_4_4;
8424 parse_func = md5aix_parse_hash;
8425 sort_by_digest = sort_by_digest_4_4;
8426 opti_type = OPTI_TYPE_ZERO_BYTE;
8427 dgst_pos0 = 0;
8428 dgst_pos1 = 1;
8429 dgst_pos2 = 2;
8430 dgst_pos3 = 3;
8431 break;
8432
8433 case 6400: hash_type = HASH_TYPE_SHA256;
8434 salt_type = SALT_TYPE_EMBEDDED;
8435 attack_exec = ATTACK_EXEC_ON_CPU;
8436 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8437 kern_type = KERN_TYPE_SHA256AIX;
8438 dgst_size = DGST_SIZE_4_8;
8439 parse_func = sha256aix_parse_hash;
8440 sort_by_digest = sort_by_digest_4_8;
8441 opti_type = OPTI_TYPE_ZERO_BYTE;
8442 dgst_pos0 = 0;
8443 dgst_pos1 = 1;
8444 dgst_pos2 = 2;
8445 dgst_pos3 = 3;
8446 break;
8447
8448 case 6500: hash_type = HASH_TYPE_SHA512;
8449 salt_type = SALT_TYPE_EMBEDDED;
8450 attack_exec = ATTACK_EXEC_ON_CPU;
8451 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8452 kern_type = KERN_TYPE_SHA512AIX;
8453 dgst_size = DGST_SIZE_8_8;
8454 parse_func = sha512aix_parse_hash;
8455 sort_by_digest = sort_by_digest_8_8;
8456 opti_type = OPTI_TYPE_ZERO_BYTE;
8457 dgst_pos0 = 0;
8458 dgst_pos1 = 1;
8459 dgst_pos2 = 2;
8460 dgst_pos3 = 3;
8461 break;
8462
8463 case 6600: hash_type = HASH_TYPE_AES;
8464 salt_type = SALT_TYPE_EMBEDDED;
8465 attack_exec = ATTACK_EXEC_ON_CPU;
8466 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8467 kern_type = KERN_TYPE_AGILEKEY;
8468 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8469 parse_func = agilekey_parse_hash;
8470 sort_by_digest = sort_by_digest_4_5;
8471 opti_type = OPTI_TYPE_ZERO_BYTE;
8472 dgst_pos0 = 0;
8473 dgst_pos1 = 1;
8474 dgst_pos2 = 2;
8475 dgst_pos3 = 3;
8476 break;
8477
8478 case 6700: hash_type = HASH_TYPE_SHA1;
8479 salt_type = SALT_TYPE_EMBEDDED;
8480 attack_exec = ATTACK_EXEC_ON_CPU;
8481 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8482 kern_type = KERN_TYPE_SHA1AIX;
8483 dgst_size = DGST_SIZE_4_5;
8484 parse_func = sha1aix_parse_hash;
8485 sort_by_digest = sort_by_digest_4_5;
8486 opti_type = OPTI_TYPE_ZERO_BYTE;
8487 dgst_pos0 = 0;
8488 dgst_pos1 = 1;
8489 dgst_pos2 = 2;
8490 dgst_pos3 = 3;
8491 break;
8492
8493 case 6800: hash_type = HASH_TYPE_AES;
8494 salt_type = SALT_TYPE_EMBEDDED;
8495 attack_exec = ATTACK_EXEC_ON_CPU;
8496 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8497 kern_type = KERN_TYPE_LASTPASS;
8498 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8499 parse_func = lastpass_parse_hash;
8500 sort_by_digest = sort_by_digest_4_8;
8501 opti_type = OPTI_TYPE_ZERO_BYTE;
8502 dgst_pos0 = 0;
8503 dgst_pos1 = 1;
8504 dgst_pos2 = 2;
8505 dgst_pos3 = 3;
8506 break;
8507
8508 case 6900: hash_type = HASH_TYPE_GOST;
8509 salt_type = SALT_TYPE_NONE;
8510 attack_exec = ATTACK_EXEC_ON_GPU;
8511 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8512 kern_type = KERN_TYPE_GOST;
8513 dgst_size = DGST_SIZE_4_8;
8514 parse_func = gost_parse_hash;
8515 sort_by_digest = sort_by_digest_4_8;
8516 opti_type = OPTI_TYPE_ZERO_BYTE;
8517 dgst_pos0 = 0;
8518 dgst_pos1 = 1;
8519 dgst_pos2 = 2;
8520 dgst_pos3 = 3;
8521 break;
8522
8523 case 7100: hash_type = HASH_TYPE_SHA512;
8524 salt_type = SALT_TYPE_EMBEDDED;
8525 attack_exec = ATTACK_EXEC_ON_CPU;
8526 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8527 kern_type = KERN_TYPE_PBKDF2_SHA512;
8528 dgst_size = DGST_SIZE_8_16;
8529 parse_func = sha512osx_parse_hash;
8530 sort_by_digest = sort_by_digest_8_16;
8531 opti_type = OPTI_TYPE_ZERO_BYTE;
8532 dgst_pos0 = 0;
8533 dgst_pos1 = 1;
8534 dgst_pos2 = 2;
8535 dgst_pos3 = 3;
8536 break;
8537
8538 case 7200: hash_type = HASH_TYPE_SHA512;
8539 salt_type = SALT_TYPE_EMBEDDED;
8540 attack_exec = ATTACK_EXEC_ON_CPU;
8541 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8542 kern_type = KERN_TYPE_PBKDF2_SHA512;
8543 dgst_size = DGST_SIZE_8_16;
8544 parse_func = sha512grub_parse_hash;
8545 sort_by_digest = sort_by_digest_8_16;
8546 opti_type = OPTI_TYPE_ZERO_BYTE;
8547 dgst_pos0 = 0;
8548 dgst_pos1 = 1;
8549 dgst_pos2 = 2;
8550 dgst_pos3 = 3;
8551 break;
8552
8553 case 7300: hash_type = HASH_TYPE_SHA1;
8554 salt_type = SALT_TYPE_EMBEDDED;
8555 attack_exec = ATTACK_EXEC_ON_GPU;
8556 opts_type = OPTS_TYPE_PT_GENERATE_BE
8557 | OPTS_TYPE_ST_ADD80
8558 | OPTS_TYPE_ST_ADDBITS15;
8559 kern_type = KERN_TYPE_RAKP;
8560 dgst_size = DGST_SIZE_4_5;
8561 parse_func = rakp_parse_hash;
8562 sort_by_digest = sort_by_digest_4_5;
8563 opti_type = OPTI_TYPE_ZERO_BYTE
8564 | OPTI_TYPE_NOT_ITERATED;
8565 dgst_pos0 = 3;
8566 dgst_pos1 = 4;
8567 dgst_pos2 = 2;
8568 dgst_pos3 = 1;
8569 break;
8570
8571 case 7400: hash_type = HASH_TYPE_SHA256;
8572 salt_type = SALT_TYPE_EMBEDDED;
8573 attack_exec = ATTACK_EXEC_ON_CPU;
8574 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8575 kern_type = KERN_TYPE_SHA256CRYPT;
8576 dgst_size = DGST_SIZE_4_8;
8577 parse_func = sha256crypt_parse_hash;
8578 sort_by_digest = sort_by_digest_4_8;
8579 opti_type = OPTI_TYPE_ZERO_BYTE;
8580 dgst_pos0 = 0;
8581 dgst_pos1 = 1;
8582 dgst_pos2 = 2;
8583 dgst_pos3 = 3;
8584 break;
8585
8586 case 7500: hash_type = HASH_TYPE_KRB5PA;
8587 salt_type = SALT_TYPE_EMBEDDED;
8588 attack_exec = ATTACK_EXEC_ON_GPU;
8589 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8590 kern_type = KERN_TYPE_KRB5PA;
8591 dgst_size = DGST_SIZE_4_4;
8592 parse_func = krb5pa_parse_hash;
8593 sort_by_digest = sort_by_digest_4_4;
8594 opti_type = OPTI_TYPE_ZERO_BYTE
8595 | OPTI_TYPE_NOT_ITERATED;
8596 dgst_pos0 = 3;
8597 dgst_pos1 = 7;
8598 dgst_pos2 = 2;
8599 dgst_pos3 = 6;
8600 break;
8601
8602 case 7600: hash_type = HASH_TYPE_SHA1;
8603 salt_type = SALT_TYPE_INTERN;
8604 attack_exec = ATTACK_EXEC_ON_GPU;
8605 opts_type = OPTS_TYPE_PT_GENERATE_BE
8606 | OPTS_TYPE_PT_ADD80
8607 | OPTS_TYPE_PT_ADDBITS15;
8608 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8609 dgst_size = DGST_SIZE_4_5;
8610 parse_func = redmine_parse_hash;
8611 sort_by_digest = sort_by_digest_4_5;
8612 opti_type = OPTI_TYPE_ZERO_BYTE
8613 | OPTI_TYPE_PRECOMPUTE_INIT
8614 | OPTI_TYPE_EARLY_SKIP
8615 | OPTI_TYPE_NOT_ITERATED
8616 | OPTI_TYPE_PREPENDED_SALT;
8617 dgst_pos0 = 3;
8618 dgst_pos1 = 4;
8619 dgst_pos2 = 2;
8620 dgst_pos3 = 1;
8621 break;
8622
8623 case 7700: hash_type = HASH_TYPE_SAPB;
8624 salt_type = SALT_TYPE_EMBEDDED;
8625 attack_exec = ATTACK_EXEC_ON_GPU;
8626 opts_type = OPTS_TYPE_PT_GENERATE_LE
8627 | OPTS_TYPE_PT_UPPER
8628 | OPTS_TYPE_ST_UPPER;
8629 kern_type = KERN_TYPE_SAPB;
8630 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8631 parse_func = sapb_parse_hash;
8632 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8633 opti_type = OPTI_TYPE_ZERO_BYTE
8634 | OPTI_TYPE_PRECOMPUTE_INIT
8635 | OPTI_TYPE_NOT_ITERATED;
8636 dgst_pos0 = 0;
8637 dgst_pos1 = 1;
8638 dgst_pos2 = 2;
8639 dgst_pos3 = 3;
8640 break;
8641
8642 case 7800: hash_type = HASH_TYPE_SAPG;
8643 salt_type = SALT_TYPE_EMBEDDED;
8644 attack_exec = ATTACK_EXEC_ON_GPU;
8645 opts_type = OPTS_TYPE_PT_GENERATE_BE
8646 | OPTS_TYPE_ST_ADD80
8647 | OPTS_TYPE_ST_UPPER;
8648 kern_type = KERN_TYPE_SAPG;
8649 dgst_size = DGST_SIZE_4_5;
8650 parse_func = sapg_parse_hash;
8651 sort_by_digest = sort_by_digest_4_5;
8652 opti_type = OPTI_TYPE_ZERO_BYTE
8653 | OPTI_TYPE_PRECOMPUTE_INIT
8654 | OPTI_TYPE_NOT_ITERATED;
8655 dgst_pos0 = 3;
8656 dgst_pos1 = 4;
8657 dgst_pos2 = 2;
8658 dgst_pos3 = 1;
8659 break;
8660
8661 case 7900: hash_type = HASH_TYPE_SHA512;
8662 salt_type = SALT_TYPE_EMBEDDED;
8663 attack_exec = ATTACK_EXEC_ON_CPU;
8664 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8665 kern_type = KERN_TYPE_DRUPAL7;
8666 dgst_size = DGST_SIZE_8_8;
8667 parse_func = drupal7_parse_hash;
8668 sort_by_digest = sort_by_digest_8_8;
8669 opti_type = OPTI_TYPE_ZERO_BYTE;
8670 dgst_pos0 = 0;
8671 dgst_pos1 = 1;
8672 dgst_pos2 = 2;
8673 dgst_pos3 = 3;
8674 break;
8675
8676 case 8000: hash_type = HASH_TYPE_SHA256;
8677 salt_type = SALT_TYPE_EMBEDDED;
8678 attack_exec = ATTACK_EXEC_ON_GPU;
8679 opts_type = OPTS_TYPE_PT_GENERATE_BE
8680 | OPTS_TYPE_PT_UNICODE
8681 | OPTS_TYPE_ST_ADD80
8682 | OPTS_TYPE_ST_HEX;
8683 kern_type = KERN_TYPE_SYBASEASE;
8684 dgst_size = DGST_SIZE_4_8;
8685 parse_func = sybasease_parse_hash;
8686 sort_by_digest = sort_by_digest_4_8;
8687 opti_type = OPTI_TYPE_ZERO_BYTE
8688 | OPTI_TYPE_PRECOMPUTE_INIT
8689 | OPTI_TYPE_EARLY_SKIP
8690 | OPTI_TYPE_NOT_ITERATED
8691 | OPTI_TYPE_RAW_HASH;
8692 dgst_pos0 = 3;
8693 dgst_pos1 = 7;
8694 dgst_pos2 = 2;
8695 dgst_pos3 = 6;
8696 break;
8697
8698 case 8100: hash_type = HASH_TYPE_SHA1;
8699 salt_type = SALT_TYPE_EMBEDDED;
8700 attack_exec = ATTACK_EXEC_ON_GPU;
8701 opts_type = OPTS_TYPE_PT_GENERATE_BE;
8702 kern_type = KERN_TYPE_NETSCALER;
8703 dgst_size = DGST_SIZE_4_5;
8704 parse_func = netscaler_parse_hash;
8705 sort_by_digest = sort_by_digest_4_5;
8706 opti_type = OPTI_TYPE_ZERO_BYTE
8707 | OPTI_TYPE_PRECOMPUTE_INIT
8708 | OPTI_TYPE_PRECOMPUTE_MERKLE
8709 | OPTI_TYPE_EARLY_SKIP
8710 | OPTI_TYPE_NOT_ITERATED
8711 | OPTI_TYPE_PREPENDED_SALT
8712 | OPTI_TYPE_RAW_HASH;
8713 dgst_pos0 = 3;
8714 dgst_pos1 = 4;
8715 dgst_pos2 = 2;
8716 dgst_pos3 = 1;
8717 break;
8718
8719 case 8200: hash_type = HASH_TYPE_SHA256;
8720 salt_type = SALT_TYPE_EMBEDDED;
8721 attack_exec = ATTACK_EXEC_ON_CPU;
8722 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8723 kern_type = KERN_TYPE_CLOUDKEY;
8724 dgst_size = DGST_SIZE_4_8;
8725 parse_func = cloudkey_parse_hash;
8726 sort_by_digest = sort_by_digest_4_8;
8727 opti_type = OPTI_TYPE_ZERO_BYTE;
8728 dgst_pos0 = 0;
8729 dgst_pos1 = 1;
8730 dgst_pos2 = 2;
8731 dgst_pos3 = 3;
8732 break;
8733
8734 case 8300: hash_type = HASH_TYPE_SHA1;
8735 salt_type = SALT_TYPE_EMBEDDED;
8736 attack_exec = ATTACK_EXEC_ON_GPU;
8737 opts_type = OPTS_TYPE_PT_GENERATE_LE
8738 | OPTS_TYPE_ST_HEX
8739 | OPTS_TYPE_ST_ADD80;
8740 kern_type = KERN_TYPE_NSEC3;
8741 dgst_size = DGST_SIZE_4_5;
8742 parse_func = nsec3_parse_hash;
8743 sort_by_digest = sort_by_digest_4_5;
8744 opti_type = OPTI_TYPE_ZERO_BYTE;
8745 dgst_pos0 = 3;
8746 dgst_pos1 = 4;
8747 dgst_pos2 = 2;
8748 dgst_pos3 = 1;
8749 break;
8750
8751 case 8400: hash_type = HASH_TYPE_SHA1;
8752 salt_type = SALT_TYPE_INTERN;
8753 attack_exec = ATTACK_EXEC_ON_GPU;
8754 opts_type = OPTS_TYPE_PT_GENERATE_BE
8755 | OPTS_TYPE_PT_ADD80
8756 | OPTS_TYPE_PT_ADDBITS15;
8757 kern_type = KERN_TYPE_WBB3;
8758 dgst_size = DGST_SIZE_4_5;
8759 parse_func = wbb3_parse_hash;
8760 sort_by_digest = sort_by_digest_4_5;
8761 opti_type = OPTI_TYPE_ZERO_BYTE
8762 | OPTI_TYPE_PRECOMPUTE_INIT
8763 | OPTI_TYPE_NOT_ITERATED;
8764 dgst_pos0 = 3;
8765 dgst_pos1 = 4;
8766 dgst_pos2 = 2;
8767 dgst_pos3 = 1;
8768 break;
8769
8770 case 8500: hash_type = HASH_TYPE_DESRACF;
8771 salt_type = SALT_TYPE_EMBEDDED;
8772 attack_exec = ATTACK_EXEC_ON_GPU;
8773 opts_type = OPTS_TYPE_PT_GENERATE_LE
8774 | OPTS_TYPE_ST_UPPER;
8775 kern_type = KERN_TYPE_RACF;
8776 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8777 parse_func = racf_parse_hash;
8778 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8779 opti_type = OPTI_TYPE_ZERO_BYTE
8780 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8781 dgst_pos0 = 0;
8782 dgst_pos1 = 1;
8783 dgst_pos2 = 2;
8784 dgst_pos3 = 3;
8785 break;
8786
8787 case 8600: hash_type = HASH_TYPE_LOTUS5;
8788 salt_type = SALT_TYPE_NONE;
8789 attack_exec = ATTACK_EXEC_ON_GPU;
8790 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8791 kern_type = KERN_TYPE_LOTUS5;
8792 dgst_size = DGST_SIZE_4_4;
8793 parse_func = lotus5_parse_hash;
8794 sort_by_digest = sort_by_digest_4_4;
8795 opti_type = OPTI_TYPE_EARLY_SKIP
8796 | OPTI_TYPE_NOT_ITERATED
8797 | OPTI_TYPE_NOT_SALTED
8798 | OPTI_TYPE_RAW_HASH;
8799 dgst_pos0 = 0;
8800 dgst_pos1 = 1;
8801 dgst_pos2 = 2;
8802 dgst_pos3 = 3;
8803 break;
8804
8805 case 8700: hash_type = HASH_TYPE_LOTUS6;
8806 salt_type = SALT_TYPE_EMBEDDED;
8807 attack_exec = ATTACK_EXEC_ON_GPU;
8808 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8809 kern_type = KERN_TYPE_LOTUS6;
8810 dgst_size = DGST_SIZE_4_4;
8811 parse_func = lotus6_parse_hash;
8812 sort_by_digest = sort_by_digest_4_4;
8813 opti_type = OPTI_TYPE_EARLY_SKIP
8814 | OPTI_TYPE_NOT_ITERATED
8815 | OPTI_TYPE_RAW_HASH;
8816 dgst_pos0 = 0;
8817 dgst_pos1 = 1;
8818 dgst_pos2 = 2;
8819 dgst_pos3 = 3;
8820 break;
8821
8822 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
8823 salt_type = SALT_TYPE_EMBEDDED;
8824 attack_exec = ATTACK_EXEC_ON_CPU;
8825 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8826 kern_type = KERN_TYPE_ANDROIDFDE;
8827 dgst_size = DGST_SIZE_4_4;
8828 parse_func = androidfde_parse_hash;
8829 sort_by_digest = sort_by_digest_4_4;
8830 opti_type = OPTI_TYPE_ZERO_BYTE;
8831 dgst_pos0 = 0;
8832 dgst_pos1 = 1;
8833 dgst_pos2 = 2;
8834 dgst_pos3 = 3;
8835 break;
8836
8837 case 8900: hash_type = HASH_TYPE_SCRYPT;
8838 salt_type = SALT_TYPE_EMBEDDED;
8839 attack_exec = ATTACK_EXEC_ON_CPU;
8840 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8841 kern_type = KERN_TYPE_SCRYPT;
8842 dgst_size = DGST_SIZE_4_8;
8843 parse_func = scrypt_parse_hash;
8844 sort_by_digest = sort_by_digest_4_8;
8845 opti_type = OPTI_TYPE_ZERO_BYTE;
8846 dgst_pos0 = 0;
8847 dgst_pos1 = 1;
8848 dgst_pos2 = 2;
8849 dgst_pos3 = 3;
8850 break;
8851
8852 case 9000: hash_type = HASH_TYPE_SHA1;
8853 salt_type = SALT_TYPE_EMBEDDED;
8854 attack_exec = ATTACK_EXEC_ON_CPU;
8855 opts_type = OPTS_TYPE_PT_GENERATE_LE
8856 | OPTS_TYPE_ST_GENERATE_LE;
8857 kern_type = KERN_TYPE_PSAFE2;
8858 dgst_size = DGST_SIZE_4_5;
8859 parse_func = psafe2_parse_hash;
8860 sort_by_digest = sort_by_digest_4_5;
8861 opti_type = OPTI_TYPE_ZERO_BYTE;
8862 dgst_pos0 = 0;
8863 dgst_pos1 = 1;
8864 dgst_pos2 = 2;
8865 dgst_pos3 = 3;
8866 break;
8867
8868 case 9100: hash_type = HASH_TYPE_LOTUS8;
8869 salt_type = SALT_TYPE_EMBEDDED;
8870 attack_exec = ATTACK_EXEC_ON_CPU;
8871 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8872 kern_type = KERN_TYPE_LOTUS8;
8873 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8874 parse_func = lotus8_parse_hash;
8875 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8876 opti_type = OPTI_TYPE_ZERO_BYTE;
8877 dgst_pos0 = 0;
8878 dgst_pos1 = 1;
8879 dgst_pos2 = 2;
8880 dgst_pos3 = 3;
8881 break;
8882
8883 case 9200: hash_type = HASH_TYPE_SHA256;
8884 salt_type = SALT_TYPE_EMBEDDED;
8885 attack_exec = ATTACK_EXEC_ON_CPU;
8886 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8887 kern_type = KERN_TYPE_PBKDF2_SHA256;
8888 dgst_size = DGST_SIZE_4_32;
8889 parse_func = cisco8_parse_hash;
8890 sort_by_digest = sort_by_digest_4_32;
8891 opti_type = OPTI_TYPE_ZERO_BYTE;
8892 dgst_pos0 = 0;
8893 dgst_pos1 = 1;
8894 dgst_pos2 = 2;
8895 dgst_pos3 = 3;
8896 break;
8897
8898 case 9300: hash_type = HASH_TYPE_SCRYPT;
8899 salt_type = SALT_TYPE_EMBEDDED;
8900 attack_exec = ATTACK_EXEC_ON_CPU;
8901 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8902 kern_type = KERN_TYPE_SCRYPT;
8903 dgst_size = DGST_SIZE_4_8;
8904 parse_func = cisco9_parse_hash;
8905 sort_by_digest = sort_by_digest_4_8;
8906 opti_type = OPTI_TYPE_ZERO_BYTE;
8907 dgst_pos0 = 0;
8908 dgst_pos1 = 1;
8909 dgst_pos2 = 2;
8910 dgst_pos3 = 3;
8911 break;
8912
8913 case 9400: hash_type = HASH_TYPE_OFFICE2007;
8914 salt_type = SALT_TYPE_EMBEDDED;
8915 attack_exec = ATTACK_EXEC_ON_CPU;
8916 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8917 kern_type = KERN_TYPE_OFFICE2007;
8918 dgst_size = DGST_SIZE_4_4;
8919 parse_func = office2007_parse_hash;
8920 sort_by_digest = sort_by_digest_4_4;
8921 opti_type = OPTI_TYPE_ZERO_BYTE;
8922 dgst_pos0 = 0;
8923 dgst_pos1 = 1;
8924 dgst_pos2 = 2;
8925 dgst_pos3 = 3;
8926 break;
8927
8928 case 9500: hash_type = HASH_TYPE_OFFICE2010;
8929 salt_type = SALT_TYPE_EMBEDDED;
8930 attack_exec = ATTACK_EXEC_ON_CPU;
8931 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8932 kern_type = KERN_TYPE_OFFICE2010;
8933 dgst_size = DGST_SIZE_4_4;
8934 parse_func = office2010_parse_hash;
8935 sort_by_digest = sort_by_digest_4_4;
8936 opti_type = OPTI_TYPE_ZERO_BYTE;
8937 dgst_pos0 = 0;
8938 dgst_pos1 = 1;
8939 dgst_pos2 = 2;
8940 dgst_pos3 = 3;
8941 break;
8942
8943 case 9600: hash_type = HASH_TYPE_OFFICE2013;
8944 salt_type = SALT_TYPE_EMBEDDED;
8945 attack_exec = ATTACK_EXEC_ON_CPU;
8946 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8947 kern_type = KERN_TYPE_OFFICE2013;
8948 dgst_size = DGST_SIZE_4_4;
8949 parse_func = office2013_parse_hash;
8950 sort_by_digest = sort_by_digest_4_4;
8951 opti_type = OPTI_TYPE_ZERO_BYTE;
8952 dgst_pos0 = 0;
8953 dgst_pos1 = 1;
8954 dgst_pos2 = 2;
8955 dgst_pos3 = 3;
8956 break;
8957
8958 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
8959 salt_type = SALT_TYPE_EMBEDDED;
8960 attack_exec = ATTACK_EXEC_ON_GPU;
8961 opts_type = OPTS_TYPE_PT_GENERATE_LE
8962 | OPTS_TYPE_PT_ADD80
8963 | OPTS_TYPE_PT_UNICODE;
8964 kern_type = KERN_TYPE_OLDOFFICE01;
8965 dgst_size = DGST_SIZE_4_4;
8966 parse_func = oldoffice01_parse_hash;
8967 sort_by_digest = sort_by_digest_4_4;
8968 opti_type = OPTI_TYPE_ZERO_BYTE
8969 | OPTI_TYPE_PRECOMPUTE_INIT
8970 | OPTI_TYPE_NOT_ITERATED;
8971 dgst_pos0 = 0;
8972 dgst_pos1 = 1;
8973 dgst_pos2 = 2;
8974 dgst_pos3 = 3;
8975 break;
8976
8977 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
8978 salt_type = SALT_TYPE_EMBEDDED;
8979 attack_exec = ATTACK_EXEC_ON_GPU;
8980 opts_type = OPTS_TYPE_PT_GENERATE_LE
8981 | OPTS_TYPE_PT_ADD80;
8982 kern_type = KERN_TYPE_OLDOFFICE01CM1;
8983 dgst_size = DGST_SIZE_4_4;
8984 parse_func = oldoffice01cm1_parse_hash;
8985 sort_by_digest = sort_by_digest_4_4;
8986 opti_type = OPTI_TYPE_ZERO_BYTE
8987 | OPTI_TYPE_PRECOMPUTE_INIT
8988 | OPTI_TYPE_NOT_ITERATED;
8989 dgst_pos0 = 0;
8990 dgst_pos1 = 1;
8991 dgst_pos2 = 2;
8992 dgst_pos3 = 3;
8993 break;
8994
8995 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
8996 salt_type = SALT_TYPE_EMBEDDED;
8997 attack_exec = ATTACK_EXEC_ON_GPU;
8998 opts_type = OPTS_TYPE_PT_GENERATE_LE
8999 | OPTS_TYPE_PT_ADD80
9000 | OPTS_TYPE_PT_UNICODE
9001 | OPTS_TYPE_PT_NEVERCRACK;
9002 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9003 dgst_size = DGST_SIZE_4_4;
9004 parse_func = oldoffice01cm2_parse_hash;
9005 sort_by_digest = sort_by_digest_4_4;
9006 opti_type = OPTI_TYPE_ZERO_BYTE
9007 | OPTI_TYPE_PRECOMPUTE_INIT
9008 | OPTI_TYPE_NOT_ITERATED;
9009 dgst_pos0 = 0;
9010 dgst_pos1 = 1;
9011 dgst_pos2 = 2;
9012 dgst_pos3 = 3;
9013 break;
9014
9015 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9016 salt_type = SALT_TYPE_EMBEDDED;
9017 attack_exec = ATTACK_EXEC_ON_GPU;
9018 opts_type = OPTS_TYPE_PT_GENERATE_BE
9019 | OPTS_TYPE_PT_ADD80
9020 | OPTS_TYPE_PT_UNICODE;
9021 kern_type = KERN_TYPE_OLDOFFICE34;
9022 dgst_size = DGST_SIZE_4_4;
9023 parse_func = oldoffice34_parse_hash;
9024 sort_by_digest = sort_by_digest_4_4;
9025 opti_type = OPTI_TYPE_ZERO_BYTE
9026 | OPTI_TYPE_PRECOMPUTE_INIT
9027 | OPTI_TYPE_NOT_ITERATED;
9028 dgst_pos0 = 0;
9029 dgst_pos1 = 1;
9030 dgst_pos2 = 2;
9031 dgst_pos3 = 3;
9032 break;
9033
9034 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9035 salt_type = SALT_TYPE_EMBEDDED;
9036 attack_exec = ATTACK_EXEC_ON_GPU;
9037 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9038 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9039 dgst_size = DGST_SIZE_4_4;
9040 parse_func = oldoffice34cm1_parse_hash;
9041 sort_by_digest = sort_by_digest_4_4;
9042 opti_type = OPTI_TYPE_ZERO_BYTE
9043 | OPTI_TYPE_PRECOMPUTE_INIT
9044 | OPTI_TYPE_NOT_ITERATED;
9045 dgst_pos0 = 0;
9046 dgst_pos1 = 1;
9047 dgst_pos2 = 2;
9048 dgst_pos3 = 3;
9049 break;
9050
9051 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9052 salt_type = SALT_TYPE_EMBEDDED;
9053 attack_exec = ATTACK_EXEC_ON_GPU;
9054 opts_type = OPTS_TYPE_PT_GENERATE_BE
9055 | OPTS_TYPE_PT_ADD80
9056 | OPTS_TYPE_PT_UNICODE
9057 | OPTS_TYPE_PT_NEVERCRACK;
9058 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9059 dgst_size = DGST_SIZE_4_4;
9060 parse_func = oldoffice34cm2_parse_hash;
9061 sort_by_digest = sort_by_digest_4_4;
9062 opti_type = OPTI_TYPE_ZERO_BYTE
9063 | OPTI_TYPE_PRECOMPUTE_INIT
9064 | OPTI_TYPE_NOT_ITERATED;
9065 dgst_pos0 = 0;
9066 dgst_pos1 = 1;
9067 dgst_pos2 = 2;
9068 dgst_pos3 = 3;
9069 break;
9070
9071 case 9900: hash_type = HASH_TYPE_MD5;
9072 salt_type = SALT_TYPE_NONE;
9073 attack_exec = ATTACK_EXEC_ON_GPU;
9074 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9075 kern_type = KERN_TYPE_RADMIN2;
9076 dgst_size = DGST_SIZE_4_4;
9077 parse_func = radmin2_parse_hash;
9078 sort_by_digest = sort_by_digest_4_4;
9079 opti_type = OPTI_TYPE_ZERO_BYTE
9080 | OPTI_TYPE_PRECOMPUTE_INIT
9081 | OPTI_TYPE_EARLY_SKIP
9082 | OPTI_TYPE_NOT_ITERATED
9083 | OPTI_TYPE_NOT_SALTED;
9084 dgst_pos0 = 0;
9085 dgst_pos1 = 3;
9086 dgst_pos2 = 2;
9087 dgst_pos3 = 1;
9088 break;
9089
9090 case 10000: hash_type = HASH_TYPE_SHA256;
9091 salt_type = SALT_TYPE_EMBEDDED;
9092 attack_exec = ATTACK_EXEC_ON_CPU;
9093 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9094 kern_type = KERN_TYPE_PBKDF2_SHA256;
9095 dgst_size = DGST_SIZE_4_32;
9096 parse_func = djangopbkdf2_parse_hash;
9097 sort_by_digest = sort_by_digest_4_32;
9098 opti_type = OPTI_TYPE_ZERO_BYTE;
9099 dgst_pos0 = 0;
9100 dgst_pos1 = 1;
9101 dgst_pos2 = 2;
9102 dgst_pos3 = 3;
9103 break;
9104
9105 case 10100: hash_type = HASH_TYPE_SIPHASH;
9106 salt_type = SALT_TYPE_EMBEDDED;
9107 attack_exec = ATTACK_EXEC_ON_GPU;
9108 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9109 kern_type = KERN_TYPE_SIPHASH;
9110 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9111 parse_func = siphash_parse_hash;
9112 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9113 opti_type = OPTI_TYPE_ZERO_BYTE
9114 | OPTI_TYPE_NOT_ITERATED
9115 | OPTI_TYPE_RAW_HASH;
9116 dgst_pos0 = 0;
9117 dgst_pos1 = 1;
9118 dgst_pos2 = 2;
9119 dgst_pos3 = 3;
9120 break;
9121
9122 case 10200: hash_type = HASH_TYPE_MD5;
9123 salt_type = SALT_TYPE_EMBEDDED;
9124 attack_exec = ATTACK_EXEC_ON_GPU;
9125 opts_type = OPTS_TYPE_PT_GENERATE_LE
9126 | OPTS_TYPE_ST_ADD80
9127 | OPTS_TYPE_ST_ADDBITS14;
9128 kern_type = KERN_TYPE_HMACMD5_PW;
9129 dgst_size = DGST_SIZE_4_4;
9130 parse_func = crammd5_parse_hash;
9131 sort_by_digest = sort_by_digest_4_4;
9132 opti_type = OPTI_TYPE_ZERO_BYTE
9133 | OPTI_TYPE_NOT_ITERATED;
9134 dgst_pos0 = 0;
9135 dgst_pos1 = 3;
9136 dgst_pos2 = 2;
9137 dgst_pos3 = 1;
9138 break;
9139
9140 case 10300: hash_type = HASH_TYPE_SHA1;
9141 salt_type = SALT_TYPE_EMBEDDED;
9142 attack_exec = ATTACK_EXEC_ON_CPU;
9143 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9144 kern_type = KERN_TYPE_SAPH_SHA1;
9145 dgst_size = DGST_SIZE_4_5;
9146 parse_func = saph_sha1_parse_hash;
9147 sort_by_digest = sort_by_digest_4_5;
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 10400: hash_type = HASH_TYPE_PDFU16;
9156 salt_type = SALT_TYPE_EMBEDDED;
9157 attack_exec = ATTACK_EXEC_ON_GPU;
9158 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9159 kern_type = KERN_TYPE_PDF11;
9160 dgst_size = DGST_SIZE_4_4;
9161 parse_func = pdf11_parse_hash;
9162 sort_by_digest = sort_by_digest_4_4;
9163 opti_type = OPTI_TYPE_ZERO_BYTE
9164 | OPTI_TYPE_NOT_ITERATED;
9165 dgst_pos0 = 0;
9166 dgst_pos1 = 1;
9167 dgst_pos2 = 2;
9168 dgst_pos3 = 3;
9169 break;
9170
9171 case 10410: hash_type = HASH_TYPE_PDFU16;
9172 salt_type = SALT_TYPE_EMBEDDED;
9173 attack_exec = ATTACK_EXEC_ON_GPU;
9174 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9175 kern_type = KERN_TYPE_PDF11CM1;
9176 dgst_size = DGST_SIZE_4_4;
9177 parse_func = pdf11cm1_parse_hash;
9178 sort_by_digest = sort_by_digest_4_4;
9179 opti_type = OPTI_TYPE_ZERO_BYTE
9180 | OPTI_TYPE_NOT_ITERATED;
9181 dgst_pos0 = 0;
9182 dgst_pos1 = 1;
9183 dgst_pos2 = 2;
9184 dgst_pos3 = 3;
9185 break;
9186
9187 case 10420: hash_type = HASH_TYPE_PDFU16;
9188 salt_type = SALT_TYPE_EMBEDDED;
9189 attack_exec = ATTACK_EXEC_ON_GPU;
9190 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9191 kern_type = KERN_TYPE_PDF11CM2;
9192 dgst_size = DGST_SIZE_4_4;
9193 parse_func = pdf11cm2_parse_hash;
9194 sort_by_digest = sort_by_digest_4_4;
9195 opti_type = OPTI_TYPE_ZERO_BYTE
9196 | OPTI_TYPE_NOT_ITERATED;
9197 dgst_pos0 = 0;
9198 dgst_pos1 = 1;
9199 dgst_pos2 = 2;
9200 dgst_pos3 = 3;
9201 break;
9202
9203 case 10500: hash_type = HASH_TYPE_PDFU16;
9204 salt_type = SALT_TYPE_EMBEDDED;
9205 attack_exec = ATTACK_EXEC_ON_CPU;
9206 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9207 kern_type = KERN_TYPE_PDF14;
9208 dgst_size = DGST_SIZE_4_4;
9209 parse_func = pdf14_parse_hash;
9210 sort_by_digest = sort_by_digest_4_4;
9211 opti_type = OPTI_TYPE_ZERO_BYTE
9212 | OPTI_TYPE_NOT_ITERATED;
9213 dgst_pos0 = 0;
9214 dgst_pos1 = 1;
9215 dgst_pos2 = 2;
9216 dgst_pos3 = 3;
9217 break;
9218
9219 case 10600: hash_type = HASH_TYPE_SHA256;
9220 salt_type = SALT_TYPE_EMBEDDED;
9221 attack_exec = ATTACK_EXEC_ON_GPU;
9222 opts_type = OPTS_TYPE_PT_GENERATE_BE
9223 | OPTS_TYPE_ST_ADD80
9224 | OPTS_TYPE_ST_ADDBITS15
9225 | OPTS_TYPE_HASH_COPY;
9226 kern_type = KERN_TYPE_SHA256_PWSLT;
9227 dgst_size = DGST_SIZE_4_8;
9228 parse_func = pdf17l3_parse_hash;
9229 sort_by_digest = sort_by_digest_4_8;
9230 opti_type = OPTI_TYPE_ZERO_BYTE
9231 | OPTI_TYPE_PRECOMPUTE_INIT
9232 | OPTI_TYPE_PRECOMPUTE_MERKLE
9233 | OPTI_TYPE_EARLY_SKIP
9234 | OPTI_TYPE_NOT_ITERATED
9235 | OPTI_TYPE_APPENDED_SALT
9236 | OPTI_TYPE_RAW_HASH;
9237 dgst_pos0 = 3;
9238 dgst_pos1 = 7;
9239 dgst_pos2 = 2;
9240 dgst_pos3 = 6;
9241 break;
9242
9243 case 10700: hash_type = HASH_TYPE_PDFU32;
9244 salt_type = SALT_TYPE_EMBEDDED;
9245 attack_exec = ATTACK_EXEC_ON_CPU;
9246 opts_type = OPTS_TYPE_PT_GENERATE_LE
9247 | OPTS_TYPE_HASH_COPY;
9248 kern_type = KERN_TYPE_PDF17L8;
9249 dgst_size = DGST_SIZE_4_8;
9250 parse_func = pdf17l8_parse_hash;
9251 sort_by_digest = sort_by_digest_4_8;
9252 opti_type = OPTI_TYPE_ZERO_BYTE
9253 | OPTI_TYPE_NOT_ITERATED;
9254 dgst_pos0 = 0;
9255 dgst_pos1 = 1;
9256 dgst_pos2 = 2;
9257 dgst_pos3 = 3;
9258 break;
9259
9260 case 10800: hash_type = HASH_TYPE_SHA384;
9261 salt_type = SALT_TYPE_NONE;
9262 attack_exec = ATTACK_EXEC_ON_GPU;
9263 opts_type = OPTS_TYPE_PT_GENERATE_BE
9264 | OPTS_TYPE_PT_ADD80
9265 | OPTS_TYPE_PT_ADDBITS15;
9266 kern_type = KERN_TYPE_SHA384;
9267 dgst_size = DGST_SIZE_8_8;
9268 parse_func = sha384_parse_hash;
9269 sort_by_digest = sort_by_digest_8_8;
9270 opti_type = OPTI_TYPE_ZERO_BYTE
9271 | OPTI_TYPE_PRECOMPUTE_INIT
9272 | OPTI_TYPE_PRECOMPUTE_MERKLE
9273 | OPTI_TYPE_EARLY_SKIP
9274 | OPTI_TYPE_NOT_ITERATED
9275 | OPTI_TYPE_NOT_SALTED
9276 | OPTI_TYPE_RAW_HASH;
9277 dgst_pos0 = 6;
9278 dgst_pos1 = 7;
9279 dgst_pos2 = 4;
9280 dgst_pos3 = 5;
9281 break;
9282
9283 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9284 salt_type = SALT_TYPE_EMBEDDED;
9285 attack_exec = ATTACK_EXEC_ON_CPU;
9286 opts_type = OPTS_TYPE_PT_GENERATE_LE
9287 | OPTS_TYPE_ST_BASE64
9288 | OPTS_TYPE_HASH_COPY;
9289 kern_type = KERN_TYPE_PBKDF2_SHA256;
9290 dgst_size = DGST_SIZE_4_32;
9291 parse_func = pbkdf2_sha256_parse_hash;
9292 sort_by_digest = sort_by_digest_4_32;
9293 opti_type = OPTI_TYPE_ZERO_BYTE;
9294 dgst_pos0 = 0;
9295 dgst_pos1 = 1;
9296 dgst_pos2 = 2;
9297 dgst_pos3 = 3;
9298 break;
9299
9300 case 11000: hash_type = HASH_TYPE_MD5;
9301 salt_type = SALT_TYPE_INTERN;
9302 attack_exec = ATTACK_EXEC_ON_GPU;
9303 opts_type = OPTS_TYPE_PT_GENERATE_LE
9304 | OPTS_TYPE_PT_ADD80;
9305 kern_type = KERN_TYPE_PRESTASHOP;
9306 dgst_size = DGST_SIZE_4_4;
9307 parse_func = prestashop_parse_hash;
9308 sort_by_digest = sort_by_digest_4_4;
9309 opti_type = OPTI_TYPE_ZERO_BYTE
9310 | OPTI_TYPE_PRECOMPUTE_INIT
9311 | OPTI_TYPE_NOT_ITERATED
9312 | OPTI_TYPE_PREPENDED_SALT;
9313 dgst_pos0 = 0;
9314 dgst_pos1 = 3;
9315 dgst_pos2 = 2;
9316 dgst_pos3 = 1;
9317 break;
9318
9319 case 11100: hash_type = HASH_TYPE_MD5;
9320 salt_type = SALT_TYPE_EMBEDDED;
9321 attack_exec = ATTACK_EXEC_ON_GPU;
9322 opts_type = OPTS_TYPE_PT_GENERATE_LE
9323 | OPTS_TYPE_ST_ADD80;
9324 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9325 dgst_size = DGST_SIZE_4_4;
9326 parse_func = postgresql_auth_parse_hash;
9327 sort_by_digest = sort_by_digest_4_4;
9328 opti_type = OPTI_TYPE_ZERO_BYTE
9329 | OPTI_TYPE_PRECOMPUTE_INIT
9330 | OPTI_TYPE_PRECOMPUTE_MERKLE
9331 | OPTI_TYPE_EARLY_SKIP;
9332 dgst_pos0 = 0;
9333 dgst_pos1 = 3;
9334 dgst_pos2 = 2;
9335 dgst_pos3 = 1;
9336 break;
9337
9338 case 11200: hash_type = HASH_TYPE_SHA1;
9339 salt_type = SALT_TYPE_EMBEDDED;
9340 attack_exec = ATTACK_EXEC_ON_GPU;
9341 opts_type = OPTS_TYPE_PT_GENERATE_BE
9342 | OPTS_TYPE_PT_ADD80
9343 | OPTS_TYPE_ST_HEX;
9344 kern_type = KERN_TYPE_MYSQL_AUTH;
9345 dgst_size = DGST_SIZE_4_5;
9346 parse_func = mysql_auth_parse_hash;
9347 sort_by_digest = sort_by_digest_4_5;
9348 opti_type = OPTI_TYPE_ZERO_BYTE
9349 | OPTI_TYPE_EARLY_SKIP;
9350 dgst_pos0 = 3;
9351 dgst_pos1 = 4;
9352 dgst_pos2 = 2;
9353 dgst_pos3 = 1;
9354 break;
9355
9356 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9357 salt_type = SALT_TYPE_EMBEDDED;
9358 attack_exec = ATTACK_EXEC_ON_CPU;
9359 opts_type = OPTS_TYPE_PT_GENERATE_LE
9360 | OPTS_TYPE_ST_HEX
9361 | OPTS_TYPE_ST_ADD80;
9362 kern_type = KERN_TYPE_BITCOIN_WALLET;
9363 dgst_size = DGST_SIZE_4_4;
9364 parse_func = bitcoin_wallet_parse_hash;
9365 sort_by_digest = sort_by_digest_4_4;
9366 opti_type = OPTI_TYPE_ZERO_BYTE;
9367 dgst_pos0 = 0;
9368 dgst_pos1 = 1;
9369 dgst_pos2 = 2;
9370 dgst_pos3 = 3;
9371 break;
9372
9373 case 11400: hash_type = HASH_TYPE_MD5;
9374 salt_type = SALT_TYPE_EMBEDDED;
9375 attack_exec = ATTACK_EXEC_ON_GPU;
9376 opts_type = OPTS_TYPE_PT_GENERATE_LE
9377 | OPTS_TYPE_PT_ADD80
9378 | OPTS_TYPE_HASH_COPY;
9379 kern_type = KERN_TYPE_SIP_AUTH;
9380 dgst_size = DGST_SIZE_4_4;
9381 parse_func = sip_auth_parse_hash;
9382 sort_by_digest = sort_by_digest_4_4;
9383 opti_type = OPTI_TYPE_ZERO_BYTE;
9384 dgst_pos0 = 0;
9385 dgst_pos1 = 3;
9386 dgst_pos2 = 2;
9387 dgst_pos3 = 1;
9388 break;
9389
9390 case 11500: hash_type = HASH_TYPE_CRC32;
9391 salt_type = SALT_TYPE_INTERN;
9392 attack_exec = ATTACK_EXEC_ON_GPU;
9393 opts_type = OPTS_TYPE_PT_GENERATE_LE
9394 | OPTS_TYPE_ST_GENERATE_LE
9395 | OPTS_TYPE_ST_HEX;
9396 kern_type = KERN_TYPE_CRC32;
9397 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9398 parse_func = crc32_parse_hash;
9399 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9400 opti_type = OPTI_TYPE_ZERO_BYTE;
9401 dgst_pos0 = 0;
9402 dgst_pos1 = 1;
9403 dgst_pos2 = 2;
9404 dgst_pos3 = 3;
9405 break;
9406
9407 case 11600: hash_type = HASH_TYPE_AES;
9408 salt_type = SALT_TYPE_EMBEDDED;
9409 attack_exec = ATTACK_EXEC_ON_CPU;
9410 opts_type = OPTS_TYPE_PT_GENERATE_LE
9411 | OPTS_TYPE_PT_NEVERCRACK;
9412 kern_type = KERN_TYPE_SEVEN_ZIP;
9413 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9414 parse_func = seven_zip_parse_hash;
9415 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9416 opti_type = OPTI_TYPE_ZERO_BYTE;
9417 dgst_pos0 = 0;
9418 dgst_pos1 = 1;
9419 dgst_pos2 = 2;
9420 dgst_pos3 = 3;
9421 break;
9422
9423 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9424 salt_type = SALT_TYPE_NONE;
9425 attack_exec = ATTACK_EXEC_ON_GPU;
9426 opts_type = OPTS_TYPE_PT_GENERATE_LE
9427 | OPTS_TYPE_PT_ADD01;
9428 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9429 dgst_size = DGST_SIZE_4_8;
9430 parse_func = gost2012sbog_256_parse_hash;
9431 sort_by_digest = sort_by_digest_4_8;
9432 opti_type = OPTI_TYPE_ZERO_BYTE;
9433 dgst_pos0 = 0;
9434 dgst_pos1 = 1;
9435 dgst_pos2 = 2;
9436 dgst_pos3 = 3;
9437 break;
9438
9439 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9440 salt_type = SALT_TYPE_NONE;
9441 attack_exec = ATTACK_EXEC_ON_GPU;
9442 opts_type = OPTS_TYPE_PT_GENERATE_LE
9443 | OPTS_TYPE_PT_ADD01;
9444 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9445 dgst_size = DGST_SIZE_4_16;
9446 parse_func = gost2012sbog_512_parse_hash;
9447 sort_by_digest = sort_by_digest_4_16;
9448 opti_type = OPTI_TYPE_ZERO_BYTE;
9449 dgst_pos0 = 0;
9450 dgst_pos1 = 1;
9451 dgst_pos2 = 2;
9452 dgst_pos3 = 3;
9453 break;
9454
9455 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9456 salt_type = SALT_TYPE_EMBEDDED;
9457 attack_exec = ATTACK_EXEC_ON_CPU;
9458 opts_type = OPTS_TYPE_PT_GENERATE_LE
9459 | OPTS_TYPE_ST_BASE64
9460 | OPTS_TYPE_HASH_COPY;
9461 kern_type = KERN_TYPE_PBKDF2_MD5;
9462 dgst_size = DGST_SIZE_4_32;
9463 parse_func = pbkdf2_md5_parse_hash;
9464 sort_by_digest = sort_by_digest_4_32;
9465 opti_type = OPTI_TYPE_ZERO_BYTE;
9466 dgst_pos0 = 0;
9467 dgst_pos1 = 1;
9468 dgst_pos2 = 2;
9469 dgst_pos3 = 3;
9470 break;
9471
9472 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9473 salt_type = SALT_TYPE_EMBEDDED;
9474 attack_exec = ATTACK_EXEC_ON_CPU;
9475 opts_type = OPTS_TYPE_PT_GENERATE_LE
9476 | OPTS_TYPE_ST_BASE64
9477 | OPTS_TYPE_HASH_COPY;
9478 kern_type = KERN_TYPE_PBKDF2_SHA1;
9479 dgst_size = DGST_SIZE_4_32;
9480 parse_func = pbkdf2_sha1_parse_hash;
9481 sort_by_digest = sort_by_digest_4_32;
9482 opti_type = OPTI_TYPE_ZERO_BYTE;
9483 dgst_pos0 = 0;
9484 dgst_pos1 = 1;
9485 dgst_pos2 = 2;
9486 dgst_pos3 = 3;
9487 break;
9488
9489 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9490 salt_type = SALT_TYPE_EMBEDDED;
9491 attack_exec = ATTACK_EXEC_ON_CPU;
9492 opts_type = OPTS_TYPE_PT_GENERATE_LE
9493 | OPTS_TYPE_ST_BASE64
9494 | OPTS_TYPE_HASH_COPY;
9495 kern_type = KERN_TYPE_PBKDF2_SHA512;
9496 dgst_size = DGST_SIZE_8_16;
9497 parse_func = pbkdf2_sha512_parse_hash;
9498 sort_by_digest = sort_by_digest_8_16;
9499 opti_type = OPTI_TYPE_ZERO_BYTE;
9500 dgst_pos0 = 0;
9501 dgst_pos1 = 1;
9502 dgst_pos2 = 2;
9503 dgst_pos3 = 3;
9504 break;
9505
9506 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9507 salt_type = SALT_TYPE_EMBEDDED;
9508 attack_exec = ATTACK_EXEC_ON_CPU;
9509 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9510 kern_type = KERN_TYPE_ECRYPTFS;
9511 dgst_size = DGST_SIZE_8_8;
9512 parse_func = ecryptfs_parse_hash;
9513 sort_by_digest = sort_by_digest_8_8;
9514 opti_type = OPTI_TYPE_ZERO_BYTE;
9515 dgst_pos0 = 0;
9516 dgst_pos1 = 1;
9517 dgst_pos2 = 2;
9518 dgst_pos3 = 3;
9519 break;
9520
9521 case 12300: hash_type = HASH_TYPE_ORACLET;
9522 salt_type = SALT_TYPE_EMBEDDED;
9523 attack_exec = ATTACK_EXEC_ON_CPU;
9524 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9525 kern_type = KERN_TYPE_ORACLET;
9526 dgst_size = DGST_SIZE_8_16;
9527 parse_func = oraclet_parse_hash;
9528 sort_by_digest = sort_by_digest_8_16;
9529 opti_type = OPTI_TYPE_ZERO_BYTE;
9530 dgst_pos0 = 0;
9531 dgst_pos1 = 1;
9532 dgst_pos2 = 2;
9533 dgst_pos3 = 3;
9534 break;
9535
9536 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9537 salt_type = SALT_TYPE_EMBEDDED;
9538 attack_exec = ATTACK_EXEC_ON_CPU;
9539 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9540 kern_type = KERN_TYPE_BSDICRYPT;
9541 dgst_size = DGST_SIZE_4_4;
9542 parse_func = bsdicrypt_parse_hash;
9543 sort_by_digest = sort_by_digest_4_4;
9544 opti_type = OPTI_TYPE_ZERO_BYTE
9545 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9546 dgst_pos0 = 0;
9547 dgst_pos1 = 1;
9548 dgst_pos2 = 2;
9549 dgst_pos3 = 3;
9550 break;
9551
9552 case 12500: hash_type = HASH_TYPE_RAR3HP;
9553 salt_type = SALT_TYPE_EMBEDDED;
9554 attack_exec = ATTACK_EXEC_ON_CPU;
9555 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9556 kern_type = KERN_TYPE_RAR3;
9557 dgst_size = DGST_SIZE_4_4;
9558 parse_func = rar3hp_parse_hash;
9559 sort_by_digest = sort_by_digest_4_4;
9560 opti_type = OPTI_TYPE_ZERO_BYTE;
9561 dgst_pos0 = 0;
9562 dgst_pos1 = 1;
9563 dgst_pos2 = 2;
9564 dgst_pos3 = 3;
9565 break;
9566
9567 case 12600: hash_type = HASH_TYPE_SHA256;
9568 salt_type = SALT_TYPE_INTERN;
9569 attack_exec = ATTACK_EXEC_ON_GPU;
9570 opts_type = OPTS_TYPE_PT_GENERATE_BE
9571 | OPTS_TYPE_PT_ADD80;
9572 kern_type = KERN_TYPE_CF10;
9573 dgst_size = DGST_SIZE_4_8;
9574 parse_func = cf10_parse_hash;
9575 sort_by_digest = sort_by_digest_4_8;
9576 opti_type = OPTI_TYPE_ZERO_BYTE
9577 | OPTI_TYPE_PRECOMPUTE_INIT
9578 | OPTI_TYPE_EARLY_SKIP
9579 | OPTI_TYPE_NOT_ITERATED;
9580 dgst_pos0 = 3;
9581 dgst_pos1 = 7;
9582 dgst_pos2 = 2;
9583 dgst_pos3 = 6;
9584 break;
9585
9586 case 12700: hash_type = HASH_TYPE_AES;
9587 salt_type = SALT_TYPE_EMBEDDED;
9588 attack_exec = ATTACK_EXEC_ON_CPU;
9589 opts_type = OPTS_TYPE_PT_GENERATE_LE
9590 | OPTS_TYPE_HASH_COPY;
9591 kern_type = KERN_TYPE_MYWALLET;
9592 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9593 parse_func = mywallet_parse_hash;
9594 sort_by_digest = sort_by_digest_4_5;
9595 opti_type = OPTI_TYPE_ZERO_BYTE;
9596 dgst_pos0 = 0;
9597 dgst_pos1 = 1;
9598 dgst_pos2 = 2;
9599 dgst_pos3 = 3;
9600 break;
9601
9602 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9603 salt_type = SALT_TYPE_EMBEDDED;
9604 attack_exec = ATTACK_EXEC_ON_CPU;
9605 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9606 kern_type = KERN_TYPE_MS_DRSR;
9607 dgst_size = DGST_SIZE_4_8;
9608 parse_func = ms_drsr_parse_hash;
9609 sort_by_digest = sort_by_digest_4_8;
9610 opti_type = OPTI_TYPE_ZERO_BYTE;
9611 dgst_pos0 = 0;
9612 dgst_pos1 = 1;
9613 dgst_pos2 = 2;
9614 dgst_pos3 = 3;
9615 break;
9616
9617 default: usage_mini_print (PROGNAME); return (-1);
9618 }
9619
9620 /**
9621 * transpose
9622 */
9623
9624 data.parse_func = parse_func;
9625
9626 /**
9627 * misc stuff
9628 */
9629
9630 if (hex_salt)
9631 {
9632 if (salt_type == SALT_TYPE_INTERN)
9633 {
9634 opts_type |= OPTS_TYPE_ST_HEX;
9635 }
9636 else
9637 {
9638 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
9639
9640 return (-1);
9641 }
9642 }
9643
9644 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
9645 | (salt_type == SALT_TYPE_EXTERN)
9646 | (salt_type == SALT_TYPE_EMBEDDED)
9647 | (salt_type == SALT_TYPE_VIRTUAL));
9648
9649 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
9650
9651 data.hash_type = hash_type;
9652 data.attack_mode = attack_mode;
9653 data.attack_kern = attack_kern;
9654 data.attack_exec = attack_exec;
9655 data.kern_type = kern_type;
9656 data.opts_type = opts_type;
9657 data.dgst_size = dgst_size;
9658 data.salt_type = salt_type;
9659 data.isSalted = isSalted;
9660 data.sort_by_digest = sort_by_digest;
9661 data.dgst_pos0 = dgst_pos0;
9662 data.dgst_pos1 = dgst_pos1;
9663 data.dgst_pos2 = dgst_pos2;
9664 data.dgst_pos3 = dgst_pos3;
9665
9666 esalt_size = 0;
9667
9668 switch (hash_mode)
9669 {
9670 case 2500: esalt_size = sizeof (wpa_t); break;
9671 case 5300: esalt_size = sizeof (ikepsk_t); break;
9672 case 5400: esalt_size = sizeof (ikepsk_t); break;
9673 case 5500: esalt_size = sizeof (netntlm_t); break;
9674 case 5600: esalt_size = sizeof (netntlm_t); break;
9675 case 6211:
9676 case 6212:
9677 case 6213:
9678 case 6221:
9679 case 6222:
9680 case 6223:
9681 case 6231:
9682 case 6232:
9683 case 6233:
9684 case 6241:
9685 case 6242:
9686 case 6243: esalt_size = sizeof (tc_t); break;
9687 case 6600: esalt_size = sizeof (agilekey_t); break;
9688 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9689 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
9690 case 7300: esalt_size = sizeof (rakp_t); break;
9691 case 7500: esalt_size = sizeof (krb5pa_t); break;
9692 case 8200: esalt_size = sizeof (cloudkey_t); break;
9693 case 8800: esalt_size = sizeof (androidfde_t); break;
9694 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
9695 case 9400: esalt_size = sizeof (office2007_t); break;
9696 case 9500: esalt_size = sizeof (office2010_t); break;
9697 case 9600: esalt_size = sizeof (office2013_t); break;
9698 case 9700: esalt_size = sizeof (oldoffice01_t); break;
9699 case 9710: esalt_size = sizeof (oldoffice01_t); break;
9700 case 9720: esalt_size = sizeof (oldoffice01_t); break;
9701 case 9800: esalt_size = sizeof (oldoffice34_t); break;
9702 case 9810: esalt_size = sizeof (oldoffice34_t); break;
9703 case 9820: esalt_size = sizeof (oldoffice34_t); break;
9704 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
9705 case 10200: esalt_size = sizeof (cram_md5_t); break;
9706 case 10400: esalt_size = sizeof (pdf_t); break;
9707 case 10410: esalt_size = sizeof (pdf_t); break;
9708 case 10420: esalt_size = sizeof (pdf_t); break;
9709 case 10500: esalt_size = sizeof (pdf_t); break;
9710 case 10600: esalt_size = sizeof (pdf_t); break;
9711 case 10700: esalt_size = sizeof (pdf_t); break;
9712 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
9713 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
9714 case 11400: esalt_size = sizeof (sip_t); break;
9715 case 11600: esalt_size = sizeof (seven_zip_t); break;
9716 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
9717 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
9718 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9719 }
9720
9721 data.esalt_size = esalt_size;
9722
9723 /**
9724 * choose dictionary parser
9725 */
9726
9727 if (hash_type == HASH_TYPE_LM)
9728 {
9729 get_next_word_func = get_next_word_lm;
9730 }
9731 else if (opts_type & OPTS_TYPE_PT_UPPER)
9732 {
9733 get_next_word_func = get_next_word_uc;
9734 }
9735 else
9736 {
9737 get_next_word_func = get_next_word_std;
9738 }
9739
9740 /**
9741 * dictstat
9742 */
9743
9744 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
9745
9746 #ifdef _POSIX
9747 size_t dictstat_nmemb = 0;
9748 #endif
9749
9750 #ifdef _WIN
9751 uint dictstat_nmemb = 0;
9752 #endif
9753
9754 char dictstat[256];
9755
9756 FILE *dictstat_fp = NULL;
9757
9758 if (keyspace == 0)
9759 {
9760 memset (dictstat, 0, sizeof (dictstat));
9761
9762 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s.dictstat", install_dir, PROGNAME);
9763
9764 dictstat_fp = fopen (dictstat, "rb");
9765
9766 if (dictstat_fp)
9767 {
9768 #ifdef _POSIX
9769 struct stat tmpstat;
9770
9771 fstat (fileno (dictstat_fp), &tmpstat);
9772 #endif
9773
9774 #ifdef _WIN
9775 struct stat64 tmpstat;
9776
9777 _fstat64 (fileno (dictstat_fp), &tmpstat);
9778 #endif
9779
9780 if (tmpstat.st_mtime < COMPTIME)
9781 {
9782 /* with v0.15 the format changed so we have to ensure user is using a good version
9783 since there is no version-header in the dictstat file */
9784
9785 fclose (dictstat_fp);
9786
9787 unlink (dictstat);
9788 }
9789 else
9790 {
9791 while (!feof (dictstat_fp))
9792 {
9793 dictstat_t d;
9794
9795 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
9796
9797 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
9798
9799 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
9800 {
9801 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
9802
9803 return -1;
9804 }
9805 }
9806
9807 fclose (dictstat_fp);
9808 }
9809 }
9810 }
9811
9812 /**
9813 * potfile
9814 */
9815
9816 char potfile[256];
9817
9818 memset (potfile, 0, sizeof (potfile));
9819
9820 snprintf (potfile, sizeof (potfile) - 1, "%s.pot", session);
9821
9822 data.pot_fp = NULL;
9823
9824 FILE *out_fp = NULL;
9825 FILE *pot_fp = NULL;
9826
9827 if (show == 1 || left == 1)
9828 {
9829 pot_fp = fopen (potfile, "rb");
9830
9831 if (pot_fp == NULL)
9832 {
9833 log_error ("ERROR: %s: %s", potfile, strerror (errno));
9834
9835 return (-1);
9836 }
9837
9838 if (outfile != NULL)
9839 {
9840 if ((out_fp = fopen (outfile, "ab")) == NULL)
9841 {
9842 log_error ("ERROR: %s: %s", outfile, strerror (errno));
9843
9844 fclose (pot_fp);
9845
9846 return (-1);
9847 }
9848 }
9849 else
9850 {
9851 out_fp = stdout;
9852 }
9853 }
9854 else
9855 {
9856 if (potfile_disable == 0)
9857 {
9858 pot_fp = fopen (potfile, "ab");
9859
9860 if (pot_fp == NULL)
9861 {
9862 log_error ("ERROR: %s: %s", potfile, strerror (errno));
9863
9864 return (-1);
9865 }
9866
9867 data.pot_fp = pot_fp;
9868 }
9869 }
9870
9871 pot_t *pot = NULL;
9872
9873 uint pot_cnt = 0;
9874 uint pot_avail = 0;
9875
9876 if (show == 1 || left == 1)
9877 {
9878 SUPPRESS_OUTPUT = 1;
9879
9880 pot_avail = count_lines (pot_fp);
9881
9882 rewind (pot_fp);
9883
9884 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
9885
9886 uint pot_hashes_avail = 0;
9887
9888 uint line_num = 0;
9889
9890 while (!feof (pot_fp))
9891 {
9892 line_num++;
9893
9894 char line_buf[BUFSIZ];
9895
9896 int line_len = fgetl (pot_fp, line_buf);
9897
9898 if (line_len == 0) continue;
9899
9900 char *plain_buf = line_buf + line_len;
9901
9902 pot_t *pot_ptr = &pot[pot_cnt];
9903
9904 hash_t *hashes_buf = &pot_ptr->hash;
9905
9906 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
9907 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
9908
9909 if (pot_cnt == pot_hashes_avail)
9910 {
9911 uint pos = 0;
9912
9913 for (pos = 0; pos < INCR_POT; pos++)
9914 {
9915 if ((pot_cnt + pos) >= pot_avail) break;
9916
9917 pot_t *tmp_pot = &pot[pot_cnt + pos];
9918
9919 hash_t *tmp_hash = &tmp_pot->hash;
9920
9921 tmp_hash->digest = mymalloc (dgst_size);
9922
9923 if (isSalted)
9924 {
9925 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
9926 }
9927
9928 if (esalt_size)
9929 {
9930 tmp_hash->esalt = mymalloc (esalt_size);
9931 }
9932
9933 pot_hashes_avail++;
9934 }
9935 }
9936
9937 int plain_len = 0;
9938
9939 int parser_status;
9940
9941 int iter = MAX_CUT_TRIES;
9942
9943 do
9944 {
9945 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
9946 {
9947 if (line_buf[i] == ':')
9948 {
9949 line_len--;
9950
9951 break;
9952 }
9953 }
9954
9955 if (data.hash_mode != 2500)
9956 {
9957 parser_status = parse_func (line_buf, line_len, hashes_buf);
9958 }
9959 else
9960 {
9961 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
9962
9963 if (line_len > max_salt_size)
9964 {
9965 parser_status = PARSER_GLOBAL_LENGTH;
9966 }
9967 else
9968 {
9969 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
9970
9971 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
9972
9973 hashes_buf->salt->salt_len = line_len;
9974
9975 parser_status = PARSER_OK;
9976 }
9977 }
9978
9979 // if NOT parsed without error, we add the ":" to the plain
9980
9981 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
9982 {
9983 plain_len++;
9984 plain_buf--;
9985 }
9986
9987 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
9988
9989 if (parser_status < PARSER_GLOBAL_ZERO)
9990 {
9991 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
9992
9993 continue;
9994 }
9995
9996 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
9997
9998 pot_ptr->plain_len = plain_len;
9999
10000 pot_cnt++;
10001 }
10002
10003 fclose (pot_fp);
10004
10005 SUPPRESS_OUTPUT = 0;
10006
10007 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10008 }
10009
10010 /**
10011 * gpu accel and loops auto adjustment
10012 */
10013
10014 if (gpu_accel_chgd == 0) gpu_accel = set_gpu_accel (hash_mode);
10015 if (gpu_loops_chgd == 0) gpu_loops = set_gpu_loops (hash_mode);
10016
10017 if (workload_profile == 1)
10018 {
10019 gpu_loops /= 8;
10020 gpu_accel /= 4;
10021
10022 if (gpu_loops == 0) gpu_loops = 8;
10023 if (gpu_accel == 0) gpu_accel = 2;
10024 }
10025 else if (workload_profile == 3)
10026 {
10027 gpu_loops *= 8;
10028 gpu_accel *= 4;
10029
10030 if (gpu_loops > 1024) gpu_loops = 1024;
10031 if (gpu_accel > 256) gpu_accel = 256; // causes memory problems otherwise
10032 }
10033
10034 // those hashes *must* run at a specific gpu_loops count because of some optimization inside the kernel
10035
10036 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10037 {
10038 gpu_loops = 1024;
10039 }
10040
10041 if (hash_mode == 12500)
10042 {
10043 gpu_loops = ROUNDS_RAR3 / 16;
10044 }
10045
10046 data.gpu_accel = gpu_accel;
10047 data.gpu_loops = gpu_loops;
10048
10049 /**
10050 * word len
10051 */
10052
10053 uint pw_min = PW_MIN;
10054 uint pw_max = PW_MAX;
10055
10056 switch (hash_mode)
10057 {
10058 case 400: if (pw_max > 40) pw_max = 40;
10059 break;
10060 case 500: if (pw_max > 16) pw_max = 16;
10061 break;
10062 case 1500: if (pw_max > 8) pw_max = 8;
10063 break;
10064 case 1600: if (pw_max > 16) pw_max = 16;
10065 break;
10066 case 1800: if (pw_max > 16) pw_max = 16;
10067 break;
10068 case 2100: if (pw_max > 16) pw_max = 16;
10069 break;
10070 case 2500: if (pw_min < 8) pw_min = 8;
10071 break;
10072 case 3000: if (pw_max > 7) pw_max = 7;
10073 break;
10074 case 5200: if (pw_max > 24) pw_max = 24;
10075 break;
10076 case 5800: if (pw_max > 16) pw_max = 16;
10077 break;
10078 case 6300: if (pw_max > 16) pw_max = 16;
10079 break;
10080 case 7400: if (pw_max > 16) pw_max = 16;
10081 break;
10082 case 7900: if (pw_max > 48) pw_max = 48;
10083 break;
10084 case 8500: if (pw_max > 8) pw_max = 8;
10085 break;
10086 case 8600: if (pw_max > 16) pw_max = 16;
10087 break;
10088 case 9710: pw_min = 5;
10089 pw_max = 5;
10090 break;
10091 case 9810: pw_min = 5;
10092 pw_max = 5;
10093 break;
10094 case 10410: pw_min = 5;
10095 pw_max = 5;
10096 break;
10097 case 10300: if (pw_max < 3) pw_min = 3;
10098 if (pw_max > 40) pw_max = 40;
10099 break;
10100 case 10500: if (pw_max < 3) pw_min = 3;
10101 if (pw_max > 40) pw_max = 40;
10102 break;
10103 case 10700: if (pw_max > 16) pw_max = 16;
10104 break;
10105 case 11300: if (pw_max > 40) pw_max = 40;
10106 break;
10107 case 12500: if (pw_max > 20) pw_max = 20;
10108 break;
10109 case 12800: if (pw_max > 24) pw_max = 24;
10110 break;
10111 }
10112
10113 if (attack_exec == ATTACK_EXEC_ON_GPU)
10114 {
10115 switch (attack_kern)
10116 {
10117 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10118 break;
10119 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10120 break;
10121 }
10122 }
10123
10124 /**
10125 * charsets : keep them together for more easy maintainnce
10126 */
10127
10128 cs_t mp_sys[6];
10129 cs_t mp_usr[4];
10130
10131 memset (mp_sys, 0, sizeof (mp_sys));
10132 memset (mp_usr, 0, sizeof (mp_usr));
10133
10134 mp_setup_sys (mp_sys);
10135
10136 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10137 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10138 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10139 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10140
10141 /**
10142 * load hashes, part I: find input mode, count hashes
10143 */
10144
10145 uint hashlist_mode = 0;
10146 uint hashlist_format = HLFMT_HASHCAT;
10147
10148 uint hashes_avail = 0;
10149
10150 if (benchmark == 0)
10151 {
10152 struct stat f;
10153
10154 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10155
10156 if ((hash_mode == 2500) ||
10157 (hash_mode == 5200) ||
10158 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10159 (hash_mode == 9000))
10160 {
10161 hashlist_mode = HL_MODE_ARG;
10162
10163 char *hashfile = myargv[optind];
10164
10165 data.hashfile = hashfile;
10166
10167 logfile_top_var_string ("target", hashfile);
10168 }
10169
10170 if (hashlist_mode == HL_MODE_ARG)
10171 {
10172 if (hash_mode == 2500)
10173 {
10174 struct stat st;
10175
10176 if (stat (data.hashfile, &st) == -1)
10177 {
10178 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10179
10180 return (-1);
10181 }
10182
10183 hashes_avail = st.st_size / sizeof (hccap_t);
10184 }
10185 else
10186 {
10187 hashes_avail = 1;
10188 }
10189 }
10190 else if (hashlist_mode == HL_MODE_FILE)
10191 {
10192 char *hashfile = myargv[optind];
10193
10194 data.hashfile = hashfile;
10195
10196 logfile_top_var_string ("target", hashfile);
10197
10198 FILE *fp = NULL;
10199
10200 if ((fp = fopen (hashfile, "rb")) == NULL)
10201 {
10202 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10203
10204 return (-1);
10205 }
10206
10207 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10208
10209 hashes_avail = count_lines (fp);
10210
10211 rewind (fp);
10212
10213 if (hashes_avail == 0)
10214 {
10215 log_error ("ERROR: hashfile is empty or corrupt");
10216
10217 fclose (fp);
10218
10219 return (-1);
10220 }
10221
10222 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10223
10224 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10225 {
10226 log_error ("ERROR: remove not supported in native hashfile-format mode");
10227
10228 fclose (fp);
10229
10230 return (-1);
10231 }
10232
10233 fclose (fp);
10234 }
10235 }
10236 else
10237 {
10238 hashlist_mode = HL_MODE_ARG;
10239
10240 hashes_avail = 1;
10241 }
10242
10243 if (hash_mode == 3000) hashes_avail *= 2;
10244
10245 data.hashlist_mode = hashlist_mode;
10246 data.hashlist_format = hashlist_format;
10247
10248 logfile_top_uint (hashlist_mode);
10249 logfile_top_uint (hashlist_format);
10250
10251 /**
10252 * load hashes, part II: allocate required memory, set pointers
10253 */
10254
10255 hash_t *hashes_buf = NULL;
10256 void *digests_buf = NULL;
10257 salt_t *salts_buf = NULL;
10258 void *esalts_buf = NULL;
10259
10260 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10261
10262 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10263
10264 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10265 {
10266 uint32_t hash_pos;
10267
10268 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10269 {
10270 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10271
10272 hashes_buf[hash_pos].hash_info = hash_info;
10273
10274 if (username && (remove || show || left))
10275 {
10276 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10277 }
10278
10279 if (benchmark)
10280 {
10281 hash_info->orighash = (char *) mymalloc (256);
10282 }
10283 }
10284 }
10285
10286 if (isSalted)
10287 {
10288 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10289
10290 if (esalt_size)
10291 {
10292 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10293 }
10294 }
10295 else
10296 {
10297 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10298 }
10299
10300 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10301 {
10302 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10303
10304 if (isSalted)
10305 {
10306 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10307
10308 if (esalt_size)
10309 {
10310 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10311 }
10312 }
10313 else
10314 {
10315 hashes_buf[hash_pos].salt = &salts_buf[0];
10316 }
10317 }
10318
10319 /**
10320 * load hashes, part III: parse hashes or generate them if benchmark
10321 */
10322
10323 uint hashes_cnt = 0;
10324
10325 if (benchmark == 0)
10326 {
10327 if (keyspace == 1)
10328 {
10329 // useless to read hash file for keyspace, cheat a little bit w/ optind
10330 }
10331 else if (hashes_avail == 0)
10332 {
10333 }
10334 else if (hashlist_mode == HL_MODE_ARG)
10335 {
10336 char *input_buf = myargv[optind];
10337
10338 uint input_len = strlen (input_buf);
10339
10340 logfile_top_var_string ("target", input_buf);
10341
10342 char *hash_buf = NULL;
10343 int hash_len = 0;
10344
10345 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10346
10347 if (hash_len)
10348 {
10349 if (opts_type & OPTS_TYPE_HASH_COPY)
10350 {
10351 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10352
10353 hash_info_tmp->orighash = mystrdup (hash_buf);
10354 }
10355
10356 if (isSalted)
10357 {
10358 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10359 }
10360
10361 int parser_status = PARSER_OK;
10362
10363 if (hash_mode == 2500)
10364 {
10365 if (hash_len == 0)
10366 {
10367 log_error ("ERROR: hccap file not specified");
10368
10369 return (-1);
10370 }
10371
10372 hashlist_mode = HL_MODE_FILE;
10373
10374 data.hashlist_mode = hashlist_mode;
10375
10376 FILE *fp = fopen (hash_buf, "rb");
10377
10378 if (fp == NULL)
10379 {
10380 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10381
10382 return (-1);
10383 }
10384
10385 if (hashes_avail < 1)
10386 {
10387 log_error ("ERROR: hccap file is empty or corrupt");
10388
10389 fclose (fp);
10390
10391 return (-1);
10392 }
10393
10394 uint hccap_size = sizeof (hccap_t);
10395
10396 char in[hccap_size];
10397
10398 while (!feof (fp))
10399 {
10400 int n = fread (&in, hccap_size, 1, fp);
10401
10402 if (n != 1)
10403 {
10404 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10405
10406 break;
10407 }
10408
10409 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10410
10411 if (parser_status != PARSER_OK)
10412 {
10413 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10414
10415 continue;
10416 }
10417
10418 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10419
10420 if ((show == 1) || (left == 1))
10421 {
10422 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10423
10424 char *salt_ptr = (char *) tmp_salt->salt_buf;
10425
10426 int cur_pos = tmp_salt->salt_len;
10427 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10428
10429 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10430
10431 unsigned char *pke_ptr = (unsigned char *) wpa->pke;
10432
10433 // do the appending task
10434
10435 snprintf (salt_ptr + cur_pos,
10436 rem_len,
10437 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10438 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10439 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10440
10441
10442 // memset () the remaining part of the salt
10443
10444 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10445 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10446
10447 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10448
10449 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10450 }
10451
10452 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);
10453 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);
10454
10455 hashes_cnt++;
10456 }
10457
10458 fclose (fp);
10459 }
10460 else if (hash_mode == 3000)
10461 {
10462 if (hash_len == 32)
10463 {
10464 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10465
10466 hash_t *lm_hash_left = NULL;
10467
10468 if (parser_status == PARSER_OK)
10469 {
10470 lm_hash_left = &hashes_buf[hashes_cnt];
10471
10472 hashes_cnt++;
10473 }
10474 else
10475 {
10476 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10477 }
10478
10479
10480 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10481
10482 hash_t *lm_hash_right = NULL;
10483
10484 if (parser_status == PARSER_OK)
10485 {
10486 lm_hash_right = &hashes_buf[hashes_cnt];
10487
10488 hashes_cnt++;
10489 }
10490 else
10491 {
10492 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10493 }
10494
10495 // show / left
10496
10497 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10498 {
10499 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);
10500 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);
10501 }
10502 }
10503 else
10504 {
10505 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10506
10507 if (parser_status == PARSER_OK)
10508 {
10509 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10510 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10511 }
10512
10513 if (parser_status == PARSER_OK)
10514 {
10515 hashes_cnt++;
10516 }
10517 else
10518 {
10519 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10520 }
10521 }
10522 }
10523 else
10524 {
10525 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10526
10527 if (parser_status == PARSER_OK)
10528 {
10529 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10530 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10531 }
10532
10533 if (parser_status == PARSER_OK)
10534 {
10535 hashes_cnt++;
10536 }
10537 else
10538 {
10539 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10540 }
10541 }
10542 }
10543 }
10544 else if (hashlist_mode == HL_MODE_FILE)
10545 {
10546 char *hashfile = data.hashfile;
10547
10548 FILE *fp;
10549
10550 if ((fp = fopen (hashfile, "rb")) == NULL)
10551 {
10552 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10553
10554 return (-1);
10555 }
10556
10557 uint line_num = 0;
10558
10559 while (!feof (fp))
10560 {
10561 line_num++;
10562
10563 char line_buf[BUFSIZ];
10564
10565 int line_len = fgetl (fp, line_buf);
10566
10567 if (line_len == 0) continue;
10568
10569 char *hash_buf = NULL;
10570 int hash_len = 0;
10571
10572 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10573
10574 if (username)
10575 {
10576 char *user_buf = NULL;
10577 int user_len = 0;
10578
10579 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10580
10581 if (remove || show)
10582 {
10583 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10584
10585 *user = (user_t *) malloc (sizeof (user_t));
10586
10587 user_t *user_ptr = *user;
10588
10589 if (user_buf != NULL)
10590 {
10591 user_ptr->user_name = mystrdup (user_buf);
10592 }
10593 else
10594 {
10595 user_ptr->user_name = mystrdup ("");
10596 }
10597
10598 user_ptr->user_len = user_len;
10599 }
10600 }
10601
10602 if (opts_type & OPTS_TYPE_HASH_COPY)
10603 {
10604 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10605
10606 hash_info_tmp->orighash = mystrdup (hash_buf);
10607 }
10608
10609 if (isSalted)
10610 {
10611 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10612 }
10613
10614 if (hash_mode == 3000)
10615 {
10616 if (hash_len == 32)
10617 {
10618 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10619
10620 if (parser_status < PARSER_GLOBAL_ZERO)
10621 {
10622 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10623
10624 continue;
10625 }
10626
10627 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10628
10629 hashes_cnt++;
10630
10631 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10632
10633 if (parser_status < PARSER_GLOBAL_ZERO)
10634 {
10635 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10636
10637 continue;
10638 }
10639
10640 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
10641
10642 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);
10643
10644 hashes_cnt++;
10645
10646 // show / left
10647
10648 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);
10649 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);
10650 }
10651 else
10652 {
10653 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10654
10655 if (parser_status < PARSER_GLOBAL_ZERO)
10656 {
10657 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10658
10659 continue;
10660 }
10661
10662 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);
10663
10664 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10665 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10666
10667 hashes_cnt++;
10668 }
10669 }
10670 else
10671 {
10672 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10673
10674 if (parser_status < PARSER_GLOBAL_ZERO)
10675 {
10676 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10677
10678 continue;
10679 }
10680
10681 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);
10682
10683 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10684 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10685
10686 hashes_cnt++;
10687 }
10688 }
10689
10690 fclose (fp);
10691
10692 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
10693
10694 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
10695 }
10696 }
10697 else
10698 {
10699 if (isSalted)
10700 {
10701 hashes_buf[0].salt->salt_len = 8;
10702
10703 // special salt handling
10704
10705 switch (hash_mode)
10706 {
10707 case 1500: hashes_buf[0].salt->salt_len = 2;
10708 break;
10709 case 1731: hashes_buf[0].salt->salt_len = 4;
10710 break;
10711 case 2410: hashes_buf[0].salt->salt_len = 4;
10712 break;
10713 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
10714 break;
10715 case 3100: hashes_buf[0].salt->salt_len = 1;
10716 break;
10717 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
10718 break;
10719 case 5800: hashes_buf[0].salt->salt_len = 16;
10720 break;
10721 case 6800: hashes_buf[0].salt->salt_len = 32;
10722 break;
10723 case 8400: hashes_buf[0].salt->salt_len = 40;
10724 break;
10725 case 8800: hashes_buf[0].salt->salt_len = 16;
10726 break;
10727 case 8900: hashes_buf[0].salt->salt_len = 16;
10728 hashes_buf[0].salt->scrypt_N = 1024;
10729 hashes_buf[0].salt->scrypt_r = 1;
10730 hashes_buf[0].salt->scrypt_p = 1;
10731 break;
10732 case 9100: hashes_buf[0].salt->salt_len = 16;
10733 break;
10734 case 9300: hashes_buf[0].salt->salt_len = 14;
10735 hashes_buf[0].salt->scrypt_N = 16384;
10736 hashes_buf[0].salt->scrypt_r = 1;
10737 hashes_buf[0].salt->scrypt_p = 1;
10738 break;
10739 case 9400: hashes_buf[0].salt->salt_len = 16;
10740 break;
10741 case 9500: hashes_buf[0].salt->salt_len = 16;
10742 break;
10743 case 9600: hashes_buf[0].salt->salt_len = 16;
10744 break;
10745 case 9700: hashes_buf[0].salt->salt_len = 16;
10746 break;
10747 case 9710: hashes_buf[0].salt->salt_len = 16;
10748 break;
10749 case 9720: hashes_buf[0].salt->salt_len = 16;
10750 break;
10751 case 9800: hashes_buf[0].salt->salt_len = 16;
10752 break;
10753 case 9810: hashes_buf[0].salt->salt_len = 16;
10754 break;
10755 case 9820: hashes_buf[0].salt->salt_len = 16;
10756 break;
10757 case 10300: hashes_buf[0].salt->salt_len = 12;
10758 break;
10759 case 11500: hashes_buf[0].salt->salt_len = 4;
10760 break;
10761 case 11600: hashes_buf[0].salt->salt_len = 4;
10762 break;
10763 case 12400: hashes_buf[0].salt->salt_len = 4;
10764 break;
10765 case 12500: hashes_buf[0].salt->salt_len = 8;
10766 break;
10767 case 12600: hashes_buf[0].salt->salt_len = 64;
10768 break;
10769 }
10770
10771 // special esalt handling
10772
10773 switch (hash_mode)
10774 {
10775 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
10776 break;
10777 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10778 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10779 break;
10780 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10781 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10782 break;
10783 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10784 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10785 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10786 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10787 break;
10788 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10789 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10790 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10791 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10792 break;
10793 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
10794 break;
10795 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10796 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10797 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10798 break;
10799 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10800 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10801 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10802 break;
10803 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10804 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10805 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10806 break;
10807 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10808 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10809 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10810 break;
10811 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10812 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
10813 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
10814 break;
10815 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10816 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
10817 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
10818 break;
10819 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
10820 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
10821 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
10822 break;
10823 }
10824 }
10825
10826 // set hashfile
10827
10828 switch (hash_mode)
10829 {
10830 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
10831 break;
10832 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
10833 break;
10834 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
10835 break;
10836 case 6211:
10837 case 6212:
10838 case 6213:
10839 case 6221:
10840 case 6222:
10841 case 6223:
10842 case 6231:
10843 case 6232:
10844 case 6233:
10845 case 6241:
10846 case 6242:
10847 case 6243: data.hashfile = mystrdup ("hashcat.tc");
10848 break;
10849 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
10850 break;
10851 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
10852 break;
10853 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
10854 break;
10855 }
10856
10857 // set default iterations
10858
10859 switch (hash_mode)
10860 {
10861 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
10862 break;
10863 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
10864 break;
10865 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
10866 break;
10867 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
10868 break;
10869 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
10870 break;
10871 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
10872 break;
10873 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
10874 break;
10875 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
10876 break;
10877 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
10878 break;
10879 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
10880 break;
10881 case 6211:
10882 case 6212:
10883 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
10884 break;
10885 case 6221:
10886 case 6222:
10887 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
10888 break;
10889 case 6231:
10890 case 6232:
10891 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
10892 break;
10893 case 6241:
10894 case 6242:
10895 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
10896 break;
10897 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
10898 break;
10899 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
10900 break;
10901 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
10902 break;
10903 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
10904 break;
10905 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
10906 break;
10907 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
10908 break;
10909 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
10910 break;
10911 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
10912 break;
10913 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
10914 break;
10915 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
10916 break;
10917 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
10918 break;
10919 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
10920 break;
10921 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
10922 break;
10923 case 8900: hashes_buf[0].salt->salt_iter = 1;
10924 break;
10925 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
10926 break;
10927 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
10928 break;
10929 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
10930 break;
10931 case 9300: hashes_buf[0].salt->salt_iter = 1;
10932 break;
10933 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
10934 break;
10935 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
10936 break;
10937 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
10938 break;
10939 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
10940 break;
10941 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
10942 break;
10943 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
10944 break;
10945 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
10946 break;
10947 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
10948 break;
10949 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
10950 break;
10951 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
10952 break;
10953 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
10954 break;
10955 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
10956 break;
10957 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
10958 break;
10959 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
10960 break;
10961 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
10962 break;
10963 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
10964 break;
10965 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
10966 break;
10967 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
10968 break;
10969 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
10970 break;
10971 }
10972
10973 // set special tuning for benchmark-mode 1
10974
10975 if (benchmark_mode == 1)
10976 {
10977 gpu_loops *= 8;
10978 gpu_accel *= 4;
10979
10980 switch (hash_mode)
10981 {
10982 case 400: gpu_loops = ROUNDS_PHPASS;
10983 gpu_accel = 32;
10984 break;
10985 case 500: gpu_loops = ROUNDS_MD5CRYPT;
10986 gpu_accel = 32;
10987 break;
10988 case 501: gpu_loops = ROUNDS_MD5CRYPT;
10989 gpu_accel = 32;
10990 break;
10991 case 1600: gpu_loops = ROUNDS_MD5CRYPT;
10992 gpu_accel = 32;
10993 break;
10994 case 1800: gpu_loops = ROUNDS_SHA512CRYPT;
10995 gpu_accel = 8;
10996 break;
10997 case 2100: gpu_loops = ROUNDS_DCC2;
10998 gpu_accel = 16;
10999 break;
11000 case 2500: gpu_loops = ROUNDS_WPA2;
11001 gpu_accel = 32;
11002 break;
11003 case 3200: gpu_loops = ROUNDS_BCRYPT;
11004 gpu_accel = 2;
11005 break;
11006 case 5200: gpu_loops = ROUNDS_PSAFE3;
11007 gpu_accel = 16;
11008 break;
11009 case 5800: gpu_loops = ROUNDS_ANDROIDPIN;
11010 gpu_accel = 16;
11011 break;
11012 case 6211: gpu_loops = ROUNDS_TRUECRYPT_2K;
11013 gpu_accel = 64;
11014 break;
11015 case 6212: gpu_loops = ROUNDS_TRUECRYPT_2K;
11016 gpu_accel = 32;
11017 break;
11018 case 6213: gpu_loops = ROUNDS_TRUECRYPT_2K;
11019 gpu_accel = 32;
11020 break;
11021 case 6221: gpu_loops = ROUNDS_TRUECRYPT_1K;
11022 gpu_accel = 8;
11023 break;
11024 case 6222: gpu_loops = ROUNDS_TRUECRYPT_1K;
11025 gpu_accel = 8;
11026 break;
11027 case 6223: gpu_loops = ROUNDS_TRUECRYPT_1K;
11028 gpu_accel = 8;
11029 break;
11030 case 6231: gpu_loops = ROUNDS_TRUECRYPT_1K;
11031 gpu_accel = 8;
11032 break;
11033 case 6232: gpu_loops = ROUNDS_TRUECRYPT_1K;
11034 gpu_accel = 8;
11035 break;
11036 case 6233: gpu_loops = ROUNDS_TRUECRYPT_1K;
11037 gpu_accel = 8;
11038 break;
11039 case 6241: gpu_loops = ROUNDS_TRUECRYPT_1K;
11040 gpu_accel = 128;
11041 break;
11042 case 6242: gpu_loops = ROUNDS_TRUECRYPT_1K;
11043 gpu_accel = 64;
11044 break;
11045 case 6243: gpu_loops = ROUNDS_TRUECRYPT_1K;
11046 gpu_accel = 64;
11047 break;
11048 case 6300: gpu_loops = ROUNDS_MD5CRYPT;
11049 gpu_accel = 32;
11050 break;
11051 case 6700: gpu_loops = ROUNDS_SHA1AIX;
11052 gpu_accel = 128;
11053 break;
11054 case 6400: gpu_loops = ROUNDS_SHA256AIX;
11055 gpu_accel = 128;
11056 break;
11057 case 6500: gpu_loops = ROUNDS_SHA512AIX;
11058 gpu_accel = 32;
11059 break;
11060 case 6600: gpu_loops = ROUNDS_AGILEKEY;
11061 gpu_accel = 64;
11062 break;
11063 case 6800: gpu_loops = ROUNDS_LASTPASS;
11064 gpu_accel = 64;
11065 break;
11066 case 7100: gpu_loops = ROUNDS_SHA512OSX;
11067 gpu_accel = 2;
11068 break;
11069 case 7200: gpu_loops = ROUNDS_GRUB;
11070 gpu_accel = 2;
11071 break;
11072 case 7400: gpu_loops = ROUNDS_SHA256CRYPT;
11073 gpu_accel = 4;
11074 break;
11075 case 7900: gpu_loops = ROUNDS_DRUPAL7;
11076 gpu_accel = 8;
11077 break;
11078 case 8200: gpu_loops = ROUNDS_CLOUDKEY;
11079 gpu_accel = 2;
11080 break;
11081 case 8800: gpu_loops = ROUNDS_ANDROIDFDE;
11082 gpu_accel = 32;
11083 break;
11084 case 8900: gpu_loops = 1;
11085 gpu_accel = 64;
11086 break;
11087 case 9000: gpu_loops = ROUNDS_PSAFE2;
11088 gpu_accel = 16;
11089 break;
11090 case 9100: gpu_loops = ROUNDS_LOTUS8;
11091 gpu_accel = 64;
11092 break;
11093 case 9200: gpu_loops = ROUNDS_CISCO8;
11094 gpu_accel = 8;
11095 break;
11096 case 9300: gpu_loops = 1;
11097 gpu_accel = 4;
11098 break;
11099 case 9400: gpu_loops = ROUNDS_OFFICE2007;
11100 gpu_accel = 32;
11101 break;
11102 case 9500: gpu_loops = ROUNDS_OFFICE2010;
11103 gpu_accel = 32;
11104 break;
11105 case 9600: gpu_loops = ROUNDS_OFFICE2013;
11106 gpu_accel = 4;
11107 break;
11108 case 10000: gpu_loops = ROUNDS_DJANGOPBKDF2;
11109 gpu_accel = 8;
11110 break;
11111 case 10300: gpu_loops = ROUNDS_SAPH_SHA1;
11112 gpu_accel = 16;
11113 break;
11114 case 10500: gpu_loops = ROUNDS_PDF14;
11115 gpu_accel = 256;
11116 break;
11117 case 10700: gpu_loops = ROUNDS_PDF17L8;
11118 gpu_accel = 8;
11119 break;
11120 case 10900: gpu_loops = ROUNDS_PBKDF2_SHA256;
11121 gpu_accel = 8;
11122 break;
11123 case 11300: gpu_loops = ROUNDS_BITCOIN_WALLET;
11124 gpu_accel = 2;
11125 break;
11126 case 11600: gpu_loops = ROUNDS_SEVEN_ZIP;
11127 gpu_accel = 4;
11128 break;
11129 case 11900: gpu_loops = ROUNDS_PBKDF2_MD5;
11130 gpu_accel = 8;
11131 break;
11132 case 12000: gpu_loops = ROUNDS_PBKDF2_SHA1;
11133 gpu_accel = 8;
11134 break;
11135 case 12100: gpu_loops = ROUNDS_PBKDF2_SHA512;
11136 gpu_accel = 8;
11137 break;
11138 case 12200: gpu_loops = ROUNDS_ECRYPTFS;
11139 gpu_accel = 8;
11140 break;
11141 case 12300: gpu_loops = ROUNDS_ORACLET;
11142 gpu_accel = 8;
11143 break;
11144 case 12500: gpu_loops = ROUNDS_RAR3;
11145 gpu_accel = 32;
11146 break;
11147 case 12700: gpu_loops = ROUNDS_MYWALLET;
11148 gpu_accel = 512;
11149 break;
11150 case 12800: gpu_loops = ROUNDS_MS_DRSR;
11151 gpu_accel = 512;
11152 break;
11153 }
11154
11155 // some algorithm collide too fast, make that impossible
11156
11157 switch (hash_mode)
11158 {
11159 case 11500: ((uint *) digests_buf)[1] = 1;
11160 break;
11161 }
11162
11163 if (gpu_loops > 1024) gpu_loops = 1024;
11164 if (gpu_accel > 256) gpu_accel = 256; // causes memory problems otherwise
11165 }
11166
11167 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11168 {
11169 gpu_loops = 1024;
11170 }
11171
11172 if (hash_mode == 12500)
11173 {
11174 gpu_loops = ROUNDS_RAR3 / 16;
11175 }
11176
11177 data.gpu_accel = gpu_accel;
11178 data.gpu_loops = gpu_loops;
11179
11180 hashes_cnt = 1;
11181 }
11182
11183 if (show == 1 || left == 1)
11184 {
11185 for (uint i = 0; i < pot_cnt; i++)
11186 {
11187 pot_t *pot_ptr = &pot[i];
11188
11189 hash_t *hashes_buf = &pot_ptr->hash;
11190
11191 local_free (hashes_buf->digest);
11192
11193 if (isSalted)
11194 {
11195 local_free (hashes_buf->salt);
11196 }
11197 }
11198
11199 local_free (pot);
11200
11201 if (data.quiet == 0) log_info_nn ("");
11202
11203 return (0);
11204 }
11205
11206 if (keyspace == 0)
11207 {
11208 if (hashes_cnt == 0)
11209 {
11210 log_error ("ERROR: No hashes loaded");
11211
11212 return (-1);
11213 }
11214 }
11215
11216 /**
11217 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11218 */
11219
11220 if (data.outfile != NULL)
11221 {
11222 if (data.hashfile != NULL)
11223 {
11224 #ifdef _POSIX
11225 struct stat tmpstat_outfile;
11226 struct stat tmpstat_hashfile;
11227 #endif
11228
11229 #ifdef _WIN
11230 struct stat64 tmpstat_outfile;
11231 struct stat64 tmpstat_hashfile;
11232 #endif
11233
11234 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11235
11236 if (tmp_outfile_fp)
11237 {
11238 #ifdef _POSIX
11239 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11240 #endif
11241
11242 #ifdef _WIN
11243 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11244 #endif
11245
11246 fclose (tmp_outfile_fp);
11247 }
11248
11249 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11250
11251 if (tmp_hashfile_fp)
11252 {
11253 #ifdef _POSIX
11254 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11255 #endif
11256
11257 #ifdef _WIN
11258 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11259 #endif
11260
11261 fclose (tmp_hashfile_fp);
11262 }
11263
11264 if (tmp_outfile_fp && tmp_outfile_fp)
11265 {
11266 tmpstat_outfile.st_mode = 0;
11267 tmpstat_outfile.st_nlink = 0;
11268 tmpstat_outfile.st_uid = 0;
11269 tmpstat_outfile.st_gid = 0;
11270 tmpstat_outfile.st_rdev = 0;
11271 tmpstat_outfile.st_atime = 0;
11272
11273 tmpstat_hashfile.st_mode = 0;
11274 tmpstat_hashfile.st_nlink = 0;
11275 tmpstat_hashfile.st_uid = 0;
11276 tmpstat_hashfile.st_gid = 0;
11277 tmpstat_hashfile.st_rdev = 0;
11278 tmpstat_hashfile.st_atime = 0;
11279
11280 #ifdef _POSIX
11281 tmpstat_outfile.st_blksize = 0;
11282 tmpstat_outfile.st_blocks = 0;
11283
11284 tmpstat_hashfile.st_blksize = 0;
11285 tmpstat_hashfile.st_blocks = 0;
11286 #endif
11287
11288 #ifdef _POSIX
11289 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11290 {
11291 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11292
11293 return (-1);
11294 }
11295 #endif
11296
11297 #ifdef _WIN
11298 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11299 {
11300 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11301
11302 return (-1);
11303 }
11304 #endif
11305 }
11306 }
11307 }
11308
11309 /**
11310 * Remove duplicates
11311 */
11312
11313 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11314
11315 if (isSalted)
11316 {
11317 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11318 }
11319 else
11320 {
11321 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11322 }
11323
11324 uint hashes_cnt_orig = hashes_cnt;
11325
11326 hashes_cnt = 1;
11327
11328 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11329 {
11330 if (isSalted)
11331 {
11332 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11333 {
11334 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11335 }
11336 }
11337 else
11338 {
11339 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11340 }
11341
11342 if (hashes_pos > hashes_cnt)
11343 {
11344 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11345 }
11346
11347 hashes_cnt++;
11348 }
11349
11350 /**
11351 * Potfile removes
11352 */
11353
11354 uint potfile_remove_cracks = 0;
11355
11356 if (potfile_disable == 0)
11357 {
11358 hash_t hash_buf;
11359
11360 hash_buf.digest = mymalloc (dgst_size);
11361 hash_buf.salt = NULL;
11362 hash_buf.esalt = NULL;
11363 hash_buf.hash_info = NULL;
11364 hash_buf.cracked = 0;
11365
11366 if (isSalted)
11367 {
11368 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11369 }
11370
11371 if (esalt_size)
11372 {
11373 hash_buf.esalt = mymalloc (esalt_size);
11374 }
11375
11376 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11377
11378 // no solution for these special hash types (for instane because they use hashfile in output etc)
11379 if ((hash_mode != 5200) &&
11380 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11381 (hash_mode != 9000))
11382 {
11383 FILE *fp = fopen (potfile, "rb");
11384
11385 if (fp != NULL)
11386 {
11387 while (!feof (fp))
11388 {
11389 char line_buf[BUFSIZ];
11390
11391 memset (line_buf, 0, BUFSIZ);
11392
11393 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11394
11395 if (ptr == NULL) break;
11396
11397 int line_len = strlen (line_buf);
11398
11399 if (line_len == 0) continue;
11400
11401 int iter = MAX_CUT_TRIES;
11402
11403 for (int i = line_len - 1; i && iter; i--, line_len--)
11404 {
11405 if (line_buf[i] != ':') continue;
11406
11407 if (isSalted)
11408 {
11409 memset (hash_buf.salt, 0, sizeof (salt_t));
11410 }
11411
11412 hash_t *found = NULL;
11413
11414 if (hash_mode == 6800)
11415 {
11416 if (i < 48) // 48 = 12 * uint in salt_buf[]
11417 {
11418 // manipulate salt_buf
11419 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11420
11421 hash_buf.salt->salt_len = i;
11422
11423 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11424 }
11425 }
11426 else if (hash_mode == 2500)
11427 {
11428 if (i < 48) // 48 = 12 * uint in salt_buf[]
11429 {
11430 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11431 // manipulate salt_buf
11432
11433 // to be safe work with a copy (because of line_len loop, i etc)
11434
11435 char line_buf_cpy[BUFSIZ];
11436 memset (line_buf_cpy, 0, BUFSIZ);
11437
11438 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
11439
11440 memcpy (line_buf_cpy, line_buf, i);
11441
11442 char *mac2_pos = strrchr (line_buf_cpy, ':');
11443
11444 if (mac2_pos == NULL) continue;
11445
11446 mac2_pos[0] = 0;
11447 mac2_pos++;
11448
11449 if (strlen (mac2_pos) != 12) continue;
11450
11451 char *mac1_pos = strrchr (line_buf_cpy, ':');
11452
11453 if (mac1_pos == NULL) continue;
11454
11455 mac1_pos[0] = 0;
11456 mac1_pos++;
11457
11458 if (strlen (mac1_pos) != 12) continue;
11459
11460 uint essid_length = mac1_pos - line_buf_cpy - 1;
11461
11462 // here we need the ESSID
11463 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11464
11465 hash_buf.salt->salt_len = essid_length;
11466
11467 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11468
11469 if (found)
11470 {
11471 wpa_t *wpa = (wpa_t *) found->esalt;
11472
11473 uint pke[25];
11474
11475 char *pke_ptr = (char *) pke;
11476
11477 for (uint i = 0; i < 25; i++)
11478 {
11479 pke[i] = byte_swap_32 (wpa->pke[i]);
11480 }
11481
11482 unsigned char mac1[6];
11483 unsigned char mac2[6];
11484
11485 memcpy (mac1, pke_ptr + 23, 6);
11486 memcpy (mac2, pke_ptr + 29, 6);
11487
11488 // compare hex string(s) vs binary MAC address(es)
11489
11490 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11491 {
11492 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
11493 {
11494 found = NULL;
11495 break;
11496 }
11497 }
11498
11499 // early skip ;)
11500 if (!found) continue;
11501
11502 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11503 {
11504 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
11505 {
11506 found = NULL;
11507 break;
11508 }
11509 }
11510 }
11511 }
11512 }
11513 else
11514 {
11515 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11516
11517 if (parser_status == PARSER_OK)
11518 {
11519 if (isSalted)
11520 {
11521 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11522 }
11523 else
11524 {
11525 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11526 }
11527 }
11528 }
11529
11530 if (found == NULL) continue;
11531
11532 if (!found->cracked) potfile_remove_cracks++;
11533
11534 found->cracked = 1;
11535
11536 if (found) break;
11537
11538 iter--;
11539 }
11540 }
11541
11542 fclose (fp);
11543 }
11544 }
11545
11546 if (esalt_size)
11547 {
11548 local_free (hash_buf.esalt);
11549 }
11550
11551 if (isSalted)
11552 {
11553 local_free (hash_buf.salt);
11554 }
11555
11556 local_free (hash_buf.digest);
11557 }
11558
11559 /**
11560 * Now generate all the buffers required for later
11561 */
11562
11563 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11564
11565 salt_t *salts_buf_new = NULL;
11566 void *esalts_buf_new = NULL;
11567
11568 if (isSalted)
11569 {
11570 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11571
11572 if (esalt_size)
11573 {
11574 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11575 }
11576 }
11577 else
11578 {
11579 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11580 }
11581
11582 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11583
11584 uint digests_cnt = hashes_cnt;
11585 uint digests_done = 0;
11586
11587 uint size_digests = digests_cnt * dgst_size;
11588 uint size_shown = digests_cnt * sizeof (uint);
11589
11590 uint *digests_shown = (uint *) mymalloc (size_shown);
11591 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11592
11593 uint salts_cnt = 0;
11594 uint salts_done = 0;
11595
11596 hashinfo_t **hash_info = NULL;
11597
11598 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11599 {
11600 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11601
11602 if (username && (remove || show))
11603 {
11604 uint user_pos;
11605
11606 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11607 {
11608 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11609
11610 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11611 }
11612 }
11613 }
11614
11615 uint *salts_shown = (uint *) mymalloc (size_shown);
11616
11617 salt_t *salt_buf;
11618
11619 {
11620 // copied from inner loop
11621
11622 salt_buf = &salts_buf_new[salts_cnt];
11623
11624 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11625
11626 if (esalt_size)
11627 {
11628 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11629 }
11630
11631 salt_buf->digests_cnt = 0;
11632 salt_buf->digests_done = 0;
11633 salt_buf->digests_offset = 0;
11634
11635 salts_cnt++;
11636 }
11637
11638 if (hashes_buf[0].cracked == 1)
11639 {
11640 digests_shown[0] = 1;
11641
11642 digests_done++;
11643
11644 salt_buf->digests_done++;
11645 }
11646
11647 salt_buf->digests_cnt++;
11648
11649 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11650
11651 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11652 {
11653 hash_info[0] = hashes_buf[0].hash_info;
11654 }
11655
11656 // copy from inner loop
11657
11658 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11659 {
11660 if (isSalted)
11661 {
11662 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11663 {
11664 salt_buf = &salts_buf_new[salts_cnt];
11665
11666 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11667
11668 if (esalt_size)
11669 {
11670 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11671 }
11672
11673 salt_buf->digests_cnt = 0;
11674 salt_buf->digests_done = 0;
11675 salt_buf->digests_offset = hashes_pos;
11676
11677 salts_cnt++;
11678 }
11679 }
11680
11681 if (hashes_buf[hashes_pos].cracked == 1)
11682 {
11683 digests_shown[hashes_pos] = 1;
11684
11685 digests_done++;
11686
11687 salt_buf->digests_done++;
11688 }
11689
11690 salt_buf->digests_cnt++;
11691
11692 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11693
11694 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11695 {
11696 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11697 }
11698 }
11699
11700 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11701 {
11702 salt_t *salt_buf = &salts_buf_new[salt_pos];
11703
11704 if (salt_buf->digests_done == salt_buf->digests_cnt)
11705 {
11706 salts_shown[salt_pos] = 1;
11707
11708 salts_done++;
11709 }
11710
11711 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11712 }
11713
11714 local_free (digests_buf);
11715 local_free (salts_buf);
11716 local_free (esalts_buf);
11717
11718 digests_buf = digests_buf_new;
11719 salts_buf = salts_buf_new;
11720 esalts_buf = esalts_buf_new;
11721
11722 local_free (hashes_buf);
11723
11724 /**
11725 * special modification not set from parser
11726 */
11727
11728 switch (hash_mode)
11729 {
11730 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
11731 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
11732 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
11733 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
11734 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
11735 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
11736 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
11737 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
11738 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
11739 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
11740 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
11741 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
11742 }
11743
11744 if (truecrypt_keyfiles)
11745 {
11746 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
11747
11748 char *keyfiles = strdup (truecrypt_keyfiles);
11749
11750 char *keyfile = strtok (keyfiles, ",");
11751
11752 do
11753 {
11754 truecrypt_crc32 (keyfile, (unsigned char *) keyfile_buf);
11755
11756 } while ((keyfile = strtok (NULL, ",")) != NULL);
11757
11758 free (keyfiles);
11759 }
11760
11761 data.digests_cnt = digests_cnt;
11762 data.digests_done = digests_done;
11763 data.digests_buf = digests_buf;
11764 data.digests_shown = digests_shown;
11765 data.digests_shown_tmp = digests_shown_tmp;
11766
11767 data.salts_cnt = salts_cnt;
11768 data.salts_done = salts_done;
11769 data.salts_buf = salts_buf;
11770 data.salts_shown = salts_shown;
11771
11772 data.esalts_buf = esalts_buf;
11773 data.hash_info = hash_info;
11774
11775 /**
11776 * Automatic Optimizers
11777 */
11778
11779 if (salts_cnt == 1)
11780 opti_type |= OPTI_TYPE_SINGLE_SALT;
11781
11782 if (digests_cnt == 1)
11783 opti_type |= OPTI_TYPE_SINGLE_HASH;
11784
11785 if (attack_exec == ATTACK_EXEC_ON_GPU)
11786 opti_type |= OPTI_TYPE_NOT_ITERATED;
11787
11788 if (attack_mode == ATTACK_MODE_BF)
11789 opti_type |= OPTI_TYPE_BRUTE_FORCE;
11790
11791 data.opti_type = opti_type;
11792
11793 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
11794 {
11795 if (opti_type & OPTI_TYPE_SINGLE_HASH)
11796 {
11797 if (opti_type & OPTI_TYPE_APPENDED_SALT)
11798 {
11799 if (opts_type & OPTS_TYPE_ST_ADD80)
11800 {
11801 opts_type &= ~OPTS_TYPE_ST_ADD80;
11802 opts_type |= OPTS_TYPE_PT_ADD80;
11803 }
11804
11805 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
11806 {
11807 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
11808 opts_type |= OPTS_TYPE_PT_ADDBITS14;
11809 }
11810
11811 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
11812 {
11813 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
11814 opts_type |= OPTS_TYPE_PT_ADDBITS15;
11815 }
11816 }
11817 }
11818 }
11819
11820 /**
11821 * Some algorithm, like descrypt, can benefit from JIT compilation
11822 */
11823
11824 uint force_jit_compilation = 0;
11825
11826 if (hash_mode == 8900)
11827 {
11828 force_jit_compilation = 8900;
11829 }
11830 else if (hash_mode == 9300)
11831 {
11832 force_jit_compilation = 8900;
11833 }
11834 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
11835 {
11836 force_jit_compilation = 1500;
11837 }
11838
11839 /**
11840 * generate bitmap tables
11841 */
11842
11843 const uint bitmap_shift1 = 5;
11844 const uint bitmap_shift2 = 13;
11845
11846 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
11847
11848 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11849 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11850 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11851 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11852 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11853 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11854 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11855 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
11856
11857 uint bitmap_bits;
11858 uint bitmap_nums;
11859 uint bitmap_mask;
11860 uint bitmap_size;
11861
11862 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
11863 {
11864 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
11865
11866 bitmap_nums = 1 << bitmap_bits;
11867
11868 bitmap_mask = bitmap_nums - 1;
11869
11870 bitmap_size = bitmap_nums * sizeof (uint);
11871
11872 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
11873
11874 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;
11875 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;
11876
11877 break;
11878 }
11879
11880 bitmap_nums = 1 << bitmap_bits;
11881
11882 bitmap_mask = bitmap_nums - 1;
11883
11884 bitmap_size = bitmap_nums * sizeof (uint);
11885
11886 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);
11887 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);
11888
11889 /**
11890 * prepare quick rule
11891 */
11892
11893 data.rule_buf_l = rule_buf_l;
11894 data.rule_buf_r = rule_buf_r;
11895
11896 int rule_len_l = (int) strlen (rule_buf_l);
11897 int rule_len_r = (int) strlen (rule_buf_r);
11898
11899 data.rule_len_l = rule_len_l;
11900 data.rule_len_r = rule_len_r;
11901
11902 /**
11903 * load rules
11904 */
11905
11906 uint *all_gpu_rules_cnt = NULL;
11907
11908 gpu_rule_t **all_gpu_rules_buf = NULL;
11909
11910 if (rp_files_cnt)
11911 {
11912 all_gpu_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
11913
11914 all_gpu_rules_buf = (gpu_rule_t **) mycalloc (rp_files_cnt, sizeof (gpu_rule_t *));
11915 }
11916
11917 char rule_buf[BUFSIZ];
11918
11919 int rule_len = 0;
11920
11921 for (uint i = 0; i < rp_files_cnt; i++)
11922 {
11923 uint gpu_rules_avail = 0;
11924
11925 uint gpu_rules_cnt = 0;
11926
11927 gpu_rule_t *gpu_rules_buf = NULL;
11928
11929 char *rp_file = rp_files[i];
11930
11931 char in[BLOCK_SIZE];
11932 char out[BLOCK_SIZE];
11933
11934 FILE *fp = NULL;
11935
11936 uint rule_line = 0;
11937
11938 if ((fp = fopen (rp_file, "rb")) == NULL)
11939 {
11940 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
11941
11942 return (-1);
11943 }
11944
11945 while (!feof (fp))
11946 {
11947 memset (rule_buf, 0, BUFSIZ);
11948
11949 rule_len = fgetl (fp, rule_buf);
11950
11951 rule_line++;
11952
11953 if (rule_len == 0) continue;
11954
11955 if (rule_buf[0] == '#') continue;
11956
11957 if (gpu_rules_avail == gpu_rules_cnt)
11958 {
11959 gpu_rules_buf = (gpu_rule_t *) myrealloc (gpu_rules_buf, gpu_rules_avail * sizeof (gpu_rule_t), INCR_RULES * sizeof (gpu_rule_t));
11960
11961 gpu_rules_avail += INCR_RULES;
11962 }
11963
11964 memset (in, 0, BLOCK_SIZE);
11965 memset (out, 0, BLOCK_SIZE);
11966
11967 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
11968
11969 if (result == -1)
11970 {
11971 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
11972
11973 continue;
11974 }
11975
11976 if (cpu_rule_to_gpu_rule (rule_buf, rule_len, &gpu_rules_buf[gpu_rules_cnt]) == -1)
11977 {
11978 log_info ("WARNING: Cannot convert rule for use on GPU in file %s in line %u: %s", rp_file, rule_line, rule_buf);
11979
11980 memset (&gpu_rules_buf[gpu_rules_cnt], 0, sizeof (gpu_rule_t)); // needs to be cleared otherwise we could have some remaining data
11981
11982 continue;
11983 }
11984
11985 /* its so slow
11986 if (rulefind (&gpu_rules_buf[gpu_rules_cnt], gpu_rules_buf, gpu_rules_cnt, sizeof (gpu_rule_t), sort_by_gpu_rule))
11987 {
11988 log_info ("Duplicate rule for use on GPU in file %s in line %u: %s", rp_file, rule_line, rule_buf);
11989
11990 continue;
11991 }
11992 */
11993
11994 gpu_rules_cnt++;
11995 }
11996
11997 fclose (fp);
11998
11999 all_gpu_rules_cnt[i] = gpu_rules_cnt;
12000
12001 all_gpu_rules_buf[i] = gpu_rules_buf;
12002 }
12003
12004 /**
12005 * merge rules or automatic rule generator
12006 */
12007
12008 uint gpu_rules_cnt = 0;
12009
12010 gpu_rule_t *gpu_rules_buf = NULL;
12011
12012 if (attack_mode == ATTACK_MODE_STRAIGHT)
12013 {
12014 if (rp_files_cnt)
12015 {
12016 gpu_rules_cnt = 1;
12017
12018 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12019
12020 repeats[0] = gpu_rules_cnt;
12021
12022 for (uint i = 0; i < rp_files_cnt; i++)
12023 {
12024 gpu_rules_cnt *= all_gpu_rules_cnt[i];
12025
12026 repeats[i + 1] = gpu_rules_cnt;
12027 }
12028
12029 gpu_rules_buf = (gpu_rule_t *) mycalloc (gpu_rules_cnt, sizeof (gpu_rule_t));
12030
12031 memset (gpu_rules_buf, 0, gpu_rules_cnt * sizeof (gpu_rule_t));
12032
12033 for (uint i = 0; i < gpu_rules_cnt; i++)
12034 {
12035 uint out_pos = 0;
12036
12037 gpu_rule_t *out = &gpu_rules_buf[i];
12038
12039 for (uint j = 0; j < rp_files_cnt; j++)
12040 {
12041 uint in_off = (i / repeats[j]) % all_gpu_rules_cnt[j];
12042 uint in_pos;
12043
12044 gpu_rule_t *in = &all_gpu_rules_buf[j][in_off];
12045
12046 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12047 {
12048 if (out_pos == RULES_MAX - 1)
12049 {
12050 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12051
12052 break;
12053 }
12054
12055 out->cmds[out_pos] = in->cmds[in_pos];
12056 }
12057 }
12058 }
12059
12060 local_free (repeats);
12061 }
12062 else if (rp_gen)
12063 {
12064 uint gpu_rules_avail = 0;
12065
12066 while (gpu_rules_cnt < rp_gen)
12067 {
12068 if (gpu_rules_avail == gpu_rules_cnt)
12069 {
12070 gpu_rules_buf = (gpu_rule_t *) myrealloc (gpu_rules_buf, gpu_rules_avail * sizeof (gpu_rule_t), INCR_RULES * sizeof (gpu_rule_t));
12071
12072 gpu_rules_avail += INCR_RULES;
12073 }
12074
12075 memset (rule_buf, 0, BLOCK_SIZE);
12076
12077 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12078
12079 if (cpu_rule_to_gpu_rule (rule_buf, rule_len, &gpu_rules_buf[gpu_rules_cnt]) == -1) continue;
12080
12081 gpu_rules_cnt++;
12082 }
12083 }
12084 }
12085
12086 /**
12087 * generate NOP rules
12088 */
12089
12090 if (gpu_rules_cnt == 0)
12091 {
12092 gpu_rules_buf = (gpu_rule_t *) mymalloc (sizeof (gpu_rule_t));
12093
12094 gpu_rules_buf[gpu_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12095
12096 gpu_rules_cnt++;
12097 }
12098
12099 data.gpu_rules_cnt = gpu_rules_cnt;
12100 data.gpu_rules_buf = gpu_rules_buf;
12101
12102 /**
12103 * platform
12104 */
12105
12106 cl_platform_id CL_platforms[CL_PLATFORMS_MAX];
12107
12108 uint CL_platforms_cnt = 0;
12109
12110 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, CL_platforms, &CL_platforms_cnt);
12111
12112 if (CL_platforms_cnt == 0)
12113 {
12114 log_error ("ERROR: No OpenCL compatible platform found");
12115
12116 return (-1);
12117 }
12118
12119 if (CL_platforms_cnt > 1)
12120 {
12121 log_error ("ERROR: Too many OpenCL compatible platforms found");
12122
12123 return (-1);
12124 }
12125
12126 cl_platform_id CL_platform = CL_platforms[0];
12127
12128 char CL_platform_vendor[INFOSZ];
12129
12130 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12131
12132 hc_clGetPlatformInfo (CL_platform, CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12133
12134 uint vendor_id;
12135
12136 if (strcmp (CL_platform_vendor, CL_VENDOR_AMD) == 0)
12137 {
12138 vendor_id = VENDOR_ID_AMD;
12139 }
12140 else if (strcmp (CL_platform_vendor, CL_VENDOR_NV) == 0)
12141 {
12142 vendor_id = VENDOR_ID_NV;
12143
12144 // make sure that we do not directly control the fan for NVidia
12145
12146 gpu_temp_retain = 0;
12147 data.gpu_temp_retain = gpu_temp_retain;
12148 }
12149 else
12150 {
12151 vendor_id = VENDOR_ID_UNKNOWN;
12152 }
12153
12154 if (vendor_id == VENDOR_ID_UNKNOWN)
12155 {
12156 log_error ("Warning: unknown OpenCL vendor '%s' detected", CL_platform_vendor);
12157
12158 gpu_temp_disable = 1;
12159 }
12160
12161 data.vendor_id = vendor_id;
12162
12163 /**
12164 * devices
12165 */
12166
12167 cl_device_id devices_all[DEVICES_MAX];
12168 cl_device_id devices[DEVICES_MAX];
12169
12170 uint devices_all_cnt = 0;
12171
12172 hc_clGetDeviceIDs (CL_platform, CL_DEVICE_TYPE_GPU, DEVICES_MAX, devices_all, (uint *) &devices_all_cnt);
12173
12174 int hm_adapters_all = devices_all_cnt;
12175
12176 hm_attrs_t hm_adapter_all[DEVICES_MAX];
12177
12178 memset (hm_adapter_all, 0, sizeof (hm_adapter_all));
12179
12180 if (gpu_temp_disable == 0)
12181 {
12182 if (vendor_id == VENDOR_ID_NV)
12183 {
12184 #ifdef LINUX
12185 HM_LIB hm_dll = hm_init ();
12186
12187 data.hm_dll = hm_dll;
12188
12189 if (hc_NVML_nvmlInit (hm_dll) == NVML_SUCCESS)
12190 {
12191 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12192
12193 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12194
12195 int tmp_out = 0;
12196
12197 for (int i = 0; i < tmp_in; i++)
12198 {
12199 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12200 }
12201
12202 hm_adapters_all = tmp_out;
12203
12204 for (int i = 0; i < tmp_out; i++)
12205 {
12206 unsigned int speed;
12207
12208 if (hc_NVML_nvmlDeviceGetFanSpeed (hm_dll, 1, hm_adapter_all[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapter_all[i].fan_supported = 1;
12209 }
12210 }
12211 #endif
12212
12213 #ifdef WIN
12214 if (NvAPI_Initialize () == NVAPI_OK)
12215 {
12216 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12217
12218 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12219
12220 int tmp_out = 0;
12221
12222 for (int i = 0; i < tmp_in; i++)
12223 {
12224 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12225 }
12226
12227 hm_adapters_all = tmp_out;
12228
12229 for (int i = 0; i < tmp_out; i++)
12230 {
12231 NvU32 speed;
12232
12233 if (NvAPI_GPU_GetTachReading (hm_adapter_all[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapter_all[i].fan_supported = 1;
12234 }
12235 }
12236 #endif
12237 }
12238
12239 if (vendor_id == VENDOR_ID_AMD)
12240 {
12241 HM_LIB hm_dll = hm_init ();
12242
12243 data.hm_dll = hm_dll;
12244
12245 if (hc_ADL_Main_Control_Create (hm_dll, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12246 {
12247 // total number of adapters
12248
12249 int hm_adapters_num;
12250
12251 if (get_adapters_num_amd (hm_dll, &hm_adapters_num) != 0) return (-1);
12252
12253 // adapter info
12254
12255 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll, hm_adapters_num);
12256
12257 if (lpAdapterInfo == NULL) return (-1);
12258
12259 // get a list (of ids of) valid/usable adapters
12260
12261 int num_adl_adapters = 0;
12262
12263 uint32_t *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12264
12265 if (num_adl_adapters > 0)
12266 {
12267 hc_thread_mutex_lock (mux_adl);
12268
12269 // hm_get_opencl_busid_devid (hm_adapter_all, devices_all_cnt, devices_all);
12270
12271 hm_get_adapter_index_amd (hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12272
12273 hm_get_overdrive_version (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12274 hm_check_fanspeed_control (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12275
12276 hc_thread_mutex_unlock (mux_adl);
12277 }
12278
12279 hm_adapters_all = num_adl_adapters;
12280
12281 myfree (valid_adl_device_list);
12282 myfree (lpAdapterInfo);
12283 }
12284 }
12285 }
12286
12287 if (hm_adapters_all == 0)
12288 {
12289 gpu_temp_disable = 1;
12290 }
12291
12292 if (gpu_temp_disable == 1)
12293 {
12294 gpu_temp_abort = 0;
12295 gpu_temp_retain = 0;
12296 }
12297
12298 /**
12299 * enable custom signal handler(s)
12300 */
12301
12302 if (benchmark == 0)
12303 {
12304 hc_signal (sigHandler_default);
12305 }
12306 else
12307 {
12308 hc_signal (sigHandler_benchmark);
12309 }
12310
12311 /**
12312 * devices mask and properties
12313 */
12314
12315 uint devices_cnt = 0;
12316
12317 for (uint device_all_id = 0; device_all_id < devices_all_cnt; device_all_id++)
12318 {
12319 if (gpu_devicemask)
12320 {
12321 uint device_all_id_mask = 1 << device_all_id;
12322
12323 if ((device_all_id_mask & gpu_devicemask) != device_all_id_mask)
12324 {
12325 if (quiet == 0 && algorithm_pos == 0) log_info ("Device #%d: skipped by user", device_all_id_mask + 1);
12326
12327 continue;
12328 }
12329 }
12330
12331 const uint device_id = devices_cnt;
12332
12333 devices[device_id] = devices_all[device_all_id];
12334
12335 memcpy (&data.hm_device[device_id], &hm_adapter_all[device_all_id], sizeof (hm_attrs_t));
12336
12337 char device_name[INFOSZ];
12338
12339 memset (device_name, 0, sizeof (device_name));
12340
12341 cl_ulong global_mem_size;
12342 cl_uint max_clock_frequency;
12343 cl_uint max_compute_units;
12344
12345 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_NAME, sizeof (device_name), &device_name, NULL);
12346 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (global_mem_size), &global_mem_size, NULL);
12347 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (max_clock_frequency), &max_clock_frequency, NULL);
12348 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12349
12350 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12351 {
12352 log_info ("Device #%u: %s, %luMB, %dMhz, %uMCU",
12353 device_all_id + 1,
12354 device_name,
12355 (unsigned int) (global_mem_size / 1024 / 1024),
12356 (unsigned int) (max_clock_frequency),
12357 (unsigned int) max_compute_units);
12358 }
12359
12360 devices_cnt++;
12361 }
12362
12363 if (devices_cnt == 0)
12364 {
12365 log_error ("ERROR: No devices left that matches your specification.");
12366
12367 return (-1);
12368 }
12369
12370 data.devices_cnt = devices_cnt;
12371
12372 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12373 {
12374 log_info ("");
12375 }
12376
12377 /**
12378 * inform the user
12379 */
12380
12381 // gpu temp sanity check
12382
12383 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12384 {
12385 if (gpu_temp_abort < gpu_temp_retain)
12386 {
12387 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12388
12389 return (-1);
12390 }
12391 }
12392
12393 data.gpu_temp_disable = gpu_temp_disable;
12394 data.gpu_temp_abort = gpu_temp_abort;
12395 data.gpu_temp_retain = gpu_temp_retain;
12396
12397 if (data.quiet == 0)
12398 {
12399 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12400
12401 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);
12402
12403 if (attack_mode == ATTACK_MODE_STRAIGHT)
12404 {
12405 log_info ("Rules: %u", gpu_rules_cnt);
12406 }
12407
12408 if (opti_type)
12409 {
12410 log_info ("Applicable Optimizers:");
12411
12412 for (uint i = 0; i < 32; i++)
12413 {
12414 const uint opti_bit = 1 << i;
12415
12416 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12417 }
12418 }
12419
12420 /**
12421 * Watchdog and Temperature balance
12422 */
12423
12424 if (gpu_temp_abort == 0)
12425 {
12426 log_info ("Watchdog: Temperature abort trigger disabled");
12427 }
12428 else
12429 {
12430 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12431 }
12432
12433 if (gpu_temp_retain == 0)
12434 {
12435 log_info ("Watchdog: Temperature retain trigger disabled");
12436 }
12437 else
12438 {
12439 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12440 }
12441 }
12442
12443 /**
12444 * devices init
12445 */
12446
12447 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12448
12449 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12450
12451 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12452
12453 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (devices_cnt, sizeof (hc_device_param_t));
12454
12455 data.devices_param = devices_param;
12456
12457 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12458 {
12459 hc_device_param_t *device_param = &data.devices_param[device_id];
12460
12461 cl_device_id device = devices[device_id];
12462
12463 device_param->device = device;
12464
12465 cl_uint max_compute_units = 0;
12466
12467 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12468
12469 device_param->gpu_processors = max_compute_units;
12470
12471 cl_ulong max_mem_alloc_size = 0;
12472
12473 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12474
12475 device_param->gpu_maxmem_alloc = max_mem_alloc_size;
12476
12477 char tmp[INFOSZ], t1[64];
12478
12479 memset (tmp, 0, sizeof (tmp));
12480
12481 hc_clGetDeviceInfo (device, CL_DEVICE_NAME, sizeof (tmp), &tmp, NULL);
12482
12483 device_param->device_name = mystrdup (tmp);
12484
12485 memset (tmp, 0, sizeof (tmp));
12486
12487 hc_clGetDeviceInfo (device, CL_DEVICE_VERSION, sizeof (tmp), &tmp, NULL);
12488
12489 memset (t1, 0, sizeof (t1));
12490
12491 sscanf (tmp, "%*16s %*16s %*16s (%[^)]16s)", t1);
12492
12493 device_param->device_version = mystrdup (t1);
12494
12495 memset (tmp, 0, sizeof (tmp));
12496
12497 hc_clGetDeviceInfo (device, CL_DRIVER_VERSION, sizeof (tmp), &tmp, NULL);
12498
12499 device_param->driver_version = mystrdup (tmp);
12500
12501 if (vendor_id == VENDOR_ID_NV)
12502 {
12503 cl_uint sm_minor = 0;
12504 cl_uint sm_major = 0;
12505
12506 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12507 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12508
12509 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12510 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12511
12512 device_param->sm_minor = sm_minor;
12513 device_param->sm_major = sm_major;
12514 }
12515
12516 /**
12517 * catalyst driver check
12518 */
12519
12520 if (vendor_id == VENDOR_ID_AMD)
12521 {
12522 int catalyst_check = (force == 1) ? 0 : 1;
12523
12524 int catalyst_warn = 0;
12525
12526 int catalyst_broken = 0;
12527
12528 if (catalyst_check == 1)
12529 {
12530 catalyst_warn = 1;
12531
12532 // v14.9 and higher
12533 if ((atoi (device_param->device_version) >= 1573)
12534 && (atoi (device_param->driver_version) >= 1573))
12535 {
12536 catalyst_warn = 0;
12537 }
12538
12539 /*
12540 // v14.9
12541 if ((strstr (device_param->device_version, "1573.") != NULL)
12542 && (strstr (device_param->driver_version, "1573.") != NULL))
12543 {
12544 catalyst_warn = 0;
12545 }
12546
12547 // v14.12 -- version overlaps with v15.4 beta
12548 if ((strstr (device_param->device_version, "1642.") != NULL)
12549 && (strstr (device_param->driver_version, "1642.") != NULL))
12550 {
12551 catalyst_broken = 1;
12552 }
12553
12554 // v15.4 (Beta, Windows only release)
12555 if ((strstr (device_param->device_version, "1642.") != NULL)
12556 && (strstr (device_param->driver_version, "1642.") != NULL))
12557 {
12558 catalyst_warn = 0;
12559 }
12560
12561 // v15.5 (Release, Linux)
12562 if ((strstr (device_param->device_version, "1702.") != NULL)
12563 && (strstr (device_param->driver_version, "1702.") != NULL))
12564 {
12565 catalyst_warn = 0;
12566 }
12567
12568 // v15.3 (Beta, Ubuntu repository release)
12569 if ((strstr (device_param->device_version, "1729.") != NULL)
12570 && (strstr (device_param->driver_version, "1729.") != NULL))
12571 {
12572 catalyst_warn = 0;
12573 }
12574 */
12575
12576 catalyst_check = 0;
12577 }
12578
12579 if (catalyst_broken == 1)
12580 {
12581 log_error ("");
12582 log_error ("ATTENTION! The installed GPU driver in your system is known to be broken!");
12583 log_error ("It will pass over cracked hashes and does not report them as cracked");
12584 log_error ("You are STRONGLY encouraged not to use it");
12585 log_error ("You can use --force to override this but do not post error reports if you do so");
12586
12587 return (-1);
12588 }
12589
12590 if (catalyst_warn == 1)
12591 {
12592 log_error ("");
12593 log_error ("ATTENTION! Unsupported or incorrect installed GPU driver detected!");
12594 log_error ("You are STRONGLY encouraged to use the official supported GPU driver for good reasons");
12595 log_error ("See oclHashcat's homepage for official supported GPU drivers");
12596 #ifdef _WIN
12597 log_error ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12598 #endif
12599 log_error ("You can use --force to override this but do not post error reports if you do so");
12600
12601 return (-1);
12602 }
12603 }
12604 }
12605
12606 /*
12607 * Temporary fix:
12608 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
12609 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
12610 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
12611 * Driver / ADL bug?
12612 */
12613
12614 if (vendor_id == VENDOR_ID_AMD)
12615 {
12616 if (powertune_enable == 1)
12617 {
12618 hc_thread_mutex_lock (mux_adl);
12619
12620 for (uint i = 0; i < devices_cnt; i++)
12621 {
12622 if (data.hm_device[i].od_version == 6)
12623 {
12624 // set powertune value only
12625
12626 int powertune_supported = 0;
12627
12628 int ADL_rc = 0;
12629
12630 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
12631 {
12632 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
12633
12634 return (-1);
12635 }
12636
12637 if (powertune_supported != 0)
12638 {
12639 // powertune set
12640 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
12641
12642 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune)) != ADL_OK)
12643 {
12644 log_error ("ERROR: Failed to get current ADL PowerControl settings");
12645
12646 return (-1);
12647 }
12648
12649 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
12650 {
12651 log_error ("ERROR: Failed to set new ADL PowerControl values");
12652
12653 return (-1);
12654 }
12655 }
12656 }
12657 }
12658
12659 hc_thread_mutex_unlock (mux_adl);
12660 }
12661 }
12662
12663 uint gpu_blocks_all = 0;
12664
12665 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12666 {
12667 /**
12668 * host buffer
12669 */
12670
12671 hc_device_param_t *device_param = &data.devices_param[device_id];
12672
12673 /**
12674 * device properties
12675 */
12676
12677 char *device_name = device_param->device_name;
12678 char *device_version = device_param->device_version;
12679 char *driver_version = device_param->driver_version;
12680
12681 uint gpu_processors = device_param->gpu_processors;
12682
12683 /**
12684 * create context for each device
12685 */
12686
12687 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
12688
12689 /**
12690 * create command-queue
12691 */
12692
12693 // not support with NV
12694 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
12695
12696 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
12697
12698 /**
12699 * create input buffers on device
12700 */
12701
12702 uint gpu_threads = GPU_THREADS;
12703
12704 if (hash_mode == 3200) gpu_threads = 8;
12705 if (hash_mode == 9000) gpu_threads = 8;
12706
12707 uint gpu_power = gpu_processors * gpu_threads * gpu_accel;
12708 uint gpu_blocks = gpu_power;
12709
12710 device_param->gpu_threads = gpu_threads;
12711 device_param->gpu_power_user = gpu_power;
12712 device_param->gpu_blocks_user = gpu_blocks;
12713
12714 gpu_blocks_all += gpu_blocks;
12715
12716 uint size_pws = gpu_power * sizeof (pw_t);
12717
12718 uint size_tmps = 4;
12719
12720 switch (hash_mode)
12721 {
12722 case 400: size_tmps = gpu_blocks * sizeof (phpass_tmp_t); break;
12723 case 500: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
12724 case 501: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
12725 case 1600: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
12726 case 1800: size_tmps = gpu_blocks * sizeof (sha512crypt_tmp_t); break;
12727 case 2100: size_tmps = gpu_blocks * sizeof (dcc2_tmp_t); break;
12728 case 2500: size_tmps = gpu_blocks * sizeof (wpa_tmp_t); break;
12729 case 3200: size_tmps = gpu_blocks * sizeof (bcrypt_tmp_t); break;
12730 case 5200: size_tmps = gpu_blocks * sizeof (pwsafe3_tmp_t); break;
12731 case 5800: size_tmps = gpu_blocks * sizeof (androidpin_tmp_t); break;
12732 case 6211:
12733 case 6212:
12734 case 6213: size_tmps = gpu_blocks * sizeof (tc_tmp_t); break;
12735 case 6221:
12736 case 6222:
12737 case 6223: size_tmps = gpu_blocks * sizeof (tc64_tmp_t); break;
12738 case 6231:
12739 case 6232:
12740 case 6233: size_tmps = gpu_blocks * sizeof (tc_tmp_t); break;
12741 case 6241:
12742 case 6242:
12743 case 6243: size_tmps = gpu_blocks * sizeof (tc_tmp_t); break;
12744 case 6300: size_tmps = gpu_blocks * sizeof (md5crypt_tmp_t); break;
12745 case 6400: size_tmps = gpu_blocks * sizeof (sha256aix_tmp_t); break;
12746 case 6500: size_tmps = gpu_blocks * sizeof (sha512aix_tmp_t); break;
12747 case 6600: size_tmps = gpu_blocks * sizeof (agilekey_tmp_t); break;
12748 case 6700: size_tmps = gpu_blocks * sizeof (sha1aix_tmp_t); break;
12749 case 6800: size_tmps = gpu_blocks * sizeof (lastpass_tmp_t); break;
12750 case 7100: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
12751 case 7200: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
12752 case 7400: size_tmps = gpu_blocks * sizeof (sha256crypt_tmp_t); break;
12753 case 7900: size_tmps = gpu_blocks * sizeof (drupal7_tmp_t); break;
12754 case 8200: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
12755 case 8800: size_tmps = gpu_blocks * sizeof (androidfde_tmp_t); break;
12756 case 8900: size_tmps = gpu_blocks * sizeof (scrypt_tmp_t); break;
12757 case 9000: size_tmps = gpu_blocks * sizeof (pwsafe2_tmp_t); break;
12758 case 9100: size_tmps = gpu_blocks * sizeof (lotus8_tmp_t); break;
12759 case 9200: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
12760 case 9300: size_tmps = gpu_blocks * sizeof (scrypt_tmp_t); break;
12761 case 9400: size_tmps = gpu_blocks * sizeof (office2007_tmp_t); break;
12762 case 9500: size_tmps = gpu_blocks * sizeof (office2010_tmp_t); break;
12763 case 9600: size_tmps = gpu_blocks * sizeof (office2013_tmp_t); break;
12764 case 10000: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
12765 case 10200: size_tmps = gpu_blocks * sizeof (cram_md5_t); break;
12766 case 10300: size_tmps = gpu_blocks * sizeof (saph_sha1_tmp_t); break;
12767 case 10500: size_tmps = gpu_blocks * sizeof (pdf14_tmp_t); break;
12768 case 10700: size_tmps = gpu_blocks * sizeof (pdf17l8_tmp_t); break;
12769 case 10900: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
12770 case 11300: size_tmps = gpu_blocks * sizeof (bitcoin_wallet_tmp_t); break;
12771 case 11600: size_tmps = gpu_blocks * sizeof (seven_zip_tmp_t); break;
12772 case 11900: size_tmps = gpu_blocks * sizeof (pbkdf2_md5_tmp_t); break;
12773 case 12000: size_tmps = gpu_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
12774 case 12100: size_tmps = gpu_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
12775 case 12200: size_tmps = gpu_blocks * sizeof (ecryptfs_tmp_t); break;
12776 case 12300: size_tmps = gpu_blocks * sizeof (oraclet_tmp_t); break;
12777 case 12400: size_tmps = gpu_blocks * sizeof (bsdicrypt_tmp_t); break;
12778 case 12500: size_tmps = gpu_blocks * sizeof (rar3_tmp_t); break;
12779 case 12700: size_tmps = gpu_blocks * sizeof (mywallet_tmp_t); break;
12780 case 12800: size_tmps = gpu_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
12781 };
12782
12783 uint size_hooks = 4;
12784
12785 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
12786 {
12787 // insert correct hook size
12788 }
12789
12790 // we can optimize some stuff here...
12791
12792 device_param->size_pws = size_pws;
12793 device_param->size_tmps = size_tmps;
12794 device_param->size_hooks = size_hooks;
12795
12796 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
12797 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
12798
12799 device_param->size_root_css = size_root_css;
12800 device_param->size_markov_css = size_markov_css;
12801
12802 uint size_results = GPU_THREADS * sizeof (uint);
12803
12804 device_param->size_results = size_results;
12805
12806 uint size_rules = gpu_rules_cnt * sizeof (gpu_rule_t);
12807 uint size_rules_c = GPU_RULES * sizeof (gpu_rule_t);
12808 uint size_plains = digests_cnt * sizeof (plain_t);
12809 uint size_salts = salts_cnt * sizeof (salt_t);
12810 uint size_esalts = salts_cnt * esalt_size;
12811
12812 device_param->size_plains = size_plains;
12813 device_param->size_digests = size_digests;
12814 device_param->size_shown = size_shown;
12815 device_param->size_salts = size_salts;
12816
12817 uint size_combs = GPU_COMBS * sizeof (comb_t);
12818 uint size_bfs = GPU_BFS * sizeof (bf_t);
12819 uint size_tm = 32 * sizeof (bs_word_t);
12820
12821 uint64_t size_scryptV = 1;
12822
12823 if ((hash_mode == 8900) || (hash_mode == 9300))
12824 {
12825 #define SHADER_PER_MP 8
12826 #define WAVEFRONTS 64
12827
12828 uint tmto_start = 2;
12829 uint tmto_stop = 1024;
12830
12831 if (scrypt_tmto)
12832 {
12833 tmto_start = 1 << scrypt_tmto;
12834 tmto_stop = tmto_start + 1;
12835 }
12836
12837 for (uint tmto = tmto_start; tmto < tmto_stop; tmto <<= 1)
12838 {
12839 // todo -- make sure all salts get the new tmto value
12840
12841 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
12842
12843 size_scryptV /= tmto;
12844
12845 size_scryptV *= gpu_processors * WAVEFRONTS * SHADER_PER_MP;
12846
12847 if (size_scryptV > (device_param->gpu_maxmem_alloc / 2)) continue;
12848
12849 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
12850 {
12851 data.salts_buf[salts_pos].scrypt_tmto = tmto;
12852 data.salts_buf[salts_pos].scrypt_phy = gpu_processors * WAVEFRONTS * SHADER_PER_MP;
12853 }
12854
12855 break;
12856 }
12857
12858 if (data.salts_buf[0].scrypt_tmto == 0)
12859 {
12860 log_error ("ERROR: can't allocate enough GPU memory");
12861
12862 return -1;
12863 }
12864
12865 if (quiet == 0) log_info ("");
12866 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u\n", data.salts_buf[0].scrypt_tmto);
12867 }
12868
12869 /**
12870 * kernel find
12871 */
12872
12873 char build_opts[1024];
12874
12875 // we don't have sm_* on AMD but it doesn't matter
12876
12877 sprintf (build_opts, "-I. -IOpenCL/ -DVENDOR_ID=%d -DCUDA_ARCH=%d", vendor_id, (device_param->sm_major * 100) + device_param->sm_minor);
12878
12879 struct stat st;
12880
12881 char kernel_file[256];
12882
12883 memset (kernel_file, 0, sizeof (kernel_file));
12884
12885 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
12886
12887 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
12888
12889 #ifdef BINARY_KERNEL
12890 if (force_jit_compilation == 0)
12891 {
12892 if (attack_exec == ATTACK_EXEC_ON_GPU)
12893 {
12894 if (attack_kern == ATTACK_KERN_STRAIGHT)
12895 snprintf (kernel_file, sizeof (kernel_file) - 1, "%s/kernels/4098/m%05d_a0.%s_%s_%s_%d.kernel", install_dir, (int) kern_type, device_name, device_version, driver_version, COMPTIME);
12896 else if (attack_kern == ATTACK_KERN_COMBI)
12897 snprintf (kernel_file, sizeof (kernel_file) - 1, "%s/kernels/4098/m%05d_a1.%s_%s_%s_%d.kernel", install_dir, (int) kern_type, device_name, device_version, driver_version, COMPTIME);
12898 else if (attack_kern == ATTACK_KERN_BF)
12899 snprintf (kernel_file, sizeof (kernel_file) - 1, "%s/kernels/4098/m%05d_a3.%s_%s_%s_%d.kernel", install_dir, (int) kern_type, device_name, device_version, driver_version, COMPTIME);
12900 }
12901 else
12902 {
12903 snprintf (kernel_file, sizeof (kernel_file) - 1, "%s/kernels/4098/m%05d.%s_%s_%s_%d.kernel", install_dir, (int) kern_type, device_name, device_version, driver_version, COMPTIME);
12904
12905 if ((hash_mode == 8900) || (hash_mode == 9300))
12906 {
12907 snprintf (kernel_file, sizeof (kernel_file) - 1, "%s/kernels/4098/m%05d_%d_%d_%d_%d.%s_%s_%s_%d.kernel", install_dir, (int) kern_type, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, data.salts_buf[0].scrypt_tmto, device_name, device_version, driver_version, COMPTIME);
12908 }
12909 }
12910
12911 if (stat (kernel_file, &st) == -1)
12912 {
12913 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, kernel_file);
12914
12915 char module_file[256];
12916
12917 memset (module_file, 0, sizeof (module_file));
12918
12919 if (attack_exec == ATTACK_EXEC_ON_GPU)
12920 {
12921 if (attack_kern == ATTACK_KERN_STRAIGHT)
12922 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4098/m%05d_a0.llvmir", install_dir, (int) kern_type);
12923 else if (attack_kern == ATTACK_KERN_COMBI)
12924 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4098/m%05d_a1.llvmir", install_dir, (int) kern_type);
12925 else if (attack_kern == ATTACK_KERN_BF)
12926 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4098/m%05d_a3.llvmir", install_dir, (int) kern_type);
12927 }
12928 else
12929 {
12930 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4098/m%05d.llvmir", install_dir, (int) kern_type);
12931
12932 if ((hash_mode == 8900) || (hash_mode == 9300))
12933 {
12934 snprintf (module_file, sizeof (module_file) - 1, "%s/kernels/4098/m%05d_%d_%d_%d_%d.llvmir", install_dir, (int) kern_type, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, data.salts_buf[0].scrypt_tmto);
12935 }
12936 }
12937
12938 load_kernel (module_file, 1, kernel_lengths, kernel_sources);
12939
12940 cl_program program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
12941
12942 local_free (kernel_sources[0]);
12943
12944 hc_clBuildProgram (program, 1, &device_param->device, build_opts, NULL, NULL);
12945
12946 size_t binary_size;
12947
12948 clGetProgramInfo (program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
12949
12950 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
12951
12952 clGetProgramInfo (program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
12953
12954 writeProgramBin (kernel_file, binary, binary_size);
12955
12956 local_free (binary);
12957
12958 stat (kernel_file, &st); // to reload filesize
12959 }
12960 }
12961 else
12962 {
12963 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, install_dir, kernel_file);
12964
12965 if (stat (kernel_file, &st) == -1)
12966 {
12967 log_error ("ERROR: %s: %s", kernel_file, strerror (errno));
12968
12969 return -1;
12970 }
12971 }
12972
12973 #else
12974
12975 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, install_dir, kernel_file);
12976
12977 if (stat (kernel_file, &st) == -1)
12978 {
12979 log_error ("ERROR: %s: %s", kernel_file, strerror (errno));
12980
12981 return -1;
12982 }
12983
12984 #endif
12985
12986 load_kernel (kernel_file, 1, kernel_lengths, kernel_sources);
12987
12988 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, kernel_file, st.st_size);
12989
12990 #ifdef BINARY_KERNEL
12991 if (force_jit_compilation == 0)
12992 {
12993 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
12994 }
12995 else
12996 {
12997 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
12998 }
12999 #else
13000 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13001 #endif
13002
13003 local_free (kernel_lengths);
13004
13005 local_free (kernel_sources[0]);
13006
13007 local_free (kernel_sources)
13008
13009 /**
13010 * kernel mp find
13011 */
13012
13013 if (attack_mode != ATTACK_MODE_STRAIGHT)
13014 {
13015 char kernel_mp_file[256];
13016
13017 memset (kernel_mp_file, 0, sizeof (kernel_mp_file));
13018
13019 size_t *kernel_mp_lengths = (size_t *) mymalloc (sizeof (size_t));
13020
13021 const unsigned char **kernel_mp_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13022
13023 #ifdef BINARY_KERNEL
13024 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
13025 {
13026 snprintf (kernel_mp_file, sizeof (kernel_mp_file) - 1, "%s/kernels/4098/markov_be.%s_%s_%s_%d.kernel", install_dir, device_name, device_version, driver_version, COMPTIME);
13027 }
13028 else
13029 {
13030 snprintf (kernel_mp_file, sizeof (kernel_mp_file) - 1, "%s/kernels/4098/markov_le.%s_%s_%s_%d.kernel", install_dir, device_name, device_version, driver_version, COMPTIME);
13031 }
13032
13033 if (stat (kernel_mp_file, &st) == -1)
13034 {
13035 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, kernel_mp_file);
13036
13037 char module_mp_file[256];
13038
13039 memset (module_mp_file, 0, sizeof (module_mp_file));
13040
13041 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
13042 {
13043 snprintf (module_mp_file, sizeof (module_mp_file) - 1, "%s/kernels/4098/markov_be.llvmir", install_dir);
13044 }
13045 else
13046 {
13047 snprintf (module_mp_file, sizeof (module_mp_file) - 1, "%s/kernels/4098/markov_le.llvmir", install_dir);
13048 }
13049
13050 load_kernel (module_mp_file, 1, kernel_mp_lengths, kernel_mp_sources);
13051
13052 cl_program program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_mp_lengths, (const unsigned char **) kernel_mp_sources, NULL);
13053
13054 local_free (kernel_mp_sources[0]);
13055
13056 hc_clBuildProgram (program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13057
13058 size_t binary_mp_size;
13059
13060 clGetProgramInfo (program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_mp_size, NULL);
13061
13062 unsigned char *binary_mp = (unsigned char *) mymalloc (binary_mp_size);
13063
13064 clGetProgramInfo (program_mp, CL_PROGRAM_BINARIES, sizeof (binary_mp), &binary_mp, NULL);
13065
13066 writeProgramBin (kernel_mp_file, binary_mp, binary_mp_size);
13067
13068 local_free (binary_mp);
13069
13070 stat (kernel_mp_file, &st); // to reload filesize
13071 }
13072
13073 #else
13074 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
13075 {
13076 snprintf (kernel_mp_file, sizeof (kernel_mp_file) - 1, "%s/OpenCL/markov_be.cl", install_dir);
13077 }
13078 else
13079 {
13080 snprintf (kernel_mp_file, sizeof (kernel_mp_file) - 1, "%s/OpenCL/markov_le.cl", install_dir);
13081 }
13082
13083 if (stat (kernel_mp_file, &st) == -1)
13084 {
13085 log_error ("ERROR: %s: %s", kernel_mp_file, strerror (errno));
13086
13087 return -1;
13088 }
13089
13090 #endif
13091
13092 load_kernel (kernel_mp_file, 1, kernel_mp_lengths, kernel_mp_sources);
13093
13094 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, kernel_mp_file, st.st_size);
13095
13096 #ifdef BINARY_KERNEL
13097 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_mp_lengths, (const unsigned char **) kernel_mp_sources, NULL);
13098 #else
13099 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_mp_sources, NULL);
13100 #endif
13101
13102 local_free (kernel_mp_lengths);
13103
13104 local_free (kernel_mp_sources[0]);
13105
13106 local_free (kernel_mp_sources);
13107 }
13108
13109 /**
13110 * kernel amp find
13111 */
13112
13113 if (attack_exec == ATTACK_EXEC_ON_GPU)
13114 {
13115 // nothing to do
13116 }
13117 else
13118 {
13119 char kernel_amp_file[256];
13120
13121 memset (kernel_amp_file, 0, sizeof (kernel_amp_file));
13122
13123 size_t *kernel_amp_lengths = (size_t *) mymalloc (sizeof (size_t));
13124
13125 const unsigned char **kernel_amp_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13126
13127 #ifdef BINARY_KERNEL
13128 snprintf (kernel_amp_file, sizeof (kernel_amp_file) - 1, "%s/kernels/4098/amp_a%d.%s_%s_%s_%d.kernel", install_dir, attack_kern, device_name, device_version, driver_version, COMPTIME);
13129
13130 if (stat (kernel_amp_file, &st) == -1)
13131 {
13132 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, kernel_amp_file);
13133
13134 char module_amp_file[256];
13135
13136 memset (module_amp_file, 0, sizeof (module_amp_file));
13137
13138 snprintf (module_amp_file, sizeof (module_amp_file) - 1, "%s/kernels/4098/amp_a%d.llvmir", install_dir, attack_kern);
13139
13140 load_kernel (module_amp_file, 1, kernel_amp_lengths, kernel_amp_sources);
13141
13142 cl_program program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_amp_lengths, (const unsigned char **) kernel_amp_sources, NULL);
13143
13144 local_free (kernel_amp_sources[0]);
13145
13146 hc_clBuildProgram (program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13147
13148 size_t binary_amp_size;
13149
13150 clGetProgramInfo (program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_amp_size, NULL);
13151
13152 unsigned char *binary_amp = (unsigned char *) mymalloc (binary_amp_size);
13153
13154 clGetProgramInfo (program_amp, CL_PROGRAM_BINARIES, sizeof (binary_amp), &binary_amp, NULL);
13155
13156 writeProgramBin (kernel_amp_file, binary_amp, binary_amp_size);
13157
13158 local_free (binary_amp);
13159
13160 stat (kernel_amp_file, &st); // to reload filesize
13161 }
13162 #else
13163 snprintf (kernel_amp_file, sizeof (kernel_amp_file) - 1, "%s/OpenCL/amp_a%d.cl", install_dir, attack_kern);
13164
13165 if (stat (kernel_amp_file, &st) == -1)
13166 {
13167 log_error ("ERROR: %s: %s", kernel_amp_file, strerror (errno));
13168
13169 return -1;
13170 }
13171 #endif
13172
13173 load_kernel (kernel_amp_file, 1, kernel_amp_lengths, kernel_amp_sources);
13174
13175 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, kernel_amp_file, st.st_size);
13176
13177 #ifdef BINARY_KERNEL
13178 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_amp_lengths, (const unsigned char **) kernel_amp_sources, NULL);
13179 #else
13180 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_amp_sources, NULL);
13181 #endif
13182
13183 local_free (kernel_amp_lengths);
13184
13185 local_free (kernel_amp_sources[0]);
13186
13187 local_free (kernel_amp_sources);
13188 }
13189
13190 /**
13191 * kernel compile
13192 */
13193
13194 //#ifdef BINARY_KERNEL
13195
13196 if (force_jit_compilation == 0)
13197 {
13198 // nothing to do
13199 }
13200 else if (force_jit_compilation == 1500)
13201 {
13202 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13203 }
13204 else if (force_jit_compilation == 8900)
13205 {
13206 sprintf (build_opts, "%s -DSCRYPT_N=%d -DSCRYPT_R=%d -DSCRYPT_P=%d -DSCRYPT_TMTO=%d", build_opts, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, data.salts_buf[0].scrypt_tmto);
13207 }
13208
13209 //#endif
13210
13211 clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13212
13213 size_t ret_val_size = 0;
13214
13215 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13216
13217 if (ret_val_size > 2)
13218 {
13219 char *build_log = (char *) malloc (ret_val_size + 1);
13220
13221 memset (build_log, 0, ret_val_size + 1);
13222
13223 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13224
13225 puts (build_log);
13226
13227 free (build_log);
13228 }
13229
13230 if (attack_mode != ATTACK_MODE_STRAIGHT)
13231 {
13232 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13233 }
13234
13235 if (attack_exec == ATTACK_EXEC_ON_GPU)
13236 {
13237 // nothing to do
13238 }
13239 else
13240 {
13241 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13242 }
13243
13244 /**
13245 * amp is not independent
13246 */
13247
13248 if (attack_exec == ATTACK_EXEC_ON_GPU)
13249 {
13250 // nothing to do
13251 }
13252 else
13253 {
13254 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
13255 }
13256
13257 /**
13258 * global buffers
13259 */
13260
13261 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13262 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13263 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13264 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13265 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13266 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13267 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13268 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13269 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13270 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13271 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13272 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13273 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13274 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13275 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13276 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13277 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13278 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13279
13280 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13281 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13282 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13283 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13284 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13285 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13286 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13287 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13288 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13289 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13290 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13291
13292 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13293 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13294 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13295 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13296 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13297 run_kernel_bzero (device_param, device_param->d_result, size_results);
13298
13299 /**
13300 * special buffers
13301 */
13302
13303 if (attack_kern == ATTACK_KERN_STRAIGHT)
13304 {
13305 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13306 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13307
13308 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, gpu_rules_buf, 0, NULL, NULL);
13309
13310 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13311 }
13312 else if (attack_kern == ATTACK_KERN_COMBI)
13313 {
13314 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13315 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13316 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13317 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13318
13319 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13320 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13321 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13322 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13323 }
13324 else if (attack_kern == ATTACK_KERN_BF)
13325 {
13326 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13327 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13328 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13329 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13330 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13331
13332 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13333 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13334 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13335 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13336 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13337 }
13338
13339 if (size_esalts)
13340 {
13341 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13342
13343 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13344 }
13345
13346 /**
13347 * main host data
13348 */
13349
13350 uint *result = (uint *) mymalloc (size_results);
13351
13352 memset (result, 0, size_results);
13353
13354 device_param->result = result;
13355
13356 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13357
13358 memset (pws_buf, 0, size_pws);
13359
13360 device_param->pws_buf = pws_buf;
13361
13362 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13363
13364 for (int i = 0; i < 64; i++)
13365 {
13366 pw_caches[i].pw_buf.pw_len = i;
13367 pw_caches[i].cnt = 0;
13368 }
13369
13370 device_param->pw_caches = pw_caches;
13371
13372 comb_t *combs_buf = (comb_t *) mycalloc (GPU_COMBS, sizeof (comb_t));
13373
13374 device_param->combs_buf = combs_buf;
13375
13376 void *hooks_buf = mymalloc (size_hooks);
13377
13378 device_param->hooks_buf = hooks_buf;
13379
13380 device_param->pw_transpose = pw_transpose_to_hi1;
13381 device_param->pw_add = pw_add_to_hc1;
13382
13383 /**
13384 * kernel args
13385 */
13386
13387 device_param->kernel_params_buf32[21] = bitmap_mask;
13388 device_param->kernel_params_buf32[22] = bitmap_shift1;
13389 device_param->kernel_params_buf32[23] = bitmap_shift2;
13390 device_param->kernel_params_buf32[24] = 0; // salt_pos
13391 device_param->kernel_params_buf32[25] = 0; // loop_pos
13392 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13393 device_param->kernel_params_buf32[27] = 0; // gpu_rules_cnt
13394 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13395 device_param->kernel_params_buf32[29] = 0; // digests_offset
13396 device_param->kernel_params_buf32[30] = 0; // combs_mode
13397 device_param->kernel_params_buf32[31] = 0; // gid_max
13398
13399 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_ON_GPU)
13400 ? &device_param->d_pws_buf
13401 : &device_param->d_pws_amp_buf;
13402 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13403 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13404 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13405 device_param->kernel_params[ 4] = &device_param->d_tmps;
13406 device_param->kernel_params[ 5] = &device_param->d_hooks;
13407 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13408 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13409 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13410 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13411 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13412 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13413 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13414 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13415 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13416 device_param->kernel_params[15] = &device_param->d_digests_buf;
13417 device_param->kernel_params[16] = &device_param->d_digests_shown;
13418 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13419 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13420 device_param->kernel_params[19] = &device_param->d_result;
13421 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13422 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13423 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13424 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13425 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13426 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13427 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13428 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13429 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13430 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13431 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13432 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13433
13434 device_param->kernel_params_mp_buf64[3] = 0;
13435 device_param->kernel_params_mp_buf32[4] = 0;
13436 device_param->kernel_params_mp_buf32[5] = 0;
13437 device_param->kernel_params_mp_buf32[6] = 0;
13438 device_param->kernel_params_mp_buf32[7] = 0;
13439 device_param->kernel_params_mp_buf32[8] = 0;
13440
13441 device_param->kernel_params_mp[0] = NULL;
13442 device_param->kernel_params_mp[1] = NULL;
13443 device_param->kernel_params_mp[2] = NULL;
13444 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13445 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13446 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13447 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13448 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13449 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13450
13451 device_param->kernel_params_mp_l_buf64[3] = 0;
13452 device_param->kernel_params_mp_l_buf32[4] = 0;
13453 device_param->kernel_params_mp_l_buf32[5] = 0;
13454 device_param->kernel_params_mp_l_buf32[6] = 0;
13455 device_param->kernel_params_mp_l_buf32[7] = 0;
13456 device_param->kernel_params_mp_l_buf32[8] = 0;
13457 device_param->kernel_params_mp_l_buf32[9] = 0;
13458
13459 device_param->kernel_params_mp_l[0] = NULL;
13460 device_param->kernel_params_mp_l[1] = NULL;
13461 device_param->kernel_params_mp_l[2] = NULL;
13462 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
13463 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
13464 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
13465 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
13466 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
13467 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
13468 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
13469
13470 device_param->kernel_params_mp_r_buf64[3] = 0;
13471 device_param->kernel_params_mp_r_buf32[4] = 0;
13472 device_param->kernel_params_mp_r_buf32[5] = 0;
13473 device_param->kernel_params_mp_r_buf32[6] = 0;
13474 device_param->kernel_params_mp_r_buf32[7] = 0;
13475 device_param->kernel_params_mp_r_buf32[8] = 0;
13476
13477 device_param->kernel_params_mp_r[0] = NULL;
13478 device_param->kernel_params_mp_r[1] = NULL;
13479 device_param->kernel_params_mp_r[2] = NULL;
13480 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
13481 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
13482 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
13483 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
13484 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
13485 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
13486
13487 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
13488 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
13489
13490 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
13491 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
13492 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
13493 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
13494 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
13495 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
13496 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
13497
13498 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
13499
13500 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
13501 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
13502
13503 /**
13504 * kernel name
13505 */
13506
13507 char kernel_name[64];
13508
13509 memset (kernel_name, 0, sizeof (kernel_name));
13510
13511 if (attack_exec == ATTACK_EXEC_ON_GPU)
13512 {
13513 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13514 {
13515 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
13516
13517 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13518
13519 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
13520
13521 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13522
13523 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
13524
13525 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13526 }
13527 else
13528 {
13529 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
13530
13531 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13532
13533 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
13534
13535 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13536
13537 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
13538
13539 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13540 }
13541
13542 if (data.attack_mode == ATTACK_MODE_BF)
13543 {
13544 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13545 {
13546 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
13547
13548 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
13549
13550 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
13551
13552 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
13553 }
13554 }
13555 }
13556 else
13557 {
13558 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
13559
13560 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13561
13562 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
13563
13564 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13565
13566 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
13567
13568 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13569
13570 if (opts_type & OPTS_TYPE_HOOK12)
13571 {
13572 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
13573
13574 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
13575 }
13576
13577 if (opts_type & OPTS_TYPE_HOOK23)
13578 {
13579 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
13580
13581 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
13582 }
13583 }
13584
13585 for (uint i = 0; i <= 20; i++)
13586 {
13587 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
13588 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
13589 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
13590
13591 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
13592 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
13593 }
13594
13595 for (uint i = 21; i <= 31; i++)
13596 {
13597 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
13598 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
13599 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
13600
13601 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
13602 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
13603 }
13604
13605 if (attack_mode == ATTACK_MODE_BF)
13606 {
13607 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
13608 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
13609
13610 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13611 {
13612 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
13613
13614 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
13615 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
13616 }
13617 }
13618 else if (attack_mode == ATTACK_MODE_HYBRID1)
13619 {
13620 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
13621 }
13622 else if (attack_mode == ATTACK_MODE_HYBRID2)
13623 {
13624 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
13625 }
13626
13627 if (attack_exec == ATTACK_EXEC_ON_GPU)
13628 {
13629 // nothing to do
13630 }
13631 else
13632 {
13633 for (uint i = 0; i < 5; i++)
13634 {
13635 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
13636 }
13637
13638 for (uint i = 5; i < 7; i++)
13639 {
13640 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
13641 }
13642 }
13643
13644 /**
13645 * Store initial fanspeed if gpu_temp_retain is enabled
13646 */
13647
13648 int gpu_temp_retain_set = 0;
13649
13650 if (gpu_temp_disable == 0)
13651 {
13652 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
13653 {
13654 hc_thread_mutex_lock (mux_adl);
13655
13656 if (data.hm_device[device_id].fan_supported == 1)
13657 {
13658 if (gpu_temp_retain_chgd == 0)
13659 {
13660 uint cur_temp = 0;
13661 uint default_temp = 0;
13662
13663 int ADL_rc = hc_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, (int *) &cur_temp, (int *) &default_temp);
13664
13665 if (ADL_rc == ADL_OK)
13666 {
13667 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
13668
13669 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
13670
13671 // special case with multi gpu setups: always use minimum retain
13672
13673 if (gpu_temp_retain_set == 0)
13674 {
13675 gpu_temp_retain = gpu_temp_retain_target;
13676 gpu_temp_retain_set = 1;
13677 }
13678 else
13679 {
13680 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
13681 }
13682
13683 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
13684 }
13685 }
13686
13687 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
13688
13689 temp_retain_fanspeed_value[device_id] = fan_speed;
13690
13691 if (fan_speed == -1)
13692 {
13693 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
13694
13695 temp_retain_fanspeed_value[device_id] = 0;
13696 }
13697 }
13698
13699 hc_thread_mutex_unlock (mux_adl);
13700 }
13701 }
13702
13703 /**
13704 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
13705 */
13706
13707 if (powertune_enable == 1) // VENDOR_ID_AMD implied
13708 {
13709 hc_thread_mutex_lock (mux_adl);
13710
13711 if (data.hm_device[device_id].od_version == 6)
13712 {
13713 int ADL_rc;
13714
13715 // check powertune capabilities first, if not available then skip device
13716
13717 int powertune_supported = 0;
13718
13719 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13720 {
13721 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13722
13723 return (-1);
13724 }
13725
13726 if (powertune_supported != 0)
13727 {
13728 // powercontrol settings
13729
13730 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13731
13732 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
13733 {
13734 ADL_rc = hc_ADL_Overdrive_PowerControl_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
13735 }
13736
13737 if (ADL_rc != ADL_OK)
13738 {
13739 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13740
13741 return (-1);
13742 }
13743
13744 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13745 {
13746 log_error ("ERROR: Failed to set new ADL PowerControl values");
13747
13748 return (-1);
13749 }
13750
13751 // clocks
13752
13753 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
13754
13755 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
13756
13757 if ((ADL_rc = hc_ADL_Overdrive_StateInfo_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
13758 {
13759 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
13760
13761 return (-1);
13762 }
13763
13764 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
13765
13766 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
13767
13768 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
13769 {
13770 log_error ("ERROR: Failed to get ADL device capabilities");
13771
13772 return (-1);
13773 }
13774
13775 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
13776 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
13777
13778 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
13779 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
13780
13781 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
13782 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
13783
13784 // warning if profile has to low max values
13785
13786 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
13787 {
13788 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
13789 }
13790
13791 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
13792 {
13793 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
13794 }
13795
13796 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
13797
13798 performance_state->iNumberOfPerformanceLevels = 2;
13799
13800 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
13801 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
13802 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
13803 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
13804
13805 if ((ADL_rc = hc_ADL_Overdrive_State_Set (data.hm_dll, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
13806 {
13807 log_info ("ERROR: Failed to set ADL performance state");
13808
13809 return (-1);
13810 }
13811
13812 local_free (performance_state);
13813 }
13814 }
13815
13816 hc_thread_mutex_unlock (mux_adl);
13817 }
13818 }
13819
13820 data.gpu_blocks_all = gpu_blocks_all;
13821
13822 if (data.quiet == 0) log_info ("");
13823
13824 /**
13825 * Inform user which algorithm is checked and at which workload setting
13826 */
13827
13828 if (benchmark == 1)
13829 {
13830 quiet = 0;
13831
13832 data.quiet = quiet;
13833
13834 char *hash_type = strhashtype (data.hash_mode); // not a bug
13835
13836 log_info ("Hashtype: %s", hash_type);
13837 log_info ("Workload: %u loops, %u accel", gpu_loops, gpu_accel);
13838 log_info ("");
13839 }
13840
13841 /**
13842 * keep track of the progress
13843 */
13844
13845 data.words_progress_done = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
13846 data.words_progress_rejected = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
13847 data.words_progress_restored = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
13848
13849 /**
13850 * open filehandles
13851 */
13852
13853 #if _WIN
13854 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
13855 {
13856 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
13857
13858 return (-1);
13859 }
13860
13861 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
13862 {
13863 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
13864
13865 return (-1);
13866 }
13867
13868 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
13869 {
13870 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
13871
13872 return (-1);
13873 }
13874 #endif
13875
13876 /**
13877 * dictionary pad
13878 */
13879
13880 segment_size *= (1024 * 1024);
13881
13882 data.segment_size = segment_size;
13883
13884 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
13885
13886 wl_data->buf = (char *) mymalloc (segment_size);
13887 wl_data->avail = segment_size;
13888 wl_data->incr = segment_size;
13889 wl_data->cnt = 0;
13890 wl_data->pos = 0;
13891
13892 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
13893
13894 data.wordlist_mode = wordlist_mode;
13895
13896 cs_t *css_buf = NULL;
13897 uint css_cnt = 0;
13898 uint dictcnt = 0;
13899 uint maskcnt = 1;
13900 char **masks = NULL;
13901 char **dictfiles = NULL;
13902
13903 uint mask_from_file = 0;
13904
13905 if (attack_mode == ATTACK_MODE_STRAIGHT)
13906 {
13907 if (wordlist_mode == WL_MODE_FILE)
13908 {
13909 int wls_left = myargc - (optind + 1);
13910
13911 for (int i = 0; i < wls_left; i++)
13912 {
13913 char *l0_filename = myargv[optind + 1 + i];
13914
13915 struct stat l0_stat;
13916
13917 if (stat (l0_filename, &l0_stat) == -1)
13918 {
13919 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
13920
13921 return (-1);
13922 }
13923
13924 uint is_dir = S_ISDIR (l0_stat.st_mode);
13925
13926 if (is_dir == 0)
13927 {
13928 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
13929
13930 dictcnt++;
13931
13932 dictfiles[dictcnt - 1] = l0_filename;
13933 }
13934 else
13935 {
13936 // do not allow --keyspace w/ a directory
13937
13938 if (keyspace == 1)
13939 {
13940 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
13941
13942 return (-1);
13943 }
13944
13945 char **dictionary_files = NULL;
13946
13947 dictionary_files = scan_directory (l0_filename);
13948
13949 if (dictionary_files != NULL)
13950 {
13951 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
13952
13953 for (int d = 0; dictionary_files[d] != NULL; d++)
13954 {
13955 char *l1_filename = dictionary_files[d];
13956
13957 struct stat l1_stat;
13958
13959 if (stat (l1_filename, &l1_stat) == -1)
13960 {
13961 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
13962
13963 return (-1);
13964 }
13965
13966 if (S_ISREG (l1_stat.st_mode))
13967 {
13968 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
13969
13970 dictcnt++;
13971
13972 dictfiles[dictcnt - 1] = strdup (l1_filename);
13973 }
13974 }
13975 }
13976
13977 local_free (dictionary_files);
13978 }
13979 }
13980
13981 if (dictcnt < 1)
13982 {
13983 log_error ("ERROR: No usable dictionary file found.");
13984
13985 return (-1);
13986 }
13987 }
13988 else if (wordlist_mode == WL_MODE_STDIN)
13989 {
13990 dictcnt = 1;
13991 }
13992 }
13993 else if (attack_mode == ATTACK_MODE_COMBI)
13994 {
13995 // display
13996
13997 char *dictfile1 = myargv[optind + 1 + 0];
13998 char *dictfile2 = myargv[optind + 1 + 1];
13999
14000 // find the bigger dictionary and use as base
14001
14002 FILE *fp1;
14003 FILE *fp2;
14004
14005 struct stat tmp_stat;
14006
14007 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14008 {
14009 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14010
14011 return (-1);
14012 }
14013
14014 if (stat (dictfile1, &tmp_stat) == -1)
14015 {
14016 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14017
14018 fclose (fp1);
14019
14020 return (-1);
14021 }
14022
14023 if (S_ISDIR (tmp_stat.st_mode))
14024 {
14025 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14026
14027 fclose (fp1);
14028
14029 return (-1);
14030 }
14031
14032 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14033 {
14034 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14035
14036 fclose (fp1);
14037
14038 return (-1);
14039 }
14040
14041 if (stat (dictfile2, &tmp_stat) == -1)
14042 {
14043 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14044
14045 fclose (fp1);
14046 fclose (fp2);
14047
14048 return (-1);
14049 }
14050
14051 if (S_ISDIR (tmp_stat.st_mode))
14052 {
14053 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14054
14055 fclose (fp1);
14056 fclose (fp2);
14057
14058 return (-1);
14059 }
14060
14061 data.combs_cnt = 1;
14062
14063 data.quiet = 1;
14064
14065 const uint64_t words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14066
14067 data.quiet = quiet;
14068
14069 if (words1_cnt == 0)
14070 {
14071 log_error ("ERROR: %s: empty file", dictfile1);
14072
14073 fclose (fp1);
14074 fclose (fp2);
14075
14076 return (-1);
14077 }
14078
14079 data.combs_cnt = 1;
14080
14081 data.quiet = 1;
14082
14083 const uint64_t words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14084
14085 data.quiet = quiet;
14086
14087 if (words2_cnt == 0)
14088 {
14089 log_error ("ERROR: %s: empty file", dictfile2);
14090
14091 fclose (fp1);
14092 fclose (fp2);
14093
14094 return (-1);
14095 }
14096
14097 fclose (fp1);
14098 fclose (fp2);
14099
14100 data.dictfile = dictfile1;
14101 data.dictfile2 = dictfile2;
14102
14103 if (words1_cnt >= words2_cnt)
14104 {
14105 data.combs_cnt = words2_cnt;
14106 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14107
14108 dictfiles = &data.dictfile;
14109
14110 dictcnt = 1;
14111 }
14112 else
14113 {
14114 data.combs_cnt = words1_cnt;
14115 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14116
14117 dictfiles = &data.dictfile2;
14118
14119 dictcnt = 1;
14120
14121 // we also have to switch wordlist related rules!
14122
14123 char *tmpc = data.rule_buf_l;
14124
14125 data.rule_buf_l = data.rule_buf_r;
14126 data.rule_buf_r = tmpc;
14127
14128 int tmpi = data.rule_len_l;
14129
14130 data.rule_len_l = data.rule_len_r;
14131 data.rule_len_r = tmpi;
14132 }
14133 }
14134 else if (attack_mode == ATTACK_MODE_BF)
14135 {
14136 char *mask = NULL;
14137
14138 maskcnt = 0;
14139
14140 if (benchmark == 0)
14141 {
14142 mask = myargv[optind + 1];
14143
14144 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14145
14146 if ((optind + 2) <= myargc)
14147 {
14148 struct stat file_stat;
14149
14150 if (stat (mask, &file_stat) == -1)
14151 {
14152 maskcnt = 1;
14153
14154 masks[maskcnt - 1] = mystrdup (mask);
14155 }
14156 else
14157 {
14158 int wls_left = myargc - (optind + 1);
14159
14160 uint masks_avail = INCR_MASKS;
14161
14162 for (int i = 0; i < wls_left; i++)
14163 {
14164 if (i != 0)
14165 {
14166 mask = myargv[optind + 1 + i];
14167
14168 if (stat (mask, &file_stat) == -1)
14169 {
14170 log_error ("ERROR: %s: %s", mask, strerror (errno));
14171
14172 return (-1);
14173 }
14174 }
14175
14176 uint is_file = S_ISREG (file_stat.st_mode);
14177
14178 if (is_file == 1)
14179 {
14180 FILE *mask_fp;
14181
14182 if ((mask_fp = fopen (mask, "r")) == NULL)
14183 {
14184 log_error ("ERROR: %s: %s", mask, strerror (errno));
14185
14186 return (-1);
14187 }
14188
14189 char line_buf[BUFSIZ];
14190
14191 while (!feof (mask_fp))
14192 {
14193 memset (line_buf, 0, BUFSIZ);
14194
14195 int line_len = fgetl (mask_fp, line_buf);
14196
14197 if (line_len == 0) continue;
14198
14199 if (line_buf[0] == '#') continue;
14200
14201 if (masks_avail == maskcnt)
14202 {
14203 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14204
14205 masks_avail += INCR_MASKS;
14206 }
14207
14208 masks[maskcnt] = mystrdup (line_buf);
14209
14210 maskcnt++;
14211 }
14212
14213 fclose (mask_fp);
14214 }
14215 else
14216 {
14217 log_error ("ERROR: %s: unsupported file-type", mask);
14218
14219 return (-1);
14220 }
14221 }
14222
14223 mask_from_file = 1;
14224 }
14225 }
14226 else
14227 {
14228 custom_charset_1 = (char *) "?l?d?u";
14229 custom_charset_2 = (char *) "?l?d";
14230 custom_charset_3 = (char *) "?l?d*!$@_";
14231
14232 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14233 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14234 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14235
14236 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14237
14238 wordlist_mode = WL_MODE_MASK;
14239
14240 data.wordlist_mode = wordlist_mode;
14241
14242 increment = 1;
14243
14244 maskcnt = 1;
14245 }
14246 }
14247 else
14248 {
14249 /**
14250 * generate full masks and charsets
14251 */
14252
14253 masks = (char **) mymalloc (sizeof (char *));
14254
14255 switch (hash_mode)
14256 {
14257 case 1731: pw_min = 5;
14258 pw_max = 5;
14259 mask = mystrdup ("?b?b?b?b?b");
14260 break;
14261 case 12500: pw_min = 5;
14262 pw_max = 5;
14263 mask = mystrdup ("?b?b?b?b?b");
14264 break;
14265 default: pw_min = 7;
14266 pw_max = 7;
14267 mask = mystrdup ("?b?b?b?b?b?b?b");
14268 break;
14269 }
14270
14271 maskcnt = 1;
14272
14273 masks[maskcnt - 1] = mystrdup (mask);
14274
14275 wordlist_mode = WL_MODE_MASK;
14276
14277 data.wordlist_mode = wordlist_mode;
14278
14279 increment = 1;
14280 }
14281
14282 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14283
14284 if (increment)
14285 {
14286 if (increment_min > pw_min) pw_min = increment_min;
14287
14288 if (increment_max < pw_max) pw_max = increment_max;
14289 }
14290 }
14291 else if (attack_mode == ATTACK_MODE_HYBRID1)
14292 {
14293 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14294
14295 // display
14296
14297 char *mask = myargv[myargc - 1];
14298
14299 maskcnt = 0;
14300
14301 masks = (char **) mymalloc (1 * sizeof (char *));
14302
14303 // mod
14304
14305 struct stat file_stat;
14306
14307 if (stat (mask, &file_stat) == -1)
14308 {
14309 maskcnt = 1;
14310
14311 masks[maskcnt - 1] = mystrdup (mask);
14312 }
14313 else
14314 {
14315 uint is_file = S_ISREG (file_stat.st_mode);
14316
14317 if (is_file == 1)
14318 {
14319 FILE *mask_fp;
14320
14321 if ((mask_fp = fopen (mask, "r")) == NULL)
14322 {
14323 log_error ("ERROR: %s: %s", mask, strerror (errno));
14324
14325 return (-1);
14326 }
14327
14328 char line_buf[BUFSIZ];
14329
14330 uint masks_avail = 1;
14331
14332 while (!feof (mask_fp))
14333 {
14334 memset (line_buf, 0, BUFSIZ);
14335
14336 int line_len = fgetl (mask_fp, line_buf);
14337
14338 if (line_len == 0) continue;
14339
14340 if (line_buf[0] == '#') continue;
14341
14342 if (masks_avail == maskcnt)
14343 {
14344 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14345
14346 masks_avail += INCR_MASKS;
14347 }
14348
14349 masks[maskcnt] = mystrdup (line_buf);
14350
14351 maskcnt++;
14352 }
14353
14354 fclose (mask_fp);
14355
14356 mask_from_file = 1;
14357 }
14358 else
14359 {
14360 maskcnt = 1;
14361
14362 masks[maskcnt - 1] = mystrdup (mask);
14363 }
14364 }
14365
14366 // base
14367
14368 int wls_left = myargc - (optind + 2);
14369
14370 for (int i = 0; i < wls_left; i++)
14371 {
14372 char *filename = myargv[optind + 1 + i];
14373
14374 struct stat file_stat;
14375
14376 if (stat (filename, &file_stat) == -1)
14377 {
14378 log_error ("ERROR: %s: %s", filename, strerror (errno));
14379
14380 return (-1);
14381 }
14382
14383 uint is_dir = S_ISDIR (file_stat.st_mode);
14384
14385 if (is_dir == 0)
14386 {
14387 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14388
14389 dictcnt++;
14390
14391 dictfiles[dictcnt - 1] = filename;
14392 }
14393 else
14394 {
14395 // do not allow --keyspace w/ a directory
14396
14397 if (keyspace == 1)
14398 {
14399 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14400
14401 return (-1);
14402 }
14403
14404 char **dictionary_files = NULL;
14405
14406 dictionary_files = scan_directory (filename);
14407
14408 if (dictionary_files != NULL)
14409 {
14410 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14411
14412 for (int d = 0; dictionary_files[d] != NULL; d++)
14413 {
14414 char *l1_filename = dictionary_files[d];
14415
14416 struct stat l1_stat;
14417
14418 if (stat (l1_filename, &l1_stat) == -1)
14419 {
14420 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14421
14422 return (-1);
14423 }
14424
14425 if (S_ISREG (l1_stat.st_mode))
14426 {
14427 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14428
14429 dictcnt++;
14430
14431 dictfiles[dictcnt - 1] = strdup (l1_filename);
14432 }
14433 }
14434 }
14435
14436 local_free (dictionary_files);
14437 }
14438 }
14439
14440 if (dictcnt < 1)
14441 {
14442 log_error ("ERROR: No usable dictionary file found.");
14443
14444 return (-1);
14445 }
14446
14447 if (increment)
14448 {
14449 maskcnt = 0;
14450
14451 uint mask_min = increment_min; // we can't reject smaller masks here
14452 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14453
14454 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14455 {
14456 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14457
14458 if (cur_mask == NULL) break;
14459
14460 masks[maskcnt] = cur_mask;
14461
14462 maskcnt++;
14463
14464 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
14465 }
14466 }
14467 }
14468 else if (attack_mode == ATTACK_MODE_HYBRID2)
14469 {
14470 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14471
14472 // display
14473
14474 char *mask = myargv[optind + 1 + 0];
14475
14476 maskcnt = 0;
14477
14478 masks = (char **) mymalloc (1 * sizeof (char *));
14479
14480 // mod
14481
14482 struct stat file_stat;
14483
14484 if (stat (mask, &file_stat) == -1)
14485 {
14486 maskcnt = 1;
14487
14488 masks[maskcnt - 1] = mystrdup (mask);
14489 }
14490 else
14491 {
14492 uint is_file = S_ISREG (file_stat.st_mode);
14493
14494 if (is_file == 1)
14495 {
14496 FILE *mask_fp;
14497
14498 if ((mask_fp = fopen (mask, "r")) == NULL)
14499 {
14500 log_error ("ERROR: %s: %s", mask, strerror (errno));
14501
14502 return (-1);
14503 }
14504
14505 char line_buf[BUFSIZ];
14506
14507 uint masks_avail = 1;
14508
14509 while (!feof (mask_fp))
14510 {
14511 memset (line_buf, 0, BUFSIZ);
14512
14513 int line_len = fgetl (mask_fp, line_buf);
14514
14515 if (line_len == 0) continue;
14516
14517 if (line_buf[0] == '#') continue;
14518
14519 if (masks_avail == maskcnt)
14520 {
14521 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14522
14523 masks_avail += INCR_MASKS;
14524 }
14525
14526 masks[maskcnt] = mystrdup (line_buf);
14527
14528 maskcnt++;
14529 }
14530
14531 fclose (mask_fp);
14532
14533 mask_from_file = 1;
14534 }
14535 else
14536 {
14537 maskcnt = 1;
14538
14539 masks[maskcnt - 1] = mystrdup (mask);
14540 }
14541 }
14542
14543 // base
14544
14545 int wls_left = myargc - (optind + 2);
14546
14547 for (int i = 0; i < wls_left; i++)
14548 {
14549 char *filename = myargv[optind + 2 + i];
14550
14551 struct stat file_stat;
14552
14553 if (stat (filename, &file_stat) == -1)
14554 {
14555 log_error ("ERROR: %s: %s", filename, strerror (errno));
14556
14557 return (-1);
14558 }
14559
14560 uint is_dir = S_ISDIR (file_stat.st_mode);
14561
14562 if (is_dir == 0)
14563 {
14564 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14565
14566 dictcnt++;
14567
14568 dictfiles[dictcnt - 1] = filename;
14569 }
14570 else
14571 {
14572 // do not allow --keyspace w/ a directory
14573
14574 if (keyspace == 1)
14575 {
14576 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14577
14578 return (-1);
14579 }
14580
14581 char **dictionary_files = NULL;
14582
14583 dictionary_files = scan_directory (filename);
14584
14585 if (dictionary_files != NULL)
14586 {
14587 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14588
14589 for (int d = 0; dictionary_files[d] != NULL; d++)
14590 {
14591 char *l1_filename = dictionary_files[d];
14592
14593 struct stat l1_stat;
14594
14595 if (stat (l1_filename, &l1_stat) == -1)
14596 {
14597 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14598
14599 return (-1);
14600 }
14601
14602 if (S_ISREG (l1_stat.st_mode))
14603 {
14604 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14605
14606 dictcnt++;
14607
14608 dictfiles[dictcnt - 1] = strdup (l1_filename);
14609 }
14610 }
14611 }
14612
14613 local_free (dictionary_files);
14614 }
14615 }
14616
14617 if (dictcnt < 1)
14618 {
14619 log_error ("ERROR: No usable dictionary file found.");
14620
14621 return (-1);
14622 }
14623
14624 if (increment)
14625 {
14626 maskcnt = 0;
14627
14628 uint mask_min = increment_min; // we can't reject smaller masks here
14629 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14630
14631 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14632 {
14633 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14634
14635 if (cur_mask == NULL) break;
14636
14637 masks[maskcnt] = cur_mask;
14638
14639 maskcnt++;
14640
14641 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
14642 }
14643 }
14644 }
14645
14646 data.pw_min = pw_min;
14647 data.pw_max = pw_max;
14648
14649 /**
14650 * weak hash check
14651 */
14652
14653 if (weak_hash_threshold >= salts_cnt)
14654 {
14655 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
14656
14657 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
14658 {
14659 weak_hash_check (&data.devices_param[0], salt_pos, gpu_loops);
14660 }
14661 }
14662
14663 // Display hack, guarantee that there is at least one \r before real start
14664
14665 if (data.quiet == 0) log_info_nn ("");
14666
14667 /**
14668 * status and monitor threads
14669 */
14670
14671 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
14672
14673 hc_thread_t i_thread = 0;
14674
14675 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
14676 {
14677 hc_thread_create (i_thread, thread_keypress, &benchmark);
14678 }
14679
14680 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
14681
14682 uint ni_threads_cnt = 0;
14683
14684 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
14685
14686 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
14687
14688 ni_threads_cnt++;
14689
14690 /**
14691 * Outfile remove
14692 */
14693
14694 if (keyspace == 0)
14695 {
14696 if (outfile_check_timer != 0)
14697 {
14698 if (data.outfile_check_directory != NULL)
14699 {
14700 if ((hash_mode != 5200) &&
14701 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
14702 (hash_mode != 9000))
14703 {
14704 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
14705
14706 ni_threads_cnt++;
14707 }
14708 else
14709 {
14710 outfile_check_timer = 0;
14711 }
14712 }
14713 else
14714 {
14715 outfile_check_timer = 0;
14716 }
14717 }
14718 }
14719
14720 /**
14721 * Inform the user if we got some hashes remove because of the pot file remove feature
14722 */
14723
14724 if (data.quiet == 0)
14725 {
14726 if (potfile_remove_cracks > 0)
14727 {
14728 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
14729 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
14730 }
14731 }
14732
14733 data.outfile_check_timer = outfile_check_timer;
14734
14735 /**
14736 * main loop
14737 */
14738
14739 char **induction_dictionaries = NULL;
14740
14741 int induction_dictionaries_cnt = 0;
14742
14743 hcstat_table_t *root_table_buf = NULL;
14744 hcstat_table_t *markov_table_buf = NULL;
14745
14746 uint initial_restore_done = 0;
14747
14748 data.maskcnt = maskcnt;
14749
14750 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
14751 {
14752 if (data.devices_status == STATUS_CRACKED) break;
14753
14754 data.devices_status = STATUS_INIT;
14755
14756 if (maskpos > rd->maskpos)
14757 {
14758 rd->dictpos = 0;
14759 }
14760
14761 rd->maskpos = maskpos;
14762 data.maskpos = maskpos;
14763
14764 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
14765 {
14766 char *mask = masks[maskpos];
14767
14768 if (mask_from_file == 1)
14769 {
14770 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
14771
14772 char *str_ptr;
14773 uint str_pos;
14774
14775 uint mask_offset = 0;
14776
14777 uint separator_cnt;
14778
14779 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
14780 {
14781 str_ptr = strstr (mask + mask_offset, ",");
14782
14783 if (str_ptr == NULL) break;
14784
14785 str_pos = str_ptr - mask;
14786
14787 // escaped separator, i.e. "\,"
14788
14789 if (str_pos > 0)
14790 {
14791 if (mask[str_pos - 1] == '\\')
14792 {
14793 separator_cnt --;
14794
14795 mask_offset = str_pos + 1;
14796
14797 continue;
14798 }
14799 }
14800
14801 // reset the offset
14802
14803 mask_offset = 0;
14804
14805 mask[str_pos] = '\0';
14806
14807 switch (separator_cnt)
14808 {
14809 case 0:
14810 mp_reset_usr (mp_usr, 0);
14811
14812 custom_charset_1 = mask;
14813 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14814 break;
14815
14816 case 1:
14817 mp_reset_usr (mp_usr, 1);
14818
14819 custom_charset_2 = mask;
14820 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14821 break;
14822
14823 case 2:
14824 mp_reset_usr (mp_usr, 2);
14825
14826 custom_charset_3 = mask;
14827 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14828 break;
14829
14830 case 3:
14831 mp_reset_usr (mp_usr, 3);
14832
14833 custom_charset_4 = mask;
14834 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
14835 break;
14836 }
14837
14838 mask = mask + str_pos + 1;
14839 }
14840 }
14841
14842 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
14843 {
14844 if (maskpos > 0)
14845 {
14846 local_free (css_buf);
14847 local_free (data.root_css_buf);
14848 local_free (data.markov_css_buf);
14849
14850 local_free (masks[maskpos - 1]);
14851 }
14852
14853 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
14854
14855 data.mask = mask;
14856 data.css_cnt = css_cnt;
14857 data.css_buf = css_buf;
14858
14859 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
14860
14861 memset (uniq_tbls, 0, sizeof (uniq_tbls));
14862
14863 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
14864
14865 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
14866 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
14867
14868 sp_setup_tbl (install_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
14869
14870 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
14871
14872 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
14873 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
14874
14875 data.root_css_buf = root_css_buf;
14876 data.markov_css_buf = markov_css_buf;
14877
14878 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
14879
14880 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
14881
14882 local_free (root_table_buf);
14883 local_free (markov_table_buf);
14884
14885 // args
14886
14887 for (uint device_id = 0; device_id < devices_cnt; device_id++)
14888 {
14889 hc_device_param_t *device_param = &data.devices_param[device_id];
14890
14891 device_param->kernel_params_mp[0] = &device_param->d_combs;
14892 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
14893 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
14894
14895 device_param->kernel_params_mp_buf64[3] = 0;
14896 device_param->kernel_params_mp_buf32[4] = css_cnt;
14897 device_param->kernel_params_mp_buf32[5] = 0;
14898 device_param->kernel_params_mp_buf32[6] = 0;
14899 device_param->kernel_params_mp_buf32[7] = 0;
14900
14901 if (attack_mode == ATTACK_MODE_HYBRID1)
14902 {
14903 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
14904 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
14905 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
14906 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
14907 }
14908 else if (attack_mode == ATTACK_MODE_HYBRID2)
14909 {
14910 device_param->kernel_params_mp_buf32[5] = 0;
14911 device_param->kernel_params_mp_buf32[6] = 0;
14912 device_param->kernel_params_mp_buf32[7] = 0;
14913 }
14914
14915 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
14916 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
14917 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
14918
14919 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_root_css_buf, CL_TRUE, 0, device_param->size_root_css, root_css_buf, 0, NULL, NULL);
14920 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, markov_css_buf, 0, NULL, NULL);
14921 }
14922 }
14923 else if (attack_mode == ATTACK_MODE_BF)
14924 {
14925 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
14926
14927 if (increment)
14928 {
14929 for (uint i = 0; i < dictcnt; i++)
14930 {
14931 local_free (dictfiles[i]);
14932 }
14933
14934 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
14935 {
14936 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
14937
14938 if (l1_filename == NULL) break;
14939
14940 dictcnt++;
14941
14942 dictfiles[dictcnt - 1] = l1_filename;
14943 }
14944 }
14945 else
14946 {
14947 dictcnt++;
14948
14949 dictfiles[dictcnt - 1] = mask;
14950 }
14951
14952 if (dictcnt == 0)
14953 {
14954 log_error ("ERROR: Mask is too small");
14955
14956 return (-1);
14957 }
14958 }
14959 }
14960
14961 free (induction_dictionaries);
14962
14963 // induction_dictionaries_cnt = 0; // implied
14964
14965 if (attack_mode != ATTACK_MODE_BF)
14966 {
14967 if (keyspace == 0)
14968 {
14969 induction_dictionaries = scan_directory (induction_directory);
14970
14971 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
14972 }
14973 }
14974
14975 if (induction_dictionaries_cnt)
14976 {
14977 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
14978 }
14979
14980 /**
14981 * prevent the user from using --keyspace together w/ maskfile and or dictfile
14982 */
14983 if (keyspace == 1)
14984 {
14985 if ((maskcnt > 1) || (dictcnt > 1))
14986 {
14987 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
14988
14989 return (-1);
14990 }
14991 }
14992
14993 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
14994 {
14995 char *subid = logfile_generate_subid ();
14996
14997 data.subid = subid;
14998
14999 logfile_sub_msg ("START");
15000
15001 data.devices_status = STATUS_INIT;
15002
15003 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (uint64_t));
15004 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (uint64_t));
15005 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (uint64_t));
15006
15007 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15008
15009 data.cpt_pos = 0;
15010
15011 data.cpt_start = time (NULL);
15012
15013 data.cpt_total = 0;
15014
15015 if (data.restore == 0)
15016 {
15017 rd->words_cur = skip;
15018
15019 skip = 0;
15020
15021 data.skip = 0;
15022 }
15023
15024 data.ms_paused = 0;
15025
15026 data.words_cur = rd->words_cur;
15027
15028 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15029 {
15030 hc_device_param_t *device_param = &data.devices_param[device_id];
15031
15032 device_param->speed_pos = 0;
15033
15034 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (uint64_t));
15035 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15036 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15037
15038 device_param->gpu_power = device_param->gpu_power_user;
15039 device_param->gpu_blocks = device_param->gpu_blocks_user;
15040
15041 device_param->outerloop_pos = 0;
15042 device_param->outerloop_left = 0;
15043 device_param->innerloop_pos = 0;
15044 device_param->innerloop_left = 0;
15045
15046 // some more resets:
15047
15048 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15049
15050 memset (device_param->pws_buf, 0, device_param->size_pws);
15051
15052 device_param->pw_cnt = 0;
15053 device_param->pws_cnt = 0;
15054
15055 device_param->words_off = 0;
15056 device_param->words_done = 0;
15057 }
15058
15059 data.gpu_blocks_div = 0;
15060
15061 // figure out some workload
15062
15063 if (attack_mode == ATTACK_MODE_STRAIGHT)
15064 {
15065 if (data.wordlist_mode == WL_MODE_FILE)
15066 {
15067 char *dictfile = NULL;
15068
15069 if (induction_dictionaries_cnt)
15070 {
15071 dictfile = induction_dictionaries[0];
15072 }
15073 else
15074 {
15075 dictfile = dictfiles[dictpos];
15076 }
15077
15078 data.dictfile = dictfile;
15079
15080 logfile_sub_string (dictfile);
15081
15082 for (uint i = 0; i < rp_files_cnt; i++)
15083 {
15084 logfile_sub_var_string ("rulefile", rp_files[i]);
15085 }
15086
15087 FILE *fd2 = fopen (dictfile, "rb");
15088
15089 if (fd2 == NULL)
15090 {
15091 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15092
15093 return (-1);
15094 }
15095
15096 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15097
15098 fclose (fd2);
15099
15100 if (data.words_cnt == 0)
15101 {
15102 if (data.devices_status == STATUS_CRACKED) break;
15103 if (data.devices_status == STATUS_ABORTED) break;
15104
15105 dictpos++;
15106
15107 continue;
15108 }
15109 }
15110 }
15111 else if (attack_mode == ATTACK_MODE_COMBI)
15112 {
15113 char *dictfile = data.dictfile;
15114 char *dictfile2 = data.dictfile2;
15115
15116 logfile_sub_string (dictfile);
15117 logfile_sub_string (dictfile2);
15118
15119 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15120 {
15121 FILE *fd2 = fopen (dictfile, "rb");
15122
15123 if (fd2 == NULL)
15124 {
15125 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15126
15127 return (-1);
15128 }
15129
15130 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15131
15132 fclose (fd2);
15133 }
15134 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15135 {
15136 FILE *fd2 = fopen (dictfile2, "rb");
15137
15138 if (fd2 == NULL)
15139 {
15140 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15141
15142 return (-1);
15143 }
15144
15145 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15146
15147 fclose (fd2);
15148 }
15149
15150 if (data.words_cnt == 0)
15151 {
15152 if (data.devices_status == STATUS_CRACKED) break;
15153 if (data.devices_status == STATUS_ABORTED) break;
15154
15155 dictpos++;
15156
15157 continue;
15158 }
15159 }
15160 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15161 {
15162 char *dictfile = NULL;
15163
15164 if (induction_dictionaries_cnt)
15165 {
15166 dictfile = induction_dictionaries[0];
15167 }
15168 else
15169 {
15170 dictfile = dictfiles[dictpos];
15171 }
15172
15173 data.dictfile = dictfile;
15174
15175 char *mask = data.mask;
15176
15177 logfile_sub_string (dictfile);
15178 logfile_sub_string (mask);
15179
15180 FILE *fd2 = fopen (dictfile, "rb");
15181
15182 if (fd2 == NULL)
15183 {
15184 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15185
15186 return (-1);
15187 }
15188
15189 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15190
15191 fclose (fd2);
15192
15193 if (data.words_cnt == 0)
15194 {
15195 if (data.devices_status == STATUS_CRACKED) break;
15196 if (data.devices_status == STATUS_ABORTED) break;
15197
15198 dictpos++;
15199
15200 continue;
15201 }
15202 }
15203 else if (attack_mode == ATTACK_MODE_BF)
15204 {
15205 local_free (css_buf);
15206 local_free (data.root_css_buf);
15207 local_free (data.markov_css_buf);
15208
15209 char *mask = dictfiles[dictpos];
15210
15211 logfile_sub_string (mask);
15212
15213 // base
15214
15215 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15216
15217 if (opts_type & OPTS_TYPE_PT_UNICODE)
15218 {
15219 uint css_cnt_unicode = css_cnt * 2;
15220
15221 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15222
15223 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15224 {
15225 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15226
15227 css_buf_unicode[j + 1].cs_buf[0] = 0;
15228 css_buf_unicode[j + 1].cs_len = 1;
15229 }
15230
15231 free (css_buf);
15232
15233 css_buf = css_buf_unicode;
15234 css_cnt = css_cnt_unicode;
15235 }
15236
15237 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15238
15239 uint mask_min = pw_min;
15240 uint mask_max = pw_max;
15241
15242 if (opts_type & OPTS_TYPE_PT_UNICODE)
15243 {
15244 mask_min *= 2;
15245 mask_max *= 2;
15246 }
15247
15248 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15249 {
15250 if (css_cnt < mask_min)
15251 {
15252 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15253 }
15254
15255 if (css_cnt > mask_max)
15256 {
15257 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15258 }
15259
15260 // skip to next mask
15261
15262 dictpos++;
15263
15264 rd->dictpos = dictpos;
15265
15266 logfile_sub_msg ("STOP");
15267
15268 continue;
15269 }
15270
15271 uint save_css_cnt = css_cnt;
15272
15273 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15274 {
15275 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15276 {
15277 uint salt_len = (uint) data.salts_buf[0].salt_len;
15278 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15279
15280 uint css_cnt_salt = css_cnt + salt_len;
15281
15282 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15283
15284 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15285
15286 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15287 {
15288 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15289 css_buf_salt[j].cs_len = 1;
15290 }
15291
15292 free (css_buf);
15293
15294 css_buf = css_buf_salt;
15295 css_cnt = css_cnt_salt;
15296 }
15297 }
15298
15299 data.mask = mask;
15300 data.css_cnt = css_cnt;
15301 data.css_buf = css_buf;
15302
15303 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15304
15305 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15306
15307 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15308
15309 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15310
15311 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15312 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15313
15314 sp_setup_tbl (install_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15315
15316 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15317
15318 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15319 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15320
15321 data.root_css_buf = root_css_buf;
15322 data.markov_css_buf = markov_css_buf;
15323
15324 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15325
15326 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15327
15328 local_free (root_table_buf);
15329 local_free (markov_table_buf);
15330
15331 // copy + args
15332
15333 uint css_cnt_l = css_cnt;
15334 uint css_cnt_r;
15335
15336 if (attack_exec == ATTACK_EXEC_ON_GPU)
15337 {
15338 if (save_css_cnt < 6)
15339 {
15340 css_cnt_r = 1;
15341 }
15342 else if (save_css_cnt == 6)
15343 {
15344 css_cnt_r = 2;
15345 }
15346 else
15347 {
15348 if (opts_type & OPTS_TYPE_PT_UNICODE)
15349 {
15350 if (save_css_cnt == 8 || save_css_cnt == 10)
15351 {
15352 css_cnt_r = 2;
15353 }
15354 else
15355 {
15356 css_cnt_r = 4;
15357 }
15358 }
15359 else
15360 {
15361 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15362 {
15363 css_cnt_r = 3;
15364 }
15365 else
15366 {
15367 css_cnt_r = 4;
15368 }
15369 }
15370 }
15371 }
15372 else
15373 {
15374 css_cnt_r = 1;
15375
15376 /* unfinished code?
15377 int sum = css_buf[css_cnt_r - 1].cs_len;
15378
15379 for (uint i = 1; i < 4 && i < css_cnt; i++)
15380 {
15381 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15382
15383 css_cnt_r++;
15384
15385 sum *= css_buf[css_cnt_r - 1].cs_len;
15386 }
15387 */
15388 }
15389
15390 css_cnt_l -= css_cnt_r;
15391
15392 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15393
15394 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15395 {
15396 hc_device_param_t *device_param = &data.devices_param[device_id];
15397
15398 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15399 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15400 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15401
15402 device_param->kernel_params_mp_l_buf64[3] = 0;
15403 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15404 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15405 device_param->kernel_params_mp_l_buf32[6] = 0;
15406 device_param->kernel_params_mp_l_buf32[7] = 0;
15407 device_param->kernel_params_mp_l_buf32[8] = 0;
15408
15409 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15410 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15411 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15412 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15413
15414 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15415 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
15416 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
15417
15418 device_param->kernel_params_mp_r_buf64[3] = 0;
15419 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
15420 device_param->kernel_params_mp_r_buf32[5] = 0;
15421 device_param->kernel_params_mp_r_buf32[6] = 0;
15422 device_param->kernel_params_mp_r_buf32[7] = 0;
15423
15424 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp_l, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_l[i]);
15425 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp_l, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_l[i]);
15426 for (uint i = 4; i < 9; i++) hc_clSetKernelArg (device_param->kernel_mp_l, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_l[i]);
15427
15428 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp_r, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_r[i]);
15429 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp_r, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_r[i]);
15430 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp_r, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_r[i]);
15431
15432 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_root_css_buf, CL_TRUE, 0, device_param->size_root_css, root_css_buf, 0, NULL, NULL);
15433 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, markov_css_buf, 0, NULL, NULL);
15434 }
15435 }
15436
15437 uint64_t words_base = data.words_cnt;
15438
15439 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15440 {
15441 if (data.gpu_rules_cnt)
15442 {
15443 words_base /= data.gpu_rules_cnt;
15444 }
15445 }
15446 else if (data.attack_kern == ATTACK_KERN_COMBI)
15447 {
15448 if (data.combs_cnt)
15449 {
15450 words_base /= data.combs_cnt;
15451 }
15452 }
15453 else if (data.attack_kern == ATTACK_KERN_BF)
15454 {
15455 if (data.bfs_cnt)
15456 {
15457 words_base /= data.bfs_cnt;
15458 }
15459 }
15460
15461 data.words_base = words_base;
15462
15463 if (keyspace == 1)
15464 {
15465 log_info ("%llu", (unsigned long long int) words_base);
15466
15467 return (0);
15468 }
15469
15470 if (data.words_cur > data.words_base)
15471 {
15472 log_error ("ERROR: restore value greater keyspace");
15473
15474 return (-1);
15475 }
15476
15477 if (data.words_cur)
15478 {
15479 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15480 {
15481 for (uint i = 0; i < data.salts_cnt; i++)
15482 {
15483 data.words_progress_restored[i] = data.words_cur * data.gpu_rules_cnt;
15484 }
15485 }
15486 else if (data.attack_kern == ATTACK_KERN_COMBI)
15487 {
15488 for (uint i = 0; i < data.salts_cnt; i++)
15489 {
15490 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
15491 }
15492 }
15493 else if (data.attack_kern == ATTACK_KERN_BF)
15494 {
15495 for (uint i = 0; i < data.salts_cnt; i++)
15496 {
15497 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
15498 }
15499 }
15500 }
15501
15502 /*
15503 * Inform user about possible slow speeds
15504 */
15505
15506 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15507 {
15508 if (data.words_base < gpu_blocks_all)
15509 {
15510 if (quiet == 0)
15511 {
15512 log_info ("");
15513 log_info ("ATTENTION!");
15514 log_info (" The wordlist or mask you are using is too small.");
15515 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your GPU(s).");
15516 log_info (" The cracking speed will drop.");
15517 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
15518 log_info ("");
15519 }
15520 }
15521 }
15522
15523 /*
15524 * Update loopback file
15525 */
15526
15527 if (loopback == 1)
15528 {
15529 time_t now;
15530
15531 time (&now);
15532
15533 uint random_num = get_random_num (0, 9999);
15534
15535 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
15536
15537 data.loopback_file = loopback_file;
15538 }
15539
15540 /*
15541 * Update dictionary statistic
15542 */
15543
15544 if (keyspace == 0)
15545 {
15546 dictstat_fp = fopen (dictstat, "wb");
15547
15548 if (dictstat_fp)
15549 {
15550 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
15551
15552 fclose (dictstat_fp);
15553 }
15554 }
15555
15556 data.devices_status = STATUS_RUNNING;
15557
15558 if (initial_restore_done == 0)
15559 {
15560 if (data.restore_disable == 0) cycle_restore ();
15561
15562 initial_restore_done = 1;
15563 }
15564
15565 hc_timer_set (&data.timer_running);
15566
15567 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15568 {
15569 if ((quiet == 0) && (status == 0) && (benchmark == 0))
15570 {
15571 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
15572 if (quiet == 0) fflush (stdout);
15573 }
15574 }
15575 else if (wordlist_mode == WL_MODE_STDIN)
15576 {
15577 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
15578 if (data.quiet == 0) log_info ("");
15579 }
15580
15581 time_t runtime_start;
15582
15583 time (&runtime_start);
15584
15585 data.runtime_start = runtime_start;
15586
15587 /**
15588 * create cracker threads
15589 */
15590
15591 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
15592
15593 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15594 {
15595 hc_device_param_t *device_param = &devices_param[device_id];
15596
15597 device_param->device_id = device_id;
15598
15599 if (wordlist_mode == WL_MODE_STDIN)
15600 {
15601 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
15602 }
15603 else
15604 {
15605 hc_thread_create (c_threads[device_id], thread_calc, device_param);
15606 }
15607 }
15608
15609 // wait for crack threads to exit
15610
15611 hc_thread_wait (devices_cnt, c_threads);
15612
15613 local_free (c_threads);
15614
15615 data.restore = 0;
15616
15617 // finalize task
15618
15619 logfile_sub_var_uint ("status-after-work", data.devices_status);
15620
15621 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
15622
15623 if (data.devices_status == STATUS_CRACKED) break;
15624 if (data.devices_status == STATUS_ABORTED) break;
15625
15626 if (data.devices_status == STATUS_BYPASS)
15627 {
15628 data.devices_status = STATUS_RUNNING;
15629 }
15630
15631 if (induction_dictionaries_cnt)
15632 {
15633 unlink (induction_dictionaries[0]);
15634 }
15635
15636 free (induction_dictionaries);
15637
15638 if (attack_mode != ATTACK_MODE_BF)
15639 {
15640 induction_dictionaries = scan_directory (induction_directory);
15641
15642 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15643 }
15644
15645 if (benchmark == 0)
15646 {
15647 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
15648 {
15649 if (quiet == 0) clear_prompt ();
15650
15651 if (quiet == 0) log_info ("");
15652
15653 if (status == 1)
15654 {
15655 status_display ();
15656 }
15657 else
15658 {
15659 if (quiet == 0) status_display ();
15660 }
15661
15662 if (quiet == 0) log_info ("");
15663 }
15664 }
15665
15666 if (attack_mode == ATTACK_MODE_BF)
15667 {
15668 dictpos++;
15669
15670 rd->dictpos = dictpos;
15671 }
15672 else
15673 {
15674 if (induction_dictionaries_cnt)
15675 {
15676 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15677 }
15678 else
15679 {
15680 dictpos++;
15681
15682 rd->dictpos = dictpos;
15683 }
15684 }
15685
15686 time_t runtime_stop;
15687
15688 time (&runtime_stop);
15689
15690 data.runtime_stop = runtime_stop;
15691
15692 logfile_sub_uint (runtime_start);
15693 logfile_sub_uint (runtime_stop);
15694
15695 logfile_sub_msg ("STOP");
15696
15697 global_free (subid);
15698 }
15699
15700 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
15701
15702 if (data.devices_status == STATUS_CRACKED) break;
15703 if (data.devices_status == STATUS_ABORTED) break;
15704 if (data.devices_status == STATUS_QUIT) break;
15705
15706 if (data.devices_status == STATUS_BYPASS)
15707 {
15708 data.devices_status = STATUS_RUNNING;
15709 }
15710 }
15711
15712 // 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
15713
15714 if (attack_mode == ATTACK_MODE_STRAIGHT)
15715 {
15716 if (data.wordlist_mode == WL_MODE_FILE)
15717 {
15718 if (data.dictfile == NULL)
15719 {
15720 if (dictfiles != NULL)
15721 {
15722 data.dictfile = dictfiles[0];
15723
15724 hc_timer_set (&data.timer_running);
15725 }
15726 }
15727 }
15728 }
15729 // NOTE: combi is okay because it is already set beforehand
15730 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
15731 {
15732 if (data.dictfile == NULL)
15733 {
15734 if (dictfiles != NULL)
15735 {
15736 hc_timer_set (&data.timer_running);
15737
15738 data.dictfile = dictfiles[0];
15739 }
15740 }
15741 }
15742 else if (attack_mode == ATTACK_MODE_BF)
15743 {
15744 if (data.mask == NULL)
15745 {
15746 hc_timer_set (&data.timer_running);
15747
15748 data.mask = masks[0];
15749 }
15750 }
15751
15752 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
15753 {
15754 data.devices_status = STATUS_EXHAUSTED;
15755 }
15756
15757 // if cracked / aborted remove last induction dictionary
15758
15759 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
15760 {
15761 struct stat induct_stat;
15762
15763 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
15764 {
15765 unlink (induction_dictionaries[file_pos]);
15766 }
15767 }
15768
15769 // wait for non-interactive threads
15770
15771 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
15772 {
15773 hc_thread_wait (1, &ni_threads[thread_idx]);
15774 }
15775
15776 local_free (ni_threads);
15777
15778 // wait for interactive threads
15779
15780 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15781 {
15782 hc_thread_wait (1, &i_thread);
15783 }
15784
15785 // we dont need restore file anymore
15786 if (data.restore_disable == 0)
15787 {
15788 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
15789 {
15790 unlink (eff_restore_file);
15791 unlink (new_restore_file);
15792 }
15793 else
15794 {
15795 cycle_restore ();
15796 }
15797 }
15798
15799 // finally save left hashes
15800
15801 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
15802 {
15803 save_hash ();
15804 }
15805
15806 /**
15807 * Clean up
15808 */
15809
15810 if (benchmark == 1)
15811 {
15812 status_benchmark ();
15813
15814 log_info ("");
15815 }
15816 else
15817 {
15818 if (quiet == 0) clear_prompt ();
15819
15820 if (quiet == 0) log_info ("");
15821
15822 if (status == 1)
15823 {
15824 status_display ();
15825 }
15826 else
15827 {
15828 if (quiet == 0) status_display ();
15829 }
15830
15831 if (quiet == 0) log_info ("");
15832 }
15833
15834 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15835 {
15836 hc_device_param_t *device_param = &data.devices_param[device_id];
15837
15838 local_free (device_param->result);
15839
15840 local_free (device_param->pw_caches);
15841
15842 local_free (device_param->combs_buf);
15843
15844 local_free (device_param->hooks_buf);
15845
15846 local_free (device_param->device_name);
15847
15848 local_free (device_param->device_version);
15849
15850 local_free (device_param->driver_version);
15851
15852 if (device_param->pws_buf) myfree (device_param->pws_buf);
15853 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
15854 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
15855 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
15856 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
15857 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
15858 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
15859 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
15860 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
15861 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
15862 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
15863 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
15864 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
15865 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
15866 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
15867 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
15868 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
15869 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
15870 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
15871 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
15872 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
15873 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
15874 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
15875 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
15876 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
15877 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
15878 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
15879 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
15880
15881 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
15882 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
15883 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
15884 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
15885 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
15886 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
15887 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
15888 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
15889
15890 if (device_param->program) hc_clReleaseProgram (device_param->program);
15891 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
15892 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
15893 if (device_param->context) hc_clReleaseContext (device_param->context);
15894 }
15895
15896 // reset default fan speed
15897
15898 if (gpu_temp_disable == 0)
15899 {
15900 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
15901 {
15902 hc_thread_mutex_lock (mux_adl);
15903
15904 for (uint i = 0; i < data.devices_cnt; i++)
15905 {
15906 if (data.hm_device[i].fan_supported == 1)
15907 {
15908 int fanspeed = temp_retain_fanspeed_value[i];
15909
15910 if (fanspeed == -1) continue;
15911
15912 int rc = hm_set_fanspeed_with_device_id_amd (i, fanspeed);
15913
15914 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", i);
15915 }
15916 }
15917
15918 hc_thread_mutex_unlock (mux_adl);
15919 }
15920 }
15921
15922 // reset power tuning
15923
15924 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
15925 {
15926 hc_thread_mutex_lock (mux_adl);
15927
15928 for (uint i = 0; i < data.devices_cnt; i++)
15929 {
15930 if (data.hm_device[i].od_version == 6)
15931 {
15932 // check powertune capabilities first, if not available then skip device
15933
15934 int powertune_supported = 0;
15935
15936 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
15937 {
15938 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15939
15940 return (-1);
15941 }
15942
15943 if (powertune_supported != 0)
15944 {
15945 // powercontrol settings
15946
15947 if ((hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, od_power_control_status[i])) != ADL_OK)
15948 {
15949 log_info ("ERROR: Failed to restore the ADL PowerControl values");
15950
15951 return (-1);
15952 }
15953
15954 // clocks
15955
15956 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15957
15958 performance_state->iNumberOfPerformanceLevels = 2;
15959
15960 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[i].state.aLevels[0].iEngineClock;
15961 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[i].state.aLevels[1].iEngineClock;
15962 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[i].state.aLevels[0].iMemoryClock;
15963 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[i].state.aLevels[1].iMemoryClock;
15964
15965 if ((hc_ADL_Overdrive_State_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
15966 {
15967 log_info ("ERROR: Failed to restore ADL performance state");
15968
15969 return (-1);
15970 }
15971
15972 local_free (performance_state);
15973 }
15974 }
15975 }
15976
15977 hc_thread_mutex_unlock (mux_adl);
15978 }
15979
15980 if (gpu_temp_disable == 0)
15981 {
15982 if (vendor_id == VENDOR_ID_NV)
15983 {
15984 #ifdef LINUX
15985 hc_NVML_nvmlShutdown (data.hm_dll);
15986 #endif
15987
15988 #ifdef WIN
15989 NvAPI_Unload ();
15990 #endif
15991 }
15992
15993 if (vendor_id == VENDOR_ID_AMD)
15994 {
15995 hc_ADL_Main_Control_Destroy (data.hm_dll);
15996
15997 hm_close (data.hm_dll);
15998 }
15999
16000 #ifdef LINUX
16001 if (vendor_id == VENDOR_ID_NV)
16002 {
16003 hm_close (data.hm_dll);
16004 }
16005 #endif
16006 }
16007
16008 // free memory
16009
16010 local_free (masks);
16011
16012 local_free (dictstat_base);
16013
16014 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16015 {
16016 pot_t *pot_ptr = &pot[pot_pos];
16017
16018 hash_t *hash = &pot_ptr->hash;
16019
16020 local_free (hash->digest);
16021
16022 if (isSalted)
16023 {
16024 local_free (hash->salt);
16025 }
16026 }
16027
16028 local_free (pot);
16029
16030 local_free (all_gpu_rules_cnt);
16031 local_free (all_gpu_rules_buf);
16032
16033 local_free (wl_data->buf);
16034 local_free (wl_data);
16035
16036 local_free (bitmap_s1_a);
16037 local_free (bitmap_s1_b);
16038 local_free (bitmap_s1_c);
16039 local_free (bitmap_s1_d);
16040 local_free (bitmap_s2_a);
16041 local_free (bitmap_s2_b);
16042 local_free (bitmap_s2_c);
16043 local_free (bitmap_s2_d);
16044
16045 local_free (temp_retain_fanspeed_value);
16046 local_free (od_clock_mem_status);
16047 local_free (od_power_control_status);
16048
16049 global_free (devices_param);
16050
16051 global_free (gpu_rules_buf);
16052
16053 global_free (root_css_buf);
16054 global_free (markov_css_buf);
16055
16056 global_free (digests_buf);
16057 global_free (digests_shown);
16058 global_free (digests_shown_tmp);
16059
16060 global_free (salts_buf);
16061 global_free (salts_shown);
16062
16063 global_free (esalts_buf);
16064
16065 global_free (words_progress_done);
16066 global_free (words_progress_rejected);
16067 global_free (words_progress_restored);
16068
16069 if (pot_fp) fclose (pot_fp);
16070
16071 if (data.devices_status == STATUS_QUIT) break;
16072 }
16073
16074 // destroy others mutex
16075
16076 hc_thread_mutex_delete (mux_dispatcher);
16077 hc_thread_mutex_delete (mux_counter);
16078 hc_thread_mutex_delete (mux_display);
16079 hc_thread_mutex_delete (mux_adl);
16080
16081 // free memory
16082
16083 local_free (eff_restore_file);
16084 local_free (new_restore_file);
16085
16086 local_free (rd);
16087
16088 // loopback
16089
16090 local_free (loopback_file);
16091
16092 if (loopback == 1) unlink (loopback_file);
16093
16094 // induction directory
16095
16096 if (induction_dir == NULL)
16097 {
16098 if (attack_mode != ATTACK_MODE_BF)
16099 {
16100 if (rmdir (induction_directory) == -1)
16101 {
16102 if (errno == ENOENT)
16103 {
16104 // good, we can ignore
16105 }
16106 else if (errno == ENOTEMPTY)
16107 {
16108 // good, we can ignore
16109 }
16110 else
16111 {
16112 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16113
16114 return (-1);
16115 }
16116 }
16117
16118 local_free (induction_directory);
16119 }
16120 }
16121
16122 // outfile-check directory
16123
16124 if (outfile_check_dir == NULL)
16125 {
16126 if (rmdir (outfile_check_directory) == -1)
16127 {
16128 if (errno == ENOENT)
16129 {
16130 // good, we can ignore
16131 }
16132 else if (errno == ENOTEMPTY)
16133 {
16134 // good, we can ignore
16135 }
16136 else
16137 {
16138 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16139
16140 return (-1);
16141 }
16142 }
16143
16144 local_free (outfile_check_directory);
16145 }
16146
16147 time_t proc_stop;
16148
16149 time (&proc_stop);
16150
16151 logfile_top_uint (proc_start);
16152 logfile_top_uint (proc_stop);
16153
16154 logfile_top_msg ("STOP");
16155
16156 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16157 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16158
16159 if (data.devices_status == STATUS_ABORTED) return 2;
16160 if (data.devices_status == STATUS_QUIT) return 2;
16161 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16162 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16163 if (data.devices_status == STATUS_CRACKED) return 0;
16164
16165 return -1;
16166 }
Hashcat additions to support pwdhash