projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Add -D short flag for --opencl-device-types
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define STDOUT_FLAG 0
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define MACHINE_READABLE 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define NVIDIA_SPIN_DAMP 100
79 #define GPU_TEMP_DISABLE 0
80 #define GPU_TEMP_ABORT 90
81 #define GPU_TEMP_RETAIN 65
82 #define WORKLOAD_PROFILE 2
83 #define KERNEL_ACCEL 0
84 #define KERNEL_LOOPS 0
85 #define KERNEL_RULES 1024
86 #define KERNEL_COMBS 1024
87 #define KERNEL_BFS 1024
88 #define KERNEL_THREADS_MAX 256
89 #define KERNEL_THREADS_MAX_CPU 16
90 #define POWERTUNE_ENABLE 0
91 #define LOGFILE_DISABLE 0
92 #define SCRYPT_TMTO 0
93 #define OPENCL_VECTOR_WIDTH 0
94
95 #define WL_MODE_STDIN 1
96 #define WL_MODE_FILE 2
97 #define WL_MODE_MASK 3
98
99 #define HL_MODE_FILE 4
100 #define HL_MODE_ARG 5
101
102 #define HLFMTS_CNT 11
103 #define HLFMT_HASHCAT 0
104 #define HLFMT_PWDUMP 1
105 #define HLFMT_PASSWD 2
106 #define HLFMT_SHADOW 3
107 #define HLFMT_DCC 4
108 #define HLFMT_DCC2 5
109 #define HLFMT_NETNTLM1 7
110 #define HLFMT_NETNTLM2 8
111 #define HLFMT_NSLDAP 9
112 #define HLFMT_NSLDAPS 10
113
114 #define HLFMT_TEXT_HASHCAT "native hashcat"
115 #define HLFMT_TEXT_PWDUMP "pwdump"
116 #define HLFMT_TEXT_PASSWD "passwd"
117 #define HLFMT_TEXT_SHADOW "shadow"
118 #define HLFMT_TEXT_DCC "DCC"
119 #define HLFMT_TEXT_DCC2 "DCC 2"
120 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
121 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
122 #define HLFMT_TEXT_NSLDAP "nsldap"
123 #define HLFMT_TEXT_NSLDAPS "nsldaps"
124
125 #define ATTACK_MODE_STRAIGHT 0
126 #define ATTACK_MODE_COMBI 1
127 #define ATTACK_MODE_TOGGLE 2
128 #define ATTACK_MODE_BF 3
129 #define ATTACK_MODE_PERM 4
130 #define ATTACK_MODE_TABLE 5
131 #define ATTACK_MODE_HYBRID1 6
132 #define ATTACK_MODE_HYBRID2 7
133 #define ATTACK_MODE_NONE 100
134
135 #define ATTACK_KERN_STRAIGHT 0
136 #define ATTACK_KERN_COMBI 1
137 #define ATTACK_KERN_BF 3
138 #define ATTACK_KERN_NONE 100
139
140 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
141 #define ATTACK_EXEC_INSIDE_KERNEL 11
142
143 #define COMBINATOR_MODE_BASE_LEFT 10001
144 #define COMBINATOR_MODE_BASE_RIGHT 10002
145
146 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
147 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
148
149 #define MAX_CUT_TRIES 4
150
151 #define MAX_DICTSTAT 10000
152
153 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
154
155 #define NVIDIA_100PERCENTCPU_WORKAROUND 100
156
157 #define global_free(attr) \
158 { \
159 myfree ((void *) data.attr); \
160 \
161 data.attr = NULL; \
162 }
163
164 #define local_free(attr) \
165 { \
166 myfree ((void *) attr); \
167 \
168 attr = NULL; \
169 }
170
171 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
172 #define HC_API_CALL __stdcall
173 #else
174 #define HC_API_CALL
175 #endif
176
177 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
178 {
179 900,
180 0,
181 5100,
182 100,
183 1400,
184 10800,
185 1700,
186 5000,
187 10100,
188 6000,
189 6100,
190 6900,
191 11700,
192 11800,
193 400,
194 8900,
195 11900,
196 12000,
197 10900,
198 12100,
199 23,
200 2500,
201 5300,
202 5400,
203 5500,
204 5600,
205 7300,
206 7500,
207 13100,
208 8300,
209 11100,
210 11200,
211 11400,
212 121,
213 2611,
214 2711,
215 2811,
216 8400,
217 11,
218 2612,
219 7900,
220 21,
221 11000,
222 124,
223 10000,
224 3711,
225 7600,
226 12,
227 131,
228 132,
229 1731,
230 200,
231 300,
232 3100,
233 112,
234 12300,
235 8000,
236 141,
237 1441,
238 1600,
239 12600,
240 1421,
241 101,
242 111,
243 1711,
244 3000,
245 1000,
246 1100,
247 2100,
248 12800,
249 1500,
250 12400,
251 500,
252 3200,
253 7400,
254 1800,
255 122,
256 1722,
257 7100,
258 6300,
259 6700,
260 6400,
261 6500,
262 2400,
263 2410,
264 5700,
265 9200,
266 9300,
267 22,
268 501,
269 5800,
270 8100,
271 8500,
272 7200,
273 9900,
274 7700,
275 7800,
276 10300,
277 8600,
278 8700,
279 9100,
280 133,
281 13500,
282 11600,
283 13600,
284 12500,
285 13000,
286 13200,
287 13300,
288 6211,
289 6221,
290 6231,
291 6241,
292 13711,
293 13721,
294 13731,
295 13741,
296 13751,
297 13761,
298 8800,
299 12900,
300 12200,
301 9700,
302 9710,
303 9800,
304 9810,
305 9400,
306 9500,
307 9600,
308 10400,
309 10410,
310 10500,
311 10600,
312 10700,
313 9000,
314 5200,
315 6800,
316 6600,
317 8200,
318 11300,
319 12700,
320 13400,
321 125
322 };
323
324 /**
325 * types
326 */
327
328 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
329
330 /**
331 * globals
332 */
333
334 static unsigned int full01 = 0x01010101;
335 static unsigned int full80 = 0x80808080;
336
337 int SUPPRESS_OUTPUT = 0;
338
339 hc_thread_mutex_t mux_adl;
340 hc_thread_mutex_t mux_counter;
341 hc_thread_mutex_t mux_dispatcher;
342 hc_thread_mutex_t mux_display;
343
344 hc_global_data_t data;
345
346 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
347
348 const char *USAGE_MINI[] =
349 {
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "Try --help for more help.",
353 NULL
354 };
355
356 const char *USAGE_BIG[] =
357 {
358 "%s, advanced password recovery",
359 "",
360 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
361 "",
362 "- [ Options ] -",
363 "",
364 " Options Short / Long | Type | Description | Example",
365 "===============================|======|======================================================|=======================",
366 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
367 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
368 " -V, --version | | Print version |",
369 " -h, --help | | Print help |",
370 " --quiet | | Suppress output |",
371 " --hex-charset | | Assume charset is given in hex |",
372 " --hex-salt | | Assume salt is given in hex |",
373 " --hex-wordlist | | Assume words in wordlist is given in hex |",
374 " --force | | Ignore warnings |",
375 " --status | | Enable automatic update of the status-screen |",
376 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
377 " --machine-readable | | Display the status view in a machine readable format |",
378 " --loopback | | Add new plains to induct directory |",
379 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
380 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
381 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
382 " --markov-classic | | Enables classic markov-chains, no per-position |",
383 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
384 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
385 " --session | Str | Define specific session name | --session=mysession",
386 " --restore | | Restore session from --session |",
387 " --restore-disable | | Do not write restore file |",
388 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
389 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
390 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
391 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
392 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
393 " --stdout | | Do not crack a hash, instead print candidates only |",
394 " --show | | Show cracked passwords only |",
395 " --left | | Show un-cracked passwords only |",
396 " --username | | Enable ignoring of usernames in hashfile |",
397 " --remove | | Enable remove of hash once it is cracked |",
398 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
399 " --potfile-disable | | Do not write potfile |",
400 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
401 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
402 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
403 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
404 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
405 " --logfile-disable | | Disable the logfile |",
406 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
407 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
408 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
409 " -b, --benchmark | | Run benchmark |",
410 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
411 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
412 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
413 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
414 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
415 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
416 " -D, --opencl-device-types | Str | OpenCL device-types to use, separate with comma | -D 1",
417 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
418 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
419 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
420 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
421 " --nvidia-spin-damp | Num | Workaround NVidias CPU burning loop bug, in percent | --nvidia-spin-damp=50",
422 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
423 #ifdef HAVE_HWMON
424 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
425 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
426 " --powertune-enable | | Enable power tuning, restores settings when finished |",
427 #endif
428 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
429 " -s, --skip | Num | Skip X words from the start | -s 1000000",
430 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
431 " --keyspace | | Show keyspace base:mod values and quit |",
432 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
433 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
434 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
435 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
436 " --generate-rules-func-min | Num | Force min X funcs per rule |",
437 " --generate-rules-func-max | Num | Force max X funcs per rule |",
438 " --generate-rules-seed | Num | Force RNG seed set to X |",
439 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
440 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
441 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
442 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
443 " -i, --increment | | Enable mask increment mode |",
444 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
445 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
446 "",
447 "- [ Hash modes ] -",
448 "",
449 " # | Name | Category",
450 " ======+==================================================+======================================",
451 " 900 | MD4 | Raw Hash",
452 " 0 | MD5 | Raw Hash",
453 " 5100 | Half MD5 | Raw Hash",
454 " 100 | SHA1 | Raw Hash",
455 " 10800 | SHA-384 | Raw Hash",
456 " 1400 | SHA-256 | Raw Hash",
457 " 1700 | SHA-512 | Raw Hash",
458 " 5000 | SHA-3(Keccak) | Raw Hash",
459 " 10100 | SipHash | Raw Hash",
460 " 6000 | RipeMD160 | Raw Hash",
461 " 6100 | Whirlpool | Raw Hash",
462 " 6900 | GOST R 34.11-94 | Raw Hash",
463 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
464 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
465 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
466 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
467 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
468 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
469 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
470 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
471 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
472 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
473 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
474 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
475 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
476 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
477 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
478 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
479 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
480 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
481 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
482 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
483 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
484 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
485 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
486 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
487 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
488 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
489 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
490 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
491 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
492 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
493 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
494 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
495 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
496 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
497 " 400 | phpass | Generic KDF",
498 " 8900 | scrypt | Generic KDF",
499 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
500 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
501 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
502 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
503 " 23 | Skype | Network protocols",
504 " 2500 | WPA/WPA2 | Network protocols",
505 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
506 " 5300 | IKE-PSK MD5 | Network protocols",
507 " 5400 | IKE-PSK SHA1 | Network protocols",
508 " 5500 | NetNTLMv1 | Network protocols",
509 " 5500 | NetNTLMv1 + ESS | Network protocols",
510 " 5600 | NetNTLMv2 | Network protocols",
511 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
512 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
513 " 8300 | DNSSEC (NSEC3) | Network protocols",
514 " 10200 | Cram MD5 | Network protocols",
515 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
516 " 11200 | MySQL CRAM (SHA1) | Network protocols",
517 " 11400 | SIP digest authentication (MD5) | Network protocols",
518 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
519 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
520 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
521 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
522 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
523 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
524 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
525 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
526 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
527 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
528 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
529 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
530 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
531 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
532 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
533 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
534 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
535 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
536 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
537 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
538 " 12 | PostgreSQL | Database Server",
539 " 131 | MSSQL(2000) | Database Server",
540 " 132 | MSSQL(2005) | Database Server",
541 " 1731 | MSSQL(2012) | Database Server",
542 " 1731 | MSSQL(2014) | Database Server",
543 " 200 | MySQL323 | Database Server",
544 " 300 | MySQL4.1/MySQL5 | Database Server",
545 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
546 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
547 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
548 " 8000 | Sybase ASE | Database Server",
549 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
550 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
551 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
552 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
553 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
554 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
555 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
556 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
557 " 11500 | CRC32 | Checksums",
558 " 3000 | LM | Operating-Systems",
559 " 1000 | NTLM | Operating-Systems",
560 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
561 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
562 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
563 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
564 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
565 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
566 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
567 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
568 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
569 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
570 " 1722 | OSX v10.7 | Operating-Systems",
571 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
572 " 6300 | AIX {smd5} | Operating-Systems",
573 " 6700 | AIX {ssha1} | Operating-Systems",
574 " 6400 | AIX {ssha256} | Operating-Systems",
575 " 6500 | AIX {ssha512} | Operating-Systems",
576 " 2400 | Cisco-PIX | Operating-Systems",
577 " 2410 | Cisco-ASA | Operating-Systems",
578 " 500 | Cisco-IOS $1$ | Operating-Systems",
579 " 5700 | Cisco-IOS $4$ | Operating-Systems",
580 " 9200 | Cisco-IOS $8$ | Operating-Systems",
581 " 9300 | Cisco-IOS $9$ | Operating-Systems",
582 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
583 " 501 | Juniper IVE | Operating-Systems",
584 " 5800 | Android PIN | Operating-Systems",
585 " 13800 | Windows 8+ phone PIN/Password | Operating-Systems",
586 " 8100 | Citrix Netscaler | Operating-Systems",
587 " 8500 | RACF | Operating-Systems",
588 " 7200 | GRUB 2 | Operating-Systems",
589 " 9900 | Radmin2 | Operating-Systems",
590 " 125 | ArubaOS | Operating-Systems",
591 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
592 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
593 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
594 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
595 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
596 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
597 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
598 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
599 " 11600 | 7-Zip | Archives",
600 " 12500 | RAR3-hp | Archives",
601 " 13000 | RAR5 | Archives",
602 " 13200 | AxCrypt | Archives",
603 " 13300 | AxCrypt in memory SHA1 | Archives",
604 " 13600 | WinZip | Archives",
605 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
606 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
607 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
608 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
609 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
610 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
611 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
612 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
613 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
614 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
615 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
616 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
617 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
618 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
619 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
620 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
621 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
622 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
623 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
624 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
625 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
626 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
627 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
628 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
629 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
630 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
631 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
632 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
633 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
634 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
635 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
636 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
637 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
638 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
639 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
640 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
641 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
642 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
643 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
644 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
645 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
646 " 9400 | MS Office 2007 | Documents",
647 " 9500 | MS Office 2010 | Documents",
648 " 9600 | MS Office 2013 | Documents",
649 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
650 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
651 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
652 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
653 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
654 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
655 " 9000 | Password Safe v2 | Password Managers",
656 " 5200 | Password Safe v3 | Password Managers",
657 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
658 " 6600 | 1Password, agilekeychain | Password Managers",
659 " 8200 | 1Password, cloudkeychain | Password Managers",
660 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
661 " 12700 | Blockchain, My Wallet | Password Managers",
662 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
663 "",
664 "- [ Outfile Formats ] -",
665 "",
666 " # | Format",
667 " ===+========",
668 " 1 | hash[:salt]",
669 " 2 | plain",
670 " 3 | hash[:salt]:plain",
671 " 4 | hex_plain",
672 " 5 | hash[:salt]:hex_plain",
673 " 6 | plain:hex_plain",
674 " 7 | hash[:salt]:plain:hex_plain",
675 " 8 | crackpos",
676 " 9 | hash[:salt]:crack_pos",
677 " 10 | plain:crack_pos",
678 " 11 | hash[:salt]:plain:crack_pos",
679 " 12 | hex_plain:crack_pos",
680 " 13 | hash[:salt]:hex_plain:crack_pos",
681 " 14 | plain:hex_plain:crack_pos",
682 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
683 "",
684 "- [ Rule Debugging Modes ] -",
685 "",
686 " # | Format",
687 " ===+========",
688 " 1 | Finding-Rule",
689 " 2 | Original-Word",
690 " 3 | Original-Word:Finding-Rule",
691 " 4 | Original-Word:Finding-Rule:Processed-Word",
692 "",
693 "- [ Attack Modes ] -",
694 "",
695 " # | Mode",
696 " ===+======",
697 " 0 | Straight",
698 " 1 | Combination",
699 " 3 | Brute-force",
700 " 6 | Hybrid Wordlist + Mask",
701 " 7 | Hybrid Mask + Wordlist",
702 "",
703 "- [ Built-in Charsets ] -",
704 "",
705 " ? | Charset",
706 " ===+=========",
707 " l | abcdefghijklmnopqrstuvwxyz",
708 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
709 " d | 0123456789",
710 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
711 " a | ?l?u?d?s",
712 " b | 0x00 - 0xff",
713 "",
714 "- [ OpenCL Device Types ] -",
715 "",
716 " # | Device Type",
717 " ===+=============",
718 " 1 | CPU",
719 " 2 | GPU",
720 " 3 | FPGA, DSP, Co-Processor",
721 "",
722 "- [ Workload Profiles ] -",
723 "",
724 " # | Performance | Runtime | Power Consumption | Desktop Impact",
725 " ===+=============+=========+===================+=================",
726 " 1 | Low | 2 ms | Low | Minimal",
727 " 2 | Default | 12 ms | Economic | Noticeable",
728 " 3 | High | 96 ms | High | Unresponsive",
729 " 4 | Nightmare | 480 ms | Insane | Headless",
730 "",
731 "If you have no idea what just happened then visit the following pages:",
732 "",
733 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
734 "* https://hashcat.net/wiki/#frequently_asked_questions",
735 "",
736 NULL
737 };
738
739 /**
740 * hashcat specific functions
741 */
742
743 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
744 {
745 int exec_pos = (int) device_param->exec_pos - last_num_entries;
746
747 if (exec_pos < 0) exec_pos += EXEC_CACHE;
748
749 double exec_ms_sum = 0;
750
751 int exec_ms_cnt = 0;
752
753 for (int i = 0; i < last_num_entries; i++)
754 {
755 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
756
757 if (exec_ms)
758 {
759 exec_ms_sum += exec_ms;
760
761 exec_ms_cnt++;
762 }
763 }
764
765 if (exec_ms_cnt == 0) return 0;
766
767 return exec_ms_sum / exec_ms_cnt;
768 }
769
770 void status_display_machine_readable ()
771 {
772 FILE *out = stdout;
773
774 fprintf (out, "STATUS\t%u\t", data.devices_status);
775
776 /**
777 * speed new
778 */
779
780 fprintf (out, "SPEED\t");
781
782 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
783 {
784 hc_device_param_t *device_param = &data.devices_param[device_id];
785
786 if (device_param->skipped) continue;
787
788 u64 speed_cnt = 0;
789 double speed_ms = 0;
790
791 for (int i = 0; i < SPEED_CACHE; i++)
792 {
793 speed_cnt += device_param->speed_cnt[i];
794 speed_ms += device_param->speed_ms[i];
795 }
796
797 speed_cnt /= SPEED_CACHE;
798 speed_ms /= SPEED_CACHE;
799
800 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
801 }
802
803 /**
804 * exec time
805 */
806
807 fprintf (out, "EXEC_RUNTIME\t");
808
809 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
810 {
811 hc_device_param_t *device_param = &data.devices_param[device_id];
812
813 if (device_param->skipped) continue;
814
815 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
816
817 fprintf (out, "%f\t", exec_ms_avg);
818 }
819
820 /**
821 * words_cur
822 */
823
824 u64 words_cur = get_lowest_words_done ();
825
826 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
827
828 /**
829 * counter
830 */
831
832 u64 progress_total = data.words_cnt * data.salts_cnt;
833
834 u64 all_done = 0;
835 u64 all_rejected = 0;
836 u64 all_restored = 0;
837
838 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
839 {
840 all_done += data.words_progress_done[salt_pos];
841 all_rejected += data.words_progress_rejected[salt_pos];
842 all_restored += data.words_progress_restored[salt_pos];
843 }
844
845 u64 progress_cur = all_restored + all_done + all_rejected;
846 u64 progress_end = progress_total;
847
848 u64 progress_skip = 0;
849
850 if (data.skip)
851 {
852 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
853
854 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
855 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
856 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
857 }
858
859 if (data.limit)
860 {
861 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
862
863 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
864 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
865 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
866 }
867
868 u64 progress_cur_relative_skip = progress_cur - progress_skip;
869 u64 progress_end_relative_skip = progress_end - progress_skip;
870
871 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
872
873 /**
874 * cracks
875 */
876
877 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
878 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
879
880 /**
881 * temperature
882 */
883
884 #ifdef HAVE_HWMON
885 if (data.gpu_temp_disable == 0)
886 {
887 fprintf (out, "TEMP\t");
888
889 hc_thread_mutex_lock (mux_adl);
890
891 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
892 {
893 hc_device_param_t *device_param = &data.devices_param[device_id];
894
895 if (device_param->skipped) continue;
896
897 int temp = hm_get_temperature_with_device_id (device_id);
898
899 fprintf (out, "%d\t", temp);
900 }
901
902 hc_thread_mutex_unlock (mux_adl);
903 }
904 #endif // HAVE_HWMON
905
906 /**
907 * flush
908 */
909
910 #ifdef _WIN
911 fputc ('\r', out);
912 fputc ('\n', out);
913 #endif
914
915 #ifdef _POSIX
916 fputc ('\n', out);
917 #endif
918
919 fflush (out);
920 }
921
922 void status_display ()
923 {
924 if (data.devices_status == STATUS_INIT) return;
925 if (data.devices_status == STATUS_STARTING) return;
926 if (data.devices_status == STATUS_BYPASS) return;
927
928 if (data.machine_readable == 1)
929 {
930 status_display_machine_readable ();
931
932 return;
933 }
934
935 char tmp_buf[1000] = { 0 };
936
937 uint tmp_len = 0;
938
939 log_info ("Session.Name...: %s", data.session);
940
941 char *status_type = strstatus (data.devices_status);
942
943 uint hash_mode = data.hash_mode;
944
945 char *hash_type = strhashtype (hash_mode); // not a bug
946
947 log_info ("Status.........: %s", status_type);
948
949 /**
950 * show rules
951 */
952
953 if (data.rp_files_cnt)
954 {
955 uint i;
956
957 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
958 {
959 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
960 }
961
962 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
963
964 log_info ("Rules.Type.....: %s", tmp_buf);
965
966 tmp_len = 0;
967 }
968
969 if (data.rp_gen)
970 {
971 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
972
973 if (data.rp_gen_seed)
974 {
975 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
976 }
977 }
978
979 /**
980 * show input
981 */
982
983 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
984 {
985 if (data.wordlist_mode == WL_MODE_FILE)
986 {
987 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
988 }
989 else if (data.wordlist_mode == WL_MODE_STDIN)
990 {
991 log_info ("Input.Mode.....: Pipe");
992 }
993 }
994 else if (data.attack_mode == ATTACK_MODE_COMBI)
995 {
996 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
997 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
998 }
999 else if (data.attack_mode == ATTACK_MODE_BF)
1000 {
1001 char *mask = data.mask;
1002
1003 if (mask != NULL)
1004 {
1005 uint mask_len = data.css_cnt;
1006
1007 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1008
1009 if (mask_len > 0)
1010 {
1011 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1012 {
1013 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1014 {
1015 mask_len -= data.salts_buf[0].salt_len;
1016 }
1017 }
1018
1019 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1020
1021 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1022 }
1023
1024 if (data.maskcnt > 1)
1025 {
1026 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1027
1028 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1029 }
1030
1031 log_info ("Input.Mode.....: %s", tmp_buf);
1032 }
1033
1034 tmp_len = 0;
1035 }
1036 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1037 {
1038 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1039 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1040 }
1041 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1042 {
1043 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1044 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1045 }
1046
1047 if (data.digests_cnt == 1)
1048 {
1049 if (data.hash_mode == 2500)
1050 {
1051 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1052
1053 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1054 (char *) data.salts_buf[0].salt_buf,
1055 wpa->orig_mac1[0],
1056 wpa->orig_mac1[1],
1057 wpa->orig_mac1[2],
1058 wpa->orig_mac1[3],
1059 wpa->orig_mac1[4],
1060 wpa->orig_mac1[5],
1061 wpa->orig_mac2[0],
1062 wpa->orig_mac2[1],
1063 wpa->orig_mac2[2],
1064 wpa->orig_mac2[3],
1065 wpa->orig_mac2[4],
1066 wpa->orig_mac2[5]);
1067 }
1068 else if (data.hash_mode == 5200)
1069 {
1070 log_info ("Hash.Target....: File (%s)", data.hashfile);
1071 }
1072 else if (data.hash_mode == 9000)
1073 {
1074 log_info ("Hash.Target....: File (%s)", data.hashfile);
1075 }
1076 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1077 {
1078 log_info ("Hash.Target....: File (%s)", data.hashfile);
1079 }
1080 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1081 {
1082 log_info ("Hash.Target....: File (%s)", data.hashfile);
1083 }
1084 else
1085 {
1086 char out_buf[HCBUFSIZ] = { 0 };
1087
1088 ascii_digest (out_buf, 0, 0);
1089
1090 // limit length
1091 if (strlen (out_buf) > 40)
1092 {
1093 out_buf[41] = '.';
1094 out_buf[42] = '.';
1095 out_buf[43] = '.';
1096 out_buf[44] = 0;
1097 }
1098
1099 log_info ("Hash.Target....: %s", out_buf);
1100 }
1101 }
1102 else
1103 {
1104 if (data.hash_mode == 3000)
1105 {
1106 char out_buf1[32] = { 0 };
1107 char out_buf2[32] = { 0 };
1108
1109 ascii_digest (out_buf1, 0, 0);
1110 ascii_digest (out_buf2, 0, 1);
1111
1112 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1113 }
1114 else
1115 {
1116 log_info ("Hash.Target....: File (%s)", data.hashfile);
1117 }
1118 }
1119
1120 log_info ("Hash.Type......: %s", hash_type);
1121
1122 /**
1123 * speed new
1124 */
1125
1126 u64 speed_cnt[DEVICES_MAX] = { 0 };
1127 double speed_ms[DEVICES_MAX] = { 0 };
1128
1129 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1130 {
1131 hc_device_param_t *device_param = &data.devices_param[device_id];
1132
1133 if (device_param->skipped) continue;
1134
1135 speed_cnt[device_id] = 0;
1136 speed_ms[device_id] = 0;
1137
1138 for (int i = 0; i < SPEED_CACHE; i++)
1139 {
1140 speed_cnt[device_id] += device_param->speed_cnt[i];
1141 speed_ms[device_id] += device_param->speed_ms[i];
1142 }
1143
1144 speed_cnt[device_id] /= SPEED_CACHE;
1145 speed_ms[device_id] /= SPEED_CACHE;
1146 }
1147
1148 double hashes_all_ms = 0;
1149
1150 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1151
1152 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1153 {
1154 hc_device_param_t *device_param = &data.devices_param[device_id];
1155
1156 if (device_param->skipped) continue;
1157
1158 hashes_dev_ms[device_id] = 0;
1159
1160 if (speed_ms[device_id])
1161 {
1162 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1163
1164 hashes_all_ms += hashes_dev_ms[device_id];
1165 }
1166 }
1167
1168 /**
1169 * exec time
1170 */
1171
1172 double exec_all_ms[DEVICES_MAX] = { 0 };
1173
1174 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1175 {
1176 hc_device_param_t *device_param = &data.devices_param[device_id];
1177
1178 if (device_param->skipped) continue;
1179
1180 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1181
1182 exec_all_ms[device_id] = exec_ms_avg;
1183 }
1184
1185 /**
1186 * timers
1187 */
1188
1189 double ms_running = 0;
1190
1191 hc_timer_get (data.timer_running, ms_running);
1192
1193 double ms_paused = data.ms_paused;
1194
1195 if (data.devices_status == STATUS_PAUSED)
1196 {
1197 double ms_paused_tmp = 0;
1198
1199 hc_timer_get (data.timer_paused, ms_paused_tmp);
1200
1201 ms_paused += ms_paused_tmp;
1202 }
1203
1204 #ifdef WIN
1205
1206 __time64_t sec_run = ms_running / 1000;
1207
1208 #else
1209
1210 time_t sec_run = ms_running / 1000;
1211
1212 #endif
1213
1214 if (sec_run)
1215 {
1216 char display_run[32] = { 0 };
1217
1218 struct tm tm_run;
1219
1220 struct tm *tmp = NULL;
1221
1222 #ifdef WIN
1223
1224 tmp = _gmtime64 (&sec_run);
1225
1226 #else
1227
1228 tmp = gmtime (&sec_run);
1229
1230 #endif
1231
1232 if (tmp != NULL)
1233 {
1234 memset (&tm_run, 0, sizeof (tm_run));
1235
1236 memcpy (&tm_run, tmp, sizeof (tm_run));
1237
1238 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1239
1240 char *start = ctime (&data.proc_start);
1241
1242 size_t start_len = strlen (start);
1243
1244 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1245 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1246
1247 log_info ("Time.Started...: %s (%s)", start, display_run);
1248 }
1249 }
1250 else
1251 {
1252 log_info ("Time.Started...: 0 secs");
1253 }
1254
1255 /**
1256 * counters
1257 */
1258
1259 u64 progress_total = data.words_cnt * data.salts_cnt;
1260
1261 u64 all_done = 0;
1262 u64 all_rejected = 0;
1263 u64 all_restored = 0;
1264
1265 u64 progress_noneed = 0;
1266
1267 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1268 {
1269 all_done += data.words_progress_done[salt_pos];
1270 all_rejected += data.words_progress_rejected[salt_pos];
1271 all_restored += data.words_progress_restored[salt_pos];
1272
1273 // Important for ETA only
1274
1275 if (data.salts_shown[salt_pos] == 1)
1276 {
1277 const u64 all = data.words_progress_done[salt_pos]
1278 + data.words_progress_rejected[salt_pos]
1279 + data.words_progress_restored[salt_pos];
1280
1281 const u64 left = data.words_cnt - all;
1282
1283 progress_noneed += left;
1284 }
1285 }
1286
1287 u64 progress_cur = all_restored + all_done + all_rejected;
1288 u64 progress_end = progress_total;
1289
1290 u64 progress_skip = 0;
1291
1292 if (data.skip)
1293 {
1294 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1295
1296 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1297 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1298 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1299 }
1300
1301 if (data.limit)
1302 {
1303 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1304
1305 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1306 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1307 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1308 }
1309
1310 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1311 u64 progress_end_relative_skip = progress_end - progress_skip;
1312
1313 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1314 {
1315 if (data.devices_status != STATUS_CRACKED)
1316 {
1317 #ifdef WIN
1318 __time64_t sec_etc = 0;
1319 #else
1320 time_t sec_etc = 0;
1321 #endif
1322
1323 if (hashes_all_ms)
1324 {
1325 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1326
1327 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1328
1329 sec_etc = ms_left / 1000;
1330 }
1331
1332 if (sec_etc == 0)
1333 {
1334 //log_info ("Time.Estimated.: 0 secs");
1335 }
1336 else if ((u64) sec_etc > ETC_MAX)
1337 {
1338 log_info ("Time.Estimated.: > 10 Years");
1339 }
1340 else
1341 {
1342 char display_etc[32] = { 0 };
1343
1344 struct tm tm_etc;
1345
1346 struct tm *tmp = NULL;
1347
1348 #ifdef WIN
1349
1350 tmp = _gmtime64 (&sec_etc);
1351
1352 #else
1353
1354 tmp = gmtime (&sec_etc);
1355
1356 #endif
1357
1358 if (tmp != NULL)
1359 {
1360 memset (&tm_etc, 0, sizeof (tm_etc));
1361
1362 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1363
1364 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1365
1366 time_t now;
1367
1368 time (&now);
1369
1370 now += sec_etc;
1371
1372 char *etc = ctime (&now);
1373
1374 size_t etc_len = strlen (etc);
1375
1376 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1377 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1378
1379 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1380 }
1381 }
1382 }
1383 }
1384
1385 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1386 {
1387 hc_device_param_t *device_param = &data.devices_param[device_id];
1388
1389 if (device_param->skipped) continue;
1390
1391 char display_dev_cur[16] = { 0 };
1392
1393 strncpy (display_dev_cur, "0.00", 4);
1394
1395 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1396
1397 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1398 }
1399
1400 char display_all_cur[16] = { 0 };
1401
1402 strncpy (display_all_cur, "0.00", 4);
1403
1404 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1405
1406 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1407
1408 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1409 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1410
1411 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);
1412
1413 // crack-per-time
1414
1415 if (data.digests_cnt > 100)
1416 {
1417 time_t now = time (NULL);
1418
1419 int cpt_cur_min = 0;
1420 int cpt_cur_hour = 0;
1421 int cpt_cur_day = 0;
1422
1423 for (int i = 0; i < CPT_BUF; i++)
1424 {
1425 const uint cracked = data.cpt_buf[i].cracked;
1426 const time_t timestamp = data.cpt_buf[i].timestamp;
1427
1428 if ((timestamp + 60) > now)
1429 {
1430 cpt_cur_min += cracked;
1431 }
1432
1433 if ((timestamp + 3600) > now)
1434 {
1435 cpt_cur_hour += cracked;
1436 }
1437
1438 if ((timestamp + 86400) > now)
1439 {
1440 cpt_cur_day += cracked;
1441 }
1442 }
1443
1444 double ms_real = ms_running - ms_paused;
1445
1446 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1447 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1448 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1449
1450 if ((data.cpt_start + 86400) < now)
1451 {
1452 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1453 cpt_cur_min,
1454 cpt_cur_hour,
1455 cpt_cur_day,
1456 cpt_avg_min,
1457 cpt_avg_hour,
1458 cpt_avg_day);
1459 }
1460 else if ((data.cpt_start + 3600) < now)
1461 {
1462 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1463 cpt_cur_min,
1464 cpt_cur_hour,
1465 cpt_avg_min,
1466 cpt_avg_hour,
1467 cpt_avg_day);
1468 }
1469 else if ((data.cpt_start + 60) < now)
1470 {
1471 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1472 cpt_cur_min,
1473 cpt_avg_min,
1474 cpt_avg_hour,
1475 cpt_avg_day);
1476 }
1477 else
1478 {
1479 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1480 cpt_avg_min,
1481 cpt_avg_hour,
1482 cpt_avg_day);
1483 }
1484 }
1485
1486 // Restore point
1487
1488 u64 restore_point = get_lowest_words_done ();
1489
1490 u64 restore_total = data.words_base;
1491
1492 float percent_restore = 0;
1493
1494 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1495
1496 if (progress_end_relative_skip)
1497 {
1498 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1499 {
1500 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1501 float percent_rejected = 0.0;
1502
1503 if (progress_cur)
1504 {
1505 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1506 }
1507
1508 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);
1509 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1510
1511 if (data.restore_disable == 0)
1512 {
1513 if (percent_finished != 1)
1514 {
1515 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1516 }
1517 }
1518 }
1519 }
1520 else
1521 {
1522 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1523 {
1524 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1525 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1526
1527 if (data.restore_disable == 0)
1528 {
1529 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1530 }
1531 }
1532 else
1533 {
1534 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1535 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1536
1537 // --restore not allowed if stdin is used -- really? why?
1538
1539 //if (data.restore_disable == 0)
1540 //{
1541 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1542 //}
1543 }
1544 }
1545
1546 #ifdef HAVE_HWMON
1547
1548 if (data.devices_status == STATUS_EXHAUSTED) return;
1549 if (data.devices_status == STATUS_CRACKED) return;
1550 if (data.devices_status == STATUS_ABORTED) return;
1551 if (data.devices_status == STATUS_QUIT) return;
1552
1553 if (data.gpu_temp_disable == 0)
1554 {
1555 hc_thread_mutex_lock (mux_adl);
1556
1557 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1558 {
1559 hc_device_param_t *device_param = &data.devices_param[device_id];
1560
1561 if (device_param->skipped) continue;
1562
1563 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1564 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1565 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1566 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1567 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1568 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1569 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1570
1571 char output_buf[256] = { 0 };
1572
1573 int output_len = 0;
1574
1575 if (num_temperature >= 0)
1576 {
1577 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1578
1579 output_len = strlen (output_buf);
1580 }
1581
1582 if (num_fanspeed >= 0)
1583 {
1584 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1585
1586 output_len = strlen (output_buf);
1587 }
1588
1589 if (num_utilization >= 0)
1590 {
1591 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1592
1593 output_len = strlen (output_buf);
1594 }
1595
1596 if (num_corespeed >= 0)
1597 {
1598 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1599
1600 output_len = strlen (output_buf);
1601 }
1602
1603 if (num_memoryspeed >= 0)
1604 {
1605 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1606
1607 output_len = strlen (output_buf);
1608 }
1609
1610 if (num_buslanes >= 0)
1611 {
1612 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1613
1614 output_len = strlen (output_buf);
1615 }
1616
1617 if (num_throttle == 1)
1618 {
1619 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1620
1621 output_len = strlen (output_buf);
1622 }
1623
1624 if (output_len == 0)
1625 {
1626 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1627
1628 output_len = strlen (output_buf);
1629 }
1630
1631 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1632 }
1633
1634 hc_thread_mutex_unlock (mux_adl);
1635 }
1636
1637 #endif // HAVE_HWMON
1638 }
1639
1640 static void status_benchmark_automate ()
1641 {
1642 u64 speed_cnt[DEVICES_MAX] = { 0 };
1643 double speed_ms[DEVICES_MAX] = { 0 };
1644
1645 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1646 {
1647 hc_device_param_t *device_param = &data.devices_param[device_id];
1648
1649 if (device_param->skipped) continue;
1650
1651 speed_cnt[device_id] = device_param->speed_cnt[0];
1652 speed_ms[device_id] = device_param->speed_ms[0];
1653 }
1654
1655 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1656
1657 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1658 {
1659 hc_device_param_t *device_param = &data.devices_param[device_id];
1660
1661 if (device_param->skipped) continue;
1662
1663 hashes_dev_ms[device_id] = 0;
1664
1665 if (speed_ms[device_id])
1666 {
1667 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1668 }
1669 }
1670
1671 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1672 {
1673 hc_device_param_t *device_param = &data.devices_param[device_id];
1674
1675 if (device_param->skipped) continue;
1676
1677 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1678 }
1679 }
1680
1681 static void status_benchmark ()
1682 {
1683 if (data.devices_status == STATUS_INIT) return;
1684 if (data.devices_status == STATUS_STARTING) return;
1685 if (data.devices_status == STATUS_BYPASS) return;
1686
1687 if (data.machine_readable == 1)
1688 {
1689 status_benchmark_automate ();
1690
1691 return;
1692 }
1693
1694 u64 speed_cnt[DEVICES_MAX] = { 0 };
1695 double speed_ms[DEVICES_MAX] = { 0 };
1696
1697 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1698 {
1699 hc_device_param_t *device_param = &data.devices_param[device_id];
1700
1701 if (device_param->skipped) continue;
1702
1703 speed_cnt[device_id] = device_param->speed_cnt[0];
1704 speed_ms[device_id] = device_param->speed_ms[0];
1705 }
1706
1707 double hashes_all_ms = 0;
1708
1709 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1710
1711 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1712 {
1713 hc_device_param_t *device_param = &data.devices_param[device_id];
1714
1715 if (device_param->skipped) continue;
1716
1717 hashes_dev_ms[device_id] = 0;
1718
1719 if (speed_ms[device_id])
1720 {
1721 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1722
1723 hashes_all_ms += hashes_dev_ms[device_id];
1724 }
1725 }
1726
1727 /**
1728 * exec time
1729 */
1730
1731 double exec_all_ms[DEVICES_MAX] = { 0 };
1732
1733 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1734 {
1735 hc_device_param_t *device_param = &data.devices_param[device_id];
1736
1737 if (device_param->skipped) continue;
1738
1739 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1740
1741 exec_all_ms[device_id] = exec_ms_avg;
1742 }
1743
1744 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1745 {
1746 hc_device_param_t *device_param = &data.devices_param[device_id];
1747
1748 if (device_param->skipped) continue;
1749
1750 char display_dev_cur[16] = { 0 };
1751
1752 strncpy (display_dev_cur, "0.00", 4);
1753
1754 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1755
1756 if (data.devices_active >= 10)
1757 {
1758 log_info ("Speed.Dev.#%d: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1759 }
1760 else
1761 {
1762 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1763 }
1764 }
1765
1766 char display_all_cur[16] = { 0 };
1767
1768 strncpy (display_all_cur, "0.00", 4);
1769
1770 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1771
1772 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1773 }
1774
1775 /**
1776 * hashcat -only- functions
1777 */
1778
1779 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1780 {
1781 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1782 {
1783 if (attack_kern == ATTACK_KERN_STRAIGHT)
1784 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1785 else if (attack_kern == ATTACK_KERN_COMBI)
1786 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1787 else if (attack_kern == ATTACK_KERN_BF)
1788 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1789 }
1790 else
1791 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1792 }
1793
1794 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1795 {
1796 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1797 {
1798 if (attack_kern == ATTACK_KERN_STRAIGHT)
1799 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1800 else if (attack_kern == ATTACK_KERN_COMBI)
1801 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1802 else if (attack_kern == ATTACK_KERN_BF)
1803 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1804 }
1805 else
1806 {
1807 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1808 }
1809 }
1810
1811 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1812 {
1813 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1814 {
1815 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1816 }
1817 else
1818 {
1819 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1820 }
1821 }
1822
1823 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1824 {
1825 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1826 {
1827 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1828 }
1829 else
1830 {
1831 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1832 }
1833 }
1834
1835 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1836 {
1837 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1838 }
1839
1840 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1841 {
1842 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1843 }
1844
1845 static char *filename_from_filepath (char *filepath)
1846 {
1847 char *ptr = NULL;
1848
1849 if ((ptr = strrchr (filepath, '/')) != NULL)
1850 {
1851 ptr++;
1852 }
1853 else if ((ptr = strrchr (filepath, '\\')) != NULL)
1854 {
1855 ptr++;
1856 }
1857 else
1858 {
1859 ptr = filepath;
1860 }
1861
1862 return ptr;
1863 }
1864
1865 static uint convert_from_hex (char *line_buf, const uint line_len)
1866 {
1867 if (line_len & 1) return (line_len); // not in hex
1868
1869 if (data.hex_wordlist == 1)
1870 {
1871 uint i;
1872 uint j;
1873
1874 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1875 {
1876 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1877 }
1878
1879 memset (line_buf + i, 0, line_len - i);
1880
1881 return (i);
1882 }
1883 else if (line_len >= 6) // $HEX[] = 6
1884 {
1885 if (line_buf[0] != '$') return (line_len);
1886 if (line_buf[1] != 'H') return (line_len);
1887 if (line_buf[2] != 'E') return (line_len);
1888 if (line_buf[3] != 'X') return (line_len);
1889 if (line_buf[4] != '[') return (line_len);
1890 if (line_buf[line_len - 1] != ']') return (line_len);
1891
1892 uint i;
1893 uint j;
1894
1895 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1896 {
1897 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1898 }
1899
1900 memset (line_buf + i, 0, line_len - i);
1901
1902 return (i);
1903 }
1904
1905 return (line_len);
1906 }
1907
1908 static void clear_prompt ()
1909 {
1910 fputc ('\r', stdout);
1911
1912 for (size_t i = 0; i < strlen (PROMPT); i++)
1913 {
1914 fputc (' ', stdout);
1915 }
1916
1917 fputc ('\r', stdout);
1918
1919 fflush (stdout);
1920 }
1921
1922 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1923 {
1924 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1925 }
1926
1927 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1928 {
1929 char *outfile = data.outfile;
1930 uint quiet = data.quiet;
1931 FILE *pot_fp = data.pot_fp;
1932 uint loopback = data.loopback;
1933 uint debug_mode = data.debug_mode;
1934 char *debug_file = data.debug_file;
1935
1936 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1937 int debug_rule_len = 0; // -1 error
1938 uint debug_plain_len = 0;
1939
1940 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1941
1942 // hash
1943
1944 char out_buf[HCBUFSIZ] = { 0 };
1945
1946 const u32 salt_pos = plain->salt_pos;
1947 const u32 digest_pos = plain->digest_pos; // relative
1948 const u32 gidvid = plain->gidvid;
1949 const u32 il_pos = plain->il_pos;
1950
1951 ascii_digest (out_buf, salt_pos, digest_pos);
1952
1953 // plain
1954
1955 u64 crackpos = device_param->words_off;
1956
1957 uint plain_buf[16] = { 0 };
1958
1959 u8 *plain_ptr = (u8 *) plain_buf;
1960
1961 unsigned int plain_len = 0;
1962
1963 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1964 {
1965 pw_t pw;
1966
1967 gidd_to_pw_t (device_param, gidvid, &pw);
1968
1969 for (int i = 0; i < 16; i++)
1970 {
1971 plain_buf[i] = pw.i[i];
1972 }
1973
1974 plain_len = pw.pw_len;
1975
1976 const uint off = device_param->innerloop_pos + il_pos;
1977
1978 if (debug_mode > 0)
1979 {
1980 debug_rule_len = 0;
1981
1982 // save rule
1983 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1984 {
1985 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1986
1987 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1988 }
1989
1990 // save plain
1991 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1992 {
1993 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1994
1995 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1996
1997 debug_plain_len = plain_len;
1998 }
1999 }
2000
2001 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2002
2003 crackpos += gidvid;
2004 crackpos *= data.kernel_rules_cnt;
2005 crackpos += device_param->innerloop_pos + il_pos;
2006
2007 if (plain_len > data.pw_max) plain_len = data.pw_max;
2008 }
2009 else if (data.attack_mode == ATTACK_MODE_COMBI)
2010 {
2011 pw_t pw;
2012
2013 gidd_to_pw_t (device_param, gidvid, &pw);
2014
2015 for (int i = 0; i < 16; i++)
2016 {
2017 plain_buf[i] = pw.i[i];
2018 }
2019
2020 plain_len = pw.pw_len;
2021
2022 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2023 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2024
2025 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2026 {
2027 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2028 }
2029 else
2030 {
2031 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2032
2033 memcpy (plain_ptr, comb_buf, comb_len);
2034 }
2035
2036 plain_len += comb_len;
2037
2038 crackpos += gidvid;
2039 crackpos *= data.combs_cnt;
2040 crackpos += device_param->innerloop_pos + il_pos;
2041
2042 if (data.pw_max != PW_DICTMAX1)
2043 {
2044 if (plain_len > data.pw_max) plain_len = data.pw_max;
2045 }
2046 }
2047 else if (data.attack_mode == ATTACK_MODE_BF)
2048 {
2049 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2050 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2051
2052 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2053 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2054
2055 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2056 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2057
2058 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2059 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2060
2061 plain_len = data.css_cnt;
2062
2063 crackpos += gidvid;
2064 crackpos *= data.bfs_cnt;
2065 crackpos += device_param->innerloop_pos + il_pos;
2066 }
2067 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2068 {
2069 pw_t pw;
2070
2071 gidd_to_pw_t (device_param, gidvid, &pw);
2072
2073 for (int i = 0; i < 16; i++)
2074 {
2075 plain_buf[i] = pw.i[i];
2076 }
2077
2078 plain_len = pw.pw_len;
2079
2080 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2081
2082 uint start = 0;
2083 uint stop = device_param->kernel_params_mp_buf32[4];
2084
2085 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2086
2087 plain_len += start + stop;
2088
2089 crackpos += gidvid;
2090 crackpos *= data.combs_cnt;
2091 crackpos += device_param->innerloop_pos + il_pos;
2092
2093 if (data.pw_max != PW_DICTMAX1)
2094 {
2095 if (plain_len > data.pw_max) plain_len = data.pw_max;
2096 }
2097 }
2098 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2099 {
2100 pw_t pw;
2101
2102 gidd_to_pw_t (device_param, gidvid, &pw);
2103
2104 for (int i = 0; i < 16; i++)
2105 {
2106 plain_buf[i] = pw.i[i];
2107 }
2108
2109 plain_len = pw.pw_len;
2110
2111 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2112
2113 uint start = 0;
2114 uint stop = device_param->kernel_params_mp_buf32[4];
2115
2116 memmove (plain_ptr + stop, plain_ptr, plain_len);
2117
2118 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2119
2120 plain_len += start + stop;
2121
2122 crackpos += gidvid;
2123 crackpos *= data.combs_cnt;
2124 crackpos += device_param->innerloop_pos + il_pos;
2125
2126 if (data.pw_max != PW_DICTMAX1)
2127 {
2128 if (plain_len > data.pw_max) plain_len = data.pw_max;
2129 }
2130 }
2131
2132 if (data.attack_mode == ATTACK_MODE_BF)
2133 {
2134 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2135 {
2136 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2137 {
2138 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2139 {
2140 plain_len = plain_len - data.salts_buf[0].salt_len;
2141 }
2142 }
2143
2144 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2145 {
2146 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2147 {
2148 plain_ptr[j] = plain_ptr[i];
2149 }
2150
2151 plain_len = plain_len / 2;
2152 }
2153 }
2154 }
2155
2156 // if enabled, update also the potfile
2157
2158 if (pot_fp)
2159 {
2160 lock_file (pot_fp);
2161
2162 fprintf (pot_fp, "%s:", out_buf);
2163
2164 format_plain (pot_fp, plain_ptr, plain_len, 1);
2165
2166 fputc ('\n', pot_fp);
2167
2168 fflush (pot_fp);
2169
2170 unlock_file (pot_fp);
2171 }
2172
2173 // outfile
2174
2175 FILE *out_fp = NULL;
2176
2177 if (outfile != NULL)
2178 {
2179 if ((out_fp = fopen (outfile, "ab")) == NULL)
2180 {
2181 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2182
2183 out_fp = stdout;
2184 }
2185
2186 lock_file (out_fp);
2187 }
2188 else
2189 {
2190 out_fp = stdout;
2191
2192 if (quiet == 0) clear_prompt ();
2193 }
2194
2195 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2196
2197 if (outfile != NULL)
2198 {
2199 if (out_fp != stdout)
2200 {
2201 fclose (out_fp);
2202 }
2203 }
2204 else
2205 {
2206 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2207 {
2208 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2209 {
2210 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2211 if (quiet == 0) fflush (stdout);
2212 }
2213 }
2214 }
2215
2216 // loopback
2217
2218 if (loopback)
2219 {
2220 char *loopback_file = data.loopback_file;
2221
2222 FILE *fb_fp = NULL;
2223
2224 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2225 {
2226 lock_file (fb_fp);
2227
2228 format_plain (fb_fp, plain_ptr, plain_len, 1);
2229
2230 fputc ('\n', fb_fp);
2231
2232 fclose (fb_fp);
2233 }
2234 }
2235
2236 // (rule) debug mode
2237
2238 // the next check implies that:
2239 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2240 // - debug_mode > 0
2241
2242 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2243 {
2244 if (debug_rule_len < 0) debug_rule_len = 0;
2245
2246 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2247
2248 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2249
2250 if ((quiet == 0) && (debug_file == NULL))
2251 {
2252 fprintf (stdout, "%s", PROMPT);
2253
2254 fflush (stdout);
2255 }
2256 }
2257 }
2258
2259 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2260 {
2261 salt_t *salt_buf = &data.salts_buf[salt_pos];
2262
2263 u32 num_cracked;
2264
2265 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2266
2267 if (num_cracked)
2268 {
2269 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2270
2271 log_info_nn ("");
2272
2273 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2274
2275 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, 0, num_cracked * sizeof (plain_t), cracked, 0, NULL, NULL);
2276
2277 uint cpt_cracked = 0;
2278
2279 hc_thread_mutex_lock (mux_display);
2280
2281 for (uint i = 0; i < num_cracked; i++)
2282 {
2283 const uint hash_pos = cracked[i].hash_pos;
2284
2285 if (data.digests_shown[hash_pos] == 1) continue;
2286
2287 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2288 {
2289 data.digests_shown[hash_pos] = 1;
2290
2291 data.digests_done++;
2292
2293 cpt_cracked++;
2294
2295 salt_buf->digests_done++;
2296
2297 if (salt_buf->digests_done == salt_buf->digests_cnt)
2298 {
2299 data.salts_shown[salt_pos] = 1;
2300
2301 data.salts_done++;
2302 }
2303 }
2304
2305 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2306
2307 check_hash (device_param, &cracked[i]);
2308 }
2309
2310 hc_thread_mutex_unlock (mux_display);
2311
2312 myfree (cracked);
2313
2314 if (cpt_cracked > 0)
2315 {
2316 hc_thread_mutex_lock (mux_display);
2317
2318 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2319 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2320
2321 data.cpt_pos++;
2322
2323 data.cpt_total += cpt_cracked;
2324
2325 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2326
2327 hc_thread_mutex_unlock (mux_display);
2328 }
2329
2330 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2331 {
2332 // we need to reset cracked state on the device
2333 // otherwise host thinks again and again the hash was cracked
2334 // and returns invalid password each time
2335
2336 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2337
2338 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2339 }
2340
2341 num_cracked = 0;
2342
2343 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2344 }
2345 }
2346
2347 // stolen from princeprocessor ;)
2348
2349 typedef struct
2350 {
2351 FILE *fp;
2352
2353 char buf[BUFSIZ];
2354 int len;
2355
2356 } out_t;
2357
2358 static void out_flush (out_t *out)
2359 {
2360 fwrite (out->buf, 1, out->len, out->fp);
2361
2362 out->len = 0;
2363 }
2364
2365 static void out_push (out_t *out, const u8 *pw_buf, const int pw_len)
2366 {
2367 char *ptr = out->buf + out->len;
2368
2369 memcpy (ptr, pw_buf, pw_len);
2370
2371 ptr[pw_len] = '\n';
2372
2373 out->len += pw_len + 1;
2374
2375 if (out->len >= BUFSIZ - 100)
2376 {
2377 out_flush (out);
2378 }
2379 }
2380
2381 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2382 {
2383 out_t out;
2384
2385 out.fp = stdout;
2386 out.len = 0;
2387
2388 uint plain_buf[16] = { 0 };
2389
2390 u8 *plain_ptr = (u8 *) plain_buf;
2391
2392 uint plain_len = 0;
2393
2394 const uint il_cnt = device_param->kernel_params_buf32[27]; // ugly, i know
2395
2396 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2397 {
2398 pw_t pw;
2399
2400 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2401 {
2402 gidd_to_pw_t (device_param, gidvid, &pw);
2403
2404 const uint pos = device_param->innerloop_pos;
2405
2406 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2407 {
2408 for (int i = 0; i < 8; i++)
2409 {
2410 plain_buf[i] = pw.i[i];
2411 }
2412
2413 plain_len = pw.pw_len;
2414
2415 plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2416
2417 if (plain_len > data.pw_max) plain_len = data.pw_max;
2418
2419 out_push (&out, plain_ptr, plain_len);
2420 }
2421 }
2422 }
2423 else if (data.attack_mode == ATTACK_MODE_COMBI)
2424 {
2425 pw_t pw;
2426
2427 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2428 {
2429 gidd_to_pw_t (device_param, gidvid, &pw);
2430
2431 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2432 {
2433 for (int i = 0; i < 8; i++)
2434 {
2435 plain_buf[i] = pw.i[i];
2436 }
2437
2438 plain_len = pw.pw_len;
2439
2440 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2441 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2442
2443 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2444 {
2445 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2446 }
2447 else
2448 {
2449 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2450
2451 memcpy (plain_ptr, comb_buf, comb_len);
2452 }
2453
2454 plain_len += comb_len;
2455
2456 if (data.pw_max != PW_DICTMAX1)
2457 {
2458 if (plain_len > data.pw_max) plain_len = data.pw_max;
2459 }
2460
2461 out_push (&out, plain_ptr, plain_len);
2462 }
2463 }
2464 }
2465 else if (data.attack_mode == ATTACK_MODE_BF)
2466 {
2467 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2468 {
2469 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2470 {
2471 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2472 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2473
2474 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2475 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2476
2477 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2478 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2479
2480 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2481 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2482
2483 plain_len = data.css_cnt;
2484
2485 out_push (&out, plain_ptr, plain_len);
2486 }
2487 }
2488 }
2489 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2490 {
2491 pw_t pw;
2492
2493 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2494 {
2495 gidd_to_pw_t (device_param, gidvid, &pw);
2496
2497 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2498 {
2499 for (int i = 0; i < 8; i++)
2500 {
2501 plain_buf[i] = pw.i[i];
2502 }
2503
2504 plain_len = pw.pw_len;
2505
2506 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2507
2508 uint start = 0;
2509 uint stop = device_param->kernel_params_mp_buf32[4];
2510
2511 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2512
2513 plain_len += start + stop;
2514
2515 out_push (&out, plain_ptr, plain_len);
2516 }
2517 }
2518 }
2519 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2520 {
2521 pw_t pw;
2522
2523 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2524 {
2525 gidd_to_pw_t (device_param, gidvid, &pw);
2526
2527 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2528 {
2529 for (int i = 0; i < 8; i++)
2530 {
2531 plain_buf[i] = pw.i[i];
2532 }
2533
2534 plain_len = pw.pw_len;
2535
2536 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2537
2538 uint start = 0;
2539 uint stop = device_param->kernel_params_mp_buf32[4];
2540
2541 memmove (plain_ptr + stop, plain_ptr, plain_len);
2542
2543 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2544
2545 plain_len += start + stop;
2546
2547 out_push (&out, plain_ptr, plain_len);
2548 }
2549 }
2550 }
2551
2552 out_flush (&out);
2553 }
2554
2555 static void save_hash ()
2556 {
2557 char *hashfile = data.hashfile;
2558
2559 char new_hashfile[256] = { 0 };
2560 char old_hashfile[256] = { 0 };
2561
2562 snprintf (new_hashfile, 255, "%s.new", hashfile);
2563 snprintf (old_hashfile, 255, "%s.old", hashfile);
2564
2565 unlink (new_hashfile);
2566
2567 char separator = data.separator;
2568
2569 FILE *fp = fopen (new_hashfile, "wb");
2570
2571 if (fp == NULL)
2572 {
2573 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2574
2575 exit (-1);
2576 }
2577
2578 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2579 {
2580 if (data.salts_shown[salt_pos] == 1) continue;
2581
2582 salt_t *salt_buf = &data.salts_buf[salt_pos];
2583
2584 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2585 {
2586 uint idx = salt_buf->digests_offset + digest_pos;
2587
2588 if (data.digests_shown[idx] == 1) continue;
2589
2590 if (data.hash_mode != 2500)
2591 {
2592 if (data.username == 1)
2593 {
2594 user_t *user = data.hash_info[idx]->user;
2595
2596 uint i;
2597
2598 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2599
2600 fputc (separator, fp);
2601 }
2602
2603 char out_buf[HCBUFSIZ]; // scratch buffer
2604
2605 out_buf[0] = 0;
2606
2607 ascii_digest (out_buf, salt_pos, digest_pos);
2608
2609 fputs (out_buf, fp);
2610
2611 fputc ('\n', fp);
2612 }
2613 else
2614 {
2615 hccap_t hccap;
2616
2617 to_hccap_t (&hccap, salt_pos, digest_pos);
2618
2619 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2620 }
2621 }
2622 }
2623
2624 fflush (fp);
2625
2626 fclose (fp);
2627
2628 unlink (old_hashfile);
2629
2630 if (rename (hashfile, old_hashfile) != 0)
2631 {
2632 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2633
2634 exit (-1);
2635 }
2636
2637 unlink (hashfile);
2638
2639 if (rename (new_hashfile, hashfile) != 0)
2640 {
2641 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2642
2643 exit (-1);
2644 }
2645
2646 unlink (old_hashfile);
2647 }
2648
2649 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2650 {
2651 uint num_elements = num;
2652
2653 device_param->kernel_params_buf32[30] = data.combs_mode;
2654 device_param->kernel_params_buf32[31] = num;
2655
2656 uint kernel_threads = device_param->kernel_threads;
2657
2658 while (num_elements % kernel_threads) num_elements++;
2659
2660 cl_kernel kernel = NULL;
2661
2662 switch (kern_run)
2663 {
2664 case KERN_RUN_1: kernel = device_param->kernel1; break;
2665 case KERN_RUN_12: kernel = device_param->kernel12; break;
2666 case KERN_RUN_2: kernel = device_param->kernel2; break;
2667 case KERN_RUN_23: kernel = device_param->kernel23; break;
2668 case KERN_RUN_3: kernel = device_param->kernel3; break;
2669 }
2670
2671 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2672 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2673 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2674 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2675 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2676 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2677 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2678 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2679 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2680 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2681 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2682
2683 cl_event event;
2684
2685 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2686 {
2687 const size_t global_work_size[3] = { num_elements, 32, 1 };
2688 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2689
2690 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2691 }
2692 else
2693 {
2694 if (kern_run == KERN_RUN_2)
2695 {
2696 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2697 {
2698 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2699 }
2700 }
2701
2702 while (num_elements % kernel_threads) num_elements++;
2703
2704 const size_t global_work_size[3] = { num_elements, 1, 1 };
2705 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2706
2707 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2708 }
2709
2710 hc_clFlush (data.ocl, device_param->command_queue);
2711
2712 if (device_param->nvidia_spin_damp)
2713 {
2714 if (data.devices_status == STATUS_RUNNING)
2715 {
2716 if (iteration < EXPECTED_ITERATIONS)
2717 {
2718 switch (kern_run)
2719 {
2720 case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration] * device_param->nvidia_spin_damp); break;
2721 case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration] * device_param->nvidia_spin_damp); break;
2722 case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration] * device_param->nvidia_spin_damp); break;
2723 }
2724 }
2725 }
2726 }
2727
2728 hc_clWaitForEvents (data.ocl, 1, &event);
2729
2730 cl_ulong time_start;
2731 cl_ulong time_end;
2732
2733 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2734 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2735
2736 const double exec_us = (double) (time_end - time_start) / 1000;
2737
2738 if (data.devices_status == STATUS_RUNNING)
2739 {
2740 if (iteration < EXPECTED_ITERATIONS)
2741 {
2742 switch (kern_run)
2743 {
2744 case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2745 case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2746 case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2747 }
2748 }
2749 }
2750
2751 if (event_update)
2752 {
2753 uint exec_pos = device_param->exec_pos;
2754
2755 device_param->exec_ms[exec_pos] = exec_us / 1000;
2756
2757 exec_pos++;
2758
2759 if (exec_pos == EXEC_CACHE)
2760 {
2761 exec_pos = 0;
2762 }
2763
2764 device_param->exec_pos = exec_pos;
2765 }
2766
2767 hc_clReleaseEvent (data.ocl, event);
2768
2769 hc_clFinish (data.ocl, device_param->command_queue);
2770 }
2771
2772 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2773 {
2774 uint num_elements = num;
2775
2776 switch (kern_run)
2777 {
2778 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2779 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2780 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2781 }
2782
2783 // causes problems with special threads like in bcrypt
2784 // const uint kernel_threads = device_param->kernel_threads;
2785
2786 uint kernel_threads = device_param->kernel_threads;
2787
2788 while (num_elements % kernel_threads) num_elements++;
2789
2790 cl_kernel kernel = NULL;
2791
2792 switch (kern_run)
2793 {
2794 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2795 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2796 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2797 }
2798
2799 switch (kern_run)
2800 {
2801 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2802 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2803 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2804 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2805 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2806 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2807 break;
2808 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2809 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2810 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2811 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2812 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2813 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2814 break;
2815 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2816 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2817 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2818 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2819 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2820 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2821 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2822 break;
2823 }
2824
2825 const size_t global_work_size[3] = { num_elements, 1, 1 };
2826 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2827
2828 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2829
2830 hc_clFlush (data.ocl, device_param->command_queue);
2831
2832 hc_clFinish (data.ocl, device_param->command_queue);
2833 }
2834
2835 static void run_kernel_tm (hc_device_param_t *device_param)
2836 {
2837 const uint num_elements = 1024; // fixed
2838
2839 uint kernel_threads = 32;
2840
2841 cl_kernel kernel = device_param->kernel_tm;
2842
2843 const size_t global_work_size[3] = { num_elements, 1, 1 };
2844 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2845
2846 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2847
2848 hc_clFlush (data.ocl, device_param->command_queue);
2849
2850 hc_clFinish (data.ocl, device_param->command_queue);
2851 }
2852
2853 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2854 {
2855 uint num_elements = num;
2856
2857 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2858 device_param->kernel_params_amp_buf32[6] = num_elements;
2859
2860 // causes problems with special threads like in bcrypt
2861 // const uint kernel_threads = device_param->kernel_threads;
2862
2863 uint kernel_threads = device_param->kernel_threads;
2864
2865 while (num_elements % kernel_threads) num_elements++;
2866
2867 cl_kernel kernel = device_param->kernel_amp;
2868
2869 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2870 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2871
2872 const size_t global_work_size[3] = { num_elements, 1, 1 };
2873 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2874
2875 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2876
2877 hc_clFlush (data.ocl, device_param->command_queue);
2878
2879 hc_clFinish (data.ocl, device_param->command_queue);
2880 }
2881
2882 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2883 {
2884 const u32 num16d = num / 16;
2885 const u32 num16m = num % 16;
2886
2887 if (num16d)
2888 {
2889 device_param->kernel_params_memset_buf32[1] = value;
2890 device_param->kernel_params_memset_buf32[2] = num16d;
2891
2892 uint kernel_threads = device_param->kernel_threads;
2893
2894 uint num_elements = num16d;
2895
2896 while (num_elements % kernel_threads) num_elements++;
2897
2898 cl_kernel kernel = device_param->kernel_memset;
2899
2900 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2901 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2902 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2903
2904 const size_t global_work_size[3] = { num_elements, 1, 1 };
2905 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2906
2907 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2908
2909 hc_clFlush (data.ocl, device_param->command_queue);
2910
2911 hc_clFinish (data.ocl, device_param->command_queue);
2912 }
2913
2914 if (num16m)
2915 {
2916 u32 tmp[4];
2917
2918 tmp[0] = value;
2919 tmp[1] = value;
2920 tmp[2] = value;
2921 tmp[3] = value;
2922
2923 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2924 }
2925 }
2926
2927 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2928 {
2929 run_kernel_memset (device_param, buf, 0, size);
2930
2931 /*
2932 int rc = -1;
2933
2934 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2935 {
2936 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2937
2938 const cl_uchar zero = 0;
2939
2940 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2941 }
2942
2943 if (rc != 0)
2944 {
2945 // NOTE: clEnqueueFillBuffer () always fails with -59
2946 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2947 // How's that possible, OpenCL 1.2 support is advertised??
2948 // We need to workaround...
2949
2950 #define FILLSZ 0x100000
2951
2952 char *tmp = (char *) mymalloc (FILLSZ);
2953
2954 for (size_t i = 0; i < size; i += FILLSZ)
2955 {
2956 const size_t left = size - i;
2957
2958 const size_t fillsz = MIN (FILLSZ, left);
2959
2960 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2961 }
2962
2963 myfree (tmp);
2964 }
2965 */
2966 }
2967
2968 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt, const uint fast_iteration)
2969 {
2970 if (data.hash_mode == 2000)
2971 {
2972 process_stdout (device_param, pws_cnt);
2973
2974 return;
2975 }
2976
2977 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2978 {
2979 if (attack_mode == ATTACK_MODE_BF)
2980 {
2981 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2982 {
2983 const uint size_tm = 32 * sizeof (bs_word_t);
2984
2985 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2986
2987 run_kernel_tm (device_param);
2988
2989 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2990 }
2991 }
2992
2993 if (highest_pw_len < 16)
2994 {
2995 run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
2996 }
2997 else if (highest_pw_len < 32)
2998 {
2999 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
3000 }
3001 else
3002 {
3003 run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
3004 }
3005 }
3006 else
3007 {
3008 run_kernel_amp (device_param, pws_cnt);
3009
3010 run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
3011
3012 if (opts_type & OPTS_TYPE_HOOK12)
3013 {
3014 run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
3015
3016 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
3017
3018 // do something with data
3019
3020 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
3021 }
3022
3023 uint iter = salt_buf->salt_iter;
3024
3025 uint loop_step = device_param->kernel_loops;
3026
3027 for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
3028 {
3029 uint loop_left = iter - loop_pos;
3030
3031 loop_left = MIN (loop_left, loop_step);
3032
3033 device_param->kernel_params_buf32[25] = loop_pos;
3034 device_param->kernel_params_buf32[26] = loop_left;
3035
3036 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
3037
3038 if (data.devices_status == STATUS_CRACKED) break;
3039 if (data.devices_status == STATUS_ABORTED) break;
3040 if (data.devices_status == STATUS_QUIT) break;
3041
3042 /**
3043 * speed
3044 */
3045
3046 const float iter_part = (float) (loop_pos + loop_left) / iter;
3047
3048 const u64 perf_sum_all = pws_cnt * iter_part;
3049
3050 double speed_ms;
3051
3052 hc_timer_get (device_param->timer_speed, speed_ms);
3053
3054 const u32 speed_pos = device_param->speed_pos;
3055
3056 device_param->speed_cnt[speed_pos] = perf_sum_all;
3057
3058 device_param->speed_ms[speed_pos] = speed_ms;
3059
3060 if (data.benchmark == 1)
3061 {
3062 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
3063 }
3064 }
3065
3066 if (opts_type & OPTS_TYPE_HOOK23)
3067 {
3068 run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
3069
3070 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
3071
3072 // do something with data
3073
3074 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
3075 }
3076
3077 run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3078 }
3079 }
3080
3081 static int run_rule_engine (const int rule_len, const char *rule_buf)
3082 {
3083 if (rule_len == 0)
3084 {
3085 return 0;
3086 }
3087 else if (rule_len == 1)
3088 {
3089 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3090 }
3091
3092 return 1;
3093 }
3094
3095 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3096 {
3097 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3098 {
3099 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3100 }
3101 else if (data.attack_kern == ATTACK_KERN_COMBI)
3102 {
3103 if (data.attack_mode == ATTACK_MODE_COMBI)
3104 {
3105 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3106 {
3107 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3108 {
3109 for (u32 i = 0; i < pws_cnt; i++)
3110 {
3111 const u32 pw_len = device_param->pws_buf[i].pw_len;
3112
3113 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3114
3115 ptr[pw_len] = 0x01;
3116 }
3117 }
3118 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3119 {
3120 for (u32 i = 0; i < pws_cnt; i++)
3121 {
3122 const u32 pw_len = device_param->pws_buf[i].pw_len;
3123
3124 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3125
3126 ptr[pw_len] = 0x80;
3127 }
3128 }
3129 }
3130 }
3131 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3132 {
3133 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3134 {
3135 for (u32 i = 0; i < pws_cnt; i++)
3136 {
3137 const u32 pw_len = device_param->pws_buf[i].pw_len;
3138
3139 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3140
3141 ptr[pw_len] = 0x01;
3142 }
3143 }
3144 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3145 {
3146 for (u32 i = 0; i < pws_cnt; i++)
3147 {
3148 const u32 pw_len = device_param->pws_buf[i].pw_len;
3149
3150 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3151
3152 ptr[pw_len] = 0x80;
3153 }
3154 }
3155 }
3156
3157 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3158 }
3159 else if (data.attack_kern == ATTACK_KERN_BF)
3160 {
3161 const u64 off = device_param->words_off;
3162
3163 device_param->kernel_params_mp_l_buf64[3] = off;
3164
3165 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3166 }
3167 }
3168
3169 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3170 {
3171 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3172
3173 device_param->kernel_params_buf32[25] = 0;
3174 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
3175 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3176
3177 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3178 {
3179 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3180 }
3181 else
3182 {
3183 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3184 }
3185
3186 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3187
3188 return exec_ms_prev;
3189 }
3190
3191 static void autotune (hc_device_param_t *device_param)
3192 {
3193 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3194
3195 const u32 kernel_accel_min = device_param->kernel_accel_min;
3196 const u32 kernel_accel_max = device_param->kernel_accel_max;
3197
3198 const u32 kernel_loops_min = device_param->kernel_loops_min;
3199 const u32 kernel_loops_max = device_param->kernel_loops_max;
3200
3201 u32 kernel_accel = kernel_accel_min;
3202 u32 kernel_loops = kernel_loops_min;
3203
3204 // in this case the user specified a fixed -u and -n on the commandline
3205 // no way to tune anything
3206 // but we need to run a few caching rounds
3207
3208 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3209 {
3210 if (data.hash_mode != 2000)
3211 {
3212 try_run (device_param, kernel_accel, kernel_loops);
3213 try_run (device_param, kernel_accel, kernel_loops);
3214 try_run (device_param, kernel_accel, kernel_loops);
3215 try_run (device_param, kernel_accel, kernel_loops);
3216 }
3217
3218 device_param->kernel_accel = kernel_accel;
3219 device_param->kernel_loops = kernel_loops;
3220
3221 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3222
3223 device_param->kernel_power = kernel_power;
3224
3225 return;
3226 }
3227
3228 // from here it's clear we are allowed to autotune
3229 // so let's init some fake words
3230
3231 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3232
3233 if (data.attack_kern == ATTACK_KERN_BF)
3234 {
3235 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3236 }
3237 else
3238 {
3239 for (u32 i = 0; i < kernel_power_max; i++)
3240 {
3241 device_param->pws_buf[i].i[0] = i;
3242 device_param->pws_buf[i].i[1] = 0x01234567;
3243 device_param->pws_buf[i].pw_len = 7 + (i & 7);
3244 }
3245
3246 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3247 }
3248
3249 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3250 {
3251 if (data.kernel_rules_cnt > 1)
3252 {
3253 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, 0, 0, MIN (kernel_loops_max, KERNEL_RULES) * sizeof (kernel_rule_t), 0, NULL, NULL);
3254 }
3255 }
3256 else
3257 {
3258 run_kernel_amp (device_param, kernel_power_max);
3259 }
3260
3261 #define VERIFIER_CNT 1
3262
3263 // first find out highest kernel-loops that stays below target_ms
3264
3265 if (kernel_loops_min < kernel_loops_max)
3266 {
3267 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3268 {
3269 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3270
3271 for (int i = 0; i < VERIFIER_CNT; i++)
3272 {
3273 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3274
3275 exec_ms = MIN (exec_ms, exec_ms_v);
3276 }
3277
3278 if (exec_ms < target_ms) break;
3279 }
3280 }
3281
3282 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3283
3284 #define STEPS_CNT 10
3285
3286 if (kernel_accel_min < kernel_accel_max)
3287 {
3288 for (int i = 0; i < STEPS_CNT; i++)
3289 {
3290 const u32 kernel_accel_try = 1 << i;
3291
3292 if (kernel_accel_try < kernel_accel_min) continue;
3293 if (kernel_accel_try > kernel_accel_max) break;
3294
3295 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3296
3297 for (int i = 0; i < VERIFIER_CNT; i++)
3298 {
3299 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3300
3301 exec_ms = MIN (exec_ms, exec_ms_v);
3302 }
3303
3304 if (exec_ms > target_ms) break;
3305
3306 kernel_accel = kernel_accel_try;
3307 }
3308 }
3309
3310 // at this point we want to know the actual runtime for the following reason:
3311 // we need a reference for the balancing loop following up, and this
3312 // the balancing loop can have an effect that the creates a new opportunity, for example:
3313 // if the target is 95 ms and the current runtime is 48ms the above loop
3314 // stopped the execution because the previous exec_ms was > 95ms
3315 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3316 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3317
3318 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3319
3320 for (int i = 0; i < VERIFIER_CNT; i++)
3321 {
3322 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3323
3324 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3325 }
3326
3327 u32 diff = kernel_loops - kernel_accel;
3328
3329 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3330 {
3331 u32 kernel_accel_orig = kernel_accel;
3332 u32 kernel_loops_orig = kernel_loops;
3333
3334 for (u32 f = 1; f < 1024; f++)
3335 {
3336 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3337 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3338
3339 if (kernel_accel_try > kernel_accel_max) break;
3340 if (kernel_loops_try < kernel_loops_min) break;
3341
3342 u32 diff_new = kernel_loops_try - kernel_accel_try;
3343
3344 if (diff_new > diff) break;
3345
3346 diff_new = diff;
3347
3348 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3349
3350 for (int i = 0; i < VERIFIER_CNT; i++)
3351 {
3352 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3353
3354 exec_ms = MIN (exec_ms, exec_ms_v);
3355 }
3356
3357 if (exec_ms < exec_ms_pre_final)
3358 {
3359 exec_ms_pre_final = exec_ms;
3360
3361 kernel_accel = kernel_accel_try;
3362 kernel_loops = kernel_loops_try;
3363 }
3364 }
3365 }
3366
3367 const double exec_left = target_ms / exec_ms_pre_final;
3368
3369 const double accel_left = kernel_accel_max / kernel_accel;
3370
3371 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3372
3373 if (exec_accel_min >= 1.0)
3374 {
3375 // this is safe to not overflow kernel_accel_max because of accel_left
3376
3377 kernel_accel = (double) kernel_accel * exec_accel_min;
3378 }
3379
3380 // reset them fake words
3381
3382 /*
3383 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3384
3385 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3386 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3387 */
3388
3389 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3390
3391 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3392 {
3393 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3394 }
3395
3396 // reset timer
3397
3398 device_param->exec_pos = 0;
3399
3400 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3401
3402 memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3403 memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3404 memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3405
3406 // store
3407
3408 device_param->kernel_accel = kernel_accel;
3409 device_param->kernel_loops = kernel_loops;
3410
3411 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3412
3413 device_param->kernel_power = kernel_power;
3414
3415 #ifdef DEBUG
3416
3417 if (data.quiet == 0)
3418 {
3419 clear_prompt ();
3420
3421 log_info ("- Device #%u: autotuned kernel-accel to %u\n"
3422 "- Device #%u: autotuned kernel-loops to %u\n",
3423 device_param->device_id + 1, kernel_accel,
3424 device_param->device_id + 1, kernel_loops);
3425
3426 fprintf (stdout, "%s", PROMPT);
3427
3428 fflush (stdout);
3429 }
3430
3431 #endif
3432 }
3433
3434 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3435 {
3436 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3437
3438 // init speed timer
3439
3440 uint speed_pos = device_param->speed_pos;
3441
3442 #ifdef _POSIX
3443 if (device_param->timer_speed.tv_sec == 0)
3444 {
3445 hc_timer_set (&device_param->timer_speed);
3446 }
3447 #endif
3448
3449 #ifdef _WIN
3450 if (device_param->timer_speed.QuadPart == 0)
3451 {
3452 hc_timer_set (&device_param->timer_speed);
3453 }
3454 #endif
3455
3456 // find higest password length, this is for optimization stuff
3457
3458 uint highest_pw_len = 0;
3459
3460 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3461 {
3462 }
3463 else if (data.attack_kern == ATTACK_KERN_COMBI)
3464 {
3465 }
3466 else if (data.attack_kern == ATTACK_KERN_BF)
3467 {
3468 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3469 + device_param->kernel_params_mp_l_buf32[5];
3470 }
3471
3472 // iteration type
3473
3474 uint innerloop_step = 0;
3475 uint innerloop_cnt = 0;
3476
3477 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3478 else innerloop_step = 1;
3479
3480 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3481 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3482 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3483
3484 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3485
3486 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3487 {
3488 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3489
3490 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3491
3492 if (data.devices_status == STATUS_CRACKED) break;
3493 if (data.devices_status == STATUS_ABORTED) break;
3494 if (data.devices_status == STATUS_QUIT) break;
3495 if (data.devices_status == STATUS_BYPASS) break;
3496
3497 salt_t *salt_buf = &data.salts_buf[salt_pos];
3498
3499 device_param->kernel_params_buf32[24] = salt_pos;
3500 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3501 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3502
3503 FILE *combs_fp = device_param->combs_fp;
3504
3505 if (data.attack_mode == ATTACK_MODE_COMBI)
3506 {
3507 rewind (combs_fp);
3508 }
3509
3510 // innerloops
3511
3512 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3513 {
3514 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3515
3516 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3517
3518 if (data.devices_status == STATUS_CRACKED) break;
3519 if (data.devices_status == STATUS_ABORTED) break;
3520 if (data.devices_status == STATUS_QUIT) break;
3521 if (data.devices_status == STATUS_BYPASS) break;
3522
3523 uint fast_iteration = 0;
3524
3525 uint innerloop_left = innerloop_cnt - innerloop_pos;
3526
3527 if (innerloop_left > innerloop_step)
3528 {
3529 innerloop_left = innerloop_step;
3530
3531 fast_iteration = 1;
3532 }
3533
3534 device_param->innerloop_pos = innerloop_pos;
3535 device_param->innerloop_left = innerloop_left;
3536
3537 device_param->kernel_params_buf32[27] = innerloop_left;
3538
3539 // i think we can get rid of this
3540 if (innerloop_left == 0)
3541 {
3542 puts ("bug, how should this happen????\n");
3543
3544 continue;
3545 }
3546
3547 if (data.salts_shown[salt_pos] == 1)
3548 {
3549 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3550
3551 continue;
3552 }
3553
3554 // initialize amplifiers
3555
3556 if (data.attack_mode == ATTACK_MODE_COMBI)
3557 {
3558 uint i = 0;
3559
3560 while (i < innerloop_left)
3561 {
3562 if (feof (combs_fp)) break;
3563
3564 int line_len = fgetl (combs_fp, line_buf);
3565
3566 if (line_len >= PW_MAX1) continue;
3567
3568 line_len = convert_from_hex (line_buf, line_len);
3569
3570 char *line_buf_new = line_buf;
3571
3572 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3573 {
3574 char rule_buf_out[BLOCK_SIZE] = { 0 };
3575
3576 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3577
3578 if (rule_len_out < 0)
3579 {
3580 data.words_progress_rejected[salt_pos] += pws_cnt;
3581
3582 continue;
3583 }
3584
3585 line_len = rule_len_out;
3586
3587 line_buf_new = rule_buf_out;
3588 }
3589
3590 line_len = MIN (line_len, PW_DICTMAX);
3591
3592 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3593
3594 memcpy (ptr, line_buf_new, line_len);
3595
3596 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3597
3598 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3599 {
3600 uppercase (ptr, line_len);
3601 }
3602
3603 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3604 {
3605 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3606 {
3607 ptr[line_len] = 0x80;
3608 }
3609
3610 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3611 {
3612 ptr[line_len] = 0x01;
3613 }
3614 }
3615
3616 device_param->combs_buf[i].pw_len = line_len;
3617
3618 i++;
3619 }
3620
3621 for (uint j = i; j < innerloop_left; j++)
3622 {
3623 device_param->combs_buf[j].i[0] = 0;
3624 device_param->combs_buf[j].i[1] = 0;
3625 device_param->combs_buf[j].i[2] = 0;
3626 device_param->combs_buf[j].i[3] = 0;
3627 device_param->combs_buf[j].i[4] = 0;
3628 device_param->combs_buf[j].i[5] = 0;
3629 device_param->combs_buf[j].i[6] = 0;
3630 device_param->combs_buf[j].i[7] = 0;
3631
3632 device_param->combs_buf[j].pw_len = 0;
3633 }
3634
3635 innerloop_left = i;
3636 }
3637 else if (data.attack_mode == ATTACK_MODE_BF)
3638 {
3639 u64 off = innerloop_pos;
3640
3641 device_param->kernel_params_mp_r_buf64[3] = off;
3642
3643 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3644 }
3645 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3646 {
3647 u64 off = innerloop_pos;
3648
3649 device_param->kernel_params_mp_buf64[3] = off;
3650
3651 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3652 }
3653 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3654 {
3655 u64 off = innerloop_pos;
3656
3657 device_param->kernel_params_mp_buf64[3] = off;
3658
3659 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3660 }
3661
3662 // copy amplifiers
3663
3664 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3665 {
3666 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
3667 }
3668 else if (data.attack_mode == ATTACK_MODE_COMBI)
3669 {
3670 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
3671 }
3672 else if (data.attack_mode == ATTACK_MODE_BF)
3673 {
3674 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
3675 }
3676 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3677 {
3678 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3679 }
3680 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3681 {
3682 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3683 }
3684
3685 if (data.benchmark == 1)
3686 {
3687 hc_timer_set (&device_param->timer_speed);
3688 }
3689
3690 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
3691
3692 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3693
3694 if (data.devices_status == STATUS_CRACKED) break;
3695 if (data.devices_status == STATUS_ABORTED) break;
3696 if (data.devices_status == STATUS_QUIT) break;
3697
3698 /**
3699 * result
3700 */
3701
3702 if (data.benchmark == 0)
3703 {
3704 check_cracked (device_param, salt_pos);
3705 }
3706
3707 /**
3708 * progress
3709 */
3710
3711 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3712
3713 hc_thread_mutex_lock (mux_counter);
3714
3715 data.words_progress_done[salt_pos] += perf_sum_all;
3716
3717 hc_thread_mutex_unlock (mux_counter);
3718
3719 /**
3720 * speed
3721 */
3722
3723 double speed_ms;
3724
3725 hc_timer_get (device_param->timer_speed, speed_ms);
3726
3727 hc_timer_set (&device_param->timer_speed);
3728
3729 // current speed
3730
3731 //hc_thread_mutex_lock (mux_display);
3732
3733 device_param->speed_cnt[speed_pos] = perf_sum_all;
3734
3735 device_param->speed_ms[speed_pos] = speed_ms;
3736
3737 //hc_thread_mutex_unlock (mux_display);
3738
3739 speed_pos++;
3740
3741 if (speed_pos == SPEED_CACHE)
3742 {
3743 speed_pos = 0;
3744 }
3745
3746 /**
3747 * benchmark
3748 */
3749
3750 if (data.benchmark == 1) break;
3751 }
3752 }
3753
3754 device_param->speed_pos = speed_pos;
3755
3756 myfree (line_buf);
3757 }
3758
3759 static void load_segment (wl_data_t *wl_data, FILE *fd)
3760 {
3761 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3762
3763 wl_data->pos = 0;
3764
3765 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3766
3767 wl_data->buf[wl_data->cnt] = 0;
3768
3769 if (wl_data->cnt == 0) return;
3770
3771 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3772
3773 while (!feof (fd))
3774 {
3775 if (wl_data->cnt == wl_data->avail)
3776 {
3777 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3778
3779 wl_data->avail += wl_data->incr;
3780 }
3781
3782 const int c = fgetc (fd);
3783
3784 if (c == EOF) break;
3785
3786 wl_data->buf[wl_data->cnt] = (char) c;
3787
3788 wl_data->cnt++;
3789
3790 if (c == '\n') break;
3791 }
3792
3793 // ensure stream ends with a newline
3794
3795 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3796 {
3797 wl_data->cnt++;
3798
3799 wl_data->buf[wl_data->cnt - 1] = '\n';
3800 }
3801
3802 return;
3803 }
3804
3805 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3806 {
3807 char *ptr = buf;
3808
3809 for (u32 i = 0; i < sz; i++, ptr++)
3810 {
3811 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3812
3813 if (i == 7)
3814 {
3815 *off = i;
3816 *len = i;
3817
3818 return;
3819 }
3820
3821 if (*ptr != '\n') continue;
3822
3823 *off = i + 1;
3824
3825 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3826
3827 *len = i;
3828
3829 return;
3830 }
3831
3832 *off = sz;
3833 *len = sz;
3834 }
3835
3836 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3837 {
3838 char *ptr = buf;
3839
3840 for (u32 i = 0; i < sz; i++, ptr++)
3841 {
3842 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3843
3844 if (*ptr != '\n') continue;
3845
3846 *off = i + 1;
3847
3848 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3849
3850 *len = i;
3851
3852 return;
3853 }
3854
3855 *off = sz;
3856 *len = sz;
3857 }
3858
3859 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3860 {
3861 char *ptr = buf;
3862
3863 for (u32 i = 0; i < sz; i++, ptr++)
3864 {
3865 if (*ptr != '\n') continue;
3866
3867 *off = i + 1;
3868
3869 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3870
3871 *len = i;
3872
3873 return;
3874 }
3875
3876 *off = sz;
3877 *len = sz;
3878 }
3879
3880 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3881 {
3882 while (wl_data->pos < wl_data->cnt)
3883 {
3884 uint off;
3885 uint len;
3886
3887 char *ptr = wl_data->buf + wl_data->pos;
3888
3889 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3890
3891 wl_data->pos += off;
3892
3893 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3894 {
3895 char rule_buf_out[BLOCK_SIZE] = { 0 };
3896
3897 int rule_len_out = -1;
3898
3899 if (len < BLOCK_SIZE)
3900 {
3901 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3902 }
3903
3904 if (rule_len_out < 0)
3905 {
3906 continue;
3907 }
3908
3909 if (rule_len_out > PW_MAX)
3910 {
3911 continue;
3912 }
3913 }
3914 else
3915 {
3916 if (len > PW_MAX)
3917 {
3918 continue;
3919 }
3920 }
3921
3922 *out_buf = ptr;
3923 *out_len = len;
3924
3925 return;
3926 }
3927
3928 if (feof (fd))
3929 {
3930 fprintf (stderr, "BUG feof()!!\n");
3931
3932 return;
3933 }
3934
3935 load_segment (wl_data, fd);
3936
3937 get_next_word (wl_data, fd, out_buf, out_len);
3938 }
3939
3940 #ifdef _POSIX
3941 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3942 #endif
3943
3944 #ifdef _WIN
3945 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3946 #endif
3947 {
3948 hc_signal (NULL);
3949
3950 dictstat_t d;
3951
3952 d.cnt = 0;
3953
3954 #ifdef _POSIX
3955 fstat (fileno (fd), &d.stat);
3956 #endif
3957
3958 #ifdef _WIN
3959 _fstat64 (fileno (fd), &d.stat);
3960 #endif
3961
3962 d.stat.st_mode = 0;
3963 d.stat.st_nlink = 0;
3964 d.stat.st_uid = 0;
3965 d.stat.st_gid = 0;
3966 d.stat.st_rdev = 0;
3967 d.stat.st_atime = 0;
3968
3969 #ifdef _POSIX
3970 d.stat.st_blksize = 0;
3971 d.stat.st_blocks = 0;
3972 #endif
3973
3974 if (d.stat.st_size == 0) return 0;
3975
3976 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3977
3978 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3979 {
3980 if (d_cache)
3981 {
3982 u64 cnt = d_cache->cnt;
3983
3984 u64 keyspace = cnt;
3985
3986 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3987 {
3988 keyspace *= data.kernel_rules_cnt;
3989 }
3990 else if (data.attack_kern == ATTACK_KERN_COMBI)
3991 {
3992 keyspace *= data.combs_cnt;
3993 }
3994
3995 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);
3996 if (data.quiet == 0) log_info ("");
3997
3998 hc_signal (sigHandler_default);
3999
4000 return (keyspace);
4001 }
4002 }
4003
4004 time_t now = 0;
4005 time_t prev = 0;
4006
4007 u64 comp = 0;
4008 u64 cnt = 0;
4009 u64 cnt2 = 0;
4010
4011 while (!feof (fd))
4012 {
4013 load_segment (wl_data, fd);
4014
4015 comp += wl_data->cnt;
4016
4017 u32 i = 0;
4018
4019 while (i < wl_data->cnt)
4020 {
4021 u32 len;
4022 u32 off;
4023
4024 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
4025
4026 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4027 {
4028 char rule_buf_out[BLOCK_SIZE] = { 0 };
4029
4030 int rule_len_out = -1;
4031
4032 if (len < BLOCK_SIZE)
4033 {
4034 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
4035 }
4036
4037 if (rule_len_out < 0)
4038 {
4039 len = PW_MAX1;
4040 }
4041 else
4042 {
4043 len = rule_len_out;
4044 }
4045 }
4046
4047 if (len < PW_MAX1)
4048 {
4049 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4050 {
4051 cnt += data.kernel_rules_cnt;
4052 }
4053 else if (data.attack_kern == ATTACK_KERN_COMBI)
4054 {
4055 cnt += data.combs_cnt;
4056 }
4057
4058 d.cnt++;
4059 }
4060
4061 i += off;
4062
4063 cnt2++;
4064 }
4065
4066 time (&now);
4067
4068 if ((now - prev) == 0) continue;
4069
4070 float percent = (float) comp / (float) d.stat.st_size;
4071
4072 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);
4073
4074 time (&prev);
4075 }
4076
4077 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);
4078 if (data.quiet == 0) log_info ("");
4079
4080 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4081
4082 hc_signal (sigHandler_default);
4083
4084 return (cnt);
4085 }
4086
4087 static void *thread_monitor (void *p)
4088 {
4089 uint runtime_check = 0;
4090 uint remove_check = 0;
4091 uint status_check = 0;
4092 uint restore_check = 0;
4093
4094 uint restore_left = data.restore_timer;
4095 uint remove_left = data.remove_timer;
4096 uint status_left = data.status_timer;
4097
4098 #ifdef HAVE_HWMON
4099 uint hwmon_check = 0;
4100
4101 int slowdown_warnings = 0;
4102
4103 // these variables are mainly used for fan control
4104
4105 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4106
4107 // temperature controller "loopback" values
4108
4109 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4110 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4111
4112 int temp_threshold = 1; // degrees celcius
4113
4114 int fan_speed_min = 15; // in percentage
4115 int fan_speed_max = 100;
4116
4117 time_t last_temp_check_time;
4118 #endif // HAVE_HWMON
4119
4120 uint sleep_time = 1;
4121
4122 if (data.runtime)
4123 {
4124 runtime_check = 1;
4125 }
4126
4127 if (data.restore_timer)
4128 {
4129 restore_check = 1;
4130 }
4131
4132 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4133 {
4134 remove_check = 1;
4135 }
4136
4137 if (data.status == 1)
4138 {
4139 status_check = 1;
4140 }
4141
4142 #ifdef HAVE_HWMON
4143 if (data.gpu_temp_disable == 0)
4144 {
4145 time (&last_temp_check_time);
4146
4147 hwmon_check = 1;
4148 }
4149 #endif
4150
4151 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4152 {
4153 #ifdef HAVE_HWMON
4154 if (hwmon_check == 0)
4155 #endif
4156 return (p);
4157 }
4158
4159 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4160 {
4161 hc_sleep (sleep_time);
4162
4163 if (data.devices_status != STATUS_RUNNING) continue;
4164
4165 #ifdef HAVE_HWMON
4166
4167 if (hwmon_check == 1)
4168 {
4169 hc_thread_mutex_lock (mux_adl);
4170
4171 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4172 {
4173 hc_device_param_t *device_param = &data.devices_param[device_id];
4174
4175 if (device_param->skipped) continue;
4176
4177 if (device_param->device_vendor_id == VENDOR_ID_NV)
4178 {
4179 if (data.hm_nvapi)
4180 {
4181 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
4182 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
4183
4184 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4185 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4186
4187 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4188
4189 perfPolicies_status.info_value = perfPolicies_info.info_value;
4190
4191 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4192
4193 if (perfPolicies_status.throttle & 2)
4194 {
4195 if (slowdown_warnings < 3)
4196 {
4197 if (data.quiet == 0) clear_prompt ();
4198
4199 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4200
4201 if (slowdown_warnings == 2)
4202 {
4203 log_info ("");
4204 }
4205
4206 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4207 if (data.quiet == 0) fflush (stdout);
4208
4209 slowdown_warnings++;
4210 }
4211 }
4212 else
4213 {
4214 slowdown_warnings = 0;
4215 }
4216 }
4217 }
4218 }
4219
4220 hc_thread_mutex_unlock (mux_adl);
4221 }
4222
4223 if (hwmon_check == 1)
4224 {
4225 hc_thread_mutex_lock (mux_adl);
4226
4227 time_t temp_check_time;
4228
4229 time (&temp_check_time);
4230
4231 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4232
4233 if (Ta == 0) Ta = 1;
4234
4235 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4236 {
4237 hc_device_param_t *device_param = &data.devices_param[device_id];
4238
4239 if (device_param->skipped) continue;
4240
4241 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4242
4243 const int temperature = hm_get_temperature_with_device_id (device_id);
4244
4245 if (temperature > (int) data.gpu_temp_abort)
4246 {
4247 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4248
4249 if (data.devices_status != STATUS_QUIT) myabort ();
4250
4251 break;
4252 }
4253
4254 const int gpu_temp_retain = data.gpu_temp_retain;
4255
4256 if (gpu_temp_retain)
4257 {
4258 if (data.hm_device[device_id].fan_set_supported == 1)
4259 {
4260 int temp_cur = temperature;
4261
4262 int temp_diff_new = gpu_temp_retain - temp_cur;
4263
4264 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4265
4266 // calculate Ta value (time difference in seconds between the last check and this check)
4267
4268 last_temp_check_time = temp_check_time;
4269
4270 float Kp = 1.8;
4271 float Ki = 0.005;
4272 float Kd = 6;
4273
4274 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4275
4276 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[device_id] + Kd * ((float)(temp_diff_new - temp_diff_old[device_id])) / Ta);
4277
4278 if (abs (fan_diff_required) >= temp_threshold)
4279 {
4280 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4281
4282 int fan_speed_level = fan_speed_cur;
4283
4284 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4285
4286 int fan_speed_new = fan_speed_level - fan_diff_required;
4287
4288 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4289 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4290
4291 if (fan_speed_new != fan_speed_cur)
4292 {
4293 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4294 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4295
4296 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4297 {
4298 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4299 {
4300 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4301 }
4302 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4303 {
4304 #ifdef WIN
4305 hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1);
4306 #endif
4307
4308 #ifdef LINUX
4309 hm_set_fanspeed_with_device_id_xnvctrl (device_id, fan_speed_new);
4310 #endif
4311 }
4312
4313 fan_speed_chgd[device_id] = 1;
4314 }
4315
4316 temp_diff_old[device_id] = temp_diff_new;
4317 }
4318 }
4319 }
4320 }
4321 }
4322
4323 hc_thread_mutex_unlock (mux_adl);
4324 }
4325 #endif // HAVE_HWMON
4326
4327 if (restore_check == 1)
4328 {
4329 restore_left--;
4330
4331 if (restore_left == 0)
4332 {
4333 if (data.restore_disable == 0) cycle_restore ();
4334
4335 restore_left = data.restore_timer;
4336 }
4337 }
4338
4339 if ((runtime_check == 1) && (data.runtime_start > 0))
4340 {
4341 time_t runtime_cur;
4342
4343 time (&runtime_cur);
4344
4345 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4346
4347 if (runtime_left <= 0)
4348 {
4349 if (data.benchmark == 0)
4350 {
4351 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4352 }
4353
4354 if (data.devices_status != STATUS_QUIT) myabort ();
4355 }
4356 }
4357
4358 if (remove_check == 1)
4359 {
4360 remove_left--;
4361
4362 if (remove_left == 0)
4363 {
4364 if (data.digests_saved != data.digests_done)
4365 {
4366 data.digests_saved = data.digests_done;
4367
4368 save_hash ();
4369 }
4370
4371 remove_left = data.remove_timer;
4372 }
4373 }
4374
4375 if (status_check == 1)
4376 {
4377 status_left--;
4378
4379 if (status_left == 0)
4380 {
4381 //hc_thread_mutex_lock (mux_display);
4382
4383 if (data.quiet == 0) clear_prompt ();
4384
4385 if (data.quiet == 0) log_info ("");
4386
4387 status_display ();
4388
4389 if (data.quiet == 0) log_info ("");
4390
4391 //hc_thread_mutex_unlock (mux_display);
4392
4393 status_left = data.status_timer;
4394 }
4395 }
4396 }
4397
4398 #ifdef HAVE_HWMON
4399 myfree (fan_speed_chgd);
4400
4401 myfree (temp_diff_old);
4402 myfree (temp_diff_sum);
4403 #endif
4404
4405 p = NULL;
4406
4407 return (p);
4408 }
4409
4410 static void *thread_outfile_remove (void *p)
4411 {
4412 // some hash-dependent constants
4413 char *outfile_dir = data.outfile_check_directory;
4414 uint dgst_size = data.dgst_size;
4415 uint isSalted = data.isSalted;
4416 uint esalt_size = data.esalt_size;
4417 uint hash_mode = data.hash_mode;
4418
4419 uint outfile_check_timer = data.outfile_check_timer;
4420
4421 char separator = data.separator;
4422
4423 // some hash-dependent functions
4424 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4425 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4426
4427 // buffers
4428 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4429
4430 hash_buf.digest = mymalloc (dgst_size);
4431
4432 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4433
4434 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4435
4436 uint digest_buf[64] = { 0 };
4437
4438 outfile_data_t *out_info = NULL;
4439
4440 char **out_files = NULL;
4441
4442 time_t folder_mtime = 0;
4443
4444 int out_cnt = 0;
4445
4446 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4447
4448 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4449 {
4450 hc_sleep (1);
4451
4452 if (data.devices_status != STATUS_RUNNING) continue;
4453
4454 check_left--;
4455
4456 if (check_left == 0)
4457 {
4458 struct stat outfile_check_stat;
4459
4460 if (stat (outfile_dir, &outfile_check_stat) == 0)
4461 {
4462 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4463
4464 if (is_dir == 1)
4465 {
4466 if (outfile_check_stat.st_mtime > folder_mtime)
4467 {
4468 char **out_files_new = scan_directory (outfile_dir);
4469
4470 int out_cnt_new = count_dictionaries (out_files_new);
4471
4472 outfile_data_t *out_info_new = NULL;
4473
4474 if (out_cnt_new > 0)
4475 {
4476 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4477
4478 for (int i = 0; i < out_cnt_new; i++)
4479 {
4480 out_info_new[i].file_name = out_files_new[i];
4481
4482 // check if there are files that we have seen/checked before (and not changed)
4483
4484 for (int j = 0; j < out_cnt; j++)
4485 {
4486 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4487 {
4488 struct stat outfile_stat;
4489
4490 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4491 {
4492 if (outfile_stat.st_ctime == out_info[j].ctime)
4493 {
4494 out_info_new[i].ctime = out_info[j].ctime;
4495 out_info_new[i].seek = out_info[j].seek;
4496 }
4497 }
4498 }
4499 }
4500 }
4501 }
4502
4503 local_free (out_info);
4504 local_free (out_files);
4505
4506 out_files = out_files_new;
4507 out_cnt = out_cnt_new;
4508 out_info = out_info_new;
4509
4510 folder_mtime = outfile_check_stat.st_mtime;
4511 }
4512
4513 for (int j = 0; j < out_cnt; j++)
4514 {
4515 FILE *fp = fopen (out_info[j].file_name, "rb");
4516
4517 if (fp != NULL)
4518 {
4519 //hc_thread_mutex_lock (mux_display);
4520
4521 #ifdef _POSIX
4522 struct stat outfile_stat;
4523
4524 fstat (fileno (fp), &outfile_stat);
4525 #endif
4526
4527 #ifdef _WIN
4528 struct stat64 outfile_stat;
4529
4530 _fstat64 (fileno (fp), &outfile_stat);
4531 #endif
4532
4533 if (outfile_stat.st_ctime > out_info[j].ctime)
4534 {
4535 out_info[j].ctime = outfile_stat.st_ctime;
4536 out_info[j].seek = 0;
4537 }
4538
4539 fseek (fp, out_info[j].seek, SEEK_SET);
4540
4541 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4542
4543 while (!feof (fp))
4544 {
4545 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4546
4547 if (ptr == NULL) break;
4548
4549 int line_len = strlen (line_buf);
4550
4551 if (line_len <= 0) continue;
4552
4553 int iter = MAX_CUT_TRIES;
4554
4555 for (uint i = line_len - 1; i && iter; i--, line_len--)
4556 {
4557 if (line_buf[i] != separator) continue;
4558
4559 int parser_status = PARSER_OK;
4560
4561 if ((hash_mode != 2500) && (hash_mode != 6800))
4562 {
4563 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4564 }
4565
4566 uint found = 0;
4567
4568 if (parser_status == PARSER_OK)
4569 {
4570 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4571 {
4572 if (data.salts_shown[salt_pos] == 1) continue;
4573
4574 salt_t *salt_buf = &data.salts_buf[salt_pos];
4575
4576 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4577 {
4578 uint idx = salt_buf->digests_offset + digest_pos;
4579
4580 if (data.digests_shown[idx] == 1) continue;
4581
4582 uint cracked = 0;
4583
4584 if (hash_mode == 6800)
4585 {
4586 if (i == salt_buf->salt_len)
4587 {
4588 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4589 }
4590 }
4591 else if (hash_mode == 2500)
4592 {
4593 // BSSID : MAC1 : MAC2 (:plain)
4594 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4595 {
4596 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4597
4598 if (!cracked) continue;
4599
4600 // now compare MAC1 and MAC2 too, since we have this additional info
4601 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4602 char *mac2_pos = mac1_pos + 12 + 1;
4603
4604 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4605 wpa_t *wpa = &wpas[salt_pos];
4606
4607 // compare hex string(s) vs binary MAC address(es)
4608
4609 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4610 {
4611 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4612 {
4613 cracked = 0;
4614
4615 break;
4616 }
4617 }
4618
4619 // early skip ;)
4620 if (!cracked) continue;
4621
4622 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4623 {
4624 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4625 {
4626 cracked = 0;
4627
4628 break;
4629 }
4630 }
4631 }
4632 }
4633 else
4634 {
4635 char *digests_buf_ptr = (char *) data.digests_buf;
4636
4637 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4638
4639 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4640 }
4641
4642 if (cracked == 1)
4643 {
4644 found = 1;
4645
4646 data.digests_shown[idx] = 1;
4647
4648 data.digests_done++;
4649
4650 salt_buf->digests_done++;
4651
4652 if (salt_buf->digests_done == salt_buf->digests_cnt)
4653 {
4654 data.salts_shown[salt_pos] = 1;
4655
4656 data.salts_done++;
4657
4658 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4659 }
4660 }
4661 }
4662
4663 if (data.devices_status == STATUS_CRACKED) break;
4664 }
4665 }
4666
4667 if (found) break;
4668
4669 if (data.devices_status == STATUS_CRACKED) break;
4670
4671 iter--;
4672 }
4673
4674 if (data.devices_status == STATUS_CRACKED) break;
4675 }
4676
4677 myfree (line_buf);
4678
4679 out_info[j].seek = ftell (fp);
4680
4681 //hc_thread_mutex_unlock (mux_display);
4682
4683 fclose (fp);
4684 }
4685 }
4686 }
4687 }
4688
4689 check_left = outfile_check_timer;
4690 }
4691 }
4692
4693 if (esalt_size) local_free (hash_buf.esalt);
4694
4695 if (isSalted) local_free (hash_buf.salt);
4696
4697 local_free (hash_buf.digest);
4698
4699 local_free (out_info);
4700
4701 local_free (out_files);
4702
4703 p = NULL;
4704
4705 return (p);
4706 }
4707
4708 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4709 {
4710 //if (device_param->pws_cnt < device_param->kernel_power)
4711 //{
4712 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4713
4714 u8 *ptr = (u8 *) pw->i;
4715
4716 memcpy (ptr, pw_buf, pw_len);
4717
4718 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4719
4720 pw->pw_len = pw_len;
4721
4722 device_param->pws_cnt++;
4723 //}
4724 //else
4725 //{
4726 // fprintf (stderr, "BUG pw_add()!!\n");
4727 //
4728 // return;
4729 //}
4730 }
4731
4732 static void set_kernel_power_final (const u64 kernel_power_final)
4733 {
4734 if (data.quiet == 0)
4735 {
4736 clear_prompt ();
4737
4738 //log_info ("");
4739
4740 log_info ("INFO: approaching final keyspace, workload adjusted");
4741 log_info ("");
4742
4743 fprintf (stdout, "%s", PROMPT);
4744
4745 fflush (stdout);
4746 }
4747
4748 data.kernel_power_final = kernel_power_final;
4749 }
4750
4751 static u32 get_power (hc_device_param_t *device_param)
4752 {
4753 const u64 kernel_power_final = data.kernel_power_final;
4754
4755 if (kernel_power_final)
4756 {
4757 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4758
4759 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4760
4761 // work should be at least the hardware power available without any accelerator
4762
4763 const u64 work = MAX (words_left_device, device_param->hardware_power);
4764
4765 return work;
4766 }
4767
4768 return device_param->kernel_power;
4769 }
4770
4771 static uint get_work (hc_device_param_t *device_param, const u64 max)
4772 {
4773 hc_thread_mutex_lock (mux_dispatcher);
4774
4775 const u64 words_cur = data.words_cur;
4776 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4777
4778 device_param->words_off = words_cur;
4779
4780 const u64 kernel_power_all = data.kernel_power_all;
4781
4782 const u64 words_left = words_base - words_cur;
4783
4784 if (words_left < kernel_power_all)
4785 {
4786 if (data.kernel_power_final == 0)
4787 {
4788 set_kernel_power_final (words_left);
4789 }
4790 }
4791
4792 const u32 kernel_power = get_power (device_param);
4793
4794 uint work = MIN (words_left, kernel_power);
4795
4796 work = MIN (work, max);
4797
4798 data.words_cur += work;
4799
4800 hc_thread_mutex_unlock (mux_dispatcher);
4801
4802 return work;
4803 }
4804
4805 static void *thread_autotune (void *p)
4806 {
4807 hc_device_param_t *device_param = (hc_device_param_t *) p;
4808
4809 if (device_param->skipped) return NULL;
4810
4811 autotune (device_param);
4812
4813 return NULL;
4814 }
4815
4816 static void *thread_calc_stdin (void *p)
4817 {
4818 hc_device_param_t *device_param = (hc_device_param_t *) p;
4819
4820 if (device_param->skipped) return NULL;
4821
4822 char *buf = (char *) mymalloc (HCBUFSIZ);
4823
4824 const uint attack_kern = data.attack_kern;
4825
4826 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4827 {
4828 hc_thread_mutex_lock (mux_dispatcher);
4829
4830 if (feof (stdin) != 0)
4831 {
4832 hc_thread_mutex_unlock (mux_dispatcher);
4833
4834 break;
4835 }
4836
4837 uint words_cur = 0;
4838
4839 while (words_cur < device_param->kernel_power)
4840 {
4841 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4842
4843 if (line_buf == NULL) break;
4844
4845 uint line_len = in_superchop (line_buf);
4846
4847 line_len = convert_from_hex (line_buf, line_len);
4848
4849 // post-process rule engine
4850
4851 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4852 {
4853 char rule_buf_out[BLOCK_SIZE] = { 0 };
4854
4855 int rule_len_out = -1;
4856
4857 if (line_len < BLOCK_SIZE)
4858 {
4859 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4860 }
4861
4862 if (rule_len_out < 0) continue;
4863
4864 line_buf = rule_buf_out;
4865 line_len = rule_len_out;
4866 }
4867
4868 if (line_len > PW_MAX)
4869 {
4870 continue;
4871 }
4872
4873 // hmm that's always the case, or?
4874
4875 if (attack_kern == ATTACK_KERN_STRAIGHT)
4876 {
4877 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4878 {
4879 hc_thread_mutex_lock (mux_counter);
4880
4881 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4882 {
4883 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4884 }
4885
4886 hc_thread_mutex_unlock (mux_counter);
4887
4888 continue;
4889 }
4890 }
4891
4892 pw_add (device_param, (u8 *) line_buf, line_len);
4893
4894 words_cur++;
4895
4896 if (data.devices_status == STATUS_CRACKED) break;
4897 if (data.devices_status == STATUS_ABORTED) break;
4898 if (data.devices_status == STATUS_QUIT) break;
4899 if (data.devices_status == STATUS_BYPASS) break;
4900 }
4901
4902 hc_thread_mutex_unlock (mux_dispatcher);
4903
4904 if (data.devices_status == STATUS_CRACKED) break;
4905 if (data.devices_status == STATUS_ABORTED) break;
4906 if (data.devices_status == STATUS_QUIT) break;
4907 if (data.devices_status == STATUS_BYPASS) break;
4908
4909 // flush
4910
4911 const uint pws_cnt = device_param->pws_cnt;
4912
4913 if (pws_cnt)
4914 {
4915 run_copy (device_param, pws_cnt);
4916
4917 run_cracker (device_param, pws_cnt);
4918
4919 device_param->pws_cnt = 0;
4920
4921 /*
4922 still required?
4923 if (attack_kern == ATTACK_KERN_STRAIGHT)
4924 {
4925 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4926 }
4927 else if (attack_kern == ATTACK_KERN_COMBI)
4928 {
4929 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4930 }
4931 */
4932 }
4933 }
4934
4935 device_param->kernel_accel = 0;
4936 device_param->kernel_loops = 0;
4937
4938 myfree (buf);
4939
4940 return NULL;
4941 }
4942
4943 static void *thread_calc (void *p)
4944 {
4945 hc_device_param_t *device_param = (hc_device_param_t *) p;
4946
4947 if (device_param->skipped) return NULL;
4948
4949 const uint attack_mode = data.attack_mode;
4950 const uint attack_kern = data.attack_kern;
4951
4952 if (attack_mode == ATTACK_MODE_BF)
4953 {
4954 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4955 {
4956 const uint work = get_work (device_param, -1);
4957
4958 if (work == 0) break;
4959
4960 const u64 words_off = device_param->words_off;
4961 const u64 words_fin = words_off + work;
4962
4963 const uint pws_cnt = work;
4964
4965 device_param->pws_cnt = pws_cnt;
4966
4967 if (pws_cnt)
4968 {
4969 run_copy (device_param, pws_cnt);
4970
4971 run_cracker (device_param, pws_cnt);
4972
4973 device_param->pws_cnt = 0;
4974
4975 /*
4976 still required?
4977 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4978 */
4979 }
4980
4981 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4982
4983 if (data.devices_status == STATUS_CRACKED) break;
4984 if (data.devices_status == STATUS_ABORTED) break;
4985 if (data.devices_status == STATUS_QUIT) break;
4986 if (data.devices_status == STATUS_BYPASS) break;
4987
4988 if (data.benchmark == 1) break;
4989
4990 device_param->words_done = words_fin;
4991 }
4992 }
4993 else
4994 {
4995 const uint segment_size = data.segment_size;
4996
4997 char *dictfile = data.dictfile;
4998
4999 if (attack_mode == ATTACK_MODE_COMBI)
5000 {
5001 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5002 {
5003 dictfile = data.dictfile2;
5004 }
5005 }
5006
5007 FILE *fd = fopen (dictfile, "rb");
5008
5009 if (fd == NULL)
5010 {
5011 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
5012
5013 return NULL;
5014 }
5015
5016 if (attack_mode == ATTACK_MODE_COMBI)
5017 {
5018 const uint combs_mode = data.combs_mode;
5019
5020 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
5021 {
5022 const char *dictfilec = data.dictfile2;
5023
5024 FILE *combs_fp = fopen (dictfilec, "rb");
5025
5026 if (combs_fp == NULL)
5027 {
5028 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5029
5030 fclose (fd);
5031
5032 return NULL;
5033 }
5034
5035 device_param->combs_fp = combs_fp;
5036 }
5037 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5038 {
5039 const char *dictfilec = data.dictfile;
5040
5041 FILE *combs_fp = fopen (dictfilec, "rb");
5042
5043 if (combs_fp == NULL)
5044 {
5045 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5046
5047 fclose (fd);
5048
5049 return NULL;
5050 }
5051
5052 device_param->combs_fp = combs_fp;
5053 }
5054 }
5055
5056 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
5057
5058 wl_data->buf = (char *) mymalloc (segment_size);
5059 wl_data->avail = segment_size;
5060 wl_data->incr = segment_size;
5061 wl_data->cnt = 0;
5062 wl_data->pos = 0;
5063
5064 u64 words_cur = 0;
5065
5066 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5067 {
5068 u64 words_off = 0;
5069 u64 words_fin = 0;
5070
5071 u64 max = -1;
5072
5073 while (max)
5074 {
5075 const uint work = get_work (device_param, max);
5076
5077 if (work == 0) break;
5078
5079 max = 0;
5080
5081 words_off = device_param->words_off;
5082 words_fin = words_off + work;
5083
5084 char *line_buf;
5085 uint line_len;
5086
5087 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5088
5089 for ( ; words_cur < words_fin; words_cur++)
5090 {
5091 get_next_word (wl_data, fd, &line_buf, &line_len);
5092
5093 line_len = convert_from_hex (line_buf, line_len);
5094
5095 // post-process rule engine
5096
5097 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5098 {
5099 char rule_buf_out[BLOCK_SIZE] = { 0 };
5100
5101 int rule_len_out = -1;
5102
5103 if (line_len < BLOCK_SIZE)
5104 {
5105 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5106 }
5107
5108 if (rule_len_out < 0) continue;
5109
5110 line_buf = rule_buf_out;
5111 line_len = rule_len_out;
5112 }
5113
5114 if (attack_kern == ATTACK_KERN_STRAIGHT)
5115 {
5116 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5117 {
5118 max++;
5119
5120 hc_thread_mutex_lock (mux_counter);
5121
5122 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5123 {
5124 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5125 }
5126
5127 hc_thread_mutex_unlock (mux_counter);
5128
5129 continue;
5130 }
5131 }
5132 else if (attack_kern == ATTACK_KERN_COMBI)
5133 {
5134 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5135 // since we still need to combine the plains
5136
5137 if (line_len > data.pw_max)
5138 {
5139 max++;
5140
5141 hc_thread_mutex_lock (mux_counter);
5142
5143 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5144 {
5145 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5146 }
5147
5148 hc_thread_mutex_unlock (mux_counter);
5149
5150 continue;
5151 }
5152 }
5153
5154 pw_add (device_param, (u8 *) line_buf, line_len);
5155
5156 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5157
5158 if (data.devices_status == STATUS_CRACKED) break;
5159 if (data.devices_status == STATUS_ABORTED) break;
5160 if (data.devices_status == STATUS_QUIT) break;
5161 if (data.devices_status == STATUS_BYPASS) break;
5162 }
5163
5164 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5165
5166 if (data.devices_status == STATUS_CRACKED) break;
5167 if (data.devices_status == STATUS_ABORTED) break;
5168 if (data.devices_status == STATUS_QUIT) break;
5169 if (data.devices_status == STATUS_BYPASS) break;
5170 }
5171
5172 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5173
5174 if (data.devices_status == STATUS_CRACKED) break;
5175 if (data.devices_status == STATUS_ABORTED) break;
5176 if (data.devices_status == STATUS_QUIT) break;
5177 if (data.devices_status == STATUS_BYPASS) break;
5178
5179 //
5180 // flush
5181 //
5182
5183 const uint pws_cnt = device_param->pws_cnt;
5184
5185 if (pws_cnt)
5186 {
5187 run_copy (device_param, pws_cnt);
5188
5189 run_cracker (device_param, pws_cnt);
5190
5191 device_param->pws_cnt = 0;
5192
5193 /*
5194 still required?
5195 if (attack_kern == ATTACK_KERN_STRAIGHT)
5196 {
5197 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5198 }
5199 else if (attack_kern == ATTACK_KERN_COMBI)
5200 {
5201 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5202 }
5203 */
5204 }
5205
5206 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5207
5208 if (data.devices_status == STATUS_CRACKED) break;
5209 if (data.devices_status == STATUS_ABORTED) break;
5210 if (data.devices_status == STATUS_QUIT) break;
5211 if (data.devices_status == STATUS_BYPASS) break;
5212
5213 if (words_fin == 0) break;
5214
5215 device_param->words_done = words_fin;
5216 }
5217
5218 if (attack_mode == ATTACK_MODE_COMBI)
5219 {
5220 fclose (device_param->combs_fp);
5221 }
5222
5223 free (wl_data->buf);
5224 free (wl_data);
5225
5226 fclose (fd);
5227 }
5228
5229 device_param->kernel_accel = 0;
5230 device_param->kernel_loops = 0;
5231
5232 return NULL;
5233 }
5234
5235 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5236 {
5237 if (!device_param)
5238 {
5239 log_error ("ERROR: %s : Invalid argument", __func__);
5240
5241 exit (-1);
5242 }
5243
5244 salt_t *salt_buf = &data.salts_buf[salt_pos];
5245
5246 device_param->kernel_params_buf32[24] = salt_pos;
5247 device_param->kernel_params_buf32[27] = 1;
5248 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
5249 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
5250 device_param->kernel_params_buf32[30] = 0;
5251 device_param->kernel_params_buf32[31] = 1;
5252
5253 char *dictfile_old = data.dictfile;
5254
5255 const char *weak_hash_check = "weak-hash-check";
5256
5257 data.dictfile = (char *) weak_hash_check;
5258
5259 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5260
5261 data.kernel_rules_buf[0].cmds[0] = 0;
5262
5263 /**
5264 * run the kernel
5265 */
5266
5267 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5268 {
5269 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5270 }
5271 else
5272 {
5273 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5274
5275 uint loop_step = 16;
5276
5277 const uint iter = salt_buf->salt_iter;
5278
5279 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5280 {
5281 uint loop_left = iter - loop_pos;
5282
5283 loop_left = MIN (loop_left, loop_step);
5284
5285 device_param->kernel_params_buf32[25] = loop_pos;
5286 device_param->kernel_params_buf32[26] = loop_left;
5287
5288 run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5289 }
5290
5291 run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5292 }
5293
5294 /**
5295 * result
5296 */
5297
5298 check_cracked (device_param, salt_pos);
5299
5300 /**
5301 * cleanup
5302 */
5303
5304 device_param->kernel_params_buf32[24] = 0;
5305 device_param->kernel_params_buf32[25] = 0;
5306 device_param->kernel_params_buf32[26] = 0;
5307 device_param->kernel_params_buf32[27] = 0;
5308 device_param->kernel_params_buf32[28] = 0;
5309 device_param->kernel_params_buf32[29] = 0;
5310 device_param->kernel_params_buf32[30] = 0;
5311 device_param->kernel_params_buf32[31] = 0;
5312
5313 data.dictfile = dictfile_old;
5314
5315 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5316 }
5317
5318 // hlfmt hashcat
5319
5320 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5321 {
5322 if (data.username == 0)
5323 {
5324 *hashbuf_pos = line_buf;
5325 *hashbuf_len = line_len;
5326 }
5327 else
5328 {
5329 char *pos = line_buf;
5330 int len = line_len;
5331
5332 for (int i = 0; i < line_len; i++, pos++, len--)
5333 {
5334 if (line_buf[i] == data.separator)
5335 {
5336 pos++;
5337
5338 len--;
5339
5340 break;
5341 }
5342 }
5343
5344 *hashbuf_pos = pos;
5345 *hashbuf_len = len;
5346 }
5347 }
5348
5349 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5350 {
5351 char *pos = NULL;
5352 int len = 0;
5353
5354 int sep_cnt = 0;
5355
5356 for (int i = 0; i < line_len; i++)
5357 {
5358 if (line_buf[i] == data.separator)
5359 {
5360 sep_cnt++;
5361
5362 continue;
5363 }
5364
5365 if (sep_cnt == 0)
5366 {
5367 if (pos == NULL) pos = line_buf + i;
5368
5369 len++;
5370 }
5371 }
5372
5373 *userbuf_pos = pos;
5374 *userbuf_len = len;
5375 }
5376
5377 // hlfmt pwdump
5378
5379 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5380 {
5381 int sep_cnt = 0;
5382
5383 int sep2_len = 0;
5384 int sep3_len = 0;
5385
5386 for (int i = 0; i < line_len; i++)
5387 {
5388 if (line_buf[i] == ':')
5389 {
5390 sep_cnt++;
5391
5392 continue;
5393 }
5394
5395 if (sep_cnt == 2) sep2_len++;
5396 if (sep_cnt == 3) sep3_len++;
5397 }
5398
5399 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5400
5401 return 0;
5402 }
5403
5404 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5405 {
5406 char *pos = NULL;
5407 int len = 0;
5408
5409 int sep_cnt = 0;
5410
5411 for (int i = 0; i < line_len; i++)
5412 {
5413 if (line_buf[i] == ':')
5414 {
5415 sep_cnt++;
5416
5417 continue;
5418 }
5419
5420 if (data.hash_mode == 1000)
5421 {
5422 if (sep_cnt == 3)
5423 {
5424 if (pos == NULL) pos = line_buf + i;
5425
5426 len++;
5427 }
5428 }
5429 else if (data.hash_mode == 3000)
5430 {
5431 if (sep_cnt == 2)
5432 {
5433 if (pos == NULL) pos = line_buf + i;
5434
5435 len++;
5436 }
5437 }
5438 }
5439
5440 *hashbuf_pos = pos;
5441 *hashbuf_len = len;
5442 }
5443
5444 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5445 {
5446 char *pos = NULL;
5447 int len = 0;
5448
5449 int sep_cnt = 0;
5450
5451 for (int i = 0; i < line_len; i++)
5452 {
5453 if (line_buf[i] == ':')
5454 {
5455 sep_cnt++;
5456
5457 continue;
5458 }
5459
5460 if (sep_cnt == 0)
5461 {
5462 if (pos == NULL) pos = line_buf + i;
5463
5464 len++;
5465 }
5466 }
5467
5468 *userbuf_pos = pos;
5469 *userbuf_len = len;
5470 }
5471
5472 // hlfmt passwd
5473
5474 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5475 {
5476 int sep_cnt = 0;
5477
5478 char sep5_first = 0;
5479 char sep6_first = 0;
5480
5481 for (int i = 0; i < line_len; i++)
5482 {
5483 if (line_buf[i] == ':')
5484 {
5485 sep_cnt++;
5486
5487 continue;
5488 }
5489
5490 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5491 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5492 }
5493
5494 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5495
5496 return 0;
5497 }
5498
5499 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5500 {
5501 char *pos = NULL;
5502 int len = 0;
5503
5504 int sep_cnt = 0;
5505
5506 for (int i = 0; i < line_len; i++)
5507 {
5508 if (line_buf[i] == ':')
5509 {
5510 sep_cnt++;
5511
5512 continue;
5513 }
5514
5515 if (sep_cnt == 1)
5516 {
5517 if (pos == NULL) pos = line_buf + i;
5518
5519 len++;
5520 }
5521 }
5522
5523 *hashbuf_pos = pos;
5524 *hashbuf_len = len;
5525 }
5526
5527 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5528 {
5529 char *pos = NULL;
5530 int len = 0;
5531
5532 int sep_cnt = 0;
5533
5534 for (int i = 0; i < line_len; i++)
5535 {
5536 if (line_buf[i] == ':')
5537 {
5538 sep_cnt++;
5539
5540 continue;
5541 }
5542
5543 if (sep_cnt == 0)
5544 {
5545 if (pos == NULL) pos = line_buf + i;
5546
5547 len++;
5548 }
5549 }
5550
5551 *userbuf_pos = pos;
5552 *userbuf_len = len;
5553 }
5554
5555 // hlfmt shadow
5556
5557 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5558 {
5559 int sep_cnt = 0;
5560
5561 for (int i = 0; i < line_len; i++)
5562 {
5563 if (line_buf[i] == ':') sep_cnt++;
5564 }
5565
5566 if (sep_cnt == 8) return 1;
5567
5568 return 0;
5569 }
5570
5571 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5572 {
5573 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5574 }
5575
5576 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5577 {
5578 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5579 }
5580
5581 // hlfmt main
5582
5583 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5584 {
5585 switch (hashfile_format)
5586 {
5587 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5588 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5589 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5590 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5591 }
5592 }
5593
5594 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5595 {
5596 switch (hashfile_format)
5597 {
5598 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5599 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5600 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5601 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5602 }
5603 }
5604
5605 char *strhlfmt (const uint hashfile_format)
5606 {
5607 switch (hashfile_format)
5608 {
5609 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5610 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5611 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5612 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5613 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5614 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5615 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5616 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5617 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5618 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5619 }
5620
5621 return ((char *) "Unknown");
5622 }
5623
5624 static uint hlfmt_detect (FILE *fp, uint max_check)
5625 {
5626 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5627
5628 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5629 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5630
5631 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5632
5633 uint num_check = 0;
5634
5635 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5636
5637 while (!feof (fp))
5638 {
5639 int line_len = fgetl (fp, line_buf);
5640
5641 if (line_len == 0) continue;
5642
5643 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5644 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5645 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5646
5647 if (num_check == max_check) break;
5648
5649 num_check++;
5650 }
5651
5652 myfree (line_buf);
5653
5654 uint hashlist_format = HLFMT_HASHCAT;
5655
5656 for (int i = 1; i < HLFMTS_CNT; i++)
5657 {
5658 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5659
5660 hashlist_format = i;
5661 }
5662
5663 free (formats_cnt);
5664
5665 return hashlist_format;
5666 }
5667
5668 /**
5669 * some further helper function
5670 */
5671
5672 // wrapper around mymalloc for ADL
5673
5674 #if defined(HAVE_HWMON)
5675 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5676 {
5677 return mymalloc (iSize);
5678 }
5679 #endif
5680
5681 static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, const uint dgst_shifts, char *digests_buf_ptr, const uint bitmap_mask, const uint bitmap_size, uint *bitmap_a, uint *bitmap_b, uint *bitmap_c, uint *bitmap_d, const u64 collisions_max)
5682 {
5683 u64 collisions = 0;
5684
5685 const uint dgst_pos0 = data.dgst_pos0;
5686 const uint dgst_pos1 = data.dgst_pos1;
5687 const uint dgst_pos2 = data.dgst_pos2;
5688 const uint dgst_pos3 = data.dgst_pos3;
5689
5690 memset (bitmap_a, 0, bitmap_size);
5691 memset (bitmap_b, 0, bitmap_size);
5692 memset (bitmap_c, 0, bitmap_size);
5693 memset (bitmap_d, 0, bitmap_size);
5694
5695 for (uint i = 0; i < digests_cnt; i++)
5696 {
5697 uint *digest_ptr = (uint *) digests_buf_ptr;
5698
5699 digests_buf_ptr += dgst_size;
5700
5701 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5702 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5703 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5704 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5705
5706 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5707 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5708 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5709 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5710
5711 if (bitmap_a[idx0] & val0) collisions++;
5712 if (bitmap_b[idx1] & val1) collisions++;
5713 if (bitmap_c[idx2] & val2) collisions++;
5714 if (bitmap_d[idx3] & val3) collisions++;
5715
5716 bitmap_a[idx0] |= val0;
5717 bitmap_b[idx1] |= val1;
5718 bitmap_c[idx2] |= val2;
5719 bitmap_d[idx3] |= val3;
5720
5721 if (collisions >= collisions_max) return 0x7fffffff;
5722 }
5723
5724 return collisions;
5725 }
5726
5727 /**
5728 * main
5729 */
5730
5731 #ifdef WIN
5732 void SetConsoleWindowSize (const int x)
5733 {
5734 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5735
5736 if (h == INVALID_HANDLE_VALUE) return;
5737
5738 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5739
5740 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5741
5742 SMALL_RECT *sr = &bufferInfo.srWindow;
5743
5744 sr->Right = MAX (sr->Right, x - 1);
5745
5746 COORD co;
5747
5748 co.X = sr->Right + 1;
5749 co.Y = 9999;
5750
5751 if (!SetConsoleScreenBufferSize (h, co)) return;
5752
5753 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5754 }
5755 #endif
5756
5757 int main (int argc, char **argv)
5758 {
5759 #ifdef WIN
5760 SetConsoleWindowSize (132);
5761 #endif
5762
5763 /**
5764 * To help users a bit
5765 */
5766
5767 char *compute = getenv ("COMPUTE");
5768
5769 if (compute)
5770 {
5771 static char display[100];
5772
5773 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5774
5775 putenv (display);
5776 }
5777 else
5778 {
5779 if (getenv ("DISPLAY") == NULL)
5780 putenv ((char *) "DISPLAY=:0");
5781 }
5782
5783 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5784 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5785
5786 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5787 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5788
5789 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5790 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5791
5792 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5793 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5794
5795 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5796 putenv ((char *) "POCL_KERNEL_CACHE=0");
5797
5798 umask (077);
5799
5800 /**
5801 * Real init
5802 */
5803
5804 memset (&data, 0, sizeof (hc_global_data_t));
5805
5806 time_t proc_start;
5807
5808 time (&proc_start);
5809
5810 data.proc_start = proc_start;
5811
5812 int myargc = argc;
5813 char **myargv = argv;
5814
5815 hc_thread_mutex_init (mux_dispatcher);
5816 hc_thread_mutex_init (mux_counter);
5817 hc_thread_mutex_init (mux_display);
5818 hc_thread_mutex_init (mux_adl);
5819
5820 /**
5821 * commandline parameters
5822 */
5823
5824 uint usage = USAGE;
5825 uint version = VERSION;
5826 uint quiet = QUIET;
5827 uint benchmark = BENCHMARK;
5828 uint stdout_flag = STDOUT_FLAG;
5829 uint show = SHOW;
5830 uint left = LEFT;
5831 uint username = USERNAME;
5832 uint remove = REMOVE;
5833 uint remove_timer = REMOVE_TIMER;
5834 u64 skip = SKIP;
5835 u64 limit = LIMIT;
5836 uint keyspace = KEYSPACE;
5837 uint potfile_disable = POTFILE_DISABLE;
5838 char *potfile_path = NULL;
5839 uint debug_mode = DEBUG_MODE;
5840 char *debug_file = NULL;
5841 char *induction_dir = NULL;
5842 char *outfile_check_dir = NULL;
5843 uint force = FORCE;
5844 uint runtime = RUNTIME;
5845 uint hash_mode = HASH_MODE;
5846 uint attack_mode = ATTACK_MODE;
5847 uint markov_disable = MARKOV_DISABLE;
5848 uint markov_classic = MARKOV_CLASSIC;
5849 uint markov_threshold = MARKOV_THRESHOLD;
5850 char *markov_hcstat = NULL;
5851 char *outfile = NULL;
5852 uint outfile_format = OUTFILE_FORMAT;
5853 uint outfile_autohex = OUTFILE_AUTOHEX;
5854 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5855 uint restore = RESTORE;
5856 uint restore_timer = RESTORE_TIMER;
5857 uint restore_disable = RESTORE_DISABLE;
5858 uint status = STATUS;
5859 uint status_timer = STATUS_TIMER;
5860 uint machine_readable = MACHINE_READABLE;
5861 uint loopback = LOOPBACK;
5862 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5863 char *session = NULL;
5864 uint hex_charset = HEX_CHARSET;
5865 uint hex_salt = HEX_SALT;
5866 uint hex_wordlist = HEX_WORDLIST;
5867 uint rp_gen = RP_GEN;
5868 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5869 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5870 uint rp_gen_seed = RP_GEN_SEED;
5871 char *rule_buf_l = (char *) RULE_BUF_L;
5872 char *rule_buf_r = (char *) RULE_BUF_R;
5873 uint increment = INCREMENT;
5874 uint increment_min = INCREMENT_MIN;
5875 uint increment_max = INCREMENT_MAX;
5876 char *cpu_affinity = NULL;
5877 OCL_PTR *ocl = NULL;
5878 char *opencl_devices = NULL;
5879 char *opencl_platforms = NULL;
5880 char *opencl_device_types = NULL;
5881 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5882 char *truecrypt_keyfiles = NULL;
5883 char *veracrypt_keyfiles = NULL;
5884 uint veracrypt_pim = 0;
5885 uint workload_profile = WORKLOAD_PROFILE;
5886 uint kernel_accel = KERNEL_ACCEL;
5887 uint kernel_loops = KERNEL_LOOPS;
5888 uint nvidia_spin_damp = NVIDIA_SPIN_DAMP;
5889 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5890 #ifdef HAVE_HWMON
5891 uint gpu_temp_abort = GPU_TEMP_ABORT;
5892 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5893 uint powertune_enable = POWERTUNE_ENABLE;
5894 #endif
5895 uint logfile_disable = LOGFILE_DISABLE;
5896 uint segment_size = SEGMENT_SIZE;
5897 uint scrypt_tmto = SCRYPT_TMTO;
5898 char separator = SEPARATOR;
5899 uint bitmap_min = BITMAP_MIN;
5900 uint bitmap_max = BITMAP_MAX;
5901 char *custom_charset_1 = NULL;
5902 char *custom_charset_2 = NULL;
5903 char *custom_charset_3 = NULL;
5904 char *custom_charset_4 = NULL;
5905
5906 #define IDX_HELP 'h'
5907 #define IDX_VERSION 'V'
5908 #define IDX_VERSION_LOWER 'v'
5909 #define IDX_QUIET 0xff02
5910 #define IDX_SHOW 0xff03
5911 #define IDX_LEFT 0xff04
5912 #define IDX_REMOVE 0xff05
5913 #define IDX_REMOVE_TIMER 0xff37
5914 #define IDX_SKIP 's'
5915 #define IDX_LIMIT 'l'
5916 #define IDX_KEYSPACE 0xff35
5917 #define IDX_POTFILE_DISABLE 0xff06
5918 #define IDX_POTFILE_PATH 0xffe0
5919 #define IDX_DEBUG_MODE 0xff43
5920 #define IDX_DEBUG_FILE 0xff44
5921 #define IDX_INDUCTION_DIR 0xff46
5922 #define IDX_OUTFILE_CHECK_DIR 0xff47
5923 #define IDX_USERNAME 0xff07
5924 #define IDX_FORCE 0xff08
5925 #define IDX_RUNTIME 0xff09
5926 #define IDX_BENCHMARK 'b'
5927 #define IDX_STDOUT_FLAG 0xff77
5928 #define IDX_HASH_MODE 'm'
5929 #define IDX_ATTACK_MODE 'a'
5930 #define IDX_RP_FILE 'r'
5931 #define IDX_RP_GEN 'g'
5932 #define IDX_RP_GEN_FUNC_MIN 0xff10
5933 #define IDX_RP_GEN_FUNC_MAX 0xff11
5934 #define IDX_RP_GEN_SEED 0xff34
5935 #define IDX_RULE_BUF_L 'j'
5936 #define IDX_RULE_BUF_R 'k'
5937 #define IDX_INCREMENT 'i'
5938 #define IDX_INCREMENT_MIN 0xff12
5939 #define IDX_INCREMENT_MAX 0xff13
5940 #define IDX_OUTFILE 'o'
5941 #define IDX_OUTFILE_FORMAT 0xff14
5942 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5943 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5944 #define IDX_RESTORE 0xff15
5945 #define IDX_RESTORE_DISABLE 0xff27
5946 #define IDX_STATUS 0xff17
5947 #define IDX_STATUS_TIMER 0xff18
5948 #define IDX_MACHINE_READABLE 0xff50
5949 #define IDX_LOOPBACK 0xff38
5950 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5951 #define IDX_SESSION 0xff19
5952 #define IDX_HEX_CHARSET 0xff20
5953 #define IDX_HEX_SALT 0xff21
5954 #define IDX_HEX_WORDLIST 0xff40
5955 #define IDX_MARKOV_DISABLE 0xff22
5956 #define IDX_MARKOV_CLASSIC 0xff23
5957 #define IDX_MARKOV_THRESHOLD 't'
5958 #define IDX_MARKOV_HCSTAT 0xff24
5959 #define IDX_CPU_AFFINITY 0xff25
5960 #define IDX_OPENCL_DEVICES 'd'
5961 #define IDX_OPENCL_PLATFORMS 0xff72
5962 #define IDX_OPENCL_DEVICE_TYPES 'D'
5963 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5964 #define IDX_WORKLOAD_PROFILE 'w'
5965 #define IDX_KERNEL_ACCEL 'n'
5966 #define IDX_KERNEL_LOOPS 'u'
5967 #define IDX_NVIDIA_SPIN_DAMP 0xff79
5968 #define IDX_GPU_TEMP_DISABLE 0xff29
5969 #define IDX_GPU_TEMP_ABORT 0xff30
5970 #define IDX_GPU_TEMP_RETAIN 0xff31
5971 #define IDX_POWERTUNE_ENABLE 0xff41
5972 #define IDX_LOGFILE_DISABLE 0xff51
5973 #define IDX_TRUECRYPT_KEYFILES 0xff52
5974 #define IDX_VERACRYPT_KEYFILES 0xff53
5975 #define IDX_VERACRYPT_PIM 0xff54
5976 #define IDX_SCRYPT_TMTO 0xff61
5977 #define IDX_SEGMENT_SIZE 'c'
5978 #define IDX_SEPARATOR 'p'
5979 #define IDX_BITMAP_MIN 0xff70
5980 #define IDX_BITMAP_MAX 0xff71
5981 #define IDX_CUSTOM_CHARSET_1 '1'
5982 #define IDX_CUSTOM_CHARSET_2 '2'
5983 #define IDX_CUSTOM_CHARSET_3 '3'
5984 #define IDX_CUSTOM_CHARSET_4 '4'
5985
5986 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:D:n:u:c:p:s:l:1:2:3:4:ibw:";
5987
5988 struct option long_options[] =
5989 {
5990 {"help", no_argument, 0, IDX_HELP},
5991 {"version", no_argument, 0, IDX_VERSION},
5992 {"quiet", no_argument, 0, IDX_QUIET},
5993 {"show", no_argument, 0, IDX_SHOW},
5994 {"left", no_argument, 0, IDX_LEFT},
5995 {"username", no_argument, 0, IDX_USERNAME},
5996 {"remove", no_argument, 0, IDX_REMOVE},
5997 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5998 {"skip", required_argument, 0, IDX_SKIP},
5999 {"limit", required_argument, 0, IDX_LIMIT},
6000 {"keyspace", no_argument, 0, IDX_KEYSPACE},
6001 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
6002 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
6003 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
6004 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
6005 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
6006 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
6007 {"force", no_argument, 0, IDX_FORCE},
6008 {"benchmark", no_argument, 0, IDX_BENCHMARK},
6009 {"stdout", no_argument, 0, IDX_STDOUT_FLAG},
6010 {"restore", no_argument, 0, IDX_RESTORE},
6011 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
6012 {"status", no_argument, 0, IDX_STATUS},
6013 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
6014 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
6015 {"loopback", no_argument, 0, IDX_LOOPBACK},
6016 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
6017 {"session", required_argument, 0, IDX_SESSION},
6018 {"runtime", required_argument, 0, IDX_RUNTIME},
6019 {"generate-rules", required_argument, 0, IDX_RP_GEN},
6020 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
6021 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
6022 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
6023 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
6024 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
6025 {"hash-type", required_argument, 0, IDX_HASH_MODE},
6026 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
6027 {"rules-file", required_argument, 0, IDX_RP_FILE},
6028 {"outfile", required_argument, 0, IDX_OUTFILE},
6029 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
6030 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
6031 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
6032 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
6033 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
6034 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
6035 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
6036 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
6037 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
6038 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
6039 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
6040 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
6041 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
6042 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
6043 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
6044 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
6045 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
6046 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
6047 {"nvidia-spin-damp", required_argument, 0, IDX_NVIDIA_SPIN_DAMP},
6048 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
6049 #ifdef HAVE_HWMON
6050 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
6051 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
6052 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
6053 #endif // HAVE_HWMON
6054 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
6055 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
6056 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
6057 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
6058 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
6059 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
6060 {"seperator", required_argument, 0, IDX_SEPARATOR},
6061 {"separator", required_argument, 0, IDX_SEPARATOR},
6062 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
6063 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
6064 {"increment", no_argument, 0, IDX_INCREMENT},
6065 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
6066 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
6067 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
6068 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
6069 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
6070 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
6071 {0, 0, 0, 0}
6072 };
6073
6074 uint rp_files_cnt = 0;
6075
6076 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6077
6078 int option_index = 0;
6079 int c = -1;
6080
6081 optind = 1;
6082 optopt = 0;
6083
6084 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6085 {
6086 switch (c)
6087 {
6088 case IDX_HELP: usage = 1; break;
6089 case IDX_VERSION:
6090 case IDX_VERSION_LOWER: version = 1; break;
6091 case IDX_RESTORE: restore = 1; break;
6092 case IDX_SESSION: session = optarg; break;
6093 case IDX_SHOW: show = 1; break;
6094 case IDX_LEFT: left = 1; break;
6095 case '?': return (-1);
6096 }
6097 }
6098
6099 if (optopt != 0)
6100 {
6101 log_error ("ERROR: Invalid argument specified");
6102
6103 return (-1);
6104 }
6105
6106 /**
6107 * exit functions
6108 */
6109
6110 if (version)
6111 {
6112 log_info ("%s", VERSION_TAG);
6113
6114 return (0);
6115 }
6116
6117 if (usage)
6118 {
6119 usage_big_print (PROGNAME);
6120
6121 return (0);
6122 }
6123
6124 /**
6125 * session needs to be set, always!
6126 */
6127
6128 if (session == NULL) session = (char *) PROGNAME;
6129
6130 /**
6131 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6132 */
6133
6134 char *exec_path = get_exec_path ();
6135
6136 #ifdef LINUX
6137
6138 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6139 char *resolved_exec_path = realpath (exec_path, NULL);
6140
6141 char *install_dir = get_install_dir (resolved_exec_path);
6142 char *profile_dir = NULL;
6143 char *session_dir = NULL;
6144 char *shared_dir = NULL;
6145
6146 if (strcmp (install_dir, resolved_install_folder) == 0)
6147 {
6148 struct passwd *pw = getpwuid (getuid ());
6149
6150 const char *homedir = pw->pw_dir;
6151
6152 profile_dir = get_profile_dir (homedir);
6153 session_dir = get_session_dir (profile_dir);
6154 shared_dir = strdup (SHARED_FOLDER);
6155
6156 mkdir (profile_dir, 0700);
6157 mkdir (session_dir, 0700);
6158 }
6159 else
6160 {
6161 profile_dir = install_dir;
6162 session_dir = install_dir;
6163 shared_dir = install_dir;
6164 }
6165
6166 myfree (resolved_install_folder);
6167 myfree (resolved_exec_path);
6168
6169 #else
6170
6171 char *install_dir = get_install_dir (exec_path);
6172 char *profile_dir = install_dir;
6173 char *session_dir = install_dir;
6174 char *shared_dir = install_dir;
6175
6176 #endif
6177
6178 data.install_dir = install_dir;
6179 data.profile_dir = profile_dir;
6180 data.session_dir = session_dir;
6181 data.shared_dir = shared_dir;
6182
6183 myfree (exec_path);
6184
6185 /**
6186 * kernel cache, we need to make sure folder exist
6187 */
6188
6189 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6190
6191 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6192
6193 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6194
6195 mkdir (kernels_folder, 0700);
6196
6197 myfree (kernels_folder);
6198
6199 /**
6200 * session
6201 */
6202
6203 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6204
6205 data.session = session;
6206
6207 char *eff_restore_file = (char *) mymalloc (session_size);
6208 char *new_restore_file = (char *) mymalloc (session_size);
6209
6210 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
6211 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6212
6213 data.eff_restore_file = eff_restore_file;
6214 data.new_restore_file = new_restore_file;
6215
6216 if (((show == 1) || (left == 1)) && (restore == 1))
6217 {
6218 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6219 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6220
6221 return (-1);
6222 }
6223
6224 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6225 if ((show == 1) || (left == 1))
6226 {
6227 restore_disable = 1;
6228
6229 restore = 0;
6230 }
6231
6232 data.restore_disable = restore_disable;
6233
6234 restore_data_t *rd = init_restore (argc, argv);
6235
6236 data.rd = rd;
6237
6238 /**
6239 * restore file
6240 */
6241
6242 if (restore == 1)
6243 {
6244 read_restore (eff_restore_file, rd);
6245
6246 if (rd->version_bin < RESTORE_MIN)
6247 {
6248 log_error ("ERROR: Incompatible restore-file version");
6249
6250 return (-1);
6251 }
6252
6253 myargc = rd->argc;
6254 myargv = rd->argv;
6255
6256 #ifdef _POSIX
6257 rd->pid = getpid ();
6258 #elif _WIN
6259 rd->pid = GetCurrentProcessId ();
6260 #endif
6261 }
6262
6263 uint hash_mode_chgd = 0;
6264 uint runtime_chgd = 0;
6265 uint kernel_loops_chgd = 0;
6266 uint kernel_accel_chgd = 0;
6267 uint nvidia_spin_damp_chgd = 0;
6268 uint attack_mode_chgd = 0;
6269 uint outfile_format_chgd = 0;
6270 uint rp_gen_seed_chgd = 0;
6271 uint remove_timer_chgd = 0;
6272 uint increment_min_chgd = 0;
6273 uint increment_max_chgd = 0;
6274 uint workload_profile_chgd = 0;
6275 uint opencl_vector_width_chgd = 0;
6276
6277 optind = 1;
6278 optopt = 0;
6279 option_index = 0;
6280
6281 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6282 {
6283 switch (c)
6284 {
6285 //case IDX_HELP: usage = 1; break;
6286 //case IDX_VERSION: version = 1; break;
6287 //case IDX_RESTORE: restore = 1; break;
6288 case IDX_QUIET: quiet = 1; break;
6289 //case IDX_SHOW: show = 1; break;
6290 case IDX_SHOW: break;
6291 //case IDX_LEFT: left = 1; break;
6292 case IDX_LEFT: break;
6293 case IDX_USERNAME: username = 1; break;
6294 case IDX_REMOVE: remove = 1; break;
6295 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6296 remove_timer_chgd = 1; break;
6297 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6298 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6299 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6300 case IDX_DEBUG_FILE: debug_file = optarg; break;
6301 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6302 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6303 case IDX_FORCE: force = 1; break;
6304 case IDX_SKIP: skip = atoll (optarg); break;
6305 case IDX_LIMIT: limit = atoll (optarg); break;
6306 case IDX_KEYSPACE: keyspace = 1; break;
6307 case IDX_BENCHMARK: benchmark = 1; break;
6308 case IDX_STDOUT_FLAG: stdout_flag = 1; break;
6309 case IDX_RESTORE: break;
6310 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6311 case IDX_STATUS: status = 1; break;
6312 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6313 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6314 case IDX_LOOPBACK: loopback = 1; break;
6315 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6316 //case IDX_SESSION: session = optarg; break;
6317 case IDX_SESSION: break;
6318 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6319 hash_mode_chgd = 1; break;
6320 case IDX_RUNTIME: runtime = atoi (optarg);
6321 runtime_chgd = 1; break;
6322 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6323 attack_mode_chgd = 1; break;
6324 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6325 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6326 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6327 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6328 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6329 rp_gen_seed_chgd = 1; break;
6330 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6331 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6332 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6333 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6334 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6335 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6336 case IDX_OUTFILE: outfile = optarg; break;
6337 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6338 outfile_format_chgd = 1; break;
6339 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6340 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6341 case IDX_HEX_CHARSET: hex_charset = 1; break;
6342 case IDX_HEX_SALT: hex_salt = 1; break;
6343 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6344 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6345 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6346 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6347 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6348 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6349 opencl_vector_width_chgd = 1; break;
6350 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6351 workload_profile_chgd = 1; break;
6352 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6353 kernel_accel_chgd = 1; break;
6354 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6355 kernel_loops_chgd = 1; break;
6356 case IDX_NVIDIA_SPIN_DAMP: nvidia_spin_damp = atoi (optarg);
6357 nvidia_spin_damp_chgd = 1; break;
6358 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6359 #ifdef HAVE_HWMON
6360 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6361 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6362 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6363 #endif // HAVE_HWMON
6364 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6365 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6366 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6367 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6368 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6369 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6370 case IDX_SEPARATOR: separator = optarg[0]; break;
6371 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6372 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6373 case IDX_INCREMENT: increment = 1; break;
6374 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6375 increment_min_chgd = 1; break;
6376 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6377 increment_max_chgd = 1; break;
6378 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6379 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6380 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6381 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6382
6383 default:
6384 log_error ("ERROR: Invalid argument specified");
6385 return (-1);
6386 }
6387 }
6388
6389 if (optopt != 0)
6390 {
6391 log_error ("ERROR: Invalid argument specified");
6392
6393 return (-1);
6394 }
6395
6396 /**
6397 * Inform user things getting started,
6398 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6399 * - we do not need to check algorithm_pos
6400 */
6401
6402 if (quiet == 0)
6403 {
6404 if (benchmark == 1)
6405 {
6406 if (machine_readable == 0)
6407 {
6408 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6409 log_info ("");
6410 }
6411 else
6412 {
6413 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6414 }
6415 }
6416 else if (restore == 1)
6417 {
6418 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6419 log_info ("");
6420 }
6421 else if (stdout_flag == 1)
6422 {
6423 // do nothing
6424 }
6425 else
6426 {
6427 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6428 log_info ("");
6429 }
6430 }
6431
6432 /**
6433 * sanity check
6434 */
6435
6436 if (attack_mode > 7)
6437 {
6438 log_error ("ERROR: Invalid attack-mode specified");
6439
6440 return (-1);
6441 }
6442
6443 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6444 {
6445 log_error ("ERROR: Invalid runtime specified");
6446
6447 return (-1);
6448 }
6449
6450 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6451 {
6452 log_error ("ERROR: Invalid hash-type specified");
6453
6454 return (-1);
6455 }
6456
6457 // renamed hash modes
6458
6459 if (hash_mode_chgd)
6460 {
6461 int n = -1;
6462
6463 switch (hash_mode)
6464 {
6465 case 123: n = 124;
6466 break;
6467 }
6468
6469 if (n >= 0)
6470 {
6471 log_error ("Old -m specified, use -m %d instead", n);
6472
6473 return (-1);
6474 }
6475 }
6476
6477 if (username == 1)
6478 {
6479 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6480 {
6481 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6482
6483 return (-1);
6484 }
6485 }
6486
6487 if (outfile_format > 16)
6488 {
6489 log_error ("ERROR: Invalid outfile-format specified");
6490
6491 return (-1);
6492 }
6493
6494 if (left == 1)
6495 {
6496 if (outfile_format_chgd == 1)
6497 {
6498 if (outfile_format > 1)
6499 {
6500 log_error ("ERROR: Mixing outfile-format > 1 with left parameter is not allowed");
6501
6502 return (-1);
6503 }
6504 }
6505 else
6506 {
6507 outfile_format = OUTFILE_FMT_HASH;
6508 }
6509 }
6510
6511 if (show == 1)
6512 {
6513 if (outfile_format_chgd == 1)
6514 {
6515 if ((outfile_format > 7) && (outfile_format < 16))
6516 {
6517 log_error ("ERROR: Mixing outfile-format > 7 with show parameter is not allowed");
6518
6519 return (-1);
6520 }
6521 }
6522 }
6523
6524 if (increment_min < INCREMENT_MIN)
6525 {
6526 log_error ("ERROR: Invalid increment-min specified");
6527
6528 return (-1);
6529 }
6530
6531 if (increment_max > INCREMENT_MAX)
6532 {
6533 log_error ("ERROR: Invalid increment-max specified");
6534
6535 return (-1);
6536 }
6537
6538 if (increment_min > increment_max)
6539 {
6540 log_error ("ERROR: Invalid increment-min specified");
6541
6542 return (-1);
6543 }
6544
6545 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6546 {
6547 log_error ("ERROR: Increment is not allowed in attack-mode 0");
6548
6549 return (-1);
6550 }
6551
6552 if ((increment == 0) && (increment_min_chgd == 1))
6553 {
6554 log_error ("ERROR: Increment-min is only supported combined with increment switch");
6555
6556 return (-1);
6557 }
6558
6559 if ((increment == 0) && (increment_max_chgd == 1))
6560 {
6561 log_error ("ERROR: Increment-max is only supported combined with increment switch");
6562
6563 return (-1);
6564 }
6565
6566 if (rp_files_cnt && rp_gen)
6567 {
6568 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6569
6570 return (-1);
6571 }
6572
6573 if (rp_files_cnt || rp_gen)
6574 {
6575 if (attack_mode != ATTACK_MODE_STRAIGHT)
6576 {
6577 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6578
6579 return (-1);
6580 }
6581 }
6582
6583 if (rp_gen_func_min > rp_gen_func_max)
6584 {
6585 log_error ("ERROR: Invalid rp-gen-func-min specified");
6586
6587 return (-1);
6588 }
6589
6590 if (kernel_accel_chgd == 1)
6591 {
6592 if (force == 0)
6593 {
6594 log_info ("The manual use of the -n option (or --kernel-accel) is outdated");
6595 log_info ("Please consider using the -w option instead");
6596 log_info ("You can use --force to override this but do not post error reports if you do so");
6597 log_info ("");
6598
6599 return (-1);
6600 }
6601
6602 if (kernel_accel < 1)
6603 {
6604 log_error ("ERROR: Invalid kernel-accel specified");
6605
6606 return (-1);
6607 }
6608
6609 if (kernel_accel > 1024)
6610 {
6611 log_error ("ERROR: Invalid kernel-accel specified");
6612
6613 return (-1);
6614 }
6615 }
6616
6617 if (kernel_loops_chgd == 1)
6618 {
6619 if (force == 0)
6620 {
6621 log_info ("The manual use of the -u option (or --kernel-loops) is outdated");
6622 log_info ("Please consider using the -w option instead");
6623 log_info ("You can use --force to override this but do not post error reports if you do so");
6624 log_info ("");
6625
6626 return (-1);
6627 }
6628
6629 if (kernel_loops < 1)
6630 {
6631 log_error ("ERROR: Invalid kernel-loops specified");
6632
6633 return (-1);
6634 }
6635
6636 if (kernel_loops > 1024)
6637 {
6638 log_error ("ERROR: Invalid kernel-loops specified");
6639
6640 return (-1);
6641 }
6642 }
6643
6644 if ((workload_profile < 1) || (workload_profile > 4))
6645 {
6646 log_error ("ERROR: workload-profile %i not available", workload_profile);
6647
6648 return (-1);
6649 }
6650
6651 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6652 {
6653 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6654
6655 return (-1);
6656 }
6657
6658 if (show == 1 || left == 1)
6659 {
6660 attack_mode = ATTACK_MODE_NONE;
6661
6662 if (remove == 1)
6663 {
6664 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6665
6666 return (-1);
6667 }
6668
6669 if (potfile_disable == 1)
6670 {
6671 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6672
6673 return (-1);
6674 }
6675 }
6676
6677 uint attack_kern = ATTACK_KERN_NONE;
6678
6679 switch (attack_mode)
6680 {
6681 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6682 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6683 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6684 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6685 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6686 }
6687
6688 if (benchmark == 1)
6689 {
6690 if (myargv[optind] != 0)
6691 {
6692 log_error ("ERROR: Invalid argument for benchmark mode specified");
6693
6694 return (-1);
6695 }
6696
6697 if (attack_mode_chgd == 1)
6698 {
6699 if (attack_mode != ATTACK_MODE_BF)
6700 {
6701 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6702
6703 return (-1);
6704 }
6705 }
6706 }
6707 else
6708 {
6709 if (stdout_flag == 1) // no hash here
6710 {
6711 optind--;
6712 }
6713
6714 if (keyspace == 1)
6715 {
6716 int num_additional_params = 1;
6717
6718 if (attack_kern == ATTACK_KERN_COMBI)
6719 {
6720 num_additional_params = 2;
6721 }
6722
6723 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6724
6725 if (keyspace_wordlist_specified == 0) optind--;
6726 }
6727
6728 if (attack_kern == ATTACK_KERN_NONE)
6729 {
6730 if ((optind + 1) != myargc)
6731 {
6732 usage_mini_print (myargv[0]);
6733
6734 return (-1);
6735 }
6736 }
6737 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6738 {
6739 if ((optind + 1) > myargc)
6740 {
6741 usage_mini_print (myargv[0]);
6742
6743 return (-1);
6744 }
6745 }
6746 else if (attack_kern == ATTACK_KERN_COMBI)
6747 {
6748 if ((optind + 3) != myargc)
6749 {
6750 usage_mini_print (myargv[0]);
6751
6752 return (-1);
6753 }
6754 }
6755 else if (attack_kern == ATTACK_KERN_BF)
6756 {
6757 if ((optind + 1) > myargc)
6758 {
6759 usage_mini_print (myargv[0]);
6760
6761 return (-1);
6762 }
6763 }
6764 else
6765 {
6766 usage_mini_print (myargv[0]);
6767
6768 return (-1);
6769 }
6770 }
6771
6772 if (skip != 0 && limit != 0)
6773 {
6774 limit += skip;
6775 }
6776
6777 if (keyspace == 1)
6778 {
6779 if (show == 1)
6780 {
6781 log_error ("ERROR: Combining show parameter with keyspace parameter is not allowed");
6782
6783 return (-1);
6784 }
6785 else if (left == 1)
6786 {
6787 log_error ("ERROR: Combining left parameter with keyspace parameter is not allowed");
6788
6789 return (-1);
6790 }
6791
6792 potfile_disable = 1;
6793
6794 restore_disable = 1;
6795
6796 restore = 0;
6797
6798 weak_hash_threshold = 0;
6799
6800 quiet = 1;
6801 }
6802
6803 if (stdout_flag == 1)
6804 {
6805 status_timer = 0;
6806 restore_timer = 0;
6807 restore_disable = 1;
6808 restore = 0;
6809 potfile_disable = 1;
6810 weak_hash_threshold = 0;
6811 gpu_temp_disable = 1;
6812 hash_mode = 2000;
6813 quiet = 1;
6814 outfile_format = OUTFILE_FMT_PLAIN;
6815 kernel_accel = 1024;
6816 kernel_loops = 1024;
6817 force = 1;
6818 outfile_check_timer = 0;
6819 session = "stdout";
6820 opencl_vector_width = 1;
6821 }
6822
6823 if (remove_timer_chgd == 1)
6824 {
6825 if (remove == 0)
6826 {
6827 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6828
6829 return (-1);
6830 }
6831
6832 if (remove_timer < 1)
6833 {
6834 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6835
6836 return (-1);
6837 }
6838 }
6839
6840 if (loopback == 1)
6841 {
6842 if (attack_mode == ATTACK_MODE_STRAIGHT)
6843 {
6844 if ((rp_files_cnt == 0) && (rp_gen == 0))
6845 {
6846 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6847
6848 return (-1);
6849 }
6850 }
6851 else
6852 {
6853 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6854
6855 return (-1);
6856 }
6857 }
6858
6859 if (debug_mode > 0)
6860 {
6861 if (attack_mode != ATTACK_MODE_STRAIGHT)
6862 {
6863 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6864
6865 return (-1);
6866 }
6867
6868 if ((rp_files_cnt == 0) && (rp_gen == 0))
6869 {
6870 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6871
6872 return (-1);
6873 }
6874 }
6875
6876 if (debug_mode > 4)
6877 {
6878 log_error ("ERROR: Invalid debug-mode specified");
6879
6880 return (-1);
6881 }
6882
6883 if (debug_file != NULL)
6884 {
6885 if (debug_mode < 1)
6886 {
6887 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6888
6889 return (-1);
6890 }
6891 }
6892
6893 if (induction_dir != NULL)
6894 {
6895 if (attack_mode == ATTACK_MODE_BF)
6896 {
6897 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6898
6899 return (-1);
6900 }
6901 }
6902
6903 if (attack_mode != ATTACK_MODE_STRAIGHT)
6904 {
6905 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6906 {
6907 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6908
6909 return (-1);
6910 }
6911
6912 weak_hash_threshold = 0;
6913 }
6914
6915 if (nvidia_spin_damp > 100)
6916 {
6917 log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)");
6918
6919 return (-1);
6920 }
6921
6922
6923 /**
6924 * induction directory
6925 */
6926
6927 char *induction_directory = NULL;
6928
6929 if (attack_mode != ATTACK_MODE_BF)
6930 {
6931 if (induction_dir == NULL)
6932 {
6933 induction_directory = (char *) mymalloc (session_size);
6934
6935 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6936
6937 // create induction folder if it does not already exist
6938
6939 if (keyspace == 0)
6940 {
6941 if (rmdir (induction_directory) == -1)
6942 {
6943 if (errno == ENOENT)
6944 {
6945 // good, we can ignore
6946 }
6947 else if (errno == ENOTEMPTY)
6948 {
6949 char *induction_directory_mv = (char *) mymalloc (session_size);
6950
6951 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6952
6953 if (rename (induction_directory, induction_directory_mv) != 0)
6954 {
6955 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6956
6957 return (-1);
6958 }
6959 }
6960 else
6961 {
6962 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6963
6964 return (-1);
6965 }
6966 }
6967
6968 if (mkdir (induction_directory, 0700) == -1)
6969 {
6970 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6971
6972 return (-1);
6973 }
6974 }
6975 }
6976 else
6977 {
6978 induction_directory = induction_dir;
6979 }
6980 }
6981
6982 data.induction_directory = induction_directory;
6983
6984 /**
6985 * loopback
6986 */
6987
6988 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6989
6990 char *loopback_file = (char *) mymalloc (loopback_size);
6991
6992 /**
6993 * tuning db
6994 */
6995
6996 char tuning_db_file[256] = { 0 };
6997
6998 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6999
7000 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
7001
7002 /**
7003 * outfile-check directory
7004 */
7005
7006 char *outfile_check_directory = NULL;
7007
7008 if (outfile_check_dir == NULL)
7009 {
7010 outfile_check_directory = (char *) mymalloc (session_size);
7011
7012 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
7013 }
7014 else
7015 {
7016 outfile_check_directory = outfile_check_dir;
7017 }
7018
7019 data.outfile_check_directory = outfile_check_directory;
7020
7021 if (keyspace == 0)
7022 {
7023 struct stat outfile_check_stat;
7024
7025 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
7026 {
7027 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
7028
7029 if (is_dir == 0)
7030 {
7031 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
7032
7033 return (-1);
7034 }
7035 }
7036 else if (outfile_check_dir == NULL)
7037 {
7038 if (mkdir (outfile_check_directory, 0700) == -1)
7039 {
7040 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
7041
7042 return (-1);
7043 }
7044 }
7045 }
7046
7047 /**
7048 * special other stuff
7049 */
7050
7051 if (hash_mode == 9710)
7052 {
7053 outfile_format = 5;
7054 outfile_format_chgd = 1;
7055 }
7056
7057 if (hash_mode == 9810)
7058 {
7059 outfile_format = 5;
7060 outfile_format_chgd = 1;
7061 }
7062
7063 if (hash_mode == 10410)
7064 {
7065 outfile_format = 5;
7066 outfile_format_chgd = 1;
7067 }
7068
7069 /**
7070 * store stuff
7071 */
7072
7073 data.hash_mode = hash_mode;
7074 data.restore = restore;
7075 data.restore_timer = restore_timer;
7076 data.restore_disable = restore_disable;
7077 data.status = status;
7078 data.status_timer = status_timer;
7079 data.machine_readable = machine_readable;
7080 data.loopback = loopback;
7081 data.runtime = runtime;
7082 data.remove = remove;
7083 data.remove_timer = remove_timer;
7084 data.debug_mode = debug_mode;
7085 data.debug_file = debug_file;
7086 data.username = username;
7087 data.quiet = quiet;
7088 data.outfile = outfile;
7089 data.outfile_format = outfile_format;
7090 data.outfile_autohex = outfile_autohex;
7091 data.hex_charset = hex_charset;
7092 data.hex_salt = hex_salt;
7093 data.hex_wordlist = hex_wordlist;
7094 data.separator = separator;
7095 data.rp_files = rp_files;
7096 data.rp_files_cnt = rp_files_cnt;
7097 data.rp_gen = rp_gen;
7098 data.rp_gen_seed = rp_gen_seed;
7099 data.force = force;
7100 data.benchmark = benchmark;
7101 data.skip = skip;
7102 data.limit = limit;
7103 #ifdef HAVE_HWMON
7104 data.powertune_enable = powertune_enable;
7105 #endif
7106 data.logfile_disable = logfile_disable;
7107 data.truecrypt_keyfiles = truecrypt_keyfiles;
7108 data.veracrypt_keyfiles = veracrypt_keyfiles;
7109 data.veracrypt_pim = veracrypt_pim;
7110 data.scrypt_tmto = scrypt_tmto;
7111 data.workload_profile = workload_profile;
7112
7113 /**
7114 * cpu affinity
7115 */
7116
7117 if (cpu_affinity)
7118 {
7119 set_cpu_affinity (cpu_affinity);
7120 }
7121
7122 if (rp_gen_seed_chgd == 0)
7123 {
7124 srand (proc_start);
7125 }
7126 else
7127 {
7128 srand (rp_gen_seed);
7129 }
7130
7131 /**
7132 * logfile init
7133 */
7134
7135 if (logfile_disable == 0)
7136 {
7137 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7138
7139 char *logfile = (char *) mymalloc (logfile_size);
7140
7141 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7142
7143 data.logfile = logfile;
7144
7145 char *topid = logfile_generate_topid ();
7146
7147 data.topid = topid;
7148 }
7149
7150 // logfile_append() checks for logfile_disable internally to make it easier from here
7151
7152 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7153 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7154 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7155 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7156 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7157 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7158 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7159 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7160 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7161 #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));
7162
7163 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7164 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7165 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7166 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7167 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7168 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7169 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7170 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7171
7172 logfile_top_msg ("START");
7173
7174 logfile_top_uint (attack_mode);
7175 logfile_top_uint (attack_kern);
7176 logfile_top_uint (benchmark);
7177 logfile_top_uint (stdout_flag);
7178 logfile_top_uint (bitmap_min);
7179 logfile_top_uint (bitmap_max);
7180 logfile_top_uint (debug_mode);
7181 logfile_top_uint (force);
7182 logfile_top_uint (kernel_accel);
7183 logfile_top_uint (kernel_loops);
7184 logfile_top_uint (nvidia_spin_damp);
7185 logfile_top_uint (gpu_temp_disable);
7186 #ifdef HAVE_HWMON
7187 logfile_top_uint (gpu_temp_abort);
7188 logfile_top_uint (gpu_temp_retain);
7189 #endif
7190 logfile_top_uint (hash_mode);
7191 logfile_top_uint (hex_charset);
7192 logfile_top_uint (hex_salt);
7193 logfile_top_uint (hex_wordlist);
7194 logfile_top_uint (increment);
7195 logfile_top_uint (increment_max);
7196 logfile_top_uint (increment_min);
7197 logfile_top_uint (keyspace);
7198 logfile_top_uint (left);
7199 logfile_top_uint (logfile_disable);
7200 logfile_top_uint (loopback);
7201 logfile_top_uint (markov_classic);
7202 logfile_top_uint (markov_disable);
7203 logfile_top_uint (markov_threshold);
7204 logfile_top_uint (outfile_autohex);
7205 logfile_top_uint (outfile_check_timer);
7206 logfile_top_uint (outfile_format);
7207 logfile_top_uint (potfile_disable);
7208 logfile_top_string (potfile_path);
7209 #if defined(HAVE_HWMON)
7210 logfile_top_uint (powertune_enable);
7211 #endif
7212 logfile_top_uint (scrypt_tmto);
7213 logfile_top_uint (quiet);
7214 logfile_top_uint (remove);
7215 logfile_top_uint (remove_timer);
7216 logfile_top_uint (restore);
7217 logfile_top_uint (restore_disable);
7218 logfile_top_uint (restore_timer);
7219 logfile_top_uint (rp_gen);
7220 logfile_top_uint (rp_gen_func_max);
7221 logfile_top_uint (rp_gen_func_min);
7222 logfile_top_uint (rp_gen_seed);
7223 logfile_top_uint (runtime);
7224 logfile_top_uint (segment_size);
7225 logfile_top_uint (show);
7226 logfile_top_uint (status);
7227 logfile_top_uint (machine_readable);
7228 logfile_top_uint (status_timer);
7229 logfile_top_uint (usage);
7230 logfile_top_uint (username);
7231 logfile_top_uint (version);
7232 logfile_top_uint (weak_hash_threshold);
7233 logfile_top_uint (workload_profile);
7234 logfile_top_uint64 (limit);
7235 logfile_top_uint64 (skip);
7236 logfile_top_char (separator);
7237 logfile_top_string (cpu_affinity);
7238 logfile_top_string (custom_charset_1);
7239 logfile_top_string (custom_charset_2);
7240 logfile_top_string (custom_charset_3);
7241 logfile_top_string (custom_charset_4);
7242 logfile_top_string (debug_file);
7243 logfile_top_string (opencl_devices);
7244 logfile_top_string (opencl_platforms);
7245 logfile_top_string (opencl_device_types);
7246 logfile_top_uint (opencl_vector_width);
7247 logfile_top_string (induction_dir);
7248 logfile_top_string (markov_hcstat);
7249 logfile_top_string (outfile);
7250 logfile_top_string (outfile_check_dir);
7251 logfile_top_string (rule_buf_l);
7252 logfile_top_string (rule_buf_r);
7253 logfile_top_string (session);
7254 logfile_top_string (truecrypt_keyfiles);
7255 logfile_top_string (veracrypt_keyfiles);
7256 logfile_top_uint (veracrypt_pim);
7257
7258 /**
7259 * Init OpenCL library loader
7260 */
7261
7262 if (keyspace == 0)
7263 {
7264 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7265
7266 ocl_init (ocl);
7267
7268 data.ocl = ocl;
7269 }
7270
7271 /**
7272 * OpenCL platform selection
7273 */
7274
7275 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7276
7277 /**
7278 * OpenCL device selection
7279 */
7280
7281 u32 devices_filter = setup_devices_filter (opencl_devices);
7282
7283 /**
7284 * OpenCL device type selection
7285 */
7286
7287 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7288
7289 /**
7290 * benchmark
7291 */
7292
7293 if (benchmark == 1)
7294 {
7295 /**
7296 * disable useless stuff for benchmark
7297 */
7298
7299 status_timer = 0;
7300 restore_timer = 0;
7301 restore_disable = 1;
7302 potfile_disable = 1;
7303 weak_hash_threshold = 0;
7304 nvidia_spin_damp = 0;
7305 gpu_temp_disable = 1;
7306 outfile_check_timer = 0;
7307
7308 #ifdef HAVE_HWMON
7309 if (powertune_enable == 1)
7310 {
7311 gpu_temp_disable = 0;
7312 }
7313 #endif
7314
7315 data.status_timer = status_timer;
7316 data.restore_timer = restore_timer;
7317 data.restore_disable = restore_disable;
7318 data.outfile_check_timer = outfile_check_timer;
7319
7320 /**
7321 * force attack mode to be bruteforce
7322 */
7323
7324 attack_mode = ATTACK_MODE_BF;
7325 attack_kern = ATTACK_KERN_BF;
7326
7327 if (workload_profile_chgd == 0)
7328 {
7329 workload_profile = 3;
7330
7331 data.workload_profile = workload_profile;
7332 }
7333 }
7334
7335 /**
7336 * config
7337 */
7338
7339 uint hash_type = 0;
7340 uint salt_type = 0;
7341 uint attack_exec = 0;
7342 uint opts_type = 0;
7343 uint kern_type = 0;
7344 uint dgst_size = 0;
7345 uint esalt_size = 0;
7346 uint opti_type = 0;
7347 uint dgst_pos0 = -1;
7348 uint dgst_pos1 = -1;
7349 uint dgst_pos2 = -1;
7350 uint dgst_pos3 = -1;
7351
7352 int (*parse_func) (char *, uint, hash_t *);
7353 int (*sort_by_digest) (const void *, const void *);
7354
7355 uint algorithm_pos = 0;
7356 uint algorithm_max = 1;
7357
7358 uint *algorithms = default_benchmark_algorithms;
7359
7360 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7361
7362 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7363 {
7364 /*
7365 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7366 * the following algos are skipped entirely
7367 */
7368
7369 if (algorithm_pos > 0)
7370 {
7371 local_free (rd);
7372
7373 rd = init_restore (argc, argv);
7374
7375 data.rd = rd;
7376 }
7377
7378 /**
7379 * update hash_mode in case of multihash benchmark
7380 */
7381
7382 if (benchmark == 1)
7383 {
7384 if (hash_mode_chgd == 0)
7385 {
7386 hash_mode = algorithms[algorithm_pos];
7387
7388 data.hash_mode = hash_mode;
7389 }
7390
7391 quiet = 1;
7392
7393 data.quiet = quiet;
7394 }
7395
7396 switch (hash_mode)
7397 {
7398 case 0: hash_type = HASH_TYPE_MD5;
7399 salt_type = SALT_TYPE_NONE;
7400 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7401 opts_type = OPTS_TYPE_PT_GENERATE_LE
7402 | OPTS_TYPE_PT_ADD80
7403 | OPTS_TYPE_PT_ADDBITS14;
7404 kern_type = KERN_TYPE_MD5;
7405 dgst_size = DGST_SIZE_4_4;
7406 parse_func = md5_parse_hash;
7407 sort_by_digest = sort_by_digest_4_4;
7408 opti_type = OPTI_TYPE_ZERO_BYTE
7409 | OPTI_TYPE_PRECOMPUTE_INIT
7410 | OPTI_TYPE_PRECOMPUTE_MERKLE
7411 | OPTI_TYPE_MEET_IN_MIDDLE
7412 | OPTI_TYPE_EARLY_SKIP
7413 | OPTI_TYPE_NOT_ITERATED
7414 | OPTI_TYPE_NOT_SALTED
7415 | OPTI_TYPE_RAW_HASH;
7416 dgst_pos0 = 0;
7417 dgst_pos1 = 3;
7418 dgst_pos2 = 2;
7419 dgst_pos3 = 1;
7420 break;
7421
7422 case 10: hash_type = HASH_TYPE_MD5;
7423 salt_type = SALT_TYPE_INTERN;
7424 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7425 opts_type = OPTS_TYPE_PT_GENERATE_LE
7426 | OPTS_TYPE_ST_ADD80
7427 | OPTS_TYPE_ST_ADDBITS14;
7428 kern_type = KERN_TYPE_MD5_PWSLT;
7429 dgst_size = DGST_SIZE_4_4;
7430 parse_func = md5s_parse_hash;
7431 sort_by_digest = sort_by_digest_4_4;
7432 opti_type = OPTI_TYPE_ZERO_BYTE
7433 | OPTI_TYPE_PRECOMPUTE_INIT
7434 | OPTI_TYPE_PRECOMPUTE_MERKLE
7435 | OPTI_TYPE_MEET_IN_MIDDLE
7436 | OPTI_TYPE_EARLY_SKIP
7437 | OPTI_TYPE_NOT_ITERATED
7438 | OPTI_TYPE_APPENDED_SALT
7439 | OPTI_TYPE_RAW_HASH;
7440 dgst_pos0 = 0;
7441 dgst_pos1 = 3;
7442 dgst_pos2 = 2;
7443 dgst_pos3 = 1;
7444 break;
7445
7446 case 11: hash_type = HASH_TYPE_MD5;
7447 salt_type = SALT_TYPE_INTERN;
7448 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7449 opts_type = OPTS_TYPE_PT_GENERATE_LE
7450 | OPTS_TYPE_ST_ADD80
7451 | OPTS_TYPE_ST_ADDBITS14;
7452 kern_type = KERN_TYPE_MD5_PWSLT;
7453 dgst_size = DGST_SIZE_4_4;
7454 parse_func = joomla_parse_hash;
7455 sort_by_digest = sort_by_digest_4_4;
7456 opti_type = OPTI_TYPE_ZERO_BYTE
7457 | OPTI_TYPE_PRECOMPUTE_INIT
7458 | OPTI_TYPE_PRECOMPUTE_MERKLE
7459 | OPTI_TYPE_MEET_IN_MIDDLE
7460 | OPTI_TYPE_EARLY_SKIP
7461 | OPTI_TYPE_NOT_ITERATED
7462 | OPTI_TYPE_APPENDED_SALT
7463 | OPTI_TYPE_RAW_HASH;
7464 dgst_pos0 = 0;
7465 dgst_pos1 = 3;
7466 dgst_pos2 = 2;
7467 dgst_pos3 = 1;
7468 break;
7469
7470 case 12: hash_type = HASH_TYPE_MD5;
7471 salt_type = SALT_TYPE_INTERN;
7472 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7473 opts_type = OPTS_TYPE_PT_GENERATE_LE
7474 | OPTS_TYPE_ST_ADD80
7475 | OPTS_TYPE_ST_ADDBITS14;
7476 kern_type = KERN_TYPE_MD5_PWSLT;
7477 dgst_size = DGST_SIZE_4_4;
7478 parse_func = postgresql_parse_hash;
7479 sort_by_digest = sort_by_digest_4_4;
7480 opti_type = OPTI_TYPE_ZERO_BYTE
7481 | OPTI_TYPE_PRECOMPUTE_INIT
7482 | OPTI_TYPE_PRECOMPUTE_MERKLE
7483 | OPTI_TYPE_MEET_IN_MIDDLE
7484 | OPTI_TYPE_EARLY_SKIP
7485 | OPTI_TYPE_NOT_ITERATED
7486 | OPTI_TYPE_APPENDED_SALT
7487 | OPTI_TYPE_RAW_HASH;
7488 dgst_pos0 = 0;
7489 dgst_pos1 = 3;
7490 dgst_pos2 = 2;
7491 dgst_pos3 = 1;
7492 break;
7493
7494 case 20: hash_type = HASH_TYPE_MD5;
7495 salt_type = SALT_TYPE_INTERN;
7496 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7497 opts_type = OPTS_TYPE_PT_GENERATE_LE
7498 | OPTS_TYPE_PT_ADD80
7499 | OPTS_TYPE_PT_ADDBITS14;
7500 kern_type = KERN_TYPE_MD5_SLTPW;
7501 dgst_size = DGST_SIZE_4_4;
7502 parse_func = md5s_parse_hash;
7503 sort_by_digest = sort_by_digest_4_4;
7504 opti_type = OPTI_TYPE_ZERO_BYTE
7505 | OPTI_TYPE_PRECOMPUTE_INIT
7506 | OPTI_TYPE_PRECOMPUTE_MERKLE
7507 | OPTI_TYPE_EARLY_SKIP
7508 | OPTI_TYPE_NOT_ITERATED
7509 | OPTI_TYPE_PREPENDED_SALT
7510 | OPTI_TYPE_RAW_HASH;
7511 dgst_pos0 = 0;
7512 dgst_pos1 = 3;
7513 dgst_pos2 = 2;
7514 dgst_pos3 = 1;
7515 break;
7516
7517 case 21: hash_type = HASH_TYPE_MD5;
7518 salt_type = SALT_TYPE_INTERN;
7519 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7520 opts_type = OPTS_TYPE_PT_GENERATE_LE
7521 | OPTS_TYPE_PT_ADD80
7522 | OPTS_TYPE_PT_ADDBITS14;
7523 kern_type = KERN_TYPE_MD5_SLTPW;
7524 dgst_size = DGST_SIZE_4_4;
7525 parse_func = osc_parse_hash;
7526 sort_by_digest = sort_by_digest_4_4;
7527 opti_type = OPTI_TYPE_ZERO_BYTE
7528 | OPTI_TYPE_PRECOMPUTE_INIT
7529 | OPTI_TYPE_PRECOMPUTE_MERKLE
7530 | OPTI_TYPE_EARLY_SKIP
7531 | OPTI_TYPE_NOT_ITERATED
7532 | OPTI_TYPE_PREPENDED_SALT
7533 | OPTI_TYPE_RAW_HASH;
7534 dgst_pos0 = 0;
7535 dgst_pos1 = 3;
7536 dgst_pos2 = 2;
7537 dgst_pos3 = 1;
7538 break;
7539
7540 case 22: hash_type = HASH_TYPE_MD5;
7541 salt_type = SALT_TYPE_EMBEDDED;
7542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7543 opts_type = OPTS_TYPE_PT_GENERATE_LE
7544 | OPTS_TYPE_PT_ADD80
7545 | OPTS_TYPE_PT_ADDBITS14;
7546 kern_type = KERN_TYPE_MD5_SLTPW;
7547 dgst_size = DGST_SIZE_4_4;
7548 parse_func = netscreen_parse_hash;
7549 sort_by_digest = sort_by_digest_4_4;
7550 opti_type = OPTI_TYPE_ZERO_BYTE
7551 | OPTI_TYPE_PRECOMPUTE_INIT
7552 | OPTI_TYPE_PRECOMPUTE_MERKLE
7553 | OPTI_TYPE_EARLY_SKIP
7554 | OPTI_TYPE_NOT_ITERATED
7555 | OPTI_TYPE_PREPENDED_SALT
7556 | OPTI_TYPE_RAW_HASH;
7557 dgst_pos0 = 0;
7558 dgst_pos1 = 3;
7559 dgst_pos2 = 2;
7560 dgst_pos3 = 1;
7561 break;
7562
7563 case 23: hash_type = HASH_TYPE_MD5;
7564 salt_type = SALT_TYPE_EMBEDDED;
7565 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7566 opts_type = OPTS_TYPE_PT_GENERATE_LE
7567 | OPTS_TYPE_PT_ADD80
7568 | OPTS_TYPE_PT_ADDBITS14;
7569 kern_type = KERN_TYPE_MD5_SLTPW;
7570 dgst_size = DGST_SIZE_4_4;
7571 parse_func = skype_parse_hash;
7572 sort_by_digest = sort_by_digest_4_4;
7573 opti_type = OPTI_TYPE_ZERO_BYTE
7574 | OPTI_TYPE_PRECOMPUTE_INIT
7575 | OPTI_TYPE_PRECOMPUTE_MERKLE
7576 | OPTI_TYPE_EARLY_SKIP
7577 | OPTI_TYPE_NOT_ITERATED
7578 | OPTI_TYPE_PREPENDED_SALT
7579 | OPTI_TYPE_RAW_HASH;
7580 dgst_pos0 = 0;
7581 dgst_pos1 = 3;
7582 dgst_pos2 = 2;
7583 dgst_pos3 = 1;
7584 break;
7585
7586 case 30: hash_type = HASH_TYPE_MD5;
7587 salt_type = SALT_TYPE_INTERN;
7588 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7589 opts_type = OPTS_TYPE_PT_GENERATE_LE
7590 | OPTS_TYPE_PT_UNICODE
7591 | OPTS_TYPE_ST_ADD80
7592 | OPTS_TYPE_ST_ADDBITS14;
7593 kern_type = KERN_TYPE_MD5_PWUSLT;
7594 dgst_size = DGST_SIZE_4_4;
7595 parse_func = md5s_parse_hash;
7596 sort_by_digest = sort_by_digest_4_4;
7597 opti_type = OPTI_TYPE_ZERO_BYTE
7598 | OPTI_TYPE_PRECOMPUTE_INIT
7599 | OPTI_TYPE_PRECOMPUTE_MERKLE
7600 | OPTI_TYPE_MEET_IN_MIDDLE
7601 | OPTI_TYPE_EARLY_SKIP
7602 | OPTI_TYPE_NOT_ITERATED
7603 | OPTI_TYPE_APPENDED_SALT
7604 | OPTI_TYPE_RAW_HASH;
7605 dgst_pos0 = 0;
7606 dgst_pos1 = 3;
7607 dgst_pos2 = 2;
7608 dgst_pos3 = 1;
7609 break;
7610
7611 case 40: hash_type = HASH_TYPE_MD5;
7612 salt_type = SALT_TYPE_INTERN;
7613 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7614 opts_type = OPTS_TYPE_PT_GENERATE_LE
7615 | OPTS_TYPE_PT_ADD80
7616 | OPTS_TYPE_PT_ADDBITS14
7617 | OPTS_TYPE_PT_UNICODE;
7618 kern_type = KERN_TYPE_MD5_SLTPWU;
7619 dgst_size = DGST_SIZE_4_4;
7620 parse_func = md5s_parse_hash;
7621 sort_by_digest = sort_by_digest_4_4;
7622 opti_type = OPTI_TYPE_ZERO_BYTE
7623 | OPTI_TYPE_PRECOMPUTE_INIT
7624 | OPTI_TYPE_PRECOMPUTE_MERKLE
7625 | OPTI_TYPE_EARLY_SKIP
7626 | OPTI_TYPE_NOT_ITERATED
7627 | OPTI_TYPE_PREPENDED_SALT
7628 | OPTI_TYPE_RAW_HASH;
7629 dgst_pos0 = 0;
7630 dgst_pos1 = 3;
7631 dgst_pos2 = 2;
7632 dgst_pos3 = 1;
7633 break;
7634
7635 case 50: hash_type = HASH_TYPE_MD5;
7636 salt_type = SALT_TYPE_INTERN;
7637 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7638 opts_type = OPTS_TYPE_PT_GENERATE_LE
7639 | OPTS_TYPE_ST_ADD80
7640 | OPTS_TYPE_ST_ADDBITS14;
7641 kern_type = KERN_TYPE_HMACMD5_PW;
7642 dgst_size = DGST_SIZE_4_4;
7643 parse_func = hmacmd5_parse_hash;
7644 sort_by_digest = sort_by_digest_4_4;
7645 opti_type = OPTI_TYPE_ZERO_BYTE
7646 | OPTI_TYPE_NOT_ITERATED;
7647 dgst_pos0 = 0;
7648 dgst_pos1 = 3;
7649 dgst_pos2 = 2;
7650 dgst_pos3 = 1;
7651 break;
7652
7653 case 60: hash_type = HASH_TYPE_MD5;
7654 salt_type = SALT_TYPE_INTERN;
7655 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7656 opts_type = OPTS_TYPE_PT_GENERATE_LE
7657 | OPTS_TYPE_PT_ADD80
7658 | OPTS_TYPE_PT_ADDBITS14;
7659 kern_type = KERN_TYPE_HMACMD5_SLT;
7660 dgst_size = DGST_SIZE_4_4;
7661 parse_func = hmacmd5_parse_hash;
7662 sort_by_digest = sort_by_digest_4_4;
7663 opti_type = OPTI_TYPE_ZERO_BYTE
7664 | OPTI_TYPE_NOT_ITERATED;
7665 dgst_pos0 = 0;
7666 dgst_pos1 = 3;
7667 dgst_pos2 = 2;
7668 dgst_pos3 = 1;
7669 break;
7670
7671 case 100: hash_type = HASH_TYPE_SHA1;
7672 salt_type = SALT_TYPE_NONE;
7673 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7674 opts_type = OPTS_TYPE_PT_GENERATE_BE
7675 | OPTS_TYPE_PT_ADD80
7676 | OPTS_TYPE_PT_ADDBITS15;
7677 kern_type = KERN_TYPE_SHA1;
7678 dgst_size = DGST_SIZE_4_5;
7679 parse_func = sha1_parse_hash;
7680 sort_by_digest = sort_by_digest_4_5;
7681 opti_type = OPTI_TYPE_ZERO_BYTE
7682 | OPTI_TYPE_PRECOMPUTE_INIT
7683 | OPTI_TYPE_PRECOMPUTE_MERKLE
7684 | OPTI_TYPE_EARLY_SKIP
7685 | OPTI_TYPE_NOT_ITERATED
7686 | OPTI_TYPE_NOT_SALTED
7687 | OPTI_TYPE_RAW_HASH;
7688 dgst_pos0 = 3;
7689 dgst_pos1 = 4;
7690 dgst_pos2 = 2;
7691 dgst_pos3 = 1;
7692 break;
7693
7694 case 101: hash_type = HASH_TYPE_SHA1;
7695 salt_type = SALT_TYPE_NONE;
7696 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7697 opts_type = OPTS_TYPE_PT_GENERATE_BE
7698 | OPTS_TYPE_PT_ADD80
7699 | OPTS_TYPE_PT_ADDBITS15;
7700 kern_type = KERN_TYPE_SHA1;
7701 dgst_size = DGST_SIZE_4_5;
7702 parse_func = sha1b64_parse_hash;
7703 sort_by_digest = sort_by_digest_4_5;
7704 opti_type = OPTI_TYPE_ZERO_BYTE
7705 | OPTI_TYPE_PRECOMPUTE_INIT
7706 | OPTI_TYPE_PRECOMPUTE_MERKLE
7707 | OPTI_TYPE_EARLY_SKIP
7708 | OPTI_TYPE_NOT_ITERATED
7709 | OPTI_TYPE_NOT_SALTED
7710 | OPTI_TYPE_RAW_HASH;
7711 dgst_pos0 = 3;
7712 dgst_pos1 = 4;
7713 dgst_pos2 = 2;
7714 dgst_pos3 = 1;
7715 break;
7716
7717 case 110: hash_type = HASH_TYPE_SHA1;
7718 salt_type = SALT_TYPE_INTERN;
7719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7720 opts_type = OPTS_TYPE_PT_GENERATE_BE
7721 | OPTS_TYPE_ST_ADD80
7722 | OPTS_TYPE_ST_ADDBITS15;
7723 kern_type = KERN_TYPE_SHA1_PWSLT;
7724 dgst_size = DGST_SIZE_4_5;
7725 parse_func = sha1s_parse_hash;
7726 sort_by_digest = sort_by_digest_4_5;
7727 opti_type = OPTI_TYPE_ZERO_BYTE
7728 | OPTI_TYPE_PRECOMPUTE_INIT
7729 | OPTI_TYPE_PRECOMPUTE_MERKLE
7730 | OPTI_TYPE_EARLY_SKIP
7731 | OPTI_TYPE_NOT_ITERATED
7732 | OPTI_TYPE_APPENDED_SALT
7733 | OPTI_TYPE_RAW_HASH;
7734 dgst_pos0 = 3;
7735 dgst_pos1 = 4;
7736 dgst_pos2 = 2;
7737 dgst_pos3 = 1;
7738 break;
7739
7740 case 111: hash_type = HASH_TYPE_SHA1;
7741 salt_type = SALT_TYPE_EMBEDDED;
7742 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7743 opts_type = OPTS_TYPE_PT_GENERATE_BE
7744 | OPTS_TYPE_ST_ADD80
7745 | OPTS_TYPE_ST_ADDBITS15;
7746 kern_type = KERN_TYPE_SHA1_PWSLT;
7747 dgst_size = DGST_SIZE_4_5;
7748 parse_func = sha1b64s_parse_hash;
7749 sort_by_digest = sort_by_digest_4_5;
7750 opti_type = OPTI_TYPE_ZERO_BYTE
7751 | OPTI_TYPE_PRECOMPUTE_INIT
7752 | OPTI_TYPE_PRECOMPUTE_MERKLE
7753 | OPTI_TYPE_EARLY_SKIP
7754 | OPTI_TYPE_NOT_ITERATED
7755 | OPTI_TYPE_APPENDED_SALT
7756 | OPTI_TYPE_RAW_HASH;
7757 dgst_pos0 = 3;
7758 dgst_pos1 = 4;
7759 dgst_pos2 = 2;
7760 dgst_pos3 = 1;
7761 break;
7762
7763 case 112: hash_type = HASH_TYPE_SHA1;
7764 salt_type = SALT_TYPE_INTERN;
7765 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7766 opts_type = OPTS_TYPE_PT_GENERATE_BE
7767 | OPTS_TYPE_ST_ADD80
7768 | OPTS_TYPE_ST_ADDBITS15
7769 | OPTS_TYPE_ST_HEX;
7770 kern_type = KERN_TYPE_SHA1_PWSLT;
7771 dgst_size = DGST_SIZE_4_5;
7772 parse_func = oracles_parse_hash;
7773 sort_by_digest = sort_by_digest_4_5;
7774 opti_type = OPTI_TYPE_ZERO_BYTE
7775 | OPTI_TYPE_PRECOMPUTE_INIT
7776 | OPTI_TYPE_PRECOMPUTE_MERKLE
7777 | OPTI_TYPE_EARLY_SKIP
7778 | OPTI_TYPE_NOT_ITERATED
7779 | OPTI_TYPE_APPENDED_SALT
7780 | OPTI_TYPE_RAW_HASH;
7781 dgst_pos0 = 3;
7782 dgst_pos1 = 4;
7783 dgst_pos2 = 2;
7784 dgst_pos3 = 1;
7785 break;
7786
7787 case 120: hash_type = HASH_TYPE_SHA1;
7788 salt_type = SALT_TYPE_INTERN;
7789 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7790 opts_type = OPTS_TYPE_PT_GENERATE_BE
7791 | OPTS_TYPE_PT_ADD80
7792 | OPTS_TYPE_PT_ADDBITS15;
7793 kern_type = KERN_TYPE_SHA1_SLTPW;
7794 dgst_size = DGST_SIZE_4_5;
7795 parse_func = sha1s_parse_hash;
7796 sort_by_digest = sort_by_digest_4_5;
7797 opti_type = OPTI_TYPE_ZERO_BYTE
7798 | OPTI_TYPE_PRECOMPUTE_INIT
7799 | OPTI_TYPE_PRECOMPUTE_MERKLE
7800 | OPTI_TYPE_EARLY_SKIP
7801 | OPTI_TYPE_NOT_ITERATED
7802 | OPTI_TYPE_PREPENDED_SALT
7803 | OPTI_TYPE_RAW_HASH;
7804 dgst_pos0 = 3;
7805 dgst_pos1 = 4;
7806 dgst_pos2 = 2;
7807 dgst_pos3 = 1;
7808 break;
7809
7810 case 121: hash_type = HASH_TYPE_SHA1;
7811 salt_type = SALT_TYPE_INTERN;
7812 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7813 opts_type = OPTS_TYPE_PT_GENERATE_BE
7814 | OPTS_TYPE_PT_ADD80
7815 | OPTS_TYPE_PT_ADDBITS15
7816 | OPTS_TYPE_ST_LOWER;
7817 kern_type = KERN_TYPE_SHA1_SLTPW;
7818 dgst_size = DGST_SIZE_4_5;
7819 parse_func = smf_parse_hash;
7820 sort_by_digest = sort_by_digest_4_5;
7821 opti_type = OPTI_TYPE_ZERO_BYTE
7822 | OPTI_TYPE_PRECOMPUTE_INIT
7823 | OPTI_TYPE_PRECOMPUTE_MERKLE
7824 | OPTI_TYPE_EARLY_SKIP
7825 | OPTI_TYPE_NOT_ITERATED
7826 | OPTI_TYPE_PREPENDED_SALT
7827 | OPTI_TYPE_RAW_HASH;
7828 dgst_pos0 = 3;
7829 dgst_pos1 = 4;
7830 dgst_pos2 = 2;
7831 dgst_pos3 = 1;
7832 break;
7833
7834 case 122: hash_type = HASH_TYPE_SHA1;
7835 salt_type = SALT_TYPE_EMBEDDED;
7836 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7837 opts_type = OPTS_TYPE_PT_GENERATE_BE
7838 | OPTS_TYPE_PT_ADD80
7839 | OPTS_TYPE_PT_ADDBITS15
7840 | OPTS_TYPE_ST_HEX;
7841 kern_type = KERN_TYPE_SHA1_SLTPW;
7842 dgst_size = DGST_SIZE_4_5;
7843 parse_func = osx1_parse_hash;
7844 sort_by_digest = sort_by_digest_4_5;
7845 opti_type = OPTI_TYPE_ZERO_BYTE
7846 | OPTI_TYPE_PRECOMPUTE_INIT
7847 | OPTI_TYPE_PRECOMPUTE_MERKLE
7848 | OPTI_TYPE_EARLY_SKIP
7849 | OPTI_TYPE_NOT_ITERATED
7850 | OPTI_TYPE_PREPENDED_SALT
7851 | OPTI_TYPE_RAW_HASH;
7852 dgst_pos0 = 3;
7853 dgst_pos1 = 4;
7854 dgst_pos2 = 2;
7855 dgst_pos3 = 1;
7856 break;
7857
7858 case 124: hash_type = HASH_TYPE_SHA1;
7859 salt_type = SALT_TYPE_EMBEDDED;
7860 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7861 opts_type = OPTS_TYPE_PT_GENERATE_BE
7862 | OPTS_TYPE_PT_ADD80
7863 | OPTS_TYPE_PT_ADDBITS15;
7864 kern_type = KERN_TYPE_SHA1_SLTPW;
7865 dgst_size = DGST_SIZE_4_5;
7866 parse_func = djangosha1_parse_hash;
7867 sort_by_digest = sort_by_digest_4_5;
7868 opti_type = OPTI_TYPE_ZERO_BYTE
7869 | OPTI_TYPE_PRECOMPUTE_INIT
7870 | OPTI_TYPE_PRECOMPUTE_MERKLE
7871 | OPTI_TYPE_EARLY_SKIP
7872 | OPTI_TYPE_NOT_ITERATED
7873 | OPTI_TYPE_PREPENDED_SALT
7874 | OPTI_TYPE_RAW_HASH;
7875 dgst_pos0 = 3;
7876 dgst_pos1 = 4;
7877 dgst_pos2 = 2;
7878 dgst_pos3 = 1;
7879 break;
7880
7881 case 125: hash_type = HASH_TYPE_SHA1;
7882 salt_type = SALT_TYPE_EMBEDDED;
7883 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7884 opts_type = OPTS_TYPE_PT_GENERATE_BE
7885 | OPTS_TYPE_PT_ADD80
7886 | OPTS_TYPE_PT_ADDBITS15
7887 | OPTS_TYPE_ST_HEX;
7888 kern_type = KERN_TYPE_SHA1_SLTPW;
7889 dgst_size = DGST_SIZE_4_5;
7890 parse_func = arubaos_parse_hash;
7891 sort_by_digest = sort_by_digest_4_5;
7892 opti_type = OPTI_TYPE_ZERO_BYTE
7893 | OPTI_TYPE_PRECOMPUTE_INIT
7894 | OPTI_TYPE_PRECOMPUTE_MERKLE
7895 | OPTI_TYPE_EARLY_SKIP
7896 | OPTI_TYPE_NOT_ITERATED
7897 | OPTI_TYPE_PREPENDED_SALT
7898 | OPTI_TYPE_RAW_HASH;
7899 dgst_pos0 = 3;
7900 dgst_pos1 = 4;
7901 dgst_pos2 = 2;
7902 dgst_pos3 = 1;
7903 break;
7904
7905 case 130: hash_type = HASH_TYPE_SHA1;
7906 salt_type = SALT_TYPE_INTERN;
7907 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7908 opts_type = OPTS_TYPE_PT_GENERATE_BE
7909 | OPTS_TYPE_PT_UNICODE
7910 | OPTS_TYPE_ST_ADD80
7911 | OPTS_TYPE_ST_ADDBITS15;
7912 kern_type = KERN_TYPE_SHA1_PWUSLT;
7913 dgst_size = DGST_SIZE_4_5;
7914 parse_func = sha1s_parse_hash;
7915 sort_by_digest = sort_by_digest_4_5;
7916 opti_type = OPTI_TYPE_ZERO_BYTE
7917 | OPTI_TYPE_PRECOMPUTE_INIT
7918 | OPTI_TYPE_PRECOMPUTE_MERKLE
7919 | OPTI_TYPE_EARLY_SKIP
7920 | OPTI_TYPE_NOT_ITERATED
7921 | OPTI_TYPE_APPENDED_SALT
7922 | OPTI_TYPE_RAW_HASH;
7923 dgst_pos0 = 3;
7924 dgst_pos1 = 4;
7925 dgst_pos2 = 2;
7926 dgst_pos3 = 1;
7927 break;
7928
7929 case 131: hash_type = HASH_TYPE_SHA1;
7930 salt_type = SALT_TYPE_EMBEDDED;
7931 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7932 opts_type = OPTS_TYPE_PT_GENERATE_BE
7933 | OPTS_TYPE_PT_UNICODE
7934 | OPTS_TYPE_PT_UPPER
7935 | OPTS_TYPE_ST_ADD80
7936 | OPTS_TYPE_ST_ADDBITS15
7937 | OPTS_TYPE_ST_HEX;
7938 kern_type = KERN_TYPE_SHA1_PWUSLT;
7939 dgst_size = DGST_SIZE_4_5;
7940 parse_func = mssql2000_parse_hash;
7941 sort_by_digest = sort_by_digest_4_5;
7942 opti_type = OPTI_TYPE_ZERO_BYTE
7943 | OPTI_TYPE_PRECOMPUTE_INIT
7944 | OPTI_TYPE_PRECOMPUTE_MERKLE
7945 | OPTI_TYPE_EARLY_SKIP
7946 | OPTI_TYPE_NOT_ITERATED
7947 | OPTI_TYPE_APPENDED_SALT
7948 | OPTI_TYPE_RAW_HASH;
7949 dgst_pos0 = 3;
7950 dgst_pos1 = 4;
7951 dgst_pos2 = 2;
7952 dgst_pos3 = 1;
7953 break;
7954
7955 case 132: hash_type = HASH_TYPE_SHA1;
7956 salt_type = SALT_TYPE_EMBEDDED;
7957 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7958 opts_type = OPTS_TYPE_PT_GENERATE_BE
7959 | OPTS_TYPE_PT_UNICODE
7960 | OPTS_TYPE_ST_ADD80
7961 | OPTS_TYPE_ST_ADDBITS15
7962 | OPTS_TYPE_ST_HEX;
7963 kern_type = KERN_TYPE_SHA1_PWUSLT;
7964 dgst_size = DGST_SIZE_4_5;
7965 parse_func = mssql2005_parse_hash;
7966 sort_by_digest = sort_by_digest_4_5;
7967 opti_type = OPTI_TYPE_ZERO_BYTE
7968 | OPTI_TYPE_PRECOMPUTE_INIT
7969 | OPTI_TYPE_PRECOMPUTE_MERKLE
7970 | OPTI_TYPE_EARLY_SKIP
7971 | OPTI_TYPE_NOT_ITERATED
7972 | OPTI_TYPE_APPENDED_SALT
7973 | OPTI_TYPE_RAW_HASH;
7974 dgst_pos0 = 3;
7975 dgst_pos1 = 4;
7976 dgst_pos2 = 2;
7977 dgst_pos3 = 1;
7978 break;
7979
7980 case 133: hash_type = HASH_TYPE_SHA1;
7981 salt_type = SALT_TYPE_EMBEDDED;
7982 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7983 opts_type = OPTS_TYPE_PT_GENERATE_BE
7984 | OPTS_TYPE_PT_UNICODE
7985 | OPTS_TYPE_ST_ADD80
7986 | OPTS_TYPE_ST_ADDBITS15;
7987 kern_type = KERN_TYPE_SHA1_PWUSLT;
7988 dgst_size = DGST_SIZE_4_5;
7989 parse_func = peoplesoft_parse_hash;
7990 sort_by_digest = sort_by_digest_4_5;
7991 opti_type = OPTI_TYPE_ZERO_BYTE
7992 | OPTI_TYPE_PRECOMPUTE_INIT
7993 | OPTI_TYPE_PRECOMPUTE_MERKLE
7994 | OPTI_TYPE_EARLY_SKIP
7995 | OPTI_TYPE_NOT_ITERATED
7996 | OPTI_TYPE_APPENDED_SALT
7997 | OPTI_TYPE_RAW_HASH;
7998 dgst_pos0 = 3;
7999 dgst_pos1 = 4;
8000 dgst_pos2 = 2;
8001 dgst_pos3 = 1;
8002 break;
8003
8004 case 140: hash_type = HASH_TYPE_SHA1;
8005 salt_type = SALT_TYPE_INTERN;
8006 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8007 opts_type = OPTS_TYPE_PT_GENERATE_BE
8008 | OPTS_TYPE_PT_ADD80
8009 | OPTS_TYPE_PT_ADDBITS15
8010 | OPTS_TYPE_PT_UNICODE;
8011 kern_type = KERN_TYPE_SHA1_SLTPWU;
8012 dgst_size = DGST_SIZE_4_5;
8013 parse_func = sha1s_parse_hash;
8014 sort_by_digest = sort_by_digest_4_5;
8015 opti_type = OPTI_TYPE_ZERO_BYTE
8016 | OPTI_TYPE_PRECOMPUTE_INIT
8017 | OPTI_TYPE_PRECOMPUTE_MERKLE
8018 | OPTI_TYPE_EARLY_SKIP
8019 | OPTI_TYPE_NOT_ITERATED
8020 | OPTI_TYPE_PREPENDED_SALT
8021 | OPTI_TYPE_RAW_HASH;
8022 dgst_pos0 = 3;
8023 dgst_pos1 = 4;
8024 dgst_pos2 = 2;
8025 dgst_pos3 = 1;
8026 break;
8027
8028 case 141: hash_type = HASH_TYPE_SHA1;
8029 salt_type = SALT_TYPE_EMBEDDED;
8030 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8031 opts_type = OPTS_TYPE_PT_GENERATE_BE
8032 | OPTS_TYPE_PT_ADD80
8033 | OPTS_TYPE_PT_ADDBITS15
8034 | OPTS_TYPE_PT_UNICODE
8035 | OPTS_TYPE_ST_BASE64;
8036 kern_type = KERN_TYPE_SHA1_SLTPWU;
8037 dgst_size = DGST_SIZE_4_5;
8038 parse_func = episerver_parse_hash;
8039 sort_by_digest = sort_by_digest_4_5;
8040 opti_type = OPTI_TYPE_ZERO_BYTE
8041 | OPTI_TYPE_PRECOMPUTE_INIT
8042 | OPTI_TYPE_PRECOMPUTE_MERKLE
8043 | OPTI_TYPE_EARLY_SKIP
8044 | OPTI_TYPE_NOT_ITERATED
8045 | OPTI_TYPE_PREPENDED_SALT
8046 | OPTI_TYPE_RAW_HASH;
8047 dgst_pos0 = 3;
8048 dgst_pos1 = 4;
8049 dgst_pos2 = 2;
8050 dgst_pos3 = 1;
8051 break;
8052
8053 case 150: hash_type = HASH_TYPE_SHA1;
8054 salt_type = SALT_TYPE_INTERN;
8055 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8056 opts_type = OPTS_TYPE_PT_GENERATE_BE
8057 | OPTS_TYPE_ST_ADD80
8058 | OPTS_TYPE_ST_ADDBITS15;
8059 kern_type = KERN_TYPE_HMACSHA1_PW;
8060 dgst_size = DGST_SIZE_4_5;
8061 parse_func = hmacsha1_parse_hash;
8062 sort_by_digest = sort_by_digest_4_5;
8063 opti_type = OPTI_TYPE_ZERO_BYTE
8064 | OPTI_TYPE_NOT_ITERATED;
8065 dgst_pos0 = 3;
8066 dgst_pos1 = 4;
8067 dgst_pos2 = 2;
8068 dgst_pos3 = 1;
8069 break;
8070
8071 case 160: hash_type = HASH_TYPE_SHA1;
8072 salt_type = SALT_TYPE_INTERN;
8073 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8074 opts_type = OPTS_TYPE_PT_GENERATE_BE
8075 | OPTS_TYPE_PT_ADD80
8076 | OPTS_TYPE_PT_ADDBITS15;
8077 kern_type = KERN_TYPE_HMACSHA1_SLT;
8078 dgst_size = DGST_SIZE_4_5;
8079 parse_func = hmacsha1_parse_hash;
8080 sort_by_digest = sort_by_digest_4_5;
8081 opti_type = OPTI_TYPE_ZERO_BYTE
8082 | OPTI_TYPE_NOT_ITERATED;
8083 dgst_pos0 = 3;
8084 dgst_pos1 = 4;
8085 dgst_pos2 = 2;
8086 dgst_pos3 = 1;
8087 break;
8088
8089 case 200: hash_type = HASH_TYPE_MYSQL;
8090 salt_type = SALT_TYPE_NONE;
8091 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8092 opts_type = 0;
8093 kern_type = KERN_TYPE_MYSQL;
8094 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8095 parse_func = mysql323_parse_hash;
8096 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8097 opti_type = OPTI_TYPE_ZERO_BYTE;
8098 dgst_pos0 = 0;
8099 dgst_pos1 = 1;
8100 dgst_pos2 = 2;
8101 dgst_pos3 = 3;
8102 break;
8103
8104 case 300: hash_type = HASH_TYPE_SHA1;
8105 salt_type = SALT_TYPE_NONE;
8106 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8107 opts_type = OPTS_TYPE_PT_GENERATE_BE
8108 | OPTS_TYPE_PT_ADD80
8109 | OPTS_TYPE_PT_ADDBITS15;
8110 kern_type = KERN_TYPE_MYSQL41;
8111 dgst_size = DGST_SIZE_4_5;
8112 parse_func = sha1_parse_hash;
8113 sort_by_digest = sort_by_digest_4_5;
8114 opti_type = OPTI_TYPE_ZERO_BYTE
8115 | OPTI_TYPE_PRECOMPUTE_INIT
8116 | OPTI_TYPE_PRECOMPUTE_MERKLE
8117 | OPTI_TYPE_EARLY_SKIP
8118 | OPTI_TYPE_NOT_ITERATED
8119 | OPTI_TYPE_NOT_SALTED;
8120 dgst_pos0 = 3;
8121 dgst_pos1 = 4;
8122 dgst_pos2 = 2;
8123 dgst_pos3 = 1;
8124 break;
8125
8126 case 400: hash_type = HASH_TYPE_MD5;
8127 salt_type = SALT_TYPE_EMBEDDED;
8128 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8129 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8130 kern_type = KERN_TYPE_PHPASS;
8131 dgst_size = DGST_SIZE_4_4;
8132 parse_func = phpass_parse_hash;
8133 sort_by_digest = sort_by_digest_4_4;
8134 opti_type = OPTI_TYPE_ZERO_BYTE
8135 | OPTI_TYPE_SLOW_HASH_SIMD;
8136 dgst_pos0 = 0;
8137 dgst_pos1 = 1;
8138 dgst_pos2 = 2;
8139 dgst_pos3 = 3;
8140 break;
8141
8142 case 500: hash_type = HASH_TYPE_MD5;
8143 salt_type = SALT_TYPE_EMBEDDED;
8144 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8145 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8146 kern_type = KERN_TYPE_MD5CRYPT;
8147 dgst_size = DGST_SIZE_4_4;
8148 parse_func = md5crypt_parse_hash;
8149 sort_by_digest = sort_by_digest_4_4;
8150 opti_type = OPTI_TYPE_ZERO_BYTE;
8151 dgst_pos0 = 0;
8152 dgst_pos1 = 1;
8153 dgst_pos2 = 2;
8154 dgst_pos3 = 3;
8155 break;
8156
8157 case 501: hash_type = HASH_TYPE_MD5;
8158 salt_type = SALT_TYPE_EMBEDDED;
8159 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8160 opts_type = OPTS_TYPE_PT_GENERATE_LE
8161 | OPTS_TYPE_HASH_COPY;
8162 kern_type = KERN_TYPE_MD5CRYPT;
8163 dgst_size = DGST_SIZE_4_4;
8164 parse_func = juniper_parse_hash;
8165 sort_by_digest = sort_by_digest_4_4;
8166 opti_type = OPTI_TYPE_ZERO_BYTE;
8167 dgst_pos0 = 0;
8168 dgst_pos1 = 1;
8169 dgst_pos2 = 2;
8170 dgst_pos3 = 3;
8171 break;
8172
8173 case 900: hash_type = HASH_TYPE_MD4;
8174 salt_type = SALT_TYPE_NONE;
8175 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8176 opts_type = OPTS_TYPE_PT_GENERATE_LE
8177 | OPTS_TYPE_PT_ADD80
8178 | OPTS_TYPE_PT_ADDBITS14;
8179 kern_type = KERN_TYPE_MD4;
8180 dgst_size = DGST_SIZE_4_4;
8181 parse_func = md4_parse_hash;
8182 sort_by_digest = sort_by_digest_4_4;
8183 opti_type = OPTI_TYPE_ZERO_BYTE
8184 | OPTI_TYPE_PRECOMPUTE_INIT
8185 | OPTI_TYPE_PRECOMPUTE_MERKLE
8186 | OPTI_TYPE_MEET_IN_MIDDLE
8187 | OPTI_TYPE_EARLY_SKIP
8188 | OPTI_TYPE_NOT_ITERATED
8189 | OPTI_TYPE_NOT_SALTED
8190 | OPTI_TYPE_RAW_HASH;
8191 dgst_pos0 = 0;
8192 dgst_pos1 = 3;
8193 dgst_pos2 = 2;
8194 dgst_pos3 = 1;
8195 break;
8196
8197 case 1000: hash_type = HASH_TYPE_MD4;
8198 salt_type = SALT_TYPE_NONE;
8199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8200 opts_type = OPTS_TYPE_PT_GENERATE_LE
8201 | OPTS_TYPE_PT_ADD80
8202 | OPTS_TYPE_PT_ADDBITS14
8203 | OPTS_TYPE_PT_UNICODE;
8204 kern_type = KERN_TYPE_MD4_PWU;
8205 dgst_size = DGST_SIZE_4_4;
8206 parse_func = md4_parse_hash;
8207 sort_by_digest = sort_by_digest_4_4;
8208 opti_type = OPTI_TYPE_ZERO_BYTE
8209 | OPTI_TYPE_PRECOMPUTE_INIT
8210 | OPTI_TYPE_PRECOMPUTE_MERKLE
8211 | OPTI_TYPE_MEET_IN_MIDDLE
8212 | OPTI_TYPE_EARLY_SKIP
8213 | OPTI_TYPE_NOT_ITERATED
8214 | OPTI_TYPE_NOT_SALTED
8215 | OPTI_TYPE_RAW_HASH;
8216 dgst_pos0 = 0;
8217 dgst_pos1 = 3;
8218 dgst_pos2 = 2;
8219 dgst_pos3 = 1;
8220 break;
8221
8222 case 1100: hash_type = HASH_TYPE_MD4;
8223 salt_type = SALT_TYPE_INTERN;
8224 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8225 opts_type = OPTS_TYPE_PT_GENERATE_LE
8226 | OPTS_TYPE_PT_ADD80
8227 | OPTS_TYPE_PT_ADDBITS14
8228 | OPTS_TYPE_PT_UNICODE
8229 | OPTS_TYPE_ST_ADD80
8230 | OPTS_TYPE_ST_UNICODE
8231 | OPTS_TYPE_ST_LOWER;
8232 kern_type = KERN_TYPE_MD44_PWUSLT;
8233 dgst_size = DGST_SIZE_4_4;
8234 parse_func = dcc_parse_hash;
8235 sort_by_digest = sort_by_digest_4_4;
8236 opti_type = OPTI_TYPE_ZERO_BYTE
8237 | OPTI_TYPE_PRECOMPUTE_INIT
8238 | OPTI_TYPE_PRECOMPUTE_MERKLE
8239 | OPTI_TYPE_EARLY_SKIP
8240 | OPTI_TYPE_NOT_ITERATED;
8241 dgst_pos0 = 0;
8242 dgst_pos1 = 3;
8243 dgst_pos2 = 2;
8244 dgst_pos3 = 1;
8245 break;
8246
8247 case 1400: hash_type = HASH_TYPE_SHA256;
8248 salt_type = SALT_TYPE_NONE;
8249 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8250 opts_type = OPTS_TYPE_PT_GENERATE_BE
8251 | OPTS_TYPE_PT_ADD80
8252 | OPTS_TYPE_PT_ADDBITS15;
8253 kern_type = KERN_TYPE_SHA256;
8254 dgst_size = DGST_SIZE_4_8;
8255 parse_func = sha256_parse_hash;
8256 sort_by_digest = sort_by_digest_4_8;
8257 opti_type = OPTI_TYPE_ZERO_BYTE
8258 | OPTI_TYPE_PRECOMPUTE_INIT
8259 | OPTI_TYPE_PRECOMPUTE_MERKLE
8260 | OPTI_TYPE_EARLY_SKIP
8261 | OPTI_TYPE_NOT_ITERATED
8262 | OPTI_TYPE_NOT_SALTED
8263 | OPTI_TYPE_RAW_HASH;
8264 dgst_pos0 = 3;
8265 dgst_pos1 = 7;
8266 dgst_pos2 = 2;
8267 dgst_pos3 = 6;
8268 break;
8269
8270 case 1410: hash_type = HASH_TYPE_SHA256;
8271 salt_type = SALT_TYPE_INTERN;
8272 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8273 opts_type = OPTS_TYPE_PT_GENERATE_BE
8274 | OPTS_TYPE_ST_ADD80
8275 | OPTS_TYPE_ST_ADDBITS15;
8276 kern_type = KERN_TYPE_SHA256_PWSLT;
8277 dgst_size = DGST_SIZE_4_8;
8278 parse_func = sha256s_parse_hash;
8279 sort_by_digest = sort_by_digest_4_8;
8280 opti_type = OPTI_TYPE_ZERO_BYTE
8281 | OPTI_TYPE_PRECOMPUTE_INIT
8282 | OPTI_TYPE_PRECOMPUTE_MERKLE
8283 | OPTI_TYPE_EARLY_SKIP
8284 | OPTI_TYPE_NOT_ITERATED
8285 | OPTI_TYPE_APPENDED_SALT
8286 | OPTI_TYPE_RAW_HASH;
8287 dgst_pos0 = 3;
8288 dgst_pos1 = 7;
8289 dgst_pos2 = 2;
8290 dgst_pos3 = 6;
8291 break;
8292
8293 case 1420: hash_type = HASH_TYPE_SHA256;
8294 salt_type = SALT_TYPE_INTERN;
8295 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8296 opts_type = OPTS_TYPE_PT_GENERATE_BE
8297 | OPTS_TYPE_PT_ADD80
8298 | OPTS_TYPE_PT_ADDBITS15;
8299 kern_type = KERN_TYPE_SHA256_SLTPW;
8300 dgst_size = DGST_SIZE_4_8;
8301 parse_func = sha256s_parse_hash;
8302 sort_by_digest = sort_by_digest_4_8;
8303 opti_type = OPTI_TYPE_ZERO_BYTE
8304 | OPTI_TYPE_PRECOMPUTE_INIT
8305 | OPTI_TYPE_PRECOMPUTE_MERKLE
8306 | OPTI_TYPE_EARLY_SKIP
8307 | OPTI_TYPE_NOT_ITERATED
8308 | OPTI_TYPE_PREPENDED_SALT
8309 | OPTI_TYPE_RAW_HASH;
8310 dgst_pos0 = 3;
8311 dgst_pos1 = 7;
8312 dgst_pos2 = 2;
8313 dgst_pos3 = 6;
8314 break;
8315
8316 case 1421: hash_type = HASH_TYPE_SHA256;
8317 salt_type = SALT_TYPE_EMBEDDED;
8318 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8319 opts_type = OPTS_TYPE_PT_GENERATE_BE
8320 | OPTS_TYPE_PT_ADD80
8321 | OPTS_TYPE_PT_ADDBITS15;
8322 kern_type = KERN_TYPE_SHA256_SLTPW;
8323 dgst_size = DGST_SIZE_4_8;
8324 parse_func = hmailserver_parse_hash;
8325 sort_by_digest = sort_by_digest_4_8;
8326 opti_type = OPTI_TYPE_ZERO_BYTE
8327 | OPTI_TYPE_PRECOMPUTE_INIT
8328 | OPTI_TYPE_PRECOMPUTE_MERKLE
8329 | OPTI_TYPE_EARLY_SKIP
8330 | OPTI_TYPE_NOT_ITERATED
8331 | OPTI_TYPE_PREPENDED_SALT
8332 | OPTI_TYPE_RAW_HASH;
8333 dgst_pos0 = 3;
8334 dgst_pos1 = 7;
8335 dgst_pos2 = 2;
8336 dgst_pos3 = 6;
8337 break;
8338
8339 case 1430: hash_type = HASH_TYPE_SHA256;
8340 salt_type = SALT_TYPE_INTERN;
8341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8342 opts_type = OPTS_TYPE_PT_GENERATE_BE
8343 | OPTS_TYPE_PT_UNICODE
8344 | OPTS_TYPE_ST_ADD80
8345 | OPTS_TYPE_ST_ADDBITS15;
8346 kern_type = KERN_TYPE_SHA256_PWUSLT;
8347 dgst_size = DGST_SIZE_4_8;
8348 parse_func = sha256s_parse_hash;
8349 sort_by_digest = sort_by_digest_4_8;
8350 opti_type = OPTI_TYPE_ZERO_BYTE
8351 | OPTI_TYPE_PRECOMPUTE_INIT
8352 | OPTI_TYPE_PRECOMPUTE_MERKLE
8353 | OPTI_TYPE_EARLY_SKIP
8354 | OPTI_TYPE_NOT_ITERATED
8355 | OPTI_TYPE_APPENDED_SALT
8356 | OPTI_TYPE_RAW_HASH;
8357 dgst_pos0 = 3;
8358 dgst_pos1 = 7;
8359 dgst_pos2 = 2;
8360 dgst_pos3 = 6;
8361 break;
8362
8363 case 1440: hash_type = HASH_TYPE_SHA256;
8364 salt_type = SALT_TYPE_INTERN;
8365 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8366 opts_type = OPTS_TYPE_PT_GENERATE_BE
8367 | OPTS_TYPE_PT_ADD80
8368 | OPTS_TYPE_PT_ADDBITS15
8369 | OPTS_TYPE_PT_UNICODE;
8370 kern_type = KERN_TYPE_SHA256_SLTPWU;
8371 dgst_size = DGST_SIZE_4_8;
8372 parse_func = sha256s_parse_hash;
8373 sort_by_digest = sort_by_digest_4_8;
8374 opti_type = OPTI_TYPE_ZERO_BYTE
8375 | OPTI_TYPE_PRECOMPUTE_INIT
8376 | OPTI_TYPE_PRECOMPUTE_MERKLE
8377 | OPTI_TYPE_EARLY_SKIP
8378 | OPTI_TYPE_NOT_ITERATED
8379 | OPTI_TYPE_PREPENDED_SALT
8380 | OPTI_TYPE_RAW_HASH;
8381 dgst_pos0 = 3;
8382 dgst_pos1 = 7;
8383 dgst_pos2 = 2;
8384 dgst_pos3 = 6;
8385 break;
8386
8387 case 1441: hash_type = HASH_TYPE_SHA256;
8388 salt_type = SALT_TYPE_EMBEDDED;
8389 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8390 opts_type = OPTS_TYPE_PT_GENERATE_BE
8391 | OPTS_TYPE_PT_ADD80
8392 | OPTS_TYPE_PT_ADDBITS15
8393 | OPTS_TYPE_PT_UNICODE
8394 | OPTS_TYPE_ST_BASE64;
8395 kern_type = KERN_TYPE_SHA256_SLTPWU;
8396 dgst_size = DGST_SIZE_4_8;
8397 parse_func = episerver4_parse_hash;
8398 sort_by_digest = sort_by_digest_4_8;
8399 opti_type = OPTI_TYPE_ZERO_BYTE
8400 | OPTI_TYPE_PRECOMPUTE_INIT
8401 | OPTI_TYPE_PRECOMPUTE_MERKLE
8402 | OPTI_TYPE_EARLY_SKIP
8403 | OPTI_TYPE_NOT_ITERATED
8404 | OPTI_TYPE_PREPENDED_SALT
8405 | OPTI_TYPE_RAW_HASH;
8406 dgst_pos0 = 3;
8407 dgst_pos1 = 7;
8408 dgst_pos2 = 2;
8409 dgst_pos3 = 6;
8410 break;
8411
8412 case 1450: hash_type = HASH_TYPE_SHA256;
8413 salt_type = SALT_TYPE_INTERN;
8414 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8415 opts_type = OPTS_TYPE_PT_GENERATE_BE
8416 | OPTS_TYPE_ST_ADD80;
8417 kern_type = KERN_TYPE_HMACSHA256_PW;
8418 dgst_size = DGST_SIZE_4_8;
8419 parse_func = hmacsha256_parse_hash;
8420 sort_by_digest = sort_by_digest_4_8;
8421 opti_type = OPTI_TYPE_ZERO_BYTE
8422 | OPTI_TYPE_NOT_ITERATED;
8423 dgst_pos0 = 3;
8424 dgst_pos1 = 7;
8425 dgst_pos2 = 2;
8426 dgst_pos3 = 6;
8427 break;
8428
8429 case 1460: hash_type = HASH_TYPE_SHA256;
8430 salt_type = SALT_TYPE_INTERN;
8431 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8432 opts_type = OPTS_TYPE_PT_GENERATE_BE
8433 | OPTS_TYPE_PT_ADD80
8434 | OPTS_TYPE_PT_ADDBITS15;
8435 kern_type = KERN_TYPE_HMACSHA256_SLT;
8436 dgst_size = DGST_SIZE_4_8;
8437 parse_func = hmacsha256_parse_hash;
8438 sort_by_digest = sort_by_digest_4_8;
8439 opti_type = OPTI_TYPE_ZERO_BYTE
8440 | OPTI_TYPE_NOT_ITERATED;
8441 dgst_pos0 = 3;
8442 dgst_pos1 = 7;
8443 dgst_pos2 = 2;
8444 dgst_pos3 = 6;
8445 break;
8446
8447 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8448 salt_type = SALT_TYPE_EMBEDDED;
8449 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8450 opts_type = OPTS_TYPE_PT_GENERATE_LE
8451 | OPTS_TYPE_PT_BITSLICE;
8452 kern_type = KERN_TYPE_DESCRYPT;
8453 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8454 parse_func = descrypt_parse_hash;
8455 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8456 opti_type = OPTI_TYPE_ZERO_BYTE
8457 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8458 dgst_pos0 = 0;
8459 dgst_pos1 = 1;
8460 dgst_pos2 = 2;
8461 dgst_pos3 = 3;
8462 break;
8463
8464 case 1600: hash_type = HASH_TYPE_MD5;
8465 salt_type = SALT_TYPE_EMBEDDED;
8466 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8467 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8468 kern_type = KERN_TYPE_APR1CRYPT;
8469 dgst_size = DGST_SIZE_4_4;
8470 parse_func = md5apr1_parse_hash;
8471 sort_by_digest = sort_by_digest_4_4;
8472 opti_type = OPTI_TYPE_ZERO_BYTE;
8473 dgst_pos0 = 0;
8474 dgst_pos1 = 1;
8475 dgst_pos2 = 2;
8476 dgst_pos3 = 3;
8477 break;
8478
8479 case 1700: hash_type = HASH_TYPE_SHA512;
8480 salt_type = SALT_TYPE_NONE;
8481 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8482 opts_type = OPTS_TYPE_PT_GENERATE_BE
8483 | OPTS_TYPE_PT_ADD80
8484 | OPTS_TYPE_PT_ADDBITS15;
8485 kern_type = KERN_TYPE_SHA512;
8486 dgst_size = DGST_SIZE_8_8;
8487 parse_func = sha512_parse_hash;
8488 sort_by_digest = sort_by_digest_8_8;
8489 opti_type = OPTI_TYPE_ZERO_BYTE
8490 | OPTI_TYPE_PRECOMPUTE_INIT
8491 | OPTI_TYPE_PRECOMPUTE_MERKLE
8492 | OPTI_TYPE_EARLY_SKIP
8493 | OPTI_TYPE_NOT_ITERATED
8494 | OPTI_TYPE_NOT_SALTED
8495 | OPTI_TYPE_USES_BITS_64
8496 | OPTI_TYPE_RAW_HASH;
8497 dgst_pos0 = 14;
8498 dgst_pos1 = 15;
8499 dgst_pos2 = 6;
8500 dgst_pos3 = 7;
8501 break;
8502
8503 case 1710: hash_type = HASH_TYPE_SHA512;
8504 salt_type = SALT_TYPE_INTERN;
8505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8506 opts_type = OPTS_TYPE_PT_GENERATE_BE
8507 | OPTS_TYPE_ST_ADD80
8508 | OPTS_TYPE_ST_ADDBITS15;
8509 kern_type = KERN_TYPE_SHA512_PWSLT;
8510 dgst_size = DGST_SIZE_8_8;
8511 parse_func = sha512s_parse_hash;
8512 sort_by_digest = sort_by_digest_8_8;
8513 opti_type = OPTI_TYPE_ZERO_BYTE
8514 | OPTI_TYPE_PRECOMPUTE_INIT
8515 | OPTI_TYPE_PRECOMPUTE_MERKLE
8516 | OPTI_TYPE_EARLY_SKIP
8517 | OPTI_TYPE_NOT_ITERATED
8518 | OPTI_TYPE_APPENDED_SALT
8519 | OPTI_TYPE_USES_BITS_64
8520 | OPTI_TYPE_RAW_HASH;
8521 dgst_pos0 = 14;
8522 dgst_pos1 = 15;
8523 dgst_pos2 = 6;
8524 dgst_pos3 = 7;
8525 break;
8526
8527 case 1711: hash_type = HASH_TYPE_SHA512;
8528 salt_type = SALT_TYPE_EMBEDDED;
8529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8530 opts_type = OPTS_TYPE_PT_GENERATE_BE
8531 | OPTS_TYPE_ST_ADD80
8532 | OPTS_TYPE_ST_ADDBITS15;
8533 kern_type = KERN_TYPE_SHA512_PWSLT;
8534 dgst_size = DGST_SIZE_8_8;
8535 parse_func = sha512b64s_parse_hash;
8536 sort_by_digest = sort_by_digest_8_8;
8537 opti_type = OPTI_TYPE_ZERO_BYTE
8538 | OPTI_TYPE_PRECOMPUTE_INIT
8539 | OPTI_TYPE_PRECOMPUTE_MERKLE
8540 | OPTI_TYPE_EARLY_SKIP
8541 | OPTI_TYPE_NOT_ITERATED
8542 | OPTI_TYPE_APPENDED_SALT
8543 | OPTI_TYPE_USES_BITS_64
8544 | OPTI_TYPE_RAW_HASH;
8545 dgst_pos0 = 14;
8546 dgst_pos1 = 15;
8547 dgst_pos2 = 6;
8548 dgst_pos3 = 7;
8549 break;
8550
8551 case 1720: hash_type = HASH_TYPE_SHA512;
8552 salt_type = SALT_TYPE_INTERN;
8553 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8554 opts_type = OPTS_TYPE_PT_GENERATE_BE
8555 | OPTS_TYPE_PT_ADD80
8556 | OPTS_TYPE_PT_ADDBITS15;
8557 kern_type = KERN_TYPE_SHA512_SLTPW;
8558 dgst_size = DGST_SIZE_8_8;
8559 parse_func = sha512s_parse_hash;
8560 sort_by_digest = sort_by_digest_8_8;
8561 opti_type = OPTI_TYPE_ZERO_BYTE
8562 | OPTI_TYPE_PRECOMPUTE_INIT
8563 | OPTI_TYPE_PRECOMPUTE_MERKLE
8564 | OPTI_TYPE_EARLY_SKIP
8565 | OPTI_TYPE_NOT_ITERATED
8566 | OPTI_TYPE_PREPENDED_SALT
8567 | OPTI_TYPE_USES_BITS_64
8568 | OPTI_TYPE_RAW_HASH;
8569 dgst_pos0 = 14;
8570 dgst_pos1 = 15;
8571 dgst_pos2 = 6;
8572 dgst_pos3 = 7;
8573 break;
8574
8575 case 1722: hash_type = HASH_TYPE_SHA512;
8576 salt_type = SALT_TYPE_EMBEDDED;
8577 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8578 opts_type = OPTS_TYPE_PT_GENERATE_BE
8579 | OPTS_TYPE_PT_ADD80
8580 | OPTS_TYPE_PT_ADDBITS15
8581 | OPTS_TYPE_ST_HEX;
8582 kern_type = KERN_TYPE_SHA512_SLTPW;
8583 dgst_size = DGST_SIZE_8_8;
8584 parse_func = osx512_parse_hash;
8585 sort_by_digest = sort_by_digest_8_8;
8586 opti_type = OPTI_TYPE_ZERO_BYTE
8587 | OPTI_TYPE_PRECOMPUTE_INIT
8588 | OPTI_TYPE_PRECOMPUTE_MERKLE
8589 | OPTI_TYPE_EARLY_SKIP
8590 | OPTI_TYPE_NOT_ITERATED
8591 | OPTI_TYPE_PREPENDED_SALT
8592 | OPTI_TYPE_USES_BITS_64
8593 | OPTI_TYPE_RAW_HASH;
8594 dgst_pos0 = 14;
8595 dgst_pos1 = 15;
8596 dgst_pos2 = 6;
8597 dgst_pos3 = 7;
8598 break;
8599
8600 case 1730: hash_type = HASH_TYPE_SHA512;
8601 salt_type = SALT_TYPE_INTERN;
8602 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8603 opts_type = OPTS_TYPE_PT_GENERATE_BE
8604 | OPTS_TYPE_PT_UNICODE
8605 | OPTS_TYPE_ST_ADD80
8606 | OPTS_TYPE_ST_ADDBITS15;
8607 kern_type = KERN_TYPE_SHA512_PWSLTU;
8608 dgst_size = DGST_SIZE_8_8;
8609 parse_func = sha512s_parse_hash;
8610 sort_by_digest = sort_by_digest_8_8;
8611 opti_type = OPTI_TYPE_ZERO_BYTE
8612 | OPTI_TYPE_PRECOMPUTE_INIT
8613 | OPTI_TYPE_PRECOMPUTE_MERKLE
8614 | OPTI_TYPE_EARLY_SKIP
8615 | OPTI_TYPE_NOT_ITERATED
8616 | OPTI_TYPE_APPENDED_SALT
8617 | OPTI_TYPE_USES_BITS_64
8618 | OPTI_TYPE_RAW_HASH;
8619 dgst_pos0 = 14;
8620 dgst_pos1 = 15;
8621 dgst_pos2 = 6;
8622 dgst_pos3 = 7;
8623 break;
8624
8625 case 1731: hash_type = HASH_TYPE_SHA512;
8626 salt_type = SALT_TYPE_EMBEDDED;
8627 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8628 opts_type = OPTS_TYPE_PT_GENERATE_BE
8629 | OPTS_TYPE_PT_UNICODE
8630 | OPTS_TYPE_ST_ADD80
8631 | OPTS_TYPE_ST_ADDBITS15
8632 | OPTS_TYPE_ST_HEX;
8633 kern_type = KERN_TYPE_SHA512_PWSLTU;
8634 dgst_size = DGST_SIZE_8_8;
8635 parse_func = mssql2012_parse_hash;
8636 sort_by_digest = sort_by_digest_8_8;
8637 opti_type = OPTI_TYPE_ZERO_BYTE
8638 | OPTI_TYPE_PRECOMPUTE_INIT
8639 | OPTI_TYPE_PRECOMPUTE_MERKLE
8640 | OPTI_TYPE_EARLY_SKIP
8641 | OPTI_TYPE_NOT_ITERATED
8642 | OPTI_TYPE_APPENDED_SALT
8643 | OPTI_TYPE_USES_BITS_64
8644 | OPTI_TYPE_RAW_HASH;
8645 dgst_pos0 = 14;
8646 dgst_pos1 = 15;
8647 dgst_pos2 = 6;
8648 dgst_pos3 = 7;
8649 break;
8650
8651 case 1740: hash_type = HASH_TYPE_SHA512;
8652 salt_type = SALT_TYPE_INTERN;
8653 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8654 opts_type = OPTS_TYPE_PT_GENERATE_BE
8655 | OPTS_TYPE_PT_ADD80
8656 | OPTS_TYPE_PT_ADDBITS15
8657 | OPTS_TYPE_PT_UNICODE;
8658 kern_type = KERN_TYPE_SHA512_SLTPWU;
8659 dgst_size = DGST_SIZE_8_8;
8660 parse_func = sha512s_parse_hash;
8661 sort_by_digest = sort_by_digest_8_8;
8662 opti_type = OPTI_TYPE_ZERO_BYTE
8663 | OPTI_TYPE_PRECOMPUTE_INIT
8664 | OPTI_TYPE_PRECOMPUTE_MERKLE
8665 | OPTI_TYPE_EARLY_SKIP
8666 | OPTI_TYPE_NOT_ITERATED
8667 | OPTI_TYPE_PREPENDED_SALT
8668 | OPTI_TYPE_USES_BITS_64
8669 | OPTI_TYPE_RAW_HASH;
8670 dgst_pos0 = 14;
8671 dgst_pos1 = 15;
8672 dgst_pos2 = 6;
8673 dgst_pos3 = 7;
8674 break;
8675
8676 case 1750: hash_type = HASH_TYPE_SHA512;
8677 salt_type = SALT_TYPE_INTERN;
8678 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8679 opts_type = OPTS_TYPE_PT_GENERATE_BE
8680 | OPTS_TYPE_ST_ADD80;
8681 kern_type = KERN_TYPE_HMACSHA512_PW;
8682 dgst_size = DGST_SIZE_8_8;
8683 parse_func = hmacsha512_parse_hash;
8684 sort_by_digest = sort_by_digest_8_8;
8685 opti_type = OPTI_TYPE_ZERO_BYTE
8686 | OPTI_TYPE_USES_BITS_64
8687 | OPTI_TYPE_NOT_ITERATED;
8688 dgst_pos0 = 14;
8689 dgst_pos1 = 15;
8690 dgst_pos2 = 6;
8691 dgst_pos3 = 7;
8692 break;
8693
8694 case 1760: hash_type = HASH_TYPE_SHA512;
8695 salt_type = SALT_TYPE_INTERN;
8696 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8697 opts_type = OPTS_TYPE_PT_GENERATE_BE
8698 | OPTS_TYPE_PT_ADD80
8699 | OPTS_TYPE_PT_ADDBITS15;
8700 kern_type = KERN_TYPE_HMACSHA512_SLT;
8701 dgst_size = DGST_SIZE_8_8;
8702 parse_func = hmacsha512_parse_hash;
8703 sort_by_digest = sort_by_digest_8_8;
8704 opti_type = OPTI_TYPE_ZERO_BYTE
8705 | OPTI_TYPE_USES_BITS_64
8706 | OPTI_TYPE_NOT_ITERATED;
8707 dgst_pos0 = 14;
8708 dgst_pos1 = 15;
8709 dgst_pos2 = 6;
8710 dgst_pos3 = 7;
8711 break;
8712
8713 case 1800: hash_type = HASH_TYPE_SHA512;
8714 salt_type = SALT_TYPE_EMBEDDED;
8715 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8716 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8717 kern_type = KERN_TYPE_SHA512CRYPT;
8718 dgst_size = DGST_SIZE_8_8;
8719 parse_func = sha512crypt_parse_hash;
8720 sort_by_digest = sort_by_digest_8_8;
8721 opti_type = OPTI_TYPE_ZERO_BYTE
8722 | OPTI_TYPE_USES_BITS_64;
8723 dgst_pos0 = 0;
8724 dgst_pos1 = 1;
8725 dgst_pos2 = 2;
8726 dgst_pos3 = 3;
8727 break;
8728
8729 case 2000: hash_type = HASH_TYPE_STDOUT;
8730 salt_type = SALT_TYPE_NONE;
8731 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8732 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8733 kern_type = KERN_TYPE_STDOUT;
8734 dgst_size = DGST_SIZE_4_4;
8735 parse_func = NULL;
8736 sort_by_digest = NULL;
8737 opti_type = 0;
8738 dgst_pos0 = 0;
8739 dgst_pos1 = 0;
8740 dgst_pos2 = 0;
8741 dgst_pos3 = 0;
8742 break;
8743
8744 case 2100: hash_type = HASH_TYPE_DCC2;
8745 salt_type = SALT_TYPE_EMBEDDED;
8746 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8747 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8748 | OPTS_TYPE_ST_LOWER
8749 | OPTS_TYPE_ST_UNICODE;
8750 kern_type = KERN_TYPE_DCC2;
8751 dgst_size = DGST_SIZE_4_4;
8752 parse_func = dcc2_parse_hash;
8753 sort_by_digest = sort_by_digest_4_4;
8754 opti_type = OPTI_TYPE_ZERO_BYTE
8755 | OPTI_TYPE_SLOW_HASH_SIMD;
8756 dgst_pos0 = 0;
8757 dgst_pos1 = 1;
8758 dgst_pos2 = 2;
8759 dgst_pos3 = 3;
8760 break;
8761
8762 case 2400: hash_type = HASH_TYPE_MD5;
8763 salt_type = SALT_TYPE_NONE;
8764 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8765 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8766 kern_type = KERN_TYPE_MD5PIX;
8767 dgst_size = DGST_SIZE_4_4;
8768 parse_func = md5pix_parse_hash;
8769 sort_by_digest = sort_by_digest_4_4;
8770 opti_type = OPTI_TYPE_ZERO_BYTE
8771 | OPTI_TYPE_PRECOMPUTE_INIT
8772 | OPTI_TYPE_PRECOMPUTE_MERKLE
8773 | OPTI_TYPE_EARLY_SKIP
8774 | OPTI_TYPE_NOT_ITERATED
8775 | OPTI_TYPE_NOT_SALTED;
8776 dgst_pos0 = 0;
8777 dgst_pos1 = 3;
8778 dgst_pos2 = 2;
8779 dgst_pos3 = 1;
8780 break;
8781
8782 case 2410: hash_type = HASH_TYPE_MD5;
8783 salt_type = SALT_TYPE_INTERN;
8784 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8785 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8786 kern_type = KERN_TYPE_MD5ASA;
8787 dgst_size = DGST_SIZE_4_4;
8788 parse_func = md5asa_parse_hash;
8789 sort_by_digest = sort_by_digest_4_4;
8790 opti_type = OPTI_TYPE_ZERO_BYTE
8791 | OPTI_TYPE_PRECOMPUTE_INIT
8792 | OPTI_TYPE_PRECOMPUTE_MERKLE
8793 | OPTI_TYPE_EARLY_SKIP
8794 | OPTI_TYPE_NOT_ITERATED;
8795 dgst_pos0 = 0;
8796 dgst_pos1 = 3;
8797 dgst_pos2 = 2;
8798 dgst_pos3 = 1;
8799 break;
8800
8801 case 2500: hash_type = HASH_TYPE_WPA;
8802 salt_type = SALT_TYPE_EMBEDDED;
8803 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8804 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8805 kern_type = KERN_TYPE_WPA;
8806 dgst_size = DGST_SIZE_4_4;
8807 parse_func = wpa_parse_hash;
8808 sort_by_digest = sort_by_digest_4_4;
8809 opti_type = OPTI_TYPE_ZERO_BYTE
8810 | OPTI_TYPE_SLOW_HASH_SIMD;
8811 dgst_pos0 = 0;
8812 dgst_pos1 = 1;
8813 dgst_pos2 = 2;
8814 dgst_pos3 = 3;
8815 break;
8816
8817 case 2600: hash_type = HASH_TYPE_MD5;
8818 salt_type = SALT_TYPE_VIRTUAL;
8819 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8820 opts_type = OPTS_TYPE_PT_GENERATE_LE
8821 | OPTS_TYPE_PT_ADD80
8822 | OPTS_TYPE_PT_ADDBITS14
8823 | OPTS_TYPE_ST_ADD80;
8824 kern_type = KERN_TYPE_MD55_PWSLT1;
8825 dgst_size = DGST_SIZE_4_4;
8826 parse_func = md5md5_parse_hash;
8827 sort_by_digest = sort_by_digest_4_4;
8828 opti_type = OPTI_TYPE_ZERO_BYTE
8829 | OPTI_TYPE_PRECOMPUTE_INIT
8830 | OPTI_TYPE_PRECOMPUTE_MERKLE
8831 | OPTI_TYPE_EARLY_SKIP;
8832 dgst_pos0 = 0;
8833 dgst_pos1 = 3;
8834 dgst_pos2 = 2;
8835 dgst_pos3 = 1;
8836 break;
8837
8838 case 2611: hash_type = HASH_TYPE_MD5;
8839 salt_type = SALT_TYPE_INTERN;
8840 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8841 opts_type = OPTS_TYPE_PT_GENERATE_LE
8842 | OPTS_TYPE_PT_ADD80
8843 | OPTS_TYPE_PT_ADDBITS14
8844 | OPTS_TYPE_ST_ADD80;
8845 kern_type = KERN_TYPE_MD55_PWSLT1;
8846 dgst_size = DGST_SIZE_4_4;
8847 parse_func = vb3_parse_hash;
8848 sort_by_digest = sort_by_digest_4_4;
8849 opti_type = OPTI_TYPE_ZERO_BYTE
8850 | OPTI_TYPE_PRECOMPUTE_INIT
8851 | OPTI_TYPE_PRECOMPUTE_MERKLE
8852 | OPTI_TYPE_EARLY_SKIP;
8853 dgst_pos0 = 0;
8854 dgst_pos1 = 3;
8855 dgst_pos2 = 2;
8856 dgst_pos3 = 1;
8857 break;
8858
8859 case 2612: hash_type = HASH_TYPE_MD5;
8860 salt_type = SALT_TYPE_EMBEDDED;
8861 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8862 opts_type = OPTS_TYPE_PT_GENERATE_LE
8863 | OPTS_TYPE_PT_ADD80
8864 | OPTS_TYPE_PT_ADDBITS14
8865 | OPTS_TYPE_ST_ADD80
8866 | OPTS_TYPE_ST_HEX;
8867 kern_type = KERN_TYPE_MD55_PWSLT1;
8868 dgst_size = DGST_SIZE_4_4;
8869 parse_func = phps_parse_hash;
8870 sort_by_digest = sort_by_digest_4_4;
8871 opti_type = OPTI_TYPE_ZERO_BYTE
8872 | OPTI_TYPE_PRECOMPUTE_INIT
8873 | OPTI_TYPE_PRECOMPUTE_MERKLE
8874 | OPTI_TYPE_EARLY_SKIP;
8875 dgst_pos0 = 0;
8876 dgst_pos1 = 3;
8877 dgst_pos2 = 2;
8878 dgst_pos3 = 1;
8879 break;
8880
8881 case 2711: hash_type = HASH_TYPE_MD5;
8882 salt_type = SALT_TYPE_INTERN;
8883 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8884 opts_type = OPTS_TYPE_PT_GENERATE_LE
8885 | OPTS_TYPE_PT_ADD80
8886 | OPTS_TYPE_PT_ADDBITS14
8887 | OPTS_TYPE_ST_ADD80;
8888 kern_type = KERN_TYPE_MD55_PWSLT2;
8889 dgst_size = DGST_SIZE_4_4;
8890 parse_func = vb30_parse_hash;
8891 sort_by_digest = sort_by_digest_4_4;
8892 opti_type = OPTI_TYPE_ZERO_BYTE
8893 | OPTI_TYPE_PRECOMPUTE_INIT
8894 | OPTI_TYPE_EARLY_SKIP;
8895 dgst_pos0 = 0;
8896 dgst_pos1 = 3;
8897 dgst_pos2 = 2;
8898 dgst_pos3 = 1;
8899 break;
8900
8901 case 2811: hash_type = HASH_TYPE_MD5;
8902 salt_type = SALT_TYPE_INTERN;
8903 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8904 opts_type = OPTS_TYPE_PT_GENERATE_LE
8905 | OPTS_TYPE_PT_ADD80
8906 | OPTS_TYPE_PT_ADDBITS14;
8907 kern_type = KERN_TYPE_MD55_SLTPW;
8908 dgst_size = DGST_SIZE_4_4;
8909 parse_func = ipb2_parse_hash;
8910 sort_by_digest = sort_by_digest_4_4;
8911 opti_type = OPTI_TYPE_ZERO_BYTE
8912 | OPTI_TYPE_PRECOMPUTE_INIT
8913 | OPTI_TYPE_EARLY_SKIP;
8914 dgst_pos0 = 0;
8915 dgst_pos1 = 3;
8916 dgst_pos2 = 2;
8917 dgst_pos3 = 1;
8918 break;
8919
8920 case 3000: hash_type = HASH_TYPE_LM;
8921 salt_type = SALT_TYPE_NONE;
8922 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8923 opts_type = OPTS_TYPE_PT_GENERATE_LE
8924 | OPTS_TYPE_PT_UPPER
8925 | OPTS_TYPE_PT_BITSLICE;
8926 kern_type = KERN_TYPE_LM;
8927 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8928 parse_func = lm_parse_hash;
8929 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8930 opti_type = OPTI_TYPE_ZERO_BYTE
8931 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8932 dgst_pos0 = 0;
8933 dgst_pos1 = 1;
8934 dgst_pos2 = 2;
8935 dgst_pos3 = 3;
8936 break;
8937
8938 case 3100: hash_type = HASH_TYPE_ORACLEH;
8939 salt_type = SALT_TYPE_INTERN;
8940 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8941 opts_type = OPTS_TYPE_PT_GENERATE_LE
8942 | OPTS_TYPE_PT_UPPER
8943 | OPTS_TYPE_ST_UPPER;
8944 kern_type = KERN_TYPE_ORACLEH;
8945 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8946 parse_func = oracleh_parse_hash;
8947 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8948 opti_type = OPTI_TYPE_ZERO_BYTE;
8949 dgst_pos0 = 0;
8950 dgst_pos1 = 1;
8951 dgst_pos2 = 2;
8952 dgst_pos3 = 3;
8953 break;
8954
8955 case 3200: hash_type = HASH_TYPE_BCRYPT;
8956 salt_type = SALT_TYPE_EMBEDDED;
8957 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8958 opts_type = OPTS_TYPE_PT_GENERATE_LE
8959 | OPTS_TYPE_ST_GENERATE_LE;
8960 kern_type = KERN_TYPE_BCRYPT;
8961 dgst_size = DGST_SIZE_4_6;
8962 parse_func = bcrypt_parse_hash;
8963 sort_by_digest = sort_by_digest_4_6;
8964 opti_type = OPTI_TYPE_ZERO_BYTE;
8965 dgst_pos0 = 0;
8966 dgst_pos1 = 1;
8967 dgst_pos2 = 2;
8968 dgst_pos3 = 3;
8969 break;
8970
8971 case 3710: hash_type = HASH_TYPE_MD5;
8972 salt_type = SALT_TYPE_INTERN;
8973 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8974 opts_type = OPTS_TYPE_PT_GENERATE_LE
8975 | OPTS_TYPE_PT_ADD80
8976 | OPTS_TYPE_PT_ADDBITS14;
8977 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8978 dgst_size = DGST_SIZE_4_4;
8979 parse_func = md5s_parse_hash;
8980 sort_by_digest = sort_by_digest_4_4;
8981 opti_type = OPTI_TYPE_ZERO_BYTE
8982 | OPTI_TYPE_PRECOMPUTE_INIT
8983 | OPTI_TYPE_PRECOMPUTE_MERKLE
8984 | OPTI_TYPE_EARLY_SKIP;
8985 dgst_pos0 = 0;
8986 dgst_pos1 = 3;
8987 dgst_pos2 = 2;
8988 dgst_pos3 = 1;
8989 break;
8990
8991 case 3711: hash_type = HASH_TYPE_MD5;
8992 salt_type = SALT_TYPE_EMBEDDED;
8993 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8994 opts_type = OPTS_TYPE_PT_GENERATE_LE
8995 | OPTS_TYPE_PT_ADD80
8996 | OPTS_TYPE_PT_ADDBITS14;
8997 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8998 dgst_size = DGST_SIZE_4_4;
8999 parse_func = mediawiki_b_parse_hash;
9000 sort_by_digest = sort_by_digest_4_4;
9001 opti_type = OPTI_TYPE_ZERO_BYTE
9002 | OPTI_TYPE_PRECOMPUTE_INIT
9003 | OPTI_TYPE_PRECOMPUTE_MERKLE
9004 | OPTI_TYPE_EARLY_SKIP;
9005 dgst_pos0 = 0;
9006 dgst_pos1 = 3;
9007 dgst_pos2 = 2;
9008 dgst_pos3 = 1;
9009 break;
9010
9011 case 3800: hash_type = HASH_TYPE_MD5;
9012 salt_type = SALT_TYPE_INTERN;
9013 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9014 opts_type = OPTS_TYPE_PT_GENERATE_LE
9015 | OPTS_TYPE_ST_ADDBITS14;
9016 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
9017 dgst_size = DGST_SIZE_4_4;
9018 parse_func = md5s_parse_hash;
9019 sort_by_digest = sort_by_digest_4_4;
9020 opti_type = OPTI_TYPE_ZERO_BYTE
9021 | OPTI_TYPE_PRECOMPUTE_INIT
9022 | OPTI_TYPE_PRECOMPUTE_MERKLE
9023 | OPTI_TYPE_EARLY_SKIP
9024 | OPTI_TYPE_NOT_ITERATED
9025 | OPTI_TYPE_RAW_HASH;
9026 dgst_pos0 = 0;
9027 dgst_pos1 = 3;
9028 dgst_pos2 = 2;
9029 dgst_pos3 = 1;
9030 break;
9031
9032 case 4300: hash_type = HASH_TYPE_MD5;
9033 salt_type = SALT_TYPE_VIRTUAL;
9034 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9035 opts_type = OPTS_TYPE_PT_GENERATE_LE
9036 | OPTS_TYPE_PT_ADD80
9037 | OPTS_TYPE_PT_ADDBITS14
9038 | OPTS_TYPE_ST_ADD80;
9039 kern_type = KERN_TYPE_MD5U5_PWSLT1;
9040 dgst_size = DGST_SIZE_4_4;
9041 parse_func = md5md5_parse_hash;
9042 sort_by_digest = sort_by_digest_4_4;
9043 opti_type = OPTI_TYPE_ZERO_BYTE
9044 | OPTI_TYPE_PRECOMPUTE_INIT
9045 | OPTI_TYPE_PRECOMPUTE_MERKLE
9046 | OPTI_TYPE_EARLY_SKIP;
9047 dgst_pos0 = 0;
9048 dgst_pos1 = 3;
9049 dgst_pos2 = 2;
9050 dgst_pos3 = 1;
9051 break;
9052
9053
9054 case 4400: hash_type = HASH_TYPE_MD5;
9055 salt_type = SALT_TYPE_NONE;
9056 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9057 opts_type = OPTS_TYPE_PT_GENERATE_BE
9058 | OPTS_TYPE_PT_ADD80
9059 | OPTS_TYPE_PT_ADDBITS15;
9060 kern_type = KERN_TYPE_MD5_SHA1;
9061 dgst_size = DGST_SIZE_4_4;
9062 parse_func = md5_parse_hash;
9063 sort_by_digest = sort_by_digest_4_4;
9064 opti_type = OPTI_TYPE_ZERO_BYTE
9065 | OPTI_TYPE_PRECOMPUTE_INIT
9066 | OPTI_TYPE_PRECOMPUTE_MERKLE
9067 | OPTI_TYPE_EARLY_SKIP
9068 | OPTI_TYPE_NOT_ITERATED
9069 | OPTI_TYPE_NOT_SALTED
9070 | OPTI_TYPE_RAW_HASH;
9071 dgst_pos0 = 0;
9072 dgst_pos1 = 3;
9073 dgst_pos2 = 2;
9074 dgst_pos3 = 1;
9075 break;
9076
9077 case 4500: hash_type = HASH_TYPE_SHA1;
9078 salt_type = SALT_TYPE_NONE;
9079 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9080 opts_type = OPTS_TYPE_PT_GENERATE_BE
9081 | OPTS_TYPE_PT_ADD80
9082 | OPTS_TYPE_PT_ADDBITS15;
9083 kern_type = KERN_TYPE_SHA11;
9084 dgst_size = DGST_SIZE_4_5;
9085 parse_func = sha1_parse_hash;
9086 sort_by_digest = sort_by_digest_4_5;
9087 opti_type = OPTI_TYPE_ZERO_BYTE
9088 | OPTI_TYPE_PRECOMPUTE_INIT
9089 | OPTI_TYPE_PRECOMPUTE_MERKLE
9090 | OPTI_TYPE_EARLY_SKIP
9091 | OPTI_TYPE_NOT_SALTED;
9092 dgst_pos0 = 3;
9093 dgst_pos1 = 4;
9094 dgst_pos2 = 2;
9095 dgst_pos3 = 1;
9096 break;
9097
9098 case 4700: hash_type = HASH_TYPE_SHA1;
9099 salt_type = SALT_TYPE_NONE;
9100 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9101 opts_type = OPTS_TYPE_PT_GENERATE_LE
9102 | OPTS_TYPE_PT_ADD80
9103 | OPTS_TYPE_PT_ADDBITS14;
9104 kern_type = KERN_TYPE_SHA1_MD5;
9105 dgst_size = DGST_SIZE_4_5;
9106 parse_func = sha1_parse_hash;
9107 sort_by_digest = sort_by_digest_4_5;
9108 opti_type = OPTI_TYPE_ZERO_BYTE
9109 | OPTI_TYPE_PRECOMPUTE_INIT
9110 | OPTI_TYPE_PRECOMPUTE_MERKLE
9111 | OPTI_TYPE_EARLY_SKIP
9112 | OPTI_TYPE_NOT_ITERATED
9113 | OPTI_TYPE_NOT_SALTED
9114 | OPTI_TYPE_RAW_HASH;
9115 dgst_pos0 = 3;
9116 dgst_pos1 = 4;
9117 dgst_pos2 = 2;
9118 dgst_pos3 = 1;
9119 break;
9120
9121 case 4800: hash_type = HASH_TYPE_MD5;
9122 salt_type = SALT_TYPE_EMBEDDED;
9123 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9124 opts_type = OPTS_TYPE_PT_GENERATE_LE
9125 | OPTS_TYPE_PT_ADDBITS14;
9126 kern_type = KERN_TYPE_MD5_CHAP;
9127 dgst_size = DGST_SIZE_4_4;
9128 parse_func = chap_parse_hash;
9129 sort_by_digest = sort_by_digest_4_4;
9130 opti_type = OPTI_TYPE_ZERO_BYTE
9131 | OPTI_TYPE_PRECOMPUTE_INIT
9132 | OPTI_TYPE_PRECOMPUTE_MERKLE
9133 | OPTI_TYPE_MEET_IN_MIDDLE
9134 | OPTI_TYPE_EARLY_SKIP
9135 | OPTI_TYPE_NOT_ITERATED
9136 | OPTI_TYPE_RAW_HASH;
9137 dgst_pos0 = 0;
9138 dgst_pos1 = 3;
9139 dgst_pos2 = 2;
9140 dgst_pos3 = 1;
9141 break;
9142
9143 case 4900: hash_type = HASH_TYPE_SHA1;
9144 salt_type = SALT_TYPE_INTERN;
9145 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9146 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9147 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9148 dgst_size = DGST_SIZE_4_5;
9149 parse_func = sha1s_parse_hash;
9150 sort_by_digest = sort_by_digest_4_5;
9151 opti_type = OPTI_TYPE_ZERO_BYTE
9152 | OPTI_TYPE_PRECOMPUTE_INIT
9153 | OPTI_TYPE_PRECOMPUTE_MERKLE
9154 | OPTI_TYPE_EARLY_SKIP;
9155 dgst_pos0 = 3;
9156 dgst_pos1 = 4;
9157 dgst_pos2 = 2;
9158 dgst_pos3 = 1;
9159 break;
9160
9161 case 5000: hash_type = HASH_TYPE_KECCAK;
9162 salt_type = SALT_TYPE_EMBEDDED;
9163 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9164 opts_type = OPTS_TYPE_PT_GENERATE_LE
9165 | OPTS_TYPE_PT_ADD01;
9166 kern_type = KERN_TYPE_KECCAK;
9167 dgst_size = DGST_SIZE_8_25;
9168 parse_func = keccak_parse_hash;
9169 sort_by_digest = sort_by_digest_8_25;
9170 opti_type = OPTI_TYPE_ZERO_BYTE
9171 | OPTI_TYPE_USES_BITS_64
9172 | OPTI_TYPE_RAW_HASH;
9173 dgst_pos0 = 2;
9174 dgst_pos1 = 3;
9175 dgst_pos2 = 4;
9176 dgst_pos3 = 5;
9177 break;
9178
9179 case 5100: hash_type = HASH_TYPE_MD5H;
9180 salt_type = SALT_TYPE_NONE;
9181 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9182 opts_type = OPTS_TYPE_PT_GENERATE_LE
9183 | OPTS_TYPE_PT_ADD80
9184 | OPTS_TYPE_PT_ADDBITS14;
9185 kern_type = KERN_TYPE_MD5H;
9186 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9187 parse_func = md5half_parse_hash;
9188 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9189 opti_type = OPTI_TYPE_ZERO_BYTE
9190 | OPTI_TYPE_RAW_HASH;
9191 dgst_pos0 = 0;
9192 dgst_pos1 = 1;
9193 dgst_pos2 = 2;
9194 dgst_pos3 = 3;
9195 break;
9196
9197 case 5200: hash_type = HASH_TYPE_SHA256;
9198 salt_type = SALT_TYPE_EMBEDDED;
9199 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9200 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9201 kern_type = KERN_TYPE_PSAFE3;
9202 dgst_size = DGST_SIZE_4_8;
9203 parse_func = psafe3_parse_hash;
9204 sort_by_digest = sort_by_digest_4_8;
9205 opti_type = OPTI_TYPE_ZERO_BYTE;
9206 dgst_pos0 = 0;
9207 dgst_pos1 = 1;
9208 dgst_pos2 = 2;
9209 dgst_pos3 = 3;
9210 break;
9211
9212 case 5300: hash_type = HASH_TYPE_MD5;
9213 salt_type = SALT_TYPE_EMBEDDED;
9214 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9215 opts_type = OPTS_TYPE_PT_GENERATE_LE
9216 | OPTS_TYPE_ST_ADD80;
9217 kern_type = KERN_TYPE_IKEPSK_MD5;
9218 dgst_size = DGST_SIZE_4_4;
9219 parse_func = ikepsk_md5_parse_hash;
9220 sort_by_digest = sort_by_digest_4_4;
9221 opti_type = OPTI_TYPE_ZERO_BYTE;
9222 dgst_pos0 = 0;
9223 dgst_pos1 = 3;
9224 dgst_pos2 = 2;
9225 dgst_pos3 = 1;
9226 break;
9227
9228 case 5400: hash_type = HASH_TYPE_SHA1;
9229 salt_type = SALT_TYPE_EMBEDDED;
9230 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9231 opts_type = OPTS_TYPE_PT_GENERATE_BE
9232 | OPTS_TYPE_ST_ADD80;
9233 kern_type = KERN_TYPE_IKEPSK_SHA1;
9234 dgst_size = DGST_SIZE_4_5;
9235 parse_func = ikepsk_sha1_parse_hash;
9236 sort_by_digest = sort_by_digest_4_5;
9237 opti_type = OPTI_TYPE_ZERO_BYTE;
9238 dgst_pos0 = 3;
9239 dgst_pos1 = 4;
9240 dgst_pos2 = 2;
9241 dgst_pos3 = 1;
9242 break;
9243
9244 case 5500: hash_type = HASH_TYPE_NETNTLM;
9245 salt_type = SALT_TYPE_EMBEDDED;
9246 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9247 opts_type = OPTS_TYPE_PT_GENERATE_LE
9248 | OPTS_TYPE_PT_ADD80
9249 | OPTS_TYPE_PT_ADDBITS14
9250 | OPTS_TYPE_PT_UNICODE
9251 | OPTS_TYPE_ST_HEX;
9252 kern_type = KERN_TYPE_NETNTLMv1;
9253 dgst_size = DGST_SIZE_4_4;
9254 parse_func = netntlmv1_parse_hash;
9255 sort_by_digest = sort_by_digest_4_4;
9256 opti_type = OPTI_TYPE_ZERO_BYTE
9257 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9258 dgst_pos0 = 0;
9259 dgst_pos1 = 1;
9260 dgst_pos2 = 2;
9261 dgst_pos3 = 3;
9262 break;
9263
9264 case 5600: hash_type = HASH_TYPE_MD5;
9265 salt_type = SALT_TYPE_EMBEDDED;
9266 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9267 opts_type = OPTS_TYPE_PT_GENERATE_LE
9268 | OPTS_TYPE_PT_ADD80
9269 | OPTS_TYPE_PT_ADDBITS14
9270 | OPTS_TYPE_PT_UNICODE;
9271 kern_type = KERN_TYPE_NETNTLMv2;
9272 dgst_size = DGST_SIZE_4_4;
9273 parse_func = netntlmv2_parse_hash;
9274 sort_by_digest = sort_by_digest_4_4;
9275 opti_type = OPTI_TYPE_ZERO_BYTE;
9276 dgst_pos0 = 0;
9277 dgst_pos1 = 3;
9278 dgst_pos2 = 2;
9279 dgst_pos3 = 1;
9280 break;
9281
9282 case 5700: hash_type = HASH_TYPE_SHA256;
9283 salt_type = SALT_TYPE_NONE;
9284 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9285 opts_type = OPTS_TYPE_PT_GENERATE_BE
9286 | OPTS_TYPE_PT_ADD80
9287 | OPTS_TYPE_PT_ADDBITS15;
9288 kern_type = KERN_TYPE_SHA256;
9289 dgst_size = DGST_SIZE_4_8;
9290 parse_func = cisco4_parse_hash;
9291 sort_by_digest = sort_by_digest_4_8;
9292 opti_type = OPTI_TYPE_ZERO_BYTE
9293 | OPTI_TYPE_PRECOMPUTE_INIT
9294 | OPTI_TYPE_PRECOMPUTE_MERKLE
9295 | OPTI_TYPE_EARLY_SKIP
9296 | OPTI_TYPE_NOT_ITERATED
9297 | OPTI_TYPE_NOT_SALTED
9298 | OPTI_TYPE_RAW_HASH;
9299 dgst_pos0 = 3;
9300 dgst_pos1 = 7;
9301 dgst_pos2 = 2;
9302 dgst_pos3 = 6;
9303 break;
9304
9305 case 5800: hash_type = HASH_TYPE_SHA1;
9306 salt_type = SALT_TYPE_INTERN;
9307 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9308 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9309 | OPTS_TYPE_ST_ADD80;
9310 kern_type = KERN_TYPE_ANDROIDPIN;
9311 dgst_size = DGST_SIZE_4_5;
9312 parse_func = androidpin_parse_hash;
9313 sort_by_digest = sort_by_digest_4_5;
9314 opti_type = OPTI_TYPE_ZERO_BYTE;
9315 dgst_pos0 = 0;
9316 dgst_pos1 = 1;
9317 dgst_pos2 = 2;
9318 dgst_pos3 = 3;
9319 break;
9320
9321 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9322 salt_type = SALT_TYPE_NONE;
9323 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9324 opts_type = OPTS_TYPE_PT_GENERATE_LE
9325 | OPTS_TYPE_PT_ADD80;
9326 kern_type = KERN_TYPE_RIPEMD160;
9327 dgst_size = DGST_SIZE_4_5;
9328 parse_func = ripemd160_parse_hash;
9329 sort_by_digest = sort_by_digest_4_5;
9330 opti_type = OPTI_TYPE_ZERO_BYTE;
9331 dgst_pos0 = 0;
9332 dgst_pos1 = 1;
9333 dgst_pos2 = 2;
9334 dgst_pos3 = 3;
9335 break;
9336
9337 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9338 salt_type = SALT_TYPE_NONE;
9339 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9340 opts_type = OPTS_TYPE_PT_GENERATE_BE
9341 | OPTS_TYPE_PT_ADD80;
9342 kern_type = KERN_TYPE_WHIRLPOOL;
9343 dgst_size = DGST_SIZE_4_16;
9344 parse_func = whirlpool_parse_hash;
9345 sort_by_digest = sort_by_digest_4_16;
9346 opti_type = OPTI_TYPE_ZERO_BYTE;
9347 dgst_pos0 = 0;
9348 dgst_pos1 = 1;
9349 dgst_pos2 = 2;
9350 dgst_pos3 = 3;
9351 break;
9352
9353 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9354 salt_type = SALT_TYPE_EMBEDDED;
9355 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9356 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9357 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9358 dgst_size = DGST_SIZE_4_5;
9359 parse_func = truecrypt_parse_hash_2k;
9360 sort_by_digest = sort_by_digest_4_5;
9361 opti_type = OPTI_TYPE_ZERO_BYTE;
9362 dgst_pos0 = 0;
9363 dgst_pos1 = 1;
9364 dgst_pos2 = 2;
9365 dgst_pos3 = 3;
9366 break;
9367
9368 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9369 salt_type = SALT_TYPE_EMBEDDED;
9370 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9371 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9372 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9373 dgst_size = DGST_SIZE_4_5;
9374 parse_func = truecrypt_parse_hash_2k;
9375 sort_by_digest = sort_by_digest_4_5;
9376 opti_type = OPTI_TYPE_ZERO_BYTE;
9377 dgst_pos0 = 0;
9378 dgst_pos1 = 1;
9379 dgst_pos2 = 2;
9380 dgst_pos3 = 3;
9381 break;
9382
9383 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9384 salt_type = SALT_TYPE_EMBEDDED;
9385 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9386 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9387 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9388 dgst_size = DGST_SIZE_4_5;
9389 parse_func = truecrypt_parse_hash_2k;
9390 sort_by_digest = sort_by_digest_4_5;
9391 opti_type = OPTI_TYPE_ZERO_BYTE;
9392 dgst_pos0 = 0;
9393 dgst_pos1 = 1;
9394 dgst_pos2 = 2;
9395 dgst_pos3 = 3;
9396 break;
9397
9398 case 6221: hash_type = HASH_TYPE_SHA512;
9399 salt_type = SALT_TYPE_EMBEDDED;
9400 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9401 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9402 kern_type = KERN_TYPE_TCSHA512_XTS512;
9403 dgst_size = DGST_SIZE_8_8;
9404 parse_func = truecrypt_parse_hash_1k;
9405 sort_by_digest = sort_by_digest_8_8;
9406 opti_type = OPTI_TYPE_ZERO_BYTE
9407 | OPTI_TYPE_USES_BITS_64;
9408 dgst_pos0 = 0;
9409 dgst_pos1 = 1;
9410 dgst_pos2 = 2;
9411 dgst_pos3 = 3;
9412 break;
9413
9414 case 6222: hash_type = HASH_TYPE_SHA512;
9415 salt_type = SALT_TYPE_EMBEDDED;
9416 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9417 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9418 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9419 dgst_size = DGST_SIZE_8_8;
9420 parse_func = truecrypt_parse_hash_1k;
9421 sort_by_digest = sort_by_digest_8_8;
9422 opti_type = OPTI_TYPE_ZERO_BYTE
9423 | OPTI_TYPE_USES_BITS_64;
9424 dgst_pos0 = 0;
9425 dgst_pos1 = 1;
9426 dgst_pos2 = 2;
9427 dgst_pos3 = 3;
9428 break;
9429
9430 case 6223: hash_type = HASH_TYPE_SHA512;
9431 salt_type = SALT_TYPE_EMBEDDED;
9432 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9433 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9434 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9435 dgst_size = DGST_SIZE_8_8;
9436 parse_func = truecrypt_parse_hash_1k;
9437 sort_by_digest = sort_by_digest_8_8;
9438 opti_type = OPTI_TYPE_ZERO_BYTE
9439 | OPTI_TYPE_USES_BITS_64;
9440 dgst_pos0 = 0;
9441 dgst_pos1 = 1;
9442 dgst_pos2 = 2;
9443 dgst_pos3 = 3;
9444 break;
9445
9446 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9447 salt_type = SALT_TYPE_EMBEDDED;
9448 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9449 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9450 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9451 dgst_size = DGST_SIZE_4_8;
9452 parse_func = truecrypt_parse_hash_1k;
9453 sort_by_digest = sort_by_digest_4_8;
9454 opti_type = OPTI_TYPE_ZERO_BYTE;
9455 dgst_pos0 = 0;
9456 dgst_pos1 = 1;
9457 dgst_pos2 = 2;
9458 dgst_pos3 = 3;
9459 break;
9460
9461 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9462 salt_type = SALT_TYPE_EMBEDDED;
9463 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9464 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9465 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9466 dgst_size = DGST_SIZE_4_8;
9467 parse_func = truecrypt_parse_hash_1k;
9468 sort_by_digest = sort_by_digest_4_8;
9469 opti_type = OPTI_TYPE_ZERO_BYTE;
9470 dgst_pos0 = 0;
9471 dgst_pos1 = 1;
9472 dgst_pos2 = 2;
9473 dgst_pos3 = 3;
9474 break;
9475
9476 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9477 salt_type = SALT_TYPE_EMBEDDED;
9478 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9479 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9480 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9481 dgst_size = DGST_SIZE_4_8;
9482 parse_func = truecrypt_parse_hash_1k;
9483 sort_by_digest = sort_by_digest_4_8;
9484 opti_type = OPTI_TYPE_ZERO_BYTE;
9485 dgst_pos0 = 0;
9486 dgst_pos1 = 1;
9487 dgst_pos2 = 2;
9488 dgst_pos3 = 3;
9489 break;
9490
9491 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9492 salt_type = SALT_TYPE_EMBEDDED;
9493 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9494 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9495 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9496 dgst_size = DGST_SIZE_4_5;
9497 parse_func = truecrypt_parse_hash_1k;
9498 sort_by_digest = sort_by_digest_4_5;
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 6242: hash_type = HASH_TYPE_RIPEMD160;
9507 salt_type = SALT_TYPE_EMBEDDED;
9508 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9509 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9510 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9511 dgst_size = DGST_SIZE_4_5;
9512 parse_func = truecrypt_parse_hash_1k;
9513 sort_by_digest = sort_by_digest_4_5;
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 6243: hash_type = HASH_TYPE_RIPEMD160;
9522 salt_type = SALT_TYPE_EMBEDDED;
9523 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9524 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9525 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9526 dgst_size = DGST_SIZE_4_5;
9527 parse_func = truecrypt_parse_hash_1k;
9528 sort_by_digest = sort_by_digest_4_5;
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 6300: hash_type = HASH_TYPE_MD5;
9537 salt_type = SALT_TYPE_EMBEDDED;
9538 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9539 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9540 kern_type = KERN_TYPE_MD5AIX;
9541 dgst_size = DGST_SIZE_4_4;
9542 parse_func = md5aix_parse_hash;
9543 sort_by_digest = sort_by_digest_4_4;
9544 opti_type = OPTI_TYPE_ZERO_BYTE;
9545 dgst_pos0 = 0;
9546 dgst_pos1 = 1;
9547 dgst_pos2 = 2;
9548 dgst_pos3 = 3;
9549 break;
9550
9551 case 6400: hash_type = HASH_TYPE_SHA256;
9552 salt_type = SALT_TYPE_EMBEDDED;
9553 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9554 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9555 kern_type = KERN_TYPE_SHA256AIX;
9556 dgst_size = DGST_SIZE_4_8;
9557 parse_func = sha256aix_parse_hash;
9558 sort_by_digest = sort_by_digest_4_8;
9559 opti_type = OPTI_TYPE_ZERO_BYTE;
9560 dgst_pos0 = 0;
9561 dgst_pos1 = 1;
9562 dgst_pos2 = 2;
9563 dgst_pos3 = 3;
9564 break;
9565
9566 case 6500: hash_type = HASH_TYPE_SHA512;
9567 salt_type = SALT_TYPE_EMBEDDED;
9568 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9569 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9570 kern_type = KERN_TYPE_SHA512AIX;
9571 dgst_size = DGST_SIZE_8_8;
9572 parse_func = sha512aix_parse_hash;
9573 sort_by_digest = sort_by_digest_8_8;
9574 opti_type = OPTI_TYPE_ZERO_BYTE
9575 | OPTI_TYPE_USES_BITS_64;
9576 dgst_pos0 = 0;
9577 dgst_pos1 = 1;
9578 dgst_pos2 = 2;
9579 dgst_pos3 = 3;
9580 break;
9581
9582 case 6600: hash_type = HASH_TYPE_AES;
9583 salt_type = SALT_TYPE_EMBEDDED;
9584 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9585 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9586 kern_type = KERN_TYPE_AGILEKEY;
9587 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9588 parse_func = agilekey_parse_hash;
9589 sort_by_digest = sort_by_digest_4_5;
9590 opti_type = OPTI_TYPE_ZERO_BYTE;
9591 dgst_pos0 = 0;
9592 dgst_pos1 = 1;
9593 dgst_pos2 = 2;
9594 dgst_pos3 = 3;
9595 break;
9596
9597 case 6700: hash_type = HASH_TYPE_SHA1;
9598 salt_type = SALT_TYPE_EMBEDDED;
9599 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9600 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9601 kern_type = KERN_TYPE_SHA1AIX;
9602 dgst_size = DGST_SIZE_4_5;
9603 parse_func = sha1aix_parse_hash;
9604 sort_by_digest = sort_by_digest_4_5;
9605 opti_type = OPTI_TYPE_ZERO_BYTE;
9606 dgst_pos0 = 0;
9607 dgst_pos1 = 1;
9608 dgst_pos2 = 2;
9609 dgst_pos3 = 3;
9610 break;
9611
9612 case 6800: hash_type = HASH_TYPE_AES;
9613 salt_type = SALT_TYPE_EMBEDDED;
9614 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9615 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9616 kern_type = KERN_TYPE_LASTPASS;
9617 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9618 parse_func = lastpass_parse_hash;
9619 sort_by_digest = sort_by_digest_4_8;
9620 opti_type = OPTI_TYPE_ZERO_BYTE;
9621 dgst_pos0 = 0;
9622 dgst_pos1 = 1;
9623 dgst_pos2 = 2;
9624 dgst_pos3 = 3;
9625 break;
9626
9627 case 6900: hash_type = HASH_TYPE_GOST;
9628 salt_type = SALT_TYPE_NONE;
9629 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9630 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9631 kern_type = KERN_TYPE_GOST;
9632 dgst_size = DGST_SIZE_4_8;
9633 parse_func = gost_parse_hash;
9634 sort_by_digest = sort_by_digest_4_8;
9635 opti_type = OPTI_TYPE_ZERO_BYTE;
9636 dgst_pos0 = 0;
9637 dgst_pos1 = 1;
9638 dgst_pos2 = 2;
9639 dgst_pos3 = 3;
9640 break;
9641
9642 case 7100: hash_type = HASH_TYPE_SHA512;
9643 salt_type = SALT_TYPE_EMBEDDED;
9644 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9645 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9646 kern_type = KERN_TYPE_PBKDF2_SHA512;
9647 dgst_size = DGST_SIZE_8_16;
9648 parse_func = sha512osx_parse_hash;
9649 sort_by_digest = sort_by_digest_8_16;
9650 opti_type = OPTI_TYPE_ZERO_BYTE
9651 | OPTI_TYPE_USES_BITS_64
9652 | OPTI_TYPE_SLOW_HASH_SIMD;
9653 dgst_pos0 = 0;
9654 dgst_pos1 = 1;
9655 dgst_pos2 = 2;
9656 dgst_pos3 = 3;
9657 break;
9658
9659 case 7200: hash_type = HASH_TYPE_SHA512;
9660 salt_type = SALT_TYPE_EMBEDDED;
9661 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9662 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9663 kern_type = KERN_TYPE_PBKDF2_SHA512;
9664 dgst_size = DGST_SIZE_8_16;
9665 parse_func = sha512grub_parse_hash;
9666 sort_by_digest = sort_by_digest_8_16;
9667 opti_type = OPTI_TYPE_ZERO_BYTE
9668 | OPTI_TYPE_USES_BITS_64
9669 | OPTI_TYPE_SLOW_HASH_SIMD;
9670 dgst_pos0 = 0;
9671 dgst_pos1 = 1;
9672 dgst_pos2 = 2;
9673 dgst_pos3 = 3;
9674 break;
9675
9676 case 7300: hash_type = HASH_TYPE_SHA1;
9677 salt_type = SALT_TYPE_EMBEDDED;
9678 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9679 opts_type = OPTS_TYPE_PT_GENERATE_BE
9680 | OPTS_TYPE_ST_ADD80
9681 | OPTS_TYPE_ST_ADDBITS15;
9682 kern_type = KERN_TYPE_RAKP;
9683 dgst_size = DGST_SIZE_4_5;
9684 parse_func = rakp_parse_hash;
9685 sort_by_digest = sort_by_digest_4_5;
9686 opti_type = OPTI_TYPE_ZERO_BYTE
9687 | OPTI_TYPE_NOT_ITERATED;
9688 dgst_pos0 = 3;
9689 dgst_pos1 = 4;
9690 dgst_pos2 = 2;
9691 dgst_pos3 = 1;
9692 break;
9693
9694 case 7400: hash_type = HASH_TYPE_SHA256;
9695 salt_type = SALT_TYPE_EMBEDDED;
9696 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9697 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9698 kern_type = KERN_TYPE_SHA256CRYPT;
9699 dgst_size = DGST_SIZE_4_8;
9700 parse_func = sha256crypt_parse_hash;
9701 sort_by_digest = sort_by_digest_4_8;
9702 opti_type = OPTI_TYPE_ZERO_BYTE;
9703 dgst_pos0 = 0;
9704 dgst_pos1 = 1;
9705 dgst_pos2 = 2;
9706 dgst_pos3 = 3;
9707 break;
9708
9709 case 7500: hash_type = HASH_TYPE_KRB5PA;
9710 salt_type = SALT_TYPE_EMBEDDED;
9711 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9712 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9713 kern_type = KERN_TYPE_KRB5PA;
9714 dgst_size = DGST_SIZE_4_4;
9715 parse_func = krb5pa_parse_hash;
9716 sort_by_digest = sort_by_digest_4_4;
9717 opti_type = OPTI_TYPE_ZERO_BYTE
9718 | OPTI_TYPE_NOT_ITERATED;
9719 dgst_pos0 = 0;
9720 dgst_pos1 = 1;
9721 dgst_pos2 = 2;
9722 dgst_pos3 = 3;
9723 break;
9724
9725 case 7600: hash_type = HASH_TYPE_SHA1;
9726 salt_type = SALT_TYPE_INTERN;
9727 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9728 opts_type = OPTS_TYPE_PT_GENERATE_BE
9729 | OPTS_TYPE_PT_ADD80
9730 | OPTS_TYPE_PT_ADDBITS15;
9731 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9732 dgst_size = DGST_SIZE_4_5;
9733 parse_func = redmine_parse_hash;
9734 sort_by_digest = sort_by_digest_4_5;
9735 opti_type = OPTI_TYPE_ZERO_BYTE
9736 | OPTI_TYPE_PRECOMPUTE_INIT
9737 | OPTI_TYPE_EARLY_SKIP
9738 | OPTI_TYPE_NOT_ITERATED
9739 | OPTI_TYPE_PREPENDED_SALT;
9740 dgst_pos0 = 3;
9741 dgst_pos1 = 4;
9742 dgst_pos2 = 2;
9743 dgst_pos3 = 1;
9744 break;
9745
9746 case 7700: hash_type = HASH_TYPE_SAPB;
9747 salt_type = SALT_TYPE_EMBEDDED;
9748 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9749 opts_type = OPTS_TYPE_PT_GENERATE_LE
9750 | OPTS_TYPE_PT_UPPER
9751 | OPTS_TYPE_ST_UPPER;
9752 kern_type = KERN_TYPE_SAPB;
9753 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9754 parse_func = sapb_parse_hash;
9755 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9756 opti_type = OPTI_TYPE_ZERO_BYTE
9757 | OPTI_TYPE_PRECOMPUTE_INIT
9758 | OPTI_TYPE_NOT_ITERATED;
9759 dgst_pos0 = 0;
9760 dgst_pos1 = 1;
9761 dgst_pos2 = 2;
9762 dgst_pos3 = 3;
9763 break;
9764
9765 case 7800: hash_type = HASH_TYPE_SAPG;
9766 salt_type = SALT_TYPE_EMBEDDED;
9767 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9768 opts_type = OPTS_TYPE_PT_GENERATE_BE
9769 | OPTS_TYPE_ST_ADD80
9770 | OPTS_TYPE_ST_UPPER;
9771 kern_type = KERN_TYPE_SAPG;
9772 dgst_size = DGST_SIZE_4_5;
9773 parse_func = sapg_parse_hash;
9774 sort_by_digest = sort_by_digest_4_5;
9775 opti_type = OPTI_TYPE_ZERO_BYTE
9776 | OPTI_TYPE_PRECOMPUTE_INIT
9777 | OPTI_TYPE_NOT_ITERATED;
9778 dgst_pos0 = 3;
9779 dgst_pos1 = 4;
9780 dgst_pos2 = 2;
9781 dgst_pos3 = 1;
9782 break;
9783
9784 case 7900: hash_type = HASH_TYPE_SHA512;
9785 salt_type = SALT_TYPE_EMBEDDED;
9786 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9787 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9788 kern_type = KERN_TYPE_DRUPAL7;
9789 dgst_size = DGST_SIZE_8_8;
9790 parse_func = drupal7_parse_hash;
9791 sort_by_digest = sort_by_digest_8_8;
9792 opti_type = OPTI_TYPE_ZERO_BYTE
9793 | OPTI_TYPE_USES_BITS_64;
9794 dgst_pos0 = 0;
9795 dgst_pos1 = 1;
9796 dgst_pos2 = 2;
9797 dgst_pos3 = 3;
9798 break;
9799
9800 case 8000: hash_type = HASH_TYPE_SHA256;
9801 salt_type = SALT_TYPE_EMBEDDED;
9802 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9803 opts_type = OPTS_TYPE_PT_GENERATE_BE
9804 | OPTS_TYPE_PT_UNICODE
9805 | OPTS_TYPE_ST_ADD80
9806 | OPTS_TYPE_ST_HEX;
9807 kern_type = KERN_TYPE_SYBASEASE;
9808 dgst_size = DGST_SIZE_4_8;
9809 parse_func = sybasease_parse_hash;
9810 sort_by_digest = sort_by_digest_4_8;
9811 opti_type = OPTI_TYPE_ZERO_BYTE
9812 | OPTI_TYPE_PRECOMPUTE_INIT
9813 | OPTI_TYPE_EARLY_SKIP
9814 | OPTI_TYPE_NOT_ITERATED
9815 | OPTI_TYPE_RAW_HASH;
9816 dgst_pos0 = 3;
9817 dgst_pos1 = 7;
9818 dgst_pos2 = 2;
9819 dgst_pos3 = 6;
9820 break;
9821
9822 case 8100: hash_type = HASH_TYPE_SHA1;
9823 salt_type = SALT_TYPE_EMBEDDED;
9824 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9825 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9826 kern_type = KERN_TYPE_NETSCALER;
9827 dgst_size = DGST_SIZE_4_5;
9828 parse_func = netscaler_parse_hash;
9829 sort_by_digest = sort_by_digest_4_5;
9830 opti_type = OPTI_TYPE_ZERO_BYTE
9831 | OPTI_TYPE_PRECOMPUTE_INIT
9832 | OPTI_TYPE_PRECOMPUTE_MERKLE
9833 | OPTI_TYPE_EARLY_SKIP
9834 | OPTI_TYPE_NOT_ITERATED
9835 | OPTI_TYPE_PREPENDED_SALT
9836 | OPTI_TYPE_RAW_HASH;
9837 dgst_pos0 = 3;
9838 dgst_pos1 = 4;
9839 dgst_pos2 = 2;
9840 dgst_pos3 = 1;
9841 break;
9842
9843 case 8200: hash_type = HASH_TYPE_SHA256;
9844 salt_type = SALT_TYPE_EMBEDDED;
9845 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9846 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9847 kern_type = KERN_TYPE_CLOUDKEY;
9848 dgst_size = DGST_SIZE_4_8;
9849 parse_func = cloudkey_parse_hash;
9850 sort_by_digest = sort_by_digest_4_8;
9851 opti_type = OPTI_TYPE_ZERO_BYTE;
9852 dgst_pos0 = 0;
9853 dgst_pos1 = 1;
9854 dgst_pos2 = 2;
9855 dgst_pos3 = 3;
9856 break;
9857
9858 case 8300: hash_type = HASH_TYPE_SHA1;
9859 salt_type = SALT_TYPE_EMBEDDED;
9860 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9861 opts_type = OPTS_TYPE_PT_GENERATE_BE
9862 | OPTS_TYPE_ST_HEX
9863 | OPTS_TYPE_ST_ADD80;
9864 kern_type = KERN_TYPE_NSEC3;
9865 dgst_size = DGST_SIZE_4_5;
9866 parse_func = nsec3_parse_hash;
9867 sort_by_digest = sort_by_digest_4_5;
9868 opti_type = OPTI_TYPE_ZERO_BYTE;
9869 dgst_pos0 = 3;
9870 dgst_pos1 = 4;
9871 dgst_pos2 = 2;
9872 dgst_pos3 = 1;
9873 break;
9874
9875 case 8400: hash_type = HASH_TYPE_SHA1;
9876 salt_type = SALT_TYPE_INTERN;
9877 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9878 opts_type = OPTS_TYPE_PT_GENERATE_BE
9879 | OPTS_TYPE_PT_ADD80
9880 | OPTS_TYPE_PT_ADDBITS15;
9881 kern_type = KERN_TYPE_WBB3;
9882 dgst_size = DGST_SIZE_4_5;
9883 parse_func = wbb3_parse_hash;
9884 sort_by_digest = sort_by_digest_4_5;
9885 opti_type = OPTI_TYPE_ZERO_BYTE
9886 | OPTI_TYPE_PRECOMPUTE_INIT
9887 | OPTI_TYPE_NOT_ITERATED;
9888 dgst_pos0 = 3;
9889 dgst_pos1 = 4;
9890 dgst_pos2 = 2;
9891 dgst_pos3 = 1;
9892 break;
9893
9894 case 8500: hash_type = HASH_TYPE_DESRACF;
9895 salt_type = SALT_TYPE_EMBEDDED;
9896 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9897 opts_type = OPTS_TYPE_PT_GENERATE_LE
9898 | OPTS_TYPE_ST_UPPER;
9899 kern_type = KERN_TYPE_RACF;
9900 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9901 parse_func = racf_parse_hash;
9902 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9903 opti_type = OPTI_TYPE_ZERO_BYTE
9904 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9905 dgst_pos0 = 0;
9906 dgst_pos1 = 1;
9907 dgst_pos2 = 2;
9908 dgst_pos3 = 3;
9909 break;
9910
9911 case 8600: hash_type = HASH_TYPE_LOTUS5;
9912 salt_type = SALT_TYPE_NONE;
9913 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9914 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9915 kern_type = KERN_TYPE_LOTUS5;
9916 dgst_size = DGST_SIZE_4_4;
9917 parse_func = lotus5_parse_hash;
9918 sort_by_digest = sort_by_digest_4_4;
9919 opti_type = OPTI_TYPE_EARLY_SKIP
9920 | OPTI_TYPE_NOT_ITERATED
9921 | OPTI_TYPE_NOT_SALTED
9922 | OPTI_TYPE_RAW_HASH;
9923 dgst_pos0 = 0;
9924 dgst_pos1 = 1;
9925 dgst_pos2 = 2;
9926 dgst_pos3 = 3;
9927 break;
9928
9929 case 8700: hash_type = HASH_TYPE_LOTUS6;
9930 salt_type = SALT_TYPE_EMBEDDED;
9931 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9932 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9933 kern_type = KERN_TYPE_LOTUS6;
9934 dgst_size = DGST_SIZE_4_4;
9935 parse_func = lotus6_parse_hash;
9936 sort_by_digest = sort_by_digest_4_4;
9937 opti_type = OPTI_TYPE_EARLY_SKIP
9938 | OPTI_TYPE_NOT_ITERATED
9939 | OPTI_TYPE_RAW_HASH;
9940 dgst_pos0 = 0;
9941 dgst_pos1 = 1;
9942 dgst_pos2 = 2;
9943 dgst_pos3 = 3;
9944 break;
9945
9946 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9947 salt_type = SALT_TYPE_EMBEDDED;
9948 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9949 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9950 kern_type = KERN_TYPE_ANDROIDFDE;
9951 dgst_size = DGST_SIZE_4_4;
9952 parse_func = androidfde_parse_hash;
9953 sort_by_digest = sort_by_digest_4_4;
9954 opti_type = OPTI_TYPE_ZERO_BYTE;
9955 dgst_pos0 = 0;
9956 dgst_pos1 = 1;
9957 dgst_pos2 = 2;
9958 dgst_pos3 = 3;
9959 break;
9960
9961 case 8900: hash_type = HASH_TYPE_SCRYPT;
9962 salt_type = SALT_TYPE_EMBEDDED;
9963 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9964 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9965 kern_type = KERN_TYPE_SCRYPT;
9966 dgst_size = DGST_SIZE_4_8;
9967 parse_func = scrypt_parse_hash;
9968 sort_by_digest = sort_by_digest_4_8;
9969 opti_type = OPTI_TYPE_ZERO_BYTE;
9970 dgst_pos0 = 0;
9971 dgst_pos1 = 1;
9972 dgst_pos2 = 2;
9973 dgst_pos3 = 3;
9974 break;
9975
9976 case 9000: hash_type = HASH_TYPE_SHA1;
9977 salt_type = SALT_TYPE_EMBEDDED;
9978 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9979 opts_type = OPTS_TYPE_PT_GENERATE_LE
9980 | OPTS_TYPE_ST_GENERATE_LE;
9981 kern_type = KERN_TYPE_PSAFE2;
9982 dgst_size = DGST_SIZE_4_5;
9983 parse_func = psafe2_parse_hash;
9984 sort_by_digest = sort_by_digest_4_5;
9985 opti_type = OPTI_TYPE_ZERO_BYTE;
9986 dgst_pos0 = 0;
9987 dgst_pos1 = 1;
9988 dgst_pos2 = 2;
9989 dgst_pos3 = 3;
9990 break;
9991
9992 case 9100: hash_type = HASH_TYPE_LOTUS8;
9993 salt_type = SALT_TYPE_EMBEDDED;
9994 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9995 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9996 kern_type = KERN_TYPE_LOTUS8;
9997 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9998 parse_func = lotus8_parse_hash;
9999 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10000 opti_type = OPTI_TYPE_ZERO_BYTE;
10001 dgst_pos0 = 0;
10002 dgst_pos1 = 1;
10003 dgst_pos2 = 2;
10004 dgst_pos3 = 3;
10005 break;
10006
10007 case 9200: hash_type = HASH_TYPE_SHA256;
10008 salt_type = SALT_TYPE_EMBEDDED;
10009 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10010 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10011 kern_type = KERN_TYPE_PBKDF2_SHA256;
10012 dgst_size = DGST_SIZE_4_32;
10013 parse_func = cisco8_parse_hash;
10014 sort_by_digest = sort_by_digest_4_32;
10015 opti_type = OPTI_TYPE_ZERO_BYTE
10016 | OPTI_TYPE_SLOW_HASH_SIMD;
10017 dgst_pos0 = 0;
10018 dgst_pos1 = 1;
10019 dgst_pos2 = 2;
10020 dgst_pos3 = 3;
10021 break;
10022
10023 case 9300: hash_type = HASH_TYPE_SCRYPT;
10024 salt_type = SALT_TYPE_EMBEDDED;
10025 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10026 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10027 kern_type = KERN_TYPE_SCRYPT;
10028 dgst_size = DGST_SIZE_4_8;
10029 parse_func = cisco9_parse_hash;
10030 sort_by_digest = sort_by_digest_4_8;
10031 opti_type = OPTI_TYPE_ZERO_BYTE;
10032 dgst_pos0 = 0;
10033 dgst_pos1 = 1;
10034 dgst_pos2 = 2;
10035 dgst_pos3 = 3;
10036 break;
10037
10038 case 9400: hash_type = HASH_TYPE_OFFICE2007;
10039 salt_type = SALT_TYPE_EMBEDDED;
10040 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10041 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10042 kern_type = KERN_TYPE_OFFICE2007;
10043 dgst_size = DGST_SIZE_4_4;
10044 parse_func = office2007_parse_hash;
10045 sort_by_digest = sort_by_digest_4_4;
10046 opti_type = OPTI_TYPE_ZERO_BYTE;
10047 dgst_pos0 = 0;
10048 dgst_pos1 = 1;
10049 dgst_pos2 = 2;
10050 dgst_pos3 = 3;
10051 break;
10052
10053 case 9500: hash_type = HASH_TYPE_OFFICE2010;
10054 salt_type = SALT_TYPE_EMBEDDED;
10055 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10056 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10057 kern_type = KERN_TYPE_OFFICE2010;
10058 dgst_size = DGST_SIZE_4_4;
10059 parse_func = office2010_parse_hash;
10060 sort_by_digest = sort_by_digest_4_4;
10061 opti_type = OPTI_TYPE_ZERO_BYTE;
10062 dgst_pos0 = 0;
10063 dgst_pos1 = 1;
10064 dgst_pos2 = 2;
10065 dgst_pos3 = 3;
10066 break;
10067
10068 case 9600: hash_type = HASH_TYPE_OFFICE2013;
10069 salt_type = SALT_TYPE_EMBEDDED;
10070 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10071 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10072 kern_type = KERN_TYPE_OFFICE2013;
10073 dgst_size = DGST_SIZE_4_4;
10074 parse_func = office2013_parse_hash;
10075 sort_by_digest = sort_by_digest_4_4;
10076 opti_type = OPTI_TYPE_ZERO_BYTE;
10077 dgst_pos0 = 0;
10078 dgst_pos1 = 1;
10079 dgst_pos2 = 2;
10080 dgst_pos3 = 3;
10081 break;
10082
10083 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
10084 salt_type = SALT_TYPE_EMBEDDED;
10085 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10086 opts_type = OPTS_TYPE_PT_GENERATE_LE
10087 | OPTS_TYPE_PT_ADD80
10088 | OPTS_TYPE_PT_UNICODE;
10089 kern_type = KERN_TYPE_OLDOFFICE01;
10090 dgst_size = DGST_SIZE_4_4;
10091 parse_func = oldoffice01_parse_hash;
10092 sort_by_digest = sort_by_digest_4_4;
10093 opti_type = OPTI_TYPE_ZERO_BYTE
10094 | OPTI_TYPE_PRECOMPUTE_INIT
10095 | OPTI_TYPE_NOT_ITERATED;
10096 dgst_pos0 = 0;
10097 dgst_pos1 = 1;
10098 dgst_pos2 = 2;
10099 dgst_pos3 = 3;
10100 break;
10101
10102 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
10103 salt_type = SALT_TYPE_EMBEDDED;
10104 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10105 opts_type = OPTS_TYPE_PT_GENERATE_LE
10106 | OPTS_TYPE_PT_ADD80;
10107 kern_type = KERN_TYPE_OLDOFFICE01CM1;
10108 dgst_size = DGST_SIZE_4_4;
10109 parse_func = oldoffice01cm1_parse_hash;
10110 sort_by_digest = sort_by_digest_4_4;
10111 opti_type = OPTI_TYPE_ZERO_BYTE
10112 | OPTI_TYPE_PRECOMPUTE_INIT
10113 | OPTI_TYPE_NOT_ITERATED;
10114 dgst_pos0 = 0;
10115 dgst_pos1 = 1;
10116 dgst_pos2 = 2;
10117 dgst_pos3 = 3;
10118 break;
10119
10120 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
10121 salt_type = SALT_TYPE_EMBEDDED;
10122 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10123 opts_type = OPTS_TYPE_PT_GENERATE_LE
10124 | OPTS_TYPE_PT_ADD80
10125 | OPTS_TYPE_PT_UNICODE
10126 | OPTS_TYPE_PT_NEVERCRACK;
10127 kern_type = KERN_TYPE_OLDOFFICE01CM2;
10128 dgst_size = DGST_SIZE_4_4;
10129 parse_func = oldoffice01cm2_parse_hash;
10130 sort_by_digest = sort_by_digest_4_4;
10131 opti_type = OPTI_TYPE_ZERO_BYTE
10132 | OPTI_TYPE_PRECOMPUTE_INIT
10133 | OPTI_TYPE_NOT_ITERATED;
10134 dgst_pos0 = 0;
10135 dgst_pos1 = 1;
10136 dgst_pos2 = 2;
10137 dgst_pos3 = 3;
10138 break;
10139
10140 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
10141 salt_type = SALT_TYPE_EMBEDDED;
10142 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10143 opts_type = OPTS_TYPE_PT_GENERATE_BE
10144 | OPTS_TYPE_PT_ADD80
10145 | OPTS_TYPE_PT_UNICODE;
10146 kern_type = KERN_TYPE_OLDOFFICE34;
10147 dgst_size = DGST_SIZE_4_4;
10148 parse_func = oldoffice34_parse_hash;
10149 sort_by_digest = sort_by_digest_4_4;
10150 opti_type = OPTI_TYPE_ZERO_BYTE
10151 | OPTI_TYPE_PRECOMPUTE_INIT
10152 | OPTI_TYPE_NOT_ITERATED;
10153 dgst_pos0 = 0;
10154 dgst_pos1 = 1;
10155 dgst_pos2 = 2;
10156 dgst_pos3 = 3;
10157 break;
10158
10159 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10160 salt_type = SALT_TYPE_EMBEDDED;
10161 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10162 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10163 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10164 dgst_size = DGST_SIZE_4_4;
10165 parse_func = oldoffice34cm1_parse_hash;
10166 sort_by_digest = sort_by_digest_4_4;
10167 opti_type = OPTI_TYPE_ZERO_BYTE
10168 | OPTI_TYPE_PRECOMPUTE_INIT
10169 | OPTI_TYPE_NOT_ITERATED;
10170 dgst_pos0 = 0;
10171 dgst_pos1 = 1;
10172 dgst_pos2 = 2;
10173 dgst_pos3 = 3;
10174 break;
10175
10176 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10177 salt_type = SALT_TYPE_EMBEDDED;
10178 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10179 opts_type = OPTS_TYPE_PT_GENERATE_BE
10180 | OPTS_TYPE_PT_ADD80
10181 | OPTS_TYPE_PT_UNICODE
10182 | OPTS_TYPE_PT_NEVERCRACK;
10183 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10184 dgst_size = DGST_SIZE_4_4;
10185 parse_func = oldoffice34cm2_parse_hash;
10186 sort_by_digest = sort_by_digest_4_4;
10187 opti_type = OPTI_TYPE_ZERO_BYTE
10188 | OPTI_TYPE_PRECOMPUTE_INIT
10189 | OPTI_TYPE_NOT_ITERATED;
10190 dgst_pos0 = 0;
10191 dgst_pos1 = 1;
10192 dgst_pos2 = 2;
10193 dgst_pos3 = 3;
10194 break;
10195
10196 case 9900: hash_type = HASH_TYPE_MD5;
10197 salt_type = SALT_TYPE_NONE;
10198 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10199 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10200 kern_type = KERN_TYPE_RADMIN2;
10201 dgst_size = DGST_SIZE_4_4;
10202 parse_func = radmin2_parse_hash;
10203 sort_by_digest = sort_by_digest_4_4;
10204 opti_type = OPTI_TYPE_ZERO_BYTE
10205 | OPTI_TYPE_PRECOMPUTE_INIT
10206 | OPTI_TYPE_EARLY_SKIP
10207 | OPTI_TYPE_NOT_ITERATED
10208 | OPTI_TYPE_NOT_SALTED;
10209 dgst_pos0 = 0;
10210 dgst_pos1 = 3;
10211 dgst_pos2 = 2;
10212 dgst_pos3 = 1;
10213 break;
10214
10215 case 10000: hash_type = HASH_TYPE_SHA256;
10216 salt_type = SALT_TYPE_EMBEDDED;
10217 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10218 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10219 kern_type = KERN_TYPE_PBKDF2_SHA256;
10220 dgst_size = DGST_SIZE_4_32;
10221 parse_func = djangopbkdf2_parse_hash;
10222 sort_by_digest = sort_by_digest_4_32;
10223 opti_type = OPTI_TYPE_ZERO_BYTE
10224 | OPTI_TYPE_SLOW_HASH_SIMD;
10225 dgst_pos0 = 0;
10226 dgst_pos1 = 1;
10227 dgst_pos2 = 2;
10228 dgst_pos3 = 3;
10229 break;
10230
10231 case 10100: hash_type = HASH_TYPE_SIPHASH;
10232 salt_type = SALT_TYPE_EMBEDDED;
10233 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10234 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10235 kern_type = KERN_TYPE_SIPHASH;
10236 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10237 parse_func = siphash_parse_hash;
10238 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10239 opti_type = OPTI_TYPE_ZERO_BYTE
10240 | OPTI_TYPE_NOT_ITERATED
10241 | OPTI_TYPE_RAW_HASH;
10242 dgst_pos0 = 0;
10243 dgst_pos1 = 1;
10244 dgst_pos2 = 2;
10245 dgst_pos3 = 3;
10246 break;
10247
10248 case 10200: hash_type = HASH_TYPE_MD5;
10249 salt_type = SALT_TYPE_EMBEDDED;
10250 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10251 opts_type = OPTS_TYPE_PT_GENERATE_LE
10252 | OPTS_TYPE_ST_ADD80
10253 | OPTS_TYPE_ST_ADDBITS14;
10254 kern_type = KERN_TYPE_HMACMD5_PW;
10255 dgst_size = DGST_SIZE_4_4;
10256 parse_func = crammd5_parse_hash;
10257 sort_by_digest = sort_by_digest_4_4;
10258 opti_type = OPTI_TYPE_ZERO_BYTE
10259 | OPTI_TYPE_NOT_ITERATED;
10260 dgst_pos0 = 0;
10261 dgst_pos1 = 3;
10262 dgst_pos2 = 2;
10263 dgst_pos3 = 1;
10264 break;
10265
10266 case 10300: hash_type = HASH_TYPE_SHA1;
10267 salt_type = SALT_TYPE_EMBEDDED;
10268 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10269 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10270 kern_type = KERN_TYPE_SAPH_SHA1;
10271 dgst_size = DGST_SIZE_4_5;
10272 parse_func = saph_sha1_parse_hash;
10273 sort_by_digest = sort_by_digest_4_5;
10274 opti_type = OPTI_TYPE_ZERO_BYTE;
10275 dgst_pos0 = 0;
10276 dgst_pos1 = 1;
10277 dgst_pos2 = 2;
10278 dgst_pos3 = 3;
10279 break;
10280
10281 case 10400: hash_type = HASH_TYPE_PDFU16;
10282 salt_type = SALT_TYPE_EMBEDDED;
10283 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10284 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10285 kern_type = KERN_TYPE_PDF11;
10286 dgst_size = DGST_SIZE_4_4;
10287 parse_func = pdf11_parse_hash;
10288 sort_by_digest = sort_by_digest_4_4;
10289 opti_type = OPTI_TYPE_ZERO_BYTE
10290 | OPTI_TYPE_NOT_ITERATED;
10291 dgst_pos0 = 0;
10292 dgst_pos1 = 1;
10293 dgst_pos2 = 2;
10294 dgst_pos3 = 3;
10295 break;
10296
10297 case 10410: hash_type = HASH_TYPE_PDFU16;
10298 salt_type = SALT_TYPE_EMBEDDED;
10299 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10300 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10301 kern_type = KERN_TYPE_PDF11CM1;
10302 dgst_size = DGST_SIZE_4_4;
10303 parse_func = pdf11cm1_parse_hash;
10304 sort_by_digest = sort_by_digest_4_4;
10305 opti_type = OPTI_TYPE_ZERO_BYTE
10306 | OPTI_TYPE_NOT_ITERATED;
10307 dgst_pos0 = 0;
10308 dgst_pos1 = 1;
10309 dgst_pos2 = 2;
10310 dgst_pos3 = 3;
10311 break;
10312
10313 case 10420: hash_type = HASH_TYPE_PDFU16;
10314 salt_type = SALT_TYPE_EMBEDDED;
10315 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10316 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10317 kern_type = KERN_TYPE_PDF11CM2;
10318 dgst_size = DGST_SIZE_4_4;
10319 parse_func = pdf11cm2_parse_hash;
10320 sort_by_digest = sort_by_digest_4_4;
10321 opti_type = OPTI_TYPE_ZERO_BYTE
10322 | OPTI_TYPE_NOT_ITERATED;
10323 dgst_pos0 = 0;
10324 dgst_pos1 = 1;
10325 dgst_pos2 = 2;
10326 dgst_pos3 = 3;
10327 break;
10328
10329 case 10500: hash_type = HASH_TYPE_PDFU16;
10330 salt_type = SALT_TYPE_EMBEDDED;
10331 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10332 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10333 kern_type = KERN_TYPE_PDF14;
10334 dgst_size = DGST_SIZE_4_4;
10335 parse_func = pdf14_parse_hash;
10336 sort_by_digest = sort_by_digest_4_4;
10337 opti_type = OPTI_TYPE_ZERO_BYTE
10338 | OPTI_TYPE_NOT_ITERATED;
10339 dgst_pos0 = 0;
10340 dgst_pos1 = 1;
10341 dgst_pos2 = 2;
10342 dgst_pos3 = 3;
10343 break;
10344
10345 case 10600: hash_type = HASH_TYPE_SHA256;
10346 salt_type = SALT_TYPE_EMBEDDED;
10347 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10348 opts_type = OPTS_TYPE_PT_GENERATE_BE
10349 | OPTS_TYPE_ST_ADD80
10350 | OPTS_TYPE_ST_ADDBITS15
10351 | OPTS_TYPE_HASH_COPY;
10352 kern_type = KERN_TYPE_SHA256_PWSLT;
10353 dgst_size = DGST_SIZE_4_8;
10354 parse_func = pdf17l3_parse_hash;
10355 sort_by_digest = sort_by_digest_4_8;
10356 opti_type = OPTI_TYPE_ZERO_BYTE
10357 | OPTI_TYPE_PRECOMPUTE_INIT
10358 | OPTI_TYPE_PRECOMPUTE_MERKLE
10359 | OPTI_TYPE_EARLY_SKIP
10360 | OPTI_TYPE_NOT_ITERATED
10361 | OPTI_TYPE_APPENDED_SALT
10362 | OPTI_TYPE_RAW_HASH;
10363 dgst_pos0 = 3;
10364 dgst_pos1 = 7;
10365 dgst_pos2 = 2;
10366 dgst_pos3 = 6;
10367 break;
10368
10369 case 10700: hash_type = HASH_TYPE_PDFU32;
10370 salt_type = SALT_TYPE_EMBEDDED;
10371 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10372 opts_type = OPTS_TYPE_PT_GENERATE_LE
10373 | OPTS_TYPE_HASH_COPY;
10374 kern_type = KERN_TYPE_PDF17L8;
10375 dgst_size = DGST_SIZE_4_8;
10376 parse_func = pdf17l8_parse_hash;
10377 sort_by_digest = sort_by_digest_4_8;
10378 opti_type = OPTI_TYPE_ZERO_BYTE
10379 | OPTI_TYPE_NOT_ITERATED;
10380 dgst_pos0 = 0;
10381 dgst_pos1 = 1;
10382 dgst_pos2 = 2;
10383 dgst_pos3 = 3;
10384 break;
10385
10386 case 10800: hash_type = HASH_TYPE_SHA384;
10387 salt_type = SALT_TYPE_NONE;
10388 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10389 opts_type = OPTS_TYPE_PT_GENERATE_BE
10390 | OPTS_TYPE_PT_ADD80
10391 | OPTS_TYPE_PT_ADDBITS15;
10392 kern_type = KERN_TYPE_SHA384;
10393 dgst_size = DGST_SIZE_8_8;
10394 parse_func = sha384_parse_hash;
10395 sort_by_digest = sort_by_digest_8_8;
10396 opti_type = OPTI_TYPE_ZERO_BYTE
10397 | OPTI_TYPE_PRECOMPUTE_INIT
10398 | OPTI_TYPE_PRECOMPUTE_MERKLE
10399 | OPTI_TYPE_EARLY_SKIP
10400 | OPTI_TYPE_NOT_ITERATED
10401 | OPTI_TYPE_NOT_SALTED
10402 | OPTI_TYPE_USES_BITS_64
10403 | OPTI_TYPE_RAW_HASH;
10404 dgst_pos0 = 6;
10405 dgst_pos1 = 7;
10406 dgst_pos2 = 4;
10407 dgst_pos3 = 5;
10408 break;
10409
10410 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10411 salt_type = SALT_TYPE_EMBEDDED;
10412 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10413 opts_type = OPTS_TYPE_PT_GENERATE_LE
10414 | OPTS_TYPE_ST_BASE64
10415 | OPTS_TYPE_HASH_COPY;
10416 kern_type = KERN_TYPE_PBKDF2_SHA256;
10417 dgst_size = DGST_SIZE_4_32;
10418 parse_func = pbkdf2_sha256_parse_hash;
10419 sort_by_digest = sort_by_digest_4_32;
10420 opti_type = OPTI_TYPE_ZERO_BYTE
10421 | OPTI_TYPE_SLOW_HASH_SIMD;
10422 dgst_pos0 = 0;
10423 dgst_pos1 = 1;
10424 dgst_pos2 = 2;
10425 dgst_pos3 = 3;
10426 break;
10427
10428 case 11000: hash_type = HASH_TYPE_MD5;
10429 salt_type = SALT_TYPE_INTERN;
10430 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10431 opts_type = OPTS_TYPE_PT_GENERATE_LE
10432 | OPTS_TYPE_PT_ADD80;
10433 kern_type = KERN_TYPE_PRESTASHOP;
10434 dgst_size = DGST_SIZE_4_4;
10435 parse_func = prestashop_parse_hash;
10436 sort_by_digest = sort_by_digest_4_4;
10437 opti_type = OPTI_TYPE_ZERO_BYTE
10438 | OPTI_TYPE_PRECOMPUTE_INIT
10439 | OPTI_TYPE_NOT_ITERATED
10440 | OPTI_TYPE_PREPENDED_SALT;
10441 dgst_pos0 = 0;
10442 dgst_pos1 = 3;
10443 dgst_pos2 = 2;
10444 dgst_pos3 = 1;
10445 break;
10446
10447 case 11100: hash_type = HASH_TYPE_MD5;
10448 salt_type = SALT_TYPE_EMBEDDED;
10449 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10450 opts_type = OPTS_TYPE_PT_GENERATE_LE
10451 | OPTS_TYPE_ST_ADD80;
10452 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10453 dgst_size = DGST_SIZE_4_4;
10454 parse_func = postgresql_auth_parse_hash;
10455 sort_by_digest = sort_by_digest_4_4;
10456 opti_type = OPTI_TYPE_ZERO_BYTE
10457 | OPTI_TYPE_PRECOMPUTE_INIT
10458 | OPTI_TYPE_PRECOMPUTE_MERKLE
10459 | OPTI_TYPE_EARLY_SKIP;
10460 dgst_pos0 = 0;
10461 dgst_pos1 = 3;
10462 dgst_pos2 = 2;
10463 dgst_pos3 = 1;
10464 break;
10465
10466 case 11200: hash_type = HASH_TYPE_SHA1;
10467 salt_type = SALT_TYPE_EMBEDDED;
10468 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10469 opts_type = OPTS_TYPE_PT_GENERATE_BE
10470 | OPTS_TYPE_PT_ADD80
10471 | OPTS_TYPE_ST_HEX;
10472 kern_type = KERN_TYPE_MYSQL_AUTH;
10473 dgst_size = DGST_SIZE_4_5;
10474 parse_func = mysql_auth_parse_hash;
10475 sort_by_digest = sort_by_digest_4_5;
10476 opti_type = OPTI_TYPE_ZERO_BYTE
10477 | OPTI_TYPE_EARLY_SKIP;
10478 dgst_pos0 = 3;
10479 dgst_pos1 = 4;
10480 dgst_pos2 = 2;
10481 dgst_pos3 = 1;
10482 break;
10483
10484 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10485 salt_type = SALT_TYPE_EMBEDDED;
10486 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10487 opts_type = OPTS_TYPE_PT_GENERATE_LE
10488 | OPTS_TYPE_ST_HEX
10489 | OPTS_TYPE_ST_ADD80;
10490 kern_type = KERN_TYPE_BITCOIN_WALLET;
10491 dgst_size = DGST_SIZE_4_4;
10492 parse_func = bitcoin_wallet_parse_hash;
10493 sort_by_digest = sort_by_digest_4_4;
10494 opti_type = OPTI_TYPE_ZERO_BYTE;
10495 dgst_pos0 = 0;
10496 dgst_pos1 = 1;
10497 dgst_pos2 = 2;
10498 dgst_pos3 = 3;
10499 break;
10500
10501 case 11400: hash_type = HASH_TYPE_MD5;
10502 salt_type = SALT_TYPE_EMBEDDED;
10503 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10504 opts_type = OPTS_TYPE_PT_GENERATE_LE
10505 | OPTS_TYPE_PT_ADD80
10506 | OPTS_TYPE_HASH_COPY;
10507 kern_type = KERN_TYPE_SIP_AUTH;
10508 dgst_size = DGST_SIZE_4_4;
10509 parse_func = sip_auth_parse_hash;
10510 sort_by_digest = sort_by_digest_4_4;
10511 opti_type = OPTI_TYPE_ZERO_BYTE;
10512 dgst_pos0 = 0;
10513 dgst_pos1 = 3;
10514 dgst_pos2 = 2;
10515 dgst_pos3 = 1;
10516 break;
10517
10518 case 11500: hash_type = HASH_TYPE_CRC32;
10519 salt_type = SALT_TYPE_INTERN;
10520 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10521 opts_type = OPTS_TYPE_PT_GENERATE_LE
10522 | OPTS_TYPE_ST_GENERATE_LE
10523 | OPTS_TYPE_ST_HEX;
10524 kern_type = KERN_TYPE_CRC32;
10525 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10526 parse_func = crc32_parse_hash;
10527 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10528 opti_type = OPTI_TYPE_ZERO_BYTE;
10529 dgst_pos0 = 0;
10530 dgst_pos1 = 1;
10531 dgst_pos2 = 2;
10532 dgst_pos3 = 3;
10533 break;
10534
10535 case 11600: hash_type = HASH_TYPE_AES;
10536 salt_type = SALT_TYPE_EMBEDDED;
10537 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10538 opts_type = OPTS_TYPE_PT_GENERATE_LE
10539 | OPTS_TYPE_PT_NEVERCRACK;
10540 kern_type = KERN_TYPE_SEVEN_ZIP;
10541 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10542 parse_func = seven_zip_parse_hash;
10543 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10544 opti_type = OPTI_TYPE_ZERO_BYTE;
10545 dgst_pos0 = 0;
10546 dgst_pos1 = 1;
10547 dgst_pos2 = 2;
10548 dgst_pos3 = 3;
10549 break;
10550
10551 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10552 salt_type = SALT_TYPE_NONE;
10553 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10554 opts_type = OPTS_TYPE_PT_GENERATE_LE
10555 | OPTS_TYPE_PT_ADD01;
10556 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10557 dgst_size = DGST_SIZE_4_8;
10558 parse_func = gost2012sbog_256_parse_hash;
10559 sort_by_digest = sort_by_digest_4_8;
10560 opti_type = OPTI_TYPE_ZERO_BYTE;
10561 dgst_pos0 = 0;
10562 dgst_pos1 = 1;
10563 dgst_pos2 = 2;
10564 dgst_pos3 = 3;
10565 break;
10566
10567 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10568 salt_type = SALT_TYPE_NONE;
10569 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10570 opts_type = OPTS_TYPE_PT_GENERATE_LE
10571 | OPTS_TYPE_PT_ADD01;
10572 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10573 dgst_size = DGST_SIZE_4_16;
10574 parse_func = gost2012sbog_512_parse_hash;
10575 sort_by_digest = sort_by_digest_4_16;
10576 opti_type = OPTI_TYPE_ZERO_BYTE;
10577 dgst_pos0 = 0;
10578 dgst_pos1 = 1;
10579 dgst_pos2 = 2;
10580 dgst_pos3 = 3;
10581 break;
10582
10583 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10584 salt_type = SALT_TYPE_EMBEDDED;
10585 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10586 opts_type = OPTS_TYPE_PT_GENERATE_LE
10587 | OPTS_TYPE_ST_BASE64
10588 | OPTS_TYPE_HASH_COPY;
10589 kern_type = KERN_TYPE_PBKDF2_MD5;
10590 dgst_size = DGST_SIZE_4_32;
10591 parse_func = pbkdf2_md5_parse_hash;
10592 sort_by_digest = sort_by_digest_4_32;
10593 opti_type = OPTI_TYPE_ZERO_BYTE
10594 | OPTI_TYPE_SLOW_HASH_SIMD;
10595 dgst_pos0 = 0;
10596 dgst_pos1 = 1;
10597 dgst_pos2 = 2;
10598 dgst_pos3 = 3;
10599 break;
10600
10601 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10602 salt_type = SALT_TYPE_EMBEDDED;
10603 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10604 opts_type = OPTS_TYPE_PT_GENERATE_LE
10605 | OPTS_TYPE_ST_BASE64
10606 | OPTS_TYPE_HASH_COPY;
10607 kern_type = KERN_TYPE_PBKDF2_SHA1;
10608 dgst_size = DGST_SIZE_4_32;
10609 parse_func = pbkdf2_sha1_parse_hash;
10610 sort_by_digest = sort_by_digest_4_32;
10611 opti_type = OPTI_TYPE_ZERO_BYTE
10612 | OPTI_TYPE_SLOW_HASH_SIMD;
10613 dgst_pos0 = 0;
10614 dgst_pos1 = 1;
10615 dgst_pos2 = 2;
10616 dgst_pos3 = 3;
10617 break;
10618
10619 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10620 salt_type = SALT_TYPE_EMBEDDED;
10621 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10622 opts_type = OPTS_TYPE_PT_GENERATE_LE
10623 | OPTS_TYPE_ST_BASE64
10624 | OPTS_TYPE_HASH_COPY;
10625 kern_type = KERN_TYPE_PBKDF2_SHA512;
10626 dgst_size = DGST_SIZE_8_16;
10627 parse_func = pbkdf2_sha512_parse_hash;
10628 sort_by_digest = sort_by_digest_8_16;
10629 opti_type = OPTI_TYPE_ZERO_BYTE
10630 | OPTI_TYPE_USES_BITS_64
10631 | OPTI_TYPE_SLOW_HASH_SIMD;
10632 dgst_pos0 = 0;
10633 dgst_pos1 = 1;
10634 dgst_pos2 = 2;
10635 dgst_pos3 = 3;
10636 break;
10637
10638 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10639 salt_type = SALT_TYPE_EMBEDDED;
10640 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10641 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10642 kern_type = KERN_TYPE_ECRYPTFS;
10643 dgst_size = DGST_SIZE_8_8;
10644 parse_func = ecryptfs_parse_hash;
10645 sort_by_digest = sort_by_digest_8_8;
10646 opti_type = OPTI_TYPE_ZERO_BYTE
10647 | OPTI_TYPE_USES_BITS_64;
10648 dgst_pos0 = 0;
10649 dgst_pos1 = 1;
10650 dgst_pos2 = 2;
10651 dgst_pos3 = 3;
10652 break;
10653
10654 case 12300: hash_type = HASH_TYPE_ORACLET;
10655 salt_type = SALT_TYPE_EMBEDDED;
10656 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10657 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10658 kern_type = KERN_TYPE_ORACLET;
10659 dgst_size = DGST_SIZE_8_16;
10660 parse_func = oraclet_parse_hash;
10661 sort_by_digest = sort_by_digest_8_16;
10662 opti_type = OPTI_TYPE_ZERO_BYTE
10663 | OPTI_TYPE_USES_BITS_64;
10664 dgst_pos0 = 0;
10665 dgst_pos1 = 1;
10666 dgst_pos2 = 2;
10667 dgst_pos3 = 3;
10668 break;
10669
10670 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10671 salt_type = SALT_TYPE_EMBEDDED;
10672 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10673 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10674 kern_type = KERN_TYPE_BSDICRYPT;
10675 dgst_size = DGST_SIZE_4_4;
10676 parse_func = bsdicrypt_parse_hash;
10677 sort_by_digest = sort_by_digest_4_4;
10678 opti_type = OPTI_TYPE_ZERO_BYTE
10679 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10680 dgst_pos0 = 0;
10681 dgst_pos1 = 1;
10682 dgst_pos2 = 2;
10683 dgst_pos3 = 3;
10684 break;
10685
10686 case 12500: hash_type = HASH_TYPE_RAR3HP;
10687 salt_type = SALT_TYPE_EMBEDDED;
10688 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10689 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10690 kern_type = KERN_TYPE_RAR3;
10691 dgst_size = DGST_SIZE_4_4;
10692 parse_func = rar3hp_parse_hash;
10693 sort_by_digest = sort_by_digest_4_4;
10694 opti_type = OPTI_TYPE_ZERO_BYTE;
10695 dgst_pos0 = 0;
10696 dgst_pos1 = 1;
10697 dgst_pos2 = 2;
10698 dgst_pos3 = 3;
10699 break;
10700
10701 case 12600: hash_type = HASH_TYPE_SHA256;
10702 salt_type = SALT_TYPE_INTERN;
10703 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10704 opts_type = OPTS_TYPE_PT_GENERATE_BE
10705 | OPTS_TYPE_PT_ADD80;
10706 kern_type = KERN_TYPE_CF10;
10707 dgst_size = DGST_SIZE_4_8;
10708 parse_func = cf10_parse_hash;
10709 sort_by_digest = sort_by_digest_4_8;
10710 opti_type = OPTI_TYPE_ZERO_BYTE
10711 | OPTI_TYPE_PRECOMPUTE_INIT
10712 | OPTI_TYPE_EARLY_SKIP
10713 | OPTI_TYPE_NOT_ITERATED;
10714 dgst_pos0 = 3;
10715 dgst_pos1 = 7;
10716 dgst_pos2 = 2;
10717 dgst_pos3 = 6;
10718 break;
10719
10720 case 12700: hash_type = HASH_TYPE_AES;
10721 salt_type = SALT_TYPE_EMBEDDED;
10722 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10723 opts_type = OPTS_TYPE_PT_GENERATE_LE
10724 | OPTS_TYPE_HASH_COPY;
10725 kern_type = KERN_TYPE_MYWALLET;
10726 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10727 parse_func = mywallet_parse_hash;
10728 sort_by_digest = sort_by_digest_4_5;
10729 opti_type = OPTI_TYPE_ZERO_BYTE;
10730 dgst_pos0 = 0;
10731 dgst_pos1 = 1;
10732 dgst_pos2 = 2;
10733 dgst_pos3 = 3;
10734 break;
10735
10736 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10737 salt_type = SALT_TYPE_EMBEDDED;
10738 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10739 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10740 kern_type = KERN_TYPE_MS_DRSR;
10741 dgst_size = DGST_SIZE_4_8;
10742 parse_func = ms_drsr_parse_hash;
10743 sort_by_digest = sort_by_digest_4_8;
10744 opti_type = OPTI_TYPE_ZERO_BYTE;
10745 dgst_pos0 = 0;
10746 dgst_pos1 = 1;
10747 dgst_pos2 = 2;
10748 dgst_pos3 = 3;
10749 break;
10750
10751 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10752 salt_type = SALT_TYPE_EMBEDDED;
10753 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10754 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10755 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10756 dgst_size = DGST_SIZE_4_8;
10757 parse_func = androidfde_samsung_parse_hash;
10758 sort_by_digest = sort_by_digest_4_8;
10759 opti_type = OPTI_TYPE_ZERO_BYTE;
10760 dgst_pos0 = 0;
10761 dgst_pos1 = 1;
10762 dgst_pos2 = 2;
10763 dgst_pos3 = 3;
10764 break;
10765
10766 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10767 salt_type = SALT_TYPE_EMBEDDED;
10768 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10769 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10770 kern_type = KERN_TYPE_RAR5;
10771 dgst_size = DGST_SIZE_4_4;
10772 parse_func = rar5_parse_hash;
10773 sort_by_digest = sort_by_digest_4_4;
10774 opti_type = OPTI_TYPE_ZERO_BYTE;
10775 dgst_pos0 = 0;
10776 dgst_pos1 = 1;
10777 dgst_pos2 = 2;
10778 dgst_pos3 = 3;
10779 break;
10780
10781 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10782 salt_type = SALT_TYPE_EMBEDDED;
10783 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10784 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10785 kern_type = KERN_TYPE_KRB5TGS;
10786 dgst_size = DGST_SIZE_4_4;
10787 parse_func = krb5tgs_parse_hash;
10788 sort_by_digest = sort_by_digest_4_4;
10789 opti_type = OPTI_TYPE_ZERO_BYTE
10790 | OPTI_TYPE_NOT_ITERATED;
10791 dgst_pos0 = 0;
10792 dgst_pos1 = 1;
10793 dgst_pos2 = 2;
10794 dgst_pos3 = 3;
10795 break;
10796
10797 case 13200: hash_type = HASH_TYPE_AES;
10798 salt_type = SALT_TYPE_EMBEDDED;
10799 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10800 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10801 kern_type = KERN_TYPE_AXCRYPT;
10802 dgst_size = DGST_SIZE_4_4;
10803 parse_func = axcrypt_parse_hash;
10804 sort_by_digest = sort_by_digest_4_4;
10805 opti_type = OPTI_TYPE_ZERO_BYTE;
10806 dgst_pos0 = 0;
10807 dgst_pos1 = 1;
10808 dgst_pos2 = 2;
10809 dgst_pos3 = 3;
10810 break;
10811
10812 case 13300: hash_type = HASH_TYPE_SHA1;
10813 salt_type = SALT_TYPE_NONE;
10814 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10815 opts_type = OPTS_TYPE_PT_GENERATE_BE
10816 | OPTS_TYPE_PT_ADD80
10817 | OPTS_TYPE_PT_ADDBITS15;
10818 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10819 dgst_size = DGST_SIZE_4_5;
10820 parse_func = sha1axcrypt_parse_hash;
10821 sort_by_digest = sort_by_digest_4_5;
10822 opti_type = OPTI_TYPE_ZERO_BYTE
10823 | OPTI_TYPE_PRECOMPUTE_INIT
10824 | OPTI_TYPE_EARLY_SKIP
10825 | OPTI_TYPE_NOT_ITERATED
10826 | OPTI_TYPE_NOT_SALTED;
10827 dgst_pos0 = 0;
10828 dgst_pos1 = 4;
10829 dgst_pos2 = 3;
10830 dgst_pos3 = 2;
10831 break;
10832
10833 case 13400: hash_type = HASH_TYPE_AES;
10834 salt_type = SALT_TYPE_EMBEDDED;
10835 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10836 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10837 kern_type = KERN_TYPE_KEEPASS;
10838 dgst_size = DGST_SIZE_4_4;
10839 parse_func = keepass_parse_hash;
10840 sort_by_digest = sort_by_digest_4_4;
10841 opti_type = OPTI_TYPE_ZERO_BYTE;
10842 dgst_pos0 = 0;
10843 dgst_pos1 = 1;
10844 dgst_pos2 = 2;
10845 dgst_pos3 = 3;
10846 break;
10847
10848 case 13500: hash_type = HASH_TYPE_SHA1;
10849 salt_type = SALT_TYPE_EMBEDDED;
10850 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10851 opts_type = OPTS_TYPE_PT_GENERATE_BE
10852 | OPTS_TYPE_PT_UNICODE
10853 | OPTS_TYPE_PT_ADD80;
10854 kern_type = KERN_TYPE_PSTOKEN;
10855 dgst_size = DGST_SIZE_4_5;
10856 parse_func = pstoken_parse_hash;
10857 sort_by_digest = sort_by_digest_4_5;
10858 opti_type = OPTI_TYPE_ZERO_BYTE
10859 | OPTI_TYPE_PRECOMPUTE_INIT
10860 | OPTI_TYPE_EARLY_SKIP
10861 | OPTI_TYPE_NOT_ITERATED
10862 | OPTI_TYPE_PREPENDED_SALT
10863 | OPTI_TYPE_RAW_HASH;
10864 dgst_pos0 = 3;
10865 dgst_pos1 = 4;
10866 dgst_pos2 = 2;
10867 dgst_pos3 = 1;
10868 break;
10869
10870 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10871 salt_type = SALT_TYPE_EMBEDDED;
10872 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10873 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10874 kern_type = KERN_TYPE_ZIP2;
10875 dgst_size = DGST_SIZE_4_4;
10876 parse_func = zip2_parse_hash;
10877 sort_by_digest = sort_by_digest_4_4;
10878 opti_type = OPTI_TYPE_ZERO_BYTE;
10879 dgst_pos0 = 0;
10880 dgst_pos1 = 1;
10881 dgst_pos2 = 2;
10882 dgst_pos3 = 3;
10883 break;
10884
10885 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10886 salt_type = SALT_TYPE_EMBEDDED;
10887 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10888 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10889 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10890 dgst_size = DGST_SIZE_4_5;
10891 parse_func = veracrypt_parse_hash_655331;
10892 sort_by_digest = sort_by_digest_4_5;
10893 opti_type = OPTI_TYPE_ZERO_BYTE;
10894 dgst_pos0 = 0;
10895 dgst_pos1 = 1;
10896 dgst_pos2 = 2;
10897 dgst_pos3 = 3;
10898 break;
10899
10900 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10901 salt_type = SALT_TYPE_EMBEDDED;
10902 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10903 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10904 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10905 dgst_size = DGST_SIZE_4_5;
10906 parse_func = veracrypt_parse_hash_655331;
10907 sort_by_digest = sort_by_digest_4_5;
10908 opti_type = OPTI_TYPE_ZERO_BYTE;
10909 dgst_pos0 = 0;
10910 dgst_pos1 = 1;
10911 dgst_pos2 = 2;
10912 dgst_pos3 = 3;
10913 break;
10914
10915 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10916 salt_type = SALT_TYPE_EMBEDDED;
10917 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10918 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10919 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10920 dgst_size = DGST_SIZE_4_5;
10921 parse_func = veracrypt_parse_hash_655331;
10922 sort_by_digest = sort_by_digest_4_5;
10923 opti_type = OPTI_TYPE_ZERO_BYTE;
10924 dgst_pos0 = 0;
10925 dgst_pos1 = 1;
10926 dgst_pos2 = 2;
10927 dgst_pos3 = 3;
10928 break;
10929
10930 case 13721: hash_type = HASH_TYPE_SHA512;
10931 salt_type = SALT_TYPE_EMBEDDED;
10932 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10933 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10934 kern_type = KERN_TYPE_TCSHA512_XTS512;
10935 dgst_size = DGST_SIZE_8_8;
10936 parse_func = veracrypt_parse_hash_500000;
10937 sort_by_digest = sort_by_digest_8_8;
10938 opti_type = OPTI_TYPE_ZERO_BYTE
10939 | OPTI_TYPE_USES_BITS_64;
10940 dgst_pos0 = 0;
10941 dgst_pos1 = 1;
10942 dgst_pos2 = 2;
10943 dgst_pos3 = 3;
10944 break;
10945
10946 case 13722: hash_type = HASH_TYPE_SHA512;
10947 salt_type = SALT_TYPE_EMBEDDED;
10948 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10949 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10950 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10951 dgst_size = DGST_SIZE_8_8;
10952 parse_func = veracrypt_parse_hash_500000;
10953 sort_by_digest = sort_by_digest_8_8;
10954 opti_type = OPTI_TYPE_ZERO_BYTE
10955 | OPTI_TYPE_USES_BITS_64;
10956 dgst_pos0 = 0;
10957 dgst_pos1 = 1;
10958 dgst_pos2 = 2;
10959 dgst_pos3 = 3;
10960 break;
10961
10962 case 13723: hash_type = HASH_TYPE_SHA512;
10963 salt_type = SALT_TYPE_EMBEDDED;
10964 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10965 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10966 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10967 dgst_size = DGST_SIZE_8_8;
10968 parse_func = veracrypt_parse_hash_500000;
10969 sort_by_digest = sort_by_digest_8_8;
10970 opti_type = OPTI_TYPE_ZERO_BYTE
10971 | OPTI_TYPE_USES_BITS_64;
10972 dgst_pos0 = 0;
10973 dgst_pos1 = 1;
10974 dgst_pos2 = 2;
10975 dgst_pos3 = 3;
10976 break;
10977
10978 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10979 salt_type = SALT_TYPE_EMBEDDED;
10980 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10981 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10982 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10983 dgst_size = DGST_SIZE_4_8;
10984 parse_func = veracrypt_parse_hash_500000;
10985 sort_by_digest = sort_by_digest_4_8;
10986 opti_type = OPTI_TYPE_ZERO_BYTE;
10987 dgst_pos0 = 0;
10988 dgst_pos1 = 1;
10989 dgst_pos2 = 2;
10990 dgst_pos3 = 3;
10991 break;
10992
10993 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10994 salt_type = SALT_TYPE_EMBEDDED;
10995 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10996 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10997 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10998 dgst_size = DGST_SIZE_4_8;
10999 parse_func = veracrypt_parse_hash_500000;
11000 sort_by_digest = sort_by_digest_4_8;
11001 opti_type = OPTI_TYPE_ZERO_BYTE;
11002 dgst_pos0 = 0;
11003 dgst_pos1 = 1;
11004 dgst_pos2 = 2;
11005 dgst_pos3 = 3;
11006 break;
11007
11008 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
11009 salt_type = SALT_TYPE_EMBEDDED;
11010 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11011 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11012 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
11013 dgst_size = DGST_SIZE_4_8;
11014 parse_func = veracrypt_parse_hash_500000;
11015 sort_by_digest = sort_by_digest_4_8;
11016 opti_type = OPTI_TYPE_ZERO_BYTE;
11017 dgst_pos0 = 0;
11018 dgst_pos1 = 1;
11019 dgst_pos2 = 2;
11020 dgst_pos3 = 3;
11021 break;
11022
11023 case 13741: hash_type = HASH_TYPE_RIPEMD160;
11024 salt_type = SALT_TYPE_EMBEDDED;
11025 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11026 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11027 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
11028 dgst_size = DGST_SIZE_4_5;
11029 parse_func = veracrypt_parse_hash_327661;
11030 sort_by_digest = sort_by_digest_4_5;
11031 opti_type = OPTI_TYPE_ZERO_BYTE;
11032 dgst_pos0 = 0;
11033 dgst_pos1 = 1;
11034 dgst_pos2 = 2;
11035 dgst_pos3 = 3;
11036 break;
11037
11038 case 13742: hash_type = HASH_TYPE_RIPEMD160;
11039 salt_type = SALT_TYPE_EMBEDDED;
11040 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11041 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11042 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
11043 dgst_size = DGST_SIZE_4_5;
11044 parse_func = veracrypt_parse_hash_327661;
11045 sort_by_digest = sort_by_digest_4_5;
11046 opti_type = OPTI_TYPE_ZERO_BYTE;
11047 dgst_pos0 = 0;
11048 dgst_pos1 = 1;
11049 dgst_pos2 = 2;
11050 dgst_pos3 = 3;
11051 break;
11052
11053 case 13743: hash_type = HASH_TYPE_RIPEMD160;
11054 salt_type = SALT_TYPE_EMBEDDED;
11055 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11056 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11057 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11058 dgst_size = DGST_SIZE_4_5;
11059 parse_func = veracrypt_parse_hash_327661;
11060 sort_by_digest = sort_by_digest_4_5;
11061 opti_type = OPTI_TYPE_ZERO_BYTE;
11062 dgst_pos0 = 0;
11063 dgst_pos1 = 1;
11064 dgst_pos2 = 2;
11065 dgst_pos3 = 3;
11066 break;
11067
11068 case 13751: hash_type = HASH_TYPE_SHA256;
11069 salt_type = SALT_TYPE_EMBEDDED;
11070 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11071 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11072 kern_type = KERN_TYPE_VCSHA256_XTS512;
11073 dgst_size = DGST_SIZE_4_8;
11074 parse_func = veracrypt_parse_hash_500000;
11075 sort_by_digest = sort_by_digest_4_8;
11076 opti_type = OPTI_TYPE_ZERO_BYTE;
11077 dgst_pos0 = 0;
11078 dgst_pos1 = 1;
11079 dgst_pos2 = 2;
11080 dgst_pos3 = 3;
11081 break;
11082
11083 case 13752: hash_type = HASH_TYPE_SHA256;
11084 salt_type = SALT_TYPE_EMBEDDED;
11085 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11086 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11087 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11088 dgst_size = DGST_SIZE_4_8;
11089 parse_func = veracrypt_parse_hash_500000;
11090 sort_by_digest = sort_by_digest_4_8;
11091 opti_type = OPTI_TYPE_ZERO_BYTE;
11092 dgst_pos0 = 0;
11093 dgst_pos1 = 1;
11094 dgst_pos2 = 2;
11095 dgst_pos3 = 3;
11096 break;
11097
11098 case 13753: hash_type = HASH_TYPE_SHA256;
11099 salt_type = SALT_TYPE_EMBEDDED;
11100 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11101 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11102 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11103 dgst_size = DGST_SIZE_4_8;
11104 parse_func = veracrypt_parse_hash_500000;
11105 sort_by_digest = sort_by_digest_4_8;
11106 opti_type = OPTI_TYPE_ZERO_BYTE;
11107 dgst_pos0 = 0;
11108 dgst_pos1 = 1;
11109 dgst_pos2 = 2;
11110 dgst_pos3 = 3;
11111 break;
11112
11113 case 13761: hash_type = HASH_TYPE_SHA256;
11114 salt_type = SALT_TYPE_EMBEDDED;
11115 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11116 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11117 kern_type = KERN_TYPE_VCSHA256_XTS512;
11118 dgst_size = DGST_SIZE_4_8;
11119 parse_func = veracrypt_parse_hash_200000;
11120 sort_by_digest = sort_by_digest_4_8;
11121 opti_type = OPTI_TYPE_ZERO_BYTE;
11122 dgst_pos0 = 0;
11123 dgst_pos1 = 1;
11124 dgst_pos2 = 2;
11125 dgst_pos3 = 3;
11126 break;
11127
11128 case 13762: hash_type = HASH_TYPE_SHA256;
11129 salt_type = SALT_TYPE_EMBEDDED;
11130 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11131 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11132 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11133 dgst_size = DGST_SIZE_4_8;
11134 parse_func = veracrypt_parse_hash_200000;
11135 sort_by_digest = sort_by_digest_4_8;
11136 opti_type = OPTI_TYPE_ZERO_BYTE;
11137 dgst_pos0 = 0;
11138 dgst_pos1 = 1;
11139 dgst_pos2 = 2;
11140 dgst_pos3 = 3;
11141 break;
11142
11143 case 13763: hash_type = HASH_TYPE_SHA256;
11144 salt_type = SALT_TYPE_EMBEDDED;
11145 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11146 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11147 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11148 dgst_size = DGST_SIZE_4_8;
11149 parse_func = veracrypt_parse_hash_200000;
11150 sort_by_digest = sort_by_digest_4_8;
11151 opti_type = OPTI_TYPE_ZERO_BYTE;
11152 dgst_pos0 = 0;
11153 dgst_pos1 = 1;
11154 dgst_pos2 = 2;
11155 dgst_pos3 = 3;
11156 break;
11157
11158 case 13800: hash_type = HASH_TYPE_SHA256;
11159 salt_type = SALT_TYPE_EMBEDDED;
11160 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11161 opts_type = OPTS_TYPE_PT_GENERATE_BE
11162 | OPTS_TYPE_PT_UNICODE;
11163 kern_type = KERN_TYPE_WIN8PHONE;
11164 dgst_size = DGST_SIZE_4_8;
11165 parse_func = win8phone_parse_hash;
11166 sort_by_digest = sort_by_digest_4_8;
11167 opti_type = OPTI_TYPE_ZERO_BYTE
11168 | OPTI_TYPE_PRECOMPUTE_INIT
11169 | OPTI_TYPE_EARLY_SKIP
11170 | OPTI_TYPE_NOT_ITERATED
11171 | OPTI_TYPE_RAW_HASH;
11172 dgst_pos0 = 3;
11173 dgst_pos1 = 7;
11174 dgst_pos2 = 2;
11175 dgst_pos3 = 6;
11176 break;
11177
11178 default: usage_mini_print (PROGNAME); return (-1);
11179 }
11180
11181 /**
11182 * parser
11183 */
11184
11185 data.parse_func = parse_func;
11186
11187 /**
11188 * misc stuff
11189 */
11190
11191 if (hex_salt)
11192 {
11193 if (salt_type == SALT_TYPE_INTERN)
11194 {
11195 opts_type |= OPTS_TYPE_ST_HEX;
11196 }
11197 else
11198 {
11199 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11200
11201 return (-1);
11202 }
11203 }
11204
11205 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11206 | (salt_type == SALT_TYPE_EXTERN)
11207 | (salt_type == SALT_TYPE_EMBEDDED)
11208 | (salt_type == SALT_TYPE_VIRTUAL));
11209
11210 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
11211
11212 data.hash_type = hash_type;
11213 data.attack_mode = attack_mode;
11214 data.attack_kern = attack_kern;
11215 data.attack_exec = attack_exec;
11216 data.kern_type = kern_type;
11217 data.opts_type = opts_type;
11218 data.dgst_size = dgst_size;
11219 data.salt_type = salt_type;
11220 data.isSalted = isSalted;
11221 data.sort_by_digest = sort_by_digest;
11222 data.dgst_pos0 = dgst_pos0;
11223 data.dgst_pos1 = dgst_pos1;
11224 data.dgst_pos2 = dgst_pos2;
11225 data.dgst_pos3 = dgst_pos3;
11226
11227 esalt_size = 0;
11228
11229 switch (hash_mode)
11230 {
11231 case 2500: esalt_size = sizeof (wpa_t); break;
11232 case 5300: esalt_size = sizeof (ikepsk_t); break;
11233 case 5400: esalt_size = sizeof (ikepsk_t); break;
11234 case 5500: esalt_size = sizeof (netntlm_t); break;
11235 case 5600: esalt_size = sizeof (netntlm_t); break;
11236 case 6211: esalt_size = sizeof (tc_t); break;
11237 case 6212: esalt_size = sizeof (tc_t); break;
11238 case 6213: esalt_size = sizeof (tc_t); break;
11239 case 6221: esalt_size = sizeof (tc_t); break;
11240 case 6222: esalt_size = sizeof (tc_t); break;
11241 case 6223: esalt_size = sizeof (tc_t); break;
11242 case 6231: esalt_size = sizeof (tc_t); break;
11243 case 6232: esalt_size = sizeof (tc_t); break;
11244 case 6233: esalt_size = sizeof (tc_t); break;
11245 case 6241: esalt_size = sizeof (tc_t); break;
11246 case 6242: esalt_size = sizeof (tc_t); break;
11247 case 6243: esalt_size = sizeof (tc_t); break;
11248 case 6600: esalt_size = sizeof (agilekey_t); break;
11249 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11250 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
11251 case 7300: esalt_size = sizeof (rakp_t); break;
11252 case 7500: esalt_size = sizeof (krb5pa_t); break;
11253 case 8200: esalt_size = sizeof (cloudkey_t); break;
11254 case 8800: esalt_size = sizeof (androidfde_t); break;
11255 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
11256 case 9400: esalt_size = sizeof (office2007_t); break;
11257 case 9500: esalt_size = sizeof (office2010_t); break;
11258 case 9600: esalt_size = sizeof (office2013_t); break;
11259 case 9700: esalt_size = sizeof (oldoffice01_t); break;
11260 case 9710: esalt_size = sizeof (oldoffice01_t); break;
11261 case 9720: esalt_size = sizeof (oldoffice01_t); break;
11262 case 9800: esalt_size = sizeof (oldoffice34_t); break;
11263 case 9810: esalt_size = sizeof (oldoffice34_t); break;
11264 case 9820: esalt_size = sizeof (oldoffice34_t); break;
11265 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
11266 case 10200: esalt_size = sizeof (cram_md5_t); break;
11267 case 10400: esalt_size = sizeof (pdf_t); break;
11268 case 10410: esalt_size = sizeof (pdf_t); break;
11269 case 10420: esalt_size = sizeof (pdf_t); break;
11270 case 10500: esalt_size = sizeof (pdf_t); break;
11271 case 10600: esalt_size = sizeof (pdf_t); break;
11272 case 10700: esalt_size = sizeof (pdf_t); break;
11273 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
11274 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
11275 case 11400: esalt_size = sizeof (sip_t); break;
11276 case 11600: esalt_size = sizeof (seven_zip_t); break;
11277 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
11278 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
11279 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11280 case 13000: esalt_size = sizeof (rar5_t); break;
11281 case 13100: esalt_size = sizeof (krb5tgs_t); break;
11282 case 13400: esalt_size = sizeof (keepass_t); break;
11283 case 13500: esalt_size = sizeof (pstoken_t); break;
11284 case 13600: esalt_size = sizeof (zip2_t); break;
11285 case 13711: esalt_size = sizeof (tc_t); break;
11286 case 13712: esalt_size = sizeof (tc_t); break;
11287 case 13713: esalt_size = sizeof (tc_t); break;
11288 case 13721: esalt_size = sizeof (tc_t); break;
11289 case 13722: esalt_size = sizeof (tc_t); break;
11290 case 13723: esalt_size = sizeof (tc_t); break;
11291 case 13731: esalt_size = sizeof (tc_t); break;
11292 case 13732: esalt_size = sizeof (tc_t); break;
11293 case 13733: esalt_size = sizeof (tc_t); break;
11294 case 13741: esalt_size = sizeof (tc_t); break;
11295 case 13742: esalt_size = sizeof (tc_t); break;
11296 case 13743: esalt_size = sizeof (tc_t); break;
11297 case 13751: esalt_size = sizeof (tc_t); break;
11298 case 13752: esalt_size = sizeof (tc_t); break;
11299 case 13753: esalt_size = sizeof (tc_t); break;
11300 case 13761: esalt_size = sizeof (tc_t); break;
11301 case 13762: esalt_size = sizeof (tc_t); break;
11302 case 13763: esalt_size = sizeof (tc_t); break;
11303 case 13800: esalt_size = sizeof (win8phone_t); break;
11304 }
11305
11306 data.esalt_size = esalt_size;
11307
11308 /**
11309 * choose dictionary parser
11310 */
11311
11312 if (hash_type == HASH_TYPE_LM)
11313 {
11314 get_next_word_func = get_next_word_lm;
11315 }
11316 else if (opts_type & OPTS_TYPE_PT_UPPER)
11317 {
11318 get_next_word_func = get_next_word_uc;
11319 }
11320 else
11321 {
11322 get_next_word_func = get_next_word_std;
11323 }
11324
11325 /**
11326 * dictstat
11327 */
11328
11329 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11330
11331 #ifdef _POSIX
11332 size_t dictstat_nmemb = 0;
11333 #endif
11334
11335 #ifdef _WIN
11336 uint dictstat_nmemb = 0;
11337 #endif
11338
11339 char dictstat[256] = { 0 };
11340
11341 FILE *dictstat_fp = NULL;
11342
11343 if (keyspace == 0)
11344 {
11345 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11346
11347 dictstat_fp = fopen (dictstat, "rb");
11348
11349 if (dictstat_fp)
11350 {
11351 #ifdef _POSIX
11352 struct stat tmpstat;
11353
11354 fstat (fileno (dictstat_fp), &tmpstat);
11355 #endif
11356
11357 #ifdef _WIN
11358 struct stat64 tmpstat;
11359
11360 _fstat64 (fileno (dictstat_fp), &tmpstat);
11361 #endif
11362
11363 if (tmpstat.st_mtime < COMPTIME)
11364 {
11365 /* with v0.15 the format changed so we have to ensure user is using a good version
11366 since there is no version-header in the dictstat file */
11367
11368 fclose (dictstat_fp);
11369
11370 unlink (dictstat);
11371 }
11372 else
11373 {
11374 while (!feof (dictstat_fp))
11375 {
11376 dictstat_t d;
11377
11378 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11379
11380 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11381
11382 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11383 {
11384 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11385
11386 return -1;
11387 }
11388 }
11389
11390 fclose (dictstat_fp);
11391 }
11392 }
11393 }
11394
11395 /**
11396 * potfile
11397 */
11398
11399 char potfile[256] = { 0 };
11400
11401 if (potfile_path == NULL)
11402 {
11403 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11404 }
11405 else
11406 {
11407 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11408 }
11409
11410 data.pot_fp = NULL;
11411
11412 FILE *out_fp = NULL;
11413 FILE *pot_fp = NULL;
11414
11415 if (show == 1 || left == 1)
11416 {
11417 pot_fp = fopen (potfile, "rb");
11418
11419 if (pot_fp == NULL)
11420 {
11421 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11422
11423 return (-1);
11424 }
11425
11426 if (outfile != NULL)
11427 {
11428 if ((out_fp = fopen (outfile, "ab")) == NULL)
11429 {
11430 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11431
11432 fclose (pot_fp);
11433
11434 return (-1);
11435 }
11436 }
11437 else
11438 {
11439 out_fp = stdout;
11440 }
11441 }
11442 else
11443 {
11444 if (potfile_disable == 0)
11445 {
11446 pot_fp = fopen (potfile, "ab");
11447
11448 if (pot_fp == NULL)
11449 {
11450 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11451
11452 return (-1);
11453 }
11454
11455 data.pot_fp = pot_fp;
11456 }
11457 }
11458
11459 pot_t *pot = NULL;
11460
11461 uint pot_cnt = 0;
11462 uint pot_avail = 0;
11463
11464 if (show == 1 || left == 1)
11465 {
11466 SUPPRESS_OUTPUT = 1;
11467
11468 pot_avail = count_lines (pot_fp);
11469
11470 rewind (pot_fp);
11471
11472 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11473
11474 uint pot_hashes_avail = 0;
11475
11476 uint line_num = 0;
11477
11478 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11479
11480 while (!feof (pot_fp))
11481 {
11482 line_num++;
11483
11484 int line_len = fgetl (pot_fp, line_buf);
11485
11486 if (line_len == 0) continue;
11487
11488 char *plain_buf = line_buf + line_len;
11489
11490 pot_t *pot_ptr = &pot[pot_cnt];
11491
11492 hash_t *hashes_buf = &pot_ptr->hash;
11493
11494 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11495 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11496
11497 if (pot_cnt == pot_hashes_avail)
11498 {
11499 uint pos = 0;
11500
11501 for (pos = 0; pos < INCR_POT; pos++)
11502 {
11503 if ((pot_cnt + pos) >= pot_avail) break;
11504
11505 pot_t *tmp_pot = &pot[pot_cnt + pos];
11506
11507 hash_t *tmp_hash = &tmp_pot->hash;
11508
11509 tmp_hash->digest = mymalloc (dgst_size);
11510
11511 if (isSalted)
11512 {
11513 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11514 }
11515
11516 if (esalt_size)
11517 {
11518 tmp_hash->esalt = mymalloc (esalt_size);
11519 }
11520
11521 pot_hashes_avail++;
11522 }
11523 }
11524
11525 int plain_len = 0;
11526
11527 int parser_status;
11528
11529 int iter = MAX_CUT_TRIES;
11530
11531 do
11532 {
11533 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11534 {
11535 if (line_buf[i] == ':')
11536 {
11537 line_len--;
11538
11539 break;
11540 }
11541 }
11542
11543 if (data.hash_mode != 2500)
11544 {
11545 parser_status = parse_func (line_buf, line_len, hashes_buf);
11546 }
11547 else
11548 {
11549 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11550
11551 if (line_len > max_salt_size)
11552 {
11553 parser_status = PARSER_GLOBAL_LENGTH;
11554 }
11555 else
11556 {
11557 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11558
11559 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11560
11561 hashes_buf->salt->salt_len = line_len;
11562
11563 parser_status = PARSER_OK;
11564 }
11565 }
11566
11567 // if NOT parsed without error, we add the ":" to the plain
11568
11569 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11570 {
11571 plain_len++;
11572 plain_buf--;
11573 }
11574
11575 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11576
11577 if (parser_status < PARSER_GLOBAL_ZERO)
11578 {
11579 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11580
11581 continue;
11582 }
11583
11584 if (plain_len >= 255) continue;
11585
11586 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11587
11588 pot_ptr->plain_len = plain_len;
11589
11590 pot_cnt++;
11591 }
11592
11593 myfree (line_buf);
11594
11595 fclose (pot_fp);
11596
11597 SUPPRESS_OUTPUT = 0;
11598
11599 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11600 }
11601
11602 /**
11603 * word len
11604 */
11605
11606 uint pw_min = PW_MIN;
11607 uint pw_max = PW_MAX;
11608
11609 switch (hash_mode)
11610 {
11611 case 125: if (pw_max > 32) pw_max = 32;
11612 break;
11613 case 400: if (pw_max > 40) pw_max = 40;
11614 break;
11615 case 500: if (pw_max > 16) pw_max = 16;
11616 break;
11617 case 1500: if (pw_max > 8) pw_max = 8;
11618 break;
11619 case 1600: if (pw_max > 16) pw_max = 16;
11620 break;
11621 case 1800: if (pw_max > 16) pw_max = 16;
11622 break;
11623 case 2100: if (pw_max > 16) pw_max = 16;
11624 break;
11625 case 2500: if (pw_min < 8) pw_min = 8;
11626 break;
11627 case 3000: if (pw_max > 7) pw_max = 7;
11628 break;
11629 case 5200: if (pw_max > 24) pw_max = 24;
11630 break;
11631 case 5800: if (pw_max > 16) pw_max = 16;
11632 break;
11633 case 6300: if (pw_max > 16) pw_max = 16;
11634 break;
11635 case 7400: if (pw_max > 16) pw_max = 16;
11636 break;
11637 case 7700: if (pw_max > 8) pw_max = 8;
11638 break;
11639 case 7900: if (pw_max > 48) pw_max = 48;
11640 break;
11641 case 8500: if (pw_max > 8) pw_max = 8;
11642 break;
11643 case 8600: if (pw_max > 16) pw_max = 16;
11644 break;
11645 case 9710: pw_min = 5;
11646 pw_max = 5;
11647 break;
11648 case 9810: pw_min = 5;
11649 pw_max = 5;
11650 break;
11651 case 10410: pw_min = 5;
11652 pw_max = 5;
11653 break;
11654 case 10300: if (pw_max < 3) pw_min = 3;
11655 if (pw_max > 40) pw_max = 40;
11656 break;
11657 case 10500: if (pw_max < 3) pw_min = 3;
11658 if (pw_max > 40) pw_max = 40;
11659 break;
11660 case 10700: if (pw_max > 16) pw_max = 16;
11661 break;
11662 case 11300: if (pw_max > 40) pw_max = 40;
11663 break;
11664 case 11600: if (pw_max > 32) pw_max = 32;
11665 break;
11666 case 12500: if (pw_max > 20) pw_max = 20;
11667 break;
11668 case 12800: if (pw_max > 24) pw_max = 24;
11669 break;
11670 }
11671
11672 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11673 {
11674 switch (attack_kern)
11675 {
11676 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11677 break;
11678 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11679 break;
11680 }
11681 }
11682
11683 /**
11684 * charsets : keep them together for more easy maintainnce
11685 */
11686
11687 cs_t mp_sys[6] = { { { 0 }, 0 } };
11688 cs_t mp_usr[4] = { { { 0 }, 0 } };
11689
11690 mp_setup_sys (mp_sys);
11691
11692 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11693 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11694 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11695 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11696
11697 /**
11698 * load hashes, part I: find input mode, count hashes
11699 */
11700
11701 uint hashlist_mode = 0;
11702 uint hashlist_format = HLFMT_HASHCAT;
11703
11704 uint hashes_avail = 0;
11705
11706 if ((benchmark == 0) && (stdout_flag == 0))
11707 {
11708 struct stat f;
11709
11710 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11711
11712 if ((hash_mode == 2500) ||
11713 (hash_mode == 5200) ||
11714 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11715 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11716 (hash_mode == 9000))
11717 {
11718 hashlist_mode = HL_MODE_ARG;
11719
11720 char *hashfile = myargv[optind];
11721
11722 data.hashfile = hashfile;
11723
11724 logfile_top_var_string ("target", hashfile);
11725 }
11726
11727 if (hashlist_mode == HL_MODE_ARG)
11728 {
11729 if (hash_mode == 2500)
11730 {
11731 struct stat st;
11732
11733 if (stat (data.hashfile, &st) == -1)
11734 {
11735 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11736
11737 return (-1);
11738 }
11739
11740 hashes_avail = st.st_size / sizeof (hccap_t);
11741 }
11742 else
11743 {
11744 hashes_avail = 1;
11745 }
11746 }
11747 else if (hashlist_mode == HL_MODE_FILE)
11748 {
11749 char *hashfile = myargv[optind];
11750
11751 data.hashfile = hashfile;
11752
11753 logfile_top_var_string ("target", hashfile);
11754
11755 FILE *fp = NULL;
11756
11757 if ((fp = fopen (hashfile, "rb")) == NULL)
11758 {
11759 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11760
11761 return (-1);
11762 }
11763
11764 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11765
11766 hashes_avail = count_lines (fp);
11767
11768 rewind (fp);
11769
11770 if (hashes_avail == 0)
11771 {
11772 log_error ("ERROR: hashfile is empty or corrupt");
11773
11774 fclose (fp);
11775
11776 return (-1);
11777 }
11778
11779 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11780
11781 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11782 {
11783 log_error ("ERROR: remove not supported in native hashfile-format mode");
11784
11785 fclose (fp);
11786
11787 return (-1);
11788 }
11789
11790 fclose (fp);
11791 }
11792 }
11793 else
11794 {
11795 hashlist_mode = HL_MODE_ARG;
11796
11797 hashes_avail = 1;
11798 }
11799
11800 if (hash_mode == 3000) hashes_avail *= 2;
11801
11802 data.hashlist_mode = hashlist_mode;
11803 data.hashlist_format = hashlist_format;
11804
11805 logfile_top_uint (hashlist_mode);
11806 logfile_top_uint (hashlist_format);
11807
11808 /**
11809 * load hashes, part II: allocate required memory, set pointers
11810 */
11811
11812 hash_t *hashes_buf = NULL;
11813 void *digests_buf = NULL;
11814 salt_t *salts_buf = NULL;
11815 void *esalts_buf = NULL;
11816
11817 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11818
11819 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11820
11821 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11822 {
11823 u32 hash_pos;
11824
11825 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11826 {
11827 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11828
11829 hashes_buf[hash_pos].hash_info = hash_info;
11830
11831 if (username && (remove || show || left))
11832 {
11833 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11834 }
11835
11836 if (benchmark)
11837 {
11838 hash_info->orighash = (char *) mymalloc (256);
11839 }
11840 }
11841 }
11842
11843 if (isSalted)
11844 {
11845 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11846
11847 if (esalt_size)
11848 {
11849 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11850 }
11851 }
11852 else
11853 {
11854 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11855 }
11856
11857 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11858 {
11859 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11860
11861 if (isSalted)
11862 {
11863 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11864
11865 if (esalt_size)
11866 {
11867 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11868 }
11869 }
11870 else
11871 {
11872 hashes_buf[hash_pos].salt = &salts_buf[0];
11873 }
11874 }
11875
11876 /**
11877 * load hashes, part III: parse hashes or generate them if benchmark
11878 */
11879
11880 uint hashes_cnt = 0;
11881
11882 if (benchmark == 0)
11883 {
11884 if (keyspace == 1)
11885 {
11886 // useless to read hash file for keyspace, cheat a little bit w/ optind
11887 }
11888 else if (stdout_flag == 1)
11889 {
11890 // useless to read hash file for stdout, cheat a little bit w/ optind
11891 }
11892 else if (hashes_avail == 0)
11893 {
11894 }
11895 else if (hashlist_mode == HL_MODE_ARG)
11896 {
11897 char *input_buf = myargv[optind];
11898
11899 uint input_len = strlen (input_buf);
11900
11901 logfile_top_var_string ("target", input_buf);
11902
11903 char *hash_buf = NULL;
11904 int hash_len = 0;
11905
11906 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11907
11908 bool hash_fmt_error = 0;
11909
11910 if (hash_len < 1) hash_fmt_error = 1;
11911 if (hash_buf == NULL) hash_fmt_error = 1;
11912
11913 if (hash_fmt_error)
11914 {
11915 log_info ("WARNING: Failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11916 }
11917 else
11918 {
11919 if (opts_type & OPTS_TYPE_HASH_COPY)
11920 {
11921 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11922
11923 hash_info_tmp->orighash = mystrdup (hash_buf);
11924 }
11925
11926 if (isSalted)
11927 {
11928 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11929 }
11930
11931 int parser_status = PARSER_OK;
11932
11933 if (hash_mode == 2500)
11934 {
11935 if (hash_len == 0)
11936 {
11937 log_error ("ERROR: hccap file not specified");
11938
11939 return (-1);
11940 }
11941
11942 hashlist_mode = HL_MODE_FILE;
11943
11944 data.hashlist_mode = hashlist_mode;
11945
11946 FILE *fp = fopen (hash_buf, "rb");
11947
11948 if (fp == NULL)
11949 {
11950 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11951
11952 return (-1);
11953 }
11954
11955 if (hashes_avail < 1)
11956 {
11957 log_error ("ERROR: hccap file is empty or corrupt");
11958
11959 fclose (fp);
11960
11961 return (-1);
11962 }
11963
11964 uint hccap_size = sizeof (hccap_t);
11965
11966 char *in = (char *) mymalloc (hccap_size);
11967
11968 while (!feof (fp))
11969 {
11970 int n = fread (in, hccap_size, 1, fp);
11971
11972 if (n != 1)
11973 {
11974 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11975
11976 break;
11977 }
11978
11979 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11980
11981 if (parser_status != PARSER_OK)
11982 {
11983 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11984
11985 continue;
11986 }
11987
11988 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11989
11990 if ((show == 1) || (left == 1))
11991 {
11992 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11993
11994 char *salt_ptr = (char *) tmp_salt->salt_buf;
11995
11996 int cur_pos = tmp_salt->salt_len;
11997 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11998
11999 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
12000
12001 // do the appending task
12002
12003 snprintf (salt_ptr + cur_pos,
12004 rem_len,
12005 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
12006 wpa->orig_mac1[0],
12007 wpa->orig_mac1[1],
12008 wpa->orig_mac1[2],
12009 wpa->orig_mac1[3],
12010 wpa->orig_mac1[4],
12011 wpa->orig_mac1[5],
12012 wpa->orig_mac2[0],
12013 wpa->orig_mac2[1],
12014 wpa->orig_mac2[2],
12015 wpa->orig_mac2[3],
12016 wpa->orig_mac2[4],
12017 wpa->orig_mac2[5]);
12018
12019 // memset () the remaining part of the salt
12020
12021 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
12022 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12023
12024 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
12025
12026 tmp_salt->salt_len += 1 + 12 + 1 + 12;
12027 }
12028
12029 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);
12030 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);
12031
12032 hashes_cnt++;
12033 }
12034
12035 fclose (fp);
12036
12037 myfree (in);
12038 }
12039 else if (hash_mode == 3000)
12040 {
12041 if (hash_len == 32)
12042 {
12043 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12044
12045 hash_t *lm_hash_left = NULL;
12046
12047 if (parser_status == PARSER_OK)
12048 {
12049 lm_hash_left = &hashes_buf[hashes_cnt];
12050
12051 hashes_cnt++;
12052 }
12053 else
12054 {
12055 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12056 }
12057
12058 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12059
12060 hash_t *lm_hash_right = NULL;
12061
12062 if (parser_status == PARSER_OK)
12063 {
12064 lm_hash_right = &hashes_buf[hashes_cnt];
12065
12066 hashes_cnt++;
12067 }
12068 else
12069 {
12070 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12071 }
12072
12073 // show / left
12074
12075 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12076 {
12077 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);
12078 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);
12079 }
12080 }
12081 else
12082 {
12083 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12084
12085 if (parser_status == PARSER_OK)
12086 {
12087 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12088 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12089 }
12090
12091 if (parser_status == PARSER_OK)
12092 {
12093 hashes_cnt++;
12094 }
12095 else
12096 {
12097 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12098 }
12099 }
12100 }
12101 else
12102 {
12103 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12104
12105 if (parser_status == PARSER_OK)
12106 {
12107 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12108 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12109 }
12110
12111 if (parser_status == PARSER_OK)
12112 {
12113 hashes_cnt++;
12114 }
12115 else
12116 {
12117 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12118 }
12119 }
12120 }
12121 }
12122 else if (hashlist_mode == HL_MODE_FILE)
12123 {
12124 char *hashfile = data.hashfile;
12125
12126 FILE *fp;
12127
12128 if ((fp = fopen (hashfile, "rb")) == NULL)
12129 {
12130 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12131
12132 return (-1);
12133 }
12134
12135 uint line_num = 0;
12136
12137 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12138
12139 while (!feof (fp))
12140 {
12141 line_num++;
12142
12143 int line_len = fgetl (fp, line_buf);
12144
12145 if (line_len == 0) continue;
12146
12147 char *hash_buf = NULL;
12148 int hash_len = 0;
12149
12150 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12151
12152 bool hash_fmt_error = 0;
12153
12154 if (hash_len < 1) hash_fmt_error = 1;
12155 if (hash_buf == NULL) hash_fmt_error = 1;
12156
12157 if (hash_fmt_error)
12158 {
12159 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12160
12161 continue;
12162 }
12163
12164 if (username)
12165 {
12166 char *user_buf = NULL;
12167 int user_len = 0;
12168
12169 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12170
12171 if (remove || show)
12172 {
12173 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12174
12175 *user = (user_t *) mymalloc (sizeof (user_t));
12176
12177 user_t *user_ptr = *user;
12178
12179 if (user_buf != NULL)
12180 {
12181 user_ptr->user_name = mystrdup (user_buf);
12182 }
12183 else
12184 {
12185 user_ptr->user_name = mystrdup ("");
12186 }
12187
12188 user_ptr->user_len = user_len;
12189 }
12190 }
12191
12192 if (opts_type & OPTS_TYPE_HASH_COPY)
12193 {
12194 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12195
12196 hash_info_tmp->orighash = mystrdup (hash_buf);
12197 }
12198
12199 if (isSalted)
12200 {
12201 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12202 }
12203
12204 if (hash_mode == 3000)
12205 {
12206 if (hash_len == 32)
12207 {
12208 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12209
12210 if (parser_status < PARSER_GLOBAL_ZERO)
12211 {
12212 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12213
12214 continue;
12215 }
12216
12217 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12218
12219 hashes_cnt++;
12220
12221 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12222
12223 if (parser_status < PARSER_GLOBAL_ZERO)
12224 {
12225 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12226
12227 continue;
12228 }
12229
12230 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12231
12232 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);
12233
12234 hashes_cnt++;
12235
12236 // show / left
12237
12238 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);
12239 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);
12240 }
12241 else
12242 {
12243 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12244
12245 if (parser_status < PARSER_GLOBAL_ZERO)
12246 {
12247 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12248
12249 continue;
12250 }
12251
12252 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);
12253
12254 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12255 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12256
12257 hashes_cnt++;
12258 }
12259 }
12260 else
12261 {
12262 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12263
12264 if (parser_status < PARSER_GLOBAL_ZERO)
12265 {
12266 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12267
12268 continue;
12269 }
12270
12271 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);
12272
12273 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12274 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12275
12276 hashes_cnt++;
12277 }
12278 }
12279
12280 myfree (line_buf);
12281
12282 fclose (fp);
12283
12284 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12285
12286 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12287 }
12288 }
12289 else
12290 {
12291 if (isSalted)
12292 {
12293 hashes_buf[0].salt->salt_len = 8;
12294
12295 // special salt handling
12296
12297 switch (hash_mode)
12298 {
12299 case 1500: hashes_buf[0].salt->salt_len = 2;
12300 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12301 break;
12302 case 1731: hashes_buf[0].salt->salt_len = 4;
12303 break;
12304 case 2410: hashes_buf[0].salt->salt_len = 4;
12305 break;
12306 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12307 break;
12308 case 3100: hashes_buf[0].salt->salt_len = 1;
12309 break;
12310 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
12311 break;
12312 case 5800: hashes_buf[0].salt->salt_len = 16;
12313 break;
12314 case 6800: hashes_buf[0].salt->salt_len = 32;
12315 break;
12316 case 8400: hashes_buf[0].salt->salt_len = 40;
12317 break;
12318 case 8800: hashes_buf[0].salt->salt_len = 16;
12319 break;
12320 case 8900: hashes_buf[0].salt->salt_len = 16;
12321 hashes_buf[0].salt->scrypt_N = 1024;
12322 hashes_buf[0].salt->scrypt_r = 1;
12323 hashes_buf[0].salt->scrypt_p = 1;
12324 break;
12325 case 9100: hashes_buf[0].salt->salt_len = 16;
12326 break;
12327 case 9300: hashes_buf[0].salt->salt_len = 14;
12328 hashes_buf[0].salt->scrypt_N = 16384;
12329 hashes_buf[0].salt->scrypt_r = 1;
12330 hashes_buf[0].salt->scrypt_p = 1;
12331 break;
12332 case 9400: hashes_buf[0].salt->salt_len = 16;
12333 break;
12334 case 9500: hashes_buf[0].salt->salt_len = 16;
12335 break;
12336 case 9600: hashes_buf[0].salt->salt_len = 16;
12337 break;
12338 case 9700: hashes_buf[0].salt->salt_len = 16;
12339 break;
12340 case 9710: hashes_buf[0].salt->salt_len = 16;
12341 break;
12342 case 9720: hashes_buf[0].salt->salt_len = 16;
12343 break;
12344 case 9800: hashes_buf[0].salt->salt_len = 16;
12345 break;
12346 case 9810: hashes_buf[0].salt->salt_len = 16;
12347 break;
12348 case 9820: hashes_buf[0].salt->salt_len = 16;
12349 break;
12350 case 10300: hashes_buf[0].salt->salt_len = 12;
12351 break;
12352 case 11500: hashes_buf[0].salt->salt_len = 4;
12353 break;
12354 case 11600: hashes_buf[0].salt->salt_len = 4;
12355 break;
12356 case 12400: hashes_buf[0].salt->salt_len = 4;
12357 break;
12358 case 12500: hashes_buf[0].salt->salt_len = 8;
12359 break;
12360 case 12600: hashes_buf[0].salt->salt_len = 64;
12361 break;
12362 }
12363
12364 // special esalt handling
12365
12366 switch (hash_mode)
12367 {
12368 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12369 break;
12370 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12371 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12372 break;
12373 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12374 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12375 break;
12376 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12377 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12378 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12379 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12380 break;
12381 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12382 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12383 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12384 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12385 break;
12386 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12387 break;
12388 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12389 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12390 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12391 break;
12392 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12393 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12394 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12395 break;
12396 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12397 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12398 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12399 break;
12400 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12401 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12402 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12403 break;
12404 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12405 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12406 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12407 break;
12408 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12409 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12410 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12411 break;
12412 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12413 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12414 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12415 break;
12416 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12417 break;
12418 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12419 break;
12420 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12421 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12422 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12423 break;
12424 }
12425 }
12426
12427 // set hashfile
12428
12429 switch (hash_mode)
12430 {
12431 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12432 break;
12433 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12434 break;
12435 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12436 break;
12437 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12438 break;
12439 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12440 break;
12441 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12442 break;
12443 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12444 break;
12445 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12446 break;
12447 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12448 break;
12449 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12450 break;
12451 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12452 break;
12453 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12454 break;
12455 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12456 break;
12457 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12458 break;
12459 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12460 break;
12461 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12462 break;
12463 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12464 break;
12465 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12466 break;
12467 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12468 break;
12469 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12470 break;
12471 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12472 break;
12473 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12474 break;
12475 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12476 break;
12477 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12478 break;
12479 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12480 break;
12481 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12482 break;
12483 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12484 break;
12485 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12486 break;
12487 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12488 break;
12489 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12490 break;
12491 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12492 break;
12493 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12494 break;
12495 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12496 break;
12497 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12498 break;
12499 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12500 break;
12501 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12502 break;
12503 }
12504
12505 // set default iterations
12506
12507 switch (hash_mode)
12508 {
12509 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12510 break;
12511 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12512 break;
12513 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12514 break;
12515 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12516 break;
12517 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12518 break;
12519 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12520 break;
12521 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12522 break;
12523 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12524 break;
12525 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12526 break;
12527 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12528 break;
12529 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12530 break;
12531 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12532 break;
12533 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12534 break;
12535 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12536 break;
12537 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12538 break;
12539 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12540 break;
12541 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12542 break;
12543 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12544 break;
12545 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12546 break;
12547 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12548 break;
12549 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12550 break;
12551 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12552 break;
12553 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12554 break;
12555 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12556 break;
12557 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12558 break;
12559 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12560 break;
12561 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12562 break;
12563 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12564 break;
12565 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12566 break;
12567 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12568 break;
12569 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12570 break;
12571 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12572 break;
12573 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12574 break;
12575 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12576 break;
12577 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12578 break;
12579 case 8900: hashes_buf[0].salt->salt_iter = 1;
12580 break;
12581 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12582 break;
12583 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12584 break;
12585 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12586 break;
12587 case 9300: hashes_buf[0].salt->salt_iter = 1;
12588 break;
12589 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12590 break;
12591 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12592 break;
12593 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12594 break;
12595 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12596 break;
12597 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12598 break;
12599 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12600 break;
12601 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12602 break;
12603 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12604 break;
12605 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12606 break;
12607 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12608 break;
12609 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12610 break;
12611 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12612 break;
12613 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12614 break;
12615 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12616 break;
12617 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12618 break;
12619 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12620 break;
12621 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12622 break;
12623 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12624 break;
12625 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12626 break;
12627 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12628 break;
12629 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12630 break;
12631 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12632 break;
12633 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12634 break;
12635 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12636 break;
12637 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12638 break;
12639 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12640 break;
12641 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12642 break;
12643 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12644 break;
12645 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12646 break;
12647 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12648 break;
12649 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12650 break;
12651 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12652 break;
12653 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12654 break;
12655 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12656 break;
12657 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12658 break;
12659 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12660 break;
12661 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12662 break;
12663 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12664 break;
12665 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12666 break;
12667 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12668 break;
12669 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12670 break;
12671 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12672 break;
12673 }
12674
12675 hashes_cnt = 1;
12676 }
12677
12678 if (show == 1 || left == 1)
12679 {
12680 for (uint i = 0; i < pot_cnt; i++)
12681 {
12682 pot_t *pot_ptr = &pot[i];
12683
12684 hash_t *hashes_buf = &pot_ptr->hash;
12685
12686 local_free (hashes_buf->digest);
12687
12688 if (isSalted)
12689 {
12690 local_free (hashes_buf->salt);
12691 }
12692 }
12693
12694 local_free (pot);
12695
12696 if (data.quiet == 0) log_info_nn ("");
12697
12698 return (0);
12699 }
12700
12701 if ((keyspace == 0) && (stdout_flag == 0))
12702 {
12703 if (hashes_cnt == 0)
12704 {
12705 log_error ("ERROR: No hashes loaded");
12706
12707 return (-1);
12708 }
12709 }
12710
12711 /**
12712 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12713 */
12714
12715 if (data.outfile != NULL)
12716 {
12717 if (data.hashfile != NULL)
12718 {
12719 #ifdef _POSIX
12720 struct stat tmpstat_outfile;
12721 struct stat tmpstat_hashfile;
12722 #endif
12723
12724 #ifdef _WIN
12725 struct stat64 tmpstat_outfile;
12726 struct stat64 tmpstat_hashfile;
12727 #endif
12728
12729 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12730
12731 if (tmp_outfile_fp)
12732 {
12733 #ifdef _POSIX
12734 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12735 #endif
12736
12737 #ifdef _WIN
12738 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12739 #endif
12740
12741 fclose (tmp_outfile_fp);
12742 }
12743
12744 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12745
12746 if (tmp_hashfile_fp)
12747 {
12748 #ifdef _POSIX
12749 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12750 #endif
12751
12752 #ifdef _WIN
12753 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12754 #endif
12755
12756 fclose (tmp_hashfile_fp);
12757 }
12758
12759 if (tmp_outfile_fp && tmp_outfile_fp)
12760 {
12761 tmpstat_outfile.st_mode = 0;
12762 tmpstat_outfile.st_nlink = 0;
12763 tmpstat_outfile.st_uid = 0;
12764 tmpstat_outfile.st_gid = 0;
12765 tmpstat_outfile.st_rdev = 0;
12766 tmpstat_outfile.st_atime = 0;
12767
12768 tmpstat_hashfile.st_mode = 0;
12769 tmpstat_hashfile.st_nlink = 0;
12770 tmpstat_hashfile.st_uid = 0;
12771 tmpstat_hashfile.st_gid = 0;
12772 tmpstat_hashfile.st_rdev = 0;
12773 tmpstat_hashfile.st_atime = 0;
12774
12775 #ifdef _POSIX
12776 tmpstat_outfile.st_blksize = 0;
12777 tmpstat_outfile.st_blocks = 0;
12778
12779 tmpstat_hashfile.st_blksize = 0;
12780 tmpstat_hashfile.st_blocks = 0;
12781 #endif
12782
12783 #ifdef _POSIX
12784 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12785 {
12786 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12787
12788 return (-1);
12789 }
12790 #endif
12791
12792 #ifdef _WIN
12793 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12794 {
12795 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12796
12797 return (-1);
12798 }
12799 #endif
12800 }
12801 }
12802 }
12803
12804 /**
12805 * Remove duplicates
12806 */
12807
12808 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12809
12810 if (isSalted)
12811 {
12812 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12813 }
12814 else
12815 {
12816 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12817 }
12818
12819 uint hashes_cnt_orig = hashes_cnt;
12820
12821 hashes_cnt = 1;
12822
12823 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12824 {
12825 if (isSalted)
12826 {
12827 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12828 {
12829 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12830 }
12831 }
12832 else
12833 {
12834 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12835 }
12836
12837 if (hashes_pos > hashes_cnt)
12838 {
12839 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12840 }
12841
12842 hashes_cnt++;
12843 }
12844
12845 /**
12846 * Potfile removes
12847 */
12848
12849 uint potfile_remove_cracks = 0;
12850
12851 if (potfile_disable == 0)
12852 {
12853 hash_t hash_buf;
12854
12855 hash_buf.digest = mymalloc (dgst_size);
12856 hash_buf.salt = NULL;
12857 hash_buf.esalt = NULL;
12858 hash_buf.hash_info = NULL;
12859 hash_buf.cracked = 0;
12860
12861 if (isSalted)
12862 {
12863 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12864 }
12865
12866 if (esalt_size)
12867 {
12868 hash_buf.esalt = mymalloc (esalt_size);
12869 }
12870
12871 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12872
12873 // no solution for these special hash types (for instane because they use hashfile in output etc)
12874 if ((hash_mode != 5200) &&
12875 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12876 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12877 (hash_mode != 9000))
12878 {
12879 FILE *fp = fopen (potfile, "rb");
12880
12881 if (fp != NULL)
12882 {
12883 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12884
12885 // to be safe work with a copy (because of line_len loop, i etc)
12886 // moved up here because it's easier to handle continue case
12887 // it's just 64kb
12888
12889 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12890
12891 while (!feof (fp))
12892 {
12893 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12894
12895 if (ptr == NULL) break;
12896
12897 int line_len = strlen (line_buf);
12898
12899 if (line_len == 0) continue;
12900
12901 int iter = MAX_CUT_TRIES;
12902
12903 for (int i = line_len - 1; i && iter; i--, line_len--)
12904 {
12905 if (line_buf[i] != ':') continue;
12906
12907 if (isSalted)
12908 {
12909 memset (hash_buf.salt, 0, sizeof (salt_t));
12910 }
12911
12912 hash_t *found = NULL;
12913
12914 if (hash_mode == 6800)
12915 {
12916 if (i < 64) // 64 = 16 * uint in salt_buf[]
12917 {
12918 // manipulate salt_buf
12919 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12920
12921 hash_buf.salt->salt_len = i;
12922
12923 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12924 }
12925 }
12926 else if (hash_mode == 2500)
12927 {
12928 if (i < 64) // 64 = 16 * uint in salt_buf[]
12929 {
12930 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12931 // manipulate salt_buf
12932
12933 memcpy (line_buf_cpy, line_buf, i);
12934
12935 char *mac2_pos = strrchr (line_buf_cpy, ':');
12936
12937 if (mac2_pos == NULL) continue;
12938
12939 mac2_pos[0] = 0;
12940 mac2_pos++;
12941
12942 if (strlen (mac2_pos) != 12) continue;
12943
12944 char *mac1_pos = strrchr (line_buf_cpy, ':');
12945
12946 if (mac1_pos == NULL) continue;
12947
12948 mac1_pos[0] = 0;
12949 mac1_pos++;
12950
12951 if (strlen (mac1_pos) != 12) continue;
12952
12953 uint essid_length = mac1_pos - line_buf_cpy - 1;
12954
12955 // here we need the ESSID
12956 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12957
12958 hash_buf.salt->salt_len = essid_length;
12959
12960 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12961
12962 if (found)
12963 {
12964 wpa_t *wpa = (wpa_t *) found->esalt;
12965
12966 // compare hex string(s) vs binary MAC address(es)
12967
12968 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12969 {
12970 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12971 {
12972 found = NULL;
12973
12974 break;
12975 }
12976 }
12977
12978 // early skip ;)
12979 if (!found) continue;
12980
12981 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12982 {
12983 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12984 {
12985 found = NULL;
12986
12987 break;
12988 }
12989 }
12990 }
12991 }
12992 }
12993 else
12994 {
12995 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12996
12997 if (parser_status == PARSER_OK)
12998 {
12999 if (isSalted)
13000 {
13001 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
13002 }
13003 else
13004 {
13005 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
13006 }
13007 }
13008 }
13009
13010 if (found == NULL) continue;
13011
13012 if (!found->cracked) potfile_remove_cracks++;
13013
13014 found->cracked = 1;
13015
13016 if (found) break;
13017
13018 iter--;
13019 }
13020 }
13021
13022 myfree (line_buf_cpy);
13023
13024 myfree (line_buf);
13025
13026 fclose (fp);
13027 }
13028 }
13029
13030 if (esalt_size)
13031 {
13032 local_free (hash_buf.esalt);
13033 }
13034
13035 if (isSalted)
13036 {
13037 local_free (hash_buf.salt);
13038 }
13039
13040 local_free (hash_buf.digest);
13041 }
13042
13043 /**
13044 * Now generate all the buffers required for later
13045 */
13046
13047 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
13048
13049 salt_t *salts_buf_new = NULL;
13050 void *esalts_buf_new = NULL;
13051
13052 if (isSalted)
13053 {
13054 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
13055
13056 if (esalt_size)
13057 {
13058 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
13059 }
13060 }
13061 else
13062 {
13063 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13064 }
13065
13066 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13067
13068 uint digests_cnt = hashes_cnt;
13069 uint digests_done = 0;
13070
13071 size_t size_digests = digests_cnt * dgst_size;
13072 size_t size_shown = digests_cnt * sizeof (uint);
13073
13074 uint *digests_shown = (uint *) mymalloc (size_shown);
13075 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13076
13077 uint salts_cnt = 0;
13078 uint salts_done = 0;
13079
13080 hashinfo_t **hash_info = NULL;
13081
13082 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13083 {
13084 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13085
13086 if (username && (remove || show))
13087 {
13088 uint user_pos;
13089
13090 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13091 {
13092 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13093
13094 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13095 }
13096 }
13097 }
13098
13099 uint *salts_shown = (uint *) mymalloc (size_shown);
13100
13101 salt_t *salt_buf;
13102
13103 {
13104 // copied from inner loop
13105
13106 salt_buf = &salts_buf_new[salts_cnt];
13107
13108 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13109
13110 if (esalt_size)
13111 {
13112 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13113 }
13114
13115 salt_buf->digests_cnt = 0;
13116 salt_buf->digests_done = 0;
13117 salt_buf->digests_offset = 0;
13118
13119 salts_cnt++;
13120 }
13121
13122 if (hashes_buf[0].cracked == 1)
13123 {
13124 digests_shown[0] = 1;
13125
13126 digests_done++;
13127
13128 salt_buf->digests_done++;
13129 }
13130
13131 salt_buf->digests_cnt++;
13132
13133 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13134
13135 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13136 {
13137 hash_info[0] = hashes_buf[0].hash_info;
13138 }
13139
13140 // copy from inner loop
13141
13142 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13143 {
13144 if (isSalted)
13145 {
13146 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13147 {
13148 salt_buf = &salts_buf_new[salts_cnt];
13149
13150 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13151
13152 if (esalt_size)
13153 {
13154 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13155 }
13156
13157 salt_buf->digests_cnt = 0;
13158 salt_buf->digests_done = 0;
13159 salt_buf->digests_offset = hashes_pos;
13160
13161 salts_cnt++;
13162 }
13163 }
13164
13165 if (hashes_buf[hashes_pos].cracked == 1)
13166 {
13167 digests_shown[hashes_pos] = 1;
13168
13169 digests_done++;
13170
13171 salt_buf->digests_done++;
13172 }
13173
13174 salt_buf->digests_cnt++;
13175
13176 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13177
13178 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13179 {
13180 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13181 }
13182 }
13183
13184 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13185 {
13186 salt_t *salt_buf = &salts_buf_new[salt_pos];
13187
13188 if (salt_buf->digests_done == salt_buf->digests_cnt)
13189 {
13190 salts_shown[salt_pos] = 1;
13191
13192 salts_done++;
13193 }
13194
13195 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13196 }
13197
13198 local_free (digests_buf);
13199 local_free (salts_buf);
13200 local_free (esalts_buf);
13201
13202 digests_buf = digests_buf_new;
13203 salts_buf = salts_buf_new;
13204 esalts_buf = esalts_buf_new;
13205
13206 local_free (hashes_buf);
13207
13208 /**
13209 * special modification not set from parser
13210 */
13211
13212 switch (hash_mode)
13213 {
13214 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13215 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13216 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13217 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13218 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13219 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13220 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13221 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13222 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13223 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13224 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13225 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13226 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13227 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13228 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13229 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13230 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13231 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13232 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13233 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13234 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13235 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13236 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13237 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13238 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13239 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13240 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13241 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13242 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13243 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13244 }
13245
13246 if (truecrypt_keyfiles)
13247 {
13248 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13249
13250 char *keyfiles = strdup (truecrypt_keyfiles);
13251
13252 char *keyfile = strtok (keyfiles, ",");
13253
13254 do
13255 {
13256 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13257
13258 } while ((keyfile = strtok (NULL, ",")) != NULL);
13259
13260 free (keyfiles);
13261 }
13262
13263 if (veracrypt_keyfiles)
13264 {
13265 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13266
13267 char *keyfiles = strdup (veracrypt_keyfiles);
13268
13269 char *keyfile = strtok (keyfiles, ",");
13270
13271 do
13272 {
13273 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13274
13275 } while ((keyfile = strtok (NULL, ",")) != NULL);
13276
13277 free (keyfiles);
13278 }
13279
13280 data.digests_cnt = digests_cnt;
13281 data.digests_done = digests_done;
13282 data.digests_buf = digests_buf;
13283 data.digests_shown = digests_shown;
13284 data.digests_shown_tmp = digests_shown_tmp;
13285
13286 data.salts_cnt = salts_cnt;
13287 data.salts_done = salts_done;
13288 data.salts_buf = salts_buf;
13289 data.salts_shown = salts_shown;
13290
13291 data.esalts_buf = esalts_buf;
13292 data.hash_info = hash_info;
13293
13294 /**
13295 * Automatic Optimizers
13296 */
13297
13298 if (salts_cnt == 1)
13299 opti_type |= OPTI_TYPE_SINGLE_SALT;
13300
13301 if (digests_cnt == 1)
13302 opti_type |= OPTI_TYPE_SINGLE_HASH;
13303
13304 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13305 opti_type |= OPTI_TYPE_NOT_ITERATED;
13306
13307 if (attack_mode == ATTACK_MODE_BF)
13308 opti_type |= OPTI_TYPE_BRUTE_FORCE;
13309
13310 data.opti_type = opti_type;
13311
13312 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13313 {
13314 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13315 {
13316 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13317 {
13318 if (opts_type & OPTS_TYPE_ST_ADD80)
13319 {
13320 opts_type &= ~OPTS_TYPE_ST_ADD80;
13321 opts_type |= OPTS_TYPE_PT_ADD80;
13322 }
13323
13324 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13325 {
13326 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13327 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13328 }
13329
13330 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13331 {
13332 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13333 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13334 }
13335 }
13336 }
13337 }
13338
13339 /**
13340 * Some algorithm, like descrypt, can benefit from JIT compilation
13341 */
13342
13343 int force_jit_compilation = -1;
13344
13345 if (hash_mode == 8900)
13346 {
13347 force_jit_compilation = 8900;
13348 }
13349 else if (hash_mode == 9300)
13350 {
13351 force_jit_compilation = 8900;
13352 }
13353 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13354 {
13355 force_jit_compilation = 1500;
13356 }
13357
13358 /**
13359 * generate bitmap tables
13360 */
13361
13362 const uint bitmap_shift1 = 5;
13363 const uint bitmap_shift2 = 13;
13364
13365 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13366
13367 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13368 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13369 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13370 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13371 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13372 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13373 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13374 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13375
13376 uint bitmap_bits;
13377 uint bitmap_nums;
13378 uint bitmap_mask;
13379 uint bitmap_size;
13380
13381 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13382 {
13383 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13384
13385 bitmap_nums = 1 << bitmap_bits;
13386
13387 bitmap_mask = bitmap_nums - 1;
13388
13389 bitmap_size = bitmap_nums * sizeof (uint);
13390
13391 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13392
13393 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;
13394 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;
13395
13396 break;
13397 }
13398
13399 bitmap_nums = 1 << bitmap_bits;
13400
13401 bitmap_mask = bitmap_nums - 1;
13402
13403 bitmap_size = bitmap_nums * sizeof (uint);
13404
13405 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);
13406 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);
13407
13408 /**
13409 * prepare quick rule
13410 */
13411
13412 data.rule_buf_l = rule_buf_l;
13413 data.rule_buf_r = rule_buf_r;
13414
13415 int rule_len_l = (int) strlen (rule_buf_l);
13416 int rule_len_r = (int) strlen (rule_buf_r);
13417
13418 data.rule_len_l = rule_len_l;
13419 data.rule_len_r = rule_len_r;
13420
13421 /**
13422 * load rules
13423 */
13424
13425 uint *all_kernel_rules_cnt = NULL;
13426
13427 kernel_rule_t **all_kernel_rules_buf = NULL;
13428
13429 if (rp_files_cnt)
13430 {
13431 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13432
13433 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13434 }
13435
13436 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13437
13438 int rule_len = 0;
13439
13440 for (uint i = 0; i < rp_files_cnt; i++)
13441 {
13442 uint kernel_rules_avail = 0;
13443
13444 uint kernel_rules_cnt = 0;
13445
13446 kernel_rule_t *kernel_rules_buf = NULL;
13447
13448 char *rp_file = rp_files[i];
13449
13450 char in[BLOCK_SIZE] = { 0 };
13451 char out[BLOCK_SIZE] = { 0 };
13452
13453 FILE *fp = NULL;
13454
13455 uint rule_line = 0;
13456
13457 if ((fp = fopen (rp_file, "rb")) == NULL)
13458 {
13459 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13460
13461 return (-1);
13462 }
13463
13464 while (!feof (fp))
13465 {
13466 memset (rule_buf, 0, HCBUFSIZ);
13467
13468 rule_len = fgetl (fp, rule_buf);
13469
13470 rule_line++;
13471
13472 if (rule_len == 0) continue;
13473
13474 if (rule_buf[0] == '#') continue;
13475
13476 if (kernel_rules_avail == kernel_rules_cnt)
13477 {
13478 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13479
13480 kernel_rules_avail += INCR_RULES;
13481 }
13482
13483 memset (in, 0, BLOCK_SIZE);
13484 memset (out, 0, BLOCK_SIZE);
13485
13486 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13487
13488 if (result == -1)
13489 {
13490 log_info ("WARNING: Skipping invalid or unsupported rule in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13491
13492 continue;
13493 }
13494
13495 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13496 {
13497 log_info ("WARNING: Cannot convert rule for use on device in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13498
13499 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13500
13501 continue;
13502 }
13503
13504 /* its so slow
13505 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13506 {
13507 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13508
13509 continue;
13510 }
13511 */
13512
13513 kernel_rules_cnt++;
13514 }
13515
13516 fclose (fp);
13517
13518 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13519
13520 all_kernel_rules_buf[i] = kernel_rules_buf;
13521 }
13522
13523 /**
13524 * merge rules or automatic rule generator
13525 */
13526
13527 uint kernel_rules_cnt = 0;
13528
13529 kernel_rule_t *kernel_rules_buf = NULL;
13530
13531 if (attack_mode == ATTACK_MODE_STRAIGHT)
13532 {
13533 if (rp_files_cnt)
13534 {
13535 kernel_rules_cnt = 1;
13536
13537 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13538
13539 repeats[0] = kernel_rules_cnt;
13540
13541 for (uint i = 0; i < rp_files_cnt; i++)
13542 {
13543 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13544
13545 repeats[i + 1] = kernel_rules_cnt;
13546 }
13547
13548 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13549
13550 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13551
13552 for (uint i = 0; i < kernel_rules_cnt; i++)
13553 {
13554 uint out_pos = 0;
13555
13556 kernel_rule_t *out = &kernel_rules_buf[i];
13557
13558 for (uint j = 0; j < rp_files_cnt; j++)
13559 {
13560 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13561 uint in_pos;
13562
13563 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13564
13565 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13566 {
13567 if (out_pos == RULES_MAX - 1)
13568 {
13569 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13570
13571 break;
13572 }
13573
13574 out->cmds[out_pos] = in->cmds[in_pos];
13575 }
13576 }
13577 }
13578
13579 local_free (repeats);
13580 }
13581 else if (rp_gen)
13582 {
13583 uint kernel_rules_avail = 0;
13584
13585 while (kernel_rules_cnt < rp_gen)
13586 {
13587 if (kernel_rules_avail == kernel_rules_cnt)
13588 {
13589 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13590
13591 kernel_rules_avail += INCR_RULES;
13592 }
13593
13594 memset (rule_buf, 0, HCBUFSIZ);
13595
13596 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13597
13598 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13599
13600 kernel_rules_cnt++;
13601 }
13602 }
13603 }
13604
13605 myfree (rule_buf);
13606
13607 /**
13608 * generate NOP rules
13609 */
13610
13611 if (kernel_rules_cnt == 0)
13612 {
13613 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13614
13615 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13616
13617 kernel_rules_cnt++;
13618 }
13619
13620 data.kernel_rules_cnt = kernel_rules_cnt;
13621 data.kernel_rules_buf = kernel_rules_buf;
13622
13623 /**
13624 * OpenCL platforms: detect
13625 */
13626
13627 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13628 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13629
13630 cl_uint platforms_cnt = 0;
13631 cl_uint platform_devices_cnt = 0;
13632
13633 if (keyspace == 0)
13634 {
13635 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13636
13637 if (platforms_cnt == 0)
13638 {
13639 log_info ("");
13640 log_info ("ATTENTION! No OpenCL compatible platform found");
13641 log_info ("");
13642 log_info ("You're probably missing the OpenCL runtime installation");
13643 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13644 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13645 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13646 log_info ("");
13647
13648 return (-1);
13649 }
13650
13651 if (opencl_platforms_filter != (uint) -1)
13652 {
13653 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13654
13655 if (opencl_platforms_filter > platform_cnt_mask)
13656 {
13657 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13658
13659 return (-1);
13660 }
13661 }
13662 }
13663
13664 if (opencl_device_types == NULL)
13665 {
13666 /**
13667 * OpenCL device types:
13668 * In case the user did not specify --opencl-device-types and the user runs hashcat in a system with only a CPU only he probably want to use that CPU.
13669 */
13670
13671 cl_device_type device_types_all = 0;
13672
13673 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13674 {
13675 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13676
13677 cl_platform_id platform = platforms[platform_id];
13678
13679 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13680
13681 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13682 {
13683 cl_device_id device = platform_devices[platform_devices_id];
13684
13685 cl_device_type device_type;
13686
13687 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13688
13689 device_types_all |= device_type;
13690 }
13691 }
13692
13693 // In such a case, automatically enable CPU device type support, since it's disabled by default.
13694
13695 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13696 {
13697 device_types_filter |= CL_DEVICE_TYPE_CPU;
13698 }
13699
13700 // In another case, when the user uses --stdout, using CPU devices is much faster to setup
13701 // If we have a CPU device, force it to be used
13702
13703 if (stdout_flag == 1)
13704 {
13705 if (device_types_all & CL_DEVICE_TYPE_CPU)
13706 {
13707 device_types_filter = CL_DEVICE_TYPE_CPU;
13708 }
13709 }
13710 }
13711
13712 /**
13713 * OpenCL devices: simply push all devices from all platforms into the same device array
13714 */
13715
13716 int need_adl = 0;
13717 int need_nvapi = 0;
13718 int need_nvml = 0;
13719 int need_xnvctrl = 0;
13720
13721 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13722
13723 data.devices_param = devices_param;
13724
13725 uint devices_cnt = 0;
13726
13727 uint devices_active = 0;
13728
13729 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13730 {
13731 cl_platform_id platform = platforms[platform_id];
13732
13733 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13734
13735 char platform_vendor[INFOSZ] = { 0 };
13736
13737 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13738
13739 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13740 // this causes trouble with vendor id based macros
13741 // we'll assign generic to those without special optimization available
13742
13743 cl_uint platform_vendor_id = 0;
13744
13745 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13746 {
13747 platform_vendor_id = VENDOR_ID_AMD;
13748 }
13749 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13750 {
13751 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13752 }
13753 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13754 {
13755 platform_vendor_id = VENDOR_ID_APPLE;
13756 }
13757 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13758 {
13759 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13760 }
13761 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13762 {
13763 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13764 }
13765 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13766 {
13767 platform_vendor_id = VENDOR_ID_MESA;
13768 }
13769 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13770 {
13771 platform_vendor_id = VENDOR_ID_NV;
13772 }
13773 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13774 {
13775 platform_vendor_id = VENDOR_ID_POCL;
13776 }
13777 else
13778 {
13779 platform_vendor_id = VENDOR_ID_GENERIC;
13780 }
13781
13782 const uint platform_skipped = ((opencl_platforms_filter & (1 << platform_id)) == 0);
13783
13784 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13785 {
13786 if (machine_readable == 0)
13787 {
13788 if (platform_skipped == 0)
13789 {
13790 const int len = log_info ("OpenCL Platform #%u: %s", platform_id + 1, platform_vendor);
13791
13792 char line[256] = { 0 };
13793
13794 for (int i = 0; i < len; i++) line[i] = '=';
13795
13796 log_info (line);
13797 }
13798 else
13799 {
13800 log_info ("OpenCL Platform #%u: %s, skipped", platform_id + 1, platform_vendor);
13801 log_info ("");
13802 }
13803 }
13804 }
13805
13806 if (platform_skipped == 1) continue;
13807
13808 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13809 {
13810 size_t param_value_size = 0;
13811
13812 const uint device_id = devices_cnt;
13813
13814 hc_device_param_t *device_param = &data.devices_param[device_id];
13815
13816 device_param->platform_vendor_id = platform_vendor_id;
13817
13818 device_param->device = platform_devices[platform_devices_id];
13819
13820 device_param->device_id = device_id;
13821
13822 device_param->platform_devices_id = platform_devices_id;
13823
13824 // device_type
13825
13826 cl_device_type device_type;
13827
13828 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13829
13830 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13831
13832 device_param->device_type = device_type;
13833
13834 // device_name
13835
13836 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13837
13838 char *device_name = (char *) mymalloc (param_value_size);
13839
13840 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13841
13842 device_param->device_name = device_name;
13843
13844 // device_vendor
13845
13846 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13847
13848 char *device_vendor = (char *) mymalloc (param_value_size);
13849
13850 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13851
13852 device_param->device_vendor = device_vendor;
13853
13854 cl_uint device_vendor_id = 0;
13855
13856 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13857 {
13858 device_vendor_id = VENDOR_ID_AMD;
13859 }
13860 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13861 {
13862 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13863 }
13864 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13865 {
13866 device_vendor_id = VENDOR_ID_APPLE;
13867 }
13868 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13869 {
13870 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13871 }
13872 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13873 {
13874 device_vendor_id = VENDOR_ID_INTEL_SDK;
13875 }
13876 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13877 {
13878 device_vendor_id = VENDOR_ID_MESA;
13879 }
13880 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13881 {
13882 device_vendor_id = VENDOR_ID_NV;
13883 }
13884 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13885 {
13886 device_vendor_id = VENDOR_ID_POCL;
13887 }
13888 else
13889 {
13890 device_vendor_id = VENDOR_ID_GENERIC;
13891 }
13892
13893 device_param->device_vendor_id = device_vendor_id;
13894
13895 // tuning db
13896
13897 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13898
13899 // device_version
13900
13901 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13902
13903 char *device_version = (char *) mymalloc (param_value_size);
13904
13905 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13906
13907 device_param->device_version = device_version;
13908
13909 // device_opencl_version
13910
13911 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13912
13913 char *device_opencl_version = (char *) mymalloc (param_value_size);
13914
13915 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13916
13917 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13918
13919 myfree (device_opencl_version);
13920
13921 // vector_width
13922
13923 cl_uint vector_width;
13924
13925 if (opencl_vector_width_chgd == 0)
13926 {
13927 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13928 {
13929 if (opti_type & OPTI_TYPE_USES_BITS_64)
13930 {
13931 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13932 }
13933 else
13934 {
13935 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13936 }
13937 }
13938 else
13939 {
13940 vector_width = (cl_uint) tuningdb_entry->vector_width;
13941 }
13942 }
13943 else
13944 {
13945 vector_width = opencl_vector_width;
13946 }
13947
13948 if (vector_width > 16) vector_width = 16;
13949
13950 device_param->vector_width = vector_width;
13951
13952 // max_compute_units
13953
13954 cl_uint device_processors;
13955
13956 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13957
13958 device_param->device_processors = device_processors;
13959
13960 // device_maxmem_alloc
13961 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13962
13963 cl_ulong device_maxmem_alloc;
13964
13965 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13966
13967 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13968
13969 // device_global_mem
13970
13971 cl_ulong device_global_mem;
13972
13973 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13974
13975 device_param->device_global_mem = device_global_mem;
13976
13977 // max_work_group_size
13978
13979 size_t device_maxworkgroup_size;
13980
13981 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13982
13983 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13984
13985 // max_clock_frequency
13986
13987 cl_uint device_maxclock_frequency;
13988
13989 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13990
13991 device_param->device_maxclock_frequency = device_maxclock_frequency;
13992
13993 // device_endian_little
13994
13995 cl_bool device_endian_little;
13996
13997 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13998
13999 if (device_endian_little == CL_FALSE)
14000 {
14001 log_info ("- Device #%u: WARNING: Not a little endian device", device_id + 1);
14002
14003 device_param->skipped = 1;
14004 }
14005
14006 // device_available
14007
14008 cl_bool device_available;
14009
14010 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
14011
14012 if (device_available == CL_FALSE)
14013 {
14014 log_info ("- Device #%u: WARNING: Device not available", device_id + 1);
14015
14016 device_param->skipped = 1;
14017 }
14018
14019 // device_compiler_available
14020
14021 cl_bool device_compiler_available;
14022
14023 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
14024
14025 if (device_compiler_available == CL_FALSE)
14026 {
14027 log_info ("- Device #%u: WARNING: No compiler available for device", device_id + 1);
14028
14029 device_param->skipped = 1;
14030 }
14031
14032 // device_execution_capabilities
14033
14034 cl_device_exec_capabilities device_execution_capabilities;
14035
14036 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
14037
14038 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
14039 {
14040 log_info ("- Device #%u: WARNING: Device does not support executing kernels", device_id + 1);
14041
14042 device_param->skipped = 1;
14043 }
14044
14045 // device_extensions
14046
14047 size_t device_extensions_size;
14048
14049 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
14050
14051 char *device_extensions = mymalloc (device_extensions_size + 1);
14052
14053 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
14054
14055 if (strstr (device_extensions, "base_atomics") == 0)
14056 {
14057 log_info ("- Device #%u: WARNING: Device does not support base atomics", device_id + 1);
14058
14059 device_param->skipped = 1;
14060 }
14061
14062 if (strstr (device_extensions, "byte_addressable_store") == 0)
14063 {
14064 log_info ("- Device #%u: WARNING: Device does not support byte addressable store", device_id + 1);
14065
14066 device_param->skipped = 1;
14067 }
14068
14069 myfree (device_extensions);
14070
14071 // device_local_mem_size
14072
14073 cl_ulong device_local_mem_size;
14074
14075 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
14076
14077 if (device_local_mem_size < 32768)
14078 {
14079 log_info ("- Device #%u: WARNING: Device local mem size is too small", device_id + 1);
14080
14081 device_param->skipped = 1;
14082 }
14083
14084 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
14085 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
14086 // This results in both utilizing it for 50%
14087 // However, Intel has much better SIMD control over their own hardware
14088 // It makes sense to give them full control over their own hardware
14089
14090 if (device_type & CL_DEVICE_TYPE_CPU)
14091 {
14092 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14093 {
14094 if (data.force == 0)
14095 {
14096 if (algorithm_pos == 0)
14097 {
14098 log_info ("- Device #%u: WARNING: Not a native Intel OpenCL runtime, expect massive speed loss", device_id + 1);
14099 log_info (" You can use --force to override this but do not post error reports if you do so");
14100 }
14101
14102 device_param->skipped = 1;
14103 }
14104 }
14105 }
14106
14107 // skipped
14108
14109 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14110 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14111
14112 // driver_version
14113
14114 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14115
14116 char *driver_version = (char *) mymalloc (param_value_size);
14117
14118 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14119
14120 device_param->driver_version = driver_version;
14121
14122 // device_name_chksum
14123
14124 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14125
14126 #if __x86_64__
14127 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 64, device_param->platform_vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
14128 #else
14129 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 32, device_param->platform_vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
14130 #endif
14131
14132 uint device_name_digest[4] = { 0 };
14133
14134 md5_64 ((uint *) device_name_chksum, device_name_digest);
14135
14136 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14137
14138 device_param->device_name_chksum = device_name_chksum;
14139
14140 // device_processor_cores
14141
14142 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14143 {
14144 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14145 {
14146 need_adl = 1;
14147 }
14148
14149 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14150 {
14151 need_nvml = 1;
14152
14153 #ifdef LINUX
14154 need_xnvctrl = 1;
14155 #endif
14156
14157 #ifdef WIN
14158 need_nvapi = 1;
14159 #endif
14160 }
14161 }
14162
14163 // device_processor_cores
14164
14165 if (device_type & CL_DEVICE_TYPE_CPU)
14166 {
14167 cl_uint device_processor_cores = 1;
14168
14169 device_param->device_processor_cores = device_processor_cores;
14170 }
14171
14172 if (device_type & CL_DEVICE_TYPE_GPU)
14173 {
14174 if (device_vendor_id == VENDOR_ID_AMD)
14175 {
14176 cl_uint device_processor_cores = 0;
14177
14178 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
14179
14180 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
14181
14182 device_param->device_processor_cores = device_processor_cores;
14183 }
14184 else if (device_vendor_id == VENDOR_ID_NV)
14185 {
14186 cl_uint kernel_exec_timeout = 0;
14187
14188 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14189
14190 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14191
14192 device_param->kernel_exec_timeout = kernel_exec_timeout;
14193
14194 cl_uint device_processor_cores = 0;
14195
14196 #define CL_DEVICE_WARP_SIZE_NV 0x4003
14197
14198 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
14199
14200 device_param->device_processor_cores = device_processor_cores;
14201
14202 cl_uint sm_minor = 0;
14203 cl_uint sm_major = 0;
14204
14205 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14206 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14207
14208 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14209 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14210
14211 device_param->sm_minor = sm_minor;
14212 device_param->sm_major = sm_major;
14213
14214 // CPU burning loop damper
14215 // Value is given as number between 0-100
14216 // By default 100%
14217
14218 device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14219
14220 if (nvidia_spin_damp_chgd == 0)
14221 {
14222 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14223 {
14224 /**
14225 * the workaround is not a friend of rule based attacks
14226 * the words from the wordlist combined with fast and slow rules cause
14227 * fluctuations which cause inaccurate wait time estimations
14228 * using a reduced damping percentage almost compensates this
14229 */
14230
14231 device_param->nvidia_spin_damp = 64;
14232 }
14233 }
14234
14235 device_param->nvidia_spin_damp /= 100;
14236 }
14237 else
14238 {
14239 cl_uint device_processor_cores = 1;
14240
14241 device_param->device_processor_cores = device_processor_cores;
14242 }
14243 }
14244
14245 // display results
14246
14247 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14248 {
14249 if (machine_readable == 0)
14250 {
14251 if (device_param->skipped == 0)
14252 {
14253 log_info ("- Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14254 device_id + 1,
14255 device_name,
14256 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14257 (unsigned int) (device_global_mem / 1024 / 1024),
14258 (unsigned int) device_processors);
14259 }
14260 else
14261 {
14262 log_info ("- Device #%u: %s, skipped",
14263 device_id + 1,
14264 device_name);
14265 }
14266 }
14267 }
14268
14269 // common driver check
14270
14271 if (device_param->skipped == 0)
14272 {
14273 if (device_type & CL_DEVICE_TYPE_GPU)
14274 {
14275 if (platform_vendor_id == VENDOR_ID_AMD)
14276 {
14277 int catalyst_check = (force == 1) ? 0 : 1;
14278
14279 int catalyst_warn = 0;
14280
14281 int catalyst_broken = 0;
14282
14283 if (catalyst_check == 1)
14284 {
14285 catalyst_warn = 1;
14286
14287 // v14.9 and higher
14288 if (atoi (device_param->driver_version) >= 1573)
14289 {
14290 catalyst_warn = 0;
14291 }
14292
14293 catalyst_check = 0;
14294 }
14295
14296 if (catalyst_broken == 1)
14297 {
14298 log_info ("");
14299 log_info ("ATTENTION! The Catalyst driver installed on your system is known to be broken!");
14300 log_info ("It passes over cracked hashes and will not report them as cracked");
14301 log_info ("You are STRONGLY encouraged not to use it");
14302 log_info ("You can use --force to override this but do not post error reports if you do so");
14303 log_info ("");
14304
14305 return (-1);
14306 }
14307
14308 if (catalyst_warn == 1)
14309 {
14310 log_info ("");
14311 log_info ("ATTENTION! Unsupported or incorrectly installed Catalyst driver detected!");
14312 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver");
14313 log_info ("See hashcat's homepage for official supported catalyst drivers");
14314 #ifdef _WIN
14315 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14316 #endif
14317 log_info ("You can use --force to override this but do not post error reports if you do so");
14318 log_info ("");
14319
14320 return (-1);
14321 }
14322 }
14323 else if (platform_vendor_id == VENDOR_ID_NV)
14324 {
14325 if (device_param->kernel_exec_timeout != 0)
14326 {
14327 if (data.quiet == 0) log_info ("- Device #%u: WARNING! Kernel exec timeout is not disabled, it might cause you errors of code 702", device_id + 1);
14328 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14329 }
14330 }
14331 }
14332
14333 /* turns out pocl still creates segfaults (because of llvm)
14334 if (device_type & CL_DEVICE_TYPE_CPU)
14335 {
14336 if (platform_vendor_id == VENDOR_ID_AMD)
14337 {
14338 if (force == 0)
14339 {
14340 log_info ("");
14341 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14342 log_info ("You are STRONGLY encouraged not to use it");
14343 log_info ("You can use --force to override this but do not post error reports if you do so");
14344 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14345 log_info ("");
14346
14347 return (-1);
14348 }
14349 }
14350 }
14351 */
14352
14353 /**
14354 * kernel accel and loops tuning db adjustment
14355 */
14356
14357 device_param->kernel_accel_min = 1;
14358 device_param->kernel_accel_max = 1024;
14359
14360 device_param->kernel_loops_min = 1;
14361 device_param->kernel_loops_max = 1024;
14362
14363 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14364
14365 if (tuningdb_entry)
14366 {
14367 u32 _kernel_accel = tuningdb_entry->kernel_accel;
14368 u32 _kernel_loops = tuningdb_entry->kernel_loops;
14369
14370 if (_kernel_accel)
14371 {
14372 device_param->kernel_accel_min = _kernel_accel;
14373 device_param->kernel_accel_max = _kernel_accel;
14374 }
14375
14376 if (_kernel_loops)
14377 {
14378 if (workload_profile == 1)
14379 {
14380 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14381 }
14382 else if (workload_profile == 2)
14383 {
14384 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14385 }
14386
14387 device_param->kernel_loops_min = _kernel_loops;
14388 device_param->kernel_loops_max = _kernel_loops;
14389 }
14390 }
14391
14392 // commandline parameters overwrite tuningdb entries
14393
14394 if (kernel_accel)
14395 {
14396 device_param->kernel_accel_min = kernel_accel;
14397 device_param->kernel_accel_max = kernel_accel;
14398 }
14399
14400 if (kernel_loops)
14401 {
14402 device_param->kernel_loops_min = kernel_loops;
14403 device_param->kernel_loops_max = kernel_loops;
14404 }
14405
14406 /**
14407 * activate device
14408 */
14409
14410 devices_active++;
14411 }
14412
14413 // next please
14414
14415 devices_cnt++;
14416 }
14417
14418 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14419 {
14420 if (machine_readable == 0)
14421 {
14422 log_info ("");
14423 }
14424 }
14425 }
14426
14427 if (keyspace == 0 && devices_active == 0)
14428 {
14429 log_error ("ERROR: No devices found/left");
14430
14431 return (-1);
14432 }
14433
14434 // additional check to see if the user has chosen a device that is not within the range of available devices (i.e. larger than devices_cnt)
14435
14436 if (devices_filter != (uint) -1)
14437 {
14438 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14439
14440 if (devices_filter > devices_cnt_mask)
14441 {
14442 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14443
14444 return (-1);
14445 }
14446 }
14447
14448 data.devices_cnt = devices_cnt;
14449
14450 data.devices_active = devices_active;
14451
14452 /**
14453 * HM devices: init
14454 */
14455
14456 #ifdef HAVE_HWMON
14457 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14458 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14459 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14460 hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX] = { { 0 } };
14461
14462 if (gpu_temp_disable == 0)
14463 {
14464 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14465 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14466 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14467 XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));
14468
14469 data.hm_adl = NULL;
14470 data.hm_nvapi = NULL;
14471 data.hm_nvml = NULL;
14472 data.hm_xnvctrl = NULL;
14473
14474 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14475 {
14476 data.hm_nvml = nvml;
14477 }
14478
14479 if (data.hm_nvml)
14480 {
14481 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14482 {
14483 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14484
14485 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14486
14487 int tmp_out = 0;
14488
14489 for (int i = 0; i < tmp_in; i++)
14490 {
14491 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14492 }
14493
14494 for (int i = 0; i < tmp_out; i++)
14495 {
14496 unsigned int speed;
14497
14498 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14499
14500 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14501
14502 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14503 }
14504 }
14505 }
14506
14507 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14508 {
14509 data.hm_nvapi = nvapi;
14510 }
14511
14512 if (data.hm_nvapi)
14513 {
14514 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14515 {
14516 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14517
14518 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14519
14520 int tmp_out = 0;
14521
14522 for (int i = 0; i < tmp_in; i++)
14523 {
14524 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14525 }
14526 }
14527 }
14528
14529 if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0))
14530 {
14531 data.hm_xnvctrl = xnvctrl;
14532 }
14533
14534 if (data.hm_xnvctrl)
14535 {
14536 if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
14537 {
14538 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14539 {
14540 hc_device_param_t *device_param = &data.devices_param[device_id];
14541
14542 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14543
14544 hm_adapters_xnvctrl[device_id].xnvctrl = device_id;
14545
14546 int speed = 0;
14547
14548 if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
14549 }
14550 }
14551 }
14552
14553 if ((need_adl == 1) && (adl_init (adl) == 0))
14554 {
14555 data.hm_adl = adl;
14556 }
14557
14558 if (data.hm_adl)
14559 {
14560 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14561 {
14562 // total number of adapters
14563
14564 int hm_adapters_num;
14565
14566 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14567
14568 // adapter info
14569
14570 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14571
14572 if (lpAdapterInfo == NULL) return (-1);
14573
14574 // get a list (of ids of) valid/usable adapters
14575
14576 int num_adl_adapters = 0;
14577
14578 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14579
14580 if (num_adl_adapters > 0)
14581 {
14582 hc_thread_mutex_lock (mux_adl);
14583
14584 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14585
14586 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14587
14588 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14589 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14590
14591 hc_thread_mutex_unlock (mux_adl);
14592 }
14593
14594 myfree (valid_adl_device_list);
14595 myfree (lpAdapterInfo);
14596 }
14597 }
14598
14599 if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14600 {
14601 gpu_temp_disable = 1;
14602 }
14603 }
14604
14605 /**
14606 * OpenCL devices: allocate buffer for device specific information
14607 */
14608
14609 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14610 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14611
14612 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14613
14614 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14615
14616 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14617
14618 /**
14619 * User-defined GPU temp handling
14620 */
14621
14622 if (gpu_temp_disable == 1)
14623 {
14624 gpu_temp_abort = 0;
14625 gpu_temp_retain = 0;
14626 }
14627
14628 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14629 {
14630 if (gpu_temp_abort < gpu_temp_retain)
14631 {
14632 log_error ("ERROR: Invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14633
14634 return (-1);
14635 }
14636 }
14637
14638 data.gpu_temp_disable = gpu_temp_disable;
14639 data.gpu_temp_abort = gpu_temp_abort;
14640 data.gpu_temp_retain = gpu_temp_retain;
14641 #endif
14642
14643 /**
14644 * enable custom signal handler(s)
14645 */
14646
14647 if (benchmark == 0)
14648 {
14649 hc_signal (sigHandler_default);
14650 }
14651 else
14652 {
14653 hc_signal (sigHandler_benchmark);
14654 }
14655
14656 /**
14657 * inform the user
14658 */
14659
14660 if (data.quiet == 0)
14661 {
14662 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14663
14664 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);
14665
14666 if (attack_mode == ATTACK_MODE_STRAIGHT)
14667 {
14668 log_info ("Rules: %u", kernel_rules_cnt);
14669 }
14670
14671 if (opti_type)
14672 {
14673 log_info ("Applicable Optimizers:");
14674
14675 for (uint i = 0; i < 32; i++)
14676 {
14677 const uint opti_bit = 1u << i;
14678
14679 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14680 }
14681 }
14682
14683 /**
14684 * Watchdog and Temperature balance
14685 */
14686
14687 #ifdef HAVE_HWMON
14688 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14689 {
14690 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14691 }
14692
14693 if (gpu_temp_abort == 0)
14694 {
14695 log_info ("Watchdog: Temperature abort trigger disabled");
14696 }
14697 else
14698 {
14699 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14700 }
14701
14702 if (gpu_temp_retain == 0)
14703 {
14704 log_info ("Watchdog: Temperature retain trigger disabled");
14705 }
14706 else
14707 {
14708 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14709 }
14710
14711 if (data.quiet == 0) log_info ("");
14712 #endif
14713 }
14714
14715 #ifdef HAVE_HWMON
14716
14717 /**
14718 * HM devices: copy
14719 */
14720
14721 if (gpu_temp_disable == 0)
14722 {
14723 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14724 {
14725 hc_device_param_t *device_param = &data.devices_param[device_id];
14726
14727 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14728
14729 if (device_param->skipped) continue;
14730
14731 const uint platform_devices_id = device_param->platform_devices_id;
14732
14733 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14734 {
14735 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14736 data.hm_device[device_id].nvapi = 0;
14737 data.hm_device[device_id].nvml = 0;
14738 data.hm_device[device_id].xnvctrl = 0;
14739 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14740 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14741 data.hm_device[device_id].fan_set_supported = 0;
14742 }
14743
14744 if (device_param->device_vendor_id == VENDOR_ID_NV)
14745 {
14746 data.hm_device[device_id].adl = 0;
14747 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14748 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14749 data.hm_device[device_id].xnvctrl = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
14750 data.hm_device[device_id].od_version = 0;
14751 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14752 data.hm_device[device_id].fan_set_supported = 0;
14753 }
14754 }
14755 }
14756
14757 /**
14758 * powertune on user request
14759 */
14760
14761 if (powertune_enable == 1)
14762 {
14763 hc_thread_mutex_lock (mux_adl);
14764
14765 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14766 {
14767 hc_device_param_t *device_param = &data.devices_param[device_id];
14768
14769 if (device_param->skipped) continue;
14770
14771 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14772 {
14773 /**
14774 * Temporary fix:
14775 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14776 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14777 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14778 * Driver / ADL bug?
14779 */
14780
14781 if (data.hm_device[device_id].od_version == 6)
14782 {
14783 int ADL_rc;
14784
14785 // check powertune capabilities first, if not available then skip device
14786
14787 int powertune_supported = 0;
14788
14789 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14790 {
14791 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14792
14793 return (-1);
14794 }
14795
14796 // first backup current value, we will restore it later
14797
14798 if (powertune_supported != 0)
14799 {
14800 // powercontrol settings
14801
14802 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14803
14804 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14805 {
14806 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14807 }
14808
14809 if (ADL_rc != ADL_OK)
14810 {
14811 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14812
14813 return (-1);
14814 }
14815
14816 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14817 {
14818 log_error ("ERROR: Failed to set new ADL PowerControl values");
14819
14820 return (-1);
14821 }
14822
14823 // clocks
14824
14825 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14826
14827 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14828
14829 if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
14830 {
14831 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14832
14833 return (-1);
14834 }
14835
14836 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14837
14838 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14839
14840 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14841 {
14842 log_error ("ERROR: Failed to get ADL device capabilities");
14843
14844 return (-1);
14845 }
14846
14847 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14848 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14849
14850 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14851 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14852
14853 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14854 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14855
14856 // warning if profile has too low max values
14857
14858 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14859 {
14860 log_info ("WARN: The custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14861 }
14862
14863 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14864 {
14865 log_info ("WARN: The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14866 }
14867
14868 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14869
14870 performance_state->iNumberOfPerformanceLevels = 2;
14871
14872 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14873 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14874 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14875 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14876
14877 if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
14878 {
14879 log_info ("ERROR: Failed to set ADL performance state");
14880
14881 return (-1);
14882 }
14883
14884 local_free (performance_state);
14885 }
14886
14887 // set powertune value only
14888
14889 if (powertune_supported != 0)
14890 {
14891 // powertune set
14892 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14893
14894 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14895 {
14896 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14897
14898 return (-1);
14899 }
14900
14901 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14902 {
14903 log_error ("ERROR: Failed to set new ADL PowerControl values");
14904
14905 return (-1);
14906 }
14907 }
14908 }
14909 }
14910
14911 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14912 {
14913 // first backup current value, we will restore it later
14914
14915 unsigned int limit;
14916
14917 int powertune_supported = 0;
14918
14919 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14920 {
14921 powertune_supported = 1;
14922 }
14923
14924 // if backup worked, activate the maximum allowed
14925
14926 if (powertune_supported != 0)
14927 {
14928 unsigned int minLimit;
14929 unsigned int maxLimit;
14930
14931 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14932 {
14933 if (maxLimit > 0)
14934 {
14935 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14936 {
14937 // now we can be sure we need to reset later
14938
14939 nvml_power_limit[device_id] = limit;
14940 }
14941 }
14942 }
14943 }
14944 }
14945 }
14946
14947 hc_thread_mutex_unlock (mux_adl);
14948 }
14949
14950 #endif // HAVE_HWMON
14951
14952 #ifdef DEBUG
14953 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14954 #endif
14955
14956 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14957
14958 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14959 {
14960 /**
14961 * host buffer
14962 */
14963
14964 hc_device_param_t *device_param = &data.devices_param[device_id];
14965
14966 if (device_param->skipped) continue;
14967
14968 /**
14969 * device properties
14970 */
14971
14972 const char *device_name_chksum = device_param->device_name_chksum;
14973 const u32 device_processors = device_param->device_processors;
14974 const u32 device_processor_cores = device_param->device_processor_cores;
14975
14976 /**
14977 * create context for each device
14978 */
14979
14980 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14981
14982 /**
14983 * create command-queue
14984 */
14985
14986 // not supported with NV
14987 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14988
14989 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14990
14991 /**
14992 * kernel threads: some algorithms need a fixed kernel-threads count
14993 * because of shared memory usage or bitslice
14994 * there needs to be some upper limit, otherwise there's too much overhead
14995 */
14996
14997 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14998
14999 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
15000 {
15001 kernel_threads = KERNEL_THREADS_MAX_CPU;
15002 }
15003
15004 if (hash_mode == 1500) kernel_threads = 64; // DES
15005 if (hash_mode == 3000) kernel_threads = 64; // DES
15006 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
15007 if (hash_mode == 7500) kernel_threads = 64; // RC4
15008 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
15009 if (hash_mode == 9700) kernel_threads = 64; // RC4
15010 if (hash_mode == 9710) kernel_threads = 64; // RC4
15011 if (hash_mode == 9800) kernel_threads = 64; // RC4
15012 if (hash_mode == 9810) kernel_threads = 64; // RC4
15013 if (hash_mode == 10400) kernel_threads = 64; // RC4
15014 if (hash_mode == 10410) kernel_threads = 64; // RC4
15015 if (hash_mode == 10500) kernel_threads = 64; // RC4
15016 if (hash_mode == 13100) kernel_threads = 64; // RC4
15017
15018 device_param->kernel_threads = kernel_threads;
15019
15020 device_param->hardware_power = device_processors * kernel_threads;
15021
15022 /**
15023 * create input buffers on device : calculate size of fixed memory buffers
15024 */
15025
15026 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
15027 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
15028
15029 device_param->size_root_css = size_root_css;
15030 device_param->size_markov_css = size_markov_css;
15031
15032 size_t size_results = sizeof (uint);
15033
15034 device_param->size_results = size_results;
15035
15036 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
15037 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
15038
15039 size_t size_plains = digests_cnt * sizeof (plain_t);
15040 size_t size_salts = salts_cnt * sizeof (salt_t);
15041 size_t size_esalts = salts_cnt * esalt_size;
15042
15043 device_param->size_plains = size_plains;
15044 device_param->size_digests = size_digests;
15045 device_param->size_shown = size_shown;
15046 device_param->size_salts = size_salts;
15047
15048 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
15049 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
15050 size_t size_tm = 32 * sizeof (bs_word_t);
15051
15052 // scryptV stuff
15053
15054 size_t size_scryptV = 1;
15055
15056 if ((hash_mode == 8900) || (hash_mode == 9300))
15057 {
15058 uint tmto_start = 0;
15059 uint tmto_stop = 10;
15060
15061 if (scrypt_tmto)
15062 {
15063 tmto_start = scrypt_tmto;
15064 }
15065 else
15066 {
15067 // in case the user did not specify the tmto manually
15068 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
15069 // but set the lower end only in case the user has a device with too less memory
15070
15071 if (hash_mode == 8900)
15072 {
15073 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15074 {
15075 tmto_start = 1;
15076 }
15077 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15078 {
15079 tmto_start = 2;
15080 }
15081 }
15082 else if (hash_mode == 9300)
15083 {
15084 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15085 {
15086 tmto_start = 2;
15087 }
15088 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15089 {
15090 tmto_start = 2;
15091 }
15092 }
15093 }
15094
15095 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
15096 {
15097 // TODO: in theory the following calculation needs to be done per salt, not global
15098 // we assume all hashes have the same scrypt settings
15099
15100 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
15101
15102 size_scryptV /= 1 << tmto;
15103
15104 size_scryptV *= device_processors * device_processor_cores;
15105
15106 if (size_scryptV > device_param->device_maxmem_alloc)
15107 {
15108 if (quiet == 0) log_info ("WARNING: Not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15109
15110 continue;
15111 }
15112
15113 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
15114 {
15115 data.salts_buf[salts_pos].scrypt_tmto = tmto;
15116 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
15117 }
15118
15119 break;
15120 }
15121
15122 if (data.salts_buf[0].scrypt_phy == 0)
15123 {
15124 log_error ("ERROR: Can't allocate enough device memory");
15125
15126 return -1;
15127 }
15128
15129 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
15130 }
15131
15132 /**
15133 * some algorithms need a fixed kernel-loops count
15134 */
15135
15136 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15137 {
15138 const u32 kernel_loops_fixed = 1024;
15139
15140 device_param->kernel_loops_min = kernel_loops_fixed;
15141 device_param->kernel_loops_max = kernel_loops_fixed;
15142 }
15143
15144 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15145 {
15146 const u32 kernel_loops_fixed = 1024;
15147
15148 device_param->kernel_loops_min = kernel_loops_fixed;
15149 device_param->kernel_loops_max = kernel_loops_fixed;
15150 }
15151
15152 if (hash_mode == 8900)
15153 {
15154 const u32 kernel_loops_fixed = 1;
15155
15156 device_param->kernel_loops_min = kernel_loops_fixed;
15157 device_param->kernel_loops_max = kernel_loops_fixed;
15158 }
15159
15160 if (hash_mode == 9300)
15161 {
15162 const u32 kernel_loops_fixed = 1;
15163
15164 device_param->kernel_loops_min = kernel_loops_fixed;
15165 device_param->kernel_loops_max = kernel_loops_fixed;
15166 }
15167
15168 if (hash_mode == 12500)
15169 {
15170 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15171
15172 device_param->kernel_loops_min = kernel_loops_fixed;
15173 device_param->kernel_loops_max = kernel_loops_fixed;
15174 }
15175
15176 /**
15177 * some algorithms have a maximum kernel-loops count
15178 */
15179
15180 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15181 {
15182 u32 innerloop_cnt = 0;
15183
15184 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15185 {
15186 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15187 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15188 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15189 }
15190 else
15191 {
15192 innerloop_cnt = data.salts_buf[0].salt_iter;
15193 }
15194
15195 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15196 (innerloop_cnt <= device_param->kernel_loops_max))
15197 {
15198 device_param->kernel_loops_max = innerloop_cnt;
15199 }
15200 }
15201
15202 u32 kernel_accel_min = device_param->kernel_accel_min;
15203 u32 kernel_accel_max = device_param->kernel_accel_max;
15204
15205 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15206
15207 size_t size_pws = 4;
15208 size_t size_tmps = 4;
15209 size_t size_hooks = 4;
15210
15211 while (kernel_accel_max >= kernel_accel_min)
15212 {
15213 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15214
15215 // size_pws
15216
15217 size_pws = kernel_power_max * sizeof (pw_t);
15218
15219 // size_tmps
15220
15221 switch (hash_mode)
15222 {
15223 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15224 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15225 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15226 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15227 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15228 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15229 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15230 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15231 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15232 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15233 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15234 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15235 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15236 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15237 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15238 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15239 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15240 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15241 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15242 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15243 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15244 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15245 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15246 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
15247 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
15248 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
15249 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
15250 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
15251 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15252 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15253 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
15254 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
15255 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15256 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
15257 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15258 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
15259 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
15260 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15261 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15262 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
15263 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
15264 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
15265 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15266 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
15267 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
15268 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
15269 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
15270 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15271 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
15272 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
15273 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
15274 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15275 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15276 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
15277 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
15278 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
15279 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
15280 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
15281 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15282 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15283 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15284 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
15285 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
15286 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15287 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15288 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15289 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15290 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15291 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15292 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15293 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15294 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15295 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15296 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15297 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15298 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15299 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15300 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15301 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15302 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15303 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15304 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15305 };
15306
15307 // size_hooks
15308
15309 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15310 {
15311 switch (hash_mode)
15312 {
15313 }
15314 }
15315
15316 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15317 // if not, decrease amplifier and try again
15318
15319 int memory_limit_hit = 0;
15320
15321 if (size_pws > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15322 if (size_tmps > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15323 if (size_hooks > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15324
15325 const u64 size_total
15326 = bitmap_size
15327 + bitmap_size
15328 + bitmap_size
15329 + bitmap_size
15330 + bitmap_size
15331 + bitmap_size
15332 + bitmap_size
15333 + bitmap_size
15334 + size_bfs
15335 + size_combs
15336 + size_digests
15337 + size_esalts
15338 + size_hooks
15339 + size_markov_css
15340 + size_plains
15341 + size_pws
15342 + size_pws // not a bug
15343 + size_results
15344 + size_root_css
15345 + size_rules
15346 + size_rules_c
15347 + size_salts
15348 + size_scryptV
15349 + size_shown
15350 + size_tm
15351 + size_tmps;
15352
15353 if (size_total > device_param->device_global_mem) memory_limit_hit = 1;
15354
15355 if (memory_limit_hit == 1)
15356 {
15357 kernel_accel_max--;
15358
15359 continue;
15360 }
15361
15362 break;
15363 }
15364
15365 if (kernel_accel_max < kernel_accel_min)
15366 {
15367 log_error ("- Device #%u: Device does not provide enough allocatable device-memory to handle this attack", device_id + 1);
15368
15369 return -1;
15370 }
15371
15372 device_param->kernel_accel_min = kernel_accel_min;
15373 device_param->kernel_accel_max = kernel_accel_max;
15374
15375 /*
15376 if (kernel_accel_max < kernel_accel)
15377 {
15378 if (quiet == 0) log_info ("- Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
15379
15380 device_param->kernel_accel = kernel_accel_max;
15381 }
15382 */
15383
15384 device_param->size_bfs = size_bfs;
15385 device_param->size_combs = size_combs;
15386 device_param->size_rules = size_rules;
15387 device_param->size_rules_c = size_rules_c;
15388 device_param->size_pws = size_pws;
15389 device_param->size_tmps = size_tmps;
15390 device_param->size_hooks = size_hooks;
15391
15392 /**
15393 * default building options
15394 */
15395
15396 char cpath[1024] = { 0 };
15397
15398 char build_opts[1024] = { 0 };
15399
15400 #if _WIN
15401
15402 snprintf (cpath, sizeof (cpath) - 1, "%s\\OpenCL\\", shared_dir);
15403
15404 char *cpath_real = mymalloc (MAX_PATH);
15405
15406 if (GetFullPathName (cpath, MAX_PATH, cpath_real, NULL) == 0)
15407 {
15408 log_error ("ERROR: %s: %s", cpath, "GetFullPathName()");
15409
15410 return -1;
15411 }
15412
15413 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\"", cpath_real);
15414
15415 myfree (cpath_real);
15416
15417 #else
15418
15419 snprintf (cpath, sizeof (cpath) - 1, "%s/OpenCL/", shared_dir);
15420
15421 char *cpath_real = mymalloc (PATH_MAX);
15422
15423 if (realpath (cpath, cpath_real) == NULL)
15424 {
15425 log_error ("ERROR: %s: %s", cpath, strerror (errno));
15426
15427 return -1;
15428 }
15429
15430 char cpath_escaped[1024] = { 0 };
15431
15432 naive_escape (cpath_real, cpath_escaped, sizeof (cpath_escaped));
15433
15434 myfree (cpath_real);
15435
15436 snprintf (build_opts, sizeof (build_opts) - 1, "-I %s", cpath_escaped);
15437
15438 #endif
15439
15440 // we don't have sm_* on vendors not NV but it doesn't matter
15441
15442 char build_opts_new[1024] = { 0 };
15443
15444 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -D VENDOR_ID=%u -D CUDA_ARCH=%d -D VECT_SIZE=%u -D DEVICE_TYPE=%u -D KERN_TYPE=%u -D _unroll -cl-std=CL1.1", build_opts, device_param->device_vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type);
15445
15446 strncpy (build_opts, build_opts_new, sizeof (build_opts));
15447
15448 #ifdef DEBUG
15449 log_info ("- Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15450 #endif
15451
15452 /**
15453 * main kernel
15454 */
15455
15456 {
15457 /**
15458 * kernel source filename
15459 */
15460
15461 char source_file[256] = { 0 };
15462
15463 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15464
15465 struct stat sst;
15466
15467 if (stat (source_file, &sst) == -1)
15468 {
15469 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15470
15471 return -1;
15472 }
15473
15474 /**
15475 * kernel cached filename
15476 */
15477
15478 char cached_file[256] = { 0 };
15479
15480 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15481
15482 int cached = 1;
15483
15484 struct stat cst;
15485
15486 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15487 {
15488 cached = 0;
15489 }
15490
15491 /**
15492 * kernel compile or load
15493 */
15494
15495 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15496
15497 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15498
15499 if (force_jit_compilation == -1)
15500 {
15501 if (cached == 0)
15502 {
15503 if (quiet == 0) log_info ("- Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, filename_from_filepath (cached_file));
15504
15505 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15506
15507 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15508
15509 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15510
15511 #ifdef DEBUG
15512 size_t build_log_size = 0;
15513
15514 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15515
15516 if (build_log_size > 1)
15517 {
15518 char *build_log = (char *) malloc (build_log_size + 1);
15519
15520 memset (build_log, 0, build_log_size + 1);
15521
15522 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15523
15524 puts (build_log);
15525
15526 free (build_log);
15527 }
15528 #endif
15529
15530 if (rc != 0)
15531 {
15532 device_param->skipped = true;
15533
15534 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15535
15536 continue;
15537 }
15538
15539 size_t binary_size;
15540
15541 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15542
15543 u8 *binary = (u8 *) mymalloc (binary_size);
15544
15545 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15546
15547 writeProgramBin (cached_file, binary, binary_size);
15548
15549 local_free (binary);
15550 }
15551 else
15552 {
15553 #ifdef DEBUG
15554 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15555 #endif
15556
15557 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15558
15559 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15560
15561 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15562 }
15563 }
15564 else
15565 {
15566 #ifdef DEBUG
15567 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15568 #endif
15569
15570 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15571
15572 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15573
15574 char build_opts_update[1024] = { 0 };
15575
15576 if (force_jit_compilation == 1500)
15577 {
15578 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15579 }
15580 else if (force_jit_compilation == 8900)
15581 {
15582 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DSCRYPT_N=%d -DSCRYPT_R=%d -DSCRYPT_P=%d -DSCRYPT_TMTO=%d", build_opts, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, 1 << data.salts_buf[0].scrypt_tmto);
15583 }
15584 else
15585 {
15586 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15587 }
15588
15589 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15590
15591 #ifdef DEBUG
15592 size_t build_log_size = 0;
15593
15594 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15595
15596 if (build_log_size > 1)
15597 {
15598 char *build_log = (char *) malloc (build_log_size + 1);
15599
15600 memset (build_log, 0, build_log_size + 1);
15601
15602 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15603
15604 puts (build_log);
15605
15606 free (build_log);
15607 }
15608 #endif
15609
15610 if (rc != 0)
15611 {
15612 device_param->skipped = true;
15613
15614 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15615 }
15616 }
15617
15618 local_free (kernel_lengths);
15619 local_free (kernel_sources[0]);
15620 local_free (kernel_sources);
15621 }
15622
15623 /**
15624 * word generator kernel
15625 */
15626
15627 if (attack_mode != ATTACK_MODE_STRAIGHT)
15628 {
15629 /**
15630 * kernel mp source filename
15631 */
15632
15633 char source_file[256] = { 0 };
15634
15635 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15636
15637 struct stat sst;
15638
15639 if (stat (source_file, &sst) == -1)
15640 {
15641 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15642
15643 return -1;
15644 }
15645
15646 /**
15647 * kernel mp cached filename
15648 */
15649
15650 char cached_file[256] = { 0 };
15651
15652 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15653
15654 int cached = 1;
15655
15656 struct stat cst;
15657
15658 if (stat (cached_file, &cst) == -1)
15659 {
15660 cached = 0;
15661 }
15662
15663 /**
15664 * kernel compile or load
15665 */
15666
15667 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15668
15669 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15670
15671 if (cached == 0)
15672 {
15673 if (quiet == 0) log_info ("- Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, filename_from_filepath (cached_file));
15674 if (quiet == 0) log_info ("");
15675
15676 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15677
15678 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15679
15680 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15681
15682 if (rc != 0)
15683 {
15684 device_param->skipped = true;
15685
15686 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15687
15688 continue;
15689 }
15690
15691 size_t binary_size;
15692
15693 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15694
15695 u8 *binary = (u8 *) mymalloc (binary_size);
15696
15697 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15698
15699 writeProgramBin (cached_file, binary, binary_size);
15700
15701 local_free (binary);
15702 }
15703 else
15704 {
15705 #ifdef DEBUG
15706 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15707 #endif
15708
15709 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15710
15711 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15712
15713 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15714 }
15715
15716 local_free (kernel_lengths);
15717 local_free (kernel_sources[0]);
15718 local_free (kernel_sources);
15719 }
15720
15721 /**
15722 * amplifier kernel
15723 */
15724
15725 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15726 {
15727
15728 }
15729 else
15730 {
15731 /**
15732 * kernel amp source filename
15733 */
15734
15735 char source_file[256] = { 0 };
15736
15737 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15738
15739 struct stat sst;
15740
15741 if (stat (source_file, &sst) == -1)
15742 {
15743 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15744
15745 return -1;
15746 }
15747
15748 /**
15749 * kernel amp cached filename
15750 */
15751
15752 char cached_file[256] = { 0 };
15753
15754 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15755
15756 int cached = 1;
15757
15758 struct stat cst;
15759
15760 if (stat (cached_file, &cst) == -1)
15761 {
15762 cached = 0;
15763 }
15764
15765 /**
15766 * kernel compile or load
15767 */
15768
15769 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15770
15771 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15772
15773 if (cached == 0)
15774 {
15775 if (quiet == 0) log_info ("- Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, filename_from_filepath (cached_file));
15776 if (quiet == 0) log_info ("");
15777
15778 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15779
15780 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15781
15782 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15783
15784 if (rc != 0)
15785 {
15786 device_param->skipped = true;
15787
15788 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15789
15790 continue;
15791 }
15792
15793 size_t binary_size;
15794
15795 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15796
15797 u8 *binary = (u8 *) mymalloc (binary_size);
15798
15799 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15800
15801 writeProgramBin (cached_file, binary, binary_size);
15802
15803 local_free (binary);
15804 }
15805 else
15806 {
15807 #ifdef DEBUG
15808 if (quiet == 0) log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15809 #endif
15810
15811 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15812
15813 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15814
15815 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15816 }
15817
15818 local_free (kernel_lengths);
15819 local_free (kernel_sources[0]);
15820 local_free (kernel_sources);
15821 }
15822
15823 // some algorithm collide too fast, make that impossible
15824
15825 if (benchmark == 1)
15826 {
15827 ((uint *) digests_buf)[0] = -1;
15828 ((uint *) digests_buf)[1] = -1;
15829 ((uint *) digests_buf)[2] = -1;
15830 ((uint *) digests_buf)[3] = -1;
15831 }
15832
15833 /**
15834 * global buffers
15835 */
15836
15837 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15838 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15839 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15840 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15841 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15842 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15843 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15844 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15845 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15846 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15847 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15848 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15849 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15850 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15851 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15852 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15853 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15854 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15855
15856 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
15857 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
15858 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
15859 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
15860 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
15861 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
15862 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
15863 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
15864 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15865 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15866 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15867
15868 /**
15869 * special buffers
15870 */
15871
15872 if (attack_kern == ATTACK_KERN_STRAIGHT)
15873 {
15874 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15875 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15876
15877 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15878 }
15879 else if (attack_kern == ATTACK_KERN_COMBI)
15880 {
15881 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15882 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15883 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15884 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15885 }
15886 else if (attack_kern == ATTACK_KERN_BF)
15887 {
15888 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15889 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15890 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15891 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15892 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15893 }
15894
15895 if (size_esalts)
15896 {
15897 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15898
15899 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15900 }
15901
15902 /**
15903 * main host data
15904 */
15905
15906 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15907
15908 device_param->pws_buf = pws_buf;
15909
15910 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15911
15912 device_param->combs_buf = combs_buf;
15913
15914 void *hooks_buf = mymalloc (size_hooks);
15915
15916 device_param->hooks_buf = hooks_buf;
15917
15918 /**
15919 * kernel args
15920 */
15921
15922 device_param->kernel_params_buf32[21] = bitmap_mask;
15923 device_param->kernel_params_buf32[22] = bitmap_shift1;
15924 device_param->kernel_params_buf32[23] = bitmap_shift2;
15925 device_param->kernel_params_buf32[24] = 0; // salt_pos
15926 device_param->kernel_params_buf32[25] = 0; // loop_pos
15927 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15928 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15929 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15930 device_param->kernel_params_buf32[29] = 0; // digests_offset
15931 device_param->kernel_params_buf32[30] = 0; // combs_mode
15932 device_param->kernel_params_buf32[31] = 0; // gid_max
15933
15934 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15935 ? &device_param->d_pws_buf
15936 : &device_param->d_pws_amp_buf;
15937 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15938 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15939 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15940 device_param->kernel_params[ 4] = &device_param->d_tmps;
15941 device_param->kernel_params[ 5] = &device_param->d_hooks;
15942 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15943 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15944 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15945 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15946 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15947 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15948 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15949 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15950 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15951 device_param->kernel_params[15] = &device_param->d_digests_buf;
15952 device_param->kernel_params[16] = &device_param->d_digests_shown;
15953 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15954 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15955 device_param->kernel_params[19] = &device_param->d_result;
15956 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15957 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15958 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15959 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15960 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15961 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15962 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15963 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15964 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15965 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15966 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15967 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15968
15969 device_param->kernel_params_mp_buf64[3] = 0;
15970 device_param->kernel_params_mp_buf32[4] = 0;
15971 device_param->kernel_params_mp_buf32[5] = 0;
15972 device_param->kernel_params_mp_buf32[6] = 0;
15973 device_param->kernel_params_mp_buf32[7] = 0;
15974 device_param->kernel_params_mp_buf32[8] = 0;
15975
15976 device_param->kernel_params_mp[0] = NULL;
15977 device_param->kernel_params_mp[1] = NULL;
15978 device_param->kernel_params_mp[2] = NULL;
15979 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15980 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15981 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15982 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15983 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15984 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15985
15986 device_param->kernel_params_mp_l_buf64[3] = 0;
15987 device_param->kernel_params_mp_l_buf32[4] = 0;
15988 device_param->kernel_params_mp_l_buf32[5] = 0;
15989 device_param->kernel_params_mp_l_buf32[6] = 0;
15990 device_param->kernel_params_mp_l_buf32[7] = 0;
15991 device_param->kernel_params_mp_l_buf32[8] = 0;
15992 device_param->kernel_params_mp_l_buf32[9] = 0;
15993
15994 device_param->kernel_params_mp_l[0] = NULL;
15995 device_param->kernel_params_mp_l[1] = NULL;
15996 device_param->kernel_params_mp_l[2] = NULL;
15997 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15998 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15999 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
16000 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
16001 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
16002 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
16003 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
16004
16005 device_param->kernel_params_mp_r_buf64[3] = 0;
16006 device_param->kernel_params_mp_r_buf32[4] = 0;
16007 device_param->kernel_params_mp_r_buf32[5] = 0;
16008 device_param->kernel_params_mp_r_buf32[6] = 0;
16009 device_param->kernel_params_mp_r_buf32[7] = 0;
16010 device_param->kernel_params_mp_r_buf32[8] = 0;
16011
16012 device_param->kernel_params_mp_r[0] = NULL;
16013 device_param->kernel_params_mp_r[1] = NULL;
16014 device_param->kernel_params_mp_r[2] = NULL;
16015 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
16016 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
16017 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
16018 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
16019 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
16020 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
16021
16022 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
16023 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
16024
16025 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
16026 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
16027 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
16028 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
16029 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
16030 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
16031 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
16032
16033 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
16034 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
16035
16036 device_param->kernel_params_memset_buf32[1] = 0; // value
16037 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
16038
16039 device_param->kernel_params_memset[0] = NULL;
16040 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
16041 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
16042
16043 /**
16044 * kernel name
16045 */
16046
16047 size_t kernel_wgs_tmp;
16048
16049 char kernel_name[64] = { 0 };
16050
16051 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16052 {
16053 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16054 {
16055 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
16056
16057 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16058
16059 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
16060
16061 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16062
16063 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
16064
16065 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16066 }
16067 else
16068 {
16069 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
16070
16071 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16072
16073 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
16074
16075 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16076
16077 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
16078
16079 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16080 }
16081
16082 if (data.attack_mode == ATTACK_MODE_BF)
16083 {
16084 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16085 {
16086 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
16087
16088 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16089
16090 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_tm, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
16091 }
16092 }
16093 }
16094 else
16095 {
16096 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
16097
16098 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16099
16100 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
16101
16102 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16103
16104 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
16105
16106 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16107
16108 if (opts_type & OPTS_TYPE_HOOK12)
16109 {
16110 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
16111
16112 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16113
16114 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel12, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
16115 }
16116
16117 if (opts_type & OPTS_TYPE_HOOK23)
16118 {
16119 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
16120
16121 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16122
16123 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel23, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
16124 }
16125 }
16126
16127 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel1, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
16128 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel2, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
16129 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel3, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
16130
16131 for (uint i = 0; i <= 20; i++)
16132 {
16133 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
16134 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
16135 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
16136
16137 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
16138 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
16139 }
16140
16141 for (uint i = 21; i <= 31; i++)
16142 {
16143 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
16144 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
16145 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
16146
16147 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
16148 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
16149 }
16150
16151 // GPU memset
16152
16153 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
16154
16155 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_memset, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
16156
16157 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
16158 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
16159 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
16160
16161 // MP start
16162
16163 if (attack_mode == ATTACK_MODE_BF)
16164 {
16165 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
16166 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
16167
16168 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_mp_l, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
16169 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_mp_r, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
16170
16171 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16172 {
16173 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
16174 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
16175 }
16176 }
16177 else if (attack_mode == ATTACK_MODE_HYBRID1)
16178 {
16179 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16180
16181 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_mp, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
16182 }
16183 else if (attack_mode == ATTACK_MODE_HYBRID2)
16184 {
16185 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16186
16187 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_mp, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
16188 }
16189
16190 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16191 {
16192 // nothing to do
16193 }
16194 else
16195 {
16196 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
16197
16198 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_amp, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
16199 }
16200
16201 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16202 {
16203 // nothing to do
16204 }
16205 else
16206 {
16207 for (uint i = 0; i < 5; i++)
16208 {
16209 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
16210 }
16211
16212 for (uint i = 5; i < 7; i++)
16213 {
16214 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
16215 }
16216 }
16217
16218 // maybe this has been updated by clGetKernelWorkGroupInfo()
16219 // value can only be decreased, so we don't need to reallocate buffers
16220
16221 device_param->kernel_threads = kernel_threads;
16222
16223 // zero some data buffers
16224
16225 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
16226 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
16227 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
16228 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
16229 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
16230 run_kernel_bzero (device_param, device_param->d_result, size_results);
16231
16232 /**
16233 * special buffers
16234 */
16235
16236 if (attack_kern == ATTACK_KERN_STRAIGHT)
16237 {
16238 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
16239 }
16240 else if (attack_kern == ATTACK_KERN_COMBI)
16241 {
16242 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
16243 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
16244 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16245 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16246 }
16247 else if (attack_kern == ATTACK_KERN_BF)
16248 {
16249 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
16250 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
16251 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
16252 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16253 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16254 }
16255
16256 #if defined(HAVE_HWMON)
16257
16258 /**
16259 * Store initial fanspeed if gpu_temp_retain is enabled
16260 */
16261
16262 if (gpu_temp_disable == 0)
16263 {
16264 if (gpu_temp_retain != 0)
16265 {
16266 hc_thread_mutex_lock (mux_adl);
16267
16268 if (data.hm_device[device_id].fan_get_supported == 1)
16269 {
16270 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
16271 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
16272
16273 temp_retain_fanspeed_value[device_id] = fanspeed;
16274 temp_retain_fanpolicy_value[device_id] = fanpolicy;
16275
16276 // we also set it to tell the OS we take control over the fan and it's automatic controller
16277 // if it was set to automatic. we do not control user-defined fanspeeds.
16278
16279 if (fanpolicy == 1)
16280 {
16281 data.hm_device[device_id].fan_set_supported = 1;
16282
16283 int rc = -1;
16284
16285 if (device_param->device_vendor_id == VENDOR_ID_AMD)
16286 {
16287 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
16288 }
16289 else if (device_param->device_vendor_id == VENDOR_ID_NV)
16290 {
16291 #ifdef LINUX
16292 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE);
16293 #endif
16294
16295 #ifdef WIN
16296 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
16297 #endif
16298 }
16299
16300 if (rc == 0)
16301 {
16302 data.hm_device[device_id].fan_set_supported = 1;
16303 }
16304 else
16305 {
16306 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
16307
16308 data.hm_device[device_id].fan_set_supported = 0;
16309 }
16310 }
16311 else
16312 {
16313 data.hm_device[device_id].fan_set_supported = 0;
16314 }
16315 }
16316
16317 hc_thread_mutex_unlock (mux_adl);
16318 }
16319 }
16320
16321 #endif // HAVE_HWMON
16322 }
16323
16324 if (data.quiet == 0) log_info_nn ("");
16325
16326 /**
16327 * In benchmark-mode, inform user which algorithm is checked
16328 */
16329
16330 if (benchmark == 1)
16331 {
16332 if (machine_readable == 0)
16333 {
16334 quiet = 0;
16335
16336 data.quiet = quiet;
16337
16338 char *hash_type = strhashtype (data.hash_mode); // not a bug
16339
16340 log_info ("Hashtype: %s", hash_type);
16341 log_info ("");
16342 }
16343 }
16344
16345 /**
16346 * keep track of the progress
16347 */
16348
16349 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16350 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16351 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16352
16353 /**
16354 * open filehandles
16355 */
16356
16357 #if _WIN
16358 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
16359 {
16360 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
16361
16362 return (-1);
16363 }
16364
16365 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
16366 {
16367 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
16368
16369 return (-1);
16370 }
16371
16372 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
16373 {
16374 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
16375
16376 return (-1);
16377 }
16378 #endif
16379
16380 /**
16381 * dictionary pad
16382 */
16383
16384 segment_size *= (1024 * 1024);
16385
16386 data.segment_size = segment_size;
16387
16388 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
16389
16390 wl_data->buf = (char *) mymalloc (segment_size);
16391 wl_data->avail = segment_size;
16392 wl_data->incr = segment_size;
16393 wl_data->cnt = 0;
16394 wl_data->pos = 0;
16395
16396 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
16397
16398 data.wordlist_mode = wordlist_mode;
16399
16400 cs_t *css_buf = NULL;
16401 uint css_cnt = 0;
16402 uint dictcnt = 0;
16403 uint maskcnt = 1;
16404 char **masks = NULL;
16405 char **dictfiles = NULL;
16406
16407 uint mask_from_file = 0;
16408
16409 if (attack_mode == ATTACK_MODE_STRAIGHT)
16410 {
16411 if (wordlist_mode == WL_MODE_FILE)
16412 {
16413 int wls_left = myargc - (optind + 1);
16414
16415 for (int i = 0; i < wls_left; i++)
16416 {
16417 char *l0_filename = myargv[optind + 1 + i];
16418
16419 struct stat l0_stat;
16420
16421 if (stat (l0_filename, &l0_stat) == -1)
16422 {
16423 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
16424
16425 return (-1);
16426 }
16427
16428 uint is_dir = S_ISDIR (l0_stat.st_mode);
16429
16430 if (is_dir == 0)
16431 {
16432 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16433
16434 dictcnt++;
16435
16436 dictfiles[dictcnt - 1] = l0_filename;
16437 }
16438 else
16439 {
16440 // do not allow --keyspace w/ a directory
16441
16442 if (keyspace == 1)
16443 {
16444 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16445
16446 return (-1);
16447 }
16448
16449 char **dictionary_files = NULL;
16450
16451 dictionary_files = scan_directory (l0_filename);
16452
16453 if (dictionary_files != NULL)
16454 {
16455 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16456
16457 for (int d = 0; dictionary_files[d] != NULL; d++)
16458 {
16459 char *l1_filename = dictionary_files[d];
16460
16461 struct stat l1_stat;
16462
16463 if (stat (l1_filename, &l1_stat) == -1)
16464 {
16465 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16466
16467 return (-1);
16468 }
16469
16470 if (S_ISREG (l1_stat.st_mode))
16471 {
16472 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16473
16474 dictcnt++;
16475
16476 dictfiles[dictcnt - 1] = strdup (l1_filename);
16477 }
16478 }
16479 }
16480
16481 local_free (dictionary_files);
16482 }
16483 }
16484
16485 if (dictcnt < 1)
16486 {
16487 log_error ("ERROR: No usable dictionary file found.");
16488
16489 return (-1);
16490 }
16491 }
16492 else if (wordlist_mode == WL_MODE_STDIN)
16493 {
16494 dictcnt = 1;
16495 }
16496 }
16497 else if (attack_mode == ATTACK_MODE_COMBI)
16498 {
16499 // display
16500
16501 char *dictfile1 = myargv[optind + 1 + 0];
16502 char *dictfile2 = myargv[optind + 1 + 1];
16503
16504 // find the bigger dictionary and use as base
16505
16506 FILE *fp1 = NULL;
16507 FILE *fp2 = NULL;
16508
16509 struct stat tmp_stat;
16510
16511 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16512 {
16513 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16514
16515 return (-1);
16516 }
16517
16518 if (stat (dictfile1, &tmp_stat) == -1)
16519 {
16520 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16521
16522 fclose (fp1);
16523
16524 return (-1);
16525 }
16526
16527 if (S_ISDIR (tmp_stat.st_mode))
16528 {
16529 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16530
16531 fclose (fp1);
16532
16533 return (-1);
16534 }
16535
16536 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16537 {
16538 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16539
16540 fclose (fp1);
16541
16542 return (-1);
16543 }
16544
16545 if (stat (dictfile2, &tmp_stat) == -1)
16546 {
16547 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16548
16549 fclose (fp1);
16550 fclose (fp2);
16551
16552 return (-1);
16553 }
16554
16555 if (S_ISDIR (tmp_stat.st_mode))
16556 {
16557 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16558
16559 fclose (fp1);
16560 fclose (fp2);
16561
16562 return (-1);
16563 }
16564
16565 data.combs_cnt = 1;
16566
16567 data.quiet = 1;
16568
16569 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16570
16571 data.quiet = quiet;
16572
16573 if (words1_cnt == 0)
16574 {
16575 log_error ("ERROR: %s: empty file", dictfile1);
16576
16577 fclose (fp1);
16578 fclose (fp2);
16579
16580 return (-1);
16581 }
16582
16583 data.combs_cnt = 1;
16584
16585 data.quiet = 1;
16586
16587 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16588
16589 data.quiet = quiet;
16590
16591 if (words2_cnt == 0)
16592 {
16593 log_error ("ERROR: %s: empty file", dictfile2);
16594
16595 fclose (fp1);
16596 fclose (fp2);
16597
16598 return (-1);
16599 }
16600
16601 fclose (fp1);
16602 fclose (fp2);
16603
16604 data.dictfile = dictfile1;
16605 data.dictfile2 = dictfile2;
16606
16607 if (words1_cnt >= words2_cnt)
16608 {
16609 data.combs_cnt = words2_cnt;
16610 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16611
16612 dictfiles = &data.dictfile;
16613
16614 dictcnt = 1;
16615 }
16616 else
16617 {
16618 data.combs_cnt = words1_cnt;
16619 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16620
16621 dictfiles = &data.dictfile2;
16622
16623 dictcnt = 1;
16624
16625 // we also have to switch wordlist related rules!
16626
16627 char *tmpc = data.rule_buf_l;
16628
16629 data.rule_buf_l = data.rule_buf_r;
16630 data.rule_buf_r = tmpc;
16631
16632 int tmpi = data.rule_len_l;
16633
16634 data.rule_len_l = data.rule_len_r;
16635 data.rule_len_r = tmpi;
16636 }
16637 }
16638 else if (attack_mode == ATTACK_MODE_BF)
16639 {
16640 char *mask = NULL;
16641
16642 maskcnt = 0;
16643
16644 if (benchmark == 0)
16645 {
16646 mask = myargv[optind + 1];
16647
16648 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16649
16650 if ((optind + 2) <= myargc)
16651 {
16652 struct stat file_stat;
16653
16654 if (stat (mask, &file_stat) == -1)
16655 {
16656 maskcnt = 1;
16657
16658 masks[maskcnt - 1] = mystrdup (mask);
16659 }
16660 else
16661 {
16662 int wls_left = myargc - (optind + 1);
16663
16664 uint masks_avail = INCR_MASKS;
16665
16666 for (int i = 0; i < wls_left; i++)
16667 {
16668 if (i != 0)
16669 {
16670 mask = myargv[optind + 1 + i];
16671
16672 if (stat (mask, &file_stat) == -1)
16673 {
16674 log_error ("ERROR: %s: %s", mask, strerror (errno));
16675
16676 return (-1);
16677 }
16678 }
16679
16680 uint is_file = S_ISREG (file_stat.st_mode);
16681
16682 if (is_file == 1)
16683 {
16684 FILE *mask_fp;
16685
16686 if ((mask_fp = fopen (mask, "r")) == NULL)
16687 {
16688 log_error ("ERROR: %s: %s", mask, strerror (errno));
16689
16690 return (-1);
16691 }
16692
16693 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16694
16695 while (!feof (mask_fp))
16696 {
16697 memset (line_buf, 0, HCBUFSIZ);
16698
16699 int line_len = fgetl (mask_fp, line_buf);
16700
16701 if (line_len == 0) continue;
16702
16703 if (line_buf[0] == '#') continue;
16704
16705 if (masks_avail == maskcnt)
16706 {
16707 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16708
16709 masks_avail += INCR_MASKS;
16710 }
16711
16712 masks[maskcnt] = mystrdup (line_buf);
16713
16714 maskcnt++;
16715 }
16716
16717 myfree (line_buf);
16718
16719 fclose (mask_fp);
16720 }
16721 else
16722 {
16723 log_error ("ERROR: %s: unsupported file-type", mask);
16724
16725 return (-1);
16726 }
16727 }
16728
16729 mask_from_file = 1;
16730 }
16731 }
16732 else
16733 {
16734 custom_charset_1 = (char *) "?l?d?u";
16735 custom_charset_2 = (char *) "?l?d";
16736 custom_charset_3 = (char *) "?l?d*!$@_";
16737
16738 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16739 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16740 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16741
16742 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16743
16744 wordlist_mode = WL_MODE_MASK;
16745
16746 data.wordlist_mode = wordlist_mode;
16747
16748 increment = 1;
16749
16750 maskcnt = 1;
16751 }
16752 }
16753 else
16754 {
16755 /**
16756 * generate full masks and charsets
16757 */
16758
16759 masks = (char **) mymalloc (sizeof (char *));
16760
16761 switch (hash_mode)
16762 {
16763 case 1731: pw_min = 5;
16764 pw_max = 5;
16765 mask = mystrdup ("?b?b?b?b?b");
16766 break;
16767 case 12500: pw_min = 5;
16768 pw_max = 5;
16769 mask = mystrdup ("?b?b?b?b?b");
16770 break;
16771 default: pw_min = 7;
16772 pw_max = 7;
16773 mask = mystrdup ("?b?b?b?b?b?b?b");
16774 break;
16775 }
16776
16777 maskcnt = 1;
16778
16779 masks[maskcnt - 1] = mystrdup (mask);
16780
16781 wordlist_mode = WL_MODE_MASK;
16782
16783 data.wordlist_mode = wordlist_mode;
16784
16785 increment = 1;
16786 }
16787
16788 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16789
16790 if (increment)
16791 {
16792 if (increment_min > pw_min) pw_min = increment_min;
16793
16794 if (increment_max < pw_max) pw_max = increment_max;
16795 }
16796 }
16797 else if (attack_mode == ATTACK_MODE_HYBRID1)
16798 {
16799 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16800
16801 // display
16802
16803 char *mask = myargv[myargc - 1];
16804
16805 maskcnt = 0;
16806
16807 masks = (char **) mymalloc (1 * sizeof (char *));
16808
16809 // mod
16810
16811 struct stat file_stat;
16812
16813 if (stat (mask, &file_stat) == -1)
16814 {
16815 maskcnt = 1;
16816
16817 masks[maskcnt - 1] = mystrdup (mask);
16818 }
16819 else
16820 {
16821 uint is_file = S_ISREG (file_stat.st_mode);
16822
16823 if (is_file == 1)
16824 {
16825 FILE *mask_fp;
16826
16827 if ((mask_fp = fopen (mask, "r")) == NULL)
16828 {
16829 log_error ("ERROR: %s: %s", mask, strerror (errno));
16830
16831 return (-1);
16832 }
16833
16834 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16835
16836 uint masks_avail = 1;
16837
16838 while (!feof (mask_fp))
16839 {
16840 memset (line_buf, 0, HCBUFSIZ);
16841
16842 int line_len = fgetl (mask_fp, line_buf);
16843
16844 if (line_len == 0) continue;
16845
16846 if (line_buf[0] == '#') continue;
16847
16848 if (masks_avail == maskcnt)
16849 {
16850 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16851
16852 masks_avail += INCR_MASKS;
16853 }
16854
16855 masks[maskcnt] = mystrdup (line_buf);
16856
16857 maskcnt++;
16858 }
16859
16860 myfree (line_buf);
16861
16862 fclose (mask_fp);
16863
16864 mask_from_file = 1;
16865 }
16866 else
16867 {
16868 maskcnt = 1;
16869
16870 masks[maskcnt - 1] = mystrdup (mask);
16871 }
16872 }
16873
16874 // base
16875
16876 int wls_left = myargc - (optind + 2);
16877
16878 for (int i = 0; i < wls_left; i++)
16879 {
16880 char *filename = myargv[optind + 1 + i];
16881
16882 struct stat file_stat;
16883
16884 if (stat (filename, &file_stat) == -1)
16885 {
16886 log_error ("ERROR: %s: %s", filename, strerror (errno));
16887
16888 return (-1);
16889 }
16890
16891 uint is_dir = S_ISDIR (file_stat.st_mode);
16892
16893 if (is_dir == 0)
16894 {
16895 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16896
16897 dictcnt++;
16898
16899 dictfiles[dictcnt - 1] = filename;
16900 }
16901 else
16902 {
16903 // do not allow --keyspace w/ a directory
16904
16905 if (keyspace == 1)
16906 {
16907 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16908
16909 return (-1);
16910 }
16911
16912 char **dictionary_files = NULL;
16913
16914 dictionary_files = scan_directory (filename);
16915
16916 if (dictionary_files != NULL)
16917 {
16918 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16919
16920 for (int d = 0; dictionary_files[d] != NULL; d++)
16921 {
16922 char *l1_filename = dictionary_files[d];
16923
16924 struct stat l1_stat;
16925
16926 if (stat (l1_filename, &l1_stat) == -1)
16927 {
16928 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16929
16930 return (-1);
16931 }
16932
16933 if (S_ISREG (l1_stat.st_mode))
16934 {
16935 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16936
16937 dictcnt++;
16938
16939 dictfiles[dictcnt - 1] = strdup (l1_filename);
16940 }
16941 }
16942 }
16943
16944 local_free (dictionary_files);
16945 }
16946 }
16947
16948 if (dictcnt < 1)
16949 {
16950 log_error ("ERROR: No usable dictionary file found.");
16951
16952 return (-1);
16953 }
16954
16955 if (increment)
16956 {
16957 maskcnt = 0;
16958
16959 uint mask_min = increment_min; // we can't reject smaller masks here
16960 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16961
16962 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16963 {
16964 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16965
16966 if (cur_mask == NULL) break;
16967
16968 masks[maskcnt] = cur_mask;
16969
16970 maskcnt++;
16971
16972 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16973 }
16974 }
16975 }
16976 else if (attack_mode == ATTACK_MODE_HYBRID2)
16977 {
16978 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16979
16980 // display
16981
16982 char *mask = myargv[optind + 1 + 0];
16983
16984 maskcnt = 0;
16985
16986 masks = (char **) mymalloc (1 * sizeof (char *));
16987
16988 // mod
16989
16990 struct stat file_stat;
16991
16992 if (stat (mask, &file_stat) == -1)
16993 {
16994 maskcnt = 1;
16995
16996 masks[maskcnt - 1] = mystrdup (mask);
16997 }
16998 else
16999 {
17000 uint is_file = S_ISREG (file_stat.st_mode);
17001
17002 if (is_file == 1)
17003 {
17004 FILE *mask_fp;
17005
17006 if ((mask_fp = fopen (mask, "r")) == NULL)
17007 {
17008 log_error ("ERROR: %s: %s", mask, strerror (errno));
17009
17010 return (-1);
17011 }
17012
17013 char *line_buf = (char *) mymalloc (HCBUFSIZ);
17014
17015 uint masks_avail = 1;
17016
17017 while (!feof (mask_fp))
17018 {
17019 memset (line_buf, 0, HCBUFSIZ);
17020
17021 int line_len = fgetl (mask_fp, line_buf);
17022
17023 if (line_len == 0) continue;
17024
17025 if (line_buf[0] == '#') continue;
17026
17027 if (masks_avail == maskcnt)
17028 {
17029 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
17030
17031 masks_avail += INCR_MASKS;
17032 }
17033
17034 masks[maskcnt] = mystrdup (line_buf);
17035
17036 maskcnt++;
17037 }
17038
17039 myfree (line_buf);
17040
17041 fclose (mask_fp);
17042
17043 mask_from_file = 1;
17044 }
17045 else
17046 {
17047 maskcnt = 1;
17048
17049 masks[maskcnt - 1] = mystrdup (mask);
17050 }
17051 }
17052
17053 // base
17054
17055 int wls_left = myargc - (optind + 2);
17056
17057 for (int i = 0; i < wls_left; i++)
17058 {
17059 char *filename = myargv[optind + 2 + i];
17060
17061 struct stat file_stat;
17062
17063 if (stat (filename, &file_stat) == -1)
17064 {
17065 log_error ("ERROR: %s: %s", filename, strerror (errno));
17066
17067 return (-1);
17068 }
17069
17070 uint is_dir = S_ISDIR (file_stat.st_mode);
17071
17072 if (is_dir == 0)
17073 {
17074 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17075
17076 dictcnt++;
17077
17078 dictfiles[dictcnt - 1] = filename;
17079 }
17080 else
17081 {
17082 // do not allow --keyspace w/ a directory
17083
17084 if (keyspace == 1)
17085 {
17086 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17087
17088 return (-1);
17089 }
17090
17091 char **dictionary_files = NULL;
17092
17093 dictionary_files = scan_directory (filename);
17094
17095 if (dictionary_files != NULL)
17096 {
17097 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17098
17099 for (int d = 0; dictionary_files[d] != NULL; d++)
17100 {
17101 char *l1_filename = dictionary_files[d];
17102
17103 struct stat l1_stat;
17104
17105 if (stat (l1_filename, &l1_stat) == -1)
17106 {
17107 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17108
17109 return (-1);
17110 }
17111
17112 if (S_ISREG (l1_stat.st_mode))
17113 {
17114 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17115
17116 dictcnt++;
17117
17118 dictfiles[dictcnt - 1] = strdup (l1_filename);
17119 }
17120 }
17121 }
17122
17123 local_free (dictionary_files);
17124 }
17125 }
17126
17127 if (dictcnt < 1)
17128 {
17129 log_error ("ERROR: No usable dictionary file found.");
17130
17131 return (-1);
17132 }
17133
17134 if (increment)
17135 {
17136 maskcnt = 0;
17137
17138 uint mask_min = increment_min; // we can't reject smaller masks here
17139 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17140
17141 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17142 {
17143 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17144
17145 if (cur_mask == NULL) break;
17146
17147 masks[maskcnt] = cur_mask;
17148
17149 maskcnt++;
17150
17151 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17152 }
17153 }
17154 }
17155
17156 data.pw_min = pw_min;
17157 data.pw_max = pw_max;
17158
17159 /**
17160 * weak hash check
17161 */
17162
17163 if (weak_hash_threshold >= salts_cnt)
17164 {
17165 hc_device_param_t *device_param = NULL;
17166
17167 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17168 {
17169 device_param = &data.devices_param[device_id];
17170
17171 if (device_param->skipped) continue;
17172
17173 break;
17174 }
17175
17176 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
17177
17178 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
17179 {
17180 weak_hash_check (device_param, salt_pos);
17181 }
17182
17183 // Display hack, guarantee that there is at least one \r before real start
17184
17185 //if (data.quiet == 0) log_info ("");
17186 }
17187
17188 /**
17189 * status and monitor threads
17190 */
17191
17192 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
17193
17194 uint i_threads_cnt = 0;
17195
17196 hc_thread_t *i_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17197
17198 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17199 {
17200 if (stdout_flag == 0)
17201 {
17202 hc_thread_create (i_threads[i_threads_cnt], thread_keypress, &benchmark);
17203
17204 i_threads_cnt++;
17205 }
17206 }
17207
17208 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
17209
17210 uint ni_threads_cnt = 0;
17211
17212 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17213
17214 if (stdout_flag == 0)
17215 {
17216 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
17217
17218 ni_threads_cnt++;
17219 }
17220
17221 /**
17222 * Outfile remove
17223 */
17224
17225 if (keyspace == 0)
17226 {
17227 if (outfile_check_timer != 0)
17228 {
17229 if (data.outfile_check_directory != NULL)
17230 {
17231 if ((hash_mode != 5200) &&
17232 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
17233 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
17234 (hash_mode != 9000))
17235 {
17236 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
17237
17238 ni_threads_cnt++;
17239 }
17240 else
17241 {
17242 outfile_check_timer = 0;
17243 }
17244 }
17245 else
17246 {
17247 outfile_check_timer = 0;
17248 }
17249 }
17250 }
17251
17252 /**
17253 * Inform the user if we got some hashes remove because of the pot file remove feature
17254 */
17255
17256 if (data.quiet == 0)
17257 {
17258 if (potfile_remove_cracks > 0)
17259 {
17260 if (potfile_remove_cracks == 1) log_info ("INFO: Removed 1 hash found in pot file\n");
17261 else log_info ("INFO: Removed %u hashes found in pot file\n", potfile_remove_cracks);
17262 }
17263 }
17264
17265 data.outfile_check_timer = outfile_check_timer;
17266
17267 /**
17268 * main loop
17269 */
17270
17271 char **induction_dictionaries = NULL;
17272
17273 int induction_dictionaries_cnt = 0;
17274
17275 hcstat_table_t *root_table_buf = NULL;
17276 hcstat_table_t *markov_table_buf = NULL;
17277
17278 uint initial_restore_done = 0;
17279
17280 data.maskcnt = maskcnt;
17281
17282 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
17283 {
17284 if (data.devices_status == STATUS_CRACKED) break;
17285
17286 data.devices_status = STATUS_INIT;
17287
17288 if (maskpos > rd->maskpos)
17289 {
17290 rd->dictpos = 0;
17291 }
17292
17293 rd->maskpos = maskpos;
17294 data.maskpos = maskpos;
17295
17296 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
17297 {
17298 char *mask = masks[maskpos];
17299
17300 if (mask_from_file == 1)
17301 {
17302 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
17303
17304 char *str_ptr;
17305 uint str_pos;
17306
17307 uint mask_offset = 0;
17308
17309 uint separator_cnt;
17310
17311 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
17312 {
17313 str_ptr = strstr (mask + mask_offset, ",");
17314
17315 if (str_ptr == NULL) break;
17316
17317 str_pos = str_ptr - mask;
17318
17319 // escaped separator, i.e. "\,"
17320
17321 if (str_pos > 0)
17322 {
17323 if (mask[str_pos - 1] == '\\')
17324 {
17325 separator_cnt --;
17326
17327 mask_offset = str_pos + 1;
17328
17329 continue;
17330 }
17331 }
17332
17333 // reset the offset
17334
17335 mask_offset = 0;
17336
17337 mask[str_pos] = '\0';
17338
17339 switch (separator_cnt)
17340 {
17341 case 0:
17342 mp_reset_usr (mp_usr, 0);
17343
17344 custom_charset_1 = mask;
17345 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17346 break;
17347
17348 case 1:
17349 mp_reset_usr (mp_usr, 1);
17350
17351 custom_charset_2 = mask;
17352 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17353 break;
17354
17355 case 2:
17356 mp_reset_usr (mp_usr, 2);
17357
17358 custom_charset_3 = mask;
17359 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17360 break;
17361
17362 case 3:
17363 mp_reset_usr (mp_usr, 3);
17364
17365 custom_charset_4 = mask;
17366 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
17367 break;
17368 }
17369
17370 mask = mask + str_pos + 1;
17371 }
17372 }
17373
17374 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17375 {
17376 if (maskpos > 0)
17377 {
17378 local_free (css_buf);
17379 local_free (data.root_css_buf);
17380 local_free (data.markov_css_buf);
17381
17382 local_free (masks[maskpos - 1]);
17383 }
17384
17385 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17386
17387 data.mask = mask;
17388 data.css_cnt = css_cnt;
17389 data.css_buf = css_buf;
17390
17391 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17392
17393 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17394
17395 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17396 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17397
17398 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17399
17400 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17401
17402 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17403 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17404
17405 data.root_css_buf = root_css_buf;
17406 data.markov_css_buf = markov_css_buf;
17407
17408 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17409
17410 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17411
17412 local_free (root_table_buf);
17413 local_free (markov_table_buf);
17414
17415 // args
17416
17417 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17418 {
17419 hc_device_param_t *device_param = &data.devices_param[device_id];
17420
17421 if (device_param->skipped) continue;
17422
17423 device_param->kernel_params_mp[0] = &device_param->d_combs;
17424 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
17425 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
17426
17427 device_param->kernel_params_mp_buf64[3] = 0;
17428 device_param->kernel_params_mp_buf32[4] = css_cnt;
17429 device_param->kernel_params_mp_buf32[5] = 0;
17430 device_param->kernel_params_mp_buf32[6] = 0;
17431 device_param->kernel_params_mp_buf32[7] = 0;
17432
17433 if (attack_mode == ATTACK_MODE_HYBRID1)
17434 {
17435 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
17436 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
17437 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
17438 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
17439 }
17440 else if (attack_mode == ATTACK_MODE_HYBRID2)
17441 {
17442 device_param->kernel_params_mp_buf32[5] = 0;
17443 device_param->kernel_params_mp_buf32[6] = 0;
17444 device_param->kernel_params_mp_buf32[7] = 0;
17445 }
17446
17447 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
17448 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
17449 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
17450
17451 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_root_css_buf, CL_TRUE, 0, device_param->size_root_css, root_css_buf, 0, NULL, NULL);
17452 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, markov_css_buf, 0, NULL, NULL);
17453 }
17454 }
17455 else if (attack_mode == ATTACK_MODE_BF)
17456 {
17457 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
17458
17459 if (increment)
17460 {
17461 for (uint i = 0; i < dictcnt; i++)
17462 {
17463 local_free (dictfiles[i]);
17464 }
17465
17466 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17467 {
17468 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17469
17470 if (l1_filename == NULL) break;
17471
17472 dictcnt++;
17473
17474 dictfiles[dictcnt - 1] = l1_filename;
17475 }
17476 }
17477 else
17478 {
17479 dictcnt++;
17480
17481 dictfiles[dictcnt - 1] = mask;
17482 }
17483
17484 if (dictcnt == 0)
17485 {
17486 log_error ("ERROR: Mask is too small");
17487
17488 return (-1);
17489 }
17490 }
17491 }
17492
17493 free (induction_dictionaries);
17494
17495 // induction_dictionaries_cnt = 0; // implied
17496
17497 if (attack_mode != ATTACK_MODE_BF)
17498 {
17499 if (keyspace == 0)
17500 {
17501 induction_dictionaries = scan_directory (induction_directory);
17502
17503 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17504 }
17505 }
17506
17507 if (induction_dictionaries_cnt)
17508 {
17509 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17510 }
17511
17512 /**
17513 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17514 */
17515 if (keyspace == 1)
17516 {
17517 if ((maskcnt > 1) || (dictcnt > 1))
17518 {
17519 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17520
17521 return (-1);
17522 }
17523 }
17524
17525 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17526 {
17527 char *subid = logfile_generate_subid ();
17528
17529 data.subid = subid;
17530
17531 logfile_sub_msg ("START");
17532
17533 data.devices_status = STATUS_INIT;
17534
17535 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17536 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17537 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17538
17539 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17540
17541 data.cpt_pos = 0;
17542
17543 data.cpt_start = time (NULL);
17544
17545 data.cpt_total = 0;
17546
17547 if (data.restore == 0)
17548 {
17549 rd->words_cur = skip;
17550
17551 skip = 0;
17552
17553 data.skip = 0;
17554 }
17555
17556 data.ms_paused = 0;
17557
17558 data.kernel_power_final = 0;
17559
17560 data.words_cur = rd->words_cur;
17561
17562 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17563 {
17564 hc_device_param_t *device_param = &data.devices_param[device_id];
17565
17566 if (device_param->skipped) continue;
17567
17568 device_param->speed_pos = 0;
17569
17570 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17571 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17572
17573 device_param->exec_pos = 0;
17574
17575 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17576
17577 device_param->outerloop_pos = 0;
17578 device_param->outerloop_left = 0;
17579 device_param->innerloop_pos = 0;
17580 device_param->innerloop_left = 0;
17581
17582 // some more resets:
17583
17584 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17585
17586 device_param->pws_cnt = 0;
17587
17588 device_param->words_off = 0;
17589 device_param->words_done = 0;
17590 }
17591
17592 // figure out some workload
17593
17594 if (attack_mode == ATTACK_MODE_STRAIGHT)
17595 {
17596 if (data.wordlist_mode == WL_MODE_FILE)
17597 {
17598 char *dictfile = NULL;
17599
17600 if (induction_dictionaries_cnt)
17601 {
17602 dictfile = induction_dictionaries[0];
17603 }
17604 else
17605 {
17606 dictfile = dictfiles[dictpos];
17607 }
17608
17609 data.dictfile = dictfile;
17610
17611 logfile_sub_string (dictfile);
17612
17613 for (uint i = 0; i < rp_files_cnt; i++)
17614 {
17615 logfile_sub_var_string ("rulefile", rp_files[i]);
17616 }
17617
17618 FILE *fd2 = fopen (dictfile, "rb");
17619
17620 if (fd2 == NULL)
17621 {
17622 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17623
17624 return (-1);
17625 }
17626
17627 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17628
17629 fclose (fd2);
17630
17631 if (data.words_cnt == 0)
17632 {
17633 if (data.devices_status == STATUS_CRACKED) break;
17634 if (data.devices_status == STATUS_ABORTED) break;
17635
17636 dictpos++;
17637
17638 continue;
17639 }
17640 }
17641 }
17642 else if (attack_mode == ATTACK_MODE_COMBI)
17643 {
17644 char *dictfile = data.dictfile;
17645 char *dictfile2 = data.dictfile2;
17646
17647 logfile_sub_string (dictfile);
17648 logfile_sub_string (dictfile2);
17649
17650 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17651 {
17652 FILE *fd2 = fopen (dictfile, "rb");
17653
17654 if (fd2 == NULL)
17655 {
17656 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17657
17658 return (-1);
17659 }
17660
17661 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17662
17663 fclose (fd2);
17664 }
17665 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17666 {
17667 FILE *fd2 = fopen (dictfile2, "rb");
17668
17669 if (fd2 == NULL)
17670 {
17671 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17672
17673 return (-1);
17674 }
17675
17676 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17677
17678 fclose (fd2);
17679 }
17680
17681 if (data.words_cnt == 0)
17682 {
17683 if (data.devices_status == STATUS_CRACKED) break;
17684 if (data.devices_status == STATUS_ABORTED) break;
17685
17686 dictpos++;
17687
17688 continue;
17689 }
17690 }
17691 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17692 {
17693 char *dictfile = NULL;
17694
17695 if (induction_dictionaries_cnt)
17696 {
17697 dictfile = induction_dictionaries[0];
17698 }
17699 else
17700 {
17701 dictfile = dictfiles[dictpos];
17702 }
17703
17704 data.dictfile = dictfile;
17705
17706 char *mask = data.mask;
17707
17708 logfile_sub_string (dictfile);
17709 logfile_sub_string (mask);
17710
17711 FILE *fd2 = fopen (dictfile, "rb");
17712
17713 if (fd2 == NULL)
17714 {
17715 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17716
17717 return (-1);
17718 }
17719
17720 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17721
17722 fclose (fd2);
17723
17724 if (data.words_cnt == 0)
17725 {
17726 if (data.devices_status == STATUS_CRACKED) break;
17727 if (data.devices_status == STATUS_ABORTED) break;
17728
17729 dictpos++;
17730
17731 continue;
17732 }
17733 }
17734 else if (attack_mode == ATTACK_MODE_BF)
17735 {
17736 local_free (css_buf);
17737 local_free (data.root_css_buf);
17738 local_free (data.markov_css_buf);
17739
17740 char *mask = dictfiles[dictpos];
17741
17742 logfile_sub_string (mask);
17743
17744 // base
17745
17746 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17747
17748 if (opts_type & OPTS_TYPE_PT_UNICODE)
17749 {
17750 uint css_cnt_unicode = css_cnt * 2;
17751
17752 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17753
17754 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17755 {
17756 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17757
17758 css_buf_unicode[j + 1].cs_buf[0] = 0;
17759 css_buf_unicode[j + 1].cs_len = 1;
17760 }
17761
17762 free (css_buf);
17763
17764 css_buf = css_buf_unicode;
17765 css_cnt = css_cnt_unicode;
17766 }
17767
17768 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17769
17770 uint mask_min = pw_min;
17771 uint mask_max = pw_max;
17772
17773 if (opts_type & OPTS_TYPE_PT_UNICODE)
17774 {
17775 mask_min *= 2;
17776 mask_max *= 2;
17777 }
17778
17779 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17780 {
17781 if (css_cnt < mask_min)
17782 {
17783 log_info ("WARNING: Skipping mask '%s' because it is smaller than the minimum password length", mask);
17784 }
17785
17786 if (css_cnt > mask_max)
17787 {
17788 log_info ("WARNING: Skipping mask '%s' because it is larger than the maximum password length", mask);
17789 }
17790
17791 // skip to next mask
17792
17793 dictpos++;
17794
17795 rd->dictpos = dictpos;
17796
17797 logfile_sub_msg ("STOP");
17798
17799 continue;
17800 }
17801
17802 uint save_css_cnt = css_cnt;
17803
17804 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17805 {
17806 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17807 {
17808 uint salt_len = (uint) data.salts_buf[0].salt_len;
17809 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17810
17811 uint css_cnt_salt = css_cnt + salt_len;
17812
17813 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17814
17815 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17816
17817 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17818 {
17819 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17820 css_buf_salt[j].cs_len = 1;
17821 }
17822
17823 free (css_buf);
17824
17825 css_buf = css_buf_salt;
17826 css_cnt = css_cnt_salt;
17827 }
17828 }
17829
17830 data.mask = mask;
17831 data.css_cnt = css_cnt;
17832 data.css_buf = css_buf;
17833
17834 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17835
17836 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17837
17838 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17839
17840 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17841 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17842
17843 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17844
17845 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17846
17847 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17848 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17849
17850 data.root_css_buf = root_css_buf;
17851 data.markov_css_buf = markov_css_buf;
17852
17853 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17854
17855 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17856
17857 local_free (root_table_buf);
17858 local_free (markov_table_buf);
17859
17860 // copy + args
17861
17862 uint css_cnt_l = css_cnt;
17863 uint css_cnt_r;
17864
17865 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17866 {
17867 if (save_css_cnt < 6)
17868 {
17869 css_cnt_r = 1;
17870 }
17871 else if (save_css_cnt == 6)
17872 {
17873 css_cnt_r = 2;
17874 }
17875 else
17876 {
17877 if (opts_type & OPTS_TYPE_PT_UNICODE)
17878 {
17879 if (save_css_cnt == 8 || save_css_cnt == 10)
17880 {
17881 css_cnt_r = 2;
17882 }
17883 else
17884 {
17885 css_cnt_r = 4;
17886 }
17887 }
17888 else
17889 {
17890 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17891 {
17892 css_cnt_r = 3;
17893 }
17894 else
17895 {
17896 css_cnt_r = 4;
17897 }
17898 }
17899 }
17900 }
17901 else
17902 {
17903 css_cnt_r = 1;
17904
17905 /* unfinished code?
17906 int sum = css_buf[css_cnt_r - 1].cs_len;
17907
17908 for (uint i = 1; i < 4 && i < css_cnt; i++)
17909 {
17910 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17911
17912 css_cnt_r++;
17913
17914 sum *= css_buf[css_cnt_r - 1].cs_len;
17915 }
17916 */
17917 }
17918
17919 css_cnt_l -= css_cnt_r;
17920
17921 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17922
17923 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17924 {
17925 hc_device_param_t *device_param = &data.devices_param[device_id];
17926
17927 if (device_param->skipped) continue;
17928
17929 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17930 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17931 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17932
17933 device_param->kernel_params_mp_l_buf64[3] = 0;
17934 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17935 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17936 device_param->kernel_params_mp_l_buf32[6] = 0;
17937 device_param->kernel_params_mp_l_buf32[7] = 0;
17938 device_param->kernel_params_mp_l_buf32[8] = 0;
17939
17940 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17941 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17942 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17943 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17944
17945 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17946 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17947 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17948
17949 device_param->kernel_params_mp_r_buf64[3] = 0;
17950 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17951 device_param->kernel_params_mp_r_buf32[5] = 0;
17952 device_param->kernel_params_mp_r_buf32[6] = 0;
17953 device_param->kernel_params_mp_r_buf32[7] = 0;
17954
17955 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_l[i]);
17956 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_l[i]);
17957 for (uint i = 4; i < 9; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_l[i]);
17958
17959 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_r[i]);
17960 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_r[i]);
17961 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_r[i]);
17962
17963 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_root_css_buf, CL_TRUE, 0, device_param->size_root_css, root_css_buf, 0, NULL, NULL);
17964 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, markov_css_buf, 0, NULL, NULL);
17965 }
17966 }
17967
17968 u64 words_base = data.words_cnt;
17969
17970 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17971 {
17972 if (data.kernel_rules_cnt)
17973 {
17974 words_base /= data.kernel_rules_cnt;
17975 }
17976 }
17977 else if (data.attack_kern == ATTACK_KERN_COMBI)
17978 {
17979 if (data.combs_cnt)
17980 {
17981 words_base /= data.combs_cnt;
17982 }
17983 }
17984 else if (data.attack_kern == ATTACK_KERN_BF)
17985 {
17986 if (data.bfs_cnt)
17987 {
17988 words_base /= data.bfs_cnt;
17989 }
17990 }
17991
17992 data.words_base = words_base;
17993
17994 if (keyspace == 1)
17995 {
17996 log_info ("%llu", (unsigned long long int) words_base);
17997
17998 return (0);
17999 }
18000
18001 if (data.words_cur > data.words_base)
18002 {
18003 log_error ("ERROR: Restore value greater keyspace");
18004
18005 return (-1);
18006 }
18007
18008 if (data.words_cur)
18009 {
18010 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18011 {
18012 for (uint i = 0; i < data.salts_cnt; i++)
18013 {
18014 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
18015 }
18016 }
18017 else if (data.attack_kern == ATTACK_KERN_COMBI)
18018 {
18019 for (uint i = 0; i < data.salts_cnt; i++)
18020 {
18021 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
18022 }
18023 }
18024 else if (data.attack_kern == ATTACK_KERN_BF)
18025 {
18026 for (uint i = 0; i < data.salts_cnt; i++)
18027 {
18028 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
18029 }
18030 }
18031 }
18032
18033 /*
18034 * Update loopback file
18035 */
18036
18037 if (loopback == 1)
18038 {
18039 time_t now;
18040
18041 time (&now);
18042
18043 uint random_num = get_random_num (0, 9999);
18044
18045 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
18046
18047 data.loopback_file = loopback_file;
18048 }
18049
18050 /*
18051 * Update dictionary statistic
18052 */
18053
18054 if (keyspace == 0)
18055 {
18056 dictstat_fp = fopen (dictstat, "wb");
18057
18058 if (dictstat_fp)
18059 {
18060 lock_file (dictstat_fp);
18061
18062 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
18063
18064 fclose (dictstat_fp);
18065 }
18066 }
18067
18068 /**
18069 * create autotune threads
18070 */
18071
18072 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
18073
18074 data.devices_status = STATUS_AUTOTUNE;
18075
18076 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18077 {
18078 hc_device_param_t *device_param = &devices_param[device_id];
18079
18080 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
18081 }
18082
18083 hc_thread_wait (data.devices_cnt, c_threads);
18084
18085 /*
18086 * Inform user about possible slow speeds
18087 */
18088
18089 uint hardware_power_all = 0;
18090
18091 uint kernel_power_all = 0;
18092
18093 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18094 {
18095 hc_device_param_t *device_param = &devices_param[device_id];
18096
18097 hardware_power_all += device_param->hardware_power;
18098
18099 kernel_power_all += device_param->kernel_power;
18100 }
18101
18102 data.hardware_power_all = hardware_power_all; // hardware_power_all is the same as kernel_power_all but without the influence of kernel_accel on the devices
18103
18104 data.kernel_power_all = kernel_power_all;
18105
18106 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18107 {
18108 if (data.words_base < kernel_power_all)
18109 {
18110 if (quiet == 0)
18111 {
18112 clear_prompt ();
18113
18114 log_info ("ATTENTION!");
18115 log_info (" The wordlist or mask you are using is too small.");
18116 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
18117 log_info (" The cracking speed will drop.");
18118 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
18119 log_info ("");
18120 }
18121 }
18122 }
18123
18124 /**
18125 * create cracker threads
18126 */
18127
18128 data.devices_status = STATUS_RUNNING;
18129
18130 if (initial_restore_done == 0)
18131 {
18132 if (data.restore_disable == 0) cycle_restore ();
18133
18134 initial_restore_done = 1;
18135 }
18136
18137 hc_timer_set (&data.timer_running);
18138
18139 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18140 {
18141 if ((quiet == 0) && (status == 0) && (benchmark == 0))
18142 {
18143 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
18144 if (quiet == 0) fflush (stdout);
18145 }
18146 }
18147 else if (wordlist_mode == WL_MODE_STDIN)
18148 {
18149 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
18150 if (data.quiet == 0) log_info ("");
18151 }
18152
18153 time_t runtime_start;
18154
18155 time (&runtime_start);
18156
18157 data.runtime_start = runtime_start;
18158
18159 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18160 {
18161 hc_device_param_t *device_param = &devices_param[device_id];
18162
18163 if (wordlist_mode == WL_MODE_STDIN)
18164 {
18165 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
18166 }
18167 else
18168 {
18169 hc_thread_create (c_threads[device_id], thread_calc, device_param);
18170 }
18171 }
18172
18173 hc_thread_wait (data.devices_cnt, c_threads);
18174
18175 local_free (c_threads);
18176
18177 data.restore = 0;
18178
18179 // finalize task
18180
18181 logfile_sub_var_uint ("status-after-work", data.devices_status);
18182
18183 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18184
18185 if (data.devices_status == STATUS_CRACKED) break;
18186 if (data.devices_status == STATUS_ABORTED) break;
18187
18188 if (data.devices_status == STATUS_BYPASS)
18189 {
18190 data.devices_status = STATUS_RUNNING;
18191 }
18192
18193 if (induction_dictionaries_cnt)
18194 {
18195 unlink (induction_dictionaries[0]);
18196 }
18197
18198 free (induction_dictionaries);
18199
18200 if (attack_mode != ATTACK_MODE_BF)
18201 {
18202 induction_dictionaries = scan_directory (induction_directory);
18203
18204 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18205 }
18206
18207 if (benchmark == 0)
18208 {
18209 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
18210 {
18211 if (quiet == 0) clear_prompt ();
18212
18213 if (quiet == 0) log_info ("");
18214
18215 if (status == 1)
18216 {
18217 status_display ();
18218 }
18219 else
18220 {
18221 if (quiet == 0) status_display ();
18222 }
18223
18224 if (quiet == 0) log_info ("");
18225 }
18226 }
18227
18228 if (attack_mode == ATTACK_MODE_BF)
18229 {
18230 dictpos++;
18231
18232 rd->dictpos = dictpos;
18233 }
18234 else
18235 {
18236 if (induction_dictionaries_cnt)
18237 {
18238 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18239 }
18240 else
18241 {
18242 dictpos++;
18243
18244 rd->dictpos = dictpos;
18245 }
18246 }
18247
18248 time_t runtime_stop;
18249
18250 time (&runtime_stop);
18251
18252 data.runtime_stop = runtime_stop;
18253
18254 logfile_sub_uint (runtime_start);
18255 logfile_sub_uint (runtime_stop);
18256
18257 logfile_sub_msg ("STOP");
18258
18259 global_free (subid);
18260 }
18261
18262 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18263
18264 if (data.devices_status == STATUS_CRACKED) break;
18265 if (data.devices_status == STATUS_ABORTED) break;
18266 if (data.devices_status == STATUS_QUIT) break;
18267
18268 if (data.devices_status == STATUS_BYPASS)
18269 {
18270 data.devices_status = STATUS_RUNNING;
18271 }
18272 }
18273
18274 // 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
18275
18276 if (attack_mode == ATTACK_MODE_STRAIGHT)
18277 {
18278 if (data.wordlist_mode == WL_MODE_FILE)
18279 {
18280 if (data.dictfile == NULL)
18281 {
18282 if (dictfiles != NULL)
18283 {
18284 data.dictfile = dictfiles[0];
18285
18286 hc_timer_set (&data.timer_running);
18287 }
18288 }
18289 }
18290 }
18291 // NOTE: combi is okay because it is already set beforehand
18292 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
18293 {
18294 if (data.dictfile == NULL)
18295 {
18296 if (dictfiles != NULL)
18297 {
18298 hc_timer_set (&data.timer_running);
18299
18300 data.dictfile = dictfiles[0];
18301 }
18302 }
18303 }
18304 else if (attack_mode == ATTACK_MODE_BF)
18305 {
18306 if (data.mask == NULL)
18307 {
18308 hc_timer_set (&data.timer_running);
18309
18310 data.mask = masks[0];
18311 }
18312 }
18313
18314 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18315 {
18316 data.devices_status = STATUS_EXHAUSTED;
18317 }
18318
18319 // if cracked / aborted remove last induction dictionary
18320
18321 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
18322 {
18323 struct stat induct_stat;
18324
18325 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
18326 {
18327 unlink (induction_dictionaries[file_pos]);
18328 }
18329 }
18330
18331 // wait for non-interactive threads
18332
18333 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
18334 {
18335 hc_thread_wait (1, &ni_threads[thread_idx]);
18336 }
18337
18338 local_free (ni_threads);
18339
18340 // wait for interactive threads
18341
18342 for (uint thread_idx = 0; thread_idx < i_threads_cnt; thread_idx++)
18343 {
18344 hc_thread_wait (1, &i_threads[thread_idx]);
18345 }
18346
18347 local_free (i_threads);
18348
18349 // we dont need restore file anymore
18350 if (data.restore_disable == 0)
18351 {
18352 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
18353 {
18354 unlink (eff_restore_file);
18355 unlink (new_restore_file);
18356 }
18357 else
18358 {
18359 cycle_restore ();
18360 }
18361 }
18362
18363 // finally save left hashes
18364
18365 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
18366 {
18367 save_hash ();
18368 }
18369
18370 /**
18371 * Clean up
18372 */
18373
18374 if (benchmark == 1)
18375 {
18376 status_benchmark ();
18377
18378 if (machine_readable == 0)
18379 {
18380 log_info ("");
18381 }
18382 }
18383 else
18384 {
18385 if (quiet == 0) clear_prompt ();
18386
18387 if (quiet == 0) log_info ("");
18388
18389 if (status == 1)
18390 {
18391 status_display ();
18392 }
18393 else
18394 {
18395 if (quiet == 0) status_display ();
18396 }
18397
18398 if (quiet == 0) log_info ("");
18399 }
18400
18401 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18402 {
18403 hc_device_param_t *device_param = &data.devices_param[device_id];
18404
18405 if (device_param->skipped) continue;
18406
18407 local_free (device_param->combs_buf);
18408
18409 local_free (device_param->hooks_buf);
18410
18411 local_free (device_param->device_name);
18412
18413 local_free (device_param->device_name_chksum);
18414
18415 local_free (device_param->device_version);
18416
18417 local_free (device_param->driver_version);
18418
18419 if (device_param->pws_buf) myfree (device_param->pws_buf);
18420 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
18421 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
18422 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
18423 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
18424 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
18425 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
18426 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
18427 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
18428 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
18429 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
18430 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
18431 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
18432 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
18433 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
18434 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
18435 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
18436 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
18437 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
18438 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
18439 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
18440 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
18441 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
18442 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
18443 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
18444 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
18445 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
18446 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
18447 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
18448
18449 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
18450 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
18451 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
18452 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
18453 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
18454 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
18455 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
18456 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
18457 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
18458 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
18459 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
18460
18461 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
18462 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
18463 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
18464
18465 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
18466 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
18467 }
18468
18469 // reset default fan speed
18470
18471 #ifdef HAVE_HWMON
18472 if (gpu_temp_disable == 0)
18473 {
18474 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
18475 {
18476 hc_thread_mutex_lock (mux_adl);
18477
18478 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18479 {
18480 hc_device_param_t *device_param = &data.devices_param[device_id];
18481
18482 if (device_param->skipped) continue;
18483
18484 if (data.hm_device[device_id].fan_set_supported == 1)
18485 {
18486 int fanspeed = temp_retain_fanspeed_value[device_id];
18487 int fanpolicy = temp_retain_fanpolicy_value[device_id];
18488
18489 if (fanpolicy == 1)
18490 {
18491 int rc = -1;
18492
18493 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18494 {
18495 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
18496 }
18497 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18498 {
18499 #ifdef LINUX
18500 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE);
18501 #endif
18502
18503 #ifdef WIN
18504 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, fanpolicy);
18505 #endif
18506 }
18507
18508 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18509 }
18510 }
18511 }
18512
18513 hc_thread_mutex_unlock (mux_adl);
18514 }
18515 }
18516
18517 // reset power tuning
18518
18519 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
18520 {
18521 hc_thread_mutex_lock (mux_adl);
18522
18523 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18524 {
18525 hc_device_param_t *device_param = &data.devices_param[device_id];
18526
18527 if (device_param->skipped) continue;
18528
18529 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18530 {
18531 if (data.hm_device[device_id].od_version == 6)
18532 {
18533 // check powertune capabilities first, if not available then skip device
18534
18535 int powertune_supported = 0;
18536
18537 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18538 {
18539 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18540
18541 return (-1);
18542 }
18543
18544 if (powertune_supported != 0)
18545 {
18546 // powercontrol settings
18547
18548 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18549 {
18550 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18551
18552 return (-1);
18553 }
18554
18555 // clocks
18556
18557 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18558
18559 performance_state->iNumberOfPerformanceLevels = 2;
18560
18561 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18562 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18563 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18564 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18565
18566 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18567 {
18568 log_info ("ERROR: Failed to restore ADL performance state");
18569
18570 return (-1);
18571 }
18572
18573 local_free (performance_state);
18574 }
18575 }
18576 }
18577
18578 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18579 {
18580 unsigned int limit = nvml_power_limit[device_id];
18581
18582 if (limit > 0)
18583 {
18584 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18585 }
18586 }
18587 }
18588
18589 hc_thread_mutex_unlock (mux_adl);
18590 }
18591
18592 if (gpu_temp_disable == 0)
18593 {
18594 if (data.hm_nvml)
18595 {
18596 hm_NVML_nvmlShutdown (data.hm_nvml);
18597
18598 nvml_close (data.hm_nvml);
18599
18600 data.hm_nvml = NULL;
18601 }
18602
18603 if (data.hm_nvapi)
18604 {
18605 hm_NvAPI_Unload (data.hm_nvapi);
18606
18607 nvapi_close (data.hm_nvapi);
18608
18609 data.hm_nvapi = NULL;
18610 }
18611
18612 if (data.hm_xnvctrl)
18613 {
18614 hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);
18615
18616 xnvctrl_close (data.hm_xnvctrl);
18617
18618 data.hm_xnvctrl = NULL;
18619 }
18620
18621 if (data.hm_adl)
18622 {
18623 hm_ADL_Main_Control_Destroy (data.hm_adl);
18624
18625 adl_close (data.hm_adl);
18626
18627 data.hm_adl = NULL;
18628 }
18629 }
18630 #endif // HAVE_HWMON
18631
18632 // free memory
18633
18634 local_free (masks);
18635
18636 local_free (dictstat_base);
18637
18638 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18639 {
18640 pot_t *pot_ptr = &pot[pot_pos];
18641
18642 hash_t *hash = &pot_ptr->hash;
18643
18644 local_free (hash->digest);
18645
18646 if (isSalted)
18647 {
18648 local_free (hash->salt);
18649 }
18650 }
18651
18652 local_free (pot);
18653
18654 local_free (all_kernel_rules_cnt);
18655 local_free (all_kernel_rules_buf);
18656
18657 local_free (wl_data->buf);
18658 local_free (wl_data);
18659
18660 local_free (bitmap_s1_a);
18661 local_free (bitmap_s1_b);
18662 local_free (bitmap_s1_c);
18663 local_free (bitmap_s1_d);
18664 local_free (bitmap_s2_a);
18665 local_free (bitmap_s2_b);
18666 local_free (bitmap_s2_c);
18667 local_free (bitmap_s2_d);
18668
18669 #ifdef HAVE_HWMON
18670 local_free (temp_retain_fanspeed_value);
18671 local_free (od_clock_mem_status);
18672 local_free (od_power_control_status);
18673 local_free (nvml_power_limit);
18674 #endif
18675
18676 global_free (devices_param);
18677
18678 global_free (kernel_rules_buf);
18679
18680 global_free (root_css_buf);
18681 global_free (markov_css_buf);
18682
18683 global_free (digests_buf);
18684 global_free (digests_shown);
18685 global_free (digests_shown_tmp);
18686
18687 global_free (salts_buf);
18688 global_free (salts_shown);
18689
18690 global_free (esalts_buf);
18691
18692 global_free (words_progress_done);
18693 global_free (words_progress_rejected);
18694 global_free (words_progress_restored);
18695
18696 if (pot_fp) fclose (pot_fp);
18697
18698 if (data.devices_status == STATUS_QUIT) break;
18699 }
18700
18701 // destroy others mutex
18702
18703 hc_thread_mutex_delete (mux_dispatcher);
18704 hc_thread_mutex_delete (mux_counter);
18705 hc_thread_mutex_delete (mux_display);
18706 hc_thread_mutex_delete (mux_adl);
18707
18708 // free memory
18709
18710 local_free (eff_restore_file);
18711 local_free (new_restore_file);
18712
18713 local_free (rd);
18714
18715 // tuning db
18716
18717 tuning_db_destroy (tuning_db);
18718
18719 // loopback
18720
18721 local_free (loopback_file);
18722
18723 if (loopback == 1) unlink (loopback_file);
18724
18725 // induction directory
18726
18727 if (induction_dir == NULL)
18728 {
18729 if (attack_mode != ATTACK_MODE_BF)
18730 {
18731 if (rmdir (induction_directory) == -1)
18732 {
18733 if (errno == ENOENT)
18734 {
18735 // good, we can ignore
18736 }
18737 else if (errno == ENOTEMPTY)
18738 {
18739 // good, we can ignore
18740 }
18741 else
18742 {
18743 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18744
18745 return (-1);
18746 }
18747 }
18748
18749 local_free (induction_directory);
18750 }
18751 }
18752
18753 // outfile-check directory
18754
18755 if (outfile_check_dir == NULL)
18756 {
18757 if (rmdir (outfile_check_directory) == -1)
18758 {
18759 if (errno == ENOENT)
18760 {
18761 // good, we can ignore
18762 }
18763 else if (errno == ENOTEMPTY)
18764 {
18765 // good, we can ignore
18766 }
18767 else
18768 {
18769 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18770
18771 return (-1);
18772 }
18773 }
18774
18775 local_free (outfile_check_directory);
18776 }
18777
18778 time_t proc_stop;
18779
18780 time (&proc_stop);
18781
18782 logfile_top_uint (proc_start);
18783 logfile_top_uint (proc_stop);
18784
18785 logfile_top_msg ("STOP");
18786
18787 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18788 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18789
18790 if (data.ocl) ocl_close (data.ocl);
18791
18792 if (data.devices_status == STATUS_ABORTED) return 2;
18793 if (data.devices_status == STATUS_QUIT) return 2;
18794 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18795 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18796 if (data.devices_status == STATUS_CRACKED) return 0;
18797
18798 return -1;
18799 }
Hashcat additions to support pwdhash