projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Speed up startup time for --stdout by using an empty kernel
[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 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=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 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1757 }
1758
1759 char display_all_cur[16] = { 0 };
1760
1761 strncpy (display_all_cur, "0.00", 4);
1762
1763 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1764
1765 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1766 }
1767
1768 /**
1769 * hashcat -only- functions
1770 */
1771
1772 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1773 {
1774 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1775 {
1776 if (attack_kern == ATTACK_KERN_STRAIGHT)
1777 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1778 else if (attack_kern == ATTACK_KERN_COMBI)
1779 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1780 else if (attack_kern == ATTACK_KERN_BF)
1781 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1782 }
1783 else
1784 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1785 }
1786
1787 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)
1788 {
1789 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1790 {
1791 if (attack_kern == ATTACK_KERN_STRAIGHT)
1792 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1793 else if (attack_kern == ATTACK_KERN_COMBI)
1794 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1795 else if (attack_kern == ATTACK_KERN_BF)
1796 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1797 }
1798 else
1799 {
1800 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1801 }
1802 }
1803
1804 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1805 {
1806 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1807 {
1808 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1809 }
1810 else
1811 {
1812 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1813 }
1814 }
1815
1816 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)
1817 {
1818 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1819 {
1820 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1821 }
1822 else
1823 {
1824 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1825 }
1826 }
1827
1828 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1829 {
1830 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1831 }
1832
1833 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1834 {
1835 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1836 }
1837
1838 static char *filename_from_filepath (char *filepath)
1839 {
1840 char *ptr = NULL;
1841
1842 if ((ptr = strrchr (filepath, '/')) != NULL)
1843 {
1844 ptr++;
1845 }
1846 else if ((ptr = strrchr (filepath, '\\')) != NULL)
1847 {
1848 ptr++;
1849 }
1850 else
1851 {
1852 ptr = filepath;
1853 }
1854
1855 return ptr;
1856 }
1857
1858 static uint convert_from_hex (char *line_buf, const uint line_len)
1859 {
1860 if (line_len & 1) return (line_len); // not in hex
1861
1862 if (data.hex_wordlist == 1)
1863 {
1864 uint i;
1865 uint j;
1866
1867 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1868 {
1869 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1870 }
1871
1872 memset (line_buf + i, 0, line_len - i);
1873
1874 return (i);
1875 }
1876 else if (line_len >= 6) // $HEX[] = 6
1877 {
1878 if (line_buf[0] != '$') return (line_len);
1879 if (line_buf[1] != 'H') return (line_len);
1880 if (line_buf[2] != 'E') return (line_len);
1881 if (line_buf[3] != 'X') return (line_len);
1882 if (line_buf[4] != '[') return (line_len);
1883 if (line_buf[line_len - 1] != ']') return (line_len);
1884
1885 uint i;
1886 uint j;
1887
1888 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1889 {
1890 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1891 }
1892
1893 memset (line_buf + i, 0, line_len - i);
1894
1895 return (i);
1896 }
1897
1898 return (line_len);
1899 }
1900
1901 static void clear_prompt ()
1902 {
1903 fputc ('\r', stdout);
1904
1905 for (size_t i = 0; i < strlen (PROMPT); i++)
1906 {
1907 fputc (' ', stdout);
1908 }
1909
1910 fputc ('\r', stdout);
1911
1912 fflush (stdout);
1913 }
1914
1915 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1916 {
1917 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);
1918 }
1919
1920 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1921 {
1922 char *outfile = data.outfile;
1923 uint quiet = data.quiet;
1924 FILE *pot_fp = data.pot_fp;
1925 uint loopback = data.loopback;
1926 uint debug_mode = data.debug_mode;
1927 char *debug_file = data.debug_file;
1928
1929 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1930 int debug_rule_len = 0; // -1 error
1931 uint debug_plain_len = 0;
1932
1933 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1934
1935 // hash
1936
1937 char out_buf[HCBUFSIZ] = { 0 };
1938
1939 const u32 salt_pos = plain->salt_pos;
1940 const u32 digest_pos = plain->digest_pos; // relative
1941 const u32 gidvid = plain->gidvid;
1942 const u32 il_pos = plain->il_pos;
1943
1944 ascii_digest (out_buf, salt_pos, digest_pos);
1945
1946 // plain
1947
1948 u64 crackpos = device_param->words_off;
1949
1950 uint plain_buf[16] = { 0 };
1951
1952 u8 *plain_ptr = (u8 *) plain_buf;
1953
1954 unsigned int plain_len = 0;
1955
1956 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1957 {
1958 pw_t pw;
1959
1960 gidd_to_pw_t (device_param, gidvid, &pw);
1961
1962 for (int i = 0; i < 16; i++)
1963 {
1964 plain_buf[i] = pw.i[i];
1965 }
1966
1967 plain_len = pw.pw_len;
1968
1969 const uint off = device_param->innerloop_pos + il_pos;
1970
1971 if (debug_mode > 0)
1972 {
1973 debug_rule_len = 0;
1974
1975 // save rule
1976 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1977 {
1978 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1979
1980 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1981 }
1982
1983 // save plain
1984 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1985 {
1986 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1987
1988 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1989
1990 debug_plain_len = plain_len;
1991 }
1992 }
1993
1994 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1995
1996 crackpos += gidvid;
1997 crackpos *= data.kernel_rules_cnt;
1998 crackpos += device_param->innerloop_pos + il_pos;
1999
2000 if (plain_len > data.pw_max) plain_len = data.pw_max;
2001 }
2002 else if (data.attack_mode == ATTACK_MODE_COMBI)
2003 {
2004 pw_t pw;
2005
2006 gidd_to_pw_t (device_param, gidvid, &pw);
2007
2008 for (int i = 0; i < 16; i++)
2009 {
2010 plain_buf[i] = pw.i[i];
2011 }
2012
2013 plain_len = pw.pw_len;
2014
2015 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2016 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2017
2018 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2019 {
2020 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2021 }
2022 else
2023 {
2024 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2025
2026 memcpy (plain_ptr, comb_buf, comb_len);
2027 }
2028
2029 plain_len += comb_len;
2030
2031 crackpos += gidvid;
2032 crackpos *= data.combs_cnt;
2033 crackpos += device_param->innerloop_pos + il_pos;
2034
2035 if (data.pw_max != PW_DICTMAX1)
2036 {
2037 if (plain_len > data.pw_max) plain_len = data.pw_max;
2038 }
2039 }
2040 else if (data.attack_mode == ATTACK_MODE_BF)
2041 {
2042 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2043 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2044
2045 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2046 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2047
2048 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2049 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2050
2051 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2052 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2053
2054 plain_len = data.css_cnt;
2055
2056 crackpos += gidvid;
2057 crackpos *= data.bfs_cnt;
2058 crackpos += device_param->innerloop_pos + il_pos;
2059 }
2060 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2061 {
2062 pw_t pw;
2063
2064 gidd_to_pw_t (device_param, gidvid, &pw);
2065
2066 for (int i = 0; i < 16; i++)
2067 {
2068 plain_buf[i] = pw.i[i];
2069 }
2070
2071 plain_len = pw.pw_len;
2072
2073 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2074
2075 uint start = 0;
2076 uint stop = device_param->kernel_params_mp_buf32[4];
2077
2078 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2079
2080 plain_len += start + stop;
2081
2082 crackpos += gidvid;
2083 crackpos *= data.combs_cnt;
2084 crackpos += device_param->innerloop_pos + il_pos;
2085
2086 if (data.pw_max != PW_DICTMAX1)
2087 {
2088 if (plain_len > data.pw_max) plain_len = data.pw_max;
2089 }
2090 }
2091 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2092 {
2093 pw_t pw;
2094
2095 gidd_to_pw_t (device_param, gidvid, &pw);
2096
2097 for (int i = 0; i < 16; i++)
2098 {
2099 plain_buf[i] = pw.i[i];
2100 }
2101
2102 plain_len = pw.pw_len;
2103
2104 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2105
2106 uint start = 0;
2107 uint stop = device_param->kernel_params_mp_buf32[4];
2108
2109 memmove (plain_ptr + stop, plain_ptr, plain_len);
2110
2111 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2112
2113 plain_len += start + stop;
2114
2115 crackpos += gidvid;
2116 crackpos *= data.combs_cnt;
2117 crackpos += device_param->innerloop_pos + il_pos;
2118
2119 if (data.pw_max != PW_DICTMAX1)
2120 {
2121 if (plain_len > data.pw_max) plain_len = data.pw_max;
2122 }
2123 }
2124
2125 if (data.attack_mode == ATTACK_MODE_BF)
2126 {
2127 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2128 {
2129 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2130 {
2131 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2132 {
2133 plain_len = plain_len - data.salts_buf[0].salt_len;
2134 }
2135 }
2136
2137 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2138 {
2139 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2140 {
2141 plain_ptr[j] = plain_ptr[i];
2142 }
2143
2144 plain_len = plain_len / 2;
2145 }
2146 }
2147 }
2148
2149 // if enabled, update also the potfile
2150
2151 if (pot_fp)
2152 {
2153 lock_file (pot_fp);
2154
2155 fprintf (pot_fp, "%s:", out_buf);
2156
2157 format_plain (pot_fp, plain_ptr, plain_len, 1);
2158
2159 fputc ('\n', pot_fp);
2160
2161 fflush (pot_fp);
2162
2163 unlock_file (pot_fp);
2164 }
2165
2166 // outfile
2167
2168 FILE *out_fp = NULL;
2169
2170 if (outfile != NULL)
2171 {
2172 if ((out_fp = fopen (outfile, "ab")) == NULL)
2173 {
2174 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2175
2176 out_fp = stdout;
2177 }
2178
2179 lock_file (out_fp);
2180 }
2181 else
2182 {
2183 out_fp = stdout;
2184
2185 if (quiet == 0) clear_prompt ();
2186 }
2187
2188 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2189
2190 if (outfile != NULL)
2191 {
2192 if (out_fp != stdout)
2193 {
2194 fclose (out_fp);
2195 }
2196 }
2197 else
2198 {
2199 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2200 {
2201 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2202 {
2203 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2204 if (quiet == 0) fflush (stdout);
2205 }
2206 }
2207 }
2208
2209 // loopback
2210
2211 if (loopback)
2212 {
2213 char *loopback_file = data.loopback_file;
2214
2215 FILE *fb_fp = NULL;
2216
2217 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2218 {
2219 lock_file (fb_fp);
2220
2221 format_plain (fb_fp, plain_ptr, plain_len, 1);
2222
2223 fputc ('\n', fb_fp);
2224
2225 fclose (fb_fp);
2226 }
2227 }
2228
2229 // (rule) debug mode
2230
2231 // the next check implies that:
2232 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2233 // - debug_mode > 0
2234
2235 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2236 {
2237 if (debug_rule_len < 0) debug_rule_len = 0;
2238
2239 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2240
2241 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2242
2243 if ((quiet == 0) && (debug_file == NULL))
2244 {
2245 fprintf (stdout, "%s", PROMPT);
2246
2247 fflush (stdout);
2248 }
2249 }
2250 }
2251
2252 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2253 {
2254 salt_t *salt_buf = &data.salts_buf[salt_pos];
2255
2256 u32 num_cracked;
2257
2258 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2259
2260 if (num_cracked)
2261 {
2262 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2263
2264 log_info_nn ("");
2265
2266 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2267
2268 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);
2269
2270 uint cpt_cracked = 0;
2271
2272 for (uint i = 0; i < num_cracked; i++)
2273 {
2274 const uint hash_pos = cracked[i].hash_pos;
2275
2276 if (data.digests_shown[hash_pos] == 1) continue;
2277
2278 hc_thread_mutex_lock (mux_display);
2279
2280 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2281 {
2282 data.digests_shown[hash_pos] = 1;
2283
2284 data.digests_done++;
2285
2286 cpt_cracked++;
2287
2288 salt_buf->digests_done++;
2289
2290 if (salt_buf->digests_done == salt_buf->digests_cnt)
2291 {
2292 data.salts_shown[salt_pos] = 1;
2293
2294 data.salts_done++;
2295 }
2296 }
2297
2298 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2299
2300 hc_thread_mutex_unlock (mux_display);
2301
2302 check_hash (device_param, &cracked[i]);
2303 }
2304
2305 myfree (cracked);
2306
2307 if (cpt_cracked > 0)
2308 {
2309 hc_thread_mutex_lock (mux_display);
2310
2311 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2312 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2313
2314 data.cpt_pos++;
2315
2316 data.cpt_total += cpt_cracked;
2317
2318 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2319
2320 hc_thread_mutex_unlock (mux_display);
2321 }
2322
2323 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2324 {
2325 // we need to reset cracked state on the device
2326 // otherwise host thinks again and again the hash was cracked
2327 // and returns invalid password each time
2328
2329 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2330
2331 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);
2332 }
2333
2334 num_cracked = 0;
2335
2336 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2337 }
2338 }
2339
2340 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2341 {
2342 char out_buf[HCBUFSIZ] = { 0 };
2343
2344 uint plain_buf[16] = { 0 };
2345
2346 u8 *plain_ptr = (u8 *) plain_buf;
2347
2348 uint plain_len = 0;
2349
2350 const uint il_cnt = device_param->kernel_params_buf32[27]; // ugly, i know
2351
2352 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2353 {
2354 pw_t pw;
2355
2356 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2357 {
2358 gidd_to_pw_t (device_param, gidvid, &pw);
2359
2360 const uint pos = device_param->innerloop_pos;
2361
2362 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2363 {
2364 for (int i = 0; i < 8; i++)
2365 {
2366 plain_buf[i] = pw.i[i];
2367 }
2368
2369 plain_len = pw.pw_len;
2370
2371 plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2372
2373 if (plain_len > data.pw_max) plain_len = data.pw_max;
2374
2375 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2376 }
2377 }
2378 }
2379 else if (data.attack_mode == ATTACK_MODE_COMBI)
2380 {
2381 pw_t pw;
2382
2383 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2384 {
2385 gidd_to_pw_t (device_param, gidvid, &pw);
2386
2387 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2388 {
2389 for (int i = 0; i < 8; i++)
2390 {
2391 plain_buf[i] = pw.i[i];
2392 }
2393
2394 plain_len = pw.pw_len;
2395
2396 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2397 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2398
2399 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2400 {
2401 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2402 }
2403 else
2404 {
2405 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2406
2407 memcpy (plain_ptr, comb_buf, comb_len);
2408 }
2409
2410 plain_len += comb_len;
2411
2412 if (data.pw_max != PW_DICTMAX1)
2413 {
2414 if (plain_len > data.pw_max) plain_len = data.pw_max;
2415 }
2416
2417 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2418 }
2419 }
2420 }
2421 else if (data.attack_mode == ATTACK_MODE_BF)
2422 {
2423 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2424 {
2425 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2426 {
2427 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2428 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2429
2430 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2431 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2432
2433 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2434 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2435
2436 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2437 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2438
2439 plain_len = data.css_cnt;
2440
2441 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2442 }
2443 }
2444 }
2445 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2446 {
2447 pw_t pw;
2448
2449 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2450 {
2451 gidd_to_pw_t (device_param, gidvid, &pw);
2452
2453 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2454 {
2455 for (int i = 0; i < 8; i++)
2456 {
2457 plain_buf[i] = pw.i[i];
2458 }
2459
2460 plain_len = pw.pw_len;
2461
2462 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2463
2464 uint start = 0;
2465 uint stop = device_param->kernel_params_mp_buf32[4];
2466
2467 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2468
2469 plain_len += start + stop;
2470
2471 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2472 }
2473 }
2474 }
2475 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2476 {
2477 pw_t pw;
2478
2479 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2480 {
2481 gidd_to_pw_t (device_param, gidvid, &pw);
2482
2483 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2484 {
2485 for (int i = 0; i < 8; i++)
2486 {
2487 plain_buf[i] = pw.i[i];
2488 }
2489
2490 plain_len = pw.pw_len;
2491
2492 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2493
2494 uint start = 0;
2495 uint stop = device_param->kernel_params_mp_buf32[4];
2496
2497 memmove (plain_ptr + stop, plain_ptr, plain_len);
2498
2499 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2500
2501 plain_len += start + stop;
2502
2503 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2504 }
2505 }
2506 }
2507 }
2508
2509 static void save_hash ()
2510 {
2511 char *hashfile = data.hashfile;
2512
2513 char new_hashfile[256] = { 0 };
2514 char old_hashfile[256] = { 0 };
2515
2516 snprintf (new_hashfile, 255, "%s.new", hashfile);
2517 snprintf (old_hashfile, 255, "%s.old", hashfile);
2518
2519 unlink (new_hashfile);
2520
2521 char separator = data.separator;
2522
2523 FILE *fp = fopen (new_hashfile, "wb");
2524
2525 if (fp == NULL)
2526 {
2527 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2528
2529 exit (-1);
2530 }
2531
2532 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2533 {
2534 if (data.salts_shown[salt_pos] == 1) continue;
2535
2536 salt_t *salt_buf = &data.salts_buf[salt_pos];
2537
2538 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2539 {
2540 uint idx = salt_buf->digests_offset + digest_pos;
2541
2542 if (data.digests_shown[idx] == 1) continue;
2543
2544 if (data.hash_mode != 2500)
2545 {
2546 if (data.username == 1)
2547 {
2548 user_t *user = data.hash_info[idx]->user;
2549
2550 uint i;
2551
2552 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2553
2554 fputc (separator, fp);
2555 }
2556
2557 char out_buf[HCBUFSIZ]; // scratch buffer
2558
2559 out_buf[0] = 0;
2560
2561 ascii_digest (out_buf, salt_pos, digest_pos);
2562
2563 fputs (out_buf, fp);
2564
2565 fputc ('\n', fp);
2566 }
2567 else
2568 {
2569 hccap_t hccap;
2570
2571 to_hccap_t (&hccap, salt_pos, digest_pos);
2572
2573 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2574 }
2575 }
2576 }
2577
2578 fflush (fp);
2579
2580 fclose (fp);
2581
2582 unlink (old_hashfile);
2583
2584 if (rename (hashfile, old_hashfile) != 0)
2585 {
2586 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2587
2588 exit (-1);
2589 }
2590
2591 unlink (hashfile);
2592
2593 if (rename (new_hashfile, hashfile) != 0)
2594 {
2595 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2596
2597 exit (-1);
2598 }
2599
2600 unlink (old_hashfile);
2601 }
2602
2603 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2604 {
2605 uint num_elements = num;
2606
2607 device_param->kernel_params_buf32[30] = data.combs_mode;
2608 device_param->kernel_params_buf32[31] = num;
2609
2610 uint kernel_threads = device_param->kernel_threads;
2611
2612 while (num_elements % kernel_threads) num_elements++;
2613
2614 cl_kernel kernel = NULL;
2615
2616 switch (kern_run)
2617 {
2618 case KERN_RUN_1: kernel = device_param->kernel1; break;
2619 case KERN_RUN_12: kernel = device_param->kernel12; break;
2620 case KERN_RUN_2: kernel = device_param->kernel2; break;
2621 case KERN_RUN_23: kernel = device_param->kernel23; break;
2622 case KERN_RUN_3: kernel = device_param->kernel3; break;
2623 }
2624
2625 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2626 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2627 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2628 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2629 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2630 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2631 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2632 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2633 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2634 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2635 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2636
2637 cl_event event;
2638
2639 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2640 {
2641 const size_t global_work_size[3] = { num_elements, 32, 1 };
2642 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2643
2644 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2645 }
2646 else
2647 {
2648 if (kern_run == KERN_RUN_2)
2649 {
2650 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2651 {
2652 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2653 }
2654 }
2655
2656 while (num_elements % kernel_threads) num_elements++;
2657
2658 const size_t global_work_size[3] = { num_elements, 1, 1 };
2659 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2660
2661 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2662 }
2663
2664 hc_clFlush (data.ocl, device_param->command_queue);
2665
2666 if (device_param->nvidia_spin_damp)
2667 {
2668 if (data.devices_status == STATUS_RUNNING)
2669 {
2670 if (iteration < EXPECTED_ITERATIONS)
2671 {
2672 switch (kern_run)
2673 {
2674 case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration] * device_param->nvidia_spin_damp); break;
2675 case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration] * device_param->nvidia_spin_damp); break;
2676 case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration] * device_param->nvidia_spin_damp); break;
2677 }
2678 }
2679 }
2680 }
2681
2682 hc_clWaitForEvents (data.ocl, 1, &event);
2683
2684 cl_ulong time_start;
2685 cl_ulong time_end;
2686
2687 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2688 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2689
2690 const double exec_us = (double) (time_end - time_start) / 1000;
2691
2692 if (data.devices_status == STATUS_RUNNING)
2693 {
2694 if (iteration < EXPECTED_ITERATIONS)
2695 {
2696 switch (kern_run)
2697 {
2698 case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2699 case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2700 case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2701 }
2702 }
2703 }
2704
2705 if (event_update)
2706 {
2707 uint exec_pos = device_param->exec_pos;
2708
2709 device_param->exec_ms[exec_pos] = exec_us / 1000;
2710
2711 exec_pos++;
2712
2713 if (exec_pos == EXEC_CACHE)
2714 {
2715 exec_pos = 0;
2716 }
2717
2718 device_param->exec_pos = exec_pos;
2719 }
2720
2721 hc_clReleaseEvent (data.ocl, event);
2722
2723 hc_clFinish (data.ocl, device_param->command_queue);
2724 }
2725
2726 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2727 {
2728 uint num_elements = num;
2729
2730 switch (kern_run)
2731 {
2732 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2733 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2734 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2735 }
2736
2737 // causes problems with special threads like in bcrypt
2738 // const uint kernel_threads = device_param->kernel_threads;
2739
2740 uint kernel_threads = device_param->kernel_threads;
2741
2742 while (num_elements % kernel_threads) num_elements++;
2743
2744 cl_kernel kernel = NULL;
2745
2746 switch (kern_run)
2747 {
2748 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2749 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2750 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2751 }
2752
2753 switch (kern_run)
2754 {
2755 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2756 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2757 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2758 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2759 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2760 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2761 break;
2762 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2763 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2764 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2765 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2766 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2767 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2768 break;
2769 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2770 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2771 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2772 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2773 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2774 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2775 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2776 break;
2777 }
2778
2779 const size_t global_work_size[3] = { num_elements, 1, 1 };
2780 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2781
2782 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2783
2784 hc_clFlush (data.ocl, device_param->command_queue);
2785
2786 hc_clFinish (data.ocl, device_param->command_queue);
2787 }
2788
2789 static void run_kernel_tm (hc_device_param_t *device_param)
2790 {
2791 const uint num_elements = 1024; // fixed
2792
2793 uint kernel_threads = 32;
2794
2795 cl_kernel kernel = device_param->kernel_tm;
2796
2797 const size_t global_work_size[3] = { num_elements, 1, 1 };
2798 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2799
2800 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2801
2802 hc_clFlush (data.ocl, device_param->command_queue);
2803
2804 hc_clFinish (data.ocl, device_param->command_queue);
2805 }
2806
2807 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2808 {
2809 uint num_elements = num;
2810
2811 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2812 device_param->kernel_params_amp_buf32[6] = num_elements;
2813
2814 // causes problems with special threads like in bcrypt
2815 // const uint kernel_threads = device_param->kernel_threads;
2816
2817 uint kernel_threads = device_param->kernel_threads;
2818
2819 while (num_elements % kernel_threads) num_elements++;
2820
2821 cl_kernel kernel = device_param->kernel_amp;
2822
2823 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2824 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2825
2826 const size_t global_work_size[3] = { num_elements, 1, 1 };
2827 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2828
2829 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2830
2831 hc_clFlush (data.ocl, device_param->command_queue);
2832
2833 hc_clFinish (data.ocl, device_param->command_queue);
2834 }
2835
2836 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2837 {
2838 const u32 num16d = num / 16;
2839 const u32 num16m = num % 16;
2840
2841 if (num16d)
2842 {
2843 device_param->kernel_params_memset_buf32[1] = value;
2844 device_param->kernel_params_memset_buf32[2] = num16d;
2845
2846 uint kernel_threads = device_param->kernel_threads;
2847
2848 uint num_elements = num16d;
2849
2850 while (num_elements % kernel_threads) num_elements++;
2851
2852 cl_kernel kernel = device_param->kernel_memset;
2853
2854 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2855 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2856 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2857
2858 const size_t global_work_size[3] = { num_elements, 1, 1 };
2859 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2860
2861 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2862
2863 hc_clFlush (data.ocl, device_param->command_queue);
2864
2865 hc_clFinish (data.ocl, device_param->command_queue);
2866 }
2867
2868 if (num16m)
2869 {
2870 u32 tmp[4];
2871
2872 tmp[0] = value;
2873 tmp[1] = value;
2874 tmp[2] = value;
2875 tmp[3] = value;
2876
2877 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2878 }
2879 }
2880
2881 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2882 {
2883 run_kernel_memset (device_param, buf, 0, size);
2884
2885 /*
2886 int rc = -1;
2887
2888 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2889 {
2890 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2891
2892 const cl_uchar zero = 0;
2893
2894 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2895 }
2896
2897 if (rc != 0)
2898 {
2899 // NOTE: clEnqueueFillBuffer () always fails with -59
2900 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2901 // How's that possible, OpenCL 1.2 support is advertised??
2902 // We need to workaround...
2903
2904 #define FILLSZ 0x100000
2905
2906 char *tmp = (char *) mymalloc (FILLSZ);
2907
2908 for (size_t i = 0; i < size; i += FILLSZ)
2909 {
2910 const size_t left = size - i;
2911
2912 const size_t fillsz = MIN (FILLSZ, left);
2913
2914 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2915 }
2916
2917 myfree (tmp);
2918 }
2919 */
2920 }
2921
2922 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)
2923 {
2924 if (data.hash_mode == 2000)
2925 {
2926 process_stdout (device_param, pws_cnt);
2927
2928 return;
2929 }
2930
2931 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2932 {
2933 if (attack_mode == ATTACK_MODE_BF)
2934 {
2935 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2936 {
2937 const uint size_tm = 32 * sizeof (bs_word_t);
2938
2939 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2940
2941 run_kernel_tm (device_param);
2942
2943 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);
2944 }
2945 }
2946
2947 if (highest_pw_len < 16)
2948 {
2949 run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
2950 }
2951 else if (highest_pw_len < 32)
2952 {
2953 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
2954 }
2955 else
2956 {
2957 run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
2958 }
2959 }
2960 else
2961 {
2962 run_kernel_amp (device_param, pws_cnt);
2963
2964 run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
2965
2966 if (opts_type & OPTS_TYPE_HOOK12)
2967 {
2968 run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
2969
2970 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);
2971
2972 // do something with data
2973
2974 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);
2975 }
2976
2977 uint iter = salt_buf->salt_iter;
2978
2979 uint loop_step = device_param->kernel_loops;
2980
2981 for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
2982 {
2983 uint loop_left = iter - loop_pos;
2984
2985 loop_left = MIN (loop_left, loop_step);
2986
2987 device_param->kernel_params_buf32[25] = loop_pos;
2988 device_param->kernel_params_buf32[26] = loop_left;
2989
2990 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
2991
2992 if (data.devices_status == STATUS_CRACKED) break;
2993 if (data.devices_status == STATUS_ABORTED) break;
2994 if (data.devices_status == STATUS_QUIT) break;
2995
2996 /**
2997 * speed
2998 */
2999
3000 const float iter_part = (float) (loop_pos + loop_left) / iter;
3001
3002 const u64 perf_sum_all = pws_cnt * iter_part;
3003
3004 double speed_ms;
3005
3006 hc_timer_get (device_param->timer_speed, speed_ms);
3007
3008 const u32 speed_pos = device_param->speed_pos;
3009
3010 device_param->speed_cnt[speed_pos] = perf_sum_all;
3011
3012 device_param->speed_ms[speed_pos] = speed_ms;
3013
3014 if (data.benchmark == 1)
3015 {
3016 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
3017 }
3018 }
3019
3020 if (opts_type & OPTS_TYPE_HOOK23)
3021 {
3022 run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
3023
3024 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);
3025
3026 // do something with data
3027
3028 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);
3029 }
3030
3031 run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3032 }
3033 }
3034
3035 static int run_rule_engine (const int rule_len, const char *rule_buf)
3036 {
3037 if (rule_len == 0)
3038 {
3039 return 0;
3040 }
3041 else if (rule_len == 1)
3042 {
3043 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3044 }
3045
3046 return 1;
3047 }
3048
3049 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3050 {
3051 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3052 {
3053 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);
3054 }
3055 else if (data.attack_kern == ATTACK_KERN_COMBI)
3056 {
3057 if (data.attack_mode == ATTACK_MODE_COMBI)
3058 {
3059 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3060 {
3061 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3062 {
3063 for (u32 i = 0; i < pws_cnt; i++)
3064 {
3065 const u32 pw_len = device_param->pws_buf[i].pw_len;
3066
3067 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3068
3069 ptr[pw_len] = 0x01;
3070 }
3071 }
3072 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3073 {
3074 for (u32 i = 0; i < pws_cnt; i++)
3075 {
3076 const u32 pw_len = device_param->pws_buf[i].pw_len;
3077
3078 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3079
3080 ptr[pw_len] = 0x80;
3081 }
3082 }
3083 }
3084 }
3085 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3086 {
3087 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3088 {
3089 for (u32 i = 0; i < pws_cnt; i++)
3090 {
3091 const u32 pw_len = device_param->pws_buf[i].pw_len;
3092
3093 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3094
3095 ptr[pw_len] = 0x01;
3096 }
3097 }
3098 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3099 {
3100 for (u32 i = 0; i < pws_cnt; i++)
3101 {
3102 const u32 pw_len = device_param->pws_buf[i].pw_len;
3103
3104 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3105
3106 ptr[pw_len] = 0x80;
3107 }
3108 }
3109 }
3110
3111 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);
3112 }
3113 else if (data.attack_kern == ATTACK_KERN_BF)
3114 {
3115 const u64 off = device_param->words_off;
3116
3117 device_param->kernel_params_mp_l_buf64[3] = off;
3118
3119 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3120 }
3121 }
3122
3123 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3124 {
3125 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3126
3127 device_param->kernel_params_buf32[25] = 0;
3128 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
3129 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3130
3131 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3132 {
3133 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3134 }
3135 else
3136 {
3137 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3138 }
3139
3140 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3141
3142 return exec_ms_prev;
3143 }
3144
3145 static void autotune (hc_device_param_t *device_param)
3146 {
3147 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3148
3149 const u32 kernel_accel_min = device_param->kernel_accel_min;
3150 const u32 kernel_accel_max = device_param->kernel_accel_max;
3151
3152 const u32 kernel_loops_min = device_param->kernel_loops_min;
3153 const u32 kernel_loops_max = device_param->kernel_loops_max;
3154
3155 u32 kernel_accel = kernel_accel_min;
3156 u32 kernel_loops = kernel_loops_min;
3157
3158 // in this case the user specified a fixed -u and -n on the commandline
3159 // no way to tune anything
3160 // but we need to run a few caching rounds
3161
3162 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3163 {
3164 if (data.hash_mode != 2000)
3165 {
3166 try_run (device_param, kernel_accel, kernel_loops);
3167 try_run (device_param, kernel_accel, kernel_loops);
3168 try_run (device_param, kernel_accel, kernel_loops);
3169 try_run (device_param, kernel_accel, kernel_loops);
3170 }
3171
3172 device_param->kernel_accel = kernel_accel;
3173 device_param->kernel_loops = kernel_loops;
3174
3175 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3176
3177 device_param->kernel_power = kernel_power;
3178
3179 return;
3180 }
3181
3182 // from here it's clear we are allowed to autotune
3183 // so let's init some fake words
3184
3185 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3186
3187 if (data.attack_kern == ATTACK_KERN_BF)
3188 {
3189 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3190 }
3191 else
3192 {
3193 for (u32 i = 0; i < kernel_power_max; i++)
3194 {
3195 device_param->pws_buf[i].i[0] = i;
3196 device_param->pws_buf[i].i[1] = 0x01234567;
3197 device_param->pws_buf[i].pw_len = 7 + (i & 7);
3198 }
3199
3200 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);
3201 }
3202
3203 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3204 {
3205 if (data.kernel_rules_cnt > 1)
3206 {
3207 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);
3208 }
3209 }
3210 else
3211 {
3212 run_kernel_amp (device_param, kernel_power_max);
3213 }
3214
3215 #define VERIFIER_CNT 1
3216
3217 // first find out highest kernel-loops that stays below target_ms
3218
3219 if (kernel_loops_min < kernel_loops_max)
3220 {
3221 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3222 {
3223 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3224
3225 for (int i = 0; i < VERIFIER_CNT; i++)
3226 {
3227 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3228
3229 exec_ms = MIN (exec_ms, exec_ms_v);
3230 }
3231
3232 if (exec_ms < target_ms) break;
3233 }
3234 }
3235
3236 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3237
3238 #define STEPS_CNT 10
3239
3240 if (kernel_accel_min < kernel_accel_max)
3241 {
3242 for (int i = 0; i < STEPS_CNT; i++)
3243 {
3244 const u32 kernel_accel_try = 1 << i;
3245
3246 if (kernel_accel_try < kernel_accel_min) continue;
3247 if (kernel_accel_try > kernel_accel_max) break;
3248
3249 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3250
3251 for (int i = 0; i < VERIFIER_CNT; i++)
3252 {
3253 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3254
3255 exec_ms = MIN (exec_ms, exec_ms_v);
3256 }
3257
3258 if (exec_ms > target_ms) break;
3259
3260 kernel_accel = kernel_accel_try;
3261 }
3262 }
3263
3264 // at this point we want to know the actual runtime for the following reason:
3265 // we need a reference for the balancing loop following up, and this
3266 // the balancing loop can have an effect that the creates a new opportunity, for example:
3267 // if the target is 95 ms and the current runtime is 48ms the above loop
3268 // stopped the execution because the previous exec_ms was > 95ms
3269 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3270 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3271
3272 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3273
3274 for (int i = 0; i < VERIFIER_CNT; i++)
3275 {
3276 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3277
3278 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3279 }
3280
3281 u32 diff = kernel_loops - kernel_accel;
3282
3283 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3284 {
3285 u32 kernel_accel_orig = kernel_accel;
3286 u32 kernel_loops_orig = kernel_loops;
3287
3288 for (u32 f = 1; f < 1024; f++)
3289 {
3290 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3291 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3292
3293 if (kernel_accel_try > kernel_accel_max) break;
3294 if (kernel_loops_try < kernel_loops_min) break;
3295
3296 u32 diff_new = kernel_loops_try - kernel_accel_try;
3297
3298 if (diff_new > diff) break;
3299
3300 diff_new = diff;
3301
3302 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3303
3304 for (int i = 0; i < VERIFIER_CNT; i++)
3305 {
3306 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3307
3308 exec_ms = MIN (exec_ms, exec_ms_v);
3309 }
3310
3311 if (exec_ms < exec_ms_pre_final)
3312 {
3313 exec_ms_pre_final = exec_ms;
3314
3315 kernel_accel = kernel_accel_try;
3316 kernel_loops = kernel_loops_try;
3317 }
3318 }
3319 }
3320
3321 const double exec_left = target_ms / exec_ms_pre_final;
3322
3323 const double accel_left = kernel_accel_max / kernel_accel;
3324
3325 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3326
3327 if (exec_accel_min >= 1.0)
3328 {
3329 // this is safe to not overflow kernel_accel_max because of accel_left
3330
3331 kernel_accel = (double) kernel_accel * exec_accel_min;
3332 }
3333
3334 // reset them fake words
3335
3336 /*
3337 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3338
3339 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);
3340 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);
3341 */
3342
3343 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3344
3345 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3346 {
3347 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3348 }
3349
3350 // reset timer
3351
3352 device_param->exec_pos = 0;
3353
3354 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3355
3356 memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3357 memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3358 memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3359
3360 // store
3361
3362 device_param->kernel_accel = kernel_accel;
3363 device_param->kernel_loops = kernel_loops;
3364
3365 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3366
3367 device_param->kernel_power = kernel_power;
3368
3369 #ifdef DEBUG
3370
3371 if (data.quiet == 0)
3372 {
3373 clear_prompt ();
3374
3375 log_info ("- Device #%u: autotuned kernel-accel to %u\n"
3376 "- Device #%u: autotuned kernel-loops to %u\n",
3377 device_param->device_id + 1, kernel_accel,
3378 device_param->device_id + 1, kernel_loops);
3379
3380 fprintf (stdout, "%s", PROMPT);
3381
3382 fflush (stdout);
3383 }
3384
3385 #endif
3386 }
3387
3388 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3389 {
3390 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3391
3392 // init speed timer
3393
3394 uint speed_pos = device_param->speed_pos;
3395
3396 #ifdef _POSIX
3397 if (device_param->timer_speed.tv_sec == 0)
3398 {
3399 hc_timer_set (&device_param->timer_speed);
3400 }
3401 #endif
3402
3403 #ifdef _WIN
3404 if (device_param->timer_speed.QuadPart == 0)
3405 {
3406 hc_timer_set (&device_param->timer_speed);
3407 }
3408 #endif
3409
3410 // find higest password length, this is for optimization stuff
3411
3412 uint highest_pw_len = 0;
3413
3414 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3415 {
3416 }
3417 else if (data.attack_kern == ATTACK_KERN_COMBI)
3418 {
3419 }
3420 else if (data.attack_kern == ATTACK_KERN_BF)
3421 {
3422 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3423 + device_param->kernel_params_mp_l_buf32[5];
3424 }
3425
3426 // iteration type
3427
3428 uint innerloop_step = 0;
3429 uint innerloop_cnt = 0;
3430
3431 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3432 else innerloop_step = 1;
3433
3434 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3435 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3436 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3437
3438 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3439
3440 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3441 {
3442 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3443
3444 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3445
3446 if (data.devices_status == STATUS_CRACKED) break;
3447 if (data.devices_status == STATUS_ABORTED) break;
3448 if (data.devices_status == STATUS_QUIT) break;
3449 if (data.devices_status == STATUS_BYPASS) break;
3450
3451 salt_t *salt_buf = &data.salts_buf[salt_pos];
3452
3453 device_param->kernel_params_buf32[24] = salt_pos;
3454 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3455 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3456
3457 FILE *combs_fp = device_param->combs_fp;
3458
3459 if (data.attack_mode == ATTACK_MODE_COMBI)
3460 {
3461 rewind (combs_fp);
3462 }
3463
3464 // innerloops
3465
3466 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3467 {
3468 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3469
3470 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3471
3472 if (data.devices_status == STATUS_CRACKED) break;
3473 if (data.devices_status == STATUS_ABORTED) break;
3474 if (data.devices_status == STATUS_QUIT) break;
3475 if (data.devices_status == STATUS_BYPASS) break;
3476
3477 uint fast_iteration = 0;
3478
3479 uint innerloop_left = innerloop_cnt - innerloop_pos;
3480
3481 if (innerloop_left > innerloop_step)
3482 {
3483 innerloop_left = innerloop_step;
3484
3485 fast_iteration = 1;
3486 }
3487
3488 device_param->innerloop_pos = innerloop_pos;
3489 device_param->innerloop_left = innerloop_left;
3490
3491 device_param->kernel_params_buf32[27] = innerloop_left;
3492
3493 // i think we can get rid of this
3494 if (innerloop_left == 0)
3495 {
3496 puts ("bug, how should this happen????\n");
3497
3498 continue;
3499 }
3500
3501 if (data.salts_shown[salt_pos] == 1)
3502 {
3503 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3504
3505 continue;
3506 }
3507
3508 // initialize amplifiers
3509
3510 if (data.attack_mode == ATTACK_MODE_COMBI)
3511 {
3512 uint i = 0;
3513
3514 while (i < innerloop_left)
3515 {
3516 if (feof (combs_fp)) break;
3517
3518 int line_len = fgetl (combs_fp, line_buf);
3519
3520 if (line_len >= PW_MAX1) continue;
3521
3522 line_len = convert_from_hex (line_buf, line_len);
3523
3524 char *line_buf_new = line_buf;
3525
3526 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3527 {
3528 char rule_buf_out[BLOCK_SIZE] = { 0 };
3529
3530 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3531
3532 if (rule_len_out < 0)
3533 {
3534 data.words_progress_rejected[salt_pos] += pws_cnt;
3535
3536 continue;
3537 }
3538
3539 line_len = rule_len_out;
3540
3541 line_buf_new = rule_buf_out;
3542 }
3543
3544 line_len = MIN (line_len, PW_DICTMAX);
3545
3546 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3547
3548 memcpy (ptr, line_buf_new, line_len);
3549
3550 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3551
3552 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3553 {
3554 uppercase (ptr, line_len);
3555 }
3556
3557 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3558 {
3559 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3560 {
3561 ptr[line_len] = 0x80;
3562 }
3563
3564 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3565 {
3566 ptr[line_len] = 0x01;
3567 }
3568 }
3569
3570 device_param->combs_buf[i].pw_len = line_len;
3571
3572 i++;
3573 }
3574
3575 for (uint j = i; j < innerloop_left; j++)
3576 {
3577 device_param->combs_buf[j].i[0] = 0;
3578 device_param->combs_buf[j].i[1] = 0;
3579 device_param->combs_buf[j].i[2] = 0;
3580 device_param->combs_buf[j].i[3] = 0;
3581 device_param->combs_buf[j].i[4] = 0;
3582 device_param->combs_buf[j].i[5] = 0;
3583 device_param->combs_buf[j].i[6] = 0;
3584 device_param->combs_buf[j].i[7] = 0;
3585
3586 device_param->combs_buf[j].pw_len = 0;
3587 }
3588
3589 innerloop_left = i;
3590 }
3591 else if (data.attack_mode == ATTACK_MODE_BF)
3592 {
3593 u64 off = innerloop_pos;
3594
3595 device_param->kernel_params_mp_r_buf64[3] = off;
3596
3597 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3598 }
3599 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3600 {
3601 u64 off = innerloop_pos;
3602
3603 device_param->kernel_params_mp_buf64[3] = off;
3604
3605 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3606 }
3607 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3608 {
3609 u64 off = innerloop_pos;
3610
3611 device_param->kernel_params_mp_buf64[3] = off;
3612
3613 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3614 }
3615
3616 // copy amplifiers
3617
3618 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3619 {
3620 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);
3621 }
3622 else if (data.attack_mode == ATTACK_MODE_COMBI)
3623 {
3624 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);
3625 }
3626 else if (data.attack_mode == ATTACK_MODE_BF)
3627 {
3628 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);
3629 }
3630 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3631 {
3632 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);
3633 }
3634 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3635 {
3636 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);
3637 }
3638
3639 if (data.benchmark == 1)
3640 {
3641 hc_timer_set (&device_param->timer_speed);
3642 }
3643
3644 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
3645
3646 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3647
3648 if (data.devices_status == STATUS_CRACKED) break;
3649 if (data.devices_status == STATUS_ABORTED) break;
3650 if (data.devices_status == STATUS_QUIT) break;
3651
3652 /**
3653 * result
3654 */
3655
3656 if (data.benchmark == 0)
3657 {
3658 check_cracked (device_param, salt_pos);
3659 }
3660
3661 /**
3662 * progress
3663 */
3664
3665 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3666
3667 hc_thread_mutex_lock (mux_counter);
3668
3669 data.words_progress_done[salt_pos] += perf_sum_all;
3670
3671 hc_thread_mutex_unlock (mux_counter);
3672
3673 /**
3674 * speed
3675 */
3676
3677 double speed_ms;
3678
3679 hc_timer_get (device_param->timer_speed, speed_ms);
3680
3681 hc_timer_set (&device_param->timer_speed);
3682
3683 // current speed
3684
3685 //hc_thread_mutex_lock (mux_display);
3686
3687 device_param->speed_cnt[speed_pos] = perf_sum_all;
3688
3689 device_param->speed_ms[speed_pos] = speed_ms;
3690
3691 //hc_thread_mutex_unlock (mux_display);
3692
3693 speed_pos++;
3694
3695 if (speed_pos == SPEED_CACHE)
3696 {
3697 speed_pos = 0;
3698 }
3699
3700 /**
3701 * benchmark
3702 */
3703
3704 if (data.benchmark == 1) break;
3705 }
3706 }
3707
3708 device_param->speed_pos = speed_pos;
3709
3710 myfree (line_buf);
3711 }
3712
3713 static void load_segment (wl_data_t *wl_data, FILE *fd)
3714 {
3715 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3716
3717 wl_data->pos = 0;
3718
3719 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3720
3721 wl_data->buf[wl_data->cnt] = 0;
3722
3723 if (wl_data->cnt == 0) return;
3724
3725 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3726
3727 while (!feof (fd))
3728 {
3729 if (wl_data->cnt == wl_data->avail)
3730 {
3731 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3732
3733 wl_data->avail += wl_data->incr;
3734 }
3735
3736 const int c = fgetc (fd);
3737
3738 if (c == EOF) break;
3739
3740 wl_data->buf[wl_data->cnt] = (char) c;
3741
3742 wl_data->cnt++;
3743
3744 if (c == '\n') break;
3745 }
3746
3747 // ensure stream ends with a newline
3748
3749 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3750 {
3751 wl_data->cnt++;
3752
3753 wl_data->buf[wl_data->cnt - 1] = '\n';
3754 }
3755
3756 return;
3757 }
3758
3759 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3760 {
3761 char *ptr = buf;
3762
3763 for (u32 i = 0; i < sz; i++, ptr++)
3764 {
3765 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3766
3767 if (i == 7)
3768 {
3769 *off = i;
3770 *len = i;
3771
3772 return;
3773 }
3774
3775 if (*ptr != '\n') continue;
3776
3777 *off = i + 1;
3778
3779 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3780
3781 *len = i;
3782
3783 return;
3784 }
3785
3786 *off = sz;
3787 *len = sz;
3788 }
3789
3790 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3791 {
3792 char *ptr = buf;
3793
3794 for (u32 i = 0; i < sz; i++, ptr++)
3795 {
3796 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3797
3798 if (*ptr != '\n') continue;
3799
3800 *off = i + 1;
3801
3802 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3803
3804 *len = i;
3805
3806 return;
3807 }
3808
3809 *off = sz;
3810 *len = sz;
3811 }
3812
3813 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3814 {
3815 char *ptr = buf;
3816
3817 for (u32 i = 0; i < sz; i++, ptr++)
3818 {
3819 if (*ptr != '\n') continue;
3820
3821 *off = i + 1;
3822
3823 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3824
3825 *len = i;
3826
3827 return;
3828 }
3829
3830 *off = sz;
3831 *len = sz;
3832 }
3833
3834 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3835 {
3836 while (wl_data->pos < wl_data->cnt)
3837 {
3838 uint off;
3839 uint len;
3840
3841 char *ptr = wl_data->buf + wl_data->pos;
3842
3843 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3844
3845 wl_data->pos += off;
3846
3847 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3848 {
3849 char rule_buf_out[BLOCK_SIZE] = { 0 };
3850
3851 int rule_len_out = -1;
3852
3853 if (len < BLOCK_SIZE)
3854 {
3855 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3856 }
3857
3858 if (rule_len_out < 0)
3859 {
3860 continue;
3861 }
3862
3863 if (rule_len_out > PW_MAX)
3864 {
3865 continue;
3866 }
3867 }
3868 else
3869 {
3870 if (len > PW_MAX)
3871 {
3872 continue;
3873 }
3874 }
3875
3876 *out_buf = ptr;
3877 *out_len = len;
3878
3879 return;
3880 }
3881
3882 if (feof (fd))
3883 {
3884 fprintf (stderr, "BUG feof()!!\n");
3885
3886 return;
3887 }
3888
3889 load_segment (wl_data, fd);
3890
3891 get_next_word (wl_data, fd, out_buf, out_len);
3892 }
3893
3894 #ifdef _POSIX
3895 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3896 #endif
3897
3898 #ifdef _WIN
3899 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3900 #endif
3901 {
3902 hc_signal (NULL);
3903
3904 dictstat_t d;
3905
3906 d.cnt = 0;
3907
3908 #ifdef _POSIX
3909 fstat (fileno (fd), &d.stat);
3910 #endif
3911
3912 #ifdef _WIN
3913 _fstat64 (fileno (fd), &d.stat);
3914 #endif
3915
3916 d.stat.st_mode = 0;
3917 d.stat.st_nlink = 0;
3918 d.stat.st_uid = 0;
3919 d.stat.st_gid = 0;
3920 d.stat.st_rdev = 0;
3921 d.stat.st_atime = 0;
3922
3923 #ifdef _POSIX
3924 d.stat.st_blksize = 0;
3925 d.stat.st_blocks = 0;
3926 #endif
3927
3928 if (d.stat.st_size == 0) return 0;
3929
3930 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3931
3932 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3933 {
3934 if (d_cache)
3935 {
3936 u64 cnt = d_cache->cnt;
3937
3938 u64 keyspace = cnt;
3939
3940 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3941 {
3942 keyspace *= data.kernel_rules_cnt;
3943 }
3944 else if (data.attack_kern == ATTACK_KERN_COMBI)
3945 {
3946 keyspace *= data.combs_cnt;
3947 }
3948
3949 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);
3950 if (data.quiet == 0) log_info ("");
3951
3952 hc_signal (sigHandler_default);
3953
3954 return (keyspace);
3955 }
3956 }
3957
3958 time_t now = 0;
3959 time_t prev = 0;
3960
3961 u64 comp = 0;
3962 u64 cnt = 0;
3963 u64 cnt2 = 0;
3964
3965 while (!feof (fd))
3966 {
3967 load_segment (wl_data, fd);
3968
3969 comp += wl_data->cnt;
3970
3971 u32 i = 0;
3972
3973 while (i < wl_data->cnt)
3974 {
3975 u32 len;
3976 u32 off;
3977
3978 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3979
3980 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3981 {
3982 char rule_buf_out[BLOCK_SIZE] = { 0 };
3983
3984 int rule_len_out = -1;
3985
3986 if (len < BLOCK_SIZE)
3987 {
3988 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3989 }
3990
3991 if (rule_len_out < 0)
3992 {
3993 len = PW_MAX1;
3994 }
3995 else
3996 {
3997 len = rule_len_out;
3998 }
3999 }
4000
4001 if (len < PW_MAX1)
4002 {
4003 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4004 {
4005 cnt += data.kernel_rules_cnt;
4006 }
4007 else if (data.attack_kern == ATTACK_KERN_COMBI)
4008 {
4009 cnt += data.combs_cnt;
4010 }
4011
4012 d.cnt++;
4013 }
4014
4015 i += off;
4016
4017 cnt2++;
4018 }
4019
4020 time (&now);
4021
4022 if ((now - prev) == 0) continue;
4023
4024 float percent = (float) comp / (float) d.stat.st_size;
4025
4026 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);
4027
4028 time (&prev);
4029 }
4030
4031 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);
4032 if (data.quiet == 0) log_info ("");
4033
4034 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4035
4036 hc_signal (sigHandler_default);
4037
4038 return (cnt);
4039 }
4040
4041 static void *thread_monitor (void *p)
4042 {
4043 uint runtime_check = 0;
4044 uint remove_check = 0;
4045 uint status_check = 0;
4046 uint restore_check = 0;
4047
4048 uint restore_left = data.restore_timer;
4049 uint remove_left = data.remove_timer;
4050 uint status_left = data.status_timer;
4051
4052 #ifdef HAVE_HWMON
4053 uint hwmon_check = 0;
4054
4055 int slowdown_warnings = 0;
4056
4057 // these variables are mainly used for fan control
4058
4059 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4060
4061 // temperature controller "loopback" values
4062
4063 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4064 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4065
4066 int temp_threshold = 1; // degrees celcius
4067
4068 int fan_speed_min = 15; // in percentage
4069 int fan_speed_max = 100;
4070
4071 time_t last_temp_check_time;
4072 #endif // HAVE_HWMON
4073
4074 uint sleep_time = 1;
4075
4076 if (data.runtime)
4077 {
4078 runtime_check = 1;
4079 }
4080
4081 if (data.restore_timer)
4082 {
4083 restore_check = 1;
4084 }
4085
4086 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4087 {
4088 remove_check = 1;
4089 }
4090
4091 if (data.status == 1)
4092 {
4093 status_check = 1;
4094 }
4095
4096 #ifdef HAVE_HWMON
4097 if (data.gpu_temp_disable == 0)
4098 {
4099 time (&last_temp_check_time);
4100
4101 hwmon_check = 1;
4102 }
4103 #endif
4104
4105 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4106 {
4107 #ifdef HAVE_HWMON
4108 if (hwmon_check == 0)
4109 #endif
4110 return (p);
4111 }
4112
4113 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4114 {
4115 hc_sleep (sleep_time);
4116
4117 if (data.devices_status != STATUS_RUNNING) continue;
4118
4119 #ifdef HAVE_HWMON
4120
4121 if (hwmon_check == 1)
4122 {
4123 hc_thread_mutex_lock (mux_adl);
4124
4125 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4126 {
4127 hc_device_param_t *device_param = &data.devices_param[device_id];
4128
4129 if (device_param->skipped) continue;
4130
4131 if (device_param->device_vendor_id == VENDOR_ID_NV)
4132 {
4133 if (data.hm_nvapi)
4134 {
4135 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
4136 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
4137
4138 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4139 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4140
4141 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4142
4143 perfPolicies_status.info_value = perfPolicies_info.info_value;
4144
4145 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4146
4147 if (perfPolicies_status.throttle & 2)
4148 {
4149 if (slowdown_warnings < 3)
4150 {
4151 if (data.quiet == 0) clear_prompt ();
4152
4153 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4154
4155 if (slowdown_warnings == 2)
4156 {
4157 log_info ("");
4158 }
4159
4160 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4161 if (data.quiet == 0) fflush (stdout);
4162
4163 slowdown_warnings++;
4164 }
4165 }
4166 else
4167 {
4168 slowdown_warnings = 0;
4169 }
4170 }
4171 }
4172 }
4173
4174 hc_thread_mutex_unlock (mux_adl);
4175 }
4176
4177 if (hwmon_check == 1)
4178 {
4179 hc_thread_mutex_lock (mux_adl);
4180
4181 time_t temp_check_time;
4182
4183 time (&temp_check_time);
4184
4185 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4186
4187 if (Ta == 0) Ta = 1;
4188
4189 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4190 {
4191 hc_device_param_t *device_param = &data.devices_param[device_id];
4192
4193 if (device_param->skipped) continue;
4194
4195 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4196
4197 const int temperature = hm_get_temperature_with_device_id (device_id);
4198
4199 if (temperature > (int) data.gpu_temp_abort)
4200 {
4201 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4202
4203 if (data.devices_status != STATUS_QUIT) myabort ();
4204
4205 break;
4206 }
4207
4208 const int gpu_temp_retain = data.gpu_temp_retain;
4209
4210 if (gpu_temp_retain)
4211 {
4212 if (data.hm_device[device_id].fan_set_supported == 1)
4213 {
4214 int temp_cur = temperature;
4215
4216 int temp_diff_new = gpu_temp_retain - temp_cur;
4217
4218 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4219
4220 // calculate Ta value (time difference in seconds between the last check and this check)
4221
4222 last_temp_check_time = temp_check_time;
4223
4224 float Kp = 1.8;
4225 float Ki = 0.005;
4226 float Kd = 6;
4227
4228 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4229
4230 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);
4231
4232 if (abs (fan_diff_required) >= temp_threshold)
4233 {
4234 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4235
4236 int fan_speed_level = fan_speed_cur;
4237
4238 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4239
4240 int fan_speed_new = fan_speed_level - fan_diff_required;
4241
4242 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4243 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4244
4245 if (fan_speed_new != fan_speed_cur)
4246 {
4247 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4248 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4249
4250 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4251 {
4252 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4253 {
4254 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4255 }
4256 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4257 {
4258 #ifdef WIN
4259 hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1);
4260 #endif
4261
4262 #ifdef LINUX
4263 hm_set_fanspeed_with_device_id_xnvctrl (device_id, fan_speed_new);
4264 #endif
4265 }
4266
4267 fan_speed_chgd[device_id] = 1;
4268 }
4269
4270 temp_diff_old[device_id] = temp_diff_new;
4271 }
4272 }
4273 }
4274 }
4275 }
4276
4277 hc_thread_mutex_unlock (mux_adl);
4278 }
4279 #endif // HAVE_HWMON
4280
4281 if (restore_check == 1)
4282 {
4283 restore_left--;
4284
4285 if (restore_left == 0)
4286 {
4287 if (data.restore_disable == 0) cycle_restore ();
4288
4289 restore_left = data.restore_timer;
4290 }
4291 }
4292
4293 if ((runtime_check == 1) && (data.runtime_start > 0))
4294 {
4295 time_t runtime_cur;
4296
4297 time (&runtime_cur);
4298
4299 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4300
4301 if (runtime_left <= 0)
4302 {
4303 if (data.benchmark == 0)
4304 {
4305 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4306 }
4307
4308 if (data.devices_status != STATUS_QUIT) myabort ();
4309 }
4310 }
4311
4312 if (remove_check == 1)
4313 {
4314 remove_left--;
4315
4316 if (remove_left == 0)
4317 {
4318 if (data.digests_saved != data.digests_done)
4319 {
4320 data.digests_saved = data.digests_done;
4321
4322 save_hash ();
4323 }
4324
4325 remove_left = data.remove_timer;
4326 }
4327 }
4328
4329 if (status_check == 1)
4330 {
4331 status_left--;
4332
4333 if (status_left == 0)
4334 {
4335 //hc_thread_mutex_lock (mux_display);
4336
4337 if (data.quiet == 0) clear_prompt ();
4338
4339 if (data.quiet == 0) log_info ("");
4340
4341 status_display ();
4342
4343 if (data.quiet == 0) log_info ("");
4344
4345 //hc_thread_mutex_unlock (mux_display);
4346
4347 status_left = data.status_timer;
4348 }
4349 }
4350 }
4351
4352 #ifdef HAVE_HWMON
4353 myfree (fan_speed_chgd);
4354
4355 myfree (temp_diff_old);
4356 myfree (temp_diff_sum);
4357 #endif
4358
4359 p = NULL;
4360
4361 return (p);
4362 }
4363
4364 static void *thread_outfile_remove (void *p)
4365 {
4366 // some hash-dependent constants
4367 char *outfile_dir = data.outfile_check_directory;
4368 uint dgst_size = data.dgst_size;
4369 uint isSalted = data.isSalted;
4370 uint esalt_size = data.esalt_size;
4371 uint hash_mode = data.hash_mode;
4372
4373 uint outfile_check_timer = data.outfile_check_timer;
4374
4375 char separator = data.separator;
4376
4377 // some hash-dependent functions
4378 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4379 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4380
4381 // buffers
4382 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4383
4384 hash_buf.digest = mymalloc (dgst_size);
4385
4386 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4387
4388 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4389
4390 uint digest_buf[64] = { 0 };
4391
4392 outfile_data_t *out_info = NULL;
4393
4394 char **out_files = NULL;
4395
4396 time_t folder_mtime = 0;
4397
4398 int out_cnt = 0;
4399
4400 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4401
4402 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4403 {
4404 hc_sleep (1);
4405
4406 if (data.devices_status != STATUS_RUNNING) continue;
4407
4408 check_left--;
4409
4410 if (check_left == 0)
4411 {
4412 struct stat outfile_check_stat;
4413
4414 if (stat (outfile_dir, &outfile_check_stat) == 0)
4415 {
4416 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4417
4418 if (is_dir == 1)
4419 {
4420 if (outfile_check_stat.st_mtime > folder_mtime)
4421 {
4422 char **out_files_new = scan_directory (outfile_dir);
4423
4424 int out_cnt_new = count_dictionaries (out_files_new);
4425
4426 outfile_data_t *out_info_new = NULL;
4427
4428 if (out_cnt_new > 0)
4429 {
4430 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4431
4432 for (int i = 0; i < out_cnt_new; i++)
4433 {
4434 out_info_new[i].file_name = out_files_new[i];
4435
4436 // check if there are files that we have seen/checked before (and not changed)
4437
4438 for (int j = 0; j < out_cnt; j++)
4439 {
4440 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4441 {
4442 struct stat outfile_stat;
4443
4444 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4445 {
4446 if (outfile_stat.st_ctime == out_info[j].ctime)
4447 {
4448 out_info_new[i].ctime = out_info[j].ctime;
4449 out_info_new[i].seek = out_info[j].seek;
4450 }
4451 }
4452 }
4453 }
4454 }
4455 }
4456
4457 local_free (out_info);
4458 local_free (out_files);
4459
4460 out_files = out_files_new;
4461 out_cnt = out_cnt_new;
4462 out_info = out_info_new;
4463
4464 folder_mtime = outfile_check_stat.st_mtime;
4465 }
4466
4467 for (int j = 0; j < out_cnt; j++)
4468 {
4469 FILE *fp = fopen (out_info[j].file_name, "rb");
4470
4471 if (fp != NULL)
4472 {
4473 //hc_thread_mutex_lock (mux_display);
4474
4475 #ifdef _POSIX
4476 struct stat outfile_stat;
4477
4478 fstat (fileno (fp), &outfile_stat);
4479 #endif
4480
4481 #ifdef _WIN
4482 struct stat64 outfile_stat;
4483
4484 _fstat64 (fileno (fp), &outfile_stat);
4485 #endif
4486
4487 if (outfile_stat.st_ctime > out_info[j].ctime)
4488 {
4489 out_info[j].ctime = outfile_stat.st_ctime;
4490 out_info[j].seek = 0;
4491 }
4492
4493 fseek (fp, out_info[j].seek, SEEK_SET);
4494
4495 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4496
4497 while (!feof (fp))
4498 {
4499 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4500
4501 if (ptr == NULL) break;
4502
4503 int line_len = strlen (line_buf);
4504
4505 if (line_len <= 0) continue;
4506
4507 int iter = MAX_CUT_TRIES;
4508
4509 for (uint i = line_len - 1; i && iter; i--, line_len--)
4510 {
4511 if (line_buf[i] != separator) continue;
4512
4513 int parser_status = PARSER_OK;
4514
4515 if ((hash_mode != 2500) && (hash_mode != 6800))
4516 {
4517 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4518 }
4519
4520 uint found = 0;
4521
4522 if (parser_status == PARSER_OK)
4523 {
4524 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4525 {
4526 if (data.salts_shown[salt_pos] == 1) continue;
4527
4528 salt_t *salt_buf = &data.salts_buf[salt_pos];
4529
4530 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4531 {
4532 uint idx = salt_buf->digests_offset + digest_pos;
4533
4534 if (data.digests_shown[idx] == 1) continue;
4535
4536 uint cracked = 0;
4537
4538 if (hash_mode == 6800)
4539 {
4540 if (i == salt_buf->salt_len)
4541 {
4542 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4543 }
4544 }
4545 else if (hash_mode == 2500)
4546 {
4547 // BSSID : MAC1 : MAC2 (:plain)
4548 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4549 {
4550 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4551
4552 if (!cracked) continue;
4553
4554 // now compare MAC1 and MAC2 too, since we have this additional info
4555 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4556 char *mac2_pos = mac1_pos + 12 + 1;
4557
4558 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4559 wpa_t *wpa = &wpas[salt_pos];
4560
4561 // compare hex string(s) vs binary MAC address(es)
4562
4563 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4564 {
4565 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4566 {
4567 cracked = 0;
4568
4569 break;
4570 }
4571 }
4572
4573 // early skip ;)
4574 if (!cracked) continue;
4575
4576 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4577 {
4578 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4579 {
4580 cracked = 0;
4581
4582 break;
4583 }
4584 }
4585 }
4586 }
4587 else
4588 {
4589 char *digests_buf_ptr = (char *) data.digests_buf;
4590
4591 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4592
4593 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4594 }
4595
4596 if (cracked == 1)
4597 {
4598 found = 1;
4599
4600 data.digests_shown[idx] = 1;
4601
4602 data.digests_done++;
4603
4604 salt_buf->digests_done++;
4605
4606 if (salt_buf->digests_done == salt_buf->digests_cnt)
4607 {
4608 data.salts_shown[salt_pos] = 1;
4609
4610 data.salts_done++;
4611
4612 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4613 }
4614 }
4615 }
4616
4617 if (data.devices_status == STATUS_CRACKED) break;
4618 }
4619 }
4620
4621 if (found) break;
4622
4623 if (data.devices_status == STATUS_CRACKED) break;
4624
4625 iter--;
4626 }
4627
4628 if (data.devices_status == STATUS_CRACKED) break;
4629 }
4630
4631 myfree (line_buf);
4632
4633 out_info[j].seek = ftell (fp);
4634
4635 //hc_thread_mutex_unlock (mux_display);
4636
4637 fclose (fp);
4638 }
4639 }
4640 }
4641 }
4642
4643 check_left = outfile_check_timer;
4644 }
4645 }
4646
4647 if (esalt_size) local_free (hash_buf.esalt);
4648
4649 if (isSalted) local_free (hash_buf.salt);
4650
4651 local_free (hash_buf.digest);
4652
4653 local_free (out_info);
4654
4655 local_free (out_files);
4656
4657 p = NULL;
4658
4659 return (p);
4660 }
4661
4662 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4663 {
4664 //if (device_param->pws_cnt < device_param->kernel_power)
4665 //{
4666 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4667
4668 u8 *ptr = (u8 *) pw->i;
4669
4670 memcpy (ptr, pw_buf, pw_len);
4671
4672 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4673
4674 pw->pw_len = pw_len;
4675
4676 device_param->pws_cnt++;
4677 //}
4678 //else
4679 //{
4680 // fprintf (stderr, "BUG pw_add()!!\n");
4681 //
4682 // return;
4683 //}
4684 }
4685
4686 static void set_kernel_power_final (const u64 kernel_power_final)
4687 {
4688 if (data.quiet == 0)
4689 {
4690 clear_prompt ();
4691
4692 //log_info ("");
4693
4694 log_info ("INFO: approaching final keyspace, workload adjusted");
4695 log_info ("");
4696
4697 fprintf (stdout, "%s", PROMPT);
4698
4699 fflush (stdout);
4700 }
4701
4702 data.kernel_power_final = kernel_power_final;
4703 }
4704
4705 static u32 get_power (hc_device_param_t *device_param)
4706 {
4707 const u64 kernel_power_final = data.kernel_power_final;
4708
4709 if (kernel_power_final)
4710 {
4711 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4712
4713 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4714
4715 // work should be at least the hardware power available without any accelerator
4716
4717 const u64 work = MAX (words_left_device, device_param->hardware_power);
4718
4719 return work;
4720 }
4721
4722 return device_param->kernel_power;
4723 }
4724
4725 static uint get_work (hc_device_param_t *device_param, const u64 max)
4726 {
4727 hc_thread_mutex_lock (mux_dispatcher);
4728
4729 const u64 words_cur = data.words_cur;
4730 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4731
4732 device_param->words_off = words_cur;
4733
4734 const u64 kernel_power_all = data.kernel_power_all;
4735
4736 const u64 words_left = words_base - words_cur;
4737
4738 if (words_left < kernel_power_all)
4739 {
4740 if (data.kernel_power_final == 0)
4741 {
4742 set_kernel_power_final (words_left);
4743 }
4744 }
4745
4746 const u32 kernel_power = get_power (device_param);
4747
4748 uint work = MIN (words_left, kernel_power);
4749
4750 work = MIN (work, max);
4751
4752 data.words_cur += work;
4753
4754 hc_thread_mutex_unlock (mux_dispatcher);
4755
4756 return work;
4757 }
4758
4759 static void *thread_autotune (void *p)
4760 {
4761 hc_device_param_t *device_param = (hc_device_param_t *) p;
4762
4763 if (device_param->skipped) return NULL;
4764
4765 autotune (device_param);
4766
4767 return NULL;
4768 }
4769
4770 static void *thread_calc_stdin (void *p)
4771 {
4772 hc_device_param_t *device_param = (hc_device_param_t *) p;
4773
4774 if (device_param->skipped) return NULL;
4775
4776 char *buf = (char *) mymalloc (HCBUFSIZ);
4777
4778 const uint attack_kern = data.attack_kern;
4779
4780 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4781 {
4782 hc_thread_mutex_lock (mux_dispatcher);
4783
4784 if (feof (stdin) != 0)
4785 {
4786 hc_thread_mutex_unlock (mux_dispatcher);
4787
4788 break;
4789 }
4790
4791 uint words_cur = 0;
4792
4793 while (words_cur < device_param->kernel_power)
4794 {
4795 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4796
4797 if (line_buf == NULL) break;
4798
4799 uint line_len = in_superchop (line_buf);
4800
4801 line_len = convert_from_hex (line_buf, line_len);
4802
4803 // post-process rule engine
4804
4805 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4806 {
4807 char rule_buf_out[BLOCK_SIZE] = { 0 };
4808
4809 int rule_len_out = -1;
4810
4811 if (line_len < BLOCK_SIZE)
4812 {
4813 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4814 }
4815
4816 if (rule_len_out < 0) continue;
4817
4818 line_buf = rule_buf_out;
4819 line_len = rule_len_out;
4820 }
4821
4822 if (line_len > PW_MAX)
4823 {
4824 continue;
4825 }
4826
4827 // hmm that's always the case, or?
4828
4829 if (attack_kern == ATTACK_KERN_STRAIGHT)
4830 {
4831 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4832 {
4833 hc_thread_mutex_lock (mux_counter);
4834
4835 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4836 {
4837 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4838 }
4839
4840 hc_thread_mutex_unlock (mux_counter);
4841
4842 continue;
4843 }
4844 }
4845
4846 pw_add (device_param, (u8 *) line_buf, line_len);
4847
4848 words_cur++;
4849
4850 if (data.devices_status == STATUS_CRACKED) break;
4851 if (data.devices_status == STATUS_ABORTED) break;
4852 if (data.devices_status == STATUS_QUIT) break;
4853 if (data.devices_status == STATUS_BYPASS) break;
4854 }
4855
4856 hc_thread_mutex_unlock (mux_dispatcher);
4857
4858 if (data.devices_status == STATUS_CRACKED) break;
4859 if (data.devices_status == STATUS_ABORTED) break;
4860 if (data.devices_status == STATUS_QUIT) break;
4861 if (data.devices_status == STATUS_BYPASS) break;
4862
4863 // flush
4864
4865 const uint pws_cnt = device_param->pws_cnt;
4866
4867 if (pws_cnt)
4868 {
4869 run_copy (device_param, pws_cnt);
4870
4871 run_cracker (device_param, pws_cnt);
4872
4873 device_param->pws_cnt = 0;
4874
4875 /*
4876 still required?
4877 if (attack_kern == ATTACK_KERN_STRAIGHT)
4878 {
4879 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4880 }
4881 else if (attack_kern == ATTACK_KERN_COMBI)
4882 {
4883 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4884 }
4885 */
4886 }
4887 }
4888
4889 device_param->kernel_accel = 0;
4890 device_param->kernel_loops = 0;
4891
4892 myfree (buf);
4893
4894 return NULL;
4895 }
4896
4897 static void *thread_calc (void *p)
4898 {
4899 hc_device_param_t *device_param = (hc_device_param_t *) p;
4900
4901 if (device_param->skipped) return NULL;
4902
4903 const uint attack_mode = data.attack_mode;
4904 const uint attack_kern = data.attack_kern;
4905
4906 if (attack_mode == ATTACK_MODE_BF)
4907 {
4908 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4909 {
4910 const uint work = get_work (device_param, -1);
4911
4912 if (work == 0) break;
4913
4914 const u64 words_off = device_param->words_off;
4915 const u64 words_fin = words_off + work;
4916
4917 const uint pws_cnt = work;
4918
4919 device_param->pws_cnt = pws_cnt;
4920
4921 if (pws_cnt)
4922 {
4923 run_copy (device_param, pws_cnt);
4924
4925 run_cracker (device_param, pws_cnt);
4926
4927 device_param->pws_cnt = 0;
4928
4929 /*
4930 still required?
4931 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4932 */
4933 }
4934
4935 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4936
4937 if (data.devices_status == STATUS_CRACKED) break;
4938 if (data.devices_status == STATUS_ABORTED) break;
4939 if (data.devices_status == STATUS_QUIT) break;
4940 if (data.devices_status == STATUS_BYPASS) break;
4941
4942 if (data.benchmark == 1) break;
4943
4944 device_param->words_done = words_fin;
4945 }
4946 }
4947 else
4948 {
4949 const uint segment_size = data.segment_size;
4950
4951 char *dictfile = data.dictfile;
4952
4953 if (attack_mode == ATTACK_MODE_COMBI)
4954 {
4955 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4956 {
4957 dictfile = data.dictfile2;
4958 }
4959 }
4960
4961 FILE *fd = fopen (dictfile, "rb");
4962
4963 if (fd == NULL)
4964 {
4965 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4966
4967 return NULL;
4968 }
4969
4970 if (attack_mode == ATTACK_MODE_COMBI)
4971 {
4972 const uint combs_mode = data.combs_mode;
4973
4974 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4975 {
4976 const char *dictfilec = data.dictfile2;
4977
4978 FILE *combs_fp = fopen (dictfilec, "rb");
4979
4980 if (combs_fp == NULL)
4981 {
4982 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4983
4984 fclose (fd);
4985
4986 return NULL;
4987 }
4988
4989 device_param->combs_fp = combs_fp;
4990 }
4991 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4992 {
4993 const char *dictfilec = data.dictfile;
4994
4995 FILE *combs_fp = fopen (dictfilec, "rb");
4996
4997 if (combs_fp == NULL)
4998 {
4999 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5000
5001 fclose (fd);
5002
5003 return NULL;
5004 }
5005
5006 device_param->combs_fp = combs_fp;
5007 }
5008 }
5009
5010 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
5011
5012 wl_data->buf = (char *) mymalloc (segment_size);
5013 wl_data->avail = segment_size;
5014 wl_data->incr = segment_size;
5015 wl_data->cnt = 0;
5016 wl_data->pos = 0;
5017
5018 u64 words_cur = 0;
5019
5020 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5021 {
5022 u64 words_off = 0;
5023 u64 words_fin = 0;
5024
5025 u64 max = -1;
5026
5027 while (max)
5028 {
5029 const uint work = get_work (device_param, max);
5030
5031 if (work == 0) break;
5032
5033 max = 0;
5034
5035 words_off = device_param->words_off;
5036 words_fin = words_off + work;
5037
5038 char *line_buf;
5039 uint line_len;
5040
5041 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5042
5043 for ( ; words_cur < words_fin; words_cur++)
5044 {
5045 get_next_word (wl_data, fd, &line_buf, &line_len);
5046
5047 line_len = convert_from_hex (line_buf, line_len);
5048
5049 // post-process rule engine
5050
5051 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5052 {
5053 char rule_buf_out[BLOCK_SIZE] = { 0 };
5054
5055 int rule_len_out = -1;
5056
5057 if (line_len < BLOCK_SIZE)
5058 {
5059 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5060 }
5061
5062 if (rule_len_out < 0) continue;
5063
5064 line_buf = rule_buf_out;
5065 line_len = rule_len_out;
5066 }
5067
5068 if (attack_kern == ATTACK_KERN_STRAIGHT)
5069 {
5070 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5071 {
5072 max++;
5073
5074 hc_thread_mutex_lock (mux_counter);
5075
5076 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5077 {
5078 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5079 }
5080
5081 hc_thread_mutex_unlock (mux_counter);
5082
5083 continue;
5084 }
5085 }
5086 else if (attack_kern == ATTACK_KERN_COMBI)
5087 {
5088 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5089 // since we still need to combine the plains
5090
5091 if (line_len > data.pw_max)
5092 {
5093 max++;
5094
5095 hc_thread_mutex_lock (mux_counter);
5096
5097 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5098 {
5099 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5100 }
5101
5102 hc_thread_mutex_unlock (mux_counter);
5103
5104 continue;
5105 }
5106 }
5107
5108 pw_add (device_param, (u8 *) line_buf, line_len);
5109
5110 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5111
5112 if (data.devices_status == STATUS_CRACKED) break;
5113 if (data.devices_status == STATUS_ABORTED) break;
5114 if (data.devices_status == STATUS_QUIT) break;
5115 if (data.devices_status == STATUS_BYPASS) break;
5116 }
5117
5118 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5119
5120 if (data.devices_status == STATUS_CRACKED) break;
5121 if (data.devices_status == STATUS_ABORTED) break;
5122 if (data.devices_status == STATUS_QUIT) break;
5123 if (data.devices_status == STATUS_BYPASS) break;
5124 }
5125
5126 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5127
5128 if (data.devices_status == STATUS_CRACKED) break;
5129 if (data.devices_status == STATUS_ABORTED) break;
5130 if (data.devices_status == STATUS_QUIT) break;
5131 if (data.devices_status == STATUS_BYPASS) break;
5132
5133 //
5134 // flush
5135 //
5136
5137 const uint pws_cnt = device_param->pws_cnt;
5138
5139 if (pws_cnt)
5140 {
5141 run_copy (device_param, pws_cnt);
5142
5143 run_cracker (device_param, pws_cnt);
5144
5145 device_param->pws_cnt = 0;
5146
5147 /*
5148 still required?
5149 if (attack_kern == ATTACK_KERN_STRAIGHT)
5150 {
5151 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5152 }
5153 else if (attack_kern == ATTACK_KERN_COMBI)
5154 {
5155 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5156 }
5157 */
5158 }
5159
5160 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5161
5162 if (data.devices_status == STATUS_CRACKED) break;
5163 if (data.devices_status == STATUS_ABORTED) break;
5164 if (data.devices_status == STATUS_QUIT) break;
5165 if (data.devices_status == STATUS_BYPASS) break;
5166
5167 if (words_fin == 0) break;
5168
5169 device_param->words_done = words_fin;
5170 }
5171
5172 if (attack_mode == ATTACK_MODE_COMBI)
5173 {
5174 fclose (device_param->combs_fp);
5175 }
5176
5177 free (wl_data->buf);
5178 free (wl_data);
5179
5180 fclose (fd);
5181 }
5182
5183 device_param->kernel_accel = 0;
5184 device_param->kernel_loops = 0;
5185
5186 return NULL;
5187 }
5188
5189 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5190 {
5191 if (!device_param)
5192 {
5193 log_error ("ERROR: %s : Invalid argument", __func__);
5194
5195 exit (-1);
5196 }
5197
5198 salt_t *salt_buf = &data.salts_buf[salt_pos];
5199
5200 device_param->kernel_params_buf32[24] = salt_pos;
5201 device_param->kernel_params_buf32[27] = 1;
5202 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
5203 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
5204 device_param->kernel_params_buf32[30] = 0;
5205 device_param->kernel_params_buf32[31] = 1;
5206
5207 char *dictfile_old = data.dictfile;
5208
5209 const char *weak_hash_check = "weak-hash-check";
5210
5211 data.dictfile = (char *) weak_hash_check;
5212
5213 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5214
5215 data.kernel_rules_buf[0].cmds[0] = 0;
5216
5217 /**
5218 * run the kernel
5219 */
5220
5221 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5222 {
5223 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5224 }
5225 else
5226 {
5227 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5228
5229 uint loop_step = 16;
5230
5231 const uint iter = salt_buf->salt_iter;
5232
5233 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5234 {
5235 uint loop_left = iter - loop_pos;
5236
5237 loop_left = MIN (loop_left, loop_step);
5238
5239 device_param->kernel_params_buf32[25] = loop_pos;
5240 device_param->kernel_params_buf32[26] = loop_left;
5241
5242 run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5243 }
5244
5245 run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5246 }
5247
5248 /**
5249 * result
5250 */
5251
5252 check_cracked (device_param, salt_pos);
5253
5254 /**
5255 * cleanup
5256 */
5257
5258 device_param->kernel_params_buf32[24] = 0;
5259 device_param->kernel_params_buf32[25] = 0;
5260 device_param->kernel_params_buf32[26] = 0;
5261 device_param->kernel_params_buf32[27] = 0;
5262 device_param->kernel_params_buf32[28] = 0;
5263 device_param->kernel_params_buf32[29] = 0;
5264 device_param->kernel_params_buf32[30] = 0;
5265 device_param->kernel_params_buf32[31] = 0;
5266
5267 data.dictfile = dictfile_old;
5268
5269 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5270 }
5271
5272 // hlfmt hashcat
5273
5274 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5275 {
5276 if (data.username == 0)
5277 {
5278 *hashbuf_pos = line_buf;
5279 *hashbuf_len = line_len;
5280 }
5281 else
5282 {
5283 char *pos = line_buf;
5284 int len = line_len;
5285
5286 for (int i = 0; i < line_len; i++, pos++, len--)
5287 {
5288 if (line_buf[i] == data.separator)
5289 {
5290 pos++;
5291
5292 len--;
5293
5294 break;
5295 }
5296 }
5297
5298 *hashbuf_pos = pos;
5299 *hashbuf_len = len;
5300 }
5301 }
5302
5303 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5304 {
5305 char *pos = NULL;
5306 int len = 0;
5307
5308 int sep_cnt = 0;
5309
5310 for (int i = 0; i < line_len; i++)
5311 {
5312 if (line_buf[i] == data.separator)
5313 {
5314 sep_cnt++;
5315
5316 continue;
5317 }
5318
5319 if (sep_cnt == 0)
5320 {
5321 if (pos == NULL) pos = line_buf + i;
5322
5323 len++;
5324 }
5325 }
5326
5327 *userbuf_pos = pos;
5328 *userbuf_len = len;
5329 }
5330
5331 // hlfmt pwdump
5332
5333 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5334 {
5335 int sep_cnt = 0;
5336
5337 int sep2_len = 0;
5338 int sep3_len = 0;
5339
5340 for (int i = 0; i < line_len; i++)
5341 {
5342 if (line_buf[i] == ':')
5343 {
5344 sep_cnt++;
5345
5346 continue;
5347 }
5348
5349 if (sep_cnt == 2) sep2_len++;
5350 if (sep_cnt == 3) sep3_len++;
5351 }
5352
5353 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5354
5355 return 0;
5356 }
5357
5358 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5359 {
5360 char *pos = NULL;
5361 int len = 0;
5362
5363 int sep_cnt = 0;
5364
5365 for (int i = 0; i < line_len; i++)
5366 {
5367 if (line_buf[i] == ':')
5368 {
5369 sep_cnt++;
5370
5371 continue;
5372 }
5373
5374 if (data.hash_mode == 1000)
5375 {
5376 if (sep_cnt == 3)
5377 {
5378 if (pos == NULL) pos = line_buf + i;
5379
5380 len++;
5381 }
5382 }
5383 else if (data.hash_mode == 3000)
5384 {
5385 if (sep_cnt == 2)
5386 {
5387 if (pos == NULL) pos = line_buf + i;
5388
5389 len++;
5390 }
5391 }
5392 }
5393
5394 *hashbuf_pos = pos;
5395 *hashbuf_len = len;
5396 }
5397
5398 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5399 {
5400 char *pos = NULL;
5401 int len = 0;
5402
5403 int sep_cnt = 0;
5404
5405 for (int i = 0; i < line_len; i++)
5406 {
5407 if (line_buf[i] == ':')
5408 {
5409 sep_cnt++;
5410
5411 continue;
5412 }
5413
5414 if (sep_cnt == 0)
5415 {
5416 if (pos == NULL) pos = line_buf + i;
5417
5418 len++;
5419 }
5420 }
5421
5422 *userbuf_pos = pos;
5423 *userbuf_len = len;
5424 }
5425
5426 // hlfmt passwd
5427
5428 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5429 {
5430 int sep_cnt = 0;
5431
5432 char sep5_first = 0;
5433 char sep6_first = 0;
5434
5435 for (int i = 0; i < line_len; i++)
5436 {
5437 if (line_buf[i] == ':')
5438 {
5439 sep_cnt++;
5440
5441 continue;
5442 }
5443
5444 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5445 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5446 }
5447
5448 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5449
5450 return 0;
5451 }
5452
5453 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5454 {
5455 char *pos = NULL;
5456 int len = 0;
5457
5458 int sep_cnt = 0;
5459
5460 for (int i = 0; i < line_len; i++)
5461 {
5462 if (line_buf[i] == ':')
5463 {
5464 sep_cnt++;
5465
5466 continue;
5467 }
5468
5469 if (sep_cnt == 1)
5470 {
5471 if (pos == NULL) pos = line_buf + i;
5472
5473 len++;
5474 }
5475 }
5476
5477 *hashbuf_pos = pos;
5478 *hashbuf_len = len;
5479 }
5480
5481 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5482 {
5483 char *pos = NULL;
5484 int len = 0;
5485
5486 int sep_cnt = 0;
5487
5488 for (int i = 0; i < line_len; i++)
5489 {
5490 if (line_buf[i] == ':')
5491 {
5492 sep_cnt++;
5493
5494 continue;
5495 }
5496
5497 if (sep_cnt == 0)
5498 {
5499 if (pos == NULL) pos = line_buf + i;
5500
5501 len++;
5502 }
5503 }
5504
5505 *userbuf_pos = pos;
5506 *userbuf_len = len;
5507 }
5508
5509 // hlfmt shadow
5510
5511 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5512 {
5513 int sep_cnt = 0;
5514
5515 for (int i = 0; i < line_len; i++)
5516 {
5517 if (line_buf[i] == ':') sep_cnt++;
5518 }
5519
5520 if (sep_cnt == 8) return 1;
5521
5522 return 0;
5523 }
5524
5525 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5526 {
5527 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5528 }
5529
5530 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5531 {
5532 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5533 }
5534
5535 // hlfmt main
5536
5537 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5538 {
5539 switch (hashfile_format)
5540 {
5541 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5542 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5543 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5544 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5545 }
5546 }
5547
5548 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5549 {
5550 switch (hashfile_format)
5551 {
5552 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5553 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5554 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5555 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5556 }
5557 }
5558
5559 char *strhlfmt (const uint hashfile_format)
5560 {
5561 switch (hashfile_format)
5562 {
5563 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5564 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5565 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5566 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5567 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5568 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5569 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5570 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5571 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5572 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5573 }
5574
5575 return ((char *) "Unknown");
5576 }
5577
5578 static uint hlfmt_detect (FILE *fp, uint max_check)
5579 {
5580 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5581
5582 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5583 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5584
5585 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5586
5587 uint num_check = 0;
5588
5589 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5590
5591 while (!feof (fp))
5592 {
5593 int line_len = fgetl (fp, line_buf);
5594
5595 if (line_len == 0) continue;
5596
5597 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5598 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5599 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5600
5601 if (num_check == max_check) break;
5602
5603 num_check++;
5604 }
5605
5606 myfree (line_buf);
5607
5608 uint hashlist_format = HLFMT_HASHCAT;
5609
5610 for (int i = 1; i < HLFMTS_CNT; i++)
5611 {
5612 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5613
5614 hashlist_format = i;
5615 }
5616
5617 free (formats_cnt);
5618
5619 return hashlist_format;
5620 }
5621
5622 /**
5623 * some further helper function
5624 */
5625
5626 // wrapper around mymalloc for ADL
5627
5628 #if defined(HAVE_HWMON)
5629 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5630 {
5631 return mymalloc (iSize);
5632 }
5633 #endif
5634
5635 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)
5636 {
5637 u64 collisions = 0;
5638
5639 const uint dgst_pos0 = data.dgst_pos0;
5640 const uint dgst_pos1 = data.dgst_pos1;
5641 const uint dgst_pos2 = data.dgst_pos2;
5642 const uint dgst_pos3 = data.dgst_pos3;
5643
5644 memset (bitmap_a, 0, bitmap_size);
5645 memset (bitmap_b, 0, bitmap_size);
5646 memset (bitmap_c, 0, bitmap_size);
5647 memset (bitmap_d, 0, bitmap_size);
5648
5649 for (uint i = 0; i < digests_cnt; i++)
5650 {
5651 uint *digest_ptr = (uint *) digests_buf_ptr;
5652
5653 digests_buf_ptr += dgst_size;
5654
5655 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5656 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5657 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5658 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5659
5660 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5661 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5662 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5663 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5664
5665 if (bitmap_a[idx0] & val0) collisions++;
5666 if (bitmap_b[idx1] & val1) collisions++;
5667 if (bitmap_c[idx2] & val2) collisions++;
5668 if (bitmap_d[idx3] & val3) collisions++;
5669
5670 bitmap_a[idx0] |= val0;
5671 bitmap_b[idx1] |= val1;
5672 bitmap_c[idx2] |= val2;
5673 bitmap_d[idx3] |= val3;
5674
5675 if (collisions >= collisions_max) return 0x7fffffff;
5676 }
5677
5678 return collisions;
5679 }
5680
5681 /**
5682 * main
5683 */
5684
5685 #ifdef WIN
5686 void SetConsoleWindowSize (const int x)
5687 {
5688 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5689
5690 if (h == INVALID_HANDLE_VALUE) return;
5691
5692 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5693
5694 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5695
5696 SMALL_RECT *sr = &bufferInfo.srWindow;
5697
5698 sr->Right = MAX (sr->Right, x - 1);
5699
5700 COORD co;
5701
5702 co.X = sr->Right + 1;
5703 co.Y = 9999;
5704
5705 if (!SetConsoleScreenBufferSize (h, co)) return;
5706
5707 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5708 }
5709 #endif
5710
5711 int main (int argc, char **argv)
5712 {
5713 #ifdef WIN
5714 SetConsoleWindowSize (132);
5715 #endif
5716
5717 /**
5718 * To help users a bit
5719 */
5720
5721 char *compute = getenv ("COMPUTE");
5722
5723 if (compute)
5724 {
5725 static char display[100];
5726
5727 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5728
5729 putenv (display);
5730 }
5731 else
5732 {
5733 if (getenv ("DISPLAY") == NULL)
5734 putenv ((char *) "DISPLAY=:0");
5735 }
5736
5737 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5738 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5739
5740 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5741 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5742
5743 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5744 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5745
5746 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5747 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5748
5749 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5750 putenv ((char *) "POCL_KERNEL_CACHE=0");
5751
5752 umask (077);
5753
5754 /**
5755 * Real init
5756 */
5757
5758 memset (&data, 0, sizeof (hc_global_data_t));
5759
5760 time_t proc_start;
5761
5762 time (&proc_start);
5763
5764 data.proc_start = proc_start;
5765
5766 int myargc = argc;
5767 char **myargv = argv;
5768
5769 hc_thread_mutex_init (mux_dispatcher);
5770 hc_thread_mutex_init (mux_counter);
5771 hc_thread_mutex_init (mux_display);
5772 hc_thread_mutex_init (mux_adl);
5773
5774 /**
5775 * commandline parameters
5776 */
5777
5778 uint usage = USAGE;
5779 uint version = VERSION;
5780 uint quiet = QUIET;
5781 uint benchmark = BENCHMARK;
5782 uint stdout_flag = STDOUT_FLAG;
5783 uint show = SHOW;
5784 uint left = LEFT;
5785 uint username = USERNAME;
5786 uint remove = REMOVE;
5787 uint remove_timer = REMOVE_TIMER;
5788 u64 skip = SKIP;
5789 u64 limit = LIMIT;
5790 uint keyspace = KEYSPACE;
5791 uint potfile_disable = POTFILE_DISABLE;
5792 char *potfile_path = NULL;
5793 uint debug_mode = DEBUG_MODE;
5794 char *debug_file = NULL;
5795 char *induction_dir = NULL;
5796 char *outfile_check_dir = NULL;
5797 uint force = FORCE;
5798 uint runtime = RUNTIME;
5799 uint hash_mode = HASH_MODE;
5800 uint attack_mode = ATTACK_MODE;
5801 uint markov_disable = MARKOV_DISABLE;
5802 uint markov_classic = MARKOV_CLASSIC;
5803 uint markov_threshold = MARKOV_THRESHOLD;
5804 char *markov_hcstat = NULL;
5805 char *outfile = NULL;
5806 uint outfile_format = OUTFILE_FORMAT;
5807 uint outfile_autohex = OUTFILE_AUTOHEX;
5808 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5809 uint restore = RESTORE;
5810 uint restore_timer = RESTORE_TIMER;
5811 uint restore_disable = RESTORE_DISABLE;
5812 uint status = STATUS;
5813 uint status_timer = STATUS_TIMER;
5814 uint machine_readable = MACHINE_READABLE;
5815 uint loopback = LOOPBACK;
5816 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5817 char *session = NULL;
5818 uint hex_charset = HEX_CHARSET;
5819 uint hex_salt = HEX_SALT;
5820 uint hex_wordlist = HEX_WORDLIST;
5821 uint rp_gen = RP_GEN;
5822 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5823 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5824 uint rp_gen_seed = RP_GEN_SEED;
5825 char *rule_buf_l = (char *) RULE_BUF_L;
5826 char *rule_buf_r = (char *) RULE_BUF_R;
5827 uint increment = INCREMENT;
5828 uint increment_min = INCREMENT_MIN;
5829 uint increment_max = INCREMENT_MAX;
5830 char *cpu_affinity = NULL;
5831 OCL_PTR *ocl = NULL;
5832 char *opencl_devices = NULL;
5833 char *opencl_platforms = NULL;
5834 char *opencl_device_types = NULL;
5835 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5836 char *truecrypt_keyfiles = NULL;
5837 char *veracrypt_keyfiles = NULL;
5838 uint veracrypt_pim = 0;
5839 uint workload_profile = WORKLOAD_PROFILE;
5840 uint kernel_accel = KERNEL_ACCEL;
5841 uint kernel_loops = KERNEL_LOOPS;
5842 uint nvidia_spin_damp = NVIDIA_SPIN_DAMP;
5843 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5844 #ifdef HAVE_HWMON
5845 uint gpu_temp_abort = GPU_TEMP_ABORT;
5846 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5847 uint powertune_enable = POWERTUNE_ENABLE;
5848 #endif
5849 uint logfile_disable = LOGFILE_DISABLE;
5850 uint segment_size = SEGMENT_SIZE;
5851 uint scrypt_tmto = SCRYPT_TMTO;
5852 char separator = SEPARATOR;
5853 uint bitmap_min = BITMAP_MIN;
5854 uint bitmap_max = BITMAP_MAX;
5855 char *custom_charset_1 = NULL;
5856 char *custom_charset_2 = NULL;
5857 char *custom_charset_3 = NULL;
5858 char *custom_charset_4 = NULL;
5859
5860 #define IDX_HELP 'h'
5861 #define IDX_VERSION 'V'
5862 #define IDX_VERSION_LOWER 'v'
5863 #define IDX_QUIET 0xff02
5864 #define IDX_SHOW 0xff03
5865 #define IDX_LEFT 0xff04
5866 #define IDX_REMOVE 0xff05
5867 #define IDX_REMOVE_TIMER 0xff37
5868 #define IDX_SKIP 's'
5869 #define IDX_LIMIT 'l'
5870 #define IDX_KEYSPACE 0xff35
5871 #define IDX_POTFILE_DISABLE 0xff06
5872 #define IDX_POTFILE_PATH 0xffe0
5873 #define IDX_DEBUG_MODE 0xff43
5874 #define IDX_DEBUG_FILE 0xff44
5875 #define IDX_INDUCTION_DIR 0xff46
5876 #define IDX_OUTFILE_CHECK_DIR 0xff47
5877 #define IDX_USERNAME 0xff07
5878 #define IDX_FORCE 0xff08
5879 #define IDX_RUNTIME 0xff09
5880 #define IDX_BENCHMARK 'b'
5881 #define IDX_STDOUT_FLAG 0xff77
5882 #define IDX_HASH_MODE 'm'
5883 #define IDX_ATTACK_MODE 'a'
5884 #define IDX_RP_FILE 'r'
5885 #define IDX_RP_GEN 'g'
5886 #define IDX_RP_GEN_FUNC_MIN 0xff10
5887 #define IDX_RP_GEN_FUNC_MAX 0xff11
5888 #define IDX_RP_GEN_SEED 0xff34
5889 #define IDX_RULE_BUF_L 'j'
5890 #define IDX_RULE_BUF_R 'k'
5891 #define IDX_INCREMENT 'i'
5892 #define IDX_INCREMENT_MIN 0xff12
5893 #define IDX_INCREMENT_MAX 0xff13
5894 #define IDX_OUTFILE 'o'
5895 #define IDX_OUTFILE_FORMAT 0xff14
5896 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5897 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5898 #define IDX_RESTORE 0xff15
5899 #define IDX_RESTORE_DISABLE 0xff27
5900 #define IDX_STATUS 0xff17
5901 #define IDX_STATUS_TIMER 0xff18
5902 #define IDX_MACHINE_READABLE 0xff50
5903 #define IDX_LOOPBACK 0xff38
5904 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5905 #define IDX_SESSION 0xff19
5906 #define IDX_HEX_CHARSET 0xff20
5907 #define IDX_HEX_SALT 0xff21
5908 #define IDX_HEX_WORDLIST 0xff40
5909 #define IDX_MARKOV_DISABLE 0xff22
5910 #define IDX_MARKOV_CLASSIC 0xff23
5911 #define IDX_MARKOV_THRESHOLD 't'
5912 #define IDX_MARKOV_HCSTAT 0xff24
5913 #define IDX_CPU_AFFINITY 0xff25
5914 #define IDX_OPENCL_DEVICES 'd'
5915 #define IDX_OPENCL_PLATFORMS 0xff72
5916 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5917 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5918 #define IDX_WORKLOAD_PROFILE 'w'
5919 #define IDX_KERNEL_ACCEL 'n'
5920 #define IDX_KERNEL_LOOPS 'u'
5921 #define IDX_NVIDIA_SPIN_DAMP 0xff79
5922 #define IDX_GPU_TEMP_DISABLE 0xff29
5923 #define IDX_GPU_TEMP_ABORT 0xff30
5924 #define IDX_GPU_TEMP_RETAIN 0xff31
5925 #define IDX_POWERTUNE_ENABLE 0xff41
5926 #define IDX_LOGFILE_DISABLE 0xff51
5927 #define IDX_TRUECRYPT_KEYFILES 0xff52
5928 #define IDX_VERACRYPT_KEYFILES 0xff53
5929 #define IDX_VERACRYPT_PIM 0xff54
5930 #define IDX_SCRYPT_TMTO 0xff61
5931 #define IDX_SEGMENT_SIZE 'c'
5932 #define IDX_SEPARATOR 'p'
5933 #define IDX_BITMAP_MIN 0xff70
5934 #define IDX_BITMAP_MAX 0xff71
5935 #define IDX_CUSTOM_CHARSET_1 '1'
5936 #define IDX_CUSTOM_CHARSET_2 '2'
5937 #define IDX_CUSTOM_CHARSET_3 '3'
5938 #define IDX_CUSTOM_CHARSET_4 '4'
5939
5940 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5941
5942 struct option long_options[] =
5943 {
5944 {"help", no_argument, 0, IDX_HELP},
5945 {"version", no_argument, 0, IDX_VERSION},
5946 {"quiet", no_argument, 0, IDX_QUIET},
5947 {"show", no_argument, 0, IDX_SHOW},
5948 {"left", no_argument, 0, IDX_LEFT},
5949 {"username", no_argument, 0, IDX_USERNAME},
5950 {"remove", no_argument, 0, IDX_REMOVE},
5951 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5952 {"skip", required_argument, 0, IDX_SKIP},
5953 {"limit", required_argument, 0, IDX_LIMIT},
5954 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5955 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5956 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5957 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5958 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5959 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5960 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5961 {"force", no_argument, 0, IDX_FORCE},
5962 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5963 {"stdout", no_argument, 0, IDX_STDOUT_FLAG},
5964 {"restore", no_argument, 0, IDX_RESTORE},
5965 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5966 {"status", no_argument, 0, IDX_STATUS},
5967 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5968 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5969 {"loopback", no_argument, 0, IDX_LOOPBACK},
5970 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5971 {"session", required_argument, 0, IDX_SESSION},
5972 {"runtime", required_argument, 0, IDX_RUNTIME},
5973 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5974 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5975 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5976 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5977 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5978 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5979 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5980 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5981 {"rules-file", required_argument, 0, IDX_RP_FILE},
5982 {"outfile", required_argument, 0, IDX_OUTFILE},
5983 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5984 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5985 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5986 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5987 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5988 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5989 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5990 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5991 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5992 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5993 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5994 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5995 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5996 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5997 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5998 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5999 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
6000 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
6001 {"nvidia-spin-damp", required_argument, 0, IDX_NVIDIA_SPIN_DAMP},
6002 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
6003 #ifdef HAVE_HWMON
6004 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
6005 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
6006 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
6007 #endif // HAVE_HWMON
6008 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
6009 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
6010 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
6011 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
6012 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
6013 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
6014 {"seperator", required_argument, 0, IDX_SEPARATOR},
6015 {"separator", required_argument, 0, IDX_SEPARATOR},
6016 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
6017 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
6018 {"increment", no_argument, 0, IDX_INCREMENT},
6019 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
6020 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
6021 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
6022 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
6023 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
6024 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
6025 {0, 0, 0, 0}
6026 };
6027
6028 uint rp_files_cnt = 0;
6029
6030 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6031
6032 int option_index = 0;
6033 int c = -1;
6034
6035 optind = 1;
6036 optopt = 0;
6037
6038 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6039 {
6040 switch (c)
6041 {
6042 case IDX_HELP: usage = 1; break;
6043 case IDX_VERSION:
6044 case IDX_VERSION_LOWER: version = 1; break;
6045 case IDX_RESTORE: restore = 1; break;
6046 case IDX_SESSION: session = optarg; break;
6047 case IDX_SHOW: show = 1; break;
6048 case IDX_LEFT: left = 1; break;
6049 case '?': return (-1);
6050 }
6051 }
6052
6053 if (optopt != 0)
6054 {
6055 log_error ("ERROR: Invalid argument specified");
6056
6057 return (-1);
6058 }
6059
6060 /**
6061 * exit functions
6062 */
6063
6064 if (version)
6065 {
6066 log_info ("%s", VERSION_TAG);
6067
6068 return (0);
6069 }
6070
6071 if (usage)
6072 {
6073 usage_big_print (PROGNAME);
6074
6075 return (0);
6076 }
6077
6078 /**
6079 * session needs to be set, always!
6080 */
6081
6082 if (session == NULL) session = (char *) PROGNAME;
6083
6084 /**
6085 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6086 */
6087
6088 char *exec_path = get_exec_path ();
6089
6090 #ifdef LINUX
6091
6092 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6093 char *resolved_exec_path = realpath (exec_path, NULL);
6094
6095 char *install_dir = get_install_dir (resolved_exec_path);
6096 char *profile_dir = NULL;
6097 char *session_dir = NULL;
6098 char *shared_dir = NULL;
6099
6100 if (strcmp (install_dir, resolved_install_folder) == 0)
6101 {
6102 struct passwd *pw = getpwuid (getuid ());
6103
6104 const char *homedir = pw->pw_dir;
6105
6106 profile_dir = get_profile_dir (homedir);
6107 session_dir = get_session_dir (profile_dir);
6108 shared_dir = strdup (SHARED_FOLDER);
6109
6110 mkdir (profile_dir, 0700);
6111 mkdir (session_dir, 0700);
6112 }
6113 else
6114 {
6115 profile_dir = install_dir;
6116 session_dir = install_dir;
6117 shared_dir = install_dir;
6118 }
6119
6120 myfree (resolved_install_folder);
6121 myfree (resolved_exec_path);
6122
6123 #else
6124
6125 char *install_dir = get_install_dir (exec_path);
6126 char *profile_dir = install_dir;
6127 char *session_dir = install_dir;
6128 char *shared_dir = install_dir;
6129
6130 #endif
6131
6132 data.install_dir = install_dir;
6133 data.profile_dir = profile_dir;
6134 data.session_dir = session_dir;
6135 data.shared_dir = shared_dir;
6136
6137 myfree (exec_path);
6138
6139 /**
6140 * kernel cache, we need to make sure folder exist
6141 */
6142
6143 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6144
6145 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6146
6147 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6148
6149 mkdir (kernels_folder, 0700);
6150
6151 myfree (kernels_folder);
6152
6153 /**
6154 * session
6155 */
6156
6157 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6158
6159 data.session = session;
6160
6161 char *eff_restore_file = (char *) mymalloc (session_size);
6162 char *new_restore_file = (char *) mymalloc (session_size);
6163
6164 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
6165 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6166
6167 data.eff_restore_file = eff_restore_file;
6168 data.new_restore_file = new_restore_file;
6169
6170 if (((show == 1) || (left == 1)) && (restore == 1))
6171 {
6172 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6173 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6174
6175 return (-1);
6176 }
6177
6178 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6179 if ((show == 1) || (left == 1))
6180 {
6181 restore_disable = 1;
6182
6183 restore = 0;
6184 }
6185
6186 data.restore_disable = restore_disable;
6187
6188 restore_data_t *rd = init_restore (argc, argv);
6189
6190 data.rd = rd;
6191
6192 /**
6193 * restore file
6194 */
6195
6196 if (restore == 1)
6197 {
6198 read_restore (eff_restore_file, rd);
6199
6200 if (rd->version_bin < RESTORE_MIN)
6201 {
6202 log_error ("ERROR: Incompatible restore-file version");
6203
6204 return (-1);
6205 }
6206
6207 myargc = rd->argc;
6208 myargv = rd->argv;
6209
6210 #ifdef _POSIX
6211 rd->pid = getpid ();
6212 #elif _WIN
6213 rd->pid = GetCurrentProcessId ();
6214 #endif
6215 }
6216
6217 uint hash_mode_chgd = 0;
6218 uint runtime_chgd = 0;
6219 uint kernel_loops_chgd = 0;
6220 uint kernel_accel_chgd = 0;
6221 uint nvidia_spin_damp_chgd = 0;
6222 uint attack_mode_chgd = 0;
6223 uint outfile_format_chgd = 0;
6224 uint rp_gen_seed_chgd = 0;
6225 uint remove_timer_chgd = 0;
6226 uint increment_min_chgd = 0;
6227 uint increment_max_chgd = 0;
6228 uint workload_profile_chgd = 0;
6229 uint opencl_vector_width_chgd = 0;
6230
6231 optind = 1;
6232 optopt = 0;
6233 option_index = 0;
6234
6235 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6236 {
6237 switch (c)
6238 {
6239 //case IDX_HELP: usage = 1; break;
6240 //case IDX_VERSION: version = 1; break;
6241 //case IDX_RESTORE: restore = 1; break;
6242 case IDX_QUIET: quiet = 1; break;
6243 //case IDX_SHOW: show = 1; break;
6244 case IDX_SHOW: break;
6245 //case IDX_LEFT: left = 1; break;
6246 case IDX_LEFT: break;
6247 case IDX_USERNAME: username = 1; break;
6248 case IDX_REMOVE: remove = 1; break;
6249 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6250 remove_timer_chgd = 1; break;
6251 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6252 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6253 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6254 case IDX_DEBUG_FILE: debug_file = optarg; break;
6255 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6256 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6257 case IDX_FORCE: force = 1; break;
6258 case IDX_SKIP: skip = atoll (optarg); break;
6259 case IDX_LIMIT: limit = atoll (optarg); break;
6260 case IDX_KEYSPACE: keyspace = 1; break;
6261 case IDX_BENCHMARK: benchmark = 1; break;
6262 case IDX_STDOUT_FLAG: stdout_flag = 1; break;
6263 case IDX_RESTORE: break;
6264 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6265 case IDX_STATUS: status = 1; break;
6266 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6267 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6268 case IDX_LOOPBACK: loopback = 1; break;
6269 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6270 //case IDX_SESSION: session = optarg; break;
6271 case IDX_SESSION: break;
6272 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6273 hash_mode_chgd = 1; break;
6274 case IDX_RUNTIME: runtime = atoi (optarg);
6275 runtime_chgd = 1; break;
6276 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6277 attack_mode_chgd = 1; break;
6278 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6279 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6280 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6281 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6282 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6283 rp_gen_seed_chgd = 1; break;
6284 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6285 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6286 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6287 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6288 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6289 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6290 case IDX_OUTFILE: outfile = optarg; break;
6291 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6292 outfile_format_chgd = 1; break;
6293 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6294 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6295 case IDX_HEX_CHARSET: hex_charset = 1; break;
6296 case IDX_HEX_SALT: hex_salt = 1; break;
6297 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6298 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6299 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6300 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6301 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6302 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6303 opencl_vector_width_chgd = 1; break;
6304 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6305 workload_profile_chgd = 1; break;
6306 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6307 kernel_accel_chgd = 1; break;
6308 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6309 kernel_loops_chgd = 1; break;
6310 case IDX_NVIDIA_SPIN_DAMP: nvidia_spin_damp = atoi (optarg);
6311 nvidia_spin_damp_chgd = 1; break;
6312 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6313 #ifdef HAVE_HWMON
6314 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6315 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6316 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6317 #endif // HAVE_HWMON
6318 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6319 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6320 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6321 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6322 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6323 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6324 case IDX_SEPARATOR: separator = optarg[0]; break;
6325 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6326 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6327 case IDX_INCREMENT: increment = 1; break;
6328 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6329 increment_min_chgd = 1; break;
6330 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6331 increment_max_chgd = 1; break;
6332 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6333 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6334 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6335 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6336
6337 default:
6338 log_error ("ERROR: Invalid argument specified");
6339 return (-1);
6340 }
6341 }
6342
6343 if (optopt != 0)
6344 {
6345 log_error ("ERROR: Invalid argument specified");
6346
6347 return (-1);
6348 }
6349
6350 /**
6351 * Inform user things getting started,
6352 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6353 * - we do not need to check algorithm_pos
6354 */
6355
6356 if (quiet == 0)
6357 {
6358 if (benchmark == 1)
6359 {
6360 if (machine_readable == 0)
6361 {
6362 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6363 log_info ("");
6364 log_info ("Note: Reported benchmark cracking speed = real cracking speed");
6365 log_info ("To verify, run hashcat like this: only_one_hash.txt -a 3 -w 3 ?b?b?b?b?b?b?b");
6366 log_info ("");
6367 }
6368 else
6369 {
6370 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6371 }
6372 }
6373 else if (restore == 1)
6374 {
6375 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6376 log_info ("");
6377 }
6378 else if (stdout_flag == 1)
6379 {
6380 // do nothing
6381 }
6382 else
6383 {
6384 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6385 log_info ("");
6386 }
6387 }
6388
6389 /**
6390 * sanity check
6391 */
6392
6393 if (attack_mode > 7)
6394 {
6395 log_error ("ERROR: Invalid attack-mode specified");
6396
6397 return (-1);
6398 }
6399
6400 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6401 {
6402 log_error ("ERROR: Invalid runtime specified");
6403
6404 return (-1);
6405 }
6406
6407 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6408 {
6409 log_error ("ERROR: Invalid hash-type specified");
6410
6411 return (-1);
6412 }
6413
6414 // renamed hash modes
6415
6416 if (hash_mode_chgd)
6417 {
6418 int n = -1;
6419
6420 switch (hash_mode)
6421 {
6422 case 123: n = 124;
6423 break;
6424 }
6425
6426 if (n >= 0)
6427 {
6428 log_error ("Old -m specified, use -m %d instead", n);
6429
6430 return (-1);
6431 }
6432 }
6433
6434 if (username == 1)
6435 {
6436 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6437 {
6438 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6439
6440 return (-1);
6441 }
6442 }
6443
6444 if (outfile_format > 16)
6445 {
6446 log_error ("ERROR: Invalid outfile-format specified");
6447
6448 return (-1);
6449 }
6450
6451 if (left == 1)
6452 {
6453 if (outfile_format_chgd == 1)
6454 {
6455 if (outfile_format > 1)
6456 {
6457 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6458
6459 return (-1);
6460 }
6461 }
6462 else
6463 {
6464 outfile_format = OUTFILE_FMT_HASH;
6465 }
6466 }
6467
6468 if (show == 1)
6469 {
6470 if (outfile_format_chgd == 1)
6471 {
6472 if ((outfile_format > 7) && (outfile_format < 16))
6473 {
6474 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6475
6476 return (-1);
6477 }
6478 }
6479 }
6480
6481 if (increment_min < INCREMENT_MIN)
6482 {
6483 log_error ("ERROR: Invalid increment-min specified");
6484
6485 return (-1);
6486 }
6487
6488 if (increment_max > INCREMENT_MAX)
6489 {
6490 log_error ("ERROR: Invalid increment-max specified");
6491
6492 return (-1);
6493 }
6494
6495 if (increment_min > increment_max)
6496 {
6497 log_error ("ERROR: Invalid increment-min specified");
6498
6499 return (-1);
6500 }
6501
6502 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6503 {
6504 log_error ("ERROR: increment is not allowed in attack-mode 0");
6505
6506 return (-1);
6507 }
6508
6509 if ((increment == 0) && (increment_min_chgd == 1))
6510 {
6511 log_error ("ERROR: increment-min is only supported together with increment switch");
6512
6513 return (-1);
6514 }
6515
6516 if ((increment == 0) && (increment_max_chgd == 1))
6517 {
6518 log_error ("ERROR: increment-max is only supported together with increment switch");
6519
6520 return (-1);
6521 }
6522
6523 if (rp_files_cnt && rp_gen)
6524 {
6525 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6526
6527 return (-1);
6528 }
6529
6530 if (rp_files_cnt || rp_gen)
6531 {
6532 if (attack_mode != ATTACK_MODE_STRAIGHT)
6533 {
6534 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6535
6536 return (-1);
6537 }
6538 }
6539
6540 if (rp_gen_func_min > rp_gen_func_max)
6541 {
6542 log_error ("ERROR: Invalid rp-gen-func-min specified");
6543
6544 return (-1);
6545 }
6546
6547 if (kernel_accel_chgd == 1)
6548 {
6549 if (force == 0)
6550 {
6551 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6552 log_info ("Please consider using the option -w instead");
6553 log_info ("You can use --force to override this but do not post error reports if you do so");
6554 log_info ("");
6555
6556 return (-1);
6557 }
6558
6559 if (kernel_accel < 1)
6560 {
6561 log_error ("ERROR: Invalid kernel-accel specified");
6562
6563 return (-1);
6564 }
6565
6566 if (kernel_accel > 1024)
6567 {
6568 log_error ("ERROR: Invalid kernel-accel specified");
6569
6570 return (-1);
6571 }
6572 }
6573
6574 if (kernel_loops_chgd == 1)
6575 {
6576 if (force == 0)
6577 {
6578 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6579 log_info ("Please consider using the option -w instead");
6580 log_info ("You can use --force to override this but do not post error reports if you do so");
6581 log_info ("");
6582
6583 return (-1);
6584 }
6585
6586 if (kernel_loops < 1)
6587 {
6588 log_error ("ERROR: Invalid kernel-loops specified");
6589
6590 return (-1);
6591 }
6592
6593 if (kernel_loops > 1024)
6594 {
6595 log_error ("ERROR: Invalid kernel-loops specified");
6596
6597 return (-1);
6598 }
6599 }
6600
6601 if ((workload_profile < 1) || (workload_profile > 4))
6602 {
6603 log_error ("ERROR: workload-profile %i not available", workload_profile);
6604
6605 return (-1);
6606 }
6607
6608 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6609 {
6610 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6611
6612 return (-1);
6613 }
6614
6615 if (show == 1 || left == 1)
6616 {
6617 attack_mode = ATTACK_MODE_NONE;
6618
6619 if (remove == 1)
6620 {
6621 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6622
6623 return (-1);
6624 }
6625
6626 if (potfile_disable == 1)
6627 {
6628 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6629
6630 return (-1);
6631 }
6632 }
6633
6634 uint attack_kern = ATTACK_KERN_NONE;
6635
6636 switch (attack_mode)
6637 {
6638 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6639 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6640 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6641 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6642 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6643 }
6644
6645 if (benchmark == 1)
6646 {
6647 if (myargv[optind] != 0)
6648 {
6649 log_error ("ERROR: Invalid argument for benchmark mode specified");
6650
6651 return (-1);
6652 }
6653
6654 if (attack_mode_chgd == 1)
6655 {
6656 if (attack_mode != ATTACK_MODE_BF)
6657 {
6658 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6659
6660 return (-1);
6661 }
6662 }
6663 }
6664 else
6665 {
6666 if (stdout_flag == 1) // no hash here
6667 {
6668 optind--;
6669 }
6670
6671 if (keyspace == 1)
6672 {
6673 int num_additional_params = 1;
6674
6675 if (attack_kern == ATTACK_KERN_COMBI)
6676 {
6677 num_additional_params = 2;
6678 }
6679
6680 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6681
6682 if (keyspace_wordlist_specified == 0) optind--;
6683 }
6684
6685 if (attack_kern == ATTACK_KERN_NONE)
6686 {
6687 if ((optind + 1) != myargc)
6688 {
6689 usage_mini_print (myargv[0]);
6690
6691 return (-1);
6692 }
6693 }
6694 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6695 {
6696 if ((optind + 1) > myargc)
6697 {
6698 usage_mini_print (myargv[0]);
6699
6700 return (-1);
6701 }
6702 }
6703 else if (attack_kern == ATTACK_KERN_COMBI)
6704 {
6705 if ((optind + 3) != myargc)
6706 {
6707 usage_mini_print (myargv[0]);
6708
6709 return (-1);
6710 }
6711 }
6712 else if (attack_kern == ATTACK_KERN_BF)
6713 {
6714 if ((optind + 1) > myargc)
6715 {
6716 usage_mini_print (myargv[0]);
6717
6718 return (-1);
6719 }
6720 }
6721 else
6722 {
6723 usage_mini_print (myargv[0]);
6724
6725 return (-1);
6726 }
6727 }
6728
6729 if (skip != 0 && limit != 0)
6730 {
6731 limit += skip;
6732 }
6733
6734 if (keyspace == 1)
6735 {
6736 if (show == 1)
6737 {
6738 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6739
6740 return (-1);
6741 }
6742 else if (left == 1)
6743 {
6744 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6745
6746 return (-1);
6747 }
6748
6749 potfile_disable = 1;
6750
6751 restore_disable = 1;
6752
6753 restore = 0;
6754
6755 weak_hash_threshold = 0;
6756
6757 quiet = 1;
6758 }
6759
6760 if (stdout_flag == 1)
6761 {
6762 status_timer = 0;
6763 restore_timer = 0;
6764 restore_disable = 1;
6765 restore = 0;
6766 potfile_disable = 1;
6767 weak_hash_threshold = 0;
6768 gpu_temp_disable = 1;
6769 hash_mode = 2000;
6770 quiet = 1;
6771 outfile_format = OUTFILE_FMT_PLAIN;
6772 kernel_accel = 1024;
6773 kernel_loops = 1024;
6774 force = 1;
6775 outfile_check_timer = 0;
6776 session = "stdout";
6777 opencl_vector_width = 1;
6778 }
6779
6780 if (remove_timer_chgd == 1)
6781 {
6782 if (remove == 0)
6783 {
6784 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6785
6786 return (-1);
6787 }
6788
6789 if (remove_timer < 1)
6790 {
6791 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6792
6793 return (-1);
6794 }
6795 }
6796
6797 if (loopback == 1)
6798 {
6799 if (attack_mode == ATTACK_MODE_STRAIGHT)
6800 {
6801 if ((rp_files_cnt == 0) && (rp_gen == 0))
6802 {
6803 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6804
6805 return (-1);
6806 }
6807 }
6808 else
6809 {
6810 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6811
6812 return (-1);
6813 }
6814 }
6815
6816 if (debug_mode > 0)
6817 {
6818 if (attack_mode != ATTACK_MODE_STRAIGHT)
6819 {
6820 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6821
6822 return (-1);
6823 }
6824
6825 if ((rp_files_cnt == 0) && (rp_gen == 0))
6826 {
6827 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6828
6829 return (-1);
6830 }
6831 }
6832
6833 if (debug_mode > 4)
6834 {
6835 log_error ("ERROR: Invalid debug-mode specified");
6836
6837 return (-1);
6838 }
6839
6840 if (debug_file != NULL)
6841 {
6842 if (debug_mode < 1)
6843 {
6844 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6845
6846 return (-1);
6847 }
6848 }
6849
6850 if (induction_dir != NULL)
6851 {
6852 if (attack_mode == ATTACK_MODE_BF)
6853 {
6854 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6855
6856 return (-1);
6857 }
6858 }
6859
6860 if (attack_mode != ATTACK_MODE_STRAIGHT)
6861 {
6862 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6863 {
6864 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6865
6866 return (-1);
6867 }
6868
6869 weak_hash_threshold = 0;
6870 }
6871
6872 if (nvidia_spin_damp > 100)
6873 {
6874 log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)");
6875
6876 return (-1);
6877 }
6878
6879
6880 /**
6881 * induction directory
6882 */
6883
6884 char *induction_directory = NULL;
6885
6886 if (attack_mode != ATTACK_MODE_BF)
6887 {
6888 if (induction_dir == NULL)
6889 {
6890 induction_directory = (char *) mymalloc (session_size);
6891
6892 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6893
6894 // create induction folder if it does not already exist
6895
6896 if (keyspace == 0)
6897 {
6898 if (rmdir (induction_directory) == -1)
6899 {
6900 if (errno == ENOENT)
6901 {
6902 // good, we can ignore
6903 }
6904 else if (errno == ENOTEMPTY)
6905 {
6906 char *induction_directory_mv = (char *) mymalloc (session_size);
6907
6908 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6909
6910 if (rename (induction_directory, induction_directory_mv) != 0)
6911 {
6912 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6913
6914 return (-1);
6915 }
6916 }
6917 else
6918 {
6919 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6920
6921 return (-1);
6922 }
6923 }
6924
6925 if (mkdir (induction_directory, 0700) == -1)
6926 {
6927 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6928
6929 return (-1);
6930 }
6931 }
6932 }
6933 else
6934 {
6935 induction_directory = induction_dir;
6936 }
6937 }
6938
6939 data.induction_directory = induction_directory;
6940
6941 /**
6942 * loopback
6943 */
6944
6945 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6946
6947 char *loopback_file = (char *) mymalloc (loopback_size);
6948
6949 /**
6950 * tuning db
6951 */
6952
6953 char tuning_db_file[256] = { 0 };
6954
6955 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6956
6957 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6958
6959 /**
6960 * outfile-check directory
6961 */
6962
6963 char *outfile_check_directory = NULL;
6964
6965 if (outfile_check_dir == NULL)
6966 {
6967 outfile_check_directory = (char *) mymalloc (session_size);
6968
6969 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6970 }
6971 else
6972 {
6973 outfile_check_directory = outfile_check_dir;
6974 }
6975
6976 data.outfile_check_directory = outfile_check_directory;
6977
6978 if (keyspace == 0)
6979 {
6980 struct stat outfile_check_stat;
6981
6982 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6983 {
6984 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6985
6986 if (is_dir == 0)
6987 {
6988 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6989
6990 return (-1);
6991 }
6992 }
6993 else if (outfile_check_dir == NULL)
6994 {
6995 if (mkdir (outfile_check_directory, 0700) == -1)
6996 {
6997 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6998
6999 return (-1);
7000 }
7001 }
7002 }
7003
7004 /**
7005 * special other stuff
7006 */
7007
7008 if (hash_mode == 9710)
7009 {
7010 outfile_format = 5;
7011 outfile_format_chgd = 1;
7012 }
7013
7014 if (hash_mode == 9810)
7015 {
7016 outfile_format = 5;
7017 outfile_format_chgd = 1;
7018 }
7019
7020 if (hash_mode == 10410)
7021 {
7022 outfile_format = 5;
7023 outfile_format_chgd = 1;
7024 }
7025
7026 /**
7027 * store stuff
7028 */
7029
7030 data.hash_mode = hash_mode;
7031 data.restore = restore;
7032 data.restore_timer = restore_timer;
7033 data.restore_disable = restore_disable;
7034 data.status = status;
7035 data.status_timer = status_timer;
7036 data.machine_readable = machine_readable;
7037 data.loopback = loopback;
7038 data.runtime = runtime;
7039 data.remove = remove;
7040 data.remove_timer = remove_timer;
7041 data.debug_mode = debug_mode;
7042 data.debug_file = debug_file;
7043 data.username = username;
7044 data.quiet = quiet;
7045 data.outfile = outfile;
7046 data.outfile_format = outfile_format;
7047 data.outfile_autohex = outfile_autohex;
7048 data.hex_charset = hex_charset;
7049 data.hex_salt = hex_salt;
7050 data.hex_wordlist = hex_wordlist;
7051 data.separator = separator;
7052 data.rp_files = rp_files;
7053 data.rp_files_cnt = rp_files_cnt;
7054 data.rp_gen = rp_gen;
7055 data.rp_gen_seed = rp_gen_seed;
7056 data.force = force;
7057 data.benchmark = benchmark;
7058 data.skip = skip;
7059 data.limit = limit;
7060 #ifdef HAVE_HWMON
7061 data.powertune_enable = powertune_enable;
7062 #endif
7063 data.logfile_disable = logfile_disable;
7064 data.truecrypt_keyfiles = truecrypt_keyfiles;
7065 data.veracrypt_keyfiles = veracrypt_keyfiles;
7066 data.veracrypt_pim = veracrypt_pim;
7067 data.scrypt_tmto = scrypt_tmto;
7068 data.workload_profile = workload_profile;
7069
7070 /**
7071 * cpu affinity
7072 */
7073
7074 if (cpu_affinity)
7075 {
7076 set_cpu_affinity (cpu_affinity);
7077 }
7078
7079 if (rp_gen_seed_chgd == 0)
7080 {
7081 srand (proc_start);
7082 }
7083 else
7084 {
7085 srand (rp_gen_seed);
7086 }
7087
7088 /**
7089 * logfile init
7090 */
7091
7092 if (logfile_disable == 0)
7093 {
7094 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7095
7096 char *logfile = (char *) mymalloc (logfile_size);
7097
7098 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7099
7100 data.logfile = logfile;
7101
7102 char *topid = logfile_generate_topid ();
7103
7104 data.topid = topid;
7105 }
7106
7107 // logfile_append() checks for logfile_disable internally to make it easier from here
7108
7109 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7110 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7111 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7112 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7113 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7114 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7115 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7116 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7117 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7118 #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));
7119
7120 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7121 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7122 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7123 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7124 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7125 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7126 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7127 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7128
7129 logfile_top_msg ("START");
7130
7131 logfile_top_uint (attack_mode);
7132 logfile_top_uint (attack_kern);
7133 logfile_top_uint (benchmark);
7134 logfile_top_uint (stdout_flag);
7135 logfile_top_uint (bitmap_min);
7136 logfile_top_uint (bitmap_max);
7137 logfile_top_uint (debug_mode);
7138 logfile_top_uint (force);
7139 logfile_top_uint (kernel_accel);
7140 logfile_top_uint (kernel_loops);
7141 logfile_top_uint (nvidia_spin_damp);
7142 logfile_top_uint (gpu_temp_disable);
7143 #ifdef HAVE_HWMON
7144 logfile_top_uint (gpu_temp_abort);
7145 logfile_top_uint (gpu_temp_retain);
7146 #endif
7147 logfile_top_uint (hash_mode);
7148 logfile_top_uint (hex_charset);
7149 logfile_top_uint (hex_salt);
7150 logfile_top_uint (hex_wordlist);
7151 logfile_top_uint (increment);
7152 logfile_top_uint (increment_max);
7153 logfile_top_uint (increment_min);
7154 logfile_top_uint (keyspace);
7155 logfile_top_uint (left);
7156 logfile_top_uint (logfile_disable);
7157 logfile_top_uint (loopback);
7158 logfile_top_uint (markov_classic);
7159 logfile_top_uint (markov_disable);
7160 logfile_top_uint (markov_threshold);
7161 logfile_top_uint (outfile_autohex);
7162 logfile_top_uint (outfile_check_timer);
7163 logfile_top_uint (outfile_format);
7164 logfile_top_uint (potfile_disable);
7165 logfile_top_string (potfile_path);
7166 #if defined(HAVE_HWMON)
7167 logfile_top_uint (powertune_enable);
7168 #endif
7169 logfile_top_uint (scrypt_tmto);
7170 logfile_top_uint (quiet);
7171 logfile_top_uint (remove);
7172 logfile_top_uint (remove_timer);
7173 logfile_top_uint (restore);
7174 logfile_top_uint (restore_disable);
7175 logfile_top_uint (restore_timer);
7176 logfile_top_uint (rp_gen);
7177 logfile_top_uint (rp_gen_func_max);
7178 logfile_top_uint (rp_gen_func_min);
7179 logfile_top_uint (rp_gen_seed);
7180 logfile_top_uint (runtime);
7181 logfile_top_uint (segment_size);
7182 logfile_top_uint (show);
7183 logfile_top_uint (status);
7184 logfile_top_uint (machine_readable);
7185 logfile_top_uint (status_timer);
7186 logfile_top_uint (usage);
7187 logfile_top_uint (username);
7188 logfile_top_uint (version);
7189 logfile_top_uint (weak_hash_threshold);
7190 logfile_top_uint (workload_profile);
7191 logfile_top_uint64 (limit);
7192 logfile_top_uint64 (skip);
7193 logfile_top_char (separator);
7194 logfile_top_string (cpu_affinity);
7195 logfile_top_string (custom_charset_1);
7196 logfile_top_string (custom_charset_2);
7197 logfile_top_string (custom_charset_3);
7198 logfile_top_string (custom_charset_4);
7199 logfile_top_string (debug_file);
7200 logfile_top_string (opencl_devices);
7201 logfile_top_string (opencl_platforms);
7202 logfile_top_string (opencl_device_types);
7203 logfile_top_uint (opencl_vector_width);
7204 logfile_top_string (induction_dir);
7205 logfile_top_string (markov_hcstat);
7206 logfile_top_string (outfile);
7207 logfile_top_string (outfile_check_dir);
7208 logfile_top_string (rule_buf_l);
7209 logfile_top_string (rule_buf_r);
7210 logfile_top_string (session);
7211 logfile_top_string (truecrypt_keyfiles);
7212 logfile_top_string (veracrypt_keyfiles);
7213 logfile_top_uint (veracrypt_pim);
7214
7215 /**
7216 * Init OpenCL library loader
7217 */
7218
7219 if (keyspace == 0)
7220 {
7221 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7222
7223 ocl_init (ocl);
7224
7225 data.ocl = ocl;
7226 }
7227
7228 /**
7229 * OpenCL platform selection
7230 */
7231
7232 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7233
7234 /**
7235 * OpenCL device selection
7236 */
7237
7238 u32 devices_filter = setup_devices_filter (opencl_devices);
7239
7240 /**
7241 * OpenCL device type selection
7242 */
7243
7244 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7245
7246 /**
7247 * benchmark
7248 */
7249
7250 if (benchmark == 1)
7251 {
7252 /**
7253 * disable useless stuff for benchmark
7254 */
7255
7256 status_timer = 0;
7257 restore_timer = 0;
7258 restore_disable = 1;
7259 potfile_disable = 1;
7260 weak_hash_threshold = 0;
7261 nvidia_spin_damp = 0;
7262 gpu_temp_disable = 1;
7263 outfile_check_timer = 0;
7264
7265 #ifdef HAVE_HWMON
7266 if (powertune_enable == 1)
7267 {
7268 gpu_temp_disable = 0;
7269 }
7270 #endif
7271
7272 data.status_timer = status_timer;
7273 data.restore_timer = restore_timer;
7274 data.restore_disable = restore_disable;
7275 data.outfile_check_timer = outfile_check_timer;
7276
7277 /**
7278 * force attack mode to be bruteforce
7279 */
7280
7281 attack_mode = ATTACK_MODE_BF;
7282 attack_kern = ATTACK_KERN_BF;
7283
7284 if (workload_profile_chgd == 0)
7285 {
7286 workload_profile = 3;
7287
7288 data.workload_profile = workload_profile;
7289 }
7290 }
7291
7292 /**
7293 * config
7294 */
7295
7296 uint hash_type = 0;
7297 uint salt_type = 0;
7298 uint attack_exec = 0;
7299 uint opts_type = 0;
7300 uint kern_type = 0;
7301 uint dgst_size = 0;
7302 uint esalt_size = 0;
7303 uint opti_type = 0;
7304 uint dgst_pos0 = -1;
7305 uint dgst_pos1 = -1;
7306 uint dgst_pos2 = -1;
7307 uint dgst_pos3 = -1;
7308
7309 int (*parse_func) (char *, uint, hash_t *);
7310 int (*sort_by_digest) (const void *, const void *);
7311
7312 uint algorithm_pos = 0;
7313 uint algorithm_max = 1;
7314
7315 uint *algorithms = default_benchmark_algorithms;
7316
7317 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7318
7319 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7320 {
7321 /*
7322 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7323 * the following algos are skipped entirely
7324 */
7325
7326 if (algorithm_pos > 0)
7327 {
7328 local_free (rd);
7329
7330 rd = init_restore (argc, argv);
7331
7332 data.rd = rd;
7333 }
7334
7335 /**
7336 * update hash_mode in case of multihash benchmark
7337 */
7338
7339 if (benchmark == 1)
7340 {
7341 if (hash_mode_chgd == 0)
7342 {
7343 hash_mode = algorithms[algorithm_pos];
7344
7345 data.hash_mode = hash_mode;
7346 }
7347
7348 quiet = 1;
7349
7350 data.quiet = quiet;
7351 }
7352
7353 switch (hash_mode)
7354 {
7355 case 0: hash_type = HASH_TYPE_MD5;
7356 salt_type = SALT_TYPE_NONE;
7357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7358 opts_type = OPTS_TYPE_PT_GENERATE_LE
7359 | OPTS_TYPE_PT_ADD80
7360 | OPTS_TYPE_PT_ADDBITS14;
7361 kern_type = KERN_TYPE_MD5;
7362 dgst_size = DGST_SIZE_4_4;
7363 parse_func = md5_parse_hash;
7364 sort_by_digest = sort_by_digest_4_4;
7365 opti_type = OPTI_TYPE_ZERO_BYTE
7366 | OPTI_TYPE_PRECOMPUTE_INIT
7367 | OPTI_TYPE_PRECOMPUTE_MERKLE
7368 | OPTI_TYPE_MEET_IN_MIDDLE
7369 | OPTI_TYPE_EARLY_SKIP
7370 | OPTI_TYPE_NOT_ITERATED
7371 | OPTI_TYPE_NOT_SALTED
7372 | OPTI_TYPE_RAW_HASH;
7373 dgst_pos0 = 0;
7374 dgst_pos1 = 3;
7375 dgst_pos2 = 2;
7376 dgst_pos3 = 1;
7377 break;
7378
7379 case 10: hash_type = HASH_TYPE_MD5;
7380 salt_type = SALT_TYPE_INTERN;
7381 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7382 opts_type = OPTS_TYPE_PT_GENERATE_LE
7383 | OPTS_TYPE_ST_ADD80
7384 | OPTS_TYPE_ST_ADDBITS14;
7385 kern_type = KERN_TYPE_MD5_PWSLT;
7386 dgst_size = DGST_SIZE_4_4;
7387 parse_func = md5s_parse_hash;
7388 sort_by_digest = sort_by_digest_4_4;
7389 opti_type = OPTI_TYPE_ZERO_BYTE
7390 | OPTI_TYPE_PRECOMPUTE_INIT
7391 | OPTI_TYPE_PRECOMPUTE_MERKLE
7392 | OPTI_TYPE_MEET_IN_MIDDLE
7393 | OPTI_TYPE_EARLY_SKIP
7394 | OPTI_TYPE_NOT_ITERATED
7395 | OPTI_TYPE_APPENDED_SALT
7396 | OPTI_TYPE_RAW_HASH;
7397 dgst_pos0 = 0;
7398 dgst_pos1 = 3;
7399 dgst_pos2 = 2;
7400 dgst_pos3 = 1;
7401 break;
7402
7403 case 11: hash_type = HASH_TYPE_MD5;
7404 salt_type = SALT_TYPE_INTERN;
7405 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7406 opts_type = OPTS_TYPE_PT_GENERATE_LE
7407 | OPTS_TYPE_ST_ADD80
7408 | OPTS_TYPE_ST_ADDBITS14;
7409 kern_type = KERN_TYPE_MD5_PWSLT;
7410 dgst_size = DGST_SIZE_4_4;
7411 parse_func = joomla_parse_hash;
7412 sort_by_digest = sort_by_digest_4_4;
7413 opti_type = OPTI_TYPE_ZERO_BYTE
7414 | OPTI_TYPE_PRECOMPUTE_INIT
7415 | OPTI_TYPE_PRECOMPUTE_MERKLE
7416 | OPTI_TYPE_MEET_IN_MIDDLE
7417 | OPTI_TYPE_EARLY_SKIP
7418 | OPTI_TYPE_NOT_ITERATED
7419 | OPTI_TYPE_APPENDED_SALT
7420 | OPTI_TYPE_RAW_HASH;
7421 dgst_pos0 = 0;
7422 dgst_pos1 = 3;
7423 dgst_pos2 = 2;
7424 dgst_pos3 = 1;
7425 break;
7426
7427 case 12: hash_type = HASH_TYPE_MD5;
7428 salt_type = SALT_TYPE_INTERN;
7429 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7430 opts_type = OPTS_TYPE_PT_GENERATE_LE
7431 | OPTS_TYPE_ST_ADD80
7432 | OPTS_TYPE_ST_ADDBITS14;
7433 kern_type = KERN_TYPE_MD5_PWSLT;
7434 dgst_size = DGST_SIZE_4_4;
7435 parse_func = postgresql_parse_hash;
7436 sort_by_digest = sort_by_digest_4_4;
7437 opti_type = OPTI_TYPE_ZERO_BYTE
7438 | OPTI_TYPE_PRECOMPUTE_INIT
7439 | OPTI_TYPE_PRECOMPUTE_MERKLE
7440 | OPTI_TYPE_MEET_IN_MIDDLE
7441 | OPTI_TYPE_EARLY_SKIP
7442 | OPTI_TYPE_NOT_ITERATED
7443 | OPTI_TYPE_APPENDED_SALT
7444 | OPTI_TYPE_RAW_HASH;
7445 dgst_pos0 = 0;
7446 dgst_pos1 = 3;
7447 dgst_pos2 = 2;
7448 dgst_pos3 = 1;
7449 break;
7450
7451 case 20: hash_type = HASH_TYPE_MD5;
7452 salt_type = SALT_TYPE_INTERN;
7453 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7454 opts_type = OPTS_TYPE_PT_GENERATE_LE
7455 | OPTS_TYPE_PT_ADD80
7456 | OPTS_TYPE_PT_ADDBITS14;
7457 kern_type = KERN_TYPE_MD5_SLTPW;
7458 dgst_size = DGST_SIZE_4_4;
7459 parse_func = md5s_parse_hash;
7460 sort_by_digest = sort_by_digest_4_4;
7461 opti_type = OPTI_TYPE_ZERO_BYTE
7462 | OPTI_TYPE_PRECOMPUTE_INIT
7463 | OPTI_TYPE_PRECOMPUTE_MERKLE
7464 | OPTI_TYPE_EARLY_SKIP
7465 | OPTI_TYPE_NOT_ITERATED
7466 | OPTI_TYPE_PREPENDED_SALT
7467 | OPTI_TYPE_RAW_HASH;
7468 dgst_pos0 = 0;
7469 dgst_pos1 = 3;
7470 dgst_pos2 = 2;
7471 dgst_pos3 = 1;
7472 break;
7473
7474 case 21: hash_type = HASH_TYPE_MD5;
7475 salt_type = SALT_TYPE_INTERN;
7476 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7477 opts_type = OPTS_TYPE_PT_GENERATE_LE
7478 | OPTS_TYPE_PT_ADD80
7479 | OPTS_TYPE_PT_ADDBITS14;
7480 kern_type = KERN_TYPE_MD5_SLTPW;
7481 dgst_size = DGST_SIZE_4_4;
7482 parse_func = osc_parse_hash;
7483 sort_by_digest = sort_by_digest_4_4;
7484 opti_type = OPTI_TYPE_ZERO_BYTE
7485 | OPTI_TYPE_PRECOMPUTE_INIT
7486 | OPTI_TYPE_PRECOMPUTE_MERKLE
7487 | OPTI_TYPE_EARLY_SKIP
7488 | OPTI_TYPE_NOT_ITERATED
7489 | OPTI_TYPE_PREPENDED_SALT
7490 | OPTI_TYPE_RAW_HASH;
7491 dgst_pos0 = 0;
7492 dgst_pos1 = 3;
7493 dgst_pos2 = 2;
7494 dgst_pos3 = 1;
7495 break;
7496
7497 case 22: hash_type = HASH_TYPE_MD5;
7498 salt_type = SALT_TYPE_EMBEDDED;
7499 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7500 opts_type = OPTS_TYPE_PT_GENERATE_LE
7501 | OPTS_TYPE_PT_ADD80
7502 | OPTS_TYPE_PT_ADDBITS14;
7503 kern_type = KERN_TYPE_MD5_SLTPW;
7504 dgst_size = DGST_SIZE_4_4;
7505 parse_func = netscreen_parse_hash;
7506 sort_by_digest = sort_by_digest_4_4;
7507 opti_type = OPTI_TYPE_ZERO_BYTE
7508 | OPTI_TYPE_PRECOMPUTE_INIT
7509 | OPTI_TYPE_PRECOMPUTE_MERKLE
7510 | OPTI_TYPE_EARLY_SKIP
7511 | OPTI_TYPE_NOT_ITERATED
7512 | OPTI_TYPE_PREPENDED_SALT
7513 | OPTI_TYPE_RAW_HASH;
7514 dgst_pos0 = 0;
7515 dgst_pos1 = 3;
7516 dgst_pos2 = 2;
7517 dgst_pos3 = 1;
7518 break;
7519
7520 case 23: hash_type = HASH_TYPE_MD5;
7521 salt_type = SALT_TYPE_EMBEDDED;
7522 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7523 opts_type = OPTS_TYPE_PT_GENERATE_LE
7524 | OPTS_TYPE_PT_ADD80
7525 | OPTS_TYPE_PT_ADDBITS14;
7526 kern_type = KERN_TYPE_MD5_SLTPW;
7527 dgst_size = DGST_SIZE_4_4;
7528 parse_func = skype_parse_hash;
7529 sort_by_digest = sort_by_digest_4_4;
7530 opti_type = OPTI_TYPE_ZERO_BYTE
7531 | OPTI_TYPE_PRECOMPUTE_INIT
7532 | OPTI_TYPE_PRECOMPUTE_MERKLE
7533 | OPTI_TYPE_EARLY_SKIP
7534 | OPTI_TYPE_NOT_ITERATED
7535 | OPTI_TYPE_PREPENDED_SALT
7536 | OPTI_TYPE_RAW_HASH;
7537 dgst_pos0 = 0;
7538 dgst_pos1 = 3;
7539 dgst_pos2 = 2;
7540 dgst_pos3 = 1;
7541 break;
7542
7543 case 30: hash_type = HASH_TYPE_MD5;
7544 salt_type = SALT_TYPE_INTERN;
7545 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7546 opts_type = OPTS_TYPE_PT_GENERATE_LE
7547 | OPTS_TYPE_PT_UNICODE
7548 | OPTS_TYPE_ST_ADD80
7549 | OPTS_TYPE_ST_ADDBITS14;
7550 kern_type = KERN_TYPE_MD5_PWUSLT;
7551 dgst_size = DGST_SIZE_4_4;
7552 parse_func = md5s_parse_hash;
7553 sort_by_digest = sort_by_digest_4_4;
7554 opti_type = OPTI_TYPE_ZERO_BYTE
7555 | OPTI_TYPE_PRECOMPUTE_INIT
7556 | OPTI_TYPE_PRECOMPUTE_MERKLE
7557 | OPTI_TYPE_MEET_IN_MIDDLE
7558 | OPTI_TYPE_EARLY_SKIP
7559 | OPTI_TYPE_NOT_ITERATED
7560 | OPTI_TYPE_APPENDED_SALT
7561 | OPTI_TYPE_RAW_HASH;
7562 dgst_pos0 = 0;
7563 dgst_pos1 = 3;
7564 dgst_pos2 = 2;
7565 dgst_pos3 = 1;
7566 break;
7567
7568 case 40: hash_type = HASH_TYPE_MD5;
7569 salt_type = SALT_TYPE_INTERN;
7570 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7571 opts_type = OPTS_TYPE_PT_GENERATE_LE
7572 | OPTS_TYPE_PT_ADD80
7573 | OPTS_TYPE_PT_ADDBITS14
7574 | OPTS_TYPE_PT_UNICODE;
7575 kern_type = KERN_TYPE_MD5_SLTPWU;
7576 dgst_size = DGST_SIZE_4_4;
7577 parse_func = md5s_parse_hash;
7578 sort_by_digest = sort_by_digest_4_4;
7579 opti_type = OPTI_TYPE_ZERO_BYTE
7580 | OPTI_TYPE_PRECOMPUTE_INIT
7581 | OPTI_TYPE_PRECOMPUTE_MERKLE
7582 | OPTI_TYPE_EARLY_SKIP
7583 | OPTI_TYPE_NOT_ITERATED
7584 | OPTI_TYPE_PREPENDED_SALT
7585 | OPTI_TYPE_RAW_HASH;
7586 dgst_pos0 = 0;
7587 dgst_pos1 = 3;
7588 dgst_pos2 = 2;
7589 dgst_pos3 = 1;
7590 break;
7591
7592 case 50: hash_type = HASH_TYPE_MD5;
7593 salt_type = SALT_TYPE_INTERN;
7594 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7595 opts_type = OPTS_TYPE_PT_GENERATE_LE
7596 | OPTS_TYPE_ST_ADD80
7597 | OPTS_TYPE_ST_ADDBITS14;
7598 kern_type = KERN_TYPE_HMACMD5_PW;
7599 dgst_size = DGST_SIZE_4_4;
7600 parse_func = hmacmd5_parse_hash;
7601 sort_by_digest = sort_by_digest_4_4;
7602 opti_type = OPTI_TYPE_ZERO_BYTE
7603 | OPTI_TYPE_NOT_ITERATED;
7604 dgst_pos0 = 0;
7605 dgst_pos1 = 3;
7606 dgst_pos2 = 2;
7607 dgst_pos3 = 1;
7608 break;
7609
7610 case 60: hash_type = HASH_TYPE_MD5;
7611 salt_type = SALT_TYPE_INTERN;
7612 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7613 opts_type = OPTS_TYPE_PT_GENERATE_LE
7614 | OPTS_TYPE_PT_ADD80
7615 | OPTS_TYPE_PT_ADDBITS14;
7616 kern_type = KERN_TYPE_HMACMD5_SLT;
7617 dgst_size = DGST_SIZE_4_4;
7618 parse_func = hmacmd5_parse_hash;
7619 sort_by_digest = sort_by_digest_4_4;
7620 opti_type = OPTI_TYPE_ZERO_BYTE
7621 | OPTI_TYPE_NOT_ITERATED;
7622 dgst_pos0 = 0;
7623 dgst_pos1 = 3;
7624 dgst_pos2 = 2;
7625 dgst_pos3 = 1;
7626 break;
7627
7628 case 100: hash_type = HASH_TYPE_SHA1;
7629 salt_type = SALT_TYPE_NONE;
7630 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7631 opts_type = OPTS_TYPE_PT_GENERATE_BE
7632 | OPTS_TYPE_PT_ADD80
7633 | OPTS_TYPE_PT_ADDBITS15;
7634 kern_type = KERN_TYPE_SHA1;
7635 dgst_size = DGST_SIZE_4_5;
7636 parse_func = sha1_parse_hash;
7637 sort_by_digest = sort_by_digest_4_5;
7638 opti_type = OPTI_TYPE_ZERO_BYTE
7639 | OPTI_TYPE_PRECOMPUTE_INIT
7640 | OPTI_TYPE_PRECOMPUTE_MERKLE
7641 | OPTI_TYPE_EARLY_SKIP
7642 | OPTI_TYPE_NOT_ITERATED
7643 | OPTI_TYPE_NOT_SALTED
7644 | OPTI_TYPE_RAW_HASH;
7645 dgst_pos0 = 3;
7646 dgst_pos1 = 4;
7647 dgst_pos2 = 2;
7648 dgst_pos3 = 1;
7649 break;
7650
7651 case 101: hash_type = HASH_TYPE_SHA1;
7652 salt_type = SALT_TYPE_NONE;
7653 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7654 opts_type = OPTS_TYPE_PT_GENERATE_BE
7655 | OPTS_TYPE_PT_ADD80
7656 | OPTS_TYPE_PT_ADDBITS15;
7657 kern_type = KERN_TYPE_SHA1;
7658 dgst_size = DGST_SIZE_4_5;
7659 parse_func = sha1b64_parse_hash;
7660 sort_by_digest = sort_by_digest_4_5;
7661 opti_type = OPTI_TYPE_ZERO_BYTE
7662 | OPTI_TYPE_PRECOMPUTE_INIT
7663 | OPTI_TYPE_PRECOMPUTE_MERKLE
7664 | OPTI_TYPE_EARLY_SKIP
7665 | OPTI_TYPE_NOT_ITERATED
7666 | OPTI_TYPE_NOT_SALTED
7667 | OPTI_TYPE_RAW_HASH;
7668 dgst_pos0 = 3;
7669 dgst_pos1 = 4;
7670 dgst_pos2 = 2;
7671 dgst_pos3 = 1;
7672 break;
7673
7674 case 110: hash_type = HASH_TYPE_SHA1;
7675 salt_type = SALT_TYPE_INTERN;
7676 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7677 opts_type = OPTS_TYPE_PT_GENERATE_BE
7678 | OPTS_TYPE_ST_ADD80
7679 | OPTS_TYPE_ST_ADDBITS15;
7680 kern_type = KERN_TYPE_SHA1_PWSLT;
7681 dgst_size = DGST_SIZE_4_5;
7682 parse_func = sha1s_parse_hash;
7683 sort_by_digest = sort_by_digest_4_5;
7684 opti_type = OPTI_TYPE_ZERO_BYTE
7685 | OPTI_TYPE_PRECOMPUTE_INIT
7686 | OPTI_TYPE_PRECOMPUTE_MERKLE
7687 | OPTI_TYPE_EARLY_SKIP
7688 | OPTI_TYPE_NOT_ITERATED
7689 | OPTI_TYPE_APPENDED_SALT
7690 | OPTI_TYPE_RAW_HASH;
7691 dgst_pos0 = 3;
7692 dgst_pos1 = 4;
7693 dgst_pos2 = 2;
7694 dgst_pos3 = 1;
7695 break;
7696
7697 case 111: hash_type = HASH_TYPE_SHA1;
7698 salt_type = SALT_TYPE_EMBEDDED;
7699 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7700 opts_type = OPTS_TYPE_PT_GENERATE_BE
7701 | OPTS_TYPE_ST_ADD80
7702 | OPTS_TYPE_ST_ADDBITS15;
7703 kern_type = KERN_TYPE_SHA1_PWSLT;
7704 dgst_size = DGST_SIZE_4_5;
7705 parse_func = sha1b64s_parse_hash;
7706 sort_by_digest = sort_by_digest_4_5;
7707 opti_type = OPTI_TYPE_ZERO_BYTE
7708 | OPTI_TYPE_PRECOMPUTE_INIT
7709 | OPTI_TYPE_PRECOMPUTE_MERKLE
7710 | OPTI_TYPE_EARLY_SKIP
7711 | OPTI_TYPE_NOT_ITERATED
7712 | OPTI_TYPE_APPENDED_SALT
7713 | OPTI_TYPE_RAW_HASH;
7714 dgst_pos0 = 3;
7715 dgst_pos1 = 4;
7716 dgst_pos2 = 2;
7717 dgst_pos3 = 1;
7718 break;
7719
7720 case 112: hash_type = HASH_TYPE_SHA1;
7721 salt_type = SALT_TYPE_INTERN;
7722 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7723 opts_type = OPTS_TYPE_PT_GENERATE_BE
7724 | OPTS_TYPE_ST_ADD80
7725 | OPTS_TYPE_ST_ADDBITS15
7726 | OPTS_TYPE_ST_HEX;
7727 kern_type = KERN_TYPE_SHA1_PWSLT;
7728 dgst_size = DGST_SIZE_4_5;
7729 parse_func = oracles_parse_hash;
7730 sort_by_digest = sort_by_digest_4_5;
7731 opti_type = OPTI_TYPE_ZERO_BYTE
7732 | OPTI_TYPE_PRECOMPUTE_INIT
7733 | OPTI_TYPE_PRECOMPUTE_MERKLE
7734 | OPTI_TYPE_EARLY_SKIP
7735 | OPTI_TYPE_NOT_ITERATED
7736 | OPTI_TYPE_APPENDED_SALT
7737 | OPTI_TYPE_RAW_HASH;
7738 dgst_pos0 = 3;
7739 dgst_pos1 = 4;
7740 dgst_pos2 = 2;
7741 dgst_pos3 = 1;
7742 break;
7743
7744 case 120: hash_type = HASH_TYPE_SHA1;
7745 salt_type = SALT_TYPE_INTERN;
7746 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7747 opts_type = OPTS_TYPE_PT_GENERATE_BE
7748 | OPTS_TYPE_PT_ADD80
7749 | OPTS_TYPE_PT_ADDBITS15;
7750 kern_type = KERN_TYPE_SHA1_SLTPW;
7751 dgst_size = DGST_SIZE_4_5;
7752 parse_func = sha1s_parse_hash;
7753 sort_by_digest = sort_by_digest_4_5;
7754 opti_type = OPTI_TYPE_ZERO_BYTE
7755 | OPTI_TYPE_PRECOMPUTE_INIT
7756 | OPTI_TYPE_PRECOMPUTE_MERKLE
7757 | OPTI_TYPE_EARLY_SKIP
7758 | OPTI_TYPE_NOT_ITERATED
7759 | OPTI_TYPE_PREPENDED_SALT
7760 | OPTI_TYPE_RAW_HASH;
7761 dgst_pos0 = 3;
7762 dgst_pos1 = 4;
7763 dgst_pos2 = 2;
7764 dgst_pos3 = 1;
7765 break;
7766
7767 case 121: hash_type = HASH_TYPE_SHA1;
7768 salt_type = SALT_TYPE_INTERN;
7769 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7770 opts_type = OPTS_TYPE_PT_GENERATE_BE
7771 | OPTS_TYPE_PT_ADD80
7772 | OPTS_TYPE_PT_ADDBITS15
7773 | OPTS_TYPE_ST_LOWER;
7774 kern_type = KERN_TYPE_SHA1_SLTPW;
7775 dgst_size = DGST_SIZE_4_5;
7776 parse_func = smf_parse_hash;
7777 sort_by_digest = sort_by_digest_4_5;
7778 opti_type = OPTI_TYPE_ZERO_BYTE
7779 | OPTI_TYPE_PRECOMPUTE_INIT
7780 | OPTI_TYPE_PRECOMPUTE_MERKLE
7781 | OPTI_TYPE_EARLY_SKIP
7782 | OPTI_TYPE_NOT_ITERATED
7783 | OPTI_TYPE_PREPENDED_SALT
7784 | OPTI_TYPE_RAW_HASH;
7785 dgst_pos0 = 3;
7786 dgst_pos1 = 4;
7787 dgst_pos2 = 2;
7788 dgst_pos3 = 1;
7789 break;
7790
7791 case 122: hash_type = HASH_TYPE_SHA1;
7792 salt_type = SALT_TYPE_EMBEDDED;
7793 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7794 opts_type = OPTS_TYPE_PT_GENERATE_BE
7795 | OPTS_TYPE_PT_ADD80
7796 | OPTS_TYPE_PT_ADDBITS15
7797 | OPTS_TYPE_ST_HEX;
7798 kern_type = KERN_TYPE_SHA1_SLTPW;
7799 dgst_size = DGST_SIZE_4_5;
7800 parse_func = osx1_parse_hash;
7801 sort_by_digest = sort_by_digest_4_5;
7802 opti_type = OPTI_TYPE_ZERO_BYTE
7803 | OPTI_TYPE_PRECOMPUTE_INIT
7804 | OPTI_TYPE_PRECOMPUTE_MERKLE
7805 | OPTI_TYPE_EARLY_SKIP
7806 | OPTI_TYPE_NOT_ITERATED
7807 | OPTI_TYPE_PREPENDED_SALT
7808 | OPTI_TYPE_RAW_HASH;
7809 dgst_pos0 = 3;
7810 dgst_pos1 = 4;
7811 dgst_pos2 = 2;
7812 dgst_pos3 = 1;
7813 break;
7814
7815 case 124: hash_type = HASH_TYPE_SHA1;
7816 salt_type = SALT_TYPE_EMBEDDED;
7817 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7818 opts_type = OPTS_TYPE_PT_GENERATE_BE
7819 | OPTS_TYPE_PT_ADD80
7820 | OPTS_TYPE_PT_ADDBITS15;
7821 kern_type = KERN_TYPE_SHA1_SLTPW;
7822 dgst_size = DGST_SIZE_4_5;
7823 parse_func = djangosha1_parse_hash;
7824 sort_by_digest = sort_by_digest_4_5;
7825 opti_type = OPTI_TYPE_ZERO_BYTE
7826 | OPTI_TYPE_PRECOMPUTE_INIT
7827 | OPTI_TYPE_PRECOMPUTE_MERKLE
7828 | OPTI_TYPE_EARLY_SKIP
7829 | OPTI_TYPE_NOT_ITERATED
7830 | OPTI_TYPE_PREPENDED_SALT
7831 | OPTI_TYPE_RAW_HASH;
7832 dgst_pos0 = 3;
7833 dgst_pos1 = 4;
7834 dgst_pos2 = 2;
7835 dgst_pos3 = 1;
7836 break;
7837
7838 case 125: hash_type = HASH_TYPE_SHA1;
7839 salt_type = SALT_TYPE_EMBEDDED;
7840 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7841 opts_type = OPTS_TYPE_PT_GENERATE_BE
7842 | OPTS_TYPE_PT_ADD80
7843 | OPTS_TYPE_PT_ADDBITS15
7844 | OPTS_TYPE_ST_HEX;
7845 kern_type = KERN_TYPE_SHA1_SLTPW;
7846 dgst_size = DGST_SIZE_4_5;
7847 parse_func = arubaos_parse_hash;
7848 sort_by_digest = sort_by_digest_4_5;
7849 opti_type = OPTI_TYPE_ZERO_BYTE
7850 | OPTI_TYPE_PRECOMPUTE_INIT
7851 | OPTI_TYPE_PRECOMPUTE_MERKLE
7852 | OPTI_TYPE_EARLY_SKIP
7853 | OPTI_TYPE_NOT_ITERATED
7854 | OPTI_TYPE_PREPENDED_SALT
7855 | OPTI_TYPE_RAW_HASH;
7856 dgst_pos0 = 3;
7857 dgst_pos1 = 4;
7858 dgst_pos2 = 2;
7859 dgst_pos3 = 1;
7860 break;
7861
7862 case 130: hash_type = HASH_TYPE_SHA1;
7863 salt_type = SALT_TYPE_INTERN;
7864 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7865 opts_type = OPTS_TYPE_PT_GENERATE_BE
7866 | OPTS_TYPE_PT_UNICODE
7867 | OPTS_TYPE_ST_ADD80
7868 | OPTS_TYPE_ST_ADDBITS15;
7869 kern_type = KERN_TYPE_SHA1_PWUSLT;
7870 dgst_size = DGST_SIZE_4_5;
7871 parse_func = sha1s_parse_hash;
7872 sort_by_digest = sort_by_digest_4_5;
7873 opti_type = OPTI_TYPE_ZERO_BYTE
7874 | OPTI_TYPE_PRECOMPUTE_INIT
7875 | OPTI_TYPE_PRECOMPUTE_MERKLE
7876 | OPTI_TYPE_EARLY_SKIP
7877 | OPTI_TYPE_NOT_ITERATED
7878 | OPTI_TYPE_APPENDED_SALT
7879 | OPTI_TYPE_RAW_HASH;
7880 dgst_pos0 = 3;
7881 dgst_pos1 = 4;
7882 dgst_pos2 = 2;
7883 dgst_pos3 = 1;
7884 break;
7885
7886 case 131: hash_type = HASH_TYPE_SHA1;
7887 salt_type = SALT_TYPE_EMBEDDED;
7888 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7889 opts_type = OPTS_TYPE_PT_GENERATE_BE
7890 | OPTS_TYPE_PT_UNICODE
7891 | OPTS_TYPE_PT_UPPER
7892 | OPTS_TYPE_ST_ADD80
7893 | OPTS_TYPE_ST_ADDBITS15
7894 | OPTS_TYPE_ST_HEX;
7895 kern_type = KERN_TYPE_SHA1_PWUSLT;
7896 dgst_size = DGST_SIZE_4_5;
7897 parse_func = mssql2000_parse_hash;
7898 sort_by_digest = sort_by_digest_4_5;
7899 opti_type = OPTI_TYPE_ZERO_BYTE
7900 | OPTI_TYPE_PRECOMPUTE_INIT
7901 | OPTI_TYPE_PRECOMPUTE_MERKLE
7902 | OPTI_TYPE_EARLY_SKIP
7903 | OPTI_TYPE_NOT_ITERATED
7904 | OPTI_TYPE_APPENDED_SALT
7905 | OPTI_TYPE_RAW_HASH;
7906 dgst_pos0 = 3;
7907 dgst_pos1 = 4;
7908 dgst_pos2 = 2;
7909 dgst_pos3 = 1;
7910 break;
7911
7912 case 132: hash_type = HASH_TYPE_SHA1;
7913 salt_type = SALT_TYPE_EMBEDDED;
7914 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7915 opts_type = OPTS_TYPE_PT_GENERATE_BE
7916 | OPTS_TYPE_PT_UNICODE
7917 | OPTS_TYPE_ST_ADD80
7918 | OPTS_TYPE_ST_ADDBITS15
7919 | OPTS_TYPE_ST_HEX;
7920 kern_type = KERN_TYPE_SHA1_PWUSLT;
7921 dgst_size = DGST_SIZE_4_5;
7922 parse_func = mssql2005_parse_hash;
7923 sort_by_digest = sort_by_digest_4_5;
7924 opti_type = OPTI_TYPE_ZERO_BYTE
7925 | OPTI_TYPE_PRECOMPUTE_INIT
7926 | OPTI_TYPE_PRECOMPUTE_MERKLE
7927 | OPTI_TYPE_EARLY_SKIP
7928 | OPTI_TYPE_NOT_ITERATED
7929 | OPTI_TYPE_APPENDED_SALT
7930 | OPTI_TYPE_RAW_HASH;
7931 dgst_pos0 = 3;
7932 dgst_pos1 = 4;
7933 dgst_pos2 = 2;
7934 dgst_pos3 = 1;
7935 break;
7936
7937 case 133: hash_type = HASH_TYPE_SHA1;
7938 salt_type = SALT_TYPE_EMBEDDED;
7939 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7940 opts_type = OPTS_TYPE_PT_GENERATE_BE
7941 | OPTS_TYPE_PT_UNICODE
7942 | OPTS_TYPE_ST_ADD80
7943 | OPTS_TYPE_ST_ADDBITS15;
7944 kern_type = KERN_TYPE_SHA1_PWUSLT;
7945 dgst_size = DGST_SIZE_4_5;
7946 parse_func = peoplesoft_parse_hash;
7947 sort_by_digest = sort_by_digest_4_5;
7948 opti_type = OPTI_TYPE_ZERO_BYTE
7949 | OPTI_TYPE_PRECOMPUTE_INIT
7950 | OPTI_TYPE_PRECOMPUTE_MERKLE
7951 | OPTI_TYPE_EARLY_SKIP
7952 | OPTI_TYPE_NOT_ITERATED
7953 | OPTI_TYPE_APPENDED_SALT
7954 | OPTI_TYPE_RAW_HASH;
7955 dgst_pos0 = 3;
7956 dgst_pos1 = 4;
7957 dgst_pos2 = 2;
7958 dgst_pos3 = 1;
7959 break;
7960
7961 case 140: hash_type = HASH_TYPE_SHA1;
7962 salt_type = SALT_TYPE_INTERN;
7963 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7964 opts_type = OPTS_TYPE_PT_GENERATE_BE
7965 | OPTS_TYPE_PT_ADD80
7966 | OPTS_TYPE_PT_ADDBITS15
7967 | OPTS_TYPE_PT_UNICODE;
7968 kern_type = KERN_TYPE_SHA1_SLTPWU;
7969 dgst_size = DGST_SIZE_4_5;
7970 parse_func = sha1s_parse_hash;
7971 sort_by_digest = sort_by_digest_4_5;
7972 opti_type = OPTI_TYPE_ZERO_BYTE
7973 | OPTI_TYPE_PRECOMPUTE_INIT
7974 | OPTI_TYPE_PRECOMPUTE_MERKLE
7975 | OPTI_TYPE_EARLY_SKIP
7976 | OPTI_TYPE_NOT_ITERATED
7977 | OPTI_TYPE_PREPENDED_SALT
7978 | OPTI_TYPE_RAW_HASH;
7979 dgst_pos0 = 3;
7980 dgst_pos1 = 4;
7981 dgst_pos2 = 2;
7982 dgst_pos3 = 1;
7983 break;
7984
7985 case 141: hash_type = HASH_TYPE_SHA1;
7986 salt_type = SALT_TYPE_EMBEDDED;
7987 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7988 opts_type = OPTS_TYPE_PT_GENERATE_BE
7989 | OPTS_TYPE_PT_ADD80
7990 | OPTS_TYPE_PT_ADDBITS15
7991 | OPTS_TYPE_PT_UNICODE
7992 | OPTS_TYPE_ST_BASE64;
7993 kern_type = KERN_TYPE_SHA1_SLTPWU;
7994 dgst_size = DGST_SIZE_4_5;
7995 parse_func = episerver_parse_hash;
7996 sort_by_digest = sort_by_digest_4_5;
7997 opti_type = OPTI_TYPE_ZERO_BYTE
7998 | OPTI_TYPE_PRECOMPUTE_INIT
7999 | OPTI_TYPE_PRECOMPUTE_MERKLE
8000 | OPTI_TYPE_EARLY_SKIP
8001 | OPTI_TYPE_NOT_ITERATED
8002 | OPTI_TYPE_PREPENDED_SALT
8003 | OPTI_TYPE_RAW_HASH;
8004 dgst_pos0 = 3;
8005 dgst_pos1 = 4;
8006 dgst_pos2 = 2;
8007 dgst_pos3 = 1;
8008 break;
8009
8010 case 150: hash_type = HASH_TYPE_SHA1;
8011 salt_type = SALT_TYPE_INTERN;
8012 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8013 opts_type = OPTS_TYPE_PT_GENERATE_BE
8014 | OPTS_TYPE_ST_ADD80
8015 | OPTS_TYPE_ST_ADDBITS15;
8016 kern_type = KERN_TYPE_HMACSHA1_PW;
8017 dgst_size = DGST_SIZE_4_5;
8018 parse_func = hmacsha1_parse_hash;
8019 sort_by_digest = sort_by_digest_4_5;
8020 opti_type = OPTI_TYPE_ZERO_BYTE
8021 | OPTI_TYPE_NOT_ITERATED;
8022 dgst_pos0 = 3;
8023 dgst_pos1 = 4;
8024 dgst_pos2 = 2;
8025 dgst_pos3 = 1;
8026 break;
8027
8028 case 160: hash_type = HASH_TYPE_SHA1;
8029 salt_type = SALT_TYPE_INTERN;
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 kern_type = KERN_TYPE_HMACSHA1_SLT;
8035 dgst_size = DGST_SIZE_4_5;
8036 parse_func = hmacsha1_parse_hash;
8037 sort_by_digest = sort_by_digest_4_5;
8038 opti_type = OPTI_TYPE_ZERO_BYTE
8039 | OPTI_TYPE_NOT_ITERATED;
8040 dgst_pos0 = 3;
8041 dgst_pos1 = 4;
8042 dgst_pos2 = 2;
8043 dgst_pos3 = 1;
8044 break;
8045
8046 case 190: hash_type = HASH_TYPE_SHA1;
8047 salt_type = SALT_TYPE_NONE;
8048 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8049 opts_type = OPTS_TYPE_PT_GENERATE_BE
8050 | OPTS_TYPE_PT_ADD80
8051 | OPTS_TYPE_PT_ADDBITS15;
8052 kern_type = KERN_TYPE_SHA1_LINKEDIN;
8053 dgst_size = DGST_SIZE_4_5;
8054 parse_func = sha1linkedin_parse_hash;
8055 sort_by_digest = sort_by_digest_4_5;
8056 opti_type = OPTI_TYPE_ZERO_BYTE
8057 | OPTI_TYPE_PRECOMPUTE_INIT
8058 | OPTI_TYPE_EARLY_SKIP
8059 | OPTI_TYPE_NOT_ITERATED
8060 | OPTI_TYPE_NOT_SALTED;
8061 dgst_pos0 = 0;
8062 dgst_pos1 = 4;
8063 dgst_pos2 = 3;
8064 dgst_pos3 = 2;
8065 break;
8066
8067 case 200: hash_type = HASH_TYPE_MYSQL;
8068 salt_type = SALT_TYPE_NONE;
8069 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8070 opts_type = 0;
8071 kern_type = KERN_TYPE_MYSQL;
8072 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8073 parse_func = mysql323_parse_hash;
8074 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8075 opti_type = OPTI_TYPE_ZERO_BYTE;
8076 dgst_pos0 = 0;
8077 dgst_pos1 = 1;
8078 dgst_pos2 = 2;
8079 dgst_pos3 = 3;
8080 break;
8081
8082 case 300: hash_type = HASH_TYPE_SHA1;
8083 salt_type = SALT_TYPE_NONE;
8084 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8085 opts_type = OPTS_TYPE_PT_GENERATE_BE
8086 | OPTS_TYPE_PT_ADD80
8087 | OPTS_TYPE_PT_ADDBITS15;
8088 kern_type = KERN_TYPE_MYSQL41;
8089 dgst_size = DGST_SIZE_4_5;
8090 parse_func = sha1_parse_hash;
8091 sort_by_digest = sort_by_digest_4_5;
8092 opti_type = OPTI_TYPE_ZERO_BYTE
8093 | OPTI_TYPE_PRECOMPUTE_INIT
8094 | OPTI_TYPE_PRECOMPUTE_MERKLE
8095 | OPTI_TYPE_EARLY_SKIP
8096 | OPTI_TYPE_NOT_ITERATED
8097 | OPTI_TYPE_NOT_SALTED;
8098 dgst_pos0 = 3;
8099 dgst_pos1 = 4;
8100 dgst_pos2 = 2;
8101 dgst_pos3 = 1;
8102 break;
8103
8104 case 400: hash_type = HASH_TYPE_MD5;
8105 salt_type = SALT_TYPE_EMBEDDED;
8106 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8107 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8108 kern_type = KERN_TYPE_PHPASS;
8109 dgst_size = DGST_SIZE_4_4;
8110 parse_func = phpass_parse_hash;
8111 sort_by_digest = sort_by_digest_4_4;
8112 opti_type = OPTI_TYPE_ZERO_BYTE
8113 | OPTI_TYPE_SLOW_HASH_SIMD;
8114 dgst_pos0 = 0;
8115 dgst_pos1 = 1;
8116 dgst_pos2 = 2;
8117 dgst_pos3 = 3;
8118 break;
8119
8120 case 500: hash_type = HASH_TYPE_MD5;
8121 salt_type = SALT_TYPE_EMBEDDED;
8122 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8123 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8124 kern_type = KERN_TYPE_MD5CRYPT;
8125 dgst_size = DGST_SIZE_4_4;
8126 parse_func = md5crypt_parse_hash;
8127 sort_by_digest = sort_by_digest_4_4;
8128 opti_type = OPTI_TYPE_ZERO_BYTE;
8129 dgst_pos0 = 0;
8130 dgst_pos1 = 1;
8131 dgst_pos2 = 2;
8132 dgst_pos3 = 3;
8133 break;
8134
8135 case 501: hash_type = HASH_TYPE_MD5;
8136 salt_type = SALT_TYPE_EMBEDDED;
8137 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8138 opts_type = OPTS_TYPE_PT_GENERATE_LE
8139 | OPTS_TYPE_HASH_COPY;
8140 kern_type = KERN_TYPE_MD5CRYPT;
8141 dgst_size = DGST_SIZE_4_4;
8142 parse_func = juniper_parse_hash;
8143 sort_by_digest = sort_by_digest_4_4;
8144 opti_type = OPTI_TYPE_ZERO_BYTE;
8145 dgst_pos0 = 0;
8146 dgst_pos1 = 1;
8147 dgst_pos2 = 2;
8148 dgst_pos3 = 3;
8149 break;
8150
8151 case 900: hash_type = HASH_TYPE_MD4;
8152 salt_type = SALT_TYPE_NONE;
8153 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8154 opts_type = OPTS_TYPE_PT_GENERATE_LE
8155 | OPTS_TYPE_PT_ADD80
8156 | OPTS_TYPE_PT_ADDBITS14;
8157 kern_type = KERN_TYPE_MD4;
8158 dgst_size = DGST_SIZE_4_4;
8159 parse_func = md4_parse_hash;
8160 sort_by_digest = sort_by_digest_4_4;
8161 opti_type = OPTI_TYPE_ZERO_BYTE
8162 | OPTI_TYPE_PRECOMPUTE_INIT
8163 | OPTI_TYPE_PRECOMPUTE_MERKLE
8164 | OPTI_TYPE_MEET_IN_MIDDLE
8165 | OPTI_TYPE_EARLY_SKIP
8166 | OPTI_TYPE_NOT_ITERATED
8167 | OPTI_TYPE_NOT_SALTED
8168 | OPTI_TYPE_RAW_HASH;
8169 dgst_pos0 = 0;
8170 dgst_pos1 = 3;
8171 dgst_pos2 = 2;
8172 dgst_pos3 = 1;
8173 break;
8174
8175 case 1000: hash_type = HASH_TYPE_MD4;
8176 salt_type = SALT_TYPE_NONE;
8177 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8178 opts_type = OPTS_TYPE_PT_GENERATE_LE
8179 | OPTS_TYPE_PT_ADD80
8180 | OPTS_TYPE_PT_ADDBITS14
8181 | OPTS_TYPE_PT_UNICODE;
8182 kern_type = KERN_TYPE_MD4_PWU;
8183 dgst_size = DGST_SIZE_4_4;
8184 parse_func = md4_parse_hash;
8185 sort_by_digest = sort_by_digest_4_4;
8186 opti_type = OPTI_TYPE_ZERO_BYTE
8187 | OPTI_TYPE_PRECOMPUTE_INIT
8188 | OPTI_TYPE_PRECOMPUTE_MERKLE
8189 | OPTI_TYPE_MEET_IN_MIDDLE
8190 | OPTI_TYPE_EARLY_SKIP
8191 | OPTI_TYPE_NOT_ITERATED
8192 | OPTI_TYPE_NOT_SALTED
8193 | OPTI_TYPE_RAW_HASH;
8194 dgst_pos0 = 0;
8195 dgst_pos1 = 3;
8196 dgst_pos2 = 2;
8197 dgst_pos3 = 1;
8198 break;
8199
8200 case 1100: hash_type = HASH_TYPE_MD4;
8201 salt_type = SALT_TYPE_INTERN;
8202 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8203 opts_type = OPTS_TYPE_PT_GENERATE_LE
8204 | OPTS_TYPE_PT_ADD80
8205 | OPTS_TYPE_PT_ADDBITS14
8206 | OPTS_TYPE_PT_UNICODE
8207 | OPTS_TYPE_ST_ADD80
8208 | OPTS_TYPE_ST_UNICODE
8209 | OPTS_TYPE_ST_LOWER;
8210 kern_type = KERN_TYPE_MD44_PWUSLT;
8211 dgst_size = DGST_SIZE_4_4;
8212 parse_func = dcc_parse_hash;
8213 sort_by_digest = sort_by_digest_4_4;
8214 opti_type = OPTI_TYPE_ZERO_BYTE
8215 | OPTI_TYPE_PRECOMPUTE_INIT
8216 | OPTI_TYPE_PRECOMPUTE_MERKLE
8217 | OPTI_TYPE_EARLY_SKIP
8218 | OPTI_TYPE_NOT_ITERATED;
8219 dgst_pos0 = 0;
8220 dgst_pos1 = 3;
8221 dgst_pos2 = 2;
8222 dgst_pos3 = 1;
8223 break;
8224
8225 case 1400: hash_type = HASH_TYPE_SHA256;
8226 salt_type = SALT_TYPE_NONE;
8227 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8228 opts_type = OPTS_TYPE_PT_GENERATE_BE
8229 | OPTS_TYPE_PT_ADD80
8230 | OPTS_TYPE_PT_ADDBITS15;
8231 kern_type = KERN_TYPE_SHA256;
8232 dgst_size = DGST_SIZE_4_8;
8233 parse_func = sha256_parse_hash;
8234 sort_by_digest = sort_by_digest_4_8;
8235 opti_type = OPTI_TYPE_ZERO_BYTE
8236 | OPTI_TYPE_PRECOMPUTE_INIT
8237 | OPTI_TYPE_PRECOMPUTE_MERKLE
8238 | OPTI_TYPE_EARLY_SKIP
8239 | OPTI_TYPE_NOT_ITERATED
8240 | OPTI_TYPE_NOT_SALTED
8241 | OPTI_TYPE_RAW_HASH;
8242 dgst_pos0 = 3;
8243 dgst_pos1 = 7;
8244 dgst_pos2 = 2;
8245 dgst_pos3 = 6;
8246 break;
8247
8248 case 1410: hash_type = HASH_TYPE_SHA256;
8249 salt_type = SALT_TYPE_INTERN;
8250 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8251 opts_type = OPTS_TYPE_PT_GENERATE_BE
8252 | OPTS_TYPE_ST_ADD80
8253 | OPTS_TYPE_ST_ADDBITS15;
8254 kern_type = KERN_TYPE_SHA256_PWSLT;
8255 dgst_size = DGST_SIZE_4_8;
8256 parse_func = sha256s_parse_hash;
8257 sort_by_digest = sort_by_digest_4_8;
8258 opti_type = OPTI_TYPE_ZERO_BYTE
8259 | OPTI_TYPE_PRECOMPUTE_INIT
8260 | OPTI_TYPE_PRECOMPUTE_MERKLE
8261 | OPTI_TYPE_EARLY_SKIP
8262 | OPTI_TYPE_NOT_ITERATED
8263 | OPTI_TYPE_APPENDED_SALT
8264 | OPTI_TYPE_RAW_HASH;
8265 dgst_pos0 = 3;
8266 dgst_pos1 = 7;
8267 dgst_pos2 = 2;
8268 dgst_pos3 = 6;
8269 break;
8270
8271 case 1420: hash_type = HASH_TYPE_SHA256;
8272 salt_type = SALT_TYPE_INTERN;
8273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8274 opts_type = OPTS_TYPE_PT_GENERATE_BE
8275 | OPTS_TYPE_PT_ADD80
8276 | OPTS_TYPE_PT_ADDBITS15;
8277 kern_type = KERN_TYPE_SHA256_SLTPW;
8278 dgst_size = DGST_SIZE_4_8;
8279 parse_func = sha256s_parse_hash;
8280 sort_by_digest = sort_by_digest_4_8;
8281 opti_type = OPTI_TYPE_ZERO_BYTE
8282 | OPTI_TYPE_PRECOMPUTE_INIT
8283 | OPTI_TYPE_PRECOMPUTE_MERKLE
8284 | OPTI_TYPE_EARLY_SKIP
8285 | OPTI_TYPE_NOT_ITERATED
8286 | OPTI_TYPE_PREPENDED_SALT
8287 | OPTI_TYPE_RAW_HASH;
8288 dgst_pos0 = 3;
8289 dgst_pos1 = 7;
8290 dgst_pos2 = 2;
8291 dgst_pos3 = 6;
8292 break;
8293
8294 case 1421: hash_type = HASH_TYPE_SHA256;
8295 salt_type = SALT_TYPE_EMBEDDED;
8296 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8297 opts_type = OPTS_TYPE_PT_GENERATE_BE
8298 | OPTS_TYPE_PT_ADD80
8299 | OPTS_TYPE_PT_ADDBITS15;
8300 kern_type = KERN_TYPE_SHA256_SLTPW;
8301 dgst_size = DGST_SIZE_4_8;
8302 parse_func = hmailserver_parse_hash;
8303 sort_by_digest = sort_by_digest_4_8;
8304 opti_type = OPTI_TYPE_ZERO_BYTE
8305 | OPTI_TYPE_PRECOMPUTE_INIT
8306 | OPTI_TYPE_PRECOMPUTE_MERKLE
8307 | OPTI_TYPE_EARLY_SKIP
8308 | OPTI_TYPE_NOT_ITERATED
8309 | OPTI_TYPE_PREPENDED_SALT
8310 | OPTI_TYPE_RAW_HASH;
8311 dgst_pos0 = 3;
8312 dgst_pos1 = 7;
8313 dgst_pos2 = 2;
8314 dgst_pos3 = 6;
8315 break;
8316
8317 case 1430: hash_type = HASH_TYPE_SHA256;
8318 salt_type = SALT_TYPE_INTERN;
8319 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8320 opts_type = OPTS_TYPE_PT_GENERATE_BE
8321 | OPTS_TYPE_PT_UNICODE
8322 | OPTS_TYPE_ST_ADD80
8323 | OPTS_TYPE_ST_ADDBITS15;
8324 kern_type = KERN_TYPE_SHA256_PWUSLT;
8325 dgst_size = DGST_SIZE_4_8;
8326 parse_func = sha256s_parse_hash;
8327 sort_by_digest = sort_by_digest_4_8;
8328 opti_type = OPTI_TYPE_ZERO_BYTE
8329 | OPTI_TYPE_PRECOMPUTE_INIT
8330 | OPTI_TYPE_PRECOMPUTE_MERKLE
8331 | OPTI_TYPE_EARLY_SKIP
8332 | OPTI_TYPE_NOT_ITERATED
8333 | OPTI_TYPE_APPENDED_SALT
8334 | OPTI_TYPE_RAW_HASH;
8335 dgst_pos0 = 3;
8336 dgst_pos1 = 7;
8337 dgst_pos2 = 2;
8338 dgst_pos3 = 6;
8339 break;
8340
8341 case 1440: hash_type = HASH_TYPE_SHA256;
8342 salt_type = SALT_TYPE_INTERN;
8343 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8344 opts_type = OPTS_TYPE_PT_GENERATE_BE
8345 | OPTS_TYPE_PT_ADD80
8346 | OPTS_TYPE_PT_ADDBITS15
8347 | OPTS_TYPE_PT_UNICODE;
8348 kern_type = KERN_TYPE_SHA256_SLTPWU;
8349 dgst_size = DGST_SIZE_4_8;
8350 parse_func = sha256s_parse_hash;
8351 sort_by_digest = sort_by_digest_4_8;
8352 opti_type = OPTI_TYPE_ZERO_BYTE
8353 | OPTI_TYPE_PRECOMPUTE_INIT
8354 | OPTI_TYPE_PRECOMPUTE_MERKLE
8355 | OPTI_TYPE_EARLY_SKIP
8356 | OPTI_TYPE_NOT_ITERATED
8357 | OPTI_TYPE_PREPENDED_SALT
8358 | OPTI_TYPE_RAW_HASH;
8359 dgst_pos0 = 3;
8360 dgst_pos1 = 7;
8361 dgst_pos2 = 2;
8362 dgst_pos3 = 6;
8363 break;
8364
8365 case 1441: hash_type = HASH_TYPE_SHA256;
8366 salt_type = SALT_TYPE_EMBEDDED;
8367 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8368 opts_type = OPTS_TYPE_PT_GENERATE_BE
8369 | OPTS_TYPE_PT_ADD80
8370 | OPTS_TYPE_PT_ADDBITS15
8371 | OPTS_TYPE_PT_UNICODE
8372 | OPTS_TYPE_ST_BASE64;
8373 kern_type = KERN_TYPE_SHA256_SLTPWU;
8374 dgst_size = DGST_SIZE_4_8;
8375 parse_func = episerver4_parse_hash;
8376 sort_by_digest = sort_by_digest_4_8;
8377 opti_type = OPTI_TYPE_ZERO_BYTE
8378 | OPTI_TYPE_PRECOMPUTE_INIT
8379 | OPTI_TYPE_PRECOMPUTE_MERKLE
8380 | OPTI_TYPE_EARLY_SKIP
8381 | OPTI_TYPE_NOT_ITERATED
8382 | OPTI_TYPE_PREPENDED_SALT
8383 | OPTI_TYPE_RAW_HASH;
8384 dgst_pos0 = 3;
8385 dgst_pos1 = 7;
8386 dgst_pos2 = 2;
8387 dgst_pos3 = 6;
8388 break;
8389
8390 case 1450: hash_type = HASH_TYPE_SHA256;
8391 salt_type = SALT_TYPE_INTERN;
8392 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8393 opts_type = OPTS_TYPE_PT_GENERATE_BE
8394 | OPTS_TYPE_ST_ADD80;
8395 kern_type = KERN_TYPE_HMACSHA256_PW;
8396 dgst_size = DGST_SIZE_4_8;
8397 parse_func = hmacsha256_parse_hash;
8398 sort_by_digest = sort_by_digest_4_8;
8399 opti_type = OPTI_TYPE_ZERO_BYTE
8400 | OPTI_TYPE_NOT_ITERATED;
8401 dgst_pos0 = 3;
8402 dgst_pos1 = 7;
8403 dgst_pos2 = 2;
8404 dgst_pos3 = 6;
8405 break;
8406
8407 case 1460: hash_type = HASH_TYPE_SHA256;
8408 salt_type = SALT_TYPE_INTERN;
8409 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8410 opts_type = OPTS_TYPE_PT_GENERATE_BE
8411 | OPTS_TYPE_PT_ADD80
8412 | OPTS_TYPE_PT_ADDBITS15;
8413 kern_type = KERN_TYPE_HMACSHA256_SLT;
8414 dgst_size = DGST_SIZE_4_8;
8415 parse_func = hmacsha256_parse_hash;
8416 sort_by_digest = sort_by_digest_4_8;
8417 opti_type = OPTI_TYPE_ZERO_BYTE
8418 | OPTI_TYPE_NOT_ITERATED;
8419 dgst_pos0 = 3;
8420 dgst_pos1 = 7;
8421 dgst_pos2 = 2;
8422 dgst_pos3 = 6;
8423 break;
8424
8425 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8426 salt_type = SALT_TYPE_EMBEDDED;
8427 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8428 opts_type = OPTS_TYPE_PT_GENERATE_LE
8429 | OPTS_TYPE_PT_BITSLICE;
8430 kern_type = KERN_TYPE_DESCRYPT;
8431 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8432 parse_func = descrypt_parse_hash;
8433 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8434 opti_type = OPTI_TYPE_ZERO_BYTE
8435 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8436 dgst_pos0 = 0;
8437 dgst_pos1 = 1;
8438 dgst_pos2 = 2;
8439 dgst_pos3 = 3;
8440 break;
8441
8442 case 1600: hash_type = HASH_TYPE_MD5;
8443 salt_type = SALT_TYPE_EMBEDDED;
8444 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8445 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8446 kern_type = KERN_TYPE_APR1CRYPT;
8447 dgst_size = DGST_SIZE_4_4;
8448 parse_func = md5apr1_parse_hash;
8449 sort_by_digest = sort_by_digest_4_4;
8450 opti_type = OPTI_TYPE_ZERO_BYTE;
8451 dgst_pos0 = 0;
8452 dgst_pos1 = 1;
8453 dgst_pos2 = 2;
8454 dgst_pos3 = 3;
8455 break;
8456
8457 case 1700: hash_type = HASH_TYPE_SHA512;
8458 salt_type = SALT_TYPE_NONE;
8459 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8460 opts_type = OPTS_TYPE_PT_GENERATE_BE
8461 | OPTS_TYPE_PT_ADD80
8462 | OPTS_TYPE_PT_ADDBITS15;
8463 kern_type = KERN_TYPE_SHA512;
8464 dgst_size = DGST_SIZE_8_8;
8465 parse_func = sha512_parse_hash;
8466 sort_by_digest = sort_by_digest_8_8;
8467 opti_type = OPTI_TYPE_ZERO_BYTE
8468 | OPTI_TYPE_PRECOMPUTE_INIT
8469 | OPTI_TYPE_PRECOMPUTE_MERKLE
8470 | OPTI_TYPE_EARLY_SKIP
8471 | OPTI_TYPE_NOT_ITERATED
8472 | OPTI_TYPE_NOT_SALTED
8473 | OPTI_TYPE_USES_BITS_64
8474 | OPTI_TYPE_RAW_HASH;
8475 dgst_pos0 = 14;
8476 dgst_pos1 = 15;
8477 dgst_pos2 = 6;
8478 dgst_pos3 = 7;
8479 break;
8480
8481 case 1710: hash_type = HASH_TYPE_SHA512;
8482 salt_type = SALT_TYPE_INTERN;
8483 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8484 opts_type = OPTS_TYPE_PT_GENERATE_BE
8485 | OPTS_TYPE_ST_ADD80
8486 | OPTS_TYPE_ST_ADDBITS15;
8487 kern_type = KERN_TYPE_SHA512_PWSLT;
8488 dgst_size = DGST_SIZE_8_8;
8489 parse_func = sha512s_parse_hash;
8490 sort_by_digest = sort_by_digest_8_8;
8491 opti_type = OPTI_TYPE_ZERO_BYTE
8492 | OPTI_TYPE_PRECOMPUTE_INIT
8493 | OPTI_TYPE_PRECOMPUTE_MERKLE
8494 | OPTI_TYPE_EARLY_SKIP
8495 | OPTI_TYPE_NOT_ITERATED
8496 | OPTI_TYPE_APPENDED_SALT
8497 | OPTI_TYPE_USES_BITS_64
8498 | OPTI_TYPE_RAW_HASH;
8499 dgst_pos0 = 14;
8500 dgst_pos1 = 15;
8501 dgst_pos2 = 6;
8502 dgst_pos3 = 7;
8503 break;
8504
8505 case 1711: hash_type = HASH_TYPE_SHA512;
8506 salt_type = SALT_TYPE_EMBEDDED;
8507 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8508 opts_type = OPTS_TYPE_PT_GENERATE_BE
8509 | OPTS_TYPE_ST_ADD80
8510 | OPTS_TYPE_ST_ADDBITS15;
8511 kern_type = KERN_TYPE_SHA512_PWSLT;
8512 dgst_size = DGST_SIZE_8_8;
8513 parse_func = sha512b64s_parse_hash;
8514 sort_by_digest = sort_by_digest_8_8;
8515 opti_type = OPTI_TYPE_ZERO_BYTE
8516 | OPTI_TYPE_PRECOMPUTE_INIT
8517 | OPTI_TYPE_PRECOMPUTE_MERKLE
8518 | OPTI_TYPE_EARLY_SKIP
8519 | OPTI_TYPE_NOT_ITERATED
8520 | OPTI_TYPE_APPENDED_SALT
8521 | OPTI_TYPE_USES_BITS_64
8522 | OPTI_TYPE_RAW_HASH;
8523 dgst_pos0 = 14;
8524 dgst_pos1 = 15;
8525 dgst_pos2 = 6;
8526 dgst_pos3 = 7;
8527 break;
8528
8529 case 1720: hash_type = HASH_TYPE_SHA512;
8530 salt_type = SALT_TYPE_INTERN;
8531 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8532 opts_type = OPTS_TYPE_PT_GENERATE_BE
8533 | OPTS_TYPE_PT_ADD80
8534 | OPTS_TYPE_PT_ADDBITS15;
8535 kern_type = KERN_TYPE_SHA512_SLTPW;
8536 dgst_size = DGST_SIZE_8_8;
8537 parse_func = sha512s_parse_hash;
8538 sort_by_digest = sort_by_digest_8_8;
8539 opti_type = OPTI_TYPE_ZERO_BYTE
8540 | OPTI_TYPE_PRECOMPUTE_INIT
8541 | OPTI_TYPE_PRECOMPUTE_MERKLE
8542 | OPTI_TYPE_EARLY_SKIP
8543 | OPTI_TYPE_NOT_ITERATED
8544 | OPTI_TYPE_PREPENDED_SALT
8545 | OPTI_TYPE_USES_BITS_64
8546 | OPTI_TYPE_RAW_HASH;
8547 dgst_pos0 = 14;
8548 dgst_pos1 = 15;
8549 dgst_pos2 = 6;
8550 dgst_pos3 = 7;
8551 break;
8552
8553 case 1722: hash_type = HASH_TYPE_SHA512;
8554 salt_type = SALT_TYPE_EMBEDDED;
8555 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8556 opts_type = OPTS_TYPE_PT_GENERATE_BE
8557 | OPTS_TYPE_PT_ADD80
8558 | OPTS_TYPE_PT_ADDBITS15
8559 | OPTS_TYPE_ST_HEX;
8560 kern_type = KERN_TYPE_SHA512_SLTPW;
8561 dgst_size = DGST_SIZE_8_8;
8562 parse_func = osx512_parse_hash;
8563 sort_by_digest = sort_by_digest_8_8;
8564 opti_type = OPTI_TYPE_ZERO_BYTE
8565 | OPTI_TYPE_PRECOMPUTE_INIT
8566 | OPTI_TYPE_PRECOMPUTE_MERKLE
8567 | OPTI_TYPE_EARLY_SKIP
8568 | OPTI_TYPE_NOT_ITERATED
8569 | OPTI_TYPE_PREPENDED_SALT
8570 | OPTI_TYPE_USES_BITS_64
8571 | OPTI_TYPE_RAW_HASH;
8572 dgst_pos0 = 14;
8573 dgst_pos1 = 15;
8574 dgst_pos2 = 6;
8575 dgst_pos3 = 7;
8576 break;
8577
8578 case 1730: hash_type = HASH_TYPE_SHA512;
8579 salt_type = SALT_TYPE_INTERN;
8580 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8581 opts_type = OPTS_TYPE_PT_GENERATE_BE
8582 | OPTS_TYPE_PT_UNICODE
8583 | OPTS_TYPE_ST_ADD80
8584 | OPTS_TYPE_ST_ADDBITS15;
8585 kern_type = KERN_TYPE_SHA512_PWSLTU;
8586 dgst_size = DGST_SIZE_8_8;
8587 parse_func = sha512s_parse_hash;
8588 sort_by_digest = sort_by_digest_8_8;
8589 opti_type = OPTI_TYPE_ZERO_BYTE
8590 | OPTI_TYPE_PRECOMPUTE_INIT
8591 | OPTI_TYPE_PRECOMPUTE_MERKLE
8592 | OPTI_TYPE_EARLY_SKIP
8593 | OPTI_TYPE_NOT_ITERATED
8594 | OPTI_TYPE_APPENDED_SALT
8595 | OPTI_TYPE_USES_BITS_64
8596 | OPTI_TYPE_RAW_HASH;
8597 dgst_pos0 = 14;
8598 dgst_pos1 = 15;
8599 dgst_pos2 = 6;
8600 dgst_pos3 = 7;
8601 break;
8602
8603 case 1731: hash_type = HASH_TYPE_SHA512;
8604 salt_type = SALT_TYPE_EMBEDDED;
8605 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8606 opts_type = OPTS_TYPE_PT_GENERATE_BE
8607 | OPTS_TYPE_PT_UNICODE
8608 | OPTS_TYPE_ST_ADD80
8609 | OPTS_TYPE_ST_ADDBITS15
8610 | OPTS_TYPE_ST_HEX;
8611 kern_type = KERN_TYPE_SHA512_PWSLTU;
8612 dgst_size = DGST_SIZE_8_8;
8613 parse_func = mssql2012_parse_hash;
8614 sort_by_digest = sort_by_digest_8_8;
8615 opti_type = OPTI_TYPE_ZERO_BYTE
8616 | OPTI_TYPE_PRECOMPUTE_INIT
8617 | OPTI_TYPE_PRECOMPUTE_MERKLE
8618 | OPTI_TYPE_EARLY_SKIP
8619 | OPTI_TYPE_NOT_ITERATED
8620 | OPTI_TYPE_APPENDED_SALT
8621 | OPTI_TYPE_USES_BITS_64
8622 | OPTI_TYPE_RAW_HASH;
8623 dgst_pos0 = 14;
8624 dgst_pos1 = 15;
8625 dgst_pos2 = 6;
8626 dgst_pos3 = 7;
8627 break;
8628
8629 case 1740: hash_type = HASH_TYPE_SHA512;
8630 salt_type = SALT_TYPE_INTERN;
8631 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8632 opts_type = OPTS_TYPE_PT_GENERATE_BE
8633 | OPTS_TYPE_PT_ADD80
8634 | OPTS_TYPE_PT_ADDBITS15
8635 | OPTS_TYPE_PT_UNICODE;
8636 kern_type = KERN_TYPE_SHA512_SLTPWU;
8637 dgst_size = DGST_SIZE_8_8;
8638 parse_func = sha512s_parse_hash;
8639 sort_by_digest = sort_by_digest_8_8;
8640 opti_type = OPTI_TYPE_ZERO_BYTE
8641 | OPTI_TYPE_PRECOMPUTE_INIT
8642 | OPTI_TYPE_PRECOMPUTE_MERKLE
8643 | OPTI_TYPE_EARLY_SKIP
8644 | OPTI_TYPE_NOT_ITERATED
8645 | OPTI_TYPE_PREPENDED_SALT
8646 | OPTI_TYPE_USES_BITS_64
8647 | OPTI_TYPE_RAW_HASH;
8648 dgst_pos0 = 14;
8649 dgst_pos1 = 15;
8650 dgst_pos2 = 6;
8651 dgst_pos3 = 7;
8652 break;
8653
8654 case 1750: hash_type = HASH_TYPE_SHA512;
8655 salt_type = SALT_TYPE_INTERN;
8656 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8657 opts_type = OPTS_TYPE_PT_GENERATE_BE
8658 | OPTS_TYPE_ST_ADD80;
8659 kern_type = KERN_TYPE_HMACSHA512_PW;
8660 dgst_size = DGST_SIZE_8_8;
8661 parse_func = hmacsha512_parse_hash;
8662 sort_by_digest = sort_by_digest_8_8;
8663 opti_type = OPTI_TYPE_ZERO_BYTE
8664 | OPTI_TYPE_USES_BITS_64
8665 | OPTI_TYPE_NOT_ITERATED;
8666 dgst_pos0 = 14;
8667 dgst_pos1 = 15;
8668 dgst_pos2 = 6;
8669 dgst_pos3 = 7;
8670 break;
8671
8672 case 1760: hash_type = HASH_TYPE_SHA512;
8673 salt_type = SALT_TYPE_INTERN;
8674 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8675 opts_type = OPTS_TYPE_PT_GENERATE_BE
8676 | OPTS_TYPE_PT_ADD80
8677 | OPTS_TYPE_PT_ADDBITS15;
8678 kern_type = KERN_TYPE_HMACSHA512_SLT;
8679 dgst_size = DGST_SIZE_8_8;
8680 parse_func = hmacsha512_parse_hash;
8681 sort_by_digest = sort_by_digest_8_8;
8682 opti_type = OPTI_TYPE_ZERO_BYTE
8683 | OPTI_TYPE_USES_BITS_64
8684 | OPTI_TYPE_NOT_ITERATED;
8685 dgst_pos0 = 14;
8686 dgst_pos1 = 15;
8687 dgst_pos2 = 6;
8688 dgst_pos3 = 7;
8689 break;
8690
8691 case 1800: hash_type = HASH_TYPE_SHA512;
8692 salt_type = SALT_TYPE_EMBEDDED;
8693 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8694 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8695 kern_type = KERN_TYPE_SHA512CRYPT;
8696 dgst_size = DGST_SIZE_8_8;
8697 parse_func = sha512crypt_parse_hash;
8698 sort_by_digest = sort_by_digest_8_8;
8699 opti_type = OPTI_TYPE_ZERO_BYTE
8700 | OPTI_TYPE_USES_BITS_64;
8701 dgst_pos0 = 0;
8702 dgst_pos1 = 1;
8703 dgst_pos2 = 2;
8704 dgst_pos3 = 3;
8705 break;
8706
8707 case 2000: hash_type = HASH_TYPE_STDOUT;
8708 salt_type = SALT_TYPE_NONE;
8709 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8710 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8711 kern_type = KERN_TYPE_STDOUT;
8712 dgst_size = DGST_SIZE_4_4;
8713 parse_func = NULL;
8714 sort_by_digest = NULL;
8715 opti_type = 0;
8716 dgst_pos0 = 0;
8717 dgst_pos1 = 0;
8718 dgst_pos2 = 0;
8719 dgst_pos3 = 0;
8720 break;
8721
8722 case 2100: hash_type = HASH_TYPE_DCC2;
8723 salt_type = SALT_TYPE_EMBEDDED;
8724 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8725 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8726 | OPTS_TYPE_ST_LOWER
8727 | OPTS_TYPE_ST_UNICODE;
8728 kern_type = KERN_TYPE_DCC2;
8729 dgst_size = DGST_SIZE_4_4;
8730 parse_func = dcc2_parse_hash;
8731 sort_by_digest = sort_by_digest_4_4;
8732 opti_type = OPTI_TYPE_ZERO_BYTE
8733 | OPTI_TYPE_SLOW_HASH_SIMD;
8734 dgst_pos0 = 0;
8735 dgst_pos1 = 1;
8736 dgst_pos2 = 2;
8737 dgst_pos3 = 3;
8738 break;
8739
8740 case 2400: hash_type = HASH_TYPE_MD5;
8741 salt_type = SALT_TYPE_NONE;
8742 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8743 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8744 kern_type = KERN_TYPE_MD5PIX;
8745 dgst_size = DGST_SIZE_4_4;
8746 parse_func = md5pix_parse_hash;
8747 sort_by_digest = sort_by_digest_4_4;
8748 opti_type = OPTI_TYPE_ZERO_BYTE
8749 | OPTI_TYPE_PRECOMPUTE_INIT
8750 | OPTI_TYPE_PRECOMPUTE_MERKLE
8751 | OPTI_TYPE_EARLY_SKIP
8752 | OPTI_TYPE_NOT_ITERATED
8753 | OPTI_TYPE_NOT_SALTED;
8754 dgst_pos0 = 0;
8755 dgst_pos1 = 3;
8756 dgst_pos2 = 2;
8757 dgst_pos3 = 1;
8758 break;
8759
8760 case 2410: hash_type = HASH_TYPE_MD5;
8761 salt_type = SALT_TYPE_INTERN;
8762 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8763 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8764 kern_type = KERN_TYPE_MD5ASA;
8765 dgst_size = DGST_SIZE_4_4;
8766 parse_func = md5asa_parse_hash;
8767 sort_by_digest = sort_by_digest_4_4;
8768 opti_type = OPTI_TYPE_ZERO_BYTE
8769 | OPTI_TYPE_PRECOMPUTE_INIT
8770 | OPTI_TYPE_PRECOMPUTE_MERKLE
8771 | OPTI_TYPE_EARLY_SKIP
8772 | OPTI_TYPE_NOT_ITERATED;
8773 dgst_pos0 = 0;
8774 dgst_pos1 = 3;
8775 dgst_pos2 = 2;
8776 dgst_pos3 = 1;
8777 break;
8778
8779 case 2500: hash_type = HASH_TYPE_WPA;
8780 salt_type = SALT_TYPE_EMBEDDED;
8781 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8782 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8783 kern_type = KERN_TYPE_WPA;
8784 dgst_size = DGST_SIZE_4_4;
8785 parse_func = wpa_parse_hash;
8786 sort_by_digest = sort_by_digest_4_4;
8787 opti_type = OPTI_TYPE_ZERO_BYTE
8788 | OPTI_TYPE_SLOW_HASH_SIMD;
8789 dgst_pos0 = 0;
8790 dgst_pos1 = 1;
8791 dgst_pos2 = 2;
8792 dgst_pos3 = 3;
8793 break;
8794
8795 case 2600: hash_type = HASH_TYPE_MD5;
8796 salt_type = SALT_TYPE_VIRTUAL;
8797 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8798 opts_type = OPTS_TYPE_PT_GENERATE_LE
8799 | OPTS_TYPE_PT_ADD80
8800 | OPTS_TYPE_PT_ADDBITS14
8801 | OPTS_TYPE_ST_ADD80;
8802 kern_type = KERN_TYPE_MD55_PWSLT1;
8803 dgst_size = DGST_SIZE_4_4;
8804 parse_func = md5md5_parse_hash;
8805 sort_by_digest = sort_by_digest_4_4;
8806 opti_type = OPTI_TYPE_ZERO_BYTE
8807 | OPTI_TYPE_PRECOMPUTE_INIT
8808 | OPTI_TYPE_PRECOMPUTE_MERKLE
8809 | OPTI_TYPE_EARLY_SKIP;
8810 dgst_pos0 = 0;
8811 dgst_pos1 = 3;
8812 dgst_pos2 = 2;
8813 dgst_pos3 = 1;
8814 break;
8815
8816 case 2611: hash_type = HASH_TYPE_MD5;
8817 salt_type = SALT_TYPE_INTERN;
8818 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8819 opts_type = OPTS_TYPE_PT_GENERATE_LE
8820 | OPTS_TYPE_PT_ADD80
8821 | OPTS_TYPE_PT_ADDBITS14
8822 | OPTS_TYPE_ST_ADD80;
8823 kern_type = KERN_TYPE_MD55_PWSLT1;
8824 dgst_size = DGST_SIZE_4_4;
8825 parse_func = vb3_parse_hash;
8826 sort_by_digest = sort_by_digest_4_4;
8827 opti_type = OPTI_TYPE_ZERO_BYTE
8828 | OPTI_TYPE_PRECOMPUTE_INIT
8829 | OPTI_TYPE_PRECOMPUTE_MERKLE
8830 | OPTI_TYPE_EARLY_SKIP;
8831 dgst_pos0 = 0;
8832 dgst_pos1 = 3;
8833 dgst_pos2 = 2;
8834 dgst_pos3 = 1;
8835 break;
8836
8837 case 2612: hash_type = HASH_TYPE_MD5;
8838 salt_type = SALT_TYPE_EMBEDDED;
8839 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8840 opts_type = OPTS_TYPE_PT_GENERATE_LE
8841 | OPTS_TYPE_PT_ADD80
8842 | OPTS_TYPE_PT_ADDBITS14
8843 | OPTS_TYPE_ST_ADD80
8844 | OPTS_TYPE_ST_HEX;
8845 kern_type = KERN_TYPE_MD55_PWSLT1;
8846 dgst_size = DGST_SIZE_4_4;
8847 parse_func = phps_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 2711: hash_type = HASH_TYPE_MD5;
8860 salt_type = SALT_TYPE_INTERN;
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 kern_type = KERN_TYPE_MD55_PWSLT2;
8867 dgst_size = DGST_SIZE_4_4;
8868 parse_func = vb30_parse_hash;
8869 sort_by_digest = sort_by_digest_4_4;
8870 opti_type = OPTI_TYPE_ZERO_BYTE
8871 | OPTI_TYPE_PRECOMPUTE_INIT
8872 | OPTI_TYPE_EARLY_SKIP;
8873 dgst_pos0 = 0;
8874 dgst_pos1 = 3;
8875 dgst_pos2 = 2;
8876 dgst_pos3 = 1;
8877 break;
8878
8879 case 2811: hash_type = HASH_TYPE_MD5;
8880 salt_type = SALT_TYPE_INTERN;
8881 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8882 opts_type = OPTS_TYPE_PT_GENERATE_LE
8883 | OPTS_TYPE_PT_ADD80
8884 | OPTS_TYPE_PT_ADDBITS14;
8885 kern_type = KERN_TYPE_MD55_SLTPW;
8886 dgst_size = DGST_SIZE_4_4;
8887 parse_func = ipb2_parse_hash;
8888 sort_by_digest = sort_by_digest_4_4;
8889 opti_type = OPTI_TYPE_ZERO_BYTE
8890 | OPTI_TYPE_PRECOMPUTE_INIT
8891 | OPTI_TYPE_EARLY_SKIP;
8892 dgst_pos0 = 0;
8893 dgst_pos1 = 3;
8894 dgst_pos2 = 2;
8895 dgst_pos3 = 1;
8896 break;
8897
8898 case 3000: hash_type = HASH_TYPE_LM;
8899 salt_type = SALT_TYPE_NONE;
8900 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8901 opts_type = OPTS_TYPE_PT_GENERATE_LE
8902 | OPTS_TYPE_PT_UPPER
8903 | OPTS_TYPE_PT_BITSLICE;
8904 kern_type = KERN_TYPE_LM;
8905 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8906 parse_func = lm_parse_hash;
8907 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8908 opti_type = OPTI_TYPE_ZERO_BYTE
8909 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8910 dgst_pos0 = 0;
8911 dgst_pos1 = 1;
8912 dgst_pos2 = 2;
8913 dgst_pos3 = 3;
8914 break;
8915
8916 case 3100: hash_type = HASH_TYPE_ORACLEH;
8917 salt_type = SALT_TYPE_INTERN;
8918 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8919 opts_type = OPTS_TYPE_PT_GENERATE_LE
8920 | OPTS_TYPE_PT_UPPER
8921 | OPTS_TYPE_ST_UPPER;
8922 kern_type = KERN_TYPE_ORACLEH;
8923 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8924 parse_func = oracleh_parse_hash;
8925 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8926 opti_type = OPTI_TYPE_ZERO_BYTE;
8927 dgst_pos0 = 0;
8928 dgst_pos1 = 1;
8929 dgst_pos2 = 2;
8930 dgst_pos3 = 3;
8931 break;
8932
8933 case 3200: hash_type = HASH_TYPE_BCRYPT;
8934 salt_type = SALT_TYPE_EMBEDDED;
8935 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8936 opts_type = OPTS_TYPE_PT_GENERATE_LE
8937 | OPTS_TYPE_ST_GENERATE_LE;
8938 kern_type = KERN_TYPE_BCRYPT;
8939 dgst_size = DGST_SIZE_4_6;
8940 parse_func = bcrypt_parse_hash;
8941 sort_by_digest = sort_by_digest_4_6;
8942 opti_type = OPTI_TYPE_ZERO_BYTE;
8943 dgst_pos0 = 0;
8944 dgst_pos1 = 1;
8945 dgst_pos2 = 2;
8946 dgst_pos3 = 3;
8947 break;
8948
8949 case 3710: hash_type = HASH_TYPE_MD5;
8950 salt_type = SALT_TYPE_INTERN;
8951 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8952 opts_type = OPTS_TYPE_PT_GENERATE_LE
8953 | OPTS_TYPE_PT_ADD80
8954 | OPTS_TYPE_PT_ADDBITS14;
8955 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8956 dgst_size = DGST_SIZE_4_4;
8957 parse_func = md5s_parse_hash;
8958 sort_by_digest = sort_by_digest_4_4;
8959 opti_type = OPTI_TYPE_ZERO_BYTE
8960 | OPTI_TYPE_PRECOMPUTE_INIT
8961 | OPTI_TYPE_PRECOMPUTE_MERKLE
8962 | OPTI_TYPE_EARLY_SKIP;
8963 dgst_pos0 = 0;
8964 dgst_pos1 = 3;
8965 dgst_pos2 = 2;
8966 dgst_pos3 = 1;
8967 break;
8968
8969 case 3711: hash_type = HASH_TYPE_MD5;
8970 salt_type = SALT_TYPE_EMBEDDED;
8971 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8972 opts_type = OPTS_TYPE_PT_GENERATE_LE
8973 | OPTS_TYPE_PT_ADD80
8974 | OPTS_TYPE_PT_ADDBITS14;
8975 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8976 dgst_size = DGST_SIZE_4_4;
8977 parse_func = mediawiki_b_parse_hash;
8978 sort_by_digest = sort_by_digest_4_4;
8979 opti_type = OPTI_TYPE_ZERO_BYTE
8980 | OPTI_TYPE_PRECOMPUTE_INIT
8981 | OPTI_TYPE_PRECOMPUTE_MERKLE
8982 | OPTI_TYPE_EARLY_SKIP;
8983 dgst_pos0 = 0;
8984 dgst_pos1 = 3;
8985 dgst_pos2 = 2;
8986 dgst_pos3 = 1;
8987 break;
8988
8989 case 3800: hash_type = HASH_TYPE_MD5;
8990 salt_type = SALT_TYPE_INTERN;
8991 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8992 opts_type = OPTS_TYPE_PT_GENERATE_LE
8993 | OPTS_TYPE_ST_ADDBITS14;
8994 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8995 dgst_size = DGST_SIZE_4_4;
8996 parse_func = md5s_parse_hash;
8997 sort_by_digest = sort_by_digest_4_4;
8998 opti_type = OPTI_TYPE_ZERO_BYTE
8999 | OPTI_TYPE_PRECOMPUTE_INIT
9000 | OPTI_TYPE_PRECOMPUTE_MERKLE
9001 | OPTI_TYPE_EARLY_SKIP
9002 | OPTI_TYPE_NOT_ITERATED
9003 | OPTI_TYPE_RAW_HASH;
9004 dgst_pos0 = 0;
9005 dgst_pos1 = 3;
9006 dgst_pos2 = 2;
9007 dgst_pos3 = 1;
9008 break;
9009
9010 case 4300: hash_type = HASH_TYPE_MD5;
9011 salt_type = SALT_TYPE_VIRTUAL;
9012 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9013 opts_type = OPTS_TYPE_PT_GENERATE_LE
9014 | OPTS_TYPE_PT_ADD80
9015 | OPTS_TYPE_PT_ADDBITS14
9016 | OPTS_TYPE_ST_ADD80;
9017 kern_type = KERN_TYPE_MD5U5_PWSLT1;
9018 dgst_size = DGST_SIZE_4_4;
9019 parse_func = md5md5_parse_hash;
9020 sort_by_digest = sort_by_digest_4_4;
9021 opti_type = OPTI_TYPE_ZERO_BYTE
9022 | OPTI_TYPE_PRECOMPUTE_INIT
9023 | OPTI_TYPE_PRECOMPUTE_MERKLE
9024 | OPTI_TYPE_EARLY_SKIP;
9025 dgst_pos0 = 0;
9026 dgst_pos1 = 3;
9027 dgst_pos2 = 2;
9028 dgst_pos3 = 1;
9029 break;
9030
9031
9032 case 4400: hash_type = HASH_TYPE_MD5;
9033 salt_type = SALT_TYPE_NONE;
9034 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9035 opts_type = OPTS_TYPE_PT_GENERATE_BE
9036 | OPTS_TYPE_PT_ADD80
9037 | OPTS_TYPE_PT_ADDBITS15;
9038 kern_type = KERN_TYPE_MD5_SHA1;
9039 dgst_size = DGST_SIZE_4_4;
9040 parse_func = md5_parse_hash;
9041 sort_by_digest = sort_by_digest_4_4;
9042 opti_type = OPTI_TYPE_ZERO_BYTE
9043 | OPTI_TYPE_PRECOMPUTE_INIT
9044 | OPTI_TYPE_PRECOMPUTE_MERKLE
9045 | OPTI_TYPE_EARLY_SKIP
9046 | OPTI_TYPE_NOT_ITERATED
9047 | OPTI_TYPE_NOT_SALTED
9048 | OPTI_TYPE_RAW_HASH;
9049 dgst_pos0 = 0;
9050 dgst_pos1 = 3;
9051 dgst_pos2 = 2;
9052 dgst_pos3 = 1;
9053 break;
9054
9055 case 4500: hash_type = HASH_TYPE_SHA1;
9056 salt_type = SALT_TYPE_NONE;
9057 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9058 opts_type = OPTS_TYPE_PT_GENERATE_BE
9059 | OPTS_TYPE_PT_ADD80
9060 | OPTS_TYPE_PT_ADDBITS15;
9061 kern_type = KERN_TYPE_SHA11;
9062 dgst_size = DGST_SIZE_4_5;
9063 parse_func = sha1_parse_hash;
9064 sort_by_digest = sort_by_digest_4_5;
9065 opti_type = OPTI_TYPE_ZERO_BYTE
9066 | OPTI_TYPE_PRECOMPUTE_INIT
9067 | OPTI_TYPE_PRECOMPUTE_MERKLE
9068 | OPTI_TYPE_EARLY_SKIP
9069 | OPTI_TYPE_NOT_SALTED;
9070 dgst_pos0 = 3;
9071 dgst_pos1 = 4;
9072 dgst_pos2 = 2;
9073 dgst_pos3 = 1;
9074 break;
9075
9076 case 4700: hash_type = HASH_TYPE_SHA1;
9077 salt_type = SALT_TYPE_NONE;
9078 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9079 opts_type = OPTS_TYPE_PT_GENERATE_LE
9080 | OPTS_TYPE_PT_ADD80
9081 | OPTS_TYPE_PT_ADDBITS14;
9082 kern_type = KERN_TYPE_SHA1_MD5;
9083 dgst_size = DGST_SIZE_4_5;
9084 parse_func = sha1_parse_hash;
9085 sort_by_digest = sort_by_digest_4_5;
9086 opti_type = OPTI_TYPE_ZERO_BYTE
9087 | OPTI_TYPE_PRECOMPUTE_INIT
9088 | OPTI_TYPE_PRECOMPUTE_MERKLE
9089 | OPTI_TYPE_EARLY_SKIP
9090 | OPTI_TYPE_NOT_ITERATED
9091 | OPTI_TYPE_NOT_SALTED
9092 | OPTI_TYPE_RAW_HASH;
9093 dgst_pos0 = 3;
9094 dgst_pos1 = 4;
9095 dgst_pos2 = 2;
9096 dgst_pos3 = 1;
9097 break;
9098
9099 case 4800: hash_type = HASH_TYPE_MD5;
9100 salt_type = SALT_TYPE_EMBEDDED;
9101 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9102 opts_type = OPTS_TYPE_PT_GENERATE_LE
9103 | OPTS_TYPE_PT_ADDBITS14;
9104 kern_type = KERN_TYPE_MD5_CHAP;
9105 dgst_size = DGST_SIZE_4_4;
9106 parse_func = chap_parse_hash;
9107 sort_by_digest = sort_by_digest_4_4;
9108 opti_type = OPTI_TYPE_ZERO_BYTE
9109 | OPTI_TYPE_PRECOMPUTE_INIT
9110 | OPTI_TYPE_PRECOMPUTE_MERKLE
9111 | OPTI_TYPE_MEET_IN_MIDDLE
9112 | OPTI_TYPE_EARLY_SKIP
9113 | OPTI_TYPE_NOT_ITERATED
9114 | OPTI_TYPE_RAW_HASH;
9115 dgst_pos0 = 0;
9116 dgst_pos1 = 3;
9117 dgst_pos2 = 2;
9118 dgst_pos3 = 1;
9119 break;
9120
9121 case 4900: hash_type = HASH_TYPE_SHA1;
9122 salt_type = SALT_TYPE_INTERN;
9123 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9124 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9125 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9126 dgst_size = DGST_SIZE_4_5;
9127 parse_func = sha1s_parse_hash;
9128 sort_by_digest = sort_by_digest_4_5;
9129 opti_type = OPTI_TYPE_ZERO_BYTE
9130 | OPTI_TYPE_PRECOMPUTE_INIT
9131 | OPTI_TYPE_PRECOMPUTE_MERKLE
9132 | OPTI_TYPE_EARLY_SKIP;
9133 dgst_pos0 = 3;
9134 dgst_pos1 = 4;
9135 dgst_pos2 = 2;
9136 dgst_pos3 = 1;
9137 break;
9138
9139 case 5000: hash_type = HASH_TYPE_KECCAK;
9140 salt_type = SALT_TYPE_EMBEDDED;
9141 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9142 opts_type = OPTS_TYPE_PT_GENERATE_LE
9143 | OPTS_TYPE_PT_ADD01;
9144 kern_type = KERN_TYPE_KECCAK;
9145 dgst_size = DGST_SIZE_8_25;
9146 parse_func = keccak_parse_hash;
9147 sort_by_digest = sort_by_digest_8_25;
9148 opti_type = OPTI_TYPE_ZERO_BYTE
9149 | OPTI_TYPE_USES_BITS_64
9150 | OPTI_TYPE_RAW_HASH;
9151 dgst_pos0 = 2;
9152 dgst_pos1 = 3;
9153 dgst_pos2 = 4;
9154 dgst_pos3 = 5;
9155 break;
9156
9157 case 5100: hash_type = HASH_TYPE_MD5H;
9158 salt_type = SALT_TYPE_NONE;
9159 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9160 opts_type = OPTS_TYPE_PT_GENERATE_LE
9161 | OPTS_TYPE_PT_ADD80
9162 | OPTS_TYPE_PT_ADDBITS14;
9163 kern_type = KERN_TYPE_MD5H;
9164 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9165 parse_func = md5half_parse_hash;
9166 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9167 opti_type = OPTI_TYPE_ZERO_BYTE
9168 | OPTI_TYPE_RAW_HASH;
9169 dgst_pos0 = 0;
9170 dgst_pos1 = 1;
9171 dgst_pos2 = 2;
9172 dgst_pos3 = 3;
9173 break;
9174
9175 case 5200: hash_type = HASH_TYPE_SHA256;
9176 salt_type = SALT_TYPE_EMBEDDED;
9177 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9178 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9179 kern_type = KERN_TYPE_PSAFE3;
9180 dgst_size = DGST_SIZE_4_8;
9181 parse_func = psafe3_parse_hash;
9182 sort_by_digest = sort_by_digest_4_8;
9183 opti_type = OPTI_TYPE_ZERO_BYTE;
9184 dgst_pos0 = 0;
9185 dgst_pos1 = 1;
9186 dgst_pos2 = 2;
9187 dgst_pos3 = 3;
9188 break;
9189
9190 case 5300: hash_type = HASH_TYPE_MD5;
9191 salt_type = SALT_TYPE_EMBEDDED;
9192 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9193 opts_type = OPTS_TYPE_PT_GENERATE_LE
9194 | OPTS_TYPE_ST_ADD80;
9195 kern_type = KERN_TYPE_IKEPSK_MD5;
9196 dgst_size = DGST_SIZE_4_4;
9197 parse_func = ikepsk_md5_parse_hash;
9198 sort_by_digest = sort_by_digest_4_4;
9199 opti_type = OPTI_TYPE_ZERO_BYTE;
9200 dgst_pos0 = 0;
9201 dgst_pos1 = 3;
9202 dgst_pos2 = 2;
9203 dgst_pos3 = 1;
9204 break;
9205
9206 case 5400: hash_type = HASH_TYPE_SHA1;
9207 salt_type = SALT_TYPE_EMBEDDED;
9208 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9209 opts_type = OPTS_TYPE_PT_GENERATE_BE
9210 | OPTS_TYPE_ST_ADD80;
9211 kern_type = KERN_TYPE_IKEPSK_SHA1;
9212 dgst_size = DGST_SIZE_4_5;
9213 parse_func = ikepsk_sha1_parse_hash;
9214 sort_by_digest = sort_by_digest_4_5;
9215 opti_type = OPTI_TYPE_ZERO_BYTE;
9216 dgst_pos0 = 3;
9217 dgst_pos1 = 4;
9218 dgst_pos2 = 2;
9219 dgst_pos3 = 1;
9220 break;
9221
9222 case 5500: hash_type = HASH_TYPE_NETNTLM;
9223 salt_type = SALT_TYPE_EMBEDDED;
9224 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9225 opts_type = OPTS_TYPE_PT_GENERATE_LE
9226 | OPTS_TYPE_PT_ADD80
9227 | OPTS_TYPE_PT_ADDBITS14
9228 | OPTS_TYPE_PT_UNICODE
9229 | OPTS_TYPE_ST_HEX;
9230 kern_type = KERN_TYPE_NETNTLMv1;
9231 dgst_size = DGST_SIZE_4_4;
9232 parse_func = netntlmv1_parse_hash;
9233 sort_by_digest = sort_by_digest_4_4;
9234 opti_type = OPTI_TYPE_ZERO_BYTE
9235 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9236 dgst_pos0 = 0;
9237 dgst_pos1 = 1;
9238 dgst_pos2 = 2;
9239 dgst_pos3 = 3;
9240 break;
9241
9242 case 5600: hash_type = HASH_TYPE_MD5;
9243 salt_type = SALT_TYPE_EMBEDDED;
9244 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9245 opts_type = OPTS_TYPE_PT_GENERATE_LE
9246 | OPTS_TYPE_PT_ADD80
9247 | OPTS_TYPE_PT_ADDBITS14
9248 | OPTS_TYPE_PT_UNICODE;
9249 kern_type = KERN_TYPE_NETNTLMv2;
9250 dgst_size = DGST_SIZE_4_4;
9251 parse_func = netntlmv2_parse_hash;
9252 sort_by_digest = sort_by_digest_4_4;
9253 opti_type = OPTI_TYPE_ZERO_BYTE;
9254 dgst_pos0 = 0;
9255 dgst_pos1 = 3;
9256 dgst_pos2 = 2;
9257 dgst_pos3 = 1;
9258 break;
9259
9260 case 5700: hash_type = HASH_TYPE_SHA256;
9261 salt_type = SALT_TYPE_NONE;
9262 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9263 opts_type = OPTS_TYPE_PT_GENERATE_BE
9264 | OPTS_TYPE_PT_ADD80
9265 | OPTS_TYPE_PT_ADDBITS15;
9266 kern_type = KERN_TYPE_SHA256;
9267 dgst_size = DGST_SIZE_4_8;
9268 parse_func = cisco4_parse_hash;
9269 sort_by_digest = sort_by_digest_4_8;
9270 opti_type = OPTI_TYPE_ZERO_BYTE
9271 | OPTI_TYPE_PRECOMPUTE_INIT
9272 | OPTI_TYPE_PRECOMPUTE_MERKLE
9273 | OPTI_TYPE_EARLY_SKIP
9274 | OPTI_TYPE_NOT_ITERATED
9275 | OPTI_TYPE_NOT_SALTED
9276 | OPTI_TYPE_RAW_HASH;
9277 dgst_pos0 = 3;
9278 dgst_pos1 = 7;
9279 dgst_pos2 = 2;
9280 dgst_pos3 = 6;
9281 break;
9282
9283 case 5800: hash_type = HASH_TYPE_SHA1;
9284 salt_type = SALT_TYPE_INTERN;
9285 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9286 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9287 | OPTS_TYPE_ST_ADD80;
9288 kern_type = KERN_TYPE_ANDROIDPIN;
9289 dgst_size = DGST_SIZE_4_5;
9290 parse_func = androidpin_parse_hash;
9291 sort_by_digest = sort_by_digest_4_5;
9292 opti_type = OPTI_TYPE_ZERO_BYTE;
9293 dgst_pos0 = 0;
9294 dgst_pos1 = 1;
9295 dgst_pos2 = 2;
9296 dgst_pos3 = 3;
9297 break;
9298
9299 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9300 salt_type = SALT_TYPE_NONE;
9301 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9302 opts_type = OPTS_TYPE_PT_GENERATE_LE
9303 | OPTS_TYPE_PT_ADD80;
9304 kern_type = KERN_TYPE_RIPEMD160;
9305 dgst_size = DGST_SIZE_4_5;
9306 parse_func = ripemd160_parse_hash;
9307 sort_by_digest = sort_by_digest_4_5;
9308 opti_type = OPTI_TYPE_ZERO_BYTE;
9309 dgst_pos0 = 0;
9310 dgst_pos1 = 1;
9311 dgst_pos2 = 2;
9312 dgst_pos3 = 3;
9313 break;
9314
9315 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9316 salt_type = SALT_TYPE_NONE;
9317 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9318 opts_type = OPTS_TYPE_PT_GENERATE_BE
9319 | OPTS_TYPE_PT_ADD80;
9320 kern_type = KERN_TYPE_WHIRLPOOL;
9321 dgst_size = DGST_SIZE_4_16;
9322 parse_func = whirlpool_parse_hash;
9323 sort_by_digest = sort_by_digest_4_16;
9324 opti_type = OPTI_TYPE_ZERO_BYTE;
9325 dgst_pos0 = 0;
9326 dgst_pos1 = 1;
9327 dgst_pos2 = 2;
9328 dgst_pos3 = 3;
9329 break;
9330
9331 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9332 salt_type = SALT_TYPE_EMBEDDED;
9333 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9334 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9335 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9336 dgst_size = DGST_SIZE_4_5;
9337 parse_func = truecrypt_parse_hash_2k;
9338 sort_by_digest = sort_by_digest_4_5;
9339 opti_type = OPTI_TYPE_ZERO_BYTE;
9340 dgst_pos0 = 0;
9341 dgst_pos1 = 1;
9342 dgst_pos2 = 2;
9343 dgst_pos3 = 3;
9344 break;
9345
9346 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9347 salt_type = SALT_TYPE_EMBEDDED;
9348 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9349 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9350 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9351 dgst_size = DGST_SIZE_4_5;
9352 parse_func = truecrypt_parse_hash_2k;
9353 sort_by_digest = sort_by_digest_4_5;
9354 opti_type = OPTI_TYPE_ZERO_BYTE;
9355 dgst_pos0 = 0;
9356 dgst_pos1 = 1;
9357 dgst_pos2 = 2;
9358 dgst_pos3 = 3;
9359 break;
9360
9361 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9362 salt_type = SALT_TYPE_EMBEDDED;
9363 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9364 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9365 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9366 dgst_size = DGST_SIZE_4_5;
9367 parse_func = truecrypt_parse_hash_2k;
9368 sort_by_digest = sort_by_digest_4_5;
9369 opti_type = OPTI_TYPE_ZERO_BYTE;
9370 dgst_pos0 = 0;
9371 dgst_pos1 = 1;
9372 dgst_pos2 = 2;
9373 dgst_pos3 = 3;
9374 break;
9375
9376 case 6221: hash_type = HASH_TYPE_SHA512;
9377 salt_type = SALT_TYPE_EMBEDDED;
9378 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9379 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9380 kern_type = KERN_TYPE_TCSHA512_XTS512;
9381 dgst_size = DGST_SIZE_8_8;
9382 parse_func = truecrypt_parse_hash_1k;
9383 sort_by_digest = sort_by_digest_8_8;
9384 opti_type = OPTI_TYPE_ZERO_BYTE
9385 | OPTI_TYPE_USES_BITS_64;
9386 dgst_pos0 = 0;
9387 dgst_pos1 = 1;
9388 dgst_pos2 = 2;
9389 dgst_pos3 = 3;
9390 break;
9391
9392 case 6222: hash_type = HASH_TYPE_SHA512;
9393 salt_type = SALT_TYPE_EMBEDDED;
9394 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9395 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9396 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9397 dgst_size = DGST_SIZE_8_8;
9398 parse_func = truecrypt_parse_hash_1k;
9399 sort_by_digest = sort_by_digest_8_8;
9400 opti_type = OPTI_TYPE_ZERO_BYTE
9401 | OPTI_TYPE_USES_BITS_64;
9402 dgst_pos0 = 0;
9403 dgst_pos1 = 1;
9404 dgst_pos2 = 2;
9405 dgst_pos3 = 3;
9406 break;
9407
9408 case 6223: hash_type = HASH_TYPE_SHA512;
9409 salt_type = SALT_TYPE_EMBEDDED;
9410 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9411 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9412 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9413 dgst_size = DGST_SIZE_8_8;
9414 parse_func = truecrypt_parse_hash_1k;
9415 sort_by_digest = sort_by_digest_8_8;
9416 opti_type = OPTI_TYPE_ZERO_BYTE
9417 | OPTI_TYPE_USES_BITS_64;
9418 dgst_pos0 = 0;
9419 dgst_pos1 = 1;
9420 dgst_pos2 = 2;
9421 dgst_pos3 = 3;
9422 break;
9423
9424 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9425 salt_type = SALT_TYPE_EMBEDDED;
9426 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9427 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9428 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9429 dgst_size = DGST_SIZE_4_8;
9430 parse_func = truecrypt_parse_hash_1k;
9431 sort_by_digest = sort_by_digest_4_8;
9432 opti_type = OPTI_TYPE_ZERO_BYTE;
9433 dgst_pos0 = 0;
9434 dgst_pos1 = 1;
9435 dgst_pos2 = 2;
9436 dgst_pos3 = 3;
9437 break;
9438
9439 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9440 salt_type = SALT_TYPE_EMBEDDED;
9441 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9442 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9443 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9444 dgst_size = DGST_SIZE_4_8;
9445 parse_func = truecrypt_parse_hash_1k;
9446 sort_by_digest = sort_by_digest_4_8;
9447 opti_type = OPTI_TYPE_ZERO_BYTE;
9448 dgst_pos0 = 0;
9449 dgst_pos1 = 1;
9450 dgst_pos2 = 2;
9451 dgst_pos3 = 3;
9452 break;
9453
9454 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9455 salt_type = SALT_TYPE_EMBEDDED;
9456 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9457 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9458 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9459 dgst_size = DGST_SIZE_4_8;
9460 parse_func = truecrypt_parse_hash_1k;
9461 sort_by_digest = sort_by_digest_4_8;
9462 opti_type = OPTI_TYPE_ZERO_BYTE;
9463 dgst_pos0 = 0;
9464 dgst_pos1 = 1;
9465 dgst_pos2 = 2;
9466 dgst_pos3 = 3;
9467 break;
9468
9469 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9470 salt_type = SALT_TYPE_EMBEDDED;
9471 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9472 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9473 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9474 dgst_size = DGST_SIZE_4_5;
9475 parse_func = truecrypt_parse_hash_1k;
9476 sort_by_digest = sort_by_digest_4_5;
9477 opti_type = OPTI_TYPE_ZERO_BYTE;
9478 dgst_pos0 = 0;
9479 dgst_pos1 = 1;
9480 dgst_pos2 = 2;
9481 dgst_pos3 = 3;
9482 break;
9483
9484 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9485 salt_type = SALT_TYPE_EMBEDDED;
9486 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9487 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9488 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9489 dgst_size = DGST_SIZE_4_5;
9490 parse_func = truecrypt_parse_hash_1k;
9491 sort_by_digest = sort_by_digest_4_5;
9492 opti_type = OPTI_TYPE_ZERO_BYTE;
9493 dgst_pos0 = 0;
9494 dgst_pos1 = 1;
9495 dgst_pos2 = 2;
9496 dgst_pos3 = 3;
9497 break;
9498
9499 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9500 salt_type = SALT_TYPE_EMBEDDED;
9501 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9502 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9503 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9504 dgst_size = DGST_SIZE_4_5;
9505 parse_func = truecrypt_parse_hash_1k;
9506 sort_by_digest = sort_by_digest_4_5;
9507 opti_type = OPTI_TYPE_ZERO_BYTE;
9508 dgst_pos0 = 0;
9509 dgst_pos1 = 1;
9510 dgst_pos2 = 2;
9511 dgst_pos3 = 3;
9512 break;
9513
9514 case 6300: hash_type = HASH_TYPE_MD5;
9515 salt_type = SALT_TYPE_EMBEDDED;
9516 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9517 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9518 kern_type = KERN_TYPE_MD5AIX;
9519 dgst_size = DGST_SIZE_4_4;
9520 parse_func = md5aix_parse_hash;
9521 sort_by_digest = sort_by_digest_4_4;
9522 opti_type = OPTI_TYPE_ZERO_BYTE;
9523 dgst_pos0 = 0;
9524 dgst_pos1 = 1;
9525 dgst_pos2 = 2;
9526 dgst_pos3 = 3;
9527 break;
9528
9529 case 6400: hash_type = HASH_TYPE_SHA256;
9530 salt_type = SALT_TYPE_EMBEDDED;
9531 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9532 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9533 kern_type = KERN_TYPE_SHA256AIX;
9534 dgst_size = DGST_SIZE_4_8;
9535 parse_func = sha256aix_parse_hash;
9536 sort_by_digest = sort_by_digest_4_8;
9537 opti_type = OPTI_TYPE_ZERO_BYTE;
9538 dgst_pos0 = 0;
9539 dgst_pos1 = 1;
9540 dgst_pos2 = 2;
9541 dgst_pos3 = 3;
9542 break;
9543
9544 case 6500: hash_type = HASH_TYPE_SHA512;
9545 salt_type = SALT_TYPE_EMBEDDED;
9546 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9547 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9548 kern_type = KERN_TYPE_SHA512AIX;
9549 dgst_size = DGST_SIZE_8_8;
9550 parse_func = sha512aix_parse_hash;
9551 sort_by_digest = sort_by_digest_8_8;
9552 opti_type = OPTI_TYPE_ZERO_BYTE
9553 | OPTI_TYPE_USES_BITS_64;
9554 dgst_pos0 = 0;
9555 dgst_pos1 = 1;
9556 dgst_pos2 = 2;
9557 dgst_pos3 = 3;
9558 break;
9559
9560 case 6600: hash_type = HASH_TYPE_AES;
9561 salt_type = SALT_TYPE_EMBEDDED;
9562 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9563 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9564 kern_type = KERN_TYPE_AGILEKEY;
9565 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9566 parse_func = agilekey_parse_hash;
9567 sort_by_digest = sort_by_digest_4_5;
9568 opti_type = OPTI_TYPE_ZERO_BYTE;
9569 dgst_pos0 = 0;
9570 dgst_pos1 = 1;
9571 dgst_pos2 = 2;
9572 dgst_pos3 = 3;
9573 break;
9574
9575 case 6700: hash_type = HASH_TYPE_SHA1;
9576 salt_type = SALT_TYPE_EMBEDDED;
9577 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9578 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9579 kern_type = KERN_TYPE_SHA1AIX;
9580 dgst_size = DGST_SIZE_4_5;
9581 parse_func = sha1aix_parse_hash;
9582 sort_by_digest = sort_by_digest_4_5;
9583 opti_type = OPTI_TYPE_ZERO_BYTE;
9584 dgst_pos0 = 0;
9585 dgst_pos1 = 1;
9586 dgst_pos2 = 2;
9587 dgst_pos3 = 3;
9588 break;
9589
9590 case 6800: hash_type = HASH_TYPE_AES;
9591 salt_type = SALT_TYPE_EMBEDDED;
9592 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9593 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9594 kern_type = KERN_TYPE_LASTPASS;
9595 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9596 parse_func = lastpass_parse_hash;
9597 sort_by_digest = sort_by_digest_4_8;
9598 opti_type = OPTI_TYPE_ZERO_BYTE;
9599 dgst_pos0 = 0;
9600 dgst_pos1 = 1;
9601 dgst_pos2 = 2;
9602 dgst_pos3 = 3;
9603 break;
9604
9605 case 6900: hash_type = HASH_TYPE_GOST;
9606 salt_type = SALT_TYPE_NONE;
9607 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9608 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9609 kern_type = KERN_TYPE_GOST;
9610 dgst_size = DGST_SIZE_4_8;
9611 parse_func = gost_parse_hash;
9612 sort_by_digest = sort_by_digest_4_8;
9613 opti_type = OPTI_TYPE_ZERO_BYTE;
9614 dgst_pos0 = 0;
9615 dgst_pos1 = 1;
9616 dgst_pos2 = 2;
9617 dgst_pos3 = 3;
9618 break;
9619
9620 case 7100: hash_type = HASH_TYPE_SHA512;
9621 salt_type = SALT_TYPE_EMBEDDED;
9622 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9623 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9624 kern_type = KERN_TYPE_PBKDF2_SHA512;
9625 dgst_size = DGST_SIZE_8_16;
9626 parse_func = sha512osx_parse_hash;
9627 sort_by_digest = sort_by_digest_8_16;
9628 opti_type = OPTI_TYPE_ZERO_BYTE
9629 | OPTI_TYPE_USES_BITS_64
9630 | OPTI_TYPE_SLOW_HASH_SIMD;
9631 dgst_pos0 = 0;
9632 dgst_pos1 = 1;
9633 dgst_pos2 = 2;
9634 dgst_pos3 = 3;
9635 break;
9636
9637 case 7200: hash_type = HASH_TYPE_SHA512;
9638 salt_type = SALT_TYPE_EMBEDDED;
9639 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9640 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9641 kern_type = KERN_TYPE_PBKDF2_SHA512;
9642 dgst_size = DGST_SIZE_8_16;
9643 parse_func = sha512grub_parse_hash;
9644 sort_by_digest = sort_by_digest_8_16;
9645 opti_type = OPTI_TYPE_ZERO_BYTE
9646 | OPTI_TYPE_USES_BITS_64
9647 | OPTI_TYPE_SLOW_HASH_SIMD;
9648 dgst_pos0 = 0;
9649 dgst_pos1 = 1;
9650 dgst_pos2 = 2;
9651 dgst_pos3 = 3;
9652 break;
9653
9654 case 7300: hash_type = HASH_TYPE_SHA1;
9655 salt_type = SALT_TYPE_EMBEDDED;
9656 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9657 opts_type = OPTS_TYPE_PT_GENERATE_BE
9658 | OPTS_TYPE_ST_ADD80
9659 | OPTS_TYPE_ST_ADDBITS15;
9660 kern_type = KERN_TYPE_RAKP;
9661 dgst_size = DGST_SIZE_4_5;
9662 parse_func = rakp_parse_hash;
9663 sort_by_digest = sort_by_digest_4_5;
9664 opti_type = OPTI_TYPE_ZERO_BYTE
9665 | OPTI_TYPE_NOT_ITERATED;
9666 dgst_pos0 = 3;
9667 dgst_pos1 = 4;
9668 dgst_pos2 = 2;
9669 dgst_pos3 = 1;
9670 break;
9671
9672 case 7400: hash_type = HASH_TYPE_SHA256;
9673 salt_type = SALT_TYPE_EMBEDDED;
9674 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9675 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9676 kern_type = KERN_TYPE_SHA256CRYPT;
9677 dgst_size = DGST_SIZE_4_8;
9678 parse_func = sha256crypt_parse_hash;
9679 sort_by_digest = sort_by_digest_4_8;
9680 opti_type = OPTI_TYPE_ZERO_BYTE;
9681 dgst_pos0 = 0;
9682 dgst_pos1 = 1;
9683 dgst_pos2 = 2;
9684 dgst_pos3 = 3;
9685 break;
9686
9687 case 7500: hash_type = HASH_TYPE_KRB5PA;
9688 salt_type = SALT_TYPE_EMBEDDED;
9689 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9690 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9691 kern_type = KERN_TYPE_KRB5PA;
9692 dgst_size = DGST_SIZE_4_4;
9693 parse_func = krb5pa_parse_hash;
9694 sort_by_digest = sort_by_digest_4_4;
9695 opti_type = OPTI_TYPE_ZERO_BYTE
9696 | OPTI_TYPE_NOT_ITERATED;
9697 dgst_pos0 = 0;
9698 dgst_pos1 = 1;
9699 dgst_pos2 = 2;
9700 dgst_pos3 = 3;
9701 break;
9702
9703 case 7600: hash_type = HASH_TYPE_SHA1;
9704 salt_type = SALT_TYPE_INTERN;
9705 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9706 opts_type = OPTS_TYPE_PT_GENERATE_BE
9707 | OPTS_TYPE_PT_ADD80
9708 | OPTS_TYPE_PT_ADDBITS15;
9709 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9710 dgst_size = DGST_SIZE_4_5;
9711 parse_func = redmine_parse_hash;
9712 sort_by_digest = sort_by_digest_4_5;
9713 opti_type = OPTI_TYPE_ZERO_BYTE
9714 | OPTI_TYPE_PRECOMPUTE_INIT
9715 | OPTI_TYPE_EARLY_SKIP
9716 | OPTI_TYPE_NOT_ITERATED
9717 | OPTI_TYPE_PREPENDED_SALT;
9718 dgst_pos0 = 3;
9719 dgst_pos1 = 4;
9720 dgst_pos2 = 2;
9721 dgst_pos3 = 1;
9722 break;
9723
9724 case 7700: hash_type = HASH_TYPE_SAPB;
9725 salt_type = SALT_TYPE_EMBEDDED;
9726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9727 opts_type = OPTS_TYPE_PT_GENERATE_LE
9728 | OPTS_TYPE_PT_UPPER
9729 | OPTS_TYPE_ST_UPPER;
9730 kern_type = KERN_TYPE_SAPB;
9731 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9732 parse_func = sapb_parse_hash;
9733 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9734 opti_type = OPTI_TYPE_ZERO_BYTE
9735 | OPTI_TYPE_PRECOMPUTE_INIT
9736 | OPTI_TYPE_NOT_ITERATED;
9737 dgst_pos0 = 0;
9738 dgst_pos1 = 1;
9739 dgst_pos2 = 2;
9740 dgst_pos3 = 3;
9741 break;
9742
9743 case 7800: hash_type = HASH_TYPE_SAPG;
9744 salt_type = SALT_TYPE_EMBEDDED;
9745 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9746 opts_type = OPTS_TYPE_PT_GENERATE_BE
9747 | OPTS_TYPE_ST_ADD80
9748 | OPTS_TYPE_ST_UPPER;
9749 kern_type = KERN_TYPE_SAPG;
9750 dgst_size = DGST_SIZE_4_5;
9751 parse_func = sapg_parse_hash;
9752 sort_by_digest = sort_by_digest_4_5;
9753 opti_type = OPTI_TYPE_ZERO_BYTE
9754 | OPTI_TYPE_PRECOMPUTE_INIT
9755 | OPTI_TYPE_NOT_ITERATED;
9756 dgst_pos0 = 3;
9757 dgst_pos1 = 4;
9758 dgst_pos2 = 2;
9759 dgst_pos3 = 1;
9760 break;
9761
9762 case 7900: hash_type = HASH_TYPE_SHA512;
9763 salt_type = SALT_TYPE_EMBEDDED;
9764 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9765 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9766 kern_type = KERN_TYPE_DRUPAL7;
9767 dgst_size = DGST_SIZE_8_8;
9768 parse_func = drupal7_parse_hash;
9769 sort_by_digest = sort_by_digest_8_8;
9770 opti_type = OPTI_TYPE_ZERO_BYTE
9771 | OPTI_TYPE_USES_BITS_64;
9772 dgst_pos0 = 0;
9773 dgst_pos1 = 1;
9774 dgst_pos2 = 2;
9775 dgst_pos3 = 3;
9776 break;
9777
9778 case 8000: hash_type = HASH_TYPE_SHA256;
9779 salt_type = SALT_TYPE_EMBEDDED;
9780 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9781 opts_type = OPTS_TYPE_PT_GENERATE_BE
9782 | OPTS_TYPE_PT_UNICODE
9783 | OPTS_TYPE_ST_ADD80
9784 | OPTS_TYPE_ST_HEX;
9785 kern_type = KERN_TYPE_SYBASEASE;
9786 dgst_size = DGST_SIZE_4_8;
9787 parse_func = sybasease_parse_hash;
9788 sort_by_digest = sort_by_digest_4_8;
9789 opti_type = OPTI_TYPE_ZERO_BYTE
9790 | OPTI_TYPE_PRECOMPUTE_INIT
9791 | OPTI_TYPE_EARLY_SKIP
9792 | OPTI_TYPE_NOT_ITERATED
9793 | OPTI_TYPE_RAW_HASH;
9794 dgst_pos0 = 3;
9795 dgst_pos1 = 7;
9796 dgst_pos2 = 2;
9797 dgst_pos3 = 6;
9798 break;
9799
9800 case 8100: hash_type = HASH_TYPE_SHA1;
9801 salt_type = SALT_TYPE_EMBEDDED;
9802 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9803 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9804 kern_type = KERN_TYPE_NETSCALER;
9805 dgst_size = DGST_SIZE_4_5;
9806 parse_func = netscaler_parse_hash;
9807 sort_by_digest = sort_by_digest_4_5;
9808 opti_type = OPTI_TYPE_ZERO_BYTE
9809 | OPTI_TYPE_PRECOMPUTE_INIT
9810 | OPTI_TYPE_PRECOMPUTE_MERKLE
9811 | OPTI_TYPE_EARLY_SKIP
9812 | OPTI_TYPE_NOT_ITERATED
9813 | OPTI_TYPE_PREPENDED_SALT
9814 | OPTI_TYPE_RAW_HASH;
9815 dgst_pos0 = 3;
9816 dgst_pos1 = 4;
9817 dgst_pos2 = 2;
9818 dgst_pos3 = 1;
9819 break;
9820
9821 case 8200: hash_type = HASH_TYPE_SHA256;
9822 salt_type = SALT_TYPE_EMBEDDED;
9823 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9824 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9825 kern_type = KERN_TYPE_CLOUDKEY;
9826 dgst_size = DGST_SIZE_4_8;
9827 parse_func = cloudkey_parse_hash;
9828 sort_by_digest = sort_by_digest_4_8;
9829 opti_type = OPTI_TYPE_ZERO_BYTE;
9830 dgst_pos0 = 0;
9831 dgst_pos1 = 1;
9832 dgst_pos2 = 2;
9833 dgst_pos3 = 3;
9834 break;
9835
9836 case 8300: hash_type = HASH_TYPE_SHA1;
9837 salt_type = SALT_TYPE_EMBEDDED;
9838 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9839 opts_type = OPTS_TYPE_PT_GENERATE_BE
9840 | OPTS_TYPE_ST_HEX
9841 | OPTS_TYPE_ST_ADD80;
9842 kern_type = KERN_TYPE_NSEC3;
9843 dgst_size = DGST_SIZE_4_5;
9844 parse_func = nsec3_parse_hash;
9845 sort_by_digest = sort_by_digest_4_5;
9846 opti_type = OPTI_TYPE_ZERO_BYTE;
9847 dgst_pos0 = 3;
9848 dgst_pos1 = 4;
9849 dgst_pos2 = 2;
9850 dgst_pos3 = 1;
9851 break;
9852
9853 case 8400: hash_type = HASH_TYPE_SHA1;
9854 salt_type = SALT_TYPE_INTERN;
9855 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9856 opts_type = OPTS_TYPE_PT_GENERATE_BE
9857 | OPTS_TYPE_PT_ADD80
9858 | OPTS_TYPE_PT_ADDBITS15;
9859 kern_type = KERN_TYPE_WBB3;
9860 dgst_size = DGST_SIZE_4_5;
9861 parse_func = wbb3_parse_hash;
9862 sort_by_digest = sort_by_digest_4_5;
9863 opti_type = OPTI_TYPE_ZERO_BYTE
9864 | OPTI_TYPE_PRECOMPUTE_INIT
9865 | OPTI_TYPE_NOT_ITERATED;
9866 dgst_pos0 = 3;
9867 dgst_pos1 = 4;
9868 dgst_pos2 = 2;
9869 dgst_pos3 = 1;
9870 break;
9871
9872 case 8500: hash_type = HASH_TYPE_DESRACF;
9873 salt_type = SALT_TYPE_EMBEDDED;
9874 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9875 opts_type = OPTS_TYPE_PT_GENERATE_LE
9876 | OPTS_TYPE_ST_UPPER;
9877 kern_type = KERN_TYPE_RACF;
9878 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9879 parse_func = racf_parse_hash;
9880 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9881 opti_type = OPTI_TYPE_ZERO_BYTE
9882 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9883 dgst_pos0 = 0;
9884 dgst_pos1 = 1;
9885 dgst_pos2 = 2;
9886 dgst_pos3 = 3;
9887 break;
9888
9889 case 8600: hash_type = HASH_TYPE_LOTUS5;
9890 salt_type = SALT_TYPE_NONE;
9891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9892 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9893 kern_type = KERN_TYPE_LOTUS5;
9894 dgst_size = DGST_SIZE_4_4;
9895 parse_func = lotus5_parse_hash;
9896 sort_by_digest = sort_by_digest_4_4;
9897 opti_type = OPTI_TYPE_EARLY_SKIP
9898 | OPTI_TYPE_NOT_ITERATED
9899 | OPTI_TYPE_NOT_SALTED
9900 | OPTI_TYPE_RAW_HASH;
9901 dgst_pos0 = 0;
9902 dgst_pos1 = 1;
9903 dgst_pos2 = 2;
9904 dgst_pos3 = 3;
9905 break;
9906
9907 case 8700: hash_type = HASH_TYPE_LOTUS6;
9908 salt_type = SALT_TYPE_EMBEDDED;
9909 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9910 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9911 kern_type = KERN_TYPE_LOTUS6;
9912 dgst_size = DGST_SIZE_4_4;
9913 parse_func = lotus6_parse_hash;
9914 sort_by_digest = sort_by_digest_4_4;
9915 opti_type = OPTI_TYPE_EARLY_SKIP
9916 | OPTI_TYPE_NOT_ITERATED
9917 | OPTI_TYPE_RAW_HASH;
9918 dgst_pos0 = 0;
9919 dgst_pos1 = 1;
9920 dgst_pos2 = 2;
9921 dgst_pos3 = 3;
9922 break;
9923
9924 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9925 salt_type = SALT_TYPE_EMBEDDED;
9926 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9927 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9928 kern_type = KERN_TYPE_ANDROIDFDE;
9929 dgst_size = DGST_SIZE_4_4;
9930 parse_func = androidfde_parse_hash;
9931 sort_by_digest = sort_by_digest_4_4;
9932 opti_type = OPTI_TYPE_ZERO_BYTE;
9933 dgst_pos0 = 0;
9934 dgst_pos1 = 1;
9935 dgst_pos2 = 2;
9936 dgst_pos3 = 3;
9937 break;
9938
9939 case 8900: hash_type = HASH_TYPE_SCRYPT;
9940 salt_type = SALT_TYPE_EMBEDDED;
9941 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9942 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9943 kern_type = KERN_TYPE_SCRYPT;
9944 dgst_size = DGST_SIZE_4_8;
9945 parse_func = scrypt_parse_hash;
9946 sort_by_digest = sort_by_digest_4_8;
9947 opti_type = OPTI_TYPE_ZERO_BYTE;
9948 dgst_pos0 = 0;
9949 dgst_pos1 = 1;
9950 dgst_pos2 = 2;
9951 dgst_pos3 = 3;
9952 break;
9953
9954 case 9000: hash_type = HASH_TYPE_SHA1;
9955 salt_type = SALT_TYPE_EMBEDDED;
9956 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9957 opts_type = OPTS_TYPE_PT_GENERATE_LE
9958 | OPTS_TYPE_ST_GENERATE_LE;
9959 kern_type = KERN_TYPE_PSAFE2;
9960 dgst_size = DGST_SIZE_4_5;
9961 parse_func = psafe2_parse_hash;
9962 sort_by_digest = sort_by_digest_4_5;
9963 opti_type = OPTI_TYPE_ZERO_BYTE;
9964 dgst_pos0 = 0;
9965 dgst_pos1 = 1;
9966 dgst_pos2 = 2;
9967 dgst_pos3 = 3;
9968 break;
9969
9970 case 9100: hash_type = HASH_TYPE_LOTUS8;
9971 salt_type = SALT_TYPE_EMBEDDED;
9972 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9973 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9974 kern_type = KERN_TYPE_LOTUS8;
9975 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9976 parse_func = lotus8_parse_hash;
9977 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9978 opti_type = OPTI_TYPE_ZERO_BYTE;
9979 dgst_pos0 = 0;
9980 dgst_pos1 = 1;
9981 dgst_pos2 = 2;
9982 dgst_pos3 = 3;
9983 break;
9984
9985 case 9200: hash_type = HASH_TYPE_SHA256;
9986 salt_type = SALT_TYPE_EMBEDDED;
9987 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9988 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9989 kern_type = KERN_TYPE_PBKDF2_SHA256;
9990 dgst_size = DGST_SIZE_4_32;
9991 parse_func = cisco8_parse_hash;
9992 sort_by_digest = sort_by_digest_4_32;
9993 opti_type = OPTI_TYPE_ZERO_BYTE
9994 | OPTI_TYPE_SLOW_HASH_SIMD;
9995 dgst_pos0 = 0;
9996 dgst_pos1 = 1;
9997 dgst_pos2 = 2;
9998 dgst_pos3 = 3;
9999 break;
10000
10001 case 9300: hash_type = HASH_TYPE_SCRYPT;
10002 salt_type = SALT_TYPE_EMBEDDED;
10003 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10004 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10005 kern_type = KERN_TYPE_SCRYPT;
10006 dgst_size = DGST_SIZE_4_8;
10007 parse_func = cisco9_parse_hash;
10008 sort_by_digest = sort_by_digest_4_8;
10009 opti_type = OPTI_TYPE_ZERO_BYTE;
10010 dgst_pos0 = 0;
10011 dgst_pos1 = 1;
10012 dgst_pos2 = 2;
10013 dgst_pos3 = 3;
10014 break;
10015
10016 case 9400: hash_type = HASH_TYPE_OFFICE2007;
10017 salt_type = SALT_TYPE_EMBEDDED;
10018 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10019 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10020 kern_type = KERN_TYPE_OFFICE2007;
10021 dgst_size = DGST_SIZE_4_4;
10022 parse_func = office2007_parse_hash;
10023 sort_by_digest = sort_by_digest_4_4;
10024 opti_type = OPTI_TYPE_ZERO_BYTE;
10025 dgst_pos0 = 0;
10026 dgst_pos1 = 1;
10027 dgst_pos2 = 2;
10028 dgst_pos3 = 3;
10029 break;
10030
10031 case 9500: hash_type = HASH_TYPE_OFFICE2010;
10032 salt_type = SALT_TYPE_EMBEDDED;
10033 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10034 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10035 kern_type = KERN_TYPE_OFFICE2010;
10036 dgst_size = DGST_SIZE_4_4;
10037 parse_func = office2010_parse_hash;
10038 sort_by_digest = sort_by_digest_4_4;
10039 opti_type = OPTI_TYPE_ZERO_BYTE;
10040 dgst_pos0 = 0;
10041 dgst_pos1 = 1;
10042 dgst_pos2 = 2;
10043 dgst_pos3 = 3;
10044 break;
10045
10046 case 9600: hash_type = HASH_TYPE_OFFICE2013;
10047 salt_type = SALT_TYPE_EMBEDDED;
10048 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10049 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10050 kern_type = KERN_TYPE_OFFICE2013;
10051 dgst_size = DGST_SIZE_4_4;
10052 parse_func = office2013_parse_hash;
10053 sort_by_digest = sort_by_digest_4_4;
10054 opti_type = OPTI_TYPE_ZERO_BYTE;
10055 dgst_pos0 = 0;
10056 dgst_pos1 = 1;
10057 dgst_pos2 = 2;
10058 dgst_pos3 = 3;
10059 break;
10060
10061 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
10062 salt_type = SALT_TYPE_EMBEDDED;
10063 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10064 opts_type = OPTS_TYPE_PT_GENERATE_LE
10065 | OPTS_TYPE_PT_ADD80
10066 | OPTS_TYPE_PT_UNICODE;
10067 kern_type = KERN_TYPE_OLDOFFICE01;
10068 dgst_size = DGST_SIZE_4_4;
10069 parse_func = oldoffice01_parse_hash;
10070 sort_by_digest = sort_by_digest_4_4;
10071 opti_type = OPTI_TYPE_ZERO_BYTE
10072 | OPTI_TYPE_PRECOMPUTE_INIT
10073 | OPTI_TYPE_NOT_ITERATED;
10074 dgst_pos0 = 0;
10075 dgst_pos1 = 1;
10076 dgst_pos2 = 2;
10077 dgst_pos3 = 3;
10078 break;
10079
10080 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
10081 salt_type = SALT_TYPE_EMBEDDED;
10082 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10083 opts_type = OPTS_TYPE_PT_GENERATE_LE
10084 | OPTS_TYPE_PT_ADD80;
10085 kern_type = KERN_TYPE_OLDOFFICE01CM1;
10086 dgst_size = DGST_SIZE_4_4;
10087 parse_func = oldoffice01cm1_parse_hash;
10088 sort_by_digest = sort_by_digest_4_4;
10089 opti_type = OPTI_TYPE_ZERO_BYTE
10090 | OPTI_TYPE_PRECOMPUTE_INIT
10091 | OPTI_TYPE_NOT_ITERATED;
10092 dgst_pos0 = 0;
10093 dgst_pos1 = 1;
10094 dgst_pos2 = 2;
10095 dgst_pos3 = 3;
10096 break;
10097
10098 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
10099 salt_type = SALT_TYPE_EMBEDDED;
10100 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10101 opts_type = OPTS_TYPE_PT_GENERATE_LE
10102 | OPTS_TYPE_PT_ADD80
10103 | OPTS_TYPE_PT_UNICODE
10104 | OPTS_TYPE_PT_NEVERCRACK;
10105 kern_type = KERN_TYPE_OLDOFFICE01CM2;
10106 dgst_size = DGST_SIZE_4_4;
10107 parse_func = oldoffice01cm2_parse_hash;
10108 sort_by_digest = sort_by_digest_4_4;
10109 opti_type = OPTI_TYPE_ZERO_BYTE
10110 | OPTI_TYPE_PRECOMPUTE_INIT
10111 | OPTI_TYPE_NOT_ITERATED;
10112 dgst_pos0 = 0;
10113 dgst_pos1 = 1;
10114 dgst_pos2 = 2;
10115 dgst_pos3 = 3;
10116 break;
10117
10118 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
10119 salt_type = SALT_TYPE_EMBEDDED;
10120 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10121 opts_type = OPTS_TYPE_PT_GENERATE_BE
10122 | OPTS_TYPE_PT_ADD80
10123 | OPTS_TYPE_PT_UNICODE;
10124 kern_type = KERN_TYPE_OLDOFFICE34;
10125 dgst_size = DGST_SIZE_4_4;
10126 parse_func = oldoffice34_parse_hash;
10127 sort_by_digest = sort_by_digest_4_4;
10128 opti_type = OPTI_TYPE_ZERO_BYTE
10129 | OPTI_TYPE_PRECOMPUTE_INIT
10130 | OPTI_TYPE_NOT_ITERATED;
10131 dgst_pos0 = 0;
10132 dgst_pos1 = 1;
10133 dgst_pos2 = 2;
10134 dgst_pos3 = 3;
10135 break;
10136
10137 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10138 salt_type = SALT_TYPE_EMBEDDED;
10139 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10140 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10141 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10142 dgst_size = DGST_SIZE_4_4;
10143 parse_func = oldoffice34cm1_parse_hash;
10144 sort_by_digest = sort_by_digest_4_4;
10145 opti_type = OPTI_TYPE_ZERO_BYTE
10146 | OPTI_TYPE_PRECOMPUTE_INIT
10147 | OPTI_TYPE_NOT_ITERATED;
10148 dgst_pos0 = 0;
10149 dgst_pos1 = 1;
10150 dgst_pos2 = 2;
10151 dgst_pos3 = 3;
10152 break;
10153
10154 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10155 salt_type = SALT_TYPE_EMBEDDED;
10156 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10157 opts_type = OPTS_TYPE_PT_GENERATE_BE
10158 | OPTS_TYPE_PT_ADD80
10159 | OPTS_TYPE_PT_UNICODE
10160 | OPTS_TYPE_PT_NEVERCRACK;
10161 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10162 dgst_size = DGST_SIZE_4_4;
10163 parse_func = oldoffice34cm2_parse_hash;
10164 sort_by_digest = sort_by_digest_4_4;
10165 opti_type = OPTI_TYPE_ZERO_BYTE
10166 | OPTI_TYPE_PRECOMPUTE_INIT
10167 | OPTI_TYPE_NOT_ITERATED;
10168 dgst_pos0 = 0;
10169 dgst_pos1 = 1;
10170 dgst_pos2 = 2;
10171 dgst_pos3 = 3;
10172 break;
10173
10174 case 9900: hash_type = HASH_TYPE_MD5;
10175 salt_type = SALT_TYPE_NONE;
10176 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10177 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10178 kern_type = KERN_TYPE_RADMIN2;
10179 dgst_size = DGST_SIZE_4_4;
10180 parse_func = radmin2_parse_hash;
10181 sort_by_digest = sort_by_digest_4_4;
10182 opti_type = OPTI_TYPE_ZERO_BYTE
10183 | OPTI_TYPE_PRECOMPUTE_INIT
10184 | OPTI_TYPE_EARLY_SKIP
10185 | OPTI_TYPE_NOT_ITERATED
10186 | OPTI_TYPE_NOT_SALTED;
10187 dgst_pos0 = 0;
10188 dgst_pos1 = 3;
10189 dgst_pos2 = 2;
10190 dgst_pos3 = 1;
10191 break;
10192
10193 case 10000: hash_type = HASH_TYPE_SHA256;
10194 salt_type = SALT_TYPE_EMBEDDED;
10195 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10196 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10197 kern_type = KERN_TYPE_PBKDF2_SHA256;
10198 dgst_size = DGST_SIZE_4_32;
10199 parse_func = djangopbkdf2_parse_hash;
10200 sort_by_digest = sort_by_digest_4_32;
10201 opti_type = OPTI_TYPE_ZERO_BYTE
10202 | OPTI_TYPE_SLOW_HASH_SIMD;
10203 dgst_pos0 = 0;
10204 dgst_pos1 = 1;
10205 dgst_pos2 = 2;
10206 dgst_pos3 = 3;
10207 break;
10208
10209 case 10100: hash_type = HASH_TYPE_SIPHASH;
10210 salt_type = SALT_TYPE_EMBEDDED;
10211 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10212 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10213 kern_type = KERN_TYPE_SIPHASH;
10214 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10215 parse_func = siphash_parse_hash;
10216 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10217 opti_type = OPTI_TYPE_ZERO_BYTE
10218 | OPTI_TYPE_NOT_ITERATED
10219 | OPTI_TYPE_RAW_HASH;
10220 dgst_pos0 = 0;
10221 dgst_pos1 = 1;
10222 dgst_pos2 = 2;
10223 dgst_pos3 = 3;
10224 break;
10225
10226 case 10200: hash_type = HASH_TYPE_MD5;
10227 salt_type = SALT_TYPE_EMBEDDED;
10228 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10229 opts_type = OPTS_TYPE_PT_GENERATE_LE
10230 | OPTS_TYPE_ST_ADD80
10231 | OPTS_TYPE_ST_ADDBITS14;
10232 kern_type = KERN_TYPE_HMACMD5_PW;
10233 dgst_size = DGST_SIZE_4_4;
10234 parse_func = crammd5_parse_hash;
10235 sort_by_digest = sort_by_digest_4_4;
10236 opti_type = OPTI_TYPE_ZERO_BYTE
10237 | OPTI_TYPE_NOT_ITERATED;
10238 dgst_pos0 = 0;
10239 dgst_pos1 = 3;
10240 dgst_pos2 = 2;
10241 dgst_pos3 = 1;
10242 break;
10243
10244 case 10300: hash_type = HASH_TYPE_SHA1;
10245 salt_type = SALT_TYPE_EMBEDDED;
10246 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10247 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10248 kern_type = KERN_TYPE_SAPH_SHA1;
10249 dgst_size = DGST_SIZE_4_5;
10250 parse_func = saph_sha1_parse_hash;
10251 sort_by_digest = sort_by_digest_4_5;
10252 opti_type = OPTI_TYPE_ZERO_BYTE;
10253 dgst_pos0 = 0;
10254 dgst_pos1 = 1;
10255 dgst_pos2 = 2;
10256 dgst_pos3 = 3;
10257 break;
10258
10259 case 10400: hash_type = HASH_TYPE_PDFU16;
10260 salt_type = SALT_TYPE_EMBEDDED;
10261 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10262 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10263 kern_type = KERN_TYPE_PDF11;
10264 dgst_size = DGST_SIZE_4_4;
10265 parse_func = pdf11_parse_hash;
10266 sort_by_digest = sort_by_digest_4_4;
10267 opti_type = OPTI_TYPE_ZERO_BYTE
10268 | OPTI_TYPE_NOT_ITERATED;
10269 dgst_pos0 = 0;
10270 dgst_pos1 = 1;
10271 dgst_pos2 = 2;
10272 dgst_pos3 = 3;
10273 break;
10274
10275 case 10410: hash_type = HASH_TYPE_PDFU16;
10276 salt_type = SALT_TYPE_EMBEDDED;
10277 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10278 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10279 kern_type = KERN_TYPE_PDF11CM1;
10280 dgst_size = DGST_SIZE_4_4;
10281 parse_func = pdf11cm1_parse_hash;
10282 sort_by_digest = sort_by_digest_4_4;
10283 opti_type = OPTI_TYPE_ZERO_BYTE
10284 | OPTI_TYPE_NOT_ITERATED;
10285 dgst_pos0 = 0;
10286 dgst_pos1 = 1;
10287 dgst_pos2 = 2;
10288 dgst_pos3 = 3;
10289 break;
10290
10291 case 10420: hash_type = HASH_TYPE_PDFU16;
10292 salt_type = SALT_TYPE_EMBEDDED;
10293 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10294 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10295 kern_type = KERN_TYPE_PDF11CM2;
10296 dgst_size = DGST_SIZE_4_4;
10297 parse_func = pdf11cm2_parse_hash;
10298 sort_by_digest = sort_by_digest_4_4;
10299 opti_type = OPTI_TYPE_ZERO_BYTE
10300 | OPTI_TYPE_NOT_ITERATED;
10301 dgst_pos0 = 0;
10302 dgst_pos1 = 1;
10303 dgst_pos2 = 2;
10304 dgst_pos3 = 3;
10305 break;
10306
10307 case 10500: hash_type = HASH_TYPE_PDFU16;
10308 salt_type = SALT_TYPE_EMBEDDED;
10309 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10310 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10311 kern_type = KERN_TYPE_PDF14;
10312 dgst_size = DGST_SIZE_4_4;
10313 parse_func = pdf14_parse_hash;
10314 sort_by_digest = sort_by_digest_4_4;
10315 opti_type = OPTI_TYPE_ZERO_BYTE
10316 | OPTI_TYPE_NOT_ITERATED;
10317 dgst_pos0 = 0;
10318 dgst_pos1 = 1;
10319 dgst_pos2 = 2;
10320 dgst_pos3 = 3;
10321 break;
10322
10323 case 10600: hash_type = HASH_TYPE_SHA256;
10324 salt_type = SALT_TYPE_EMBEDDED;
10325 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10326 opts_type = OPTS_TYPE_PT_GENERATE_BE
10327 | OPTS_TYPE_ST_ADD80
10328 | OPTS_TYPE_ST_ADDBITS15
10329 | OPTS_TYPE_HASH_COPY;
10330 kern_type = KERN_TYPE_SHA256_PWSLT;
10331 dgst_size = DGST_SIZE_4_8;
10332 parse_func = pdf17l3_parse_hash;
10333 sort_by_digest = sort_by_digest_4_8;
10334 opti_type = OPTI_TYPE_ZERO_BYTE
10335 | OPTI_TYPE_PRECOMPUTE_INIT
10336 | OPTI_TYPE_PRECOMPUTE_MERKLE
10337 | OPTI_TYPE_EARLY_SKIP
10338 | OPTI_TYPE_NOT_ITERATED
10339 | OPTI_TYPE_APPENDED_SALT
10340 | OPTI_TYPE_RAW_HASH;
10341 dgst_pos0 = 3;
10342 dgst_pos1 = 7;
10343 dgst_pos2 = 2;
10344 dgst_pos3 = 6;
10345 break;
10346
10347 case 10700: hash_type = HASH_TYPE_PDFU32;
10348 salt_type = SALT_TYPE_EMBEDDED;
10349 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10350 opts_type = OPTS_TYPE_PT_GENERATE_LE
10351 | OPTS_TYPE_HASH_COPY;
10352 kern_type = KERN_TYPE_PDF17L8;
10353 dgst_size = DGST_SIZE_4_8;
10354 parse_func = pdf17l8_parse_hash;
10355 sort_by_digest = sort_by_digest_4_8;
10356 opti_type = OPTI_TYPE_ZERO_BYTE
10357 | OPTI_TYPE_NOT_ITERATED;
10358 dgst_pos0 = 0;
10359 dgst_pos1 = 1;
10360 dgst_pos2 = 2;
10361 dgst_pos3 = 3;
10362 break;
10363
10364 case 10800: hash_type = HASH_TYPE_SHA384;
10365 salt_type = SALT_TYPE_NONE;
10366 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10367 opts_type = OPTS_TYPE_PT_GENERATE_BE
10368 | OPTS_TYPE_PT_ADD80
10369 | OPTS_TYPE_PT_ADDBITS15;
10370 kern_type = KERN_TYPE_SHA384;
10371 dgst_size = DGST_SIZE_8_8;
10372 parse_func = sha384_parse_hash;
10373 sort_by_digest = sort_by_digest_8_8;
10374 opti_type = OPTI_TYPE_ZERO_BYTE
10375 | OPTI_TYPE_PRECOMPUTE_INIT
10376 | OPTI_TYPE_PRECOMPUTE_MERKLE
10377 | OPTI_TYPE_EARLY_SKIP
10378 | OPTI_TYPE_NOT_ITERATED
10379 | OPTI_TYPE_NOT_SALTED
10380 | OPTI_TYPE_USES_BITS_64
10381 | OPTI_TYPE_RAW_HASH;
10382 dgst_pos0 = 6;
10383 dgst_pos1 = 7;
10384 dgst_pos2 = 4;
10385 dgst_pos3 = 5;
10386 break;
10387
10388 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10389 salt_type = SALT_TYPE_EMBEDDED;
10390 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10391 opts_type = OPTS_TYPE_PT_GENERATE_LE
10392 | OPTS_TYPE_ST_BASE64
10393 | OPTS_TYPE_HASH_COPY;
10394 kern_type = KERN_TYPE_PBKDF2_SHA256;
10395 dgst_size = DGST_SIZE_4_32;
10396 parse_func = pbkdf2_sha256_parse_hash;
10397 sort_by_digest = sort_by_digest_4_32;
10398 opti_type = OPTI_TYPE_ZERO_BYTE
10399 | OPTI_TYPE_SLOW_HASH_SIMD;
10400 dgst_pos0 = 0;
10401 dgst_pos1 = 1;
10402 dgst_pos2 = 2;
10403 dgst_pos3 = 3;
10404 break;
10405
10406 case 11000: hash_type = HASH_TYPE_MD5;
10407 salt_type = SALT_TYPE_INTERN;
10408 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10409 opts_type = OPTS_TYPE_PT_GENERATE_LE
10410 | OPTS_TYPE_PT_ADD80;
10411 kern_type = KERN_TYPE_PRESTASHOP;
10412 dgst_size = DGST_SIZE_4_4;
10413 parse_func = prestashop_parse_hash;
10414 sort_by_digest = sort_by_digest_4_4;
10415 opti_type = OPTI_TYPE_ZERO_BYTE
10416 | OPTI_TYPE_PRECOMPUTE_INIT
10417 | OPTI_TYPE_NOT_ITERATED
10418 | OPTI_TYPE_PREPENDED_SALT;
10419 dgst_pos0 = 0;
10420 dgst_pos1 = 3;
10421 dgst_pos2 = 2;
10422 dgst_pos3 = 1;
10423 break;
10424
10425 case 11100: hash_type = HASH_TYPE_MD5;
10426 salt_type = SALT_TYPE_EMBEDDED;
10427 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10428 opts_type = OPTS_TYPE_PT_GENERATE_LE
10429 | OPTS_TYPE_ST_ADD80;
10430 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10431 dgst_size = DGST_SIZE_4_4;
10432 parse_func = postgresql_auth_parse_hash;
10433 sort_by_digest = sort_by_digest_4_4;
10434 opti_type = OPTI_TYPE_ZERO_BYTE
10435 | OPTI_TYPE_PRECOMPUTE_INIT
10436 | OPTI_TYPE_PRECOMPUTE_MERKLE
10437 | OPTI_TYPE_EARLY_SKIP;
10438 dgst_pos0 = 0;
10439 dgst_pos1 = 3;
10440 dgst_pos2 = 2;
10441 dgst_pos3 = 1;
10442 break;
10443
10444 case 11200: hash_type = HASH_TYPE_SHA1;
10445 salt_type = SALT_TYPE_EMBEDDED;
10446 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10447 opts_type = OPTS_TYPE_PT_GENERATE_BE
10448 | OPTS_TYPE_PT_ADD80
10449 | OPTS_TYPE_ST_HEX;
10450 kern_type = KERN_TYPE_MYSQL_AUTH;
10451 dgst_size = DGST_SIZE_4_5;
10452 parse_func = mysql_auth_parse_hash;
10453 sort_by_digest = sort_by_digest_4_5;
10454 opti_type = OPTI_TYPE_ZERO_BYTE
10455 | OPTI_TYPE_EARLY_SKIP;
10456 dgst_pos0 = 3;
10457 dgst_pos1 = 4;
10458 dgst_pos2 = 2;
10459 dgst_pos3 = 1;
10460 break;
10461
10462 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10463 salt_type = SALT_TYPE_EMBEDDED;
10464 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10465 opts_type = OPTS_TYPE_PT_GENERATE_LE
10466 | OPTS_TYPE_ST_HEX
10467 | OPTS_TYPE_ST_ADD80;
10468 kern_type = KERN_TYPE_BITCOIN_WALLET;
10469 dgst_size = DGST_SIZE_4_4;
10470 parse_func = bitcoin_wallet_parse_hash;
10471 sort_by_digest = sort_by_digest_4_4;
10472 opti_type = OPTI_TYPE_ZERO_BYTE;
10473 dgst_pos0 = 0;
10474 dgst_pos1 = 1;
10475 dgst_pos2 = 2;
10476 dgst_pos3 = 3;
10477 break;
10478
10479 case 11400: hash_type = HASH_TYPE_MD5;
10480 salt_type = SALT_TYPE_EMBEDDED;
10481 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10482 opts_type = OPTS_TYPE_PT_GENERATE_LE
10483 | OPTS_TYPE_PT_ADD80
10484 | OPTS_TYPE_HASH_COPY;
10485 kern_type = KERN_TYPE_SIP_AUTH;
10486 dgst_size = DGST_SIZE_4_4;
10487 parse_func = sip_auth_parse_hash;
10488 sort_by_digest = sort_by_digest_4_4;
10489 opti_type = OPTI_TYPE_ZERO_BYTE;
10490 dgst_pos0 = 0;
10491 dgst_pos1 = 3;
10492 dgst_pos2 = 2;
10493 dgst_pos3 = 1;
10494 break;
10495
10496 case 11500: hash_type = HASH_TYPE_CRC32;
10497 salt_type = SALT_TYPE_INTERN;
10498 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10499 opts_type = OPTS_TYPE_PT_GENERATE_LE
10500 | OPTS_TYPE_ST_GENERATE_LE
10501 | OPTS_TYPE_ST_HEX;
10502 kern_type = KERN_TYPE_CRC32;
10503 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10504 parse_func = crc32_parse_hash;
10505 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10506 opti_type = OPTI_TYPE_ZERO_BYTE;
10507 dgst_pos0 = 0;
10508 dgst_pos1 = 1;
10509 dgst_pos2 = 2;
10510 dgst_pos3 = 3;
10511 break;
10512
10513 case 11600: hash_type = HASH_TYPE_AES;
10514 salt_type = SALT_TYPE_EMBEDDED;
10515 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10516 opts_type = OPTS_TYPE_PT_GENERATE_LE
10517 | OPTS_TYPE_PT_NEVERCRACK;
10518 kern_type = KERN_TYPE_SEVEN_ZIP;
10519 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10520 parse_func = seven_zip_parse_hash;
10521 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10522 opti_type = OPTI_TYPE_ZERO_BYTE;
10523 dgst_pos0 = 0;
10524 dgst_pos1 = 1;
10525 dgst_pos2 = 2;
10526 dgst_pos3 = 3;
10527 break;
10528
10529 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10530 salt_type = SALT_TYPE_NONE;
10531 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10532 opts_type = OPTS_TYPE_PT_GENERATE_LE
10533 | OPTS_TYPE_PT_ADD01;
10534 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10535 dgst_size = DGST_SIZE_4_8;
10536 parse_func = gost2012sbog_256_parse_hash;
10537 sort_by_digest = sort_by_digest_4_8;
10538 opti_type = OPTI_TYPE_ZERO_BYTE;
10539 dgst_pos0 = 0;
10540 dgst_pos1 = 1;
10541 dgst_pos2 = 2;
10542 dgst_pos3 = 3;
10543 break;
10544
10545 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10546 salt_type = SALT_TYPE_NONE;
10547 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10548 opts_type = OPTS_TYPE_PT_GENERATE_LE
10549 | OPTS_TYPE_PT_ADD01;
10550 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10551 dgst_size = DGST_SIZE_4_16;
10552 parse_func = gost2012sbog_512_parse_hash;
10553 sort_by_digest = sort_by_digest_4_16;
10554 opti_type = OPTI_TYPE_ZERO_BYTE;
10555 dgst_pos0 = 0;
10556 dgst_pos1 = 1;
10557 dgst_pos2 = 2;
10558 dgst_pos3 = 3;
10559 break;
10560
10561 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10562 salt_type = SALT_TYPE_EMBEDDED;
10563 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10564 opts_type = OPTS_TYPE_PT_GENERATE_LE
10565 | OPTS_TYPE_ST_BASE64
10566 | OPTS_TYPE_HASH_COPY;
10567 kern_type = KERN_TYPE_PBKDF2_MD5;
10568 dgst_size = DGST_SIZE_4_32;
10569 parse_func = pbkdf2_md5_parse_hash;
10570 sort_by_digest = sort_by_digest_4_32;
10571 opti_type = OPTI_TYPE_ZERO_BYTE
10572 | OPTI_TYPE_SLOW_HASH_SIMD;
10573 dgst_pos0 = 0;
10574 dgst_pos1 = 1;
10575 dgst_pos2 = 2;
10576 dgst_pos3 = 3;
10577 break;
10578
10579 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10580 salt_type = SALT_TYPE_EMBEDDED;
10581 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10582 opts_type = OPTS_TYPE_PT_GENERATE_LE
10583 | OPTS_TYPE_ST_BASE64
10584 | OPTS_TYPE_HASH_COPY;
10585 kern_type = KERN_TYPE_PBKDF2_SHA1;
10586 dgst_size = DGST_SIZE_4_32;
10587 parse_func = pbkdf2_sha1_parse_hash;
10588 sort_by_digest = sort_by_digest_4_32;
10589 opti_type = OPTI_TYPE_ZERO_BYTE
10590 | OPTI_TYPE_SLOW_HASH_SIMD;
10591 dgst_pos0 = 0;
10592 dgst_pos1 = 1;
10593 dgst_pos2 = 2;
10594 dgst_pos3 = 3;
10595 break;
10596
10597 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10598 salt_type = SALT_TYPE_EMBEDDED;
10599 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10600 opts_type = OPTS_TYPE_PT_GENERATE_LE
10601 | OPTS_TYPE_ST_BASE64
10602 | OPTS_TYPE_HASH_COPY;
10603 kern_type = KERN_TYPE_PBKDF2_SHA512;
10604 dgst_size = DGST_SIZE_8_16;
10605 parse_func = pbkdf2_sha512_parse_hash;
10606 sort_by_digest = sort_by_digest_8_16;
10607 opti_type = OPTI_TYPE_ZERO_BYTE
10608 | OPTI_TYPE_USES_BITS_64
10609 | OPTI_TYPE_SLOW_HASH_SIMD;
10610 dgst_pos0 = 0;
10611 dgst_pos1 = 1;
10612 dgst_pos2 = 2;
10613 dgst_pos3 = 3;
10614 break;
10615
10616 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10617 salt_type = SALT_TYPE_EMBEDDED;
10618 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10619 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10620 kern_type = KERN_TYPE_ECRYPTFS;
10621 dgst_size = DGST_SIZE_8_8;
10622 parse_func = ecryptfs_parse_hash;
10623 sort_by_digest = sort_by_digest_8_8;
10624 opti_type = OPTI_TYPE_ZERO_BYTE
10625 | OPTI_TYPE_USES_BITS_64;
10626 dgst_pos0 = 0;
10627 dgst_pos1 = 1;
10628 dgst_pos2 = 2;
10629 dgst_pos3 = 3;
10630 break;
10631
10632 case 12300: hash_type = HASH_TYPE_ORACLET;
10633 salt_type = SALT_TYPE_EMBEDDED;
10634 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10635 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10636 kern_type = KERN_TYPE_ORACLET;
10637 dgst_size = DGST_SIZE_8_16;
10638 parse_func = oraclet_parse_hash;
10639 sort_by_digest = sort_by_digest_8_16;
10640 opti_type = OPTI_TYPE_ZERO_BYTE
10641 | OPTI_TYPE_USES_BITS_64;
10642 dgst_pos0 = 0;
10643 dgst_pos1 = 1;
10644 dgst_pos2 = 2;
10645 dgst_pos3 = 3;
10646 break;
10647
10648 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10649 salt_type = SALT_TYPE_EMBEDDED;
10650 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10651 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10652 kern_type = KERN_TYPE_BSDICRYPT;
10653 dgst_size = DGST_SIZE_4_4;
10654 parse_func = bsdicrypt_parse_hash;
10655 sort_by_digest = sort_by_digest_4_4;
10656 opti_type = OPTI_TYPE_ZERO_BYTE
10657 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10658 dgst_pos0 = 0;
10659 dgst_pos1 = 1;
10660 dgst_pos2 = 2;
10661 dgst_pos3 = 3;
10662 break;
10663
10664 case 12500: hash_type = HASH_TYPE_RAR3HP;
10665 salt_type = SALT_TYPE_EMBEDDED;
10666 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10667 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10668 kern_type = KERN_TYPE_RAR3;
10669 dgst_size = DGST_SIZE_4_4;
10670 parse_func = rar3hp_parse_hash;
10671 sort_by_digest = sort_by_digest_4_4;
10672 opti_type = OPTI_TYPE_ZERO_BYTE;
10673 dgst_pos0 = 0;
10674 dgst_pos1 = 1;
10675 dgst_pos2 = 2;
10676 dgst_pos3 = 3;
10677 break;
10678
10679 case 12600: hash_type = HASH_TYPE_SHA256;
10680 salt_type = SALT_TYPE_INTERN;
10681 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10682 opts_type = OPTS_TYPE_PT_GENERATE_BE
10683 | OPTS_TYPE_PT_ADD80;
10684 kern_type = KERN_TYPE_CF10;
10685 dgst_size = DGST_SIZE_4_8;
10686 parse_func = cf10_parse_hash;
10687 sort_by_digest = sort_by_digest_4_8;
10688 opti_type = OPTI_TYPE_ZERO_BYTE
10689 | OPTI_TYPE_PRECOMPUTE_INIT
10690 | OPTI_TYPE_EARLY_SKIP
10691 | OPTI_TYPE_NOT_ITERATED;
10692 dgst_pos0 = 3;
10693 dgst_pos1 = 7;
10694 dgst_pos2 = 2;
10695 dgst_pos3 = 6;
10696 break;
10697
10698 case 12700: hash_type = HASH_TYPE_AES;
10699 salt_type = SALT_TYPE_EMBEDDED;
10700 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10701 opts_type = OPTS_TYPE_PT_GENERATE_LE
10702 | OPTS_TYPE_HASH_COPY;
10703 kern_type = KERN_TYPE_MYWALLET;
10704 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10705 parse_func = mywallet_parse_hash;
10706 sort_by_digest = sort_by_digest_4_5;
10707 opti_type = OPTI_TYPE_ZERO_BYTE;
10708 dgst_pos0 = 0;
10709 dgst_pos1 = 1;
10710 dgst_pos2 = 2;
10711 dgst_pos3 = 3;
10712 break;
10713
10714 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10715 salt_type = SALT_TYPE_EMBEDDED;
10716 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10717 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10718 kern_type = KERN_TYPE_MS_DRSR;
10719 dgst_size = DGST_SIZE_4_8;
10720 parse_func = ms_drsr_parse_hash;
10721 sort_by_digest = sort_by_digest_4_8;
10722 opti_type = OPTI_TYPE_ZERO_BYTE;
10723 dgst_pos0 = 0;
10724 dgst_pos1 = 1;
10725 dgst_pos2 = 2;
10726 dgst_pos3 = 3;
10727 break;
10728
10729 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10730 salt_type = SALT_TYPE_EMBEDDED;
10731 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10732 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10733 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10734 dgst_size = DGST_SIZE_4_8;
10735 parse_func = androidfde_samsung_parse_hash;
10736 sort_by_digest = sort_by_digest_4_8;
10737 opti_type = OPTI_TYPE_ZERO_BYTE;
10738 dgst_pos0 = 0;
10739 dgst_pos1 = 1;
10740 dgst_pos2 = 2;
10741 dgst_pos3 = 3;
10742 break;
10743
10744 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10745 salt_type = SALT_TYPE_EMBEDDED;
10746 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10747 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10748 kern_type = KERN_TYPE_RAR5;
10749 dgst_size = DGST_SIZE_4_4;
10750 parse_func = rar5_parse_hash;
10751 sort_by_digest = sort_by_digest_4_4;
10752 opti_type = OPTI_TYPE_ZERO_BYTE;
10753 dgst_pos0 = 0;
10754 dgst_pos1 = 1;
10755 dgst_pos2 = 2;
10756 dgst_pos3 = 3;
10757 break;
10758
10759 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10760 salt_type = SALT_TYPE_EMBEDDED;
10761 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10762 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10763 kern_type = KERN_TYPE_KRB5TGS;
10764 dgst_size = DGST_SIZE_4_4;
10765 parse_func = krb5tgs_parse_hash;
10766 sort_by_digest = sort_by_digest_4_4;
10767 opti_type = OPTI_TYPE_ZERO_BYTE
10768 | OPTI_TYPE_NOT_ITERATED;
10769 dgst_pos0 = 0;
10770 dgst_pos1 = 1;
10771 dgst_pos2 = 2;
10772 dgst_pos3 = 3;
10773 break;
10774
10775 case 13200: hash_type = HASH_TYPE_AES;
10776 salt_type = SALT_TYPE_EMBEDDED;
10777 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10778 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10779 kern_type = KERN_TYPE_AXCRYPT;
10780 dgst_size = DGST_SIZE_4_4;
10781 parse_func = axcrypt_parse_hash;
10782 sort_by_digest = sort_by_digest_4_4;
10783 opti_type = OPTI_TYPE_ZERO_BYTE;
10784 dgst_pos0 = 0;
10785 dgst_pos1 = 1;
10786 dgst_pos2 = 2;
10787 dgst_pos3 = 3;
10788 break;
10789
10790 case 13300: hash_type = HASH_TYPE_SHA1;
10791 salt_type = SALT_TYPE_NONE;
10792 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10793 opts_type = OPTS_TYPE_PT_GENERATE_BE
10794 | OPTS_TYPE_PT_ADD80
10795 | OPTS_TYPE_PT_ADDBITS15;
10796 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10797 dgst_size = DGST_SIZE_4_5;
10798 parse_func = sha1axcrypt_parse_hash;
10799 sort_by_digest = sort_by_digest_4_5;
10800 opti_type = OPTI_TYPE_ZERO_BYTE
10801 | OPTI_TYPE_PRECOMPUTE_INIT
10802 | OPTI_TYPE_EARLY_SKIP
10803 | OPTI_TYPE_NOT_ITERATED
10804 | OPTI_TYPE_NOT_SALTED;
10805 dgst_pos0 = 0;
10806 dgst_pos1 = 4;
10807 dgst_pos2 = 3;
10808 dgst_pos3 = 2;
10809 break;
10810
10811 case 13400: hash_type = HASH_TYPE_AES;
10812 salt_type = SALT_TYPE_EMBEDDED;
10813 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10814 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10815 kern_type = KERN_TYPE_KEEPASS;
10816 dgst_size = DGST_SIZE_4_4;
10817 parse_func = keepass_parse_hash;
10818 sort_by_digest = sort_by_digest_4_4;
10819 opti_type = OPTI_TYPE_ZERO_BYTE;
10820 dgst_pos0 = 0;
10821 dgst_pos1 = 1;
10822 dgst_pos2 = 2;
10823 dgst_pos3 = 3;
10824 break;
10825
10826 case 13500: hash_type = HASH_TYPE_SHA1;
10827 salt_type = SALT_TYPE_EMBEDDED;
10828 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10829 opts_type = OPTS_TYPE_PT_GENERATE_BE
10830 | OPTS_TYPE_PT_UNICODE
10831 | OPTS_TYPE_PT_ADD80;
10832 kern_type = KERN_TYPE_PSTOKEN;
10833 dgst_size = DGST_SIZE_4_5;
10834 parse_func = pstoken_parse_hash;
10835 sort_by_digest = sort_by_digest_4_5;
10836 opti_type = OPTI_TYPE_ZERO_BYTE
10837 | OPTI_TYPE_PRECOMPUTE_INIT
10838 | OPTI_TYPE_EARLY_SKIP
10839 | OPTI_TYPE_NOT_ITERATED
10840 | OPTI_TYPE_PREPENDED_SALT
10841 | OPTI_TYPE_RAW_HASH;
10842 dgst_pos0 = 3;
10843 dgst_pos1 = 4;
10844 dgst_pos2 = 2;
10845 dgst_pos3 = 1;
10846 break;
10847
10848 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10849 salt_type = SALT_TYPE_EMBEDDED;
10850 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10851 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10852 kern_type = KERN_TYPE_ZIP2;
10853 dgst_size = DGST_SIZE_4_4;
10854 parse_func = zip2_parse_hash;
10855 sort_by_digest = sort_by_digest_4_4;
10856 opti_type = OPTI_TYPE_ZERO_BYTE;
10857 dgst_pos0 = 0;
10858 dgst_pos1 = 1;
10859 dgst_pos2 = 2;
10860 dgst_pos3 = 3;
10861 break;
10862
10863 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10864 salt_type = SALT_TYPE_EMBEDDED;
10865 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10866 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10867 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10868 dgst_size = DGST_SIZE_4_5;
10869 parse_func = veracrypt_parse_hash_655331;
10870 sort_by_digest = sort_by_digest_4_5;
10871 opti_type = OPTI_TYPE_ZERO_BYTE;
10872 dgst_pos0 = 0;
10873 dgst_pos1 = 1;
10874 dgst_pos2 = 2;
10875 dgst_pos3 = 3;
10876 break;
10877
10878 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10879 salt_type = SALT_TYPE_EMBEDDED;
10880 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10881 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10882 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10883 dgst_size = DGST_SIZE_4_5;
10884 parse_func = veracrypt_parse_hash_655331;
10885 sort_by_digest = sort_by_digest_4_5;
10886 opti_type = OPTI_TYPE_ZERO_BYTE;
10887 dgst_pos0 = 0;
10888 dgst_pos1 = 1;
10889 dgst_pos2 = 2;
10890 dgst_pos3 = 3;
10891 break;
10892
10893 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10894 salt_type = SALT_TYPE_EMBEDDED;
10895 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10896 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10897 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10898 dgst_size = DGST_SIZE_4_5;
10899 parse_func = veracrypt_parse_hash_655331;
10900 sort_by_digest = sort_by_digest_4_5;
10901 opti_type = OPTI_TYPE_ZERO_BYTE;
10902 dgst_pos0 = 0;
10903 dgst_pos1 = 1;
10904 dgst_pos2 = 2;
10905 dgst_pos3 = 3;
10906 break;
10907
10908 case 13721: hash_type = HASH_TYPE_SHA512;
10909 salt_type = SALT_TYPE_EMBEDDED;
10910 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10911 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10912 kern_type = KERN_TYPE_TCSHA512_XTS512;
10913 dgst_size = DGST_SIZE_8_8;
10914 parse_func = veracrypt_parse_hash_500000;
10915 sort_by_digest = sort_by_digest_8_8;
10916 opti_type = OPTI_TYPE_ZERO_BYTE
10917 | OPTI_TYPE_USES_BITS_64;
10918 dgst_pos0 = 0;
10919 dgst_pos1 = 1;
10920 dgst_pos2 = 2;
10921 dgst_pos3 = 3;
10922 break;
10923
10924 case 13722: hash_type = HASH_TYPE_SHA512;
10925 salt_type = SALT_TYPE_EMBEDDED;
10926 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10927 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10928 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10929 dgst_size = DGST_SIZE_8_8;
10930 parse_func = veracrypt_parse_hash_500000;
10931 sort_by_digest = sort_by_digest_8_8;
10932 opti_type = OPTI_TYPE_ZERO_BYTE
10933 | OPTI_TYPE_USES_BITS_64;
10934 dgst_pos0 = 0;
10935 dgst_pos1 = 1;
10936 dgst_pos2 = 2;
10937 dgst_pos3 = 3;
10938 break;
10939
10940 case 13723: hash_type = HASH_TYPE_SHA512;
10941 salt_type = SALT_TYPE_EMBEDDED;
10942 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10943 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10944 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10945 dgst_size = DGST_SIZE_8_8;
10946 parse_func = veracrypt_parse_hash_500000;
10947 sort_by_digest = sort_by_digest_8_8;
10948 opti_type = OPTI_TYPE_ZERO_BYTE
10949 | OPTI_TYPE_USES_BITS_64;
10950 dgst_pos0 = 0;
10951 dgst_pos1 = 1;
10952 dgst_pos2 = 2;
10953 dgst_pos3 = 3;
10954 break;
10955
10956 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10957 salt_type = SALT_TYPE_EMBEDDED;
10958 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10959 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10960 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10961 dgst_size = DGST_SIZE_4_8;
10962 parse_func = veracrypt_parse_hash_500000;
10963 sort_by_digest = sort_by_digest_4_8;
10964 opti_type = OPTI_TYPE_ZERO_BYTE;
10965 dgst_pos0 = 0;
10966 dgst_pos1 = 1;
10967 dgst_pos2 = 2;
10968 dgst_pos3 = 3;
10969 break;
10970
10971 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10972 salt_type = SALT_TYPE_EMBEDDED;
10973 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10974 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10975 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10976 dgst_size = DGST_SIZE_4_8;
10977 parse_func = veracrypt_parse_hash_500000;
10978 sort_by_digest = sort_by_digest_4_8;
10979 opti_type = OPTI_TYPE_ZERO_BYTE;
10980 dgst_pos0 = 0;
10981 dgst_pos1 = 1;
10982 dgst_pos2 = 2;
10983 dgst_pos3 = 3;
10984 break;
10985
10986 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10987 salt_type = SALT_TYPE_EMBEDDED;
10988 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10989 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10990 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10991 dgst_size = DGST_SIZE_4_8;
10992 parse_func = veracrypt_parse_hash_500000;
10993 sort_by_digest = sort_by_digest_4_8;
10994 opti_type = OPTI_TYPE_ZERO_BYTE;
10995 dgst_pos0 = 0;
10996 dgst_pos1 = 1;
10997 dgst_pos2 = 2;
10998 dgst_pos3 = 3;
10999 break;
11000
11001 case 13741: hash_type = HASH_TYPE_RIPEMD160;
11002 salt_type = SALT_TYPE_EMBEDDED;
11003 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11004 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11005 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
11006 dgst_size = DGST_SIZE_4_5;
11007 parse_func = veracrypt_parse_hash_327661;
11008 sort_by_digest = sort_by_digest_4_5;
11009 opti_type = OPTI_TYPE_ZERO_BYTE;
11010 dgst_pos0 = 0;
11011 dgst_pos1 = 1;
11012 dgst_pos2 = 2;
11013 dgst_pos3 = 3;
11014 break;
11015
11016 case 13742: hash_type = HASH_TYPE_RIPEMD160;
11017 salt_type = SALT_TYPE_EMBEDDED;
11018 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11019 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11020 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
11021 dgst_size = DGST_SIZE_4_5;
11022 parse_func = veracrypt_parse_hash_327661;
11023 sort_by_digest = sort_by_digest_4_5;
11024 opti_type = OPTI_TYPE_ZERO_BYTE;
11025 dgst_pos0 = 0;
11026 dgst_pos1 = 1;
11027 dgst_pos2 = 2;
11028 dgst_pos3 = 3;
11029 break;
11030
11031 case 13743: hash_type = HASH_TYPE_RIPEMD160;
11032 salt_type = SALT_TYPE_EMBEDDED;
11033 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11034 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11035 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11036 dgst_size = DGST_SIZE_4_5;
11037 parse_func = veracrypt_parse_hash_327661;
11038 sort_by_digest = sort_by_digest_4_5;
11039 opti_type = OPTI_TYPE_ZERO_BYTE;
11040 dgst_pos0 = 0;
11041 dgst_pos1 = 1;
11042 dgst_pos2 = 2;
11043 dgst_pos3 = 3;
11044 break;
11045
11046 case 13751: hash_type = HASH_TYPE_SHA256;
11047 salt_type = SALT_TYPE_EMBEDDED;
11048 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11049 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11050 kern_type = KERN_TYPE_VCSHA256_XTS512;
11051 dgst_size = DGST_SIZE_4_8;
11052 parse_func = veracrypt_parse_hash_500000;
11053 sort_by_digest = sort_by_digest_4_8;
11054 opti_type = OPTI_TYPE_ZERO_BYTE;
11055 dgst_pos0 = 0;
11056 dgst_pos1 = 1;
11057 dgst_pos2 = 2;
11058 dgst_pos3 = 3;
11059 break;
11060
11061 case 13752: hash_type = HASH_TYPE_SHA256;
11062 salt_type = SALT_TYPE_EMBEDDED;
11063 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11064 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11065 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11066 dgst_size = DGST_SIZE_4_8;
11067 parse_func = veracrypt_parse_hash_500000;
11068 sort_by_digest = sort_by_digest_4_8;
11069 opti_type = OPTI_TYPE_ZERO_BYTE;
11070 dgst_pos0 = 0;
11071 dgst_pos1 = 1;
11072 dgst_pos2 = 2;
11073 dgst_pos3 = 3;
11074 break;
11075
11076 case 13753: hash_type = HASH_TYPE_SHA256;
11077 salt_type = SALT_TYPE_EMBEDDED;
11078 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11079 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11080 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11081 dgst_size = DGST_SIZE_4_8;
11082 parse_func = veracrypt_parse_hash_500000;
11083 sort_by_digest = sort_by_digest_4_8;
11084 opti_type = OPTI_TYPE_ZERO_BYTE;
11085 dgst_pos0 = 0;
11086 dgst_pos1 = 1;
11087 dgst_pos2 = 2;
11088 dgst_pos3 = 3;
11089 break;
11090
11091 case 13761: hash_type = HASH_TYPE_SHA256;
11092 salt_type = SALT_TYPE_EMBEDDED;
11093 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11094 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11095 kern_type = KERN_TYPE_VCSHA256_XTS512;
11096 dgst_size = DGST_SIZE_4_8;
11097 parse_func = veracrypt_parse_hash_200000;
11098 sort_by_digest = sort_by_digest_4_8;
11099 opti_type = OPTI_TYPE_ZERO_BYTE;
11100 dgst_pos0 = 0;
11101 dgst_pos1 = 1;
11102 dgst_pos2 = 2;
11103 dgst_pos3 = 3;
11104 break;
11105
11106 case 13762: hash_type = HASH_TYPE_SHA256;
11107 salt_type = SALT_TYPE_EMBEDDED;
11108 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11109 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11110 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11111 dgst_size = DGST_SIZE_4_8;
11112 parse_func = veracrypt_parse_hash_200000;
11113 sort_by_digest = sort_by_digest_4_8;
11114 opti_type = OPTI_TYPE_ZERO_BYTE;
11115 dgst_pos0 = 0;
11116 dgst_pos1 = 1;
11117 dgst_pos2 = 2;
11118 dgst_pos3 = 3;
11119 break;
11120
11121 case 13763: hash_type = HASH_TYPE_SHA256;
11122 salt_type = SALT_TYPE_EMBEDDED;
11123 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11124 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11125 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11126 dgst_size = DGST_SIZE_4_8;
11127 parse_func = veracrypt_parse_hash_200000;
11128 sort_by_digest = sort_by_digest_4_8;
11129 opti_type = OPTI_TYPE_ZERO_BYTE;
11130 dgst_pos0 = 0;
11131 dgst_pos1 = 1;
11132 dgst_pos2 = 2;
11133 dgst_pos3 = 3;
11134 break;
11135
11136 case 13800: hash_type = HASH_TYPE_SHA256;
11137 salt_type = SALT_TYPE_EMBEDDED;
11138 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11139 opts_type = OPTS_TYPE_PT_GENERATE_BE
11140 | OPTS_TYPE_PT_UNICODE;
11141 kern_type = KERN_TYPE_WIN8PHONE;
11142 dgst_size = DGST_SIZE_4_8;
11143 parse_func = win8phone_parse_hash;
11144 sort_by_digest = sort_by_digest_4_8;
11145 opti_type = OPTI_TYPE_ZERO_BYTE
11146 | OPTI_TYPE_PRECOMPUTE_INIT
11147 | OPTI_TYPE_EARLY_SKIP
11148 | OPTI_TYPE_NOT_ITERATED
11149 | OPTI_TYPE_RAW_HASH;
11150 dgst_pos0 = 3;
11151 dgst_pos1 = 7;
11152 dgst_pos2 = 2;
11153 dgst_pos3 = 6;
11154 break;
11155
11156 default: usage_mini_print (PROGNAME); return (-1);
11157 }
11158
11159 /**
11160 * parser
11161 */
11162
11163 data.parse_func = parse_func;
11164
11165 /**
11166 * misc stuff
11167 */
11168
11169 if (hex_salt)
11170 {
11171 if (salt_type == SALT_TYPE_INTERN)
11172 {
11173 opts_type |= OPTS_TYPE_ST_HEX;
11174 }
11175 else
11176 {
11177 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11178
11179 return (-1);
11180 }
11181 }
11182
11183 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11184 | (salt_type == SALT_TYPE_EXTERN)
11185 | (salt_type == SALT_TYPE_EMBEDDED)
11186 | (salt_type == SALT_TYPE_VIRTUAL));
11187
11188 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
11189
11190 data.hash_type = hash_type;
11191 data.attack_mode = attack_mode;
11192 data.attack_kern = attack_kern;
11193 data.attack_exec = attack_exec;
11194 data.kern_type = kern_type;
11195 data.opts_type = opts_type;
11196 data.dgst_size = dgst_size;
11197 data.salt_type = salt_type;
11198 data.isSalted = isSalted;
11199 data.sort_by_digest = sort_by_digest;
11200 data.dgst_pos0 = dgst_pos0;
11201 data.dgst_pos1 = dgst_pos1;
11202 data.dgst_pos2 = dgst_pos2;
11203 data.dgst_pos3 = dgst_pos3;
11204
11205 esalt_size = 0;
11206
11207 switch (hash_mode)
11208 {
11209 case 2500: esalt_size = sizeof (wpa_t); break;
11210 case 5300: esalt_size = sizeof (ikepsk_t); break;
11211 case 5400: esalt_size = sizeof (ikepsk_t); break;
11212 case 5500: esalt_size = sizeof (netntlm_t); break;
11213 case 5600: esalt_size = sizeof (netntlm_t); break;
11214 case 6211: esalt_size = sizeof (tc_t); break;
11215 case 6212: esalt_size = sizeof (tc_t); break;
11216 case 6213: esalt_size = sizeof (tc_t); break;
11217 case 6221: esalt_size = sizeof (tc_t); break;
11218 case 6222: esalt_size = sizeof (tc_t); break;
11219 case 6223: esalt_size = sizeof (tc_t); break;
11220 case 6231: esalt_size = sizeof (tc_t); break;
11221 case 6232: esalt_size = sizeof (tc_t); break;
11222 case 6233: esalt_size = sizeof (tc_t); break;
11223 case 6241: esalt_size = sizeof (tc_t); break;
11224 case 6242: esalt_size = sizeof (tc_t); break;
11225 case 6243: esalt_size = sizeof (tc_t); break;
11226 case 6600: esalt_size = sizeof (agilekey_t); break;
11227 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11228 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
11229 case 7300: esalt_size = sizeof (rakp_t); break;
11230 case 7500: esalt_size = sizeof (krb5pa_t); break;
11231 case 8200: esalt_size = sizeof (cloudkey_t); break;
11232 case 8800: esalt_size = sizeof (androidfde_t); break;
11233 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
11234 case 9400: esalt_size = sizeof (office2007_t); break;
11235 case 9500: esalt_size = sizeof (office2010_t); break;
11236 case 9600: esalt_size = sizeof (office2013_t); break;
11237 case 9700: esalt_size = sizeof (oldoffice01_t); break;
11238 case 9710: esalt_size = sizeof (oldoffice01_t); break;
11239 case 9720: esalt_size = sizeof (oldoffice01_t); break;
11240 case 9800: esalt_size = sizeof (oldoffice34_t); break;
11241 case 9810: esalt_size = sizeof (oldoffice34_t); break;
11242 case 9820: esalt_size = sizeof (oldoffice34_t); break;
11243 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
11244 case 10200: esalt_size = sizeof (cram_md5_t); break;
11245 case 10400: esalt_size = sizeof (pdf_t); break;
11246 case 10410: esalt_size = sizeof (pdf_t); break;
11247 case 10420: esalt_size = sizeof (pdf_t); break;
11248 case 10500: esalt_size = sizeof (pdf_t); break;
11249 case 10600: esalt_size = sizeof (pdf_t); break;
11250 case 10700: esalt_size = sizeof (pdf_t); break;
11251 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
11252 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
11253 case 11400: esalt_size = sizeof (sip_t); break;
11254 case 11600: esalt_size = sizeof (seven_zip_t); break;
11255 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
11256 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
11257 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11258 case 13000: esalt_size = sizeof (rar5_t); break;
11259 case 13100: esalt_size = sizeof (krb5tgs_t); break;
11260 case 13400: esalt_size = sizeof (keepass_t); break;
11261 case 13500: esalt_size = sizeof (pstoken_t); break;
11262 case 13600: esalt_size = sizeof (zip2_t); break;
11263 case 13711: esalt_size = sizeof (tc_t); break;
11264 case 13712: esalt_size = sizeof (tc_t); break;
11265 case 13713: esalt_size = sizeof (tc_t); break;
11266 case 13721: esalt_size = sizeof (tc_t); break;
11267 case 13722: esalt_size = sizeof (tc_t); break;
11268 case 13723: esalt_size = sizeof (tc_t); break;
11269 case 13731: esalt_size = sizeof (tc_t); break;
11270 case 13732: esalt_size = sizeof (tc_t); break;
11271 case 13733: esalt_size = sizeof (tc_t); break;
11272 case 13741: esalt_size = sizeof (tc_t); break;
11273 case 13742: esalt_size = sizeof (tc_t); break;
11274 case 13743: esalt_size = sizeof (tc_t); break;
11275 case 13751: esalt_size = sizeof (tc_t); break;
11276 case 13752: esalt_size = sizeof (tc_t); break;
11277 case 13753: esalt_size = sizeof (tc_t); break;
11278 case 13761: esalt_size = sizeof (tc_t); break;
11279 case 13762: esalt_size = sizeof (tc_t); break;
11280 case 13763: esalt_size = sizeof (tc_t); break;
11281 case 13800: esalt_size = sizeof (win8phone_t); break;
11282 }
11283
11284 data.esalt_size = esalt_size;
11285
11286 /**
11287 * choose dictionary parser
11288 */
11289
11290 if (hash_type == HASH_TYPE_LM)
11291 {
11292 get_next_word_func = get_next_word_lm;
11293 }
11294 else if (opts_type & OPTS_TYPE_PT_UPPER)
11295 {
11296 get_next_word_func = get_next_word_uc;
11297 }
11298 else
11299 {
11300 get_next_word_func = get_next_word_std;
11301 }
11302
11303 /**
11304 * dictstat
11305 */
11306
11307 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11308
11309 #ifdef _POSIX
11310 size_t dictstat_nmemb = 0;
11311 #endif
11312
11313 #ifdef _WIN
11314 uint dictstat_nmemb = 0;
11315 #endif
11316
11317 char dictstat[256] = { 0 };
11318
11319 FILE *dictstat_fp = NULL;
11320
11321 if (keyspace == 0)
11322 {
11323 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11324
11325 dictstat_fp = fopen (dictstat, "rb");
11326
11327 if (dictstat_fp)
11328 {
11329 #ifdef _POSIX
11330 struct stat tmpstat;
11331
11332 fstat (fileno (dictstat_fp), &tmpstat);
11333 #endif
11334
11335 #ifdef _WIN
11336 struct stat64 tmpstat;
11337
11338 _fstat64 (fileno (dictstat_fp), &tmpstat);
11339 #endif
11340
11341 if (tmpstat.st_mtime < COMPTIME)
11342 {
11343 /* with v0.15 the format changed so we have to ensure user is using a good version
11344 since there is no version-header in the dictstat file */
11345
11346 fclose (dictstat_fp);
11347
11348 unlink (dictstat);
11349 }
11350 else
11351 {
11352 while (!feof (dictstat_fp))
11353 {
11354 dictstat_t d;
11355
11356 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11357
11358 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11359
11360 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11361 {
11362 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11363
11364 return -1;
11365 }
11366 }
11367
11368 fclose (dictstat_fp);
11369 }
11370 }
11371 }
11372
11373 /**
11374 * potfile
11375 */
11376
11377 char potfile[256] = { 0 };
11378
11379 if (potfile_path == NULL)
11380 {
11381 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11382 }
11383 else
11384 {
11385 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11386 }
11387
11388 data.pot_fp = NULL;
11389
11390 FILE *out_fp = NULL;
11391 FILE *pot_fp = NULL;
11392
11393 if (show == 1 || left == 1)
11394 {
11395 pot_fp = fopen (potfile, "rb");
11396
11397 if (pot_fp == NULL)
11398 {
11399 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11400
11401 return (-1);
11402 }
11403
11404 if (outfile != NULL)
11405 {
11406 if ((out_fp = fopen (outfile, "ab")) == NULL)
11407 {
11408 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11409
11410 fclose (pot_fp);
11411
11412 return (-1);
11413 }
11414 }
11415 else
11416 {
11417 out_fp = stdout;
11418 }
11419 }
11420 else
11421 {
11422 if (potfile_disable == 0)
11423 {
11424 pot_fp = fopen (potfile, "ab");
11425
11426 if (pot_fp == NULL)
11427 {
11428 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11429
11430 return (-1);
11431 }
11432
11433 data.pot_fp = pot_fp;
11434 }
11435 }
11436
11437 pot_t *pot = NULL;
11438
11439 uint pot_cnt = 0;
11440 uint pot_avail = 0;
11441
11442 if (show == 1 || left == 1)
11443 {
11444 SUPPRESS_OUTPUT = 1;
11445
11446 pot_avail = count_lines (pot_fp);
11447
11448 rewind (pot_fp);
11449
11450 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11451
11452 uint pot_hashes_avail = 0;
11453
11454 uint line_num = 0;
11455
11456 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11457
11458 while (!feof (pot_fp))
11459 {
11460 line_num++;
11461
11462 int line_len = fgetl (pot_fp, line_buf);
11463
11464 if (line_len == 0) continue;
11465
11466 char *plain_buf = line_buf + line_len;
11467
11468 pot_t *pot_ptr = &pot[pot_cnt];
11469
11470 hash_t *hashes_buf = &pot_ptr->hash;
11471
11472 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11473 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11474
11475 if (pot_cnt == pot_hashes_avail)
11476 {
11477 uint pos = 0;
11478
11479 for (pos = 0; pos < INCR_POT; pos++)
11480 {
11481 if ((pot_cnt + pos) >= pot_avail) break;
11482
11483 pot_t *tmp_pot = &pot[pot_cnt + pos];
11484
11485 hash_t *tmp_hash = &tmp_pot->hash;
11486
11487 tmp_hash->digest = mymalloc (dgst_size);
11488
11489 if (isSalted)
11490 {
11491 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11492 }
11493
11494 if (esalt_size)
11495 {
11496 tmp_hash->esalt = mymalloc (esalt_size);
11497 }
11498
11499 pot_hashes_avail++;
11500 }
11501 }
11502
11503 int plain_len = 0;
11504
11505 int parser_status;
11506
11507 int iter = MAX_CUT_TRIES;
11508
11509 do
11510 {
11511 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11512 {
11513 if (line_buf[i] == ':')
11514 {
11515 line_len--;
11516
11517 break;
11518 }
11519 }
11520
11521 if (data.hash_mode != 2500)
11522 {
11523 parser_status = parse_func (line_buf, line_len, hashes_buf);
11524 }
11525 else
11526 {
11527 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11528
11529 if (line_len > max_salt_size)
11530 {
11531 parser_status = PARSER_GLOBAL_LENGTH;
11532 }
11533 else
11534 {
11535 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11536
11537 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11538
11539 hashes_buf->salt->salt_len = line_len;
11540
11541 parser_status = PARSER_OK;
11542 }
11543 }
11544
11545 // if NOT parsed without error, we add the ":" to the plain
11546
11547 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11548 {
11549 plain_len++;
11550 plain_buf--;
11551 }
11552
11553 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11554
11555 if (parser_status < PARSER_GLOBAL_ZERO)
11556 {
11557 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11558
11559 continue;
11560 }
11561
11562 if (plain_len >= 255) continue;
11563
11564 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11565
11566 pot_ptr->plain_len = plain_len;
11567
11568 pot_cnt++;
11569 }
11570
11571 myfree (line_buf);
11572
11573 fclose (pot_fp);
11574
11575 SUPPRESS_OUTPUT = 0;
11576
11577 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11578 }
11579
11580 /**
11581 * word len
11582 */
11583
11584 uint pw_min = PW_MIN;
11585 uint pw_max = PW_MAX;
11586
11587 switch (hash_mode)
11588 {
11589 case 125: if (pw_max > 32) pw_max = 32;
11590 break;
11591 case 400: if (pw_max > 40) pw_max = 40;
11592 break;
11593 case 500: if (pw_max > 16) pw_max = 16;
11594 break;
11595 case 1500: if (pw_max > 8) pw_max = 8;
11596 break;
11597 case 1600: if (pw_max > 16) pw_max = 16;
11598 break;
11599 case 1800: if (pw_max > 16) pw_max = 16;
11600 break;
11601 case 2100: if (pw_max > 16) pw_max = 16;
11602 break;
11603 case 2500: if (pw_min < 8) pw_min = 8;
11604 break;
11605 case 3000: if (pw_max > 7) pw_max = 7;
11606 break;
11607 case 5200: if (pw_max > 24) pw_max = 24;
11608 break;
11609 case 5800: if (pw_max > 16) pw_max = 16;
11610 break;
11611 case 6300: if (pw_max > 16) pw_max = 16;
11612 break;
11613 case 7400: if (pw_max > 16) pw_max = 16;
11614 break;
11615 case 7700: if (pw_max > 8) pw_max = 8;
11616 break;
11617 case 7900: if (pw_max > 48) pw_max = 48;
11618 break;
11619 case 8500: if (pw_max > 8) pw_max = 8;
11620 break;
11621 case 8600: if (pw_max > 16) pw_max = 16;
11622 break;
11623 case 9710: pw_min = 5;
11624 pw_max = 5;
11625 break;
11626 case 9810: pw_min = 5;
11627 pw_max = 5;
11628 break;
11629 case 10410: pw_min = 5;
11630 pw_max = 5;
11631 break;
11632 case 10300: if (pw_max < 3) pw_min = 3;
11633 if (pw_max > 40) pw_max = 40;
11634 break;
11635 case 10500: if (pw_max < 3) pw_min = 3;
11636 if (pw_max > 40) pw_max = 40;
11637 break;
11638 case 10700: if (pw_max > 16) pw_max = 16;
11639 break;
11640 case 11300: if (pw_max > 40) pw_max = 40;
11641 break;
11642 case 11600: if (pw_max > 32) pw_max = 32;
11643 break;
11644 case 12500: if (pw_max > 20) pw_max = 20;
11645 break;
11646 case 12800: if (pw_max > 24) pw_max = 24;
11647 break;
11648 }
11649
11650 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11651 {
11652 switch (attack_kern)
11653 {
11654 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11655 break;
11656 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11657 break;
11658 }
11659 }
11660
11661 /**
11662 * charsets : keep them together for more easy maintainnce
11663 */
11664
11665 cs_t mp_sys[6] = { { { 0 }, 0 } };
11666 cs_t mp_usr[4] = { { { 0 }, 0 } };
11667
11668 mp_setup_sys (mp_sys);
11669
11670 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11671 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11672 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11673 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11674
11675 /**
11676 * load hashes, part I: find input mode, count hashes
11677 */
11678
11679 uint hashlist_mode = 0;
11680 uint hashlist_format = HLFMT_HASHCAT;
11681
11682 uint hashes_avail = 0;
11683
11684 if ((benchmark == 0) && (stdout_flag == 0))
11685 {
11686 struct stat f;
11687
11688 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11689
11690 if ((hash_mode == 2500) ||
11691 (hash_mode == 5200) ||
11692 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11693 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11694 (hash_mode == 9000))
11695 {
11696 hashlist_mode = HL_MODE_ARG;
11697
11698 char *hashfile = myargv[optind];
11699
11700 data.hashfile = hashfile;
11701
11702 logfile_top_var_string ("target", hashfile);
11703 }
11704
11705 if (hashlist_mode == HL_MODE_ARG)
11706 {
11707 if (hash_mode == 2500)
11708 {
11709 struct stat st;
11710
11711 if (stat (data.hashfile, &st) == -1)
11712 {
11713 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11714
11715 return (-1);
11716 }
11717
11718 hashes_avail = st.st_size / sizeof (hccap_t);
11719 }
11720 else
11721 {
11722 hashes_avail = 1;
11723 }
11724 }
11725 else if (hashlist_mode == HL_MODE_FILE)
11726 {
11727 char *hashfile = myargv[optind];
11728
11729 data.hashfile = hashfile;
11730
11731 logfile_top_var_string ("target", hashfile);
11732
11733 FILE *fp = NULL;
11734
11735 if ((fp = fopen (hashfile, "rb")) == NULL)
11736 {
11737 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11738
11739 return (-1);
11740 }
11741
11742 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11743
11744 hashes_avail = count_lines (fp);
11745
11746 rewind (fp);
11747
11748 if (hashes_avail == 0)
11749 {
11750 log_error ("ERROR: hashfile is empty or corrupt");
11751
11752 fclose (fp);
11753
11754 return (-1);
11755 }
11756
11757 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11758
11759 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11760 {
11761 log_error ("ERROR: remove not supported in native hashfile-format mode");
11762
11763 fclose (fp);
11764
11765 return (-1);
11766 }
11767
11768 fclose (fp);
11769 }
11770 }
11771 else
11772 {
11773 hashlist_mode = HL_MODE_ARG;
11774
11775 hashes_avail = 1;
11776 }
11777
11778 if (hash_mode == 3000) hashes_avail *= 2;
11779
11780 data.hashlist_mode = hashlist_mode;
11781 data.hashlist_format = hashlist_format;
11782
11783 logfile_top_uint (hashlist_mode);
11784 logfile_top_uint (hashlist_format);
11785
11786 /**
11787 * load hashes, part II: allocate required memory, set pointers
11788 */
11789
11790 hash_t *hashes_buf = NULL;
11791 void *digests_buf = NULL;
11792 salt_t *salts_buf = NULL;
11793 void *esalts_buf = NULL;
11794
11795 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11796
11797 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11798
11799 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11800 {
11801 u32 hash_pos;
11802
11803 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11804 {
11805 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11806
11807 hashes_buf[hash_pos].hash_info = hash_info;
11808
11809 if (username && (remove || show || left))
11810 {
11811 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11812 }
11813
11814 if (benchmark)
11815 {
11816 hash_info->orighash = (char *) mymalloc (256);
11817 }
11818 }
11819 }
11820
11821 if (isSalted)
11822 {
11823 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11824
11825 if (esalt_size)
11826 {
11827 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11828 }
11829 }
11830 else
11831 {
11832 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11833 }
11834
11835 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11836 {
11837 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11838
11839 if (isSalted)
11840 {
11841 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11842
11843 if (esalt_size)
11844 {
11845 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11846 }
11847 }
11848 else
11849 {
11850 hashes_buf[hash_pos].salt = &salts_buf[0];
11851 }
11852 }
11853
11854 /**
11855 * load hashes, part III: parse hashes or generate them if benchmark
11856 */
11857
11858 uint hashes_cnt = 0;
11859
11860 if (benchmark == 0)
11861 {
11862 if (keyspace == 1)
11863 {
11864 // useless to read hash file for keyspace, cheat a little bit w/ optind
11865 }
11866 else if (stdout_flag == 1)
11867 {
11868 // useless to read hash file for stdout, cheat a little bit w/ optind
11869 }
11870 else if (hashes_avail == 0)
11871 {
11872 }
11873 else if (hashlist_mode == HL_MODE_ARG)
11874 {
11875 char *input_buf = myargv[optind];
11876
11877 uint input_len = strlen (input_buf);
11878
11879 logfile_top_var_string ("target", input_buf);
11880
11881 char *hash_buf = NULL;
11882 int hash_len = 0;
11883
11884 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11885
11886 bool hash_fmt_error = 0;
11887
11888 if (hash_len < 1) hash_fmt_error = 1;
11889 if (hash_buf == NULL) hash_fmt_error = 1;
11890
11891 if (hash_fmt_error)
11892 {
11893 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11894 }
11895 else
11896 {
11897 if (opts_type & OPTS_TYPE_HASH_COPY)
11898 {
11899 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11900
11901 hash_info_tmp->orighash = mystrdup (hash_buf);
11902 }
11903
11904 if (isSalted)
11905 {
11906 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11907 }
11908
11909 int parser_status = PARSER_OK;
11910
11911 if (hash_mode == 2500)
11912 {
11913 if (hash_len == 0)
11914 {
11915 log_error ("ERROR: hccap file not specified");
11916
11917 return (-1);
11918 }
11919
11920 hashlist_mode = HL_MODE_FILE;
11921
11922 data.hashlist_mode = hashlist_mode;
11923
11924 FILE *fp = fopen (hash_buf, "rb");
11925
11926 if (fp == NULL)
11927 {
11928 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11929
11930 return (-1);
11931 }
11932
11933 if (hashes_avail < 1)
11934 {
11935 log_error ("ERROR: hccap file is empty or corrupt");
11936
11937 fclose (fp);
11938
11939 return (-1);
11940 }
11941
11942 uint hccap_size = sizeof (hccap_t);
11943
11944 char *in = (char *) mymalloc (hccap_size);
11945
11946 while (!feof (fp))
11947 {
11948 int n = fread (in, hccap_size, 1, fp);
11949
11950 if (n != 1)
11951 {
11952 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11953
11954 break;
11955 }
11956
11957 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11958
11959 if (parser_status != PARSER_OK)
11960 {
11961 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11962
11963 continue;
11964 }
11965
11966 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11967
11968 if ((show == 1) || (left == 1))
11969 {
11970 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11971
11972 char *salt_ptr = (char *) tmp_salt->salt_buf;
11973
11974 int cur_pos = tmp_salt->salt_len;
11975 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11976
11977 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11978
11979 // do the appending task
11980
11981 snprintf (salt_ptr + cur_pos,
11982 rem_len,
11983 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11984 wpa->orig_mac1[0],
11985 wpa->orig_mac1[1],
11986 wpa->orig_mac1[2],
11987 wpa->orig_mac1[3],
11988 wpa->orig_mac1[4],
11989 wpa->orig_mac1[5],
11990 wpa->orig_mac2[0],
11991 wpa->orig_mac2[1],
11992 wpa->orig_mac2[2],
11993 wpa->orig_mac2[3],
11994 wpa->orig_mac2[4],
11995 wpa->orig_mac2[5]);
11996
11997 // memset () the remaining part of the salt
11998
11999 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
12000 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12001
12002 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
12003
12004 tmp_salt->salt_len += 1 + 12 + 1 + 12;
12005 }
12006
12007 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);
12008 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);
12009
12010 hashes_cnt++;
12011 }
12012
12013 fclose (fp);
12014
12015 myfree (in);
12016 }
12017 else if (hash_mode == 3000)
12018 {
12019 if (hash_len == 32)
12020 {
12021 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12022
12023 hash_t *lm_hash_left = NULL;
12024
12025 if (parser_status == PARSER_OK)
12026 {
12027 lm_hash_left = &hashes_buf[hashes_cnt];
12028
12029 hashes_cnt++;
12030 }
12031 else
12032 {
12033 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12034 }
12035
12036 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12037
12038 hash_t *lm_hash_right = NULL;
12039
12040 if (parser_status == PARSER_OK)
12041 {
12042 lm_hash_right = &hashes_buf[hashes_cnt];
12043
12044 hashes_cnt++;
12045 }
12046 else
12047 {
12048 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12049 }
12050
12051 // show / left
12052
12053 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12054 {
12055 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);
12056 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);
12057 }
12058 }
12059 else
12060 {
12061 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12062
12063 if (parser_status == PARSER_OK)
12064 {
12065 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12066 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12067 }
12068
12069 if (parser_status == PARSER_OK)
12070 {
12071 hashes_cnt++;
12072 }
12073 else
12074 {
12075 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12076 }
12077 }
12078 }
12079 else
12080 {
12081 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12082
12083 if (parser_status == PARSER_OK)
12084 {
12085 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12086 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12087 }
12088
12089 if (parser_status == PARSER_OK)
12090 {
12091 hashes_cnt++;
12092 }
12093 else
12094 {
12095 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12096 }
12097 }
12098 }
12099 }
12100 else if (hashlist_mode == HL_MODE_FILE)
12101 {
12102 char *hashfile = data.hashfile;
12103
12104 FILE *fp;
12105
12106 if ((fp = fopen (hashfile, "rb")) == NULL)
12107 {
12108 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12109
12110 return (-1);
12111 }
12112
12113 uint line_num = 0;
12114
12115 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12116
12117 while (!feof (fp))
12118 {
12119 line_num++;
12120
12121 int line_len = fgetl (fp, line_buf);
12122
12123 if (line_len == 0) continue;
12124
12125 char *hash_buf = NULL;
12126 int hash_len = 0;
12127
12128 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12129
12130 bool hash_fmt_error = 0;
12131
12132 if (hash_len < 1) hash_fmt_error = 1;
12133 if (hash_buf == NULL) hash_fmt_error = 1;
12134
12135 if (hash_fmt_error)
12136 {
12137 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12138
12139 continue;
12140 }
12141
12142 if (username)
12143 {
12144 char *user_buf = NULL;
12145 int user_len = 0;
12146
12147 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12148
12149 if (remove || show)
12150 {
12151 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12152
12153 *user = (user_t *) mymalloc (sizeof (user_t));
12154
12155 user_t *user_ptr = *user;
12156
12157 if (user_buf != NULL)
12158 {
12159 user_ptr->user_name = mystrdup (user_buf);
12160 }
12161 else
12162 {
12163 user_ptr->user_name = mystrdup ("");
12164 }
12165
12166 user_ptr->user_len = user_len;
12167 }
12168 }
12169
12170 if (opts_type & OPTS_TYPE_HASH_COPY)
12171 {
12172 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12173
12174 hash_info_tmp->orighash = mystrdup (hash_buf);
12175 }
12176
12177 if (isSalted)
12178 {
12179 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12180 }
12181
12182 if (hash_mode == 3000)
12183 {
12184 if (hash_len == 32)
12185 {
12186 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12187
12188 if (parser_status < PARSER_GLOBAL_ZERO)
12189 {
12190 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12191
12192 continue;
12193 }
12194
12195 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12196
12197 hashes_cnt++;
12198
12199 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12200
12201 if (parser_status < PARSER_GLOBAL_ZERO)
12202 {
12203 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12204
12205 continue;
12206 }
12207
12208 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12209
12210 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);
12211
12212 hashes_cnt++;
12213
12214 // show / left
12215
12216 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);
12217 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);
12218 }
12219 else
12220 {
12221 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12222
12223 if (parser_status < PARSER_GLOBAL_ZERO)
12224 {
12225 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12226
12227 continue;
12228 }
12229
12230 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);
12231
12232 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12233 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12234
12235 hashes_cnt++;
12236 }
12237 }
12238 else
12239 {
12240 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12241
12242 if (parser_status < PARSER_GLOBAL_ZERO)
12243 {
12244 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12245
12246 continue;
12247 }
12248
12249 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);
12250
12251 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12252 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12253
12254 hashes_cnt++;
12255 }
12256 }
12257
12258 myfree (line_buf);
12259
12260 fclose (fp);
12261
12262 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12263
12264 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12265 }
12266 }
12267 else
12268 {
12269 if (isSalted)
12270 {
12271 hashes_buf[0].salt->salt_len = 8;
12272
12273 // special salt handling
12274
12275 switch (hash_mode)
12276 {
12277 case 1500: hashes_buf[0].salt->salt_len = 2;
12278 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12279 break;
12280 case 1731: hashes_buf[0].salt->salt_len = 4;
12281 break;
12282 case 2410: hashes_buf[0].salt->salt_len = 4;
12283 break;
12284 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12285 break;
12286 case 3100: hashes_buf[0].salt->salt_len = 1;
12287 break;
12288 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
12289 break;
12290 case 5800: hashes_buf[0].salt->salt_len = 16;
12291 break;
12292 case 6800: hashes_buf[0].salt->salt_len = 32;
12293 break;
12294 case 8400: hashes_buf[0].salt->salt_len = 40;
12295 break;
12296 case 8800: hashes_buf[0].salt->salt_len = 16;
12297 break;
12298 case 8900: hashes_buf[0].salt->salt_len = 16;
12299 hashes_buf[0].salt->scrypt_N = 1024;
12300 hashes_buf[0].salt->scrypt_r = 1;
12301 hashes_buf[0].salt->scrypt_p = 1;
12302 break;
12303 case 9100: hashes_buf[0].salt->salt_len = 16;
12304 break;
12305 case 9300: hashes_buf[0].salt->salt_len = 14;
12306 hashes_buf[0].salt->scrypt_N = 16384;
12307 hashes_buf[0].salt->scrypt_r = 1;
12308 hashes_buf[0].salt->scrypt_p = 1;
12309 break;
12310 case 9400: hashes_buf[0].salt->salt_len = 16;
12311 break;
12312 case 9500: hashes_buf[0].salt->salt_len = 16;
12313 break;
12314 case 9600: hashes_buf[0].salt->salt_len = 16;
12315 break;
12316 case 9700: hashes_buf[0].salt->salt_len = 16;
12317 break;
12318 case 9710: hashes_buf[0].salt->salt_len = 16;
12319 break;
12320 case 9720: hashes_buf[0].salt->salt_len = 16;
12321 break;
12322 case 9800: hashes_buf[0].salt->salt_len = 16;
12323 break;
12324 case 9810: hashes_buf[0].salt->salt_len = 16;
12325 break;
12326 case 9820: hashes_buf[0].salt->salt_len = 16;
12327 break;
12328 case 10300: hashes_buf[0].salt->salt_len = 12;
12329 break;
12330 case 11500: hashes_buf[0].salt->salt_len = 4;
12331 break;
12332 case 11600: hashes_buf[0].salt->salt_len = 4;
12333 break;
12334 case 12400: hashes_buf[0].salt->salt_len = 4;
12335 break;
12336 case 12500: hashes_buf[0].salt->salt_len = 8;
12337 break;
12338 case 12600: hashes_buf[0].salt->salt_len = 64;
12339 break;
12340 }
12341
12342 // special esalt handling
12343
12344 switch (hash_mode)
12345 {
12346 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12347 break;
12348 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12349 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12350 break;
12351 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12352 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12353 break;
12354 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12355 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12356 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12357 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12358 break;
12359 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12360 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12361 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12362 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12363 break;
12364 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12365 break;
12366 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12367 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12368 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12369 break;
12370 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12371 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12372 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12373 break;
12374 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12375 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12376 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12377 break;
12378 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12379 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12380 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12381 break;
12382 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12383 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12384 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12385 break;
12386 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12387 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12388 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12389 break;
12390 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12391 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12392 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12393 break;
12394 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12395 break;
12396 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12397 break;
12398 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12399 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12400 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12401 break;
12402 }
12403 }
12404
12405 // set hashfile
12406
12407 switch (hash_mode)
12408 {
12409 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12410 break;
12411 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12412 break;
12413 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12414 break;
12415 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12416 break;
12417 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12418 break;
12419 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12420 break;
12421 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12422 break;
12423 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12424 break;
12425 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12426 break;
12427 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12428 break;
12429 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12430 break;
12431 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12432 break;
12433 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12434 break;
12435 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12436 break;
12437 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12438 break;
12439 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12440 break;
12441 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12442 break;
12443 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12444 break;
12445 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12446 break;
12447 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12448 break;
12449 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12450 break;
12451 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12452 break;
12453 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12454 break;
12455 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12456 break;
12457 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12458 break;
12459 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12460 break;
12461 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12462 break;
12463 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12464 break;
12465 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12466 break;
12467 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12468 break;
12469 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12470 break;
12471 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12472 break;
12473 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12474 break;
12475 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12476 break;
12477 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12478 break;
12479 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12480 break;
12481 }
12482
12483 // set default iterations
12484
12485 switch (hash_mode)
12486 {
12487 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12488 break;
12489 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12490 break;
12491 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12492 break;
12493 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12494 break;
12495 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12496 break;
12497 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12498 break;
12499 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12500 break;
12501 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12502 break;
12503 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12504 break;
12505 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12506 break;
12507 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12508 break;
12509 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12510 break;
12511 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12512 break;
12513 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12514 break;
12515 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12516 break;
12517 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12518 break;
12519 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12520 break;
12521 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12522 break;
12523 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12524 break;
12525 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12526 break;
12527 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12528 break;
12529 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12530 break;
12531 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12532 break;
12533 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12534 break;
12535 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12536 break;
12537 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12538 break;
12539 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12540 break;
12541 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12542 break;
12543 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12544 break;
12545 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12546 break;
12547 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12548 break;
12549 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12550 break;
12551 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12552 break;
12553 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12554 break;
12555 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12556 break;
12557 case 8900: hashes_buf[0].salt->salt_iter = 1;
12558 break;
12559 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12560 break;
12561 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12562 break;
12563 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12564 break;
12565 case 9300: hashes_buf[0].salt->salt_iter = 1;
12566 break;
12567 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12568 break;
12569 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12570 break;
12571 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12572 break;
12573 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12574 break;
12575 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12576 break;
12577 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12578 break;
12579 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12580 break;
12581 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12582 break;
12583 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12584 break;
12585 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12586 break;
12587 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12588 break;
12589 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12590 break;
12591 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12592 break;
12593 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12594 break;
12595 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12596 break;
12597 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12598 break;
12599 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12600 break;
12601 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12602 break;
12603 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12604 break;
12605 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12606 break;
12607 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12608 break;
12609 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12610 break;
12611 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12612 break;
12613 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12614 break;
12615 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12616 break;
12617 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12618 break;
12619 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12620 break;
12621 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12622 break;
12623 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12624 break;
12625 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12626 break;
12627 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12628 break;
12629 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12630 break;
12631 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12632 break;
12633 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12634 break;
12635 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12636 break;
12637 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12638 break;
12639 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12640 break;
12641 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12642 break;
12643 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12644 break;
12645 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12646 break;
12647 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12648 break;
12649 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12650 break;
12651 }
12652
12653 hashes_cnt = 1;
12654 }
12655
12656 if (show == 1 || left == 1)
12657 {
12658 for (uint i = 0; i < pot_cnt; i++)
12659 {
12660 pot_t *pot_ptr = &pot[i];
12661
12662 hash_t *hashes_buf = &pot_ptr->hash;
12663
12664 local_free (hashes_buf->digest);
12665
12666 if (isSalted)
12667 {
12668 local_free (hashes_buf->salt);
12669 }
12670 }
12671
12672 local_free (pot);
12673
12674 if (data.quiet == 0) log_info_nn ("");
12675
12676 return (0);
12677 }
12678
12679 if ((keyspace == 0) && (stdout_flag == 0))
12680 {
12681 if (hashes_cnt == 0)
12682 {
12683 log_error ("ERROR: No hashes loaded");
12684
12685 return (-1);
12686 }
12687 }
12688
12689 /**
12690 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12691 */
12692
12693 if (data.outfile != NULL)
12694 {
12695 if (data.hashfile != NULL)
12696 {
12697 #ifdef _POSIX
12698 struct stat tmpstat_outfile;
12699 struct stat tmpstat_hashfile;
12700 #endif
12701
12702 #ifdef _WIN
12703 struct stat64 tmpstat_outfile;
12704 struct stat64 tmpstat_hashfile;
12705 #endif
12706
12707 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12708
12709 if (tmp_outfile_fp)
12710 {
12711 #ifdef _POSIX
12712 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12713 #endif
12714
12715 #ifdef _WIN
12716 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12717 #endif
12718
12719 fclose (tmp_outfile_fp);
12720 }
12721
12722 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12723
12724 if (tmp_hashfile_fp)
12725 {
12726 #ifdef _POSIX
12727 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12728 #endif
12729
12730 #ifdef _WIN
12731 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12732 #endif
12733
12734 fclose (tmp_hashfile_fp);
12735 }
12736
12737 if (tmp_outfile_fp && tmp_outfile_fp)
12738 {
12739 tmpstat_outfile.st_mode = 0;
12740 tmpstat_outfile.st_nlink = 0;
12741 tmpstat_outfile.st_uid = 0;
12742 tmpstat_outfile.st_gid = 0;
12743 tmpstat_outfile.st_rdev = 0;
12744 tmpstat_outfile.st_atime = 0;
12745
12746 tmpstat_hashfile.st_mode = 0;
12747 tmpstat_hashfile.st_nlink = 0;
12748 tmpstat_hashfile.st_uid = 0;
12749 tmpstat_hashfile.st_gid = 0;
12750 tmpstat_hashfile.st_rdev = 0;
12751 tmpstat_hashfile.st_atime = 0;
12752
12753 #ifdef _POSIX
12754 tmpstat_outfile.st_blksize = 0;
12755 tmpstat_outfile.st_blocks = 0;
12756
12757 tmpstat_hashfile.st_blksize = 0;
12758 tmpstat_hashfile.st_blocks = 0;
12759 #endif
12760
12761 #ifdef _POSIX
12762 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12763 {
12764 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12765
12766 return (-1);
12767 }
12768 #endif
12769
12770 #ifdef _WIN
12771 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12772 {
12773 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12774
12775 return (-1);
12776 }
12777 #endif
12778 }
12779 }
12780 }
12781
12782 /**
12783 * Remove duplicates
12784 */
12785
12786 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12787
12788 if (isSalted)
12789 {
12790 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12791 }
12792 else
12793 {
12794 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12795 }
12796
12797 uint hashes_cnt_orig = hashes_cnt;
12798
12799 hashes_cnt = 1;
12800
12801 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12802 {
12803 if (isSalted)
12804 {
12805 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12806 {
12807 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12808 }
12809 }
12810 else
12811 {
12812 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12813 }
12814
12815 if (hashes_pos > hashes_cnt)
12816 {
12817 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12818 }
12819
12820 hashes_cnt++;
12821 }
12822
12823 /**
12824 * Potfile removes
12825 */
12826
12827 uint potfile_remove_cracks = 0;
12828
12829 if (potfile_disable == 0)
12830 {
12831 hash_t hash_buf;
12832
12833 hash_buf.digest = mymalloc (dgst_size);
12834 hash_buf.salt = NULL;
12835 hash_buf.esalt = NULL;
12836 hash_buf.hash_info = NULL;
12837 hash_buf.cracked = 0;
12838
12839 if (isSalted)
12840 {
12841 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12842 }
12843
12844 if (esalt_size)
12845 {
12846 hash_buf.esalt = mymalloc (esalt_size);
12847 }
12848
12849 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12850
12851 // no solution for these special hash types (for instane because they use hashfile in output etc)
12852 if ((hash_mode != 5200) &&
12853 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12854 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12855 (hash_mode != 9000))
12856 {
12857 FILE *fp = fopen (potfile, "rb");
12858
12859 if (fp != NULL)
12860 {
12861 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12862
12863 // to be safe work with a copy (because of line_len loop, i etc)
12864 // moved up here because it's easier to handle continue case
12865 // it's just 64kb
12866
12867 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12868
12869 while (!feof (fp))
12870 {
12871 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12872
12873 if (ptr == NULL) break;
12874
12875 int line_len = strlen (line_buf);
12876
12877 if (line_len == 0) continue;
12878
12879 int iter = MAX_CUT_TRIES;
12880
12881 for (int i = line_len - 1; i && iter; i--, line_len--)
12882 {
12883 if (line_buf[i] != ':') continue;
12884
12885 if (isSalted)
12886 {
12887 memset (hash_buf.salt, 0, sizeof (salt_t));
12888 }
12889
12890 hash_t *found = NULL;
12891
12892 if (hash_mode == 6800)
12893 {
12894 if (i < 64) // 64 = 16 * uint in salt_buf[]
12895 {
12896 // manipulate salt_buf
12897 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12898
12899 hash_buf.salt->salt_len = i;
12900
12901 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12902 }
12903 }
12904 else if (hash_mode == 2500)
12905 {
12906 if (i < 64) // 64 = 16 * uint in salt_buf[]
12907 {
12908 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12909 // manipulate salt_buf
12910
12911 memcpy (line_buf_cpy, line_buf, i);
12912
12913 char *mac2_pos = strrchr (line_buf_cpy, ':');
12914
12915 if (mac2_pos == NULL) continue;
12916
12917 mac2_pos[0] = 0;
12918 mac2_pos++;
12919
12920 if (strlen (mac2_pos) != 12) continue;
12921
12922 char *mac1_pos = strrchr (line_buf_cpy, ':');
12923
12924 if (mac1_pos == NULL) continue;
12925
12926 mac1_pos[0] = 0;
12927 mac1_pos++;
12928
12929 if (strlen (mac1_pos) != 12) continue;
12930
12931 uint essid_length = mac1_pos - line_buf_cpy - 1;
12932
12933 // here we need the ESSID
12934 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12935
12936 hash_buf.salt->salt_len = essid_length;
12937
12938 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12939
12940 if (found)
12941 {
12942 wpa_t *wpa = (wpa_t *) found->esalt;
12943
12944 // compare hex string(s) vs binary MAC address(es)
12945
12946 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12947 {
12948 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12949 {
12950 found = NULL;
12951
12952 break;
12953 }
12954 }
12955
12956 // early skip ;)
12957 if (!found) continue;
12958
12959 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12960 {
12961 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12962 {
12963 found = NULL;
12964
12965 break;
12966 }
12967 }
12968 }
12969 }
12970 }
12971 else
12972 {
12973 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12974
12975 if (parser_status == PARSER_OK)
12976 {
12977 if (isSalted)
12978 {
12979 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12980 }
12981 else
12982 {
12983 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12984 }
12985 }
12986 }
12987
12988 if (found == NULL) continue;
12989
12990 if (!found->cracked) potfile_remove_cracks++;
12991
12992 found->cracked = 1;
12993
12994 if (found) break;
12995
12996 iter--;
12997 }
12998 }
12999
13000 myfree (line_buf_cpy);
13001
13002 myfree (line_buf);
13003
13004 fclose (fp);
13005 }
13006 }
13007
13008 if (esalt_size)
13009 {
13010 local_free (hash_buf.esalt);
13011 }
13012
13013 if (isSalted)
13014 {
13015 local_free (hash_buf.salt);
13016 }
13017
13018 local_free (hash_buf.digest);
13019 }
13020
13021 /**
13022 * Now generate all the buffers required for later
13023 */
13024
13025 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
13026
13027 salt_t *salts_buf_new = NULL;
13028 void *esalts_buf_new = NULL;
13029
13030 if (isSalted)
13031 {
13032 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
13033
13034 if (esalt_size)
13035 {
13036 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
13037 }
13038 }
13039 else
13040 {
13041 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13042 }
13043
13044 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13045
13046 uint digests_cnt = hashes_cnt;
13047 uint digests_done = 0;
13048
13049 size_t size_digests = digests_cnt * dgst_size;
13050 size_t size_shown = digests_cnt * sizeof (uint);
13051
13052 uint *digests_shown = (uint *) mymalloc (size_shown);
13053 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13054
13055 uint salts_cnt = 0;
13056 uint salts_done = 0;
13057
13058 hashinfo_t **hash_info = NULL;
13059
13060 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13061 {
13062 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13063
13064 if (username && (remove || show))
13065 {
13066 uint user_pos;
13067
13068 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13069 {
13070 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13071
13072 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13073 }
13074 }
13075 }
13076
13077 uint *salts_shown = (uint *) mymalloc (size_shown);
13078
13079 salt_t *salt_buf;
13080
13081 {
13082 // copied from inner loop
13083
13084 salt_buf = &salts_buf_new[salts_cnt];
13085
13086 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13087
13088 if (esalt_size)
13089 {
13090 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13091 }
13092
13093 salt_buf->digests_cnt = 0;
13094 salt_buf->digests_done = 0;
13095 salt_buf->digests_offset = 0;
13096
13097 salts_cnt++;
13098 }
13099
13100 if (hashes_buf[0].cracked == 1)
13101 {
13102 digests_shown[0] = 1;
13103
13104 digests_done++;
13105
13106 salt_buf->digests_done++;
13107 }
13108
13109 salt_buf->digests_cnt++;
13110
13111 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13112
13113 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13114 {
13115 hash_info[0] = hashes_buf[0].hash_info;
13116 }
13117
13118 // copy from inner loop
13119
13120 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13121 {
13122 if (isSalted)
13123 {
13124 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13125 {
13126 salt_buf = &salts_buf_new[salts_cnt];
13127
13128 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13129
13130 if (esalt_size)
13131 {
13132 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13133 }
13134
13135 salt_buf->digests_cnt = 0;
13136 salt_buf->digests_done = 0;
13137 salt_buf->digests_offset = hashes_pos;
13138
13139 salts_cnt++;
13140 }
13141 }
13142
13143 if (hashes_buf[hashes_pos].cracked == 1)
13144 {
13145 digests_shown[hashes_pos] = 1;
13146
13147 digests_done++;
13148
13149 salt_buf->digests_done++;
13150 }
13151
13152 salt_buf->digests_cnt++;
13153
13154 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13155
13156 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13157 {
13158 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13159 }
13160 }
13161
13162 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13163 {
13164 salt_t *salt_buf = &salts_buf_new[salt_pos];
13165
13166 if (salt_buf->digests_done == salt_buf->digests_cnt)
13167 {
13168 salts_shown[salt_pos] = 1;
13169
13170 salts_done++;
13171 }
13172
13173 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13174 }
13175
13176 local_free (digests_buf);
13177 local_free (salts_buf);
13178 local_free (esalts_buf);
13179
13180 digests_buf = digests_buf_new;
13181 salts_buf = salts_buf_new;
13182 esalts_buf = esalts_buf_new;
13183
13184 local_free (hashes_buf);
13185
13186 /**
13187 * special modification not set from parser
13188 */
13189
13190 switch (hash_mode)
13191 {
13192 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13193 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13194 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13195 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13196 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13197 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13198 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13199 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13200 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13201 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13202 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13203 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13204 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13205 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13206 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13207 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13208 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13209 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13210 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13211 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13212 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13213 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13214 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13215 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13216 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13217 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13218 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13219 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13220 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13221 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13222 }
13223
13224 if (truecrypt_keyfiles)
13225 {
13226 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13227
13228 char *keyfiles = strdup (truecrypt_keyfiles);
13229
13230 char *keyfile = strtok (keyfiles, ",");
13231
13232 do
13233 {
13234 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13235
13236 } while ((keyfile = strtok (NULL, ",")) != NULL);
13237
13238 free (keyfiles);
13239 }
13240
13241 if (veracrypt_keyfiles)
13242 {
13243 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13244
13245 char *keyfiles = strdup (veracrypt_keyfiles);
13246
13247 char *keyfile = strtok (keyfiles, ",");
13248
13249 do
13250 {
13251 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13252
13253 } while ((keyfile = strtok (NULL, ",")) != NULL);
13254
13255 free (keyfiles);
13256 }
13257
13258 data.digests_cnt = digests_cnt;
13259 data.digests_done = digests_done;
13260 data.digests_buf = digests_buf;
13261 data.digests_shown = digests_shown;
13262 data.digests_shown_tmp = digests_shown_tmp;
13263
13264 data.salts_cnt = salts_cnt;
13265 data.salts_done = salts_done;
13266 data.salts_buf = salts_buf;
13267 data.salts_shown = salts_shown;
13268
13269 data.esalts_buf = esalts_buf;
13270 data.hash_info = hash_info;
13271
13272 /**
13273 * Automatic Optimizers
13274 */
13275
13276 if (salts_cnt == 1)
13277 opti_type |= OPTI_TYPE_SINGLE_SALT;
13278
13279 if (digests_cnt == 1)
13280 opti_type |= OPTI_TYPE_SINGLE_HASH;
13281
13282 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13283 opti_type |= OPTI_TYPE_NOT_ITERATED;
13284
13285 if (attack_mode == ATTACK_MODE_BF)
13286 opti_type |= OPTI_TYPE_BRUTE_FORCE;
13287
13288 data.opti_type = opti_type;
13289
13290 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13291 {
13292 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13293 {
13294 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13295 {
13296 if (opts_type & OPTS_TYPE_ST_ADD80)
13297 {
13298 opts_type &= ~OPTS_TYPE_ST_ADD80;
13299 opts_type |= OPTS_TYPE_PT_ADD80;
13300 }
13301
13302 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13303 {
13304 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13305 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13306 }
13307
13308 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13309 {
13310 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13311 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13312 }
13313 }
13314 }
13315 }
13316
13317 /**
13318 * Some algorithm, like descrypt, can benefit from JIT compilation
13319 */
13320
13321 int force_jit_compilation = -1;
13322
13323 if (hash_mode == 8900)
13324 {
13325 force_jit_compilation = 8900;
13326 }
13327 else if (hash_mode == 9300)
13328 {
13329 force_jit_compilation = 8900;
13330 }
13331 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13332 {
13333 force_jit_compilation = 1500;
13334 }
13335
13336 /**
13337 * generate bitmap tables
13338 */
13339
13340 const uint bitmap_shift1 = 5;
13341 const uint bitmap_shift2 = 13;
13342
13343 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13344
13345 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13346 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13347 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13348 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13349 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13350 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13351 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13352 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13353
13354 uint bitmap_bits;
13355 uint bitmap_nums;
13356 uint bitmap_mask;
13357 uint bitmap_size;
13358
13359 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13360 {
13361 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13362
13363 bitmap_nums = 1 << bitmap_bits;
13364
13365 bitmap_mask = bitmap_nums - 1;
13366
13367 bitmap_size = bitmap_nums * sizeof (uint);
13368
13369 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13370
13371 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;
13372 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;
13373
13374 break;
13375 }
13376
13377 bitmap_nums = 1 << bitmap_bits;
13378
13379 bitmap_mask = bitmap_nums - 1;
13380
13381 bitmap_size = bitmap_nums * sizeof (uint);
13382
13383 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);
13384 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);
13385
13386 /**
13387 * prepare quick rule
13388 */
13389
13390 data.rule_buf_l = rule_buf_l;
13391 data.rule_buf_r = rule_buf_r;
13392
13393 int rule_len_l = (int) strlen (rule_buf_l);
13394 int rule_len_r = (int) strlen (rule_buf_r);
13395
13396 data.rule_len_l = rule_len_l;
13397 data.rule_len_r = rule_len_r;
13398
13399 /**
13400 * load rules
13401 */
13402
13403 uint *all_kernel_rules_cnt = NULL;
13404
13405 kernel_rule_t **all_kernel_rules_buf = NULL;
13406
13407 if (rp_files_cnt)
13408 {
13409 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13410
13411 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13412 }
13413
13414 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13415
13416 int rule_len = 0;
13417
13418 for (uint i = 0; i < rp_files_cnt; i++)
13419 {
13420 uint kernel_rules_avail = 0;
13421
13422 uint kernel_rules_cnt = 0;
13423
13424 kernel_rule_t *kernel_rules_buf = NULL;
13425
13426 char *rp_file = rp_files[i];
13427
13428 char in[BLOCK_SIZE] = { 0 };
13429 char out[BLOCK_SIZE] = { 0 };
13430
13431 FILE *fp = NULL;
13432
13433 uint rule_line = 0;
13434
13435 if ((fp = fopen (rp_file, "rb")) == NULL)
13436 {
13437 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13438
13439 return (-1);
13440 }
13441
13442 while (!feof (fp))
13443 {
13444 memset (rule_buf, 0, HCBUFSIZ);
13445
13446 rule_len = fgetl (fp, rule_buf);
13447
13448 rule_line++;
13449
13450 if (rule_len == 0) continue;
13451
13452 if (rule_buf[0] == '#') continue;
13453
13454 if (kernel_rules_avail == kernel_rules_cnt)
13455 {
13456 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13457
13458 kernel_rules_avail += INCR_RULES;
13459 }
13460
13461 memset (in, 0, BLOCK_SIZE);
13462 memset (out, 0, BLOCK_SIZE);
13463
13464 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13465
13466 if (result == -1)
13467 {
13468 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13469
13470 continue;
13471 }
13472
13473 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13474 {
13475 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13476
13477 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13478
13479 continue;
13480 }
13481
13482 /* its so slow
13483 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13484 {
13485 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13486
13487 continue;
13488 }
13489 */
13490
13491 kernel_rules_cnt++;
13492 }
13493
13494 fclose (fp);
13495
13496 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13497
13498 all_kernel_rules_buf[i] = kernel_rules_buf;
13499 }
13500
13501 /**
13502 * merge rules or automatic rule generator
13503 */
13504
13505 uint kernel_rules_cnt = 0;
13506
13507 kernel_rule_t *kernel_rules_buf = NULL;
13508
13509 if (attack_mode == ATTACK_MODE_STRAIGHT)
13510 {
13511 if (rp_files_cnt)
13512 {
13513 kernel_rules_cnt = 1;
13514
13515 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13516
13517 repeats[0] = kernel_rules_cnt;
13518
13519 for (uint i = 0; i < rp_files_cnt; i++)
13520 {
13521 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13522
13523 repeats[i + 1] = kernel_rules_cnt;
13524 }
13525
13526 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13527
13528 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13529
13530 for (uint i = 0; i < kernel_rules_cnt; i++)
13531 {
13532 uint out_pos = 0;
13533
13534 kernel_rule_t *out = &kernel_rules_buf[i];
13535
13536 for (uint j = 0; j < rp_files_cnt; j++)
13537 {
13538 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13539 uint in_pos;
13540
13541 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13542
13543 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13544 {
13545 if (out_pos == RULES_MAX - 1)
13546 {
13547 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13548
13549 break;
13550 }
13551
13552 out->cmds[out_pos] = in->cmds[in_pos];
13553 }
13554 }
13555 }
13556
13557 local_free (repeats);
13558 }
13559 else if (rp_gen)
13560 {
13561 uint kernel_rules_avail = 0;
13562
13563 while (kernel_rules_cnt < rp_gen)
13564 {
13565 if (kernel_rules_avail == kernel_rules_cnt)
13566 {
13567 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13568
13569 kernel_rules_avail += INCR_RULES;
13570 }
13571
13572 memset (rule_buf, 0, HCBUFSIZ);
13573
13574 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13575
13576 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13577
13578 kernel_rules_cnt++;
13579 }
13580 }
13581 }
13582
13583 myfree (rule_buf);
13584
13585 /**
13586 * generate NOP rules
13587 */
13588
13589 if (kernel_rules_cnt == 0)
13590 {
13591 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13592
13593 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13594
13595 kernel_rules_cnt++;
13596 }
13597
13598 data.kernel_rules_cnt = kernel_rules_cnt;
13599 data.kernel_rules_buf = kernel_rules_buf;
13600
13601 /**
13602 * OpenCL platforms: detect
13603 */
13604
13605 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13606 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13607
13608 cl_uint platforms_cnt = 0;
13609 cl_uint platform_devices_cnt = 0;
13610
13611 if (keyspace == 0)
13612 {
13613 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13614
13615 if (platforms_cnt == 0)
13616 {
13617 log_info ("");
13618 log_info ("ATTENTION! No OpenCL compatible platform found");
13619 log_info ("");
13620 log_info ("You're probably missing the OpenCL runtime installation");
13621 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13622 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13623 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13624 log_info ("");
13625
13626 return (-1);
13627 }
13628
13629 if (opencl_platforms_filter != (uint) -1)
13630 {
13631 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13632
13633 if (opencl_platforms_filter > platform_cnt_mask)
13634 {
13635 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13636
13637 return (-1);
13638 }
13639 }
13640 }
13641
13642 if (opencl_device_types == NULL)
13643 {
13644 /**
13645 * OpenCL device types:
13646 * 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.
13647 */
13648
13649 cl_device_type device_types_all = 0;
13650
13651 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13652 {
13653 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13654
13655 cl_platform_id platform = platforms[platform_id];
13656
13657 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13658
13659 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13660 {
13661 cl_device_id device = platform_devices[platform_devices_id];
13662
13663 cl_device_type device_type;
13664
13665 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13666
13667 device_types_all |= device_type;
13668 }
13669 }
13670
13671 // In such a case, automatically enable CPU device type support, since it's disabled by default.
13672
13673 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13674 {
13675 device_types_filter |= CL_DEVICE_TYPE_CPU;
13676 }
13677
13678 // In another case, when the user uses --stdout, using CPU devices is much faster to setup
13679 // If we have a CPU device, force it to be used
13680
13681 if (stdout_flag == 1)
13682 {
13683 if (device_types_all & CL_DEVICE_TYPE_CPU)
13684 {
13685 device_types_filter = CL_DEVICE_TYPE_CPU;
13686 }
13687 }
13688 }
13689
13690 /**
13691 * OpenCL devices: simply push all devices from all platforms into the same device array
13692 */
13693
13694 int need_adl = 0;
13695 int need_nvapi = 0;
13696 int need_nvml = 0;
13697 int need_xnvctrl = 0;
13698
13699 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13700
13701 data.devices_param = devices_param;
13702
13703 uint devices_cnt = 0;
13704
13705 uint devices_active = 0;
13706
13707 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13708 {
13709 cl_platform_id platform = platforms[platform_id];
13710
13711 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13712
13713 char platform_vendor[INFOSZ] = { 0 };
13714
13715 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13716
13717 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13718 // this causes trouble with vendor id based macros
13719 // we'll assign generic to those without special optimization available
13720
13721 cl_uint platform_vendor_id = 0;
13722
13723 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13724 {
13725 platform_vendor_id = VENDOR_ID_AMD;
13726 }
13727 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13728 {
13729 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13730 }
13731 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13732 {
13733 platform_vendor_id = VENDOR_ID_APPLE;
13734 }
13735 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13736 {
13737 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13738 }
13739 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13740 {
13741 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13742 }
13743 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13744 {
13745 platform_vendor_id = VENDOR_ID_MESA;
13746 }
13747 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13748 {
13749 platform_vendor_id = VENDOR_ID_NV;
13750 }
13751 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13752 {
13753 platform_vendor_id = VENDOR_ID_POCL;
13754 }
13755 else
13756 {
13757 platform_vendor_id = VENDOR_ID_GENERIC;
13758 }
13759
13760 const uint platform_skipped = ((opencl_platforms_filter & (1 << platform_id)) == 0);
13761
13762 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13763 {
13764 if (machine_readable == 0)
13765 {
13766 if (platform_skipped == 0)
13767 {
13768 const int len = log_info ("OpenCL Platform #%u: %s", platform_id + 1, platform_vendor);
13769
13770 char line[256] = { 0 };
13771
13772 for (int i = 0; i < len; i++) line[i] = '=';
13773
13774 log_info (line);
13775 }
13776 else
13777 {
13778 log_info ("OpenCL Platform #%u: %s, skipped", platform_id + 1, platform_vendor);
13779 log_info ("");
13780 }
13781 }
13782 }
13783
13784 if (platform_skipped == 1) continue;
13785
13786 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13787 {
13788 size_t param_value_size = 0;
13789
13790 const uint device_id = devices_cnt;
13791
13792 hc_device_param_t *device_param = &data.devices_param[device_id];
13793
13794 device_param->platform_vendor_id = platform_vendor_id;
13795
13796 device_param->device = platform_devices[platform_devices_id];
13797
13798 device_param->device_id = device_id;
13799
13800 device_param->platform_devices_id = platform_devices_id;
13801
13802 // device_type
13803
13804 cl_device_type device_type;
13805
13806 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13807
13808 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13809
13810 device_param->device_type = device_type;
13811
13812 // device_name
13813
13814 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13815
13816 char *device_name = (char *) mymalloc (param_value_size);
13817
13818 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13819
13820 device_param->device_name = device_name;
13821
13822 // device_vendor
13823
13824 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13825
13826 char *device_vendor = (char *) mymalloc (param_value_size);
13827
13828 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13829
13830 device_param->device_vendor = device_vendor;
13831
13832 cl_uint device_vendor_id = 0;
13833
13834 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13835 {
13836 device_vendor_id = VENDOR_ID_AMD;
13837 }
13838 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13839 {
13840 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13841 }
13842 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13843 {
13844 device_vendor_id = VENDOR_ID_APPLE;
13845 }
13846 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13847 {
13848 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13849 }
13850 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13851 {
13852 device_vendor_id = VENDOR_ID_INTEL_SDK;
13853 }
13854 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13855 {
13856 device_vendor_id = VENDOR_ID_MESA;
13857 }
13858 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13859 {
13860 device_vendor_id = VENDOR_ID_NV;
13861 }
13862 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13863 {
13864 device_vendor_id = VENDOR_ID_POCL;
13865 }
13866 else
13867 {
13868 device_vendor_id = VENDOR_ID_GENERIC;
13869 }
13870
13871 device_param->device_vendor_id = device_vendor_id;
13872
13873 // tuning db
13874
13875 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13876
13877 // device_version
13878
13879 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13880
13881 char *device_version = (char *) mymalloc (param_value_size);
13882
13883 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13884
13885 device_param->device_version = device_version;
13886
13887 // device_opencl_version
13888
13889 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13890
13891 char *device_opencl_version = (char *) mymalloc (param_value_size);
13892
13893 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13894
13895 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13896
13897 myfree (device_opencl_version);
13898
13899 // vector_width
13900
13901 cl_uint vector_width;
13902
13903 if (opencl_vector_width_chgd == 0)
13904 {
13905 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13906 {
13907 if (opti_type & OPTI_TYPE_USES_BITS_64)
13908 {
13909 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13910 }
13911 else
13912 {
13913 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13914 }
13915 }
13916 else
13917 {
13918 vector_width = (cl_uint) tuningdb_entry->vector_width;
13919 }
13920 }
13921 else
13922 {
13923 vector_width = opencl_vector_width;
13924 }
13925
13926 if (vector_width > 16) vector_width = 16;
13927
13928 device_param->vector_width = vector_width;
13929
13930 // max_compute_units
13931
13932 cl_uint device_processors;
13933
13934 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13935
13936 device_param->device_processors = device_processors;
13937
13938 // device_maxmem_alloc
13939 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13940
13941 cl_ulong device_maxmem_alloc;
13942
13943 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13944
13945 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13946
13947 // device_global_mem
13948
13949 cl_ulong device_global_mem;
13950
13951 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13952
13953 device_param->device_global_mem = device_global_mem;
13954
13955 // max_work_group_size
13956
13957 size_t device_maxworkgroup_size;
13958
13959 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13960
13961 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13962
13963 // max_clock_frequency
13964
13965 cl_uint device_maxclock_frequency;
13966
13967 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13968
13969 device_param->device_maxclock_frequency = device_maxclock_frequency;
13970
13971 // device_endian_little
13972
13973 cl_bool device_endian_little;
13974
13975 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13976
13977 if (device_endian_little == CL_FALSE)
13978 {
13979 log_info ("- Device #%u: WARNING: not little endian device", device_id + 1);
13980
13981 device_param->skipped = 1;
13982 }
13983
13984 // device_available
13985
13986 cl_bool device_available;
13987
13988 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13989
13990 if (device_available == CL_FALSE)
13991 {
13992 log_info ("- Device #%u: WARNING: device not available", device_id + 1);
13993
13994 device_param->skipped = 1;
13995 }
13996
13997 // device_compiler_available
13998
13999 cl_bool device_compiler_available;
14000
14001 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
14002
14003 if (device_compiler_available == CL_FALSE)
14004 {
14005 log_info ("- Device #%u: WARNING: device no compiler available", device_id + 1);
14006
14007 device_param->skipped = 1;
14008 }
14009
14010 // device_execution_capabilities
14011
14012 cl_device_exec_capabilities device_execution_capabilities;
14013
14014 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
14015
14016 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
14017 {
14018 log_info ("- Device #%u: WARNING: device does not support executing kernels", device_id + 1);
14019
14020 device_param->skipped = 1;
14021 }
14022
14023 // device_extensions
14024
14025 size_t device_extensions_size;
14026
14027 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
14028
14029 char *device_extensions = mymalloc (device_extensions_size + 1);
14030
14031 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
14032
14033 if (strstr (device_extensions, "base_atomics") == 0)
14034 {
14035 log_info ("- Device #%u: WARNING: device does not support base atomics", device_id + 1);
14036
14037 device_param->skipped = 1;
14038 }
14039
14040 if (strstr (device_extensions, "byte_addressable_store") == 0)
14041 {
14042 log_info ("- Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
14043
14044 device_param->skipped = 1;
14045 }
14046
14047 myfree (device_extensions);
14048
14049 // device_local_mem_size
14050
14051 cl_ulong device_local_mem_size;
14052
14053 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
14054
14055 if (device_local_mem_size < 32768)
14056 {
14057 log_info ("- Device #%u: WARNING: device local mem size is too small", device_id + 1);
14058
14059 device_param->skipped = 1;
14060 }
14061
14062 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
14063 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
14064 // This results in both utilizing it for 50%
14065 // However, Intel has much better SIMD control over their own hardware
14066 // It makes sense to give them full control over their own hardware
14067
14068 if (device_type & CL_DEVICE_TYPE_CPU)
14069 {
14070 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14071 {
14072 if (data.force == 0)
14073 {
14074 if (algorithm_pos == 0)
14075 {
14076 log_info ("- Device #%u: WARNING: not native intel opencl runtime, expect massive speed loss", device_id + 1);
14077 log_info (" You can use --force to override this but do not post error reports if you do so");
14078 }
14079
14080 device_param->skipped = 1;
14081 }
14082 }
14083 }
14084
14085 // skipped
14086
14087 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14088 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14089
14090 // driver_version
14091
14092 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14093
14094 char *driver_version = (char *) mymalloc (param_value_size);
14095
14096 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14097
14098 device_param->driver_version = driver_version;
14099
14100 // device_name_chksum
14101
14102 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14103
14104 #if __x86_64__
14105 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);
14106 #else
14107 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);
14108 #endif
14109
14110 uint device_name_digest[4] = { 0 };
14111
14112 md5_64 ((uint *) device_name_chksum, device_name_digest);
14113
14114 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14115
14116 device_param->device_name_chksum = device_name_chksum;
14117
14118 // device_processor_cores
14119
14120 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14121 {
14122 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14123 {
14124 need_adl = 1;
14125 }
14126
14127 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14128 {
14129 need_nvml = 1;
14130
14131 #ifdef LINUX
14132 need_xnvctrl = 1;
14133 #endif
14134
14135 #ifdef WIN
14136 need_nvapi = 1;
14137 #endif
14138 }
14139 }
14140
14141 // device_processor_cores
14142
14143 if (device_type & CL_DEVICE_TYPE_CPU)
14144 {
14145 cl_uint device_processor_cores = 1;
14146
14147 device_param->device_processor_cores = device_processor_cores;
14148 }
14149
14150 if (device_type & CL_DEVICE_TYPE_GPU)
14151 {
14152 if (device_vendor_id == VENDOR_ID_AMD)
14153 {
14154 cl_uint device_processor_cores = 0;
14155
14156 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
14157
14158 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
14159
14160 device_param->device_processor_cores = device_processor_cores;
14161 }
14162 else if (device_vendor_id == VENDOR_ID_NV)
14163 {
14164 cl_uint kernel_exec_timeout = 0;
14165
14166 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14167
14168 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14169
14170 device_param->kernel_exec_timeout = kernel_exec_timeout;
14171
14172 cl_uint device_processor_cores = 0;
14173
14174 #define CL_DEVICE_WARP_SIZE_NV 0x4003
14175
14176 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
14177
14178 device_param->device_processor_cores = device_processor_cores;
14179
14180 cl_uint sm_minor = 0;
14181 cl_uint sm_major = 0;
14182
14183 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14184 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14185
14186 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14187 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14188
14189 device_param->sm_minor = sm_minor;
14190 device_param->sm_major = sm_major;
14191
14192 // CPU burning loop damper
14193 // Value is given as number between 0-100
14194 // By default 100%
14195
14196 device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14197
14198 if (nvidia_spin_damp_chgd == 0)
14199 {
14200 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14201 {
14202 /**
14203 * the workaround is not a friend of rule based attacks
14204 * the words from the wordlist combined with fast and slow rules cause
14205 * fluctuations which cause inaccurate wait time estimations
14206 * using a reduced damping percentage almost compensates this
14207 */
14208
14209 device_param->nvidia_spin_damp = 64;
14210 }
14211 }
14212
14213 device_param->nvidia_spin_damp /= 100;
14214 }
14215 else
14216 {
14217 cl_uint device_processor_cores = 1;
14218
14219 device_param->device_processor_cores = device_processor_cores;
14220 }
14221 }
14222
14223 // display results
14224
14225 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14226 {
14227 if (machine_readable == 0)
14228 {
14229 if (device_param->skipped == 0)
14230 {
14231 log_info ("- Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14232 device_id + 1,
14233 device_name,
14234 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14235 (unsigned int) (device_global_mem / 1024 / 1024),
14236 (unsigned int) device_processors);
14237 }
14238 else
14239 {
14240 log_info ("- Device #%u: %s, skipped",
14241 device_id + 1,
14242 device_name);
14243 }
14244 }
14245 }
14246
14247 // common driver check
14248
14249 if (device_param->skipped == 0)
14250 {
14251 if (device_type & CL_DEVICE_TYPE_GPU)
14252 {
14253 if (platform_vendor_id == VENDOR_ID_AMD)
14254 {
14255 int catalyst_check = (force == 1) ? 0 : 1;
14256
14257 int catalyst_warn = 0;
14258
14259 int catalyst_broken = 0;
14260
14261 if (catalyst_check == 1)
14262 {
14263 catalyst_warn = 1;
14264
14265 // v14.9 and higher
14266 if (atoi (device_param->driver_version) >= 1573)
14267 {
14268 catalyst_warn = 0;
14269 }
14270
14271 catalyst_check = 0;
14272 }
14273
14274 if (catalyst_broken == 1)
14275 {
14276 log_info ("");
14277 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
14278 log_info ("It will pass over cracked hashes and does not report them as cracked");
14279 log_info ("You are STRONGLY encouraged not to use it");
14280 log_info ("You can use --force to override this but do not post error reports if you do so");
14281 log_info ("");
14282
14283 return (-1);
14284 }
14285
14286 if (catalyst_warn == 1)
14287 {
14288 log_info ("");
14289 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
14290 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
14291 log_info ("See hashcat's homepage for official supported catalyst drivers");
14292 #ifdef _WIN
14293 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14294 #endif
14295 log_info ("You can use --force to override this but do not post error reports if you do so");
14296 log_info ("");
14297
14298 return (-1);
14299 }
14300 }
14301 else if (platform_vendor_id == VENDOR_ID_NV)
14302 {
14303 if (device_param->kernel_exec_timeout != 0)
14304 {
14305 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);
14306 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14307 }
14308 }
14309 }
14310
14311 /* turns out pocl still creates segfaults (because of llvm)
14312 if (device_type & CL_DEVICE_TYPE_CPU)
14313 {
14314 if (platform_vendor_id == VENDOR_ID_AMD)
14315 {
14316 if (force == 0)
14317 {
14318 log_info ("");
14319 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14320 log_info ("You are STRONGLY encouraged not to use it");
14321 log_info ("You can use --force to override this but do not post error reports if you do so");
14322 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14323 log_info ("");
14324
14325 return (-1);
14326 }
14327 }
14328 }
14329 */
14330
14331 /**
14332 * kernel accel and loops tuning db adjustment
14333 */
14334
14335 device_param->kernel_accel_min = 1;
14336 device_param->kernel_accel_max = 1024;
14337
14338 device_param->kernel_loops_min = 1;
14339 device_param->kernel_loops_max = 1024;
14340
14341 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14342
14343 if (tuningdb_entry)
14344 {
14345 u32 _kernel_accel = tuningdb_entry->kernel_accel;
14346 u32 _kernel_loops = tuningdb_entry->kernel_loops;
14347
14348 if (_kernel_accel)
14349 {
14350 device_param->kernel_accel_min = _kernel_accel;
14351 device_param->kernel_accel_max = _kernel_accel;
14352 }
14353
14354 if (_kernel_loops)
14355 {
14356 if (workload_profile == 1)
14357 {
14358 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14359 }
14360 else if (workload_profile == 2)
14361 {
14362 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14363 }
14364
14365 device_param->kernel_loops_min = _kernel_loops;
14366 device_param->kernel_loops_max = _kernel_loops;
14367 }
14368 }
14369
14370 // commandline parameters overwrite tuningdb entries
14371
14372 if (kernel_accel)
14373 {
14374 device_param->kernel_accel_min = kernel_accel;
14375 device_param->kernel_accel_max = kernel_accel;
14376 }
14377
14378 if (kernel_loops)
14379 {
14380 device_param->kernel_loops_min = kernel_loops;
14381 device_param->kernel_loops_max = kernel_loops;
14382 }
14383
14384 /**
14385 * activate device
14386 */
14387
14388 devices_active++;
14389 }
14390
14391 // next please
14392
14393 devices_cnt++;
14394 }
14395
14396 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14397 {
14398 if (machine_readable == 0)
14399 {
14400 log_info ("");
14401 }
14402 }
14403 }
14404
14405 if (keyspace == 0 && devices_active == 0)
14406 {
14407 log_error ("ERROR: No devices found/left");
14408
14409 return (-1);
14410 }
14411
14412 // 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)
14413
14414 if (devices_filter != (uint) -1)
14415 {
14416 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14417
14418 if (devices_filter > devices_cnt_mask)
14419 {
14420 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14421
14422 return (-1);
14423 }
14424 }
14425
14426 data.devices_cnt = devices_cnt;
14427
14428 data.devices_active = devices_active;
14429
14430 /**
14431 * HM devices: init
14432 */
14433
14434 #ifdef HAVE_HWMON
14435 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14436 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14437 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14438 hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX] = { { 0 } };
14439
14440 if (gpu_temp_disable == 0)
14441 {
14442 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14443 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14444 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14445 XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));
14446
14447 data.hm_adl = NULL;
14448 data.hm_nvapi = NULL;
14449 data.hm_nvml = NULL;
14450 data.hm_xnvctrl = NULL;
14451
14452 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14453 {
14454 data.hm_nvml = nvml;
14455 }
14456
14457 if (data.hm_nvml)
14458 {
14459 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14460 {
14461 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14462
14463 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14464
14465 int tmp_out = 0;
14466
14467 for (int i = 0; i < tmp_in; i++)
14468 {
14469 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14470 }
14471
14472 for (int i = 0; i < tmp_out; i++)
14473 {
14474 unsigned int speed;
14475
14476 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14477
14478 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14479
14480 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14481 }
14482 }
14483 }
14484
14485 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14486 {
14487 data.hm_nvapi = nvapi;
14488 }
14489
14490 if (data.hm_nvapi)
14491 {
14492 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14493 {
14494 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14495
14496 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14497
14498 int tmp_out = 0;
14499
14500 for (int i = 0; i < tmp_in; i++)
14501 {
14502 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14503 }
14504 }
14505 }
14506
14507 if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0))
14508 {
14509 data.hm_xnvctrl = xnvctrl;
14510 }
14511
14512 if (data.hm_xnvctrl)
14513 {
14514 if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
14515 {
14516 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14517 {
14518 hc_device_param_t *device_param = &data.devices_param[device_id];
14519
14520 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14521
14522 hm_adapters_xnvctrl[device_id].xnvctrl = device_id;
14523
14524 int speed = 0;
14525
14526 if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
14527 }
14528 }
14529 }
14530
14531 if ((need_adl == 1) && (adl_init (adl) == 0))
14532 {
14533 data.hm_adl = adl;
14534 }
14535
14536 if (data.hm_adl)
14537 {
14538 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14539 {
14540 // total number of adapters
14541
14542 int hm_adapters_num;
14543
14544 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14545
14546 // adapter info
14547
14548 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14549
14550 if (lpAdapterInfo == NULL) return (-1);
14551
14552 // get a list (of ids of) valid/usable adapters
14553
14554 int num_adl_adapters = 0;
14555
14556 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14557
14558 if (num_adl_adapters > 0)
14559 {
14560 hc_thread_mutex_lock (mux_adl);
14561
14562 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14563
14564 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14565
14566 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14567 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14568
14569 hc_thread_mutex_unlock (mux_adl);
14570 }
14571
14572 myfree (valid_adl_device_list);
14573 myfree (lpAdapterInfo);
14574 }
14575 }
14576
14577 if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14578 {
14579 gpu_temp_disable = 1;
14580 }
14581 }
14582
14583 /**
14584 * OpenCL devices: allocate buffer for device specific information
14585 */
14586
14587 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14588 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14589
14590 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14591
14592 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14593
14594 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14595
14596 /**
14597 * User-defined GPU temp handling
14598 */
14599
14600 if (gpu_temp_disable == 1)
14601 {
14602 gpu_temp_abort = 0;
14603 gpu_temp_retain = 0;
14604 }
14605
14606 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14607 {
14608 if (gpu_temp_abort < gpu_temp_retain)
14609 {
14610 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14611
14612 return (-1);
14613 }
14614 }
14615
14616 data.gpu_temp_disable = gpu_temp_disable;
14617 data.gpu_temp_abort = gpu_temp_abort;
14618 data.gpu_temp_retain = gpu_temp_retain;
14619 #endif
14620
14621 /**
14622 * enable custom signal handler(s)
14623 */
14624
14625 if (benchmark == 0)
14626 {
14627 hc_signal (sigHandler_default);
14628 }
14629 else
14630 {
14631 hc_signal (sigHandler_benchmark);
14632 }
14633
14634 /**
14635 * inform the user
14636 */
14637
14638 if (data.quiet == 0)
14639 {
14640 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14641
14642 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);
14643
14644 if (attack_mode == ATTACK_MODE_STRAIGHT)
14645 {
14646 log_info ("Rules: %u", kernel_rules_cnt);
14647 }
14648
14649 if (opti_type)
14650 {
14651 log_info ("Applicable Optimizers:");
14652
14653 for (uint i = 0; i < 32; i++)
14654 {
14655 const uint opti_bit = 1u << i;
14656
14657 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14658 }
14659 }
14660
14661 /**
14662 * Watchdog and Temperature balance
14663 */
14664
14665 #ifdef HAVE_HWMON
14666 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14667 {
14668 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14669 }
14670
14671 if (gpu_temp_abort == 0)
14672 {
14673 log_info ("Watchdog: Temperature abort trigger disabled");
14674 }
14675 else
14676 {
14677 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14678 }
14679
14680 if (gpu_temp_retain == 0)
14681 {
14682 log_info ("Watchdog: Temperature retain trigger disabled");
14683 }
14684 else
14685 {
14686 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14687 }
14688
14689 if (data.quiet == 0) log_info ("");
14690 #endif
14691 }
14692
14693 #ifdef HAVE_HWMON
14694
14695 /**
14696 * HM devices: copy
14697 */
14698
14699 if (gpu_temp_disable == 0)
14700 {
14701 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14702 {
14703 hc_device_param_t *device_param = &data.devices_param[device_id];
14704
14705 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14706
14707 if (device_param->skipped) continue;
14708
14709 const uint platform_devices_id = device_param->platform_devices_id;
14710
14711 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14712 {
14713 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14714 data.hm_device[device_id].nvapi = 0;
14715 data.hm_device[device_id].nvml = 0;
14716 data.hm_device[device_id].xnvctrl = 0;
14717 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14718 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14719 data.hm_device[device_id].fan_set_supported = 0;
14720 }
14721
14722 if (device_param->device_vendor_id == VENDOR_ID_NV)
14723 {
14724 data.hm_device[device_id].adl = 0;
14725 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14726 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14727 data.hm_device[device_id].xnvctrl = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
14728 data.hm_device[device_id].od_version = 0;
14729 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14730 data.hm_device[device_id].fan_set_supported = 0;
14731 }
14732 }
14733 }
14734
14735 /**
14736 * powertune on user request
14737 */
14738
14739 if (powertune_enable == 1)
14740 {
14741 hc_thread_mutex_lock (mux_adl);
14742
14743 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14744 {
14745 hc_device_param_t *device_param = &data.devices_param[device_id];
14746
14747 if (device_param->skipped) continue;
14748
14749 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14750 {
14751 /**
14752 * Temporary fix:
14753 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14754 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14755 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14756 * Driver / ADL bug?
14757 */
14758
14759 if (data.hm_device[device_id].od_version == 6)
14760 {
14761 int ADL_rc;
14762
14763 // check powertune capabilities first, if not available then skip device
14764
14765 int powertune_supported = 0;
14766
14767 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14768 {
14769 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14770
14771 return (-1);
14772 }
14773
14774 // first backup current value, we will restore it later
14775
14776 if (powertune_supported != 0)
14777 {
14778 // powercontrol settings
14779
14780 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14781
14782 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14783 {
14784 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14785 }
14786
14787 if (ADL_rc != ADL_OK)
14788 {
14789 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14790
14791 return (-1);
14792 }
14793
14794 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14795 {
14796 log_error ("ERROR: Failed to set new ADL PowerControl values");
14797
14798 return (-1);
14799 }
14800
14801 // clocks
14802
14803 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14804
14805 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14806
14807 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)
14808 {
14809 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14810
14811 return (-1);
14812 }
14813
14814 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14815
14816 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14817
14818 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14819 {
14820 log_error ("ERROR: Failed to get ADL device capabilities");
14821
14822 return (-1);
14823 }
14824
14825 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14826 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14827
14828 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14829 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14830
14831 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14832 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14833
14834 // warning if profile has too low max values
14835
14836 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14837 {
14838 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14839 }
14840
14841 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14842 {
14843 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14844 }
14845
14846 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14847
14848 performance_state->iNumberOfPerformanceLevels = 2;
14849
14850 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14851 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14852 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14853 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14854
14855 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)
14856 {
14857 log_info ("ERROR: Failed to set ADL performance state");
14858
14859 return (-1);
14860 }
14861
14862 local_free (performance_state);
14863 }
14864
14865 // set powertune value only
14866
14867 if (powertune_supported != 0)
14868 {
14869 // powertune set
14870 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14871
14872 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14873 {
14874 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14875
14876 return (-1);
14877 }
14878
14879 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14880 {
14881 log_error ("ERROR: Failed to set new ADL PowerControl values");
14882
14883 return (-1);
14884 }
14885 }
14886 }
14887 }
14888
14889 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14890 {
14891 // first backup current value, we will restore it later
14892
14893 unsigned int limit;
14894
14895 int powertune_supported = 0;
14896
14897 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14898 {
14899 powertune_supported = 1;
14900 }
14901
14902 // if backup worked, activate the maximum allowed
14903
14904 if (powertune_supported != 0)
14905 {
14906 unsigned int minLimit;
14907 unsigned int maxLimit;
14908
14909 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14910 {
14911 if (maxLimit > 0)
14912 {
14913 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14914 {
14915 // now we can be sure we need to reset later
14916
14917 nvml_power_limit[device_id] = limit;
14918 }
14919 }
14920 }
14921 }
14922 }
14923 }
14924
14925 hc_thread_mutex_unlock (mux_adl);
14926 }
14927
14928 #endif // HAVE_HWMON
14929
14930 #ifdef DEBUG
14931 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14932 #endif
14933
14934 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14935
14936 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14937 {
14938 /**
14939 * host buffer
14940 */
14941
14942 hc_device_param_t *device_param = &data.devices_param[device_id];
14943
14944 if (device_param->skipped) continue;
14945
14946 /**
14947 * device properties
14948 */
14949
14950 const char *device_name_chksum = device_param->device_name_chksum;
14951 const u32 device_processors = device_param->device_processors;
14952 const u32 device_processor_cores = device_param->device_processor_cores;
14953
14954 /**
14955 * create context for each device
14956 */
14957
14958 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14959
14960 /**
14961 * create command-queue
14962 */
14963
14964 // not supported with NV
14965 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14966
14967 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14968
14969 /**
14970 * kernel threads: some algorithms need a fixed kernel-threads count
14971 * because of shared memory usage or bitslice
14972 * there needs to be some upper limit, otherwise there's too much overhead
14973 */
14974
14975 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14976
14977 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14978 {
14979 kernel_threads = KERNEL_THREADS_MAX_CPU;
14980 }
14981
14982 if (hash_mode == 1500) kernel_threads = 64; // DES
14983 if (hash_mode == 3000) kernel_threads = 64; // DES
14984 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14985 if (hash_mode == 7500) kernel_threads = 64; // RC4
14986 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14987 if (hash_mode == 9700) kernel_threads = 64; // RC4
14988 if (hash_mode == 9710) kernel_threads = 64; // RC4
14989 if (hash_mode == 9800) kernel_threads = 64; // RC4
14990 if (hash_mode == 9810) kernel_threads = 64; // RC4
14991 if (hash_mode == 10400) kernel_threads = 64; // RC4
14992 if (hash_mode == 10410) kernel_threads = 64; // RC4
14993 if (hash_mode == 10500) kernel_threads = 64; // RC4
14994 if (hash_mode == 13100) kernel_threads = 64; // RC4
14995
14996 device_param->kernel_threads = kernel_threads;
14997
14998 device_param->hardware_power = device_processors * kernel_threads;
14999
15000 /**
15001 * create input buffers on device : calculate size of fixed memory buffers
15002 */
15003
15004 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
15005 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
15006
15007 device_param->size_root_css = size_root_css;
15008 device_param->size_markov_css = size_markov_css;
15009
15010 size_t size_results = sizeof (uint);
15011
15012 device_param->size_results = size_results;
15013
15014 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
15015 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
15016
15017 size_t size_plains = digests_cnt * sizeof (plain_t);
15018 size_t size_salts = salts_cnt * sizeof (salt_t);
15019 size_t size_esalts = salts_cnt * esalt_size;
15020
15021 device_param->size_plains = size_plains;
15022 device_param->size_digests = size_digests;
15023 device_param->size_shown = size_shown;
15024 device_param->size_salts = size_salts;
15025
15026 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
15027 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
15028 size_t size_tm = 32 * sizeof (bs_word_t);
15029
15030 // scryptV stuff
15031
15032 size_t size_scryptV = 1;
15033
15034 if ((hash_mode == 8900) || (hash_mode == 9300))
15035 {
15036 uint tmto_start = 0;
15037 uint tmto_stop = 10;
15038
15039 if (scrypt_tmto)
15040 {
15041 tmto_start = scrypt_tmto;
15042 }
15043 else
15044 {
15045 // in case the user did not specify the tmto manually
15046 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
15047 // but set the lower end only in case the user has a device with too less memory
15048
15049 if (hash_mode == 8900)
15050 {
15051 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15052 {
15053 tmto_start = 1;
15054 }
15055 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15056 {
15057 tmto_start = 2;
15058 }
15059 }
15060 else if (hash_mode == 9300)
15061 {
15062 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15063 {
15064 tmto_start = 2;
15065 }
15066 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15067 {
15068 tmto_start = 2;
15069 }
15070 }
15071 }
15072
15073 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
15074 {
15075 // TODO: in theory the following calculation needs to be done per salt, not global
15076 // we assume all hashes have the same scrypt settings
15077
15078 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
15079
15080 size_scryptV /= 1 << tmto;
15081
15082 size_scryptV *= device_processors * device_processor_cores;
15083
15084 if (size_scryptV > device_param->device_maxmem_alloc)
15085 {
15086 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15087
15088 continue;
15089 }
15090
15091 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
15092 {
15093 data.salts_buf[salts_pos].scrypt_tmto = tmto;
15094 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
15095 }
15096
15097 break;
15098 }
15099
15100 if (data.salts_buf[0].scrypt_phy == 0)
15101 {
15102 log_error ("ERROR: can't allocate enough device memory");
15103
15104 return -1;
15105 }
15106
15107 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
15108 }
15109
15110 /**
15111 * some algorithms need a fixed kernel-loops count
15112 */
15113
15114 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15115 {
15116 const u32 kernel_loops_fixed = 1024;
15117
15118 device_param->kernel_loops_min = kernel_loops_fixed;
15119 device_param->kernel_loops_max = kernel_loops_fixed;
15120 }
15121
15122 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15123 {
15124 const u32 kernel_loops_fixed = 1024;
15125
15126 device_param->kernel_loops_min = kernel_loops_fixed;
15127 device_param->kernel_loops_max = kernel_loops_fixed;
15128 }
15129
15130 if (hash_mode == 8900)
15131 {
15132 const u32 kernel_loops_fixed = 1;
15133
15134 device_param->kernel_loops_min = kernel_loops_fixed;
15135 device_param->kernel_loops_max = kernel_loops_fixed;
15136 }
15137
15138 if (hash_mode == 9300)
15139 {
15140 const u32 kernel_loops_fixed = 1;
15141
15142 device_param->kernel_loops_min = kernel_loops_fixed;
15143 device_param->kernel_loops_max = kernel_loops_fixed;
15144 }
15145
15146 if (hash_mode == 12500)
15147 {
15148 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15149
15150 device_param->kernel_loops_min = kernel_loops_fixed;
15151 device_param->kernel_loops_max = kernel_loops_fixed;
15152 }
15153
15154 /**
15155 * some algorithms have a maximum kernel-loops count
15156 */
15157
15158 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15159 {
15160 u32 innerloop_cnt = 0;
15161
15162 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15163 {
15164 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15165 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15166 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15167 }
15168 else
15169 {
15170 innerloop_cnt = data.salts_buf[0].salt_iter;
15171 }
15172
15173 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15174 (innerloop_cnt <= device_param->kernel_loops_max))
15175 {
15176 device_param->kernel_loops_max = innerloop_cnt;
15177 }
15178 }
15179
15180 u32 kernel_accel_min = device_param->kernel_accel_min;
15181 u32 kernel_accel_max = device_param->kernel_accel_max;
15182
15183 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15184
15185 size_t size_pws = 4;
15186 size_t size_tmps = 4;
15187 size_t size_hooks = 4;
15188
15189 while (kernel_accel_max >= kernel_accel_min)
15190 {
15191 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15192
15193 // size_pws
15194
15195 size_pws = kernel_power_max * sizeof (pw_t);
15196
15197 // size_tmps
15198
15199 switch (hash_mode)
15200 {
15201 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15202 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15203 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15204 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15205 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15206 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15207 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15208 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15209 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15210 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15211 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15212 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15213 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15214 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15215 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15216 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15217 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15218 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15219 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15220 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15221 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15222 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15223 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15224 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
15225 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
15226 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
15227 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
15228 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
15229 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15230 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15231 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
15232 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
15233 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15234 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
15235 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15236 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
15237 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
15238 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15239 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15240 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
15241 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
15242 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
15243 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15244 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
15245 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
15246 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
15247 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
15248 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15249 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
15250 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
15251 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
15252 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15253 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15254 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
15255 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
15256 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
15257 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
15258 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
15259 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15260 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15261 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15262 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
15263 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
15264 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15265 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15266 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15267 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15268 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15269 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15270 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15271 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15272 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15273 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15274 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15275 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15276 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15277 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15278 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15279 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15280 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15281 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15282 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15283 };
15284
15285 // size_hooks
15286
15287 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15288 {
15289 switch (hash_mode)
15290 {
15291 }
15292 }
15293
15294 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15295 // if not, decrease amplifier and try again
15296
15297 int skip = 0;
15298
15299 const u64 size_total
15300 = bitmap_size
15301 + bitmap_size
15302 + bitmap_size
15303 + bitmap_size
15304 + bitmap_size
15305 + bitmap_size
15306 + bitmap_size
15307 + bitmap_size
15308 + size_bfs
15309 + size_combs
15310 + size_digests
15311 + size_esalts
15312 + size_hooks
15313 + size_markov_css
15314 + size_plains
15315 + size_pws
15316 + size_pws // not a bug
15317 + size_results
15318 + size_root_css
15319 + size_rules
15320 + size_rules_c
15321 + size_salts
15322 + size_scryptV
15323 + size_shown
15324 + size_tm
15325 + size_tmps;
15326
15327 // Don't ask me, ask AMD!
15328
15329 if (size_total > device_param->device_maxmem_alloc) skip = 1;
15330 if (size_total > device_param->device_global_mem) skip = 1;
15331
15332 if (skip == 1)
15333 {
15334 kernel_accel_max--;
15335
15336 continue;
15337 }
15338
15339 break;
15340 }
15341
15342 /*
15343 if (kernel_accel_max == 0)
15344 {
15345 log_error ("- Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
15346
15347 return -1;
15348 }
15349 */
15350
15351 device_param->kernel_accel_min = kernel_accel_min;
15352 device_param->kernel_accel_max = kernel_accel_max;
15353
15354 /*
15355 if (kernel_accel_max < kernel_accel)
15356 {
15357 if (quiet == 0) log_info ("- Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
15358
15359 device_param->kernel_accel = kernel_accel_max;
15360 }
15361 */
15362
15363 device_param->size_bfs = size_bfs;
15364 device_param->size_combs = size_combs;
15365 device_param->size_rules = size_rules;
15366 device_param->size_rules_c = size_rules_c;
15367 device_param->size_pws = size_pws;
15368 device_param->size_tmps = size_tmps;
15369 device_param->size_hooks = size_hooks;
15370
15371 /**
15372 * default building options
15373 */
15374
15375 char build_opts[1024] = { 0 };
15376
15377 // we don't have sm_* on vendors not NV but it doesn't matter
15378
15379 #if _WIN
15380 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\\OpenCL\\\" -I '%s\\OpenCL\\' -I %s\\OpenCL\\ -I\"%s\\OpenCL\\\" -I'%s\\OpenCL\\' -I%s\\OpenCL\\", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
15381 #else
15382 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s/OpenCL/\" -I '%s/OpenCL/' -I %s/OpenCL/ -I\"%s/OpenCL/\" -I'%s/OpenCL/' -I%s/OpenCL/", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
15383 #endif
15384
15385 char build_opts_new[1024] = { 0 };
15386
15387 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u -DKERN_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);
15388
15389 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
15390
15391 /*
15392 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
15393 {
15394 // we do vectorizing much better than the auto-vectorizer
15395
15396 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
15397
15398 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
15399 }
15400 */
15401
15402 #ifdef DEBUG
15403 log_info ("- Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15404 #endif
15405
15406 /**
15407 * main kernel
15408 */
15409
15410 {
15411 /**
15412 * kernel source filename
15413 */
15414
15415 char source_file[256] = { 0 };
15416
15417 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15418
15419 struct stat sst;
15420
15421 if (stat (source_file, &sst) == -1)
15422 {
15423 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15424
15425 return -1;
15426 }
15427
15428 /**
15429 * kernel cached filename
15430 */
15431
15432 char cached_file[256] = { 0 };
15433
15434 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15435
15436 int cached = 1;
15437
15438 struct stat cst;
15439
15440 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15441 {
15442 cached = 0;
15443 }
15444
15445 /**
15446 * kernel compile or load
15447 */
15448
15449 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15450
15451 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15452
15453 if (force_jit_compilation == -1)
15454 {
15455 if (cached == 0)
15456 {
15457 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));
15458
15459 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15460
15461 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15462
15463 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15464
15465 #ifdef DEBUG
15466 size_t build_log_size = 0;
15467
15468 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15469
15470 if (build_log_size > 1)
15471 {
15472 char *build_log = (char *) malloc (build_log_size + 1);
15473
15474 memset (build_log, 0, build_log_size + 1);
15475
15476 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15477
15478 puts (build_log);
15479
15480 free (build_log);
15481 }
15482 #endif
15483
15484 if (rc != 0)
15485 {
15486 device_param->skipped = true;
15487
15488 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15489
15490 continue;
15491 }
15492
15493 size_t binary_size;
15494
15495 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15496
15497 u8 *binary = (u8 *) mymalloc (binary_size);
15498
15499 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15500
15501 writeProgramBin (cached_file, binary, binary_size);
15502
15503 local_free (binary);
15504 }
15505 else
15506 {
15507 #ifdef DEBUG
15508 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15509 #endif
15510
15511 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15512
15513 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15514
15515 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15516 }
15517 }
15518 else
15519 {
15520 #ifdef DEBUG
15521 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15522 #endif
15523
15524 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15525
15526 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15527
15528 char build_opts_update[1024] = { 0 };
15529
15530 if (force_jit_compilation == 1500)
15531 {
15532 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15533 }
15534 else if (force_jit_compilation == 8900)
15535 {
15536 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);
15537 }
15538 else
15539 {
15540 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15541 }
15542
15543 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15544
15545 #ifdef DEBUG
15546 size_t build_log_size = 0;
15547
15548 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15549
15550 if (build_log_size > 1)
15551 {
15552 char *build_log = (char *) malloc (build_log_size + 1);
15553
15554 memset (build_log, 0, build_log_size + 1);
15555
15556 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15557
15558 puts (build_log);
15559
15560 free (build_log);
15561 }
15562 #endif
15563
15564 if (rc != 0)
15565 {
15566 device_param->skipped = true;
15567
15568 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15569 }
15570 }
15571
15572 local_free (kernel_lengths);
15573 local_free (kernel_sources[0]);
15574 local_free (kernel_sources);
15575 }
15576
15577 /**
15578 * word generator kernel
15579 */
15580
15581 if (attack_mode != ATTACK_MODE_STRAIGHT)
15582 {
15583 /**
15584 * kernel mp source filename
15585 */
15586
15587 char source_file[256] = { 0 };
15588
15589 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15590
15591 struct stat sst;
15592
15593 if (stat (source_file, &sst) == -1)
15594 {
15595 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15596
15597 return -1;
15598 }
15599
15600 /**
15601 * kernel mp cached filename
15602 */
15603
15604 char cached_file[256] = { 0 };
15605
15606 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15607
15608 int cached = 1;
15609
15610 struct stat cst;
15611
15612 if (stat (cached_file, &cst) == -1)
15613 {
15614 cached = 0;
15615 }
15616
15617 /**
15618 * kernel compile or load
15619 */
15620
15621 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15622
15623 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15624
15625 if (cached == 0)
15626 {
15627 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));
15628 if (quiet == 0) log_info ("");
15629
15630 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15631
15632 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15633
15634 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15635
15636 if (rc != 0)
15637 {
15638 device_param->skipped = true;
15639
15640 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15641
15642 continue;
15643 }
15644
15645 size_t binary_size;
15646
15647 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15648
15649 u8 *binary = (u8 *) mymalloc (binary_size);
15650
15651 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15652
15653 writeProgramBin (cached_file, binary, binary_size);
15654
15655 local_free (binary);
15656 }
15657 else
15658 {
15659 #ifdef DEBUG
15660 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15661 #endif
15662
15663 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15664
15665 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15666
15667 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15668 }
15669
15670 local_free (kernel_lengths);
15671 local_free (kernel_sources[0]);
15672 local_free (kernel_sources);
15673 }
15674
15675 /**
15676 * amplifier kernel
15677 */
15678
15679 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15680 {
15681
15682 }
15683 else
15684 {
15685 /**
15686 * kernel amp source filename
15687 */
15688
15689 char source_file[256] = { 0 };
15690
15691 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15692
15693 struct stat sst;
15694
15695 if (stat (source_file, &sst) == -1)
15696 {
15697 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15698
15699 return -1;
15700 }
15701
15702 /**
15703 * kernel amp cached filename
15704 */
15705
15706 char cached_file[256] = { 0 };
15707
15708 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15709
15710 int cached = 1;
15711
15712 struct stat cst;
15713
15714 if (stat (cached_file, &cst) == -1)
15715 {
15716 cached = 0;
15717 }
15718
15719 /**
15720 * kernel compile or load
15721 */
15722
15723 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15724
15725 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15726
15727 if (cached == 0)
15728 {
15729 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));
15730 if (quiet == 0) log_info ("");
15731
15732 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15733
15734 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15735
15736 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15737
15738 if (rc != 0)
15739 {
15740 device_param->skipped = true;
15741
15742 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15743
15744 continue;
15745 }
15746
15747 size_t binary_size;
15748
15749 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15750
15751 u8 *binary = (u8 *) mymalloc (binary_size);
15752
15753 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15754
15755 writeProgramBin (cached_file, binary, binary_size);
15756
15757 local_free (binary);
15758 }
15759 else
15760 {
15761 #ifdef DEBUG
15762 if (quiet == 0) log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15763 #endif
15764
15765 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15766
15767 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15768
15769 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15770 }
15771
15772 local_free (kernel_lengths);
15773 local_free (kernel_sources[0]);
15774 local_free (kernel_sources);
15775 }
15776
15777 // some algorithm collide too fast, make that impossible
15778
15779 if (benchmark == 1)
15780 {
15781 ((uint *) digests_buf)[0] = -1;
15782 ((uint *) digests_buf)[1] = -1;
15783 ((uint *) digests_buf)[2] = -1;
15784 ((uint *) digests_buf)[3] = -1;
15785 }
15786
15787 /**
15788 * global buffers
15789 */
15790
15791 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15792 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15793 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15794 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15795 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15796 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15797 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15798 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15799 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15800 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15801 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15802 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15803 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15804 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15805 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15806 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15807 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15808 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15809
15810 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);
15811 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);
15812 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);
15813 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);
15814 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);
15815 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);
15816 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);
15817 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);
15818 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15819 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15820 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15821
15822 /**
15823 * special buffers
15824 */
15825
15826 if (attack_kern == ATTACK_KERN_STRAIGHT)
15827 {
15828 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15829 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15830
15831 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15832 }
15833 else if (attack_kern == ATTACK_KERN_COMBI)
15834 {
15835 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15836 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15837 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15838 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15839 }
15840 else if (attack_kern == ATTACK_KERN_BF)
15841 {
15842 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15843 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15844 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15845 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15846 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15847 }
15848
15849 if (size_esalts)
15850 {
15851 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15852
15853 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15854 }
15855
15856 /**
15857 * main host data
15858 */
15859
15860 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15861
15862 device_param->pws_buf = pws_buf;
15863
15864 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15865
15866 device_param->combs_buf = combs_buf;
15867
15868 void *hooks_buf = mymalloc (size_hooks);
15869
15870 device_param->hooks_buf = hooks_buf;
15871
15872 /**
15873 * kernel args
15874 */
15875
15876 device_param->kernel_params_buf32[21] = bitmap_mask;
15877 device_param->kernel_params_buf32[22] = bitmap_shift1;
15878 device_param->kernel_params_buf32[23] = bitmap_shift2;
15879 device_param->kernel_params_buf32[24] = 0; // salt_pos
15880 device_param->kernel_params_buf32[25] = 0; // loop_pos
15881 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15882 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15883 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15884 device_param->kernel_params_buf32[29] = 0; // digests_offset
15885 device_param->kernel_params_buf32[30] = 0; // combs_mode
15886 device_param->kernel_params_buf32[31] = 0; // gid_max
15887
15888 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15889 ? &device_param->d_pws_buf
15890 : &device_param->d_pws_amp_buf;
15891 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15892 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15893 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15894 device_param->kernel_params[ 4] = &device_param->d_tmps;
15895 device_param->kernel_params[ 5] = &device_param->d_hooks;
15896 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15897 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15898 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15899 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15900 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15901 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15902 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15903 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15904 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15905 device_param->kernel_params[15] = &device_param->d_digests_buf;
15906 device_param->kernel_params[16] = &device_param->d_digests_shown;
15907 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15908 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15909 device_param->kernel_params[19] = &device_param->d_result;
15910 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15911 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15912 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15913 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15914 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15915 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15916 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15917 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15918 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15919 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15920 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15921 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15922
15923 device_param->kernel_params_mp_buf64[3] = 0;
15924 device_param->kernel_params_mp_buf32[4] = 0;
15925 device_param->kernel_params_mp_buf32[5] = 0;
15926 device_param->kernel_params_mp_buf32[6] = 0;
15927 device_param->kernel_params_mp_buf32[7] = 0;
15928 device_param->kernel_params_mp_buf32[8] = 0;
15929
15930 device_param->kernel_params_mp[0] = NULL;
15931 device_param->kernel_params_mp[1] = NULL;
15932 device_param->kernel_params_mp[2] = NULL;
15933 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15934 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15935 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15936 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15937 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15938 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15939
15940 device_param->kernel_params_mp_l_buf64[3] = 0;
15941 device_param->kernel_params_mp_l_buf32[4] = 0;
15942 device_param->kernel_params_mp_l_buf32[5] = 0;
15943 device_param->kernel_params_mp_l_buf32[6] = 0;
15944 device_param->kernel_params_mp_l_buf32[7] = 0;
15945 device_param->kernel_params_mp_l_buf32[8] = 0;
15946 device_param->kernel_params_mp_l_buf32[9] = 0;
15947
15948 device_param->kernel_params_mp_l[0] = NULL;
15949 device_param->kernel_params_mp_l[1] = NULL;
15950 device_param->kernel_params_mp_l[2] = NULL;
15951 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15952 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15953 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15954 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15955 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15956 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15957 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15958
15959 device_param->kernel_params_mp_r_buf64[3] = 0;
15960 device_param->kernel_params_mp_r_buf32[4] = 0;
15961 device_param->kernel_params_mp_r_buf32[5] = 0;
15962 device_param->kernel_params_mp_r_buf32[6] = 0;
15963 device_param->kernel_params_mp_r_buf32[7] = 0;
15964 device_param->kernel_params_mp_r_buf32[8] = 0;
15965
15966 device_param->kernel_params_mp_r[0] = NULL;
15967 device_param->kernel_params_mp_r[1] = NULL;
15968 device_param->kernel_params_mp_r[2] = NULL;
15969 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15970 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15971 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15972 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15973 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15974 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15975
15976 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15977 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15978
15979 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15980 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15981 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15982 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15983 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15984 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15985 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15986
15987 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15988 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15989
15990 device_param->kernel_params_memset_buf32[1] = 0; // value
15991 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15992
15993 device_param->kernel_params_memset[0] = NULL;
15994 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15995 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15996
15997 /**
15998 * kernel name
15999 */
16000
16001 size_t kernel_wgs_tmp;
16002
16003 char kernel_name[64] = { 0 };
16004
16005 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16006 {
16007 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16008 {
16009 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
16010
16011 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16012
16013 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
16014
16015 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16016
16017 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
16018
16019 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16020 }
16021 else
16022 {
16023 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
16024
16025 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16026
16027 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
16028
16029 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16030
16031 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
16032
16033 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16034 }
16035
16036 if (data.attack_mode == ATTACK_MODE_BF)
16037 {
16038 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16039 {
16040 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
16041
16042 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16043
16044 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);
16045 }
16046 }
16047 }
16048 else
16049 {
16050 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
16051
16052 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16053
16054 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
16055
16056 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16057
16058 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
16059
16060 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16061
16062 if (opts_type & OPTS_TYPE_HOOK12)
16063 {
16064 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
16065
16066 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16067
16068 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);
16069 }
16070
16071 if (opts_type & OPTS_TYPE_HOOK23)
16072 {
16073 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
16074
16075 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16076
16077 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);
16078 }
16079 }
16080
16081 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);
16082 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);
16083 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);
16084
16085 for (uint i = 0; i <= 20; i++)
16086 {
16087 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
16088 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
16089 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
16090
16091 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
16092 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
16093 }
16094
16095 for (uint i = 21; i <= 31; i++)
16096 {
16097 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
16098 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
16099 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
16100
16101 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
16102 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
16103 }
16104
16105 // GPU memset
16106
16107 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
16108
16109 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);
16110
16111 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
16112 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
16113 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
16114
16115 // MP start
16116
16117 if (attack_mode == ATTACK_MODE_BF)
16118 {
16119 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
16120 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
16121
16122 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);
16123 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);
16124
16125 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16126 {
16127 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
16128 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
16129 }
16130 }
16131 else if (attack_mode == ATTACK_MODE_HYBRID1)
16132 {
16133 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16134
16135 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);
16136 }
16137 else if (attack_mode == ATTACK_MODE_HYBRID2)
16138 {
16139 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16140
16141 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);
16142 }
16143
16144 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16145 {
16146 // nothing to do
16147 }
16148 else
16149 {
16150 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
16151
16152 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);
16153 }
16154
16155 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16156 {
16157 // nothing to do
16158 }
16159 else
16160 {
16161 for (uint i = 0; i < 5; i++)
16162 {
16163 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
16164 }
16165
16166 for (uint i = 5; i < 7; i++)
16167 {
16168 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
16169 }
16170 }
16171
16172 // maybe this has been updated by clGetKernelWorkGroupInfo()
16173 // value can only be decreased, so we don't need to reallocate buffers
16174
16175 device_param->kernel_threads = kernel_threads;
16176
16177 // zero some data buffers
16178
16179 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
16180 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
16181 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
16182 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
16183 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
16184 run_kernel_bzero (device_param, device_param->d_result, size_results);
16185
16186 /**
16187 * special buffers
16188 */
16189
16190 if (attack_kern == ATTACK_KERN_STRAIGHT)
16191 {
16192 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
16193 }
16194 else if (attack_kern == ATTACK_KERN_COMBI)
16195 {
16196 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
16197 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
16198 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16199 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16200 }
16201 else if (attack_kern == ATTACK_KERN_BF)
16202 {
16203 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
16204 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
16205 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
16206 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16207 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16208 }
16209
16210 #if defined(HAVE_HWMON)
16211
16212 /**
16213 * Store initial fanspeed if gpu_temp_retain is enabled
16214 */
16215
16216 if (gpu_temp_disable == 0)
16217 {
16218 if (gpu_temp_retain != 0)
16219 {
16220 hc_thread_mutex_lock (mux_adl);
16221
16222 if (data.hm_device[device_id].fan_get_supported == 1)
16223 {
16224 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
16225 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
16226
16227 temp_retain_fanspeed_value[device_id] = fanspeed;
16228 temp_retain_fanpolicy_value[device_id] = fanpolicy;
16229
16230 // we also set it to tell the OS we take control over the fan and it's automatic controller
16231 // if it was set to automatic. we do not control user-defined fanspeeds.
16232
16233 if (fanpolicy == 1)
16234 {
16235 data.hm_device[device_id].fan_set_supported = 1;
16236
16237 int rc = -1;
16238
16239 if (device_param->device_vendor_id == VENDOR_ID_AMD)
16240 {
16241 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
16242 }
16243 else if (device_param->device_vendor_id == VENDOR_ID_NV)
16244 {
16245 #ifdef LINUX
16246 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE);
16247 #endif
16248
16249 #ifdef WIN
16250 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
16251 #endif
16252 }
16253
16254 if (rc == 0)
16255 {
16256 data.hm_device[device_id].fan_set_supported = 1;
16257 }
16258 else
16259 {
16260 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
16261
16262 data.hm_device[device_id].fan_set_supported = 0;
16263 }
16264 }
16265 else
16266 {
16267 data.hm_device[device_id].fan_set_supported = 0;
16268 }
16269 }
16270
16271 hc_thread_mutex_unlock (mux_adl);
16272 }
16273 }
16274
16275 #endif // HAVE_HWMON
16276 }
16277
16278 if (data.quiet == 0) log_info_nn ("");
16279
16280 /**
16281 * In benchmark-mode, inform user which algorithm is checked
16282 */
16283
16284 if (benchmark == 1)
16285 {
16286 if (machine_readable == 0)
16287 {
16288 quiet = 0;
16289
16290 data.quiet = quiet;
16291
16292 char *hash_type = strhashtype (data.hash_mode); // not a bug
16293
16294 log_info ("Hashtype: %s", hash_type);
16295 log_info ("");
16296 }
16297 }
16298
16299 /**
16300 * keep track of the progress
16301 */
16302
16303 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16304 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16305 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16306
16307 /**
16308 * open filehandles
16309 */
16310
16311 #if _WIN
16312 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
16313 {
16314 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
16315
16316 return (-1);
16317 }
16318
16319 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
16320 {
16321 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
16322
16323 return (-1);
16324 }
16325
16326 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
16327 {
16328 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
16329
16330 return (-1);
16331 }
16332 #endif
16333
16334 /**
16335 * dictionary pad
16336 */
16337
16338 segment_size *= (1024 * 1024);
16339
16340 data.segment_size = segment_size;
16341
16342 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
16343
16344 wl_data->buf = (char *) mymalloc (segment_size);
16345 wl_data->avail = segment_size;
16346 wl_data->incr = segment_size;
16347 wl_data->cnt = 0;
16348 wl_data->pos = 0;
16349
16350 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
16351
16352 data.wordlist_mode = wordlist_mode;
16353
16354 cs_t *css_buf = NULL;
16355 uint css_cnt = 0;
16356 uint dictcnt = 0;
16357 uint maskcnt = 1;
16358 char **masks = NULL;
16359 char **dictfiles = NULL;
16360
16361 uint mask_from_file = 0;
16362
16363 if (attack_mode == ATTACK_MODE_STRAIGHT)
16364 {
16365 if (wordlist_mode == WL_MODE_FILE)
16366 {
16367 int wls_left = myargc - (optind + 1);
16368
16369 for (int i = 0; i < wls_left; i++)
16370 {
16371 char *l0_filename = myargv[optind + 1 + i];
16372
16373 struct stat l0_stat;
16374
16375 if (stat (l0_filename, &l0_stat) == -1)
16376 {
16377 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
16378
16379 return (-1);
16380 }
16381
16382 uint is_dir = S_ISDIR (l0_stat.st_mode);
16383
16384 if (is_dir == 0)
16385 {
16386 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16387
16388 dictcnt++;
16389
16390 dictfiles[dictcnt - 1] = l0_filename;
16391 }
16392 else
16393 {
16394 // do not allow --keyspace w/ a directory
16395
16396 if (keyspace == 1)
16397 {
16398 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16399
16400 return (-1);
16401 }
16402
16403 char **dictionary_files = NULL;
16404
16405 dictionary_files = scan_directory (l0_filename);
16406
16407 if (dictionary_files != NULL)
16408 {
16409 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16410
16411 for (int d = 0; dictionary_files[d] != NULL; d++)
16412 {
16413 char *l1_filename = dictionary_files[d];
16414
16415 struct stat l1_stat;
16416
16417 if (stat (l1_filename, &l1_stat) == -1)
16418 {
16419 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16420
16421 return (-1);
16422 }
16423
16424 if (S_ISREG (l1_stat.st_mode))
16425 {
16426 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16427
16428 dictcnt++;
16429
16430 dictfiles[dictcnt - 1] = strdup (l1_filename);
16431 }
16432 }
16433 }
16434
16435 local_free (dictionary_files);
16436 }
16437 }
16438
16439 if (dictcnt < 1)
16440 {
16441 log_error ("ERROR: No usable dictionary file found.");
16442
16443 return (-1);
16444 }
16445 }
16446 else if (wordlist_mode == WL_MODE_STDIN)
16447 {
16448 dictcnt = 1;
16449 }
16450 }
16451 else if (attack_mode == ATTACK_MODE_COMBI)
16452 {
16453 // display
16454
16455 char *dictfile1 = myargv[optind + 1 + 0];
16456 char *dictfile2 = myargv[optind + 1 + 1];
16457
16458 // find the bigger dictionary and use as base
16459
16460 FILE *fp1 = NULL;
16461 FILE *fp2 = NULL;
16462
16463 struct stat tmp_stat;
16464
16465 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16466 {
16467 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16468
16469 return (-1);
16470 }
16471
16472 if (stat (dictfile1, &tmp_stat) == -1)
16473 {
16474 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16475
16476 fclose (fp1);
16477
16478 return (-1);
16479 }
16480
16481 if (S_ISDIR (tmp_stat.st_mode))
16482 {
16483 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16484
16485 fclose (fp1);
16486
16487 return (-1);
16488 }
16489
16490 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16491 {
16492 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16493
16494 fclose (fp1);
16495
16496 return (-1);
16497 }
16498
16499 if (stat (dictfile2, &tmp_stat) == -1)
16500 {
16501 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16502
16503 fclose (fp1);
16504 fclose (fp2);
16505
16506 return (-1);
16507 }
16508
16509 if (S_ISDIR (tmp_stat.st_mode))
16510 {
16511 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16512
16513 fclose (fp1);
16514 fclose (fp2);
16515
16516 return (-1);
16517 }
16518
16519 data.combs_cnt = 1;
16520
16521 data.quiet = 1;
16522
16523 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16524
16525 data.quiet = quiet;
16526
16527 if (words1_cnt == 0)
16528 {
16529 log_error ("ERROR: %s: empty file", dictfile1);
16530
16531 fclose (fp1);
16532 fclose (fp2);
16533
16534 return (-1);
16535 }
16536
16537 data.combs_cnt = 1;
16538
16539 data.quiet = 1;
16540
16541 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16542
16543 data.quiet = quiet;
16544
16545 if (words2_cnt == 0)
16546 {
16547 log_error ("ERROR: %s: empty file", dictfile2);
16548
16549 fclose (fp1);
16550 fclose (fp2);
16551
16552 return (-1);
16553 }
16554
16555 fclose (fp1);
16556 fclose (fp2);
16557
16558 data.dictfile = dictfile1;
16559 data.dictfile2 = dictfile2;
16560
16561 if (words1_cnt >= words2_cnt)
16562 {
16563 data.combs_cnt = words2_cnt;
16564 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16565
16566 dictfiles = &data.dictfile;
16567
16568 dictcnt = 1;
16569 }
16570 else
16571 {
16572 data.combs_cnt = words1_cnt;
16573 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16574
16575 dictfiles = &data.dictfile2;
16576
16577 dictcnt = 1;
16578
16579 // we also have to switch wordlist related rules!
16580
16581 char *tmpc = data.rule_buf_l;
16582
16583 data.rule_buf_l = data.rule_buf_r;
16584 data.rule_buf_r = tmpc;
16585
16586 int tmpi = data.rule_len_l;
16587
16588 data.rule_len_l = data.rule_len_r;
16589 data.rule_len_r = tmpi;
16590 }
16591 }
16592 else if (attack_mode == ATTACK_MODE_BF)
16593 {
16594 char *mask = NULL;
16595
16596 maskcnt = 0;
16597
16598 if (benchmark == 0)
16599 {
16600 mask = myargv[optind + 1];
16601
16602 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16603
16604 if ((optind + 2) <= myargc)
16605 {
16606 struct stat file_stat;
16607
16608 if (stat (mask, &file_stat) == -1)
16609 {
16610 maskcnt = 1;
16611
16612 masks[maskcnt - 1] = mystrdup (mask);
16613 }
16614 else
16615 {
16616 int wls_left = myargc - (optind + 1);
16617
16618 uint masks_avail = INCR_MASKS;
16619
16620 for (int i = 0; i < wls_left; i++)
16621 {
16622 if (i != 0)
16623 {
16624 mask = myargv[optind + 1 + i];
16625
16626 if (stat (mask, &file_stat) == -1)
16627 {
16628 log_error ("ERROR: %s: %s", mask, strerror (errno));
16629
16630 return (-1);
16631 }
16632 }
16633
16634 uint is_file = S_ISREG (file_stat.st_mode);
16635
16636 if (is_file == 1)
16637 {
16638 FILE *mask_fp;
16639
16640 if ((mask_fp = fopen (mask, "r")) == NULL)
16641 {
16642 log_error ("ERROR: %s: %s", mask, strerror (errno));
16643
16644 return (-1);
16645 }
16646
16647 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16648
16649 while (!feof (mask_fp))
16650 {
16651 memset (line_buf, 0, HCBUFSIZ);
16652
16653 int line_len = fgetl (mask_fp, line_buf);
16654
16655 if (line_len == 0) continue;
16656
16657 if (line_buf[0] == '#') continue;
16658
16659 if (masks_avail == maskcnt)
16660 {
16661 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16662
16663 masks_avail += INCR_MASKS;
16664 }
16665
16666 masks[maskcnt] = mystrdup (line_buf);
16667
16668 maskcnt++;
16669 }
16670
16671 myfree (line_buf);
16672
16673 fclose (mask_fp);
16674 }
16675 else
16676 {
16677 log_error ("ERROR: %s: unsupported file-type", mask);
16678
16679 return (-1);
16680 }
16681 }
16682
16683 mask_from_file = 1;
16684 }
16685 }
16686 else
16687 {
16688 custom_charset_1 = (char *) "?l?d?u";
16689 custom_charset_2 = (char *) "?l?d";
16690 custom_charset_3 = (char *) "?l?d*!$@_";
16691
16692 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16693 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16694 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16695
16696 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16697
16698 wordlist_mode = WL_MODE_MASK;
16699
16700 data.wordlist_mode = wordlist_mode;
16701
16702 increment = 1;
16703
16704 maskcnt = 1;
16705 }
16706 }
16707 else
16708 {
16709 /**
16710 * generate full masks and charsets
16711 */
16712
16713 masks = (char **) mymalloc (sizeof (char *));
16714
16715 switch (hash_mode)
16716 {
16717 case 1731: pw_min = 5;
16718 pw_max = 5;
16719 mask = mystrdup ("?b?b?b?b?b");
16720 break;
16721 case 12500: pw_min = 5;
16722 pw_max = 5;
16723 mask = mystrdup ("?b?b?b?b?b");
16724 break;
16725 default: pw_min = 7;
16726 pw_max = 7;
16727 mask = mystrdup ("?b?b?b?b?b?b?b");
16728 break;
16729 }
16730
16731 maskcnt = 1;
16732
16733 masks[maskcnt - 1] = mystrdup (mask);
16734
16735 wordlist_mode = WL_MODE_MASK;
16736
16737 data.wordlist_mode = wordlist_mode;
16738
16739 increment = 1;
16740 }
16741
16742 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16743
16744 if (increment)
16745 {
16746 if (increment_min > pw_min) pw_min = increment_min;
16747
16748 if (increment_max < pw_max) pw_max = increment_max;
16749 }
16750 }
16751 else if (attack_mode == ATTACK_MODE_HYBRID1)
16752 {
16753 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16754
16755 // display
16756
16757 char *mask = myargv[myargc - 1];
16758
16759 maskcnt = 0;
16760
16761 masks = (char **) mymalloc (1 * sizeof (char *));
16762
16763 // mod
16764
16765 struct stat file_stat;
16766
16767 if (stat (mask, &file_stat) == -1)
16768 {
16769 maskcnt = 1;
16770
16771 masks[maskcnt - 1] = mystrdup (mask);
16772 }
16773 else
16774 {
16775 uint is_file = S_ISREG (file_stat.st_mode);
16776
16777 if (is_file == 1)
16778 {
16779 FILE *mask_fp;
16780
16781 if ((mask_fp = fopen (mask, "r")) == NULL)
16782 {
16783 log_error ("ERROR: %s: %s", mask, strerror (errno));
16784
16785 return (-1);
16786 }
16787
16788 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16789
16790 uint masks_avail = 1;
16791
16792 while (!feof (mask_fp))
16793 {
16794 memset (line_buf, 0, HCBUFSIZ);
16795
16796 int line_len = fgetl (mask_fp, line_buf);
16797
16798 if (line_len == 0) continue;
16799
16800 if (line_buf[0] == '#') continue;
16801
16802 if (masks_avail == maskcnt)
16803 {
16804 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16805
16806 masks_avail += INCR_MASKS;
16807 }
16808
16809 masks[maskcnt] = mystrdup (line_buf);
16810
16811 maskcnt++;
16812 }
16813
16814 myfree (line_buf);
16815
16816 fclose (mask_fp);
16817
16818 mask_from_file = 1;
16819 }
16820 else
16821 {
16822 maskcnt = 1;
16823
16824 masks[maskcnt - 1] = mystrdup (mask);
16825 }
16826 }
16827
16828 // base
16829
16830 int wls_left = myargc - (optind + 2);
16831
16832 for (int i = 0; i < wls_left; i++)
16833 {
16834 char *filename = myargv[optind + 1 + i];
16835
16836 struct stat file_stat;
16837
16838 if (stat (filename, &file_stat) == -1)
16839 {
16840 log_error ("ERROR: %s: %s", filename, strerror (errno));
16841
16842 return (-1);
16843 }
16844
16845 uint is_dir = S_ISDIR (file_stat.st_mode);
16846
16847 if (is_dir == 0)
16848 {
16849 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16850
16851 dictcnt++;
16852
16853 dictfiles[dictcnt - 1] = filename;
16854 }
16855 else
16856 {
16857 // do not allow --keyspace w/ a directory
16858
16859 if (keyspace == 1)
16860 {
16861 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16862
16863 return (-1);
16864 }
16865
16866 char **dictionary_files = NULL;
16867
16868 dictionary_files = scan_directory (filename);
16869
16870 if (dictionary_files != NULL)
16871 {
16872 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16873
16874 for (int d = 0; dictionary_files[d] != NULL; d++)
16875 {
16876 char *l1_filename = dictionary_files[d];
16877
16878 struct stat l1_stat;
16879
16880 if (stat (l1_filename, &l1_stat) == -1)
16881 {
16882 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16883
16884 return (-1);
16885 }
16886
16887 if (S_ISREG (l1_stat.st_mode))
16888 {
16889 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16890
16891 dictcnt++;
16892
16893 dictfiles[dictcnt - 1] = strdup (l1_filename);
16894 }
16895 }
16896 }
16897
16898 local_free (dictionary_files);
16899 }
16900 }
16901
16902 if (dictcnt < 1)
16903 {
16904 log_error ("ERROR: No usable dictionary file found.");
16905
16906 return (-1);
16907 }
16908
16909 if (increment)
16910 {
16911 maskcnt = 0;
16912
16913 uint mask_min = increment_min; // we can't reject smaller masks here
16914 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16915
16916 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16917 {
16918 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16919
16920 if (cur_mask == NULL) break;
16921
16922 masks[maskcnt] = cur_mask;
16923
16924 maskcnt++;
16925
16926 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16927 }
16928 }
16929 }
16930 else if (attack_mode == ATTACK_MODE_HYBRID2)
16931 {
16932 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16933
16934 // display
16935
16936 char *mask = myargv[optind + 1 + 0];
16937
16938 maskcnt = 0;
16939
16940 masks = (char **) mymalloc (1 * sizeof (char *));
16941
16942 // mod
16943
16944 struct stat file_stat;
16945
16946 if (stat (mask, &file_stat) == -1)
16947 {
16948 maskcnt = 1;
16949
16950 masks[maskcnt - 1] = mystrdup (mask);
16951 }
16952 else
16953 {
16954 uint is_file = S_ISREG (file_stat.st_mode);
16955
16956 if (is_file == 1)
16957 {
16958 FILE *mask_fp;
16959
16960 if ((mask_fp = fopen (mask, "r")) == NULL)
16961 {
16962 log_error ("ERROR: %s: %s", mask, strerror (errno));
16963
16964 return (-1);
16965 }
16966
16967 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16968
16969 uint masks_avail = 1;
16970
16971 while (!feof (mask_fp))
16972 {
16973 memset (line_buf, 0, HCBUFSIZ);
16974
16975 int line_len = fgetl (mask_fp, line_buf);
16976
16977 if (line_len == 0) continue;
16978
16979 if (line_buf[0] == '#') continue;
16980
16981 if (masks_avail == maskcnt)
16982 {
16983 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16984
16985 masks_avail += INCR_MASKS;
16986 }
16987
16988 masks[maskcnt] = mystrdup (line_buf);
16989
16990 maskcnt++;
16991 }
16992
16993 myfree (line_buf);
16994
16995 fclose (mask_fp);
16996
16997 mask_from_file = 1;
16998 }
16999 else
17000 {
17001 maskcnt = 1;
17002
17003 masks[maskcnt - 1] = mystrdup (mask);
17004 }
17005 }
17006
17007 // base
17008
17009 int wls_left = myargc - (optind + 2);
17010
17011 for (int i = 0; i < wls_left; i++)
17012 {
17013 char *filename = myargv[optind + 2 + i];
17014
17015 struct stat file_stat;
17016
17017 if (stat (filename, &file_stat) == -1)
17018 {
17019 log_error ("ERROR: %s: %s", filename, strerror (errno));
17020
17021 return (-1);
17022 }
17023
17024 uint is_dir = S_ISDIR (file_stat.st_mode);
17025
17026 if (is_dir == 0)
17027 {
17028 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17029
17030 dictcnt++;
17031
17032 dictfiles[dictcnt - 1] = filename;
17033 }
17034 else
17035 {
17036 // do not allow --keyspace w/ a directory
17037
17038 if (keyspace == 1)
17039 {
17040 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
17041
17042 return (-1);
17043 }
17044
17045 char **dictionary_files = NULL;
17046
17047 dictionary_files = scan_directory (filename);
17048
17049 if (dictionary_files != NULL)
17050 {
17051 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17052
17053 for (int d = 0; dictionary_files[d] != NULL; d++)
17054 {
17055 char *l1_filename = dictionary_files[d];
17056
17057 struct stat l1_stat;
17058
17059 if (stat (l1_filename, &l1_stat) == -1)
17060 {
17061 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17062
17063 return (-1);
17064 }
17065
17066 if (S_ISREG (l1_stat.st_mode))
17067 {
17068 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17069
17070 dictcnt++;
17071
17072 dictfiles[dictcnt - 1] = strdup (l1_filename);
17073 }
17074 }
17075 }
17076
17077 local_free (dictionary_files);
17078 }
17079 }
17080
17081 if (dictcnt < 1)
17082 {
17083 log_error ("ERROR: No usable dictionary file found.");
17084
17085 return (-1);
17086 }
17087
17088 if (increment)
17089 {
17090 maskcnt = 0;
17091
17092 uint mask_min = increment_min; // we can't reject smaller masks here
17093 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17094
17095 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17096 {
17097 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17098
17099 if (cur_mask == NULL) break;
17100
17101 masks[maskcnt] = cur_mask;
17102
17103 maskcnt++;
17104
17105 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17106 }
17107 }
17108 }
17109
17110 data.pw_min = pw_min;
17111 data.pw_max = pw_max;
17112
17113 /**
17114 * weak hash check
17115 */
17116
17117 if (weak_hash_threshold >= salts_cnt)
17118 {
17119 hc_device_param_t *device_param = NULL;
17120
17121 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17122 {
17123 device_param = &data.devices_param[device_id];
17124
17125 if (device_param->skipped) continue;
17126
17127 break;
17128 }
17129
17130 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
17131
17132 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
17133 {
17134 weak_hash_check (device_param, salt_pos);
17135 }
17136
17137 // Display hack, guarantee that there is at least one \r before real start
17138
17139 //if (data.quiet == 0) log_info ("");
17140 }
17141
17142 /**
17143 * status and monitor threads
17144 */
17145
17146 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
17147
17148 uint i_threads_cnt = 0;
17149
17150 hc_thread_t *i_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17151
17152 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17153 {
17154 if (stdout_flag == 0)
17155 {
17156 hc_thread_create (i_threads[i_threads_cnt], thread_keypress, &benchmark);
17157
17158 i_threads_cnt++;
17159 }
17160 }
17161
17162 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
17163
17164 uint ni_threads_cnt = 0;
17165
17166 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17167
17168 if (stdout_flag == 0)
17169 {
17170 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
17171
17172 ni_threads_cnt++;
17173 }
17174
17175 /**
17176 * Outfile remove
17177 */
17178
17179 if (keyspace == 0)
17180 {
17181 if (outfile_check_timer != 0)
17182 {
17183 if (data.outfile_check_directory != NULL)
17184 {
17185 if ((hash_mode != 5200) &&
17186 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
17187 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
17188 (hash_mode != 9000))
17189 {
17190 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
17191
17192 ni_threads_cnt++;
17193 }
17194 else
17195 {
17196 outfile_check_timer = 0;
17197 }
17198 }
17199 else
17200 {
17201 outfile_check_timer = 0;
17202 }
17203 }
17204 }
17205
17206 /**
17207 * Inform the user if we got some hashes remove because of the pot file remove feature
17208 */
17209
17210 if (data.quiet == 0)
17211 {
17212 if (potfile_remove_cracks > 0)
17213 {
17214 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
17215 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
17216 }
17217 }
17218
17219 data.outfile_check_timer = outfile_check_timer;
17220
17221 /**
17222 * main loop
17223 */
17224
17225 char **induction_dictionaries = NULL;
17226
17227 int induction_dictionaries_cnt = 0;
17228
17229 hcstat_table_t *root_table_buf = NULL;
17230 hcstat_table_t *markov_table_buf = NULL;
17231
17232 uint initial_restore_done = 0;
17233
17234 data.maskcnt = maskcnt;
17235
17236 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
17237 {
17238 if (data.devices_status == STATUS_CRACKED) break;
17239
17240 data.devices_status = STATUS_INIT;
17241
17242 if (maskpos > rd->maskpos)
17243 {
17244 rd->dictpos = 0;
17245 }
17246
17247 rd->maskpos = maskpos;
17248 data.maskpos = maskpos;
17249
17250 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
17251 {
17252 char *mask = masks[maskpos];
17253
17254 if (mask_from_file == 1)
17255 {
17256 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
17257
17258 char *str_ptr;
17259 uint str_pos;
17260
17261 uint mask_offset = 0;
17262
17263 uint separator_cnt;
17264
17265 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
17266 {
17267 str_ptr = strstr (mask + mask_offset, ",");
17268
17269 if (str_ptr == NULL) break;
17270
17271 str_pos = str_ptr - mask;
17272
17273 // escaped separator, i.e. "\,"
17274
17275 if (str_pos > 0)
17276 {
17277 if (mask[str_pos - 1] == '\\')
17278 {
17279 separator_cnt --;
17280
17281 mask_offset = str_pos + 1;
17282
17283 continue;
17284 }
17285 }
17286
17287 // reset the offset
17288
17289 mask_offset = 0;
17290
17291 mask[str_pos] = '\0';
17292
17293 switch (separator_cnt)
17294 {
17295 case 0:
17296 mp_reset_usr (mp_usr, 0);
17297
17298 custom_charset_1 = mask;
17299 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17300 break;
17301
17302 case 1:
17303 mp_reset_usr (mp_usr, 1);
17304
17305 custom_charset_2 = mask;
17306 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17307 break;
17308
17309 case 2:
17310 mp_reset_usr (mp_usr, 2);
17311
17312 custom_charset_3 = mask;
17313 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17314 break;
17315
17316 case 3:
17317 mp_reset_usr (mp_usr, 3);
17318
17319 custom_charset_4 = mask;
17320 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
17321 break;
17322 }
17323
17324 mask = mask + str_pos + 1;
17325 }
17326 }
17327
17328 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17329 {
17330 if (maskpos > 0)
17331 {
17332 local_free (css_buf);
17333 local_free (data.root_css_buf);
17334 local_free (data.markov_css_buf);
17335
17336 local_free (masks[maskpos - 1]);
17337 }
17338
17339 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17340
17341 data.mask = mask;
17342 data.css_cnt = css_cnt;
17343 data.css_buf = css_buf;
17344
17345 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17346
17347 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17348
17349 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17350 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17351
17352 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17353
17354 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17355
17356 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17357 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17358
17359 data.root_css_buf = root_css_buf;
17360 data.markov_css_buf = markov_css_buf;
17361
17362 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17363
17364 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17365
17366 local_free (root_table_buf);
17367 local_free (markov_table_buf);
17368
17369 // args
17370
17371 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17372 {
17373 hc_device_param_t *device_param = &data.devices_param[device_id];
17374
17375 if (device_param->skipped) continue;
17376
17377 device_param->kernel_params_mp[0] = &device_param->d_combs;
17378 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
17379 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
17380
17381 device_param->kernel_params_mp_buf64[3] = 0;
17382 device_param->kernel_params_mp_buf32[4] = css_cnt;
17383 device_param->kernel_params_mp_buf32[5] = 0;
17384 device_param->kernel_params_mp_buf32[6] = 0;
17385 device_param->kernel_params_mp_buf32[7] = 0;
17386
17387 if (attack_mode == ATTACK_MODE_HYBRID1)
17388 {
17389 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
17390 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
17391 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
17392 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
17393 }
17394 else if (attack_mode == ATTACK_MODE_HYBRID2)
17395 {
17396 device_param->kernel_params_mp_buf32[5] = 0;
17397 device_param->kernel_params_mp_buf32[6] = 0;
17398 device_param->kernel_params_mp_buf32[7] = 0;
17399 }
17400
17401 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]);
17402 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]);
17403 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]);
17404
17405 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);
17406 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);
17407 }
17408 }
17409 else if (attack_mode == ATTACK_MODE_BF)
17410 {
17411 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
17412
17413 if (increment)
17414 {
17415 for (uint i = 0; i < dictcnt; i++)
17416 {
17417 local_free (dictfiles[i]);
17418 }
17419
17420 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17421 {
17422 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17423
17424 if (l1_filename == NULL) break;
17425
17426 dictcnt++;
17427
17428 dictfiles[dictcnt - 1] = l1_filename;
17429 }
17430 }
17431 else
17432 {
17433 dictcnt++;
17434
17435 dictfiles[dictcnt - 1] = mask;
17436 }
17437
17438 if (dictcnt == 0)
17439 {
17440 log_error ("ERROR: Mask is too small");
17441
17442 return (-1);
17443 }
17444 }
17445 }
17446
17447 free (induction_dictionaries);
17448
17449 // induction_dictionaries_cnt = 0; // implied
17450
17451 if (attack_mode != ATTACK_MODE_BF)
17452 {
17453 if (keyspace == 0)
17454 {
17455 induction_dictionaries = scan_directory (induction_directory);
17456
17457 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17458 }
17459 }
17460
17461 if (induction_dictionaries_cnt)
17462 {
17463 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17464 }
17465
17466 /**
17467 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17468 */
17469 if (keyspace == 1)
17470 {
17471 if ((maskcnt > 1) || (dictcnt > 1))
17472 {
17473 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17474
17475 return (-1);
17476 }
17477 }
17478
17479 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17480 {
17481 char *subid = logfile_generate_subid ();
17482
17483 data.subid = subid;
17484
17485 logfile_sub_msg ("START");
17486
17487 data.devices_status = STATUS_INIT;
17488
17489 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17490 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17491 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17492
17493 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17494
17495 data.cpt_pos = 0;
17496
17497 data.cpt_start = time (NULL);
17498
17499 data.cpt_total = 0;
17500
17501 if (data.restore == 0)
17502 {
17503 rd->words_cur = skip;
17504
17505 skip = 0;
17506
17507 data.skip = 0;
17508 }
17509
17510 data.ms_paused = 0;
17511
17512 data.kernel_power_final = 0;
17513
17514 data.words_cur = rd->words_cur;
17515
17516 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17517 {
17518 hc_device_param_t *device_param = &data.devices_param[device_id];
17519
17520 if (device_param->skipped) continue;
17521
17522 device_param->speed_pos = 0;
17523
17524 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17525 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17526
17527 device_param->exec_pos = 0;
17528
17529 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17530
17531 device_param->outerloop_pos = 0;
17532 device_param->outerloop_left = 0;
17533 device_param->innerloop_pos = 0;
17534 device_param->innerloop_left = 0;
17535
17536 // some more resets:
17537
17538 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17539
17540 device_param->pws_cnt = 0;
17541
17542 device_param->words_off = 0;
17543 device_param->words_done = 0;
17544 }
17545
17546 // figure out some workload
17547
17548 if (attack_mode == ATTACK_MODE_STRAIGHT)
17549 {
17550 if (data.wordlist_mode == WL_MODE_FILE)
17551 {
17552 char *dictfile = NULL;
17553
17554 if (induction_dictionaries_cnt)
17555 {
17556 dictfile = induction_dictionaries[0];
17557 }
17558 else
17559 {
17560 dictfile = dictfiles[dictpos];
17561 }
17562
17563 data.dictfile = dictfile;
17564
17565 logfile_sub_string (dictfile);
17566
17567 for (uint i = 0; i < rp_files_cnt; i++)
17568 {
17569 logfile_sub_var_string ("rulefile", rp_files[i]);
17570 }
17571
17572 FILE *fd2 = fopen (dictfile, "rb");
17573
17574 if (fd2 == NULL)
17575 {
17576 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17577
17578 return (-1);
17579 }
17580
17581 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17582
17583 fclose (fd2);
17584
17585 if (data.words_cnt == 0)
17586 {
17587 if (data.devices_status == STATUS_CRACKED) break;
17588 if (data.devices_status == STATUS_ABORTED) break;
17589
17590 dictpos++;
17591
17592 continue;
17593 }
17594 }
17595 }
17596 else if (attack_mode == ATTACK_MODE_COMBI)
17597 {
17598 char *dictfile = data.dictfile;
17599 char *dictfile2 = data.dictfile2;
17600
17601 logfile_sub_string (dictfile);
17602 logfile_sub_string (dictfile2);
17603
17604 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17605 {
17606 FILE *fd2 = fopen (dictfile, "rb");
17607
17608 if (fd2 == NULL)
17609 {
17610 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17611
17612 return (-1);
17613 }
17614
17615 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17616
17617 fclose (fd2);
17618 }
17619 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17620 {
17621 FILE *fd2 = fopen (dictfile2, "rb");
17622
17623 if (fd2 == NULL)
17624 {
17625 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17626
17627 return (-1);
17628 }
17629
17630 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17631
17632 fclose (fd2);
17633 }
17634
17635 if (data.words_cnt == 0)
17636 {
17637 if (data.devices_status == STATUS_CRACKED) break;
17638 if (data.devices_status == STATUS_ABORTED) break;
17639
17640 dictpos++;
17641
17642 continue;
17643 }
17644 }
17645 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17646 {
17647 char *dictfile = NULL;
17648
17649 if (induction_dictionaries_cnt)
17650 {
17651 dictfile = induction_dictionaries[0];
17652 }
17653 else
17654 {
17655 dictfile = dictfiles[dictpos];
17656 }
17657
17658 data.dictfile = dictfile;
17659
17660 char *mask = data.mask;
17661
17662 logfile_sub_string (dictfile);
17663 logfile_sub_string (mask);
17664
17665 FILE *fd2 = fopen (dictfile, "rb");
17666
17667 if (fd2 == NULL)
17668 {
17669 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17670
17671 return (-1);
17672 }
17673
17674 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17675
17676 fclose (fd2);
17677
17678 if (data.words_cnt == 0)
17679 {
17680 if (data.devices_status == STATUS_CRACKED) break;
17681 if (data.devices_status == STATUS_ABORTED) break;
17682
17683 dictpos++;
17684
17685 continue;
17686 }
17687 }
17688 else if (attack_mode == ATTACK_MODE_BF)
17689 {
17690 local_free (css_buf);
17691 local_free (data.root_css_buf);
17692 local_free (data.markov_css_buf);
17693
17694 char *mask = dictfiles[dictpos];
17695
17696 logfile_sub_string (mask);
17697
17698 // base
17699
17700 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17701
17702 if (opts_type & OPTS_TYPE_PT_UNICODE)
17703 {
17704 uint css_cnt_unicode = css_cnt * 2;
17705
17706 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17707
17708 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17709 {
17710 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17711
17712 css_buf_unicode[j + 1].cs_buf[0] = 0;
17713 css_buf_unicode[j + 1].cs_len = 1;
17714 }
17715
17716 free (css_buf);
17717
17718 css_buf = css_buf_unicode;
17719 css_cnt = css_cnt_unicode;
17720 }
17721
17722 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17723
17724 uint mask_min = pw_min;
17725 uint mask_max = pw_max;
17726
17727 if (opts_type & OPTS_TYPE_PT_UNICODE)
17728 {
17729 mask_min *= 2;
17730 mask_max *= 2;
17731 }
17732
17733 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17734 {
17735 if (css_cnt < mask_min)
17736 {
17737 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17738 }
17739
17740 if (css_cnt > mask_max)
17741 {
17742 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17743 }
17744
17745 // skip to next mask
17746
17747 dictpos++;
17748
17749 rd->dictpos = dictpos;
17750
17751 logfile_sub_msg ("STOP");
17752
17753 continue;
17754 }
17755
17756 uint save_css_cnt = css_cnt;
17757
17758 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17759 {
17760 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17761 {
17762 uint salt_len = (uint) data.salts_buf[0].salt_len;
17763 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17764
17765 uint css_cnt_salt = css_cnt + salt_len;
17766
17767 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17768
17769 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17770
17771 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17772 {
17773 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17774 css_buf_salt[j].cs_len = 1;
17775 }
17776
17777 free (css_buf);
17778
17779 css_buf = css_buf_salt;
17780 css_cnt = css_cnt_salt;
17781 }
17782 }
17783
17784 data.mask = mask;
17785 data.css_cnt = css_cnt;
17786 data.css_buf = css_buf;
17787
17788 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17789
17790 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17791
17792 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17793
17794 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17795 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17796
17797 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17798
17799 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17800
17801 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17802 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17803
17804 data.root_css_buf = root_css_buf;
17805 data.markov_css_buf = markov_css_buf;
17806
17807 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17808
17809 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17810
17811 local_free (root_table_buf);
17812 local_free (markov_table_buf);
17813
17814 // copy + args
17815
17816 uint css_cnt_l = css_cnt;
17817 uint css_cnt_r;
17818
17819 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17820 {
17821 if (save_css_cnt < 6)
17822 {
17823 css_cnt_r = 1;
17824 }
17825 else if (save_css_cnt == 6)
17826 {
17827 css_cnt_r = 2;
17828 }
17829 else
17830 {
17831 if (opts_type & OPTS_TYPE_PT_UNICODE)
17832 {
17833 if (save_css_cnt == 8 || save_css_cnt == 10)
17834 {
17835 css_cnt_r = 2;
17836 }
17837 else
17838 {
17839 css_cnt_r = 4;
17840 }
17841 }
17842 else
17843 {
17844 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17845 {
17846 css_cnt_r = 3;
17847 }
17848 else
17849 {
17850 css_cnt_r = 4;
17851 }
17852 }
17853 }
17854 }
17855 else
17856 {
17857 css_cnt_r = 1;
17858
17859 /* unfinished code?
17860 int sum = css_buf[css_cnt_r - 1].cs_len;
17861
17862 for (uint i = 1; i < 4 && i < css_cnt; i++)
17863 {
17864 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17865
17866 css_cnt_r++;
17867
17868 sum *= css_buf[css_cnt_r - 1].cs_len;
17869 }
17870 */
17871 }
17872
17873 css_cnt_l -= css_cnt_r;
17874
17875 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17876
17877 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17878 {
17879 hc_device_param_t *device_param = &data.devices_param[device_id];
17880
17881 if (device_param->skipped) continue;
17882
17883 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17884 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17885 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17886
17887 device_param->kernel_params_mp_l_buf64[3] = 0;
17888 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17889 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17890 device_param->kernel_params_mp_l_buf32[6] = 0;
17891 device_param->kernel_params_mp_l_buf32[7] = 0;
17892 device_param->kernel_params_mp_l_buf32[8] = 0;
17893
17894 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17895 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17896 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17897 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17898
17899 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17900 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17901 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17902
17903 device_param->kernel_params_mp_r_buf64[3] = 0;
17904 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17905 device_param->kernel_params_mp_r_buf32[5] = 0;
17906 device_param->kernel_params_mp_r_buf32[6] = 0;
17907 device_param->kernel_params_mp_r_buf32[7] = 0;
17908
17909 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]);
17910 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]);
17911 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]);
17912
17913 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]);
17914 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]);
17915 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]);
17916
17917 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);
17918 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);
17919 }
17920 }
17921
17922 u64 words_base = data.words_cnt;
17923
17924 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17925 {
17926 if (data.kernel_rules_cnt)
17927 {
17928 words_base /= data.kernel_rules_cnt;
17929 }
17930 }
17931 else if (data.attack_kern == ATTACK_KERN_COMBI)
17932 {
17933 if (data.combs_cnt)
17934 {
17935 words_base /= data.combs_cnt;
17936 }
17937 }
17938 else if (data.attack_kern == ATTACK_KERN_BF)
17939 {
17940 if (data.bfs_cnt)
17941 {
17942 words_base /= data.bfs_cnt;
17943 }
17944 }
17945
17946 data.words_base = words_base;
17947
17948 if (keyspace == 1)
17949 {
17950 log_info ("%llu", (unsigned long long int) words_base);
17951
17952 return (0);
17953 }
17954
17955 if (data.words_cur > data.words_base)
17956 {
17957 log_error ("ERROR: restore value greater keyspace");
17958
17959 return (-1);
17960 }
17961
17962 if (data.words_cur)
17963 {
17964 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17965 {
17966 for (uint i = 0; i < data.salts_cnt; i++)
17967 {
17968 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17969 }
17970 }
17971 else if (data.attack_kern == ATTACK_KERN_COMBI)
17972 {
17973 for (uint i = 0; i < data.salts_cnt; i++)
17974 {
17975 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17976 }
17977 }
17978 else if (data.attack_kern == ATTACK_KERN_BF)
17979 {
17980 for (uint i = 0; i < data.salts_cnt; i++)
17981 {
17982 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17983 }
17984 }
17985 }
17986
17987 /*
17988 * Update loopback file
17989 */
17990
17991 if (loopback == 1)
17992 {
17993 time_t now;
17994
17995 time (&now);
17996
17997 uint random_num = get_random_num (0, 9999);
17998
17999 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
18000
18001 data.loopback_file = loopback_file;
18002 }
18003
18004 /*
18005 * Update dictionary statistic
18006 */
18007
18008 if (keyspace == 0)
18009 {
18010 dictstat_fp = fopen (dictstat, "wb");
18011
18012 if (dictstat_fp)
18013 {
18014 lock_file (dictstat_fp);
18015
18016 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
18017
18018 fclose (dictstat_fp);
18019 }
18020 }
18021
18022 /**
18023 * create autotune threads
18024 */
18025
18026 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
18027
18028 data.devices_status = STATUS_AUTOTUNE;
18029
18030 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18031 {
18032 hc_device_param_t *device_param = &devices_param[device_id];
18033
18034 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
18035 }
18036
18037 hc_thread_wait (data.devices_cnt, c_threads);
18038
18039 /*
18040 * Inform user about possible slow speeds
18041 */
18042
18043 uint hardware_power_all = 0;
18044
18045 uint kernel_power_all = 0;
18046
18047 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18048 {
18049 hc_device_param_t *device_param = &devices_param[device_id];
18050
18051 hardware_power_all += device_param->hardware_power;
18052
18053 kernel_power_all += device_param->kernel_power;
18054 }
18055
18056 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
18057
18058 data.kernel_power_all = kernel_power_all;
18059
18060 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18061 {
18062 if (data.words_base < kernel_power_all)
18063 {
18064 if (quiet == 0)
18065 {
18066 log_info ("ATTENTION!");
18067 log_info (" The wordlist or mask you are using is too small.");
18068 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
18069 log_info (" The cracking speed will drop.");
18070 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
18071 log_info ("");
18072 }
18073 }
18074 }
18075
18076 /**
18077 * create cracker threads
18078 */
18079
18080 data.devices_status = STATUS_RUNNING;
18081
18082 if (initial_restore_done == 0)
18083 {
18084 if (data.restore_disable == 0) cycle_restore ();
18085
18086 initial_restore_done = 1;
18087 }
18088
18089 hc_timer_set (&data.timer_running);
18090
18091 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18092 {
18093 if ((quiet == 0) && (status == 0) && (benchmark == 0))
18094 {
18095 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
18096 if (quiet == 0) fflush (stdout);
18097 }
18098 }
18099 else if (wordlist_mode == WL_MODE_STDIN)
18100 {
18101 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
18102 if (data.quiet == 0) log_info ("");
18103 }
18104
18105 time_t runtime_start;
18106
18107 time (&runtime_start);
18108
18109 data.runtime_start = runtime_start;
18110
18111 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18112 {
18113 hc_device_param_t *device_param = &devices_param[device_id];
18114
18115 if (wordlist_mode == WL_MODE_STDIN)
18116 {
18117 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
18118 }
18119 else
18120 {
18121 hc_thread_create (c_threads[device_id], thread_calc, device_param);
18122 }
18123 }
18124
18125 hc_thread_wait (data.devices_cnt, c_threads);
18126
18127 local_free (c_threads);
18128
18129 data.restore = 0;
18130
18131 // finalize task
18132
18133 logfile_sub_var_uint ("status-after-work", data.devices_status);
18134
18135 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18136
18137 if (data.devices_status == STATUS_CRACKED) break;
18138 if (data.devices_status == STATUS_ABORTED) break;
18139
18140 if (data.devices_status == STATUS_BYPASS)
18141 {
18142 data.devices_status = STATUS_RUNNING;
18143 }
18144
18145 if (induction_dictionaries_cnt)
18146 {
18147 unlink (induction_dictionaries[0]);
18148 }
18149
18150 free (induction_dictionaries);
18151
18152 if (attack_mode != ATTACK_MODE_BF)
18153 {
18154 induction_dictionaries = scan_directory (induction_directory);
18155
18156 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18157 }
18158
18159 if (benchmark == 0)
18160 {
18161 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
18162 {
18163 if (quiet == 0) clear_prompt ();
18164
18165 if (quiet == 0) log_info ("");
18166
18167 if (status == 1)
18168 {
18169 status_display ();
18170 }
18171 else
18172 {
18173 if (quiet == 0) status_display ();
18174 }
18175
18176 if (quiet == 0) log_info ("");
18177 }
18178 }
18179
18180 if (attack_mode == ATTACK_MODE_BF)
18181 {
18182 dictpos++;
18183
18184 rd->dictpos = dictpos;
18185 }
18186 else
18187 {
18188 if (induction_dictionaries_cnt)
18189 {
18190 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18191 }
18192 else
18193 {
18194 dictpos++;
18195
18196 rd->dictpos = dictpos;
18197 }
18198 }
18199
18200 time_t runtime_stop;
18201
18202 time (&runtime_stop);
18203
18204 data.runtime_stop = runtime_stop;
18205
18206 logfile_sub_uint (runtime_start);
18207 logfile_sub_uint (runtime_stop);
18208
18209 logfile_sub_msg ("STOP");
18210
18211 global_free (subid);
18212 }
18213
18214 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18215
18216 if (data.devices_status == STATUS_CRACKED) break;
18217 if (data.devices_status == STATUS_ABORTED) break;
18218 if (data.devices_status == STATUS_QUIT) break;
18219
18220 if (data.devices_status == STATUS_BYPASS)
18221 {
18222 data.devices_status = STATUS_RUNNING;
18223 }
18224 }
18225
18226 // 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
18227
18228 if (attack_mode == ATTACK_MODE_STRAIGHT)
18229 {
18230 if (data.wordlist_mode == WL_MODE_FILE)
18231 {
18232 if (data.dictfile == NULL)
18233 {
18234 if (dictfiles != NULL)
18235 {
18236 data.dictfile = dictfiles[0];
18237
18238 hc_timer_set (&data.timer_running);
18239 }
18240 }
18241 }
18242 }
18243 // NOTE: combi is okay because it is already set beforehand
18244 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
18245 {
18246 if (data.dictfile == NULL)
18247 {
18248 if (dictfiles != NULL)
18249 {
18250 hc_timer_set (&data.timer_running);
18251
18252 data.dictfile = dictfiles[0];
18253 }
18254 }
18255 }
18256 else if (attack_mode == ATTACK_MODE_BF)
18257 {
18258 if (data.mask == NULL)
18259 {
18260 hc_timer_set (&data.timer_running);
18261
18262 data.mask = masks[0];
18263 }
18264 }
18265
18266 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18267 {
18268 data.devices_status = STATUS_EXHAUSTED;
18269 }
18270
18271 // if cracked / aborted remove last induction dictionary
18272
18273 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
18274 {
18275 struct stat induct_stat;
18276
18277 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
18278 {
18279 unlink (induction_dictionaries[file_pos]);
18280 }
18281 }
18282
18283 // wait for non-interactive threads
18284
18285 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
18286 {
18287 hc_thread_wait (1, &ni_threads[thread_idx]);
18288 }
18289
18290 local_free (ni_threads);
18291
18292 // wait for interactive threads
18293
18294 for (uint thread_idx = 0; thread_idx < i_threads_cnt; thread_idx++)
18295 {
18296 hc_thread_wait (1, &i_threads[thread_idx]);
18297 }
18298
18299 local_free (i_threads);
18300
18301 // we dont need restore file anymore
18302 if (data.restore_disable == 0)
18303 {
18304 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
18305 {
18306 unlink (eff_restore_file);
18307 unlink (new_restore_file);
18308 }
18309 else
18310 {
18311 cycle_restore ();
18312 }
18313 }
18314
18315 // finally save left hashes
18316
18317 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
18318 {
18319 save_hash ();
18320 }
18321
18322 /**
18323 * Clean up
18324 */
18325
18326 if (benchmark == 1)
18327 {
18328 status_benchmark ();
18329
18330 if (machine_readable == 0)
18331 {
18332 log_info ("");
18333 }
18334 }
18335 else
18336 {
18337 if (quiet == 0) clear_prompt ();
18338
18339 if (quiet == 0) log_info ("");
18340
18341 if (status == 1)
18342 {
18343 status_display ();
18344 }
18345 else
18346 {
18347 if (quiet == 0) status_display ();
18348 }
18349
18350 if (quiet == 0) log_info ("");
18351 }
18352
18353 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18354 {
18355 hc_device_param_t *device_param = &data.devices_param[device_id];
18356
18357 if (device_param->skipped) continue;
18358
18359 local_free (device_param->combs_buf);
18360
18361 local_free (device_param->hooks_buf);
18362
18363 local_free (device_param->device_name);
18364
18365 local_free (device_param->device_name_chksum);
18366
18367 local_free (device_param->device_version);
18368
18369 local_free (device_param->driver_version);
18370
18371 if (device_param->pws_buf) myfree (device_param->pws_buf);
18372 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
18373 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
18374 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
18375 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
18376 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
18377 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
18378 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
18379 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
18380 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
18381 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
18382 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
18383 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
18384 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
18385 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
18386 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
18387 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
18388 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
18389 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
18390 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
18391 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
18392 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
18393 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
18394 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
18395 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
18396 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
18397 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
18398 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
18399 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
18400
18401 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
18402 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
18403 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
18404 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
18405 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
18406 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
18407 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
18408 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
18409 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
18410 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
18411 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
18412
18413 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
18414 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
18415 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
18416
18417 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
18418 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
18419 }
18420
18421 // reset default fan speed
18422
18423 #ifdef HAVE_HWMON
18424 if (gpu_temp_disable == 0)
18425 {
18426 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
18427 {
18428 hc_thread_mutex_lock (mux_adl);
18429
18430 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18431 {
18432 hc_device_param_t *device_param = &data.devices_param[device_id];
18433
18434 if (device_param->skipped) continue;
18435
18436 if (data.hm_device[device_id].fan_set_supported == 1)
18437 {
18438 int fanspeed = temp_retain_fanspeed_value[device_id];
18439 int fanpolicy = temp_retain_fanpolicy_value[device_id];
18440
18441 if (fanpolicy == 1)
18442 {
18443 int rc = -1;
18444
18445 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18446 {
18447 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
18448 }
18449 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18450 {
18451 #ifdef LINUX
18452 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE);
18453 #endif
18454
18455 #ifdef WIN
18456 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, fanpolicy);
18457 #endif
18458 }
18459
18460 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18461 }
18462 }
18463 }
18464
18465 hc_thread_mutex_unlock (mux_adl);
18466 }
18467 }
18468
18469 // reset power tuning
18470
18471 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
18472 {
18473 hc_thread_mutex_lock (mux_adl);
18474
18475 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18476 {
18477 hc_device_param_t *device_param = &data.devices_param[device_id];
18478
18479 if (device_param->skipped) continue;
18480
18481 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18482 {
18483 if (data.hm_device[device_id].od_version == 6)
18484 {
18485 // check powertune capabilities first, if not available then skip device
18486
18487 int powertune_supported = 0;
18488
18489 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18490 {
18491 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18492
18493 return (-1);
18494 }
18495
18496 if (powertune_supported != 0)
18497 {
18498 // powercontrol settings
18499
18500 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18501 {
18502 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18503
18504 return (-1);
18505 }
18506
18507 // clocks
18508
18509 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18510
18511 performance_state->iNumberOfPerformanceLevels = 2;
18512
18513 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18514 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18515 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18516 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18517
18518 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18519 {
18520 log_info ("ERROR: Failed to restore ADL performance state");
18521
18522 return (-1);
18523 }
18524
18525 local_free (performance_state);
18526 }
18527 }
18528 }
18529
18530 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18531 {
18532 unsigned int limit = nvml_power_limit[device_id];
18533
18534 if (limit > 0)
18535 {
18536 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18537 }
18538 }
18539 }
18540
18541 hc_thread_mutex_unlock (mux_adl);
18542 }
18543
18544 if (gpu_temp_disable == 0)
18545 {
18546 if (data.hm_nvml)
18547 {
18548 hm_NVML_nvmlShutdown (data.hm_nvml);
18549
18550 nvml_close (data.hm_nvml);
18551
18552 data.hm_nvml = NULL;
18553 }
18554
18555 if (data.hm_nvapi)
18556 {
18557 hm_NvAPI_Unload (data.hm_nvapi);
18558
18559 nvapi_close (data.hm_nvapi);
18560
18561 data.hm_nvapi = NULL;
18562 }
18563
18564 if (data.hm_xnvctrl)
18565 {
18566 hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);
18567
18568 xnvctrl_close (data.hm_xnvctrl);
18569
18570 data.hm_xnvctrl = NULL;
18571 }
18572
18573 if (data.hm_adl)
18574 {
18575 hm_ADL_Main_Control_Destroy (data.hm_adl);
18576
18577 adl_close (data.hm_adl);
18578
18579 data.hm_adl = NULL;
18580 }
18581 }
18582 #endif // HAVE_HWMON
18583
18584 // free memory
18585
18586 local_free (masks);
18587
18588 local_free (dictstat_base);
18589
18590 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18591 {
18592 pot_t *pot_ptr = &pot[pot_pos];
18593
18594 hash_t *hash = &pot_ptr->hash;
18595
18596 local_free (hash->digest);
18597
18598 if (isSalted)
18599 {
18600 local_free (hash->salt);
18601 }
18602 }
18603
18604 local_free (pot);
18605
18606 local_free (all_kernel_rules_cnt);
18607 local_free (all_kernel_rules_buf);
18608
18609 local_free (wl_data->buf);
18610 local_free (wl_data);
18611
18612 local_free (bitmap_s1_a);
18613 local_free (bitmap_s1_b);
18614 local_free (bitmap_s1_c);
18615 local_free (bitmap_s1_d);
18616 local_free (bitmap_s2_a);
18617 local_free (bitmap_s2_b);
18618 local_free (bitmap_s2_c);
18619 local_free (bitmap_s2_d);
18620
18621 #ifdef HAVE_HWMON
18622 local_free (temp_retain_fanspeed_value);
18623 local_free (od_clock_mem_status);
18624 local_free (od_power_control_status);
18625 local_free (nvml_power_limit);
18626 #endif
18627
18628 global_free (devices_param);
18629
18630 global_free (kernel_rules_buf);
18631
18632 global_free (root_css_buf);
18633 global_free (markov_css_buf);
18634
18635 global_free (digests_buf);
18636 global_free (digests_shown);
18637 global_free (digests_shown_tmp);
18638
18639 global_free (salts_buf);
18640 global_free (salts_shown);
18641
18642 global_free (esalts_buf);
18643
18644 global_free (words_progress_done);
18645 global_free (words_progress_rejected);
18646 global_free (words_progress_restored);
18647
18648 if (pot_fp) fclose (pot_fp);
18649
18650 if (data.devices_status == STATUS_QUIT) break;
18651 }
18652
18653 // destroy others mutex
18654
18655 hc_thread_mutex_delete (mux_dispatcher);
18656 hc_thread_mutex_delete (mux_counter);
18657 hc_thread_mutex_delete (mux_display);
18658 hc_thread_mutex_delete (mux_adl);
18659
18660 // free memory
18661
18662 local_free (eff_restore_file);
18663 local_free (new_restore_file);
18664
18665 local_free (rd);
18666
18667 // tuning db
18668
18669 tuning_db_destroy (tuning_db);
18670
18671 // loopback
18672
18673 local_free (loopback_file);
18674
18675 if (loopback == 1) unlink (loopback_file);
18676
18677 // induction directory
18678
18679 if (induction_dir == NULL)
18680 {
18681 if (attack_mode != ATTACK_MODE_BF)
18682 {
18683 if (rmdir (induction_directory) == -1)
18684 {
18685 if (errno == ENOENT)
18686 {
18687 // good, we can ignore
18688 }
18689 else if (errno == ENOTEMPTY)
18690 {
18691 // good, we can ignore
18692 }
18693 else
18694 {
18695 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18696
18697 return (-1);
18698 }
18699 }
18700
18701 local_free (induction_directory);
18702 }
18703 }
18704
18705 // outfile-check directory
18706
18707 if (outfile_check_dir == NULL)
18708 {
18709 if (rmdir (outfile_check_directory) == -1)
18710 {
18711 if (errno == ENOENT)
18712 {
18713 // good, we can ignore
18714 }
18715 else if (errno == ENOTEMPTY)
18716 {
18717 // good, we can ignore
18718 }
18719 else
18720 {
18721 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18722
18723 return (-1);
18724 }
18725 }
18726
18727 local_free (outfile_check_directory);
18728 }
18729
18730 time_t proc_stop;
18731
18732 time (&proc_stop);
18733
18734 logfile_top_uint (proc_start);
18735 logfile_top_uint (proc_stop);
18736
18737 logfile_top_msg ("STOP");
18738
18739 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18740 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18741
18742 if (data.ocl) ocl_close (data.ocl);
18743
18744 if (data.devices_status == STATUS_ABORTED) return 2;
18745 if (data.devices_status == STATUS_QUIT) return 2;
18746 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18747 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18748 if (data.devices_status == STATUS_CRACKED) return 0;
18749
18750 return -1;
18751 }
Hashcat additions to support pwdhash