projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Do our own include-file permission check before an OpenCL runtime fails loading them...
[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 DARWIN
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 75
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 | | Compare hashlist with potfile; Show cracked hashes |",
395 " --left | | Compare hashlist with potfile; Show uncracked hashes |",
396 " --username | | Enable ignoring of usernames in hashfile |",
397 " --remove | | Enable remove of hash once it is cracked |",
398 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
399 " --potfile-disable | | Do not write potfile |",
400 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
401 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
402 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
403 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
404 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
405 " --logfile-disable | | Disable the logfile |",
406 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
407 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
408 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
409 " -b, --benchmark | | Run benchmark |",
410 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
411 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
412 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
413 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
414 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
415 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
416 " -D, --opencl-device-types | Str | OpenCL device-types to use, separate with comma | -D 1",
417 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
418 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
419 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
420 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
421 " --nvidia-spin-damp | Num | Workaround NVidias CPU burning loop bug, in percent | --nvidia-spin-damp=50",
422 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
423 #ifdef HAVE_HWMON
424 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
425 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
426 " --powertune-enable | | Enable power tuning, restores settings when finished |",
427 #endif
428 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
429 " -s, --skip | Num | Skip X words from the start | -s 1000000",
430 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
431 " --keyspace | | Show keyspace base:mod values and quit |",
432 " -j, --rule-left | Rule | Single rule applied to each word from left wordlist | -j 'c'",
433 " -k, --rule-right | Rule | Single rule applied to each word from right wordlist | -k '^-'",
434 " -r, --rules-file | File | Multiple rules applied to each word from wordlists | -r rules/best64.rule",
435 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
436 " --generate-rules-func-min | Num | Force min X funcs per rule |",
437 " --generate-rules-func-max | Num | Force max X funcs per rule |",
438 " --generate-rules-seed | Num | Force RNG seed set to X |",
439 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
440 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
441 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
442 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
443 " -i, --increment | | Enable mask increment mode |",
444 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
445 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
446 "",
447 "- [ Hash modes ] -",
448 "",
449 " # | Name | Category",
450 " ======+==================================================+======================================",
451 " 900 | MD4 | Raw Hash",
452 " 0 | MD5 | Raw Hash",
453 " 5100 | Half MD5 | Raw Hash",
454 " 100 | SHA1 | Raw Hash",
455 " 10800 | SHA-384 | Raw Hash",
456 " 1400 | SHA-256 | Raw Hash",
457 " 1700 | SHA-512 | Raw Hash",
458 " 5000 | SHA-3(Keccak) | Raw Hash",
459 " 10100 | SipHash | Raw Hash",
460 " 6000 | RipeMD160 | Raw Hash",
461 " 6100 | Whirlpool | Raw Hash",
462 " 6900 | GOST R 34.11-94 | Raw Hash",
463 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
464 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
465 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
466 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
467 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
468 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
469 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
470 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
471 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
472 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
473 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
474 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
475 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
476 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
477 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
478 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
479 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
480 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
481 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
482 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
483 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
484 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
485 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
486 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
487 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
488 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
489 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
490 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
491 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
492 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
493 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
494 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
495 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
496 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
497 " 400 | phpass | Generic KDF",
498 " 8900 | scrypt | Generic KDF",
499 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
500 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
501 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
502 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
503 " 23 | Skype | Network protocols",
504 " 2500 | WPA/WPA2 | Network protocols",
505 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
506 " 5300 | IKE-PSK MD5 | Network protocols",
507 " 5400 | IKE-PSK SHA1 | Network protocols",
508 " 5500 | NetNTLMv1 | Network protocols",
509 " 5500 | NetNTLMv1 + ESS | Network protocols",
510 " 5600 | NetNTLMv2 | Network protocols",
511 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
512 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
513 " 8300 | DNSSEC (NSEC3) | Network protocols",
514 " 10200 | Cram MD5 | Network protocols",
515 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
516 " 11200 | MySQL CRAM (SHA1) | Network protocols",
517 " 11400 | SIP digest authentication (MD5) | Network protocols",
518 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
519 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
520 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
521 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
522 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
523 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
524 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
525 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
526 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
527 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
528 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
529 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
530 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
531 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
532 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
533 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
534 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
535 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
536 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
537 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
538 " 12 | PostgreSQL | Database Server",
539 " 131 | MSSQL(2000) | Database Server",
540 " 132 | MSSQL(2005) | Database Server",
541 " 1731 | MSSQL(2012) | Database Server",
542 " 1731 | MSSQL(2014) | Database Server",
543 " 200 | MySQL323 | Database Server",
544 " 300 | MySQL4.1/MySQL5 | Database Server",
545 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
546 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
547 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
548 " 8000 | Sybase ASE | Database Server",
549 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
550 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
551 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
552 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
553 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
554 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
555 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
556 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
557 " 11500 | CRC32 | Checksums",
558 " 3000 | LM | Operating-Systems",
559 " 1000 | NTLM | Operating-Systems",
560 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
561 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
562 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
563 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
564 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
565 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
566 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
567 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
568 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
569 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
570 " 1722 | OSX v10.7 | Operating-Systems",
571 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
572 " 6300 | AIX {smd5} | Operating-Systems",
573 " 6700 | AIX {ssha1} | Operating-Systems",
574 " 6400 | AIX {ssha256} | Operating-Systems",
575 " 6500 | AIX {ssha512} | Operating-Systems",
576 " 2400 | Cisco-PIX | Operating-Systems",
577 " 2410 | Cisco-ASA | Operating-Systems",
578 " 500 | Cisco-IOS $1$ | Operating-Systems",
579 " 5700 | Cisco-IOS $4$ | Operating-Systems",
580 " 9200 | Cisco-IOS $8$ | Operating-Systems",
581 " 9300 | Cisco-IOS $9$ | Operating-Systems",
582 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
583 " 501 | Juniper IVE | Operating-Systems",
584 " 5800 | Android PIN | Operating-Systems",
585 " 13800 | Windows 8+ phone PIN/Password | Operating-Systems",
586 " 8100 | Citrix Netscaler | Operating-Systems",
587 " 8500 | RACF | Operating-Systems",
588 " 7200 | GRUB 2 | Operating-Systems",
589 " 9900 | Radmin2 | Operating-Systems",
590 " 125 | ArubaOS | Operating-Systems",
591 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
592 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
593 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
594 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
595 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
596 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
597 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
598 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
599 " 11600 | 7-Zip | Archives",
600 " 12500 | RAR3-hp | Archives",
601 " 13000 | RAR5 | Archives",
602 " 13200 | AxCrypt | Archives",
603 " 13300 | AxCrypt in memory SHA1 | Archives",
604 " 13600 | WinZip | Archives",
605 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
606 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
607 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
608 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
609 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
610 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
611 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
612 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
613 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
614 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
615 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
616 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
617 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
618 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
619 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
620 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
621 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
622 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
623 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
624 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
625 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
626 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
627 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
628 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
629 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
630 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
631 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
632 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
633 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
634 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
635 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
636 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
637 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
638 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
639 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
640 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
641 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
642 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
643 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
644 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
645 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
646 " 9400 | MS Office 2007 | Documents",
647 " 9500 | MS Office 2010 | Documents",
648 " 9600 | MS Office 2013 | Documents",
649 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
650 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
651 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
652 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
653 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
654 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
655 " 9000 | Password Safe v2 | Password Managers",
656 " 5200 | Password Safe v3 | Password Managers",
657 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
658 " 6600 | 1Password, agilekeychain | Password Managers",
659 " 8200 | 1Password, cloudkeychain | Password Managers",
660 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
661 " 12700 | Blockchain, My Wallet | Password Managers",
662 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
663 "",
664 "- [ Outfile Formats ] -",
665 "",
666 " # | Format",
667 " ===+========",
668 " 1 | hash[:salt]",
669 " 2 | plain",
670 " 3 | hash[:salt]:plain",
671 " 4 | hex_plain",
672 " 5 | hash[:salt]:hex_plain",
673 " 6 | plain:hex_plain",
674 " 7 | hash[:salt]:plain:hex_plain",
675 " 8 | crackpos",
676 " 9 | hash[:salt]:crack_pos",
677 " 10 | plain:crack_pos",
678 " 11 | hash[:salt]:plain:crack_pos",
679 " 12 | hex_plain:crack_pos",
680 " 13 | hash[:salt]:hex_plain:crack_pos",
681 " 14 | plain:hex_plain:crack_pos",
682 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
683 "",
684 "- [ Rule Debugging Modes ] -",
685 "",
686 " # | Format",
687 " ===+========",
688 " 1 | Finding-Rule",
689 " 2 | Original-Word",
690 " 3 | Original-Word:Finding-Rule",
691 " 4 | Original-Word:Finding-Rule:Processed-Word",
692 "",
693 "- [ Attack Modes ] -",
694 "",
695 " # | Mode",
696 " ===+======",
697 " 0 | Straight",
698 " 1 | Combination",
699 " 3 | Brute-force",
700 " 6 | Hybrid Wordlist + Mask",
701 " 7 | Hybrid Mask + Wordlist",
702 "",
703 "- [ Built-in Charsets ] -",
704 "",
705 " ? | Charset",
706 " ===+=========",
707 " l | abcdefghijklmnopqrstuvwxyz",
708 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
709 " d | 0123456789",
710 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
711 " a | ?l?u?d?s",
712 " b | 0x00 - 0xff",
713 "",
714 "- [ OpenCL Device Types ] -",
715 "",
716 " # | Device Type",
717 " ===+=============",
718 " 1 | CPU",
719 " 2 | GPU",
720 " 3 | FPGA, DSP, Co-Processor",
721 "",
722 "- [ Workload Profiles ] -",
723 "",
724 " # | Performance | Runtime | Power Consumption | Desktop Impact",
725 " ===+=============+=========+===================+=================",
726 " 1 | Low | 2 ms | Low | Minimal",
727 " 2 | Default | 12 ms | Economic | Noticeable",
728 " 3 | High | 96 ms | High | Unresponsive",
729 " 4 | Nightmare | 480 ms | Insane | Headless",
730 "",
731 "- [ Basic Examples ] -",
732 "",
733 " Attack- | Hash- |",
734 " Mode | Type | Example command",
735 " ==================+=======+==================================================================",
736 " Wordlist | $P$ | %s -a 0 -m 400 example400.hash example.dict",
737 " Wordlist + Rules | MD5 | %s -a 0 -m 0 example0.hash example.dict -r rules/best64.rule",
738 " Brute-Force | MD5 | %s -a 3 -m 0 example0.hash ?a?a?a?a?a?a",
739 " Combinator | MD5 | %s -a 1 -m 0 example0.hash example.dict example.dict",
740 "",
741 "If you still have no idea what just happened try following pages:",
742 "",
743 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
744 "* https://hashcat.net/wiki/#frequently_asked_questions",
745 NULL
746 };
747
748 /**
749 * hashcat specific functions
750 */
751
752 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
753 {
754 int exec_pos = (int) device_param->exec_pos - last_num_entries;
755
756 if (exec_pos < 0) exec_pos += EXEC_CACHE;
757
758 double exec_ms_sum = 0;
759
760 int exec_ms_cnt = 0;
761
762 for (int i = 0; i < last_num_entries; i++)
763 {
764 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
765
766 if (exec_ms)
767 {
768 exec_ms_sum += exec_ms;
769
770 exec_ms_cnt++;
771 }
772 }
773
774 if (exec_ms_cnt == 0) return 0;
775
776 return exec_ms_sum / exec_ms_cnt;
777 }
778
779 void status_display_machine_readable ()
780 {
781 FILE *out = stdout;
782
783 fprintf (out, "STATUS\t%u\t", data.devices_status);
784
785 /**
786 * speed new
787 */
788
789 fprintf (out, "SPEED\t");
790
791 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
792 {
793 hc_device_param_t *device_param = &data.devices_param[device_id];
794
795 if (device_param->skipped) continue;
796
797 u64 speed_cnt = 0;
798 double speed_ms = 0;
799
800 for (int i = 0; i < SPEED_CACHE; i++)
801 {
802 speed_cnt += device_param->speed_cnt[i];
803 speed_ms += device_param->speed_ms[i];
804 }
805
806 speed_cnt /= SPEED_CACHE;
807 speed_ms /= SPEED_CACHE;
808
809 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
810 }
811
812 /**
813 * exec time
814 */
815
816 fprintf (out, "EXEC_RUNTIME\t");
817
818 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
819 {
820 hc_device_param_t *device_param = &data.devices_param[device_id];
821
822 if (device_param->skipped) continue;
823
824 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
825
826 fprintf (out, "%f\t", exec_ms_avg);
827 }
828
829 /**
830 * words_cur
831 */
832
833 u64 words_cur = get_lowest_words_done ();
834
835 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
836
837 /**
838 * counter
839 */
840
841 u64 progress_total = data.words_cnt * data.salts_cnt;
842
843 u64 all_done = 0;
844 u64 all_rejected = 0;
845 u64 all_restored = 0;
846
847 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
848 {
849 all_done += data.words_progress_done[salt_pos];
850 all_rejected += data.words_progress_rejected[salt_pos];
851 all_restored += data.words_progress_restored[salt_pos];
852 }
853
854 u64 progress_cur = all_restored + all_done + all_rejected;
855 u64 progress_end = progress_total;
856
857 u64 progress_skip = 0;
858
859 if (data.skip)
860 {
861 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
862
863 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
864 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
865 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
866 }
867
868 if (data.limit)
869 {
870 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
871
872 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
873 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
874 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
875 }
876
877 u64 progress_cur_relative_skip = progress_cur - progress_skip;
878 u64 progress_end_relative_skip = progress_end - progress_skip;
879
880 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
881
882 /**
883 * cracks
884 */
885
886 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
887 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
888
889 /**
890 * temperature
891 */
892
893 #ifdef HAVE_HWMON
894 if (data.gpu_temp_disable == 0)
895 {
896 fprintf (out, "TEMP\t");
897
898 hc_thread_mutex_lock (mux_adl);
899
900 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
901 {
902 hc_device_param_t *device_param = &data.devices_param[device_id];
903
904 if (device_param->skipped) continue;
905
906 int temp = hm_get_temperature_with_device_id (device_id);
907
908 fprintf (out, "%d\t", temp);
909 }
910
911 hc_thread_mutex_unlock (mux_adl);
912 }
913 #endif // HAVE_HWMON
914
915 /**
916 * flush
917 */
918
919 fputs (EOL, out);
920 fflush (out);
921 }
922
923 void status_display ()
924 {
925 if (data.devices_status == STATUS_INIT) return;
926 if (data.devices_status == STATUS_STARTING) 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
1686 if (data.machine_readable == 1)
1687 {
1688 status_benchmark_automate ();
1689
1690 return;
1691 }
1692
1693 u64 speed_cnt[DEVICES_MAX] = { 0 };
1694 double speed_ms[DEVICES_MAX] = { 0 };
1695
1696 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1697 {
1698 hc_device_param_t *device_param = &data.devices_param[device_id];
1699
1700 if (device_param->skipped) continue;
1701
1702 speed_cnt[device_id] = device_param->speed_cnt[0];
1703 speed_ms[device_id] = device_param->speed_ms[0];
1704 }
1705
1706 double hashes_all_ms = 0;
1707
1708 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1709
1710 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1711 {
1712 hc_device_param_t *device_param = &data.devices_param[device_id];
1713
1714 if (device_param->skipped) continue;
1715
1716 hashes_dev_ms[device_id] = 0;
1717
1718 if (speed_ms[device_id])
1719 {
1720 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1721
1722 hashes_all_ms += hashes_dev_ms[device_id];
1723 }
1724 }
1725
1726 /**
1727 * exec time
1728 */
1729
1730 double exec_all_ms[DEVICES_MAX] = { 0 };
1731
1732 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1733 {
1734 hc_device_param_t *device_param = &data.devices_param[device_id];
1735
1736 if (device_param->skipped) continue;
1737
1738 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1739
1740 exec_all_ms[device_id] = exec_ms_avg;
1741 }
1742
1743 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1744 {
1745 hc_device_param_t *device_param = &data.devices_param[device_id];
1746
1747 if (device_param->skipped) continue;
1748
1749 char display_dev_cur[16] = { 0 };
1750
1751 strncpy (display_dev_cur, "0.00", 4);
1752
1753 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1754
1755 if (data.devices_active >= 10)
1756 {
1757 log_info ("Speed.Dev.#%d: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1758 }
1759 else
1760 {
1761 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1762 }
1763 }
1764
1765 char display_all_cur[16] = { 0 };
1766
1767 strncpy (display_all_cur, "0.00", 4);
1768
1769 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1770
1771 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1772 }
1773
1774 /**
1775 * hashcat -only- functions
1776 */
1777
1778 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1779 {
1780 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1781 {
1782 if (attack_kern == ATTACK_KERN_STRAIGHT)
1783 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1784 else if (attack_kern == ATTACK_KERN_COMBI)
1785 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1786 else if (attack_kern == ATTACK_KERN_BF)
1787 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1788 }
1789 else
1790 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1791 }
1792
1793 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)
1794 {
1795 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1796 {
1797 if (attack_kern == ATTACK_KERN_STRAIGHT)
1798 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1799 else if (attack_kern == ATTACK_KERN_COMBI)
1800 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1801 else if (attack_kern == ATTACK_KERN_BF)
1802 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1803 }
1804 else
1805 {
1806 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1807 }
1808 }
1809
1810 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1811 {
1812 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1813 {
1814 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1815 }
1816 else
1817 {
1818 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1819 }
1820 }
1821
1822 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)
1823 {
1824 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1825 {
1826 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1827 }
1828 else
1829 {
1830 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1831 }
1832 }
1833
1834 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1835 {
1836 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1837 }
1838
1839 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1840 {
1841 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1842 }
1843
1844 static char *filename_from_filepath (char *filepath)
1845 {
1846 char *ptr = NULL;
1847
1848 if ((ptr = strrchr (filepath, '/')) != NULL)
1849 {
1850 ptr++;
1851 }
1852 else if ((ptr = strrchr (filepath, '\\')) != NULL)
1853 {
1854 ptr++;
1855 }
1856 else
1857 {
1858 ptr = filepath;
1859 }
1860
1861 return ptr;
1862 }
1863
1864 static uint convert_from_hex (char *line_buf, const uint line_len)
1865 {
1866 if (line_len & 1) return (line_len); // not in hex
1867
1868 if (data.hex_wordlist == 1)
1869 {
1870 uint i;
1871 uint j;
1872
1873 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1874 {
1875 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1876 }
1877
1878 memset (line_buf + i, 0, line_len - i);
1879
1880 return (i);
1881 }
1882 else if (line_len >= 6) // $HEX[] = 6
1883 {
1884 if (line_buf[0] != '$') return (line_len);
1885 if (line_buf[1] != 'H') return (line_len);
1886 if (line_buf[2] != 'E') return (line_len);
1887 if (line_buf[3] != 'X') return (line_len);
1888 if (line_buf[4] != '[') return (line_len);
1889 if (line_buf[line_len - 1] != ']') return (line_len);
1890
1891 uint i;
1892 uint j;
1893
1894 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1895 {
1896 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1897 }
1898
1899 memset (line_buf + i, 0, line_len - i);
1900
1901 return (i);
1902 }
1903
1904 return (line_len);
1905 }
1906
1907 static void clear_prompt ()
1908 {
1909 fputc ('\r', stdout);
1910
1911 for (size_t i = 0; i < strlen (PROMPT); i++)
1912 {
1913 fputc (' ', stdout);
1914 }
1915
1916 fputc ('\r', stdout);
1917
1918 fflush (stdout);
1919 }
1920
1921 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1922 {
1923 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);
1924 }
1925
1926 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1927 {
1928 char *outfile = data.outfile;
1929 uint quiet = data.quiet;
1930 FILE *pot_fp = data.pot_fp;
1931 uint loopback = data.loopback;
1932 uint debug_mode = data.debug_mode;
1933 char *debug_file = data.debug_file;
1934
1935 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1936 int debug_rule_len = 0; // -1 error
1937 uint debug_plain_len = 0;
1938
1939 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1940
1941 // hash
1942
1943 char out_buf[HCBUFSIZ] = { 0 };
1944
1945 const u32 salt_pos = plain->salt_pos;
1946 const u32 digest_pos = plain->digest_pos; // relative
1947 const u32 gidvid = plain->gidvid;
1948 const u32 il_pos = plain->il_pos;
1949
1950 ascii_digest (out_buf, salt_pos, digest_pos);
1951
1952 // plain
1953
1954 u64 crackpos = device_param->words_off;
1955
1956 uint plain_buf[16] = { 0 };
1957
1958 u8 *plain_ptr = (u8 *) plain_buf;
1959
1960 unsigned int plain_len = 0;
1961
1962 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1963 {
1964 pw_t pw;
1965
1966 gidd_to_pw_t (device_param, gidvid, &pw);
1967
1968 for (int i = 0; i < 16; i++)
1969 {
1970 plain_buf[i] = pw.i[i];
1971 }
1972
1973 plain_len = pw.pw_len;
1974
1975 const uint off = device_param->innerloop_pos + il_pos;
1976
1977 if (debug_mode > 0)
1978 {
1979 debug_rule_len = 0;
1980
1981 // save rule
1982 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1983 {
1984 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1985
1986 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1987 }
1988
1989 // save plain
1990 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1991 {
1992 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1993
1994 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1995
1996 debug_plain_len = plain_len;
1997 }
1998 }
1999
2000 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2001
2002 crackpos += gidvid;
2003 crackpos *= data.kernel_rules_cnt;
2004 crackpos += device_param->innerloop_pos + il_pos;
2005
2006 if (plain_len > data.pw_max) plain_len = data.pw_max;
2007 }
2008 else if (data.attack_mode == ATTACK_MODE_COMBI)
2009 {
2010 pw_t pw;
2011
2012 gidd_to_pw_t (device_param, gidvid, &pw);
2013
2014 for (int i = 0; i < 16; i++)
2015 {
2016 plain_buf[i] = pw.i[i];
2017 }
2018
2019 plain_len = pw.pw_len;
2020
2021 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2022 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2023
2024 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2025 {
2026 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2027 }
2028 else
2029 {
2030 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2031
2032 memcpy (plain_ptr, comb_buf, comb_len);
2033 }
2034
2035 plain_len += comb_len;
2036
2037 crackpos += gidvid;
2038 crackpos *= data.combs_cnt;
2039 crackpos += device_param->innerloop_pos + il_pos;
2040
2041 if (data.pw_max != PW_DICTMAX1)
2042 {
2043 if (plain_len > data.pw_max) plain_len = data.pw_max;
2044 }
2045 }
2046 else if (data.attack_mode == ATTACK_MODE_BF)
2047 {
2048 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2049 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2050
2051 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2052 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2053
2054 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2055 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2056
2057 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2058 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2059
2060 plain_len = data.css_cnt;
2061
2062 crackpos += gidvid;
2063 crackpos *= data.bfs_cnt;
2064 crackpos += device_param->innerloop_pos + il_pos;
2065 }
2066 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2067 {
2068 pw_t pw;
2069
2070 gidd_to_pw_t (device_param, gidvid, &pw);
2071
2072 for (int i = 0; i < 16; i++)
2073 {
2074 plain_buf[i] = pw.i[i];
2075 }
2076
2077 plain_len = pw.pw_len;
2078
2079 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2080
2081 uint start = 0;
2082 uint stop = device_param->kernel_params_mp_buf32[4];
2083
2084 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2085
2086 plain_len += start + stop;
2087
2088 crackpos += gidvid;
2089 crackpos *= data.combs_cnt;
2090 crackpos += device_param->innerloop_pos + il_pos;
2091
2092 if (data.pw_max != PW_DICTMAX1)
2093 {
2094 if (plain_len > data.pw_max) plain_len = data.pw_max;
2095 }
2096 }
2097 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2098 {
2099 pw_t pw;
2100
2101 gidd_to_pw_t (device_param, gidvid, &pw);
2102
2103 for (int i = 0; i < 16; i++)
2104 {
2105 plain_buf[i] = pw.i[i];
2106 }
2107
2108 plain_len = pw.pw_len;
2109
2110 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2111
2112 uint start = 0;
2113 uint stop = device_param->kernel_params_mp_buf32[4];
2114
2115 memmove (plain_ptr + stop, plain_ptr, plain_len);
2116
2117 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2118
2119 plain_len += start + stop;
2120
2121 crackpos += gidvid;
2122 crackpos *= data.combs_cnt;
2123 crackpos += device_param->innerloop_pos + il_pos;
2124
2125 if (data.pw_max != PW_DICTMAX1)
2126 {
2127 if (plain_len > data.pw_max) plain_len = data.pw_max;
2128 }
2129 }
2130
2131 if (data.attack_mode == ATTACK_MODE_BF)
2132 {
2133 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2134 {
2135 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2136 {
2137 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2138 {
2139 plain_len = plain_len - data.salts_buf[0].salt_len;
2140 }
2141 }
2142
2143 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2144 {
2145 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2146 {
2147 plain_ptr[j] = plain_ptr[i];
2148 }
2149
2150 plain_len = plain_len / 2;
2151 }
2152 }
2153 }
2154
2155 // if enabled, update also the potfile
2156
2157 if (pot_fp)
2158 {
2159 lock_file (pot_fp);
2160
2161 fprintf (pot_fp, "%s:", out_buf);
2162
2163 format_plain (pot_fp, plain_ptr, plain_len, 1);
2164
2165 fputc ('\n', pot_fp);
2166
2167 fflush (pot_fp);
2168
2169 unlock_file (pot_fp);
2170 }
2171
2172 // outfile
2173
2174 FILE *out_fp = NULL;
2175
2176 if (outfile != NULL)
2177 {
2178 if ((out_fp = fopen (outfile, "ab")) == NULL)
2179 {
2180 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2181
2182 out_fp = stdout;
2183 }
2184
2185 lock_file (out_fp);
2186 }
2187 else
2188 {
2189 out_fp = stdout;
2190
2191 if (quiet == 0) clear_prompt ();
2192 }
2193
2194 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2195
2196 if (outfile != NULL)
2197 {
2198 if (out_fp != stdout)
2199 {
2200 fclose (out_fp);
2201 }
2202 }
2203 else
2204 {
2205 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2206 {
2207 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2208 {
2209 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2210 if (quiet == 0) fflush (stdout);
2211 }
2212 }
2213 }
2214
2215 // loopback
2216
2217 if (loopback)
2218 {
2219 char *loopback_file = data.loopback_file;
2220
2221 FILE *fb_fp = NULL;
2222
2223 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2224 {
2225 lock_file (fb_fp);
2226
2227 format_plain (fb_fp, plain_ptr, plain_len, 1);
2228
2229 fputc ('\n', fb_fp);
2230
2231 fclose (fb_fp);
2232 }
2233 }
2234
2235 // (rule) debug mode
2236
2237 // the next check implies that:
2238 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2239 // - debug_mode > 0
2240
2241 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2242 {
2243 if (debug_rule_len < 0) debug_rule_len = 0;
2244
2245 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2246
2247 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2248
2249 if ((quiet == 0) && (debug_file == NULL))
2250 {
2251 fprintf (stdout, "%s", PROMPT);
2252
2253 fflush (stdout);
2254 }
2255 }
2256 }
2257
2258 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2259 {
2260 salt_t *salt_buf = &data.salts_buf[salt_pos];
2261
2262 u32 num_cracked;
2263
2264 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2265
2266 if (num_cracked)
2267 {
2268 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2269
2270 log_info_nn ("");
2271
2272 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2273
2274 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);
2275
2276 uint cpt_cracked = 0;
2277
2278 hc_thread_mutex_lock (mux_display);
2279
2280 for (uint i = 0; i < num_cracked; i++)
2281 {
2282 const uint hash_pos = cracked[i].hash_pos;
2283
2284 if (data.digests_shown[hash_pos] == 1) continue;
2285
2286 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2287 {
2288 data.digests_shown[hash_pos] = 1;
2289
2290 data.digests_done++;
2291
2292 cpt_cracked++;
2293
2294 salt_buf->digests_done++;
2295
2296 if (salt_buf->digests_done == salt_buf->digests_cnt)
2297 {
2298 data.salts_shown[salt_pos] = 1;
2299
2300 data.salts_done++;
2301 }
2302 }
2303
2304 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2305
2306 check_hash (device_param, &cracked[i]);
2307 }
2308
2309 hc_thread_mutex_unlock (mux_display);
2310
2311 myfree (cracked);
2312
2313 if (cpt_cracked > 0)
2314 {
2315 hc_thread_mutex_lock (mux_display);
2316
2317 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2318 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2319
2320 data.cpt_pos++;
2321
2322 data.cpt_total += cpt_cracked;
2323
2324 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2325
2326 hc_thread_mutex_unlock (mux_display);
2327 }
2328
2329 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2330 {
2331 // we need to reset cracked state on the device
2332 // otherwise host thinks again and again the hash was cracked
2333 // and returns invalid password each time
2334
2335 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2336
2337 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);
2338 }
2339
2340 num_cracked = 0;
2341
2342 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2343 }
2344 }
2345
2346 // stolen from princeprocessor ;)
2347
2348 typedef struct
2349 {
2350 FILE *fp;
2351
2352 char buf[BUFSIZ];
2353 int len;
2354
2355 } out_t;
2356
2357 static void out_flush (out_t *out)
2358 {
2359 fwrite (out->buf, 1, out->len, out->fp);
2360
2361 out->len = 0;
2362 }
2363
2364 static void out_push (out_t *out, const u8 *pw_buf, const int pw_len)
2365 {
2366 char *ptr = out->buf + out->len;
2367
2368 memcpy (ptr, pw_buf, pw_len);
2369
2370 ptr[pw_len] = '\n';
2371
2372 out->len += pw_len + 1;
2373
2374 if (out->len >= BUFSIZ - 100)
2375 {
2376 out_flush (out);
2377 }
2378 }
2379
2380 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2381 {
2382 out_t out;
2383
2384 out.fp = stdout;
2385 out.len = 0;
2386
2387 uint plain_buf[16] = { 0 };
2388
2389 u8 *plain_ptr = (u8 *) plain_buf;
2390
2391 uint plain_len = 0;
2392
2393 const uint il_cnt = device_param->kernel_params_buf32[27]; // ugly, i know
2394
2395 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2396 {
2397 pw_t pw;
2398
2399 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2400 {
2401 gidd_to_pw_t (device_param, gidvid, &pw);
2402
2403 const uint pos = device_param->innerloop_pos;
2404
2405 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2406 {
2407 for (int i = 0; i < 8; i++)
2408 {
2409 plain_buf[i] = pw.i[i];
2410 }
2411
2412 plain_len = pw.pw_len;
2413
2414 plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2415
2416 if (plain_len > data.pw_max) plain_len = data.pw_max;
2417
2418 out_push (&out, plain_ptr, plain_len);
2419 }
2420 }
2421 }
2422 else if (data.attack_mode == ATTACK_MODE_COMBI)
2423 {
2424 pw_t pw;
2425
2426 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2427 {
2428 gidd_to_pw_t (device_param, gidvid, &pw);
2429
2430 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2431 {
2432 for (int i = 0; i < 8; i++)
2433 {
2434 plain_buf[i] = pw.i[i];
2435 }
2436
2437 plain_len = pw.pw_len;
2438
2439 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2440 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2441
2442 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2443 {
2444 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2445 }
2446 else
2447 {
2448 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2449
2450 memcpy (plain_ptr, comb_buf, comb_len);
2451 }
2452
2453 plain_len += comb_len;
2454
2455 if (data.pw_max != PW_DICTMAX1)
2456 {
2457 if (plain_len > data.pw_max) plain_len = data.pw_max;
2458 }
2459
2460 out_push (&out, plain_ptr, plain_len);
2461 }
2462 }
2463 }
2464 else if (data.attack_mode == ATTACK_MODE_BF)
2465 {
2466 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2467 {
2468 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2469 {
2470 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2471 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2472
2473 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2474 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2475
2476 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2477 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2478
2479 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2480 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2481
2482 plain_len = data.css_cnt;
2483
2484 out_push (&out, plain_ptr, plain_len);
2485 }
2486 }
2487 }
2488 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2489 {
2490 pw_t pw;
2491
2492 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2493 {
2494 gidd_to_pw_t (device_param, gidvid, &pw);
2495
2496 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2497 {
2498 for (int i = 0; i < 8; i++)
2499 {
2500 plain_buf[i] = pw.i[i];
2501 }
2502
2503 plain_len = pw.pw_len;
2504
2505 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2506
2507 uint start = 0;
2508 uint stop = device_param->kernel_params_mp_buf32[4];
2509
2510 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2511
2512 plain_len += start + stop;
2513
2514 out_push (&out, plain_ptr, plain_len);
2515 }
2516 }
2517 }
2518 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2519 {
2520 pw_t pw;
2521
2522 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2523 {
2524 gidd_to_pw_t (device_param, gidvid, &pw);
2525
2526 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2527 {
2528 for (int i = 0; i < 8; i++)
2529 {
2530 plain_buf[i] = pw.i[i];
2531 }
2532
2533 plain_len = pw.pw_len;
2534
2535 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2536
2537 uint start = 0;
2538 uint stop = device_param->kernel_params_mp_buf32[4];
2539
2540 memmove (plain_ptr + stop, plain_ptr, plain_len);
2541
2542 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2543
2544 plain_len += start + stop;
2545
2546 out_push (&out, plain_ptr, plain_len);
2547 }
2548 }
2549 }
2550
2551 out_flush (&out);
2552 }
2553
2554 static void save_hash ()
2555 {
2556 char *hashfile = data.hashfile;
2557
2558 char new_hashfile[256] = { 0 };
2559 char old_hashfile[256] = { 0 };
2560
2561 snprintf (new_hashfile, 255, "%s.new", hashfile);
2562 snprintf (old_hashfile, 255, "%s.old", hashfile);
2563
2564 unlink (new_hashfile);
2565
2566 char separator = data.separator;
2567
2568 FILE *fp = fopen (new_hashfile, "wb");
2569
2570 if (fp == NULL)
2571 {
2572 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2573
2574 exit (-1);
2575 }
2576
2577 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2578 {
2579 if (data.salts_shown[salt_pos] == 1) continue;
2580
2581 salt_t *salt_buf = &data.salts_buf[salt_pos];
2582
2583 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2584 {
2585 uint idx = salt_buf->digests_offset + digest_pos;
2586
2587 if (data.digests_shown[idx] == 1) continue;
2588
2589 if (data.hash_mode != 2500)
2590 {
2591 if (data.username == 1)
2592 {
2593 user_t *user = data.hash_info[idx]->user;
2594
2595 uint i;
2596
2597 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2598
2599 fputc (separator, fp);
2600 }
2601
2602 char out_buf[HCBUFSIZ]; // scratch buffer
2603
2604 out_buf[0] = 0;
2605
2606 ascii_digest (out_buf, salt_pos, digest_pos);
2607
2608 fputs (out_buf, fp);
2609
2610 fputc ('\n', fp);
2611 }
2612 else
2613 {
2614 hccap_t hccap;
2615
2616 to_hccap_t (&hccap, salt_pos, digest_pos);
2617
2618 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2619 }
2620 }
2621 }
2622
2623 fflush (fp);
2624
2625 fclose (fp);
2626
2627 unlink (old_hashfile);
2628
2629 if (rename (hashfile, old_hashfile) != 0)
2630 {
2631 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2632
2633 exit (-1);
2634 }
2635
2636 unlink (hashfile);
2637
2638 if (rename (new_hashfile, hashfile) != 0)
2639 {
2640 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2641
2642 exit (-1);
2643 }
2644
2645 unlink (old_hashfile);
2646 }
2647
2648 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2649 {
2650 uint num_elements = num;
2651
2652 device_param->kernel_params_buf32[30] = data.combs_mode;
2653 device_param->kernel_params_buf32[31] = num;
2654
2655 uint kernel_threads = device_param->kernel_threads;
2656
2657 while (num_elements % kernel_threads) num_elements++;
2658
2659 cl_kernel kernel = NULL;
2660
2661 switch (kern_run)
2662 {
2663 case KERN_RUN_1: kernel = device_param->kernel1; break;
2664 case KERN_RUN_12: kernel = device_param->kernel12; break;
2665 case KERN_RUN_2: kernel = device_param->kernel2; break;
2666 case KERN_RUN_23: kernel = device_param->kernel23; break;
2667 case KERN_RUN_3: kernel = device_param->kernel3; break;
2668 }
2669
2670 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2671 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2672 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2673 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2674 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2675 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2676 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2677 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2678 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2679 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2680 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2681
2682 cl_event event;
2683
2684 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2685 {
2686 const size_t global_work_size[3] = { num_elements, 32, 1 };
2687 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2688
2689 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2690 }
2691 else
2692 {
2693 if (kern_run == KERN_RUN_2)
2694 {
2695 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2696 {
2697 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2698 }
2699 }
2700
2701 while (num_elements % kernel_threads) num_elements++;
2702
2703 const size_t global_work_size[3] = { num_elements, 1, 1 };
2704 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2705
2706 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2707 }
2708
2709 hc_clFlush (data.ocl, device_param->command_queue);
2710
2711 if (device_param->nvidia_spin_damp)
2712 {
2713 if (data.devices_status == STATUS_RUNNING)
2714 {
2715 if (iteration < EXPECTED_ITERATIONS)
2716 {
2717 switch (kern_run)
2718 {
2719 case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration] * device_param->nvidia_spin_damp); break;
2720 case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration] * device_param->nvidia_spin_damp); break;
2721 case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration] * device_param->nvidia_spin_damp); break;
2722 }
2723 }
2724 }
2725 }
2726
2727 hc_clWaitForEvents (data.ocl, 1, &event);
2728
2729 cl_ulong time_start;
2730 cl_ulong time_end;
2731
2732 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2733 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2734
2735 const double exec_us = (double) (time_end - time_start) / 1000;
2736
2737 if (data.devices_status == STATUS_RUNNING)
2738 {
2739 if (iteration < EXPECTED_ITERATIONS)
2740 {
2741 switch (kern_run)
2742 {
2743 case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2744 case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2745 case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2746 }
2747 }
2748 }
2749
2750 if (event_update)
2751 {
2752 uint exec_pos = device_param->exec_pos;
2753
2754 device_param->exec_ms[exec_pos] = exec_us / 1000;
2755
2756 exec_pos++;
2757
2758 if (exec_pos == EXEC_CACHE)
2759 {
2760 exec_pos = 0;
2761 }
2762
2763 device_param->exec_pos = exec_pos;
2764 }
2765
2766 hc_clReleaseEvent (data.ocl, event);
2767
2768 hc_clFinish (data.ocl, device_param->command_queue);
2769 }
2770
2771 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2772 {
2773 uint num_elements = num;
2774
2775 switch (kern_run)
2776 {
2777 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2778 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2779 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2780 }
2781
2782 // causes problems with special threads like in bcrypt
2783 // const uint kernel_threads = device_param->kernel_threads;
2784
2785 uint kernel_threads = device_param->kernel_threads;
2786
2787 while (num_elements % kernel_threads) num_elements++;
2788
2789 cl_kernel kernel = NULL;
2790
2791 switch (kern_run)
2792 {
2793 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2794 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2795 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2796 }
2797
2798 switch (kern_run)
2799 {
2800 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2801 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2802 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2803 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2804 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2805 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2806 break;
2807 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2808 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2809 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2810 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2811 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2812 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2813 break;
2814 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2815 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2816 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2817 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2818 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2819 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2820 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2821 break;
2822 }
2823
2824 const size_t global_work_size[3] = { num_elements, 1, 1 };
2825 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2826
2827 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2828
2829 hc_clFlush (data.ocl, device_param->command_queue);
2830
2831 hc_clFinish (data.ocl, device_param->command_queue);
2832 }
2833
2834 static void run_kernel_tm (hc_device_param_t *device_param)
2835 {
2836 const uint num_elements = 1024; // fixed
2837
2838 uint kernel_threads = 32;
2839
2840 cl_kernel kernel = device_param->kernel_tm;
2841
2842 const size_t global_work_size[3] = { num_elements, 1, 1 };
2843 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2844
2845 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2846
2847 hc_clFlush (data.ocl, device_param->command_queue);
2848
2849 hc_clFinish (data.ocl, device_param->command_queue);
2850 }
2851
2852 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2853 {
2854 uint num_elements = num;
2855
2856 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2857 device_param->kernel_params_amp_buf32[6] = num_elements;
2858
2859 // causes problems with special threads like in bcrypt
2860 // const uint kernel_threads = device_param->kernel_threads;
2861
2862 uint kernel_threads = device_param->kernel_threads;
2863
2864 while (num_elements % kernel_threads) num_elements++;
2865
2866 cl_kernel kernel = device_param->kernel_amp;
2867
2868 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2869 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2870
2871 const size_t global_work_size[3] = { num_elements, 1, 1 };
2872 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2873
2874 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2875
2876 hc_clFlush (data.ocl, device_param->command_queue);
2877
2878 hc_clFinish (data.ocl, device_param->command_queue);
2879 }
2880
2881 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2882 {
2883 const u32 num16d = num / 16;
2884 const u32 num16m = num % 16;
2885
2886 if (num16d)
2887 {
2888 device_param->kernel_params_memset_buf32[1] = value;
2889 device_param->kernel_params_memset_buf32[2] = num16d;
2890
2891 uint kernel_threads = device_param->kernel_threads;
2892
2893 uint num_elements = num16d;
2894
2895 while (num_elements % kernel_threads) num_elements++;
2896
2897 cl_kernel kernel = device_param->kernel_memset;
2898
2899 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2900 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2901 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2902
2903 const size_t global_work_size[3] = { num_elements, 1, 1 };
2904 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2905
2906 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2907
2908 hc_clFlush (data.ocl, device_param->command_queue);
2909
2910 hc_clFinish (data.ocl, device_param->command_queue);
2911 }
2912
2913 if (num16m)
2914 {
2915 u32 tmp[4];
2916
2917 tmp[0] = value;
2918 tmp[1] = value;
2919 tmp[2] = value;
2920 tmp[3] = value;
2921
2922 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2923 }
2924 }
2925
2926 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2927 {
2928 run_kernel_memset (device_param, buf, 0, size);
2929
2930 /*
2931 int rc = -1;
2932
2933 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2934 {
2935 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2936
2937 const cl_uchar zero = 0;
2938
2939 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2940 }
2941
2942 if (rc != 0)
2943 {
2944 // NOTE: clEnqueueFillBuffer () always fails with -59
2945 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2946 // How's that possible, OpenCL 1.2 support is advertised??
2947 // We need to workaround...
2948
2949 #define FILLSZ 0x100000
2950
2951 char *tmp = (char *) mymalloc (FILLSZ);
2952
2953 for (size_t i = 0; i < size; i += FILLSZ)
2954 {
2955 const size_t left = size - i;
2956
2957 const size_t fillsz = MIN (FILLSZ, left);
2958
2959 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2960 }
2961
2962 myfree (tmp);
2963 }
2964 */
2965 }
2966
2967 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)
2968 {
2969 if (data.hash_mode == 2000)
2970 {
2971 process_stdout (device_param, pws_cnt);
2972
2973 return;
2974 }
2975
2976 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2977 {
2978 if (attack_mode == ATTACK_MODE_BF)
2979 {
2980 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2981 {
2982 const uint size_tm = 32 * sizeof (bs_word_t);
2983
2984 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2985
2986 run_kernel_tm (device_param);
2987
2988 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);
2989 }
2990 }
2991
2992 if (highest_pw_len < 16)
2993 {
2994 run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
2995 }
2996 else if (highest_pw_len < 32)
2997 {
2998 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
2999 }
3000 else
3001 {
3002 run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
3003 }
3004 }
3005 else
3006 {
3007 run_kernel_amp (device_param, pws_cnt);
3008
3009 run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
3010
3011 if (opts_type & OPTS_TYPE_HOOK12)
3012 {
3013 run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
3014
3015 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);
3016
3017 // do something with data
3018
3019 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);
3020 }
3021
3022 uint iter = salt_buf->salt_iter;
3023
3024 uint loop_step = device_param->kernel_loops;
3025
3026 for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
3027 {
3028 uint loop_left = iter - loop_pos;
3029
3030 loop_left = MIN (loop_left, loop_step);
3031
3032 device_param->kernel_params_buf32[25] = loop_pos;
3033 device_param->kernel_params_buf32[26] = loop_left;
3034
3035 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
3036
3037 if (data.devices_status == STATUS_CRACKED) break;
3038 if (data.devices_status == STATUS_ABORTED) break;
3039 if (data.devices_status == STATUS_QUIT) break;
3040 if (data.devices_status == STATUS_BYPASS) break;
3041
3042 /**
3043 * speed
3044 */
3045
3046 const float iter_part = (float) (loop_pos + loop_left) / iter;
3047
3048 const u64 perf_sum_all = pws_cnt * iter_part;
3049
3050 double speed_ms;
3051
3052 hc_timer_get (device_param->timer_speed, speed_ms);
3053
3054 const u32 speed_pos = device_param->speed_pos;
3055
3056 device_param->speed_cnt[speed_pos] = perf_sum_all;
3057
3058 device_param->speed_ms[speed_pos] = speed_ms;
3059
3060 if (data.benchmark == 1)
3061 {
3062 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
3063 }
3064 }
3065
3066 if (opts_type & OPTS_TYPE_HOOK23)
3067 {
3068 run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
3069
3070 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
3071
3072 // do something with data
3073
3074 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
3075 }
3076
3077 run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3078 }
3079 }
3080
3081 static int run_rule_engine (const int rule_len, const char *rule_buf)
3082 {
3083 if (rule_len == 0)
3084 {
3085 return 0;
3086 }
3087 else if (rule_len == 1)
3088 {
3089 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3090 }
3091
3092 return 1;
3093 }
3094
3095 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3096 {
3097 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3098 {
3099 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3100 }
3101 else if (data.attack_kern == ATTACK_KERN_COMBI)
3102 {
3103 if (data.attack_mode == ATTACK_MODE_COMBI)
3104 {
3105 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3106 {
3107 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3108 {
3109 for (u32 i = 0; i < pws_cnt; i++)
3110 {
3111 const u32 pw_len = device_param->pws_buf[i].pw_len;
3112
3113 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3114
3115 ptr[pw_len] = 0x01;
3116 }
3117 }
3118 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3119 {
3120 for (u32 i = 0; i < pws_cnt; i++)
3121 {
3122 const u32 pw_len = device_param->pws_buf[i].pw_len;
3123
3124 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3125
3126 ptr[pw_len] = 0x80;
3127 }
3128 }
3129 }
3130 }
3131 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3132 {
3133 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3134 {
3135 for (u32 i = 0; i < pws_cnt; i++)
3136 {
3137 const u32 pw_len = device_param->pws_buf[i].pw_len;
3138
3139 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3140
3141 ptr[pw_len] = 0x01;
3142 }
3143 }
3144 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3145 {
3146 for (u32 i = 0; i < pws_cnt; i++)
3147 {
3148 const u32 pw_len = device_param->pws_buf[i].pw_len;
3149
3150 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3151
3152 ptr[pw_len] = 0x80;
3153 }
3154 }
3155 }
3156
3157 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3158 }
3159 else if (data.attack_kern == ATTACK_KERN_BF)
3160 {
3161 const u64 off = device_param->words_off;
3162
3163 device_param->kernel_params_mp_l_buf64[3] = off;
3164
3165 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3166 }
3167 }
3168
3169 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3170 {
3171 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3172
3173 device_param->kernel_params_buf32[25] = 0;
3174 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
3175 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3176
3177 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3178 {
3179 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3180 }
3181 else
3182 {
3183 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3184 }
3185
3186 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3187
3188 return exec_ms_prev;
3189 }
3190
3191 static void autotune (hc_device_param_t *device_param)
3192 {
3193 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3194
3195 const u32 kernel_accel_min = device_param->kernel_accel_min;
3196 const u32 kernel_accel_max = device_param->kernel_accel_max;
3197
3198 const u32 kernel_loops_min = device_param->kernel_loops_min;
3199 const u32 kernel_loops_max = device_param->kernel_loops_max;
3200
3201 u32 kernel_accel = kernel_accel_min;
3202 u32 kernel_loops = kernel_loops_min;
3203
3204 // in this case the user specified a fixed -u and -n on the commandline
3205 // no way to tune anything
3206 // but we need to run a few caching rounds
3207
3208 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3209 {
3210 if (data.hash_mode != 2000)
3211 {
3212 try_run (device_param, kernel_accel, kernel_loops);
3213 try_run (device_param, kernel_accel, kernel_loops);
3214 try_run (device_param, kernel_accel, kernel_loops);
3215 try_run (device_param, kernel_accel, kernel_loops);
3216 }
3217
3218 device_param->kernel_accel = kernel_accel;
3219 device_param->kernel_loops = kernel_loops;
3220
3221 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3222
3223 device_param->kernel_power = kernel_power;
3224
3225 return;
3226 }
3227
3228 // from here it's clear we are allowed to autotune
3229 // so let's init some fake words
3230
3231 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3232
3233 if (data.attack_kern == ATTACK_KERN_BF)
3234 {
3235 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3236 }
3237 else
3238 {
3239 for (u32 i = 0; i < kernel_power_max; i++)
3240 {
3241 device_param->pws_buf[i].i[0] = i;
3242 device_param->pws_buf[i].i[1] = 0x01234567;
3243 device_param->pws_buf[i].pw_len = 7 + (i & 7);
3244 }
3245
3246 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3247 }
3248
3249 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3250 {
3251 if (data.kernel_rules_cnt > 1)
3252 {
3253 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, 0, 0, MIN (kernel_loops_max, KERNEL_RULES) * sizeof (kernel_rule_t), 0, NULL, NULL);
3254 }
3255 }
3256 else
3257 {
3258 run_kernel_amp (device_param, kernel_power_max);
3259 }
3260
3261 #define VERIFIER_CNT 1
3262
3263 // first find out highest kernel-loops that stays below target_ms
3264
3265 if (kernel_loops_min < kernel_loops_max)
3266 {
3267 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3268 {
3269 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3270
3271 for (int i = 0; i < VERIFIER_CNT; i++)
3272 {
3273 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3274
3275 exec_ms = MIN (exec_ms, exec_ms_v);
3276 }
3277
3278 if (exec_ms < target_ms) break;
3279 }
3280 }
3281
3282 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3283
3284 #define STEPS_CNT 10
3285
3286 if (kernel_accel_min < kernel_accel_max)
3287 {
3288 for (int i = 0; i < STEPS_CNT; i++)
3289 {
3290 const u32 kernel_accel_try = 1 << i;
3291
3292 if (kernel_accel_try < kernel_accel_min) continue;
3293 if (kernel_accel_try > kernel_accel_max) break;
3294
3295 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3296
3297 for (int i = 0; i < VERIFIER_CNT; i++)
3298 {
3299 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3300
3301 exec_ms = MIN (exec_ms, exec_ms_v);
3302 }
3303
3304 if (exec_ms > target_ms) break;
3305
3306 kernel_accel = kernel_accel_try;
3307 }
3308 }
3309
3310 // at this point we want to know the actual runtime for the following reason:
3311 // we need a reference for the balancing loop following up, and this
3312 // the balancing loop can have an effect that the creates a new opportunity, for example:
3313 // if the target is 95 ms and the current runtime is 48ms the above loop
3314 // stopped the execution because the previous exec_ms was > 95ms
3315 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3316 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3317
3318 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3319
3320 for (int i = 0; i < VERIFIER_CNT; i++)
3321 {
3322 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3323
3324 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3325 }
3326
3327 u32 diff = kernel_loops - kernel_accel;
3328
3329 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3330 {
3331 u32 kernel_accel_orig = kernel_accel;
3332 u32 kernel_loops_orig = kernel_loops;
3333
3334 for (u32 f = 1; f < 1024; f++)
3335 {
3336 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3337 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3338
3339 if (kernel_accel_try > kernel_accel_max) break;
3340 if (kernel_loops_try < kernel_loops_min) break;
3341
3342 u32 diff_new = kernel_loops_try - kernel_accel_try;
3343
3344 if (diff_new > diff) break;
3345
3346 diff_new = diff;
3347
3348 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3349
3350 for (int i = 0; i < VERIFIER_CNT; i++)
3351 {
3352 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3353
3354 exec_ms = MIN (exec_ms, exec_ms_v);
3355 }
3356
3357 if (exec_ms < exec_ms_pre_final)
3358 {
3359 exec_ms_pre_final = exec_ms;
3360
3361 kernel_accel = kernel_accel_try;
3362 kernel_loops = kernel_loops_try;
3363 }
3364 }
3365 }
3366
3367 const double exec_left = target_ms / exec_ms_pre_final;
3368
3369 const double accel_left = kernel_accel_max / kernel_accel;
3370
3371 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3372
3373 if (exec_accel_min >= 1.0)
3374 {
3375 // this is safe to not overflow kernel_accel_max because of accel_left
3376
3377 kernel_accel = (double) kernel_accel * exec_accel_min;
3378 }
3379
3380 // reset them fake words
3381
3382 /*
3383 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3384
3385 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3386 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3387 */
3388
3389 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3390
3391 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3392 {
3393 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3394 }
3395
3396 // reset timer
3397
3398 device_param->exec_pos = 0;
3399
3400 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3401
3402 memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3403 memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3404 memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3405
3406 // store
3407
3408 device_param->kernel_accel = kernel_accel;
3409 device_param->kernel_loops = kernel_loops;
3410
3411 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3412
3413 device_param->kernel_power = kernel_power;
3414
3415 #ifdef DEBUG
3416
3417 if (data.quiet == 0)
3418 {
3419 clear_prompt ();
3420
3421 log_info ("- Device #%u: autotuned kernel-accel to %u\n"
3422 "- Device #%u: autotuned kernel-loops to %u\n",
3423 device_param->device_id + 1, kernel_accel,
3424 device_param->device_id + 1, kernel_loops);
3425
3426 fprintf (stdout, "%s", PROMPT);
3427
3428 fflush (stdout);
3429 }
3430
3431 #endif
3432 }
3433
3434 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3435 {
3436 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3437
3438 // init speed timer
3439
3440 uint speed_pos = device_param->speed_pos;
3441
3442 #ifdef _POSIX
3443 if (device_param->timer_speed.tv_sec == 0)
3444 {
3445 hc_timer_set (&device_param->timer_speed);
3446 }
3447 #endif
3448
3449 #ifdef _WIN
3450 if (device_param->timer_speed.QuadPart == 0)
3451 {
3452 hc_timer_set (&device_param->timer_speed);
3453 }
3454 #endif
3455
3456 // find higest password length, this is for optimization stuff
3457
3458 uint highest_pw_len = 0;
3459
3460 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3461 {
3462 }
3463 else if (data.attack_kern == ATTACK_KERN_COMBI)
3464 {
3465 }
3466 else if (data.attack_kern == ATTACK_KERN_BF)
3467 {
3468 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3469 + device_param->kernel_params_mp_l_buf32[5];
3470 }
3471
3472 // iteration type
3473
3474 uint innerloop_step = 0;
3475 uint innerloop_cnt = 0;
3476
3477 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3478 else innerloop_step = 1;
3479
3480 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3481 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3482 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3483
3484 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3485
3486 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3487 {
3488 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3489
3490 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3491
3492 if (data.devices_status == STATUS_CRACKED) break;
3493 if (data.devices_status == STATUS_ABORTED) break;
3494 if (data.devices_status == STATUS_QUIT) break;
3495 if (data.devices_status == STATUS_BYPASS) break;
3496
3497 salt_t *salt_buf = &data.salts_buf[salt_pos];
3498
3499 device_param->kernel_params_buf32[24] = salt_pos;
3500 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3501 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3502
3503 FILE *combs_fp = device_param->combs_fp;
3504
3505 if (data.attack_mode == ATTACK_MODE_COMBI)
3506 {
3507 rewind (combs_fp);
3508 }
3509
3510 // innerloops
3511
3512 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3513 {
3514 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3515
3516 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3517
3518 if (data.devices_status == STATUS_CRACKED) break;
3519 if (data.devices_status == STATUS_ABORTED) break;
3520 if (data.devices_status == STATUS_QUIT) break;
3521 if (data.devices_status == STATUS_BYPASS) break;
3522
3523 uint fast_iteration = 0;
3524
3525 uint innerloop_left = innerloop_cnt - innerloop_pos;
3526
3527 if (innerloop_left > innerloop_step)
3528 {
3529 innerloop_left = innerloop_step;
3530
3531 fast_iteration = 1;
3532 }
3533
3534 device_param->innerloop_pos = innerloop_pos;
3535 device_param->innerloop_left = innerloop_left;
3536
3537 device_param->kernel_params_buf32[27] = innerloop_left;
3538
3539 // i think we can get rid of this
3540 if (innerloop_left == 0)
3541 {
3542 puts ("bug, how should this happen????\n");
3543
3544 continue;
3545 }
3546
3547 if (data.salts_shown[salt_pos] == 1)
3548 {
3549 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3550
3551 continue;
3552 }
3553
3554 // initialize amplifiers
3555
3556 if (data.attack_mode == ATTACK_MODE_COMBI)
3557 {
3558 uint i = 0;
3559
3560 while (i < innerloop_left)
3561 {
3562 if (feof (combs_fp)) break;
3563
3564 int line_len = fgetl (combs_fp, line_buf);
3565
3566 if (line_len >= PW_MAX1) continue;
3567
3568 line_len = convert_from_hex (line_buf, line_len);
3569
3570 char *line_buf_new = line_buf;
3571
3572 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3573 {
3574 char rule_buf_out[BLOCK_SIZE] = { 0 };
3575
3576 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3577
3578 if (rule_len_out < 0)
3579 {
3580 data.words_progress_rejected[salt_pos] += pws_cnt;
3581
3582 continue;
3583 }
3584
3585 line_len = rule_len_out;
3586
3587 line_buf_new = rule_buf_out;
3588 }
3589
3590 line_len = MIN (line_len, PW_DICTMAX);
3591
3592 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3593
3594 memcpy (ptr, line_buf_new, line_len);
3595
3596 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3597
3598 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3599 {
3600 uppercase (ptr, line_len);
3601 }
3602
3603 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3604 {
3605 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3606 {
3607 ptr[line_len] = 0x80;
3608 }
3609
3610 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3611 {
3612 ptr[line_len] = 0x01;
3613 }
3614 }
3615
3616 device_param->combs_buf[i].pw_len = line_len;
3617
3618 i++;
3619 }
3620
3621 for (uint j = i; j < innerloop_left; j++)
3622 {
3623 device_param->combs_buf[j].i[0] = 0;
3624 device_param->combs_buf[j].i[1] = 0;
3625 device_param->combs_buf[j].i[2] = 0;
3626 device_param->combs_buf[j].i[3] = 0;
3627 device_param->combs_buf[j].i[4] = 0;
3628 device_param->combs_buf[j].i[5] = 0;
3629 device_param->combs_buf[j].i[6] = 0;
3630 device_param->combs_buf[j].i[7] = 0;
3631
3632 device_param->combs_buf[j].pw_len = 0;
3633 }
3634
3635 innerloop_left = i;
3636 }
3637 else if (data.attack_mode == ATTACK_MODE_BF)
3638 {
3639 u64 off = innerloop_pos;
3640
3641 device_param->kernel_params_mp_r_buf64[3] = off;
3642
3643 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3644 }
3645 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3646 {
3647 u64 off = innerloop_pos;
3648
3649 device_param->kernel_params_mp_buf64[3] = off;
3650
3651 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3652 }
3653 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3654 {
3655 u64 off = innerloop_pos;
3656
3657 device_param->kernel_params_mp_buf64[3] = off;
3658
3659 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3660 }
3661
3662 // copy amplifiers
3663
3664 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3665 {
3666 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
3667 }
3668 else if (data.attack_mode == ATTACK_MODE_COMBI)
3669 {
3670 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
3671 }
3672 else if (data.attack_mode == ATTACK_MODE_BF)
3673 {
3674 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
3675 }
3676 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3677 {
3678 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3679 }
3680 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3681 {
3682 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3683 }
3684
3685 if (data.benchmark == 1)
3686 {
3687 hc_timer_set (&device_param->timer_speed);
3688 }
3689
3690 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
3691
3692 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3693
3694 if (data.devices_status == STATUS_CRACKED) break;
3695 if (data.devices_status == STATUS_ABORTED) break;
3696 if (data.devices_status == STATUS_QUIT) break;
3697 if (data.devices_status == STATUS_BYPASS) break;
3698
3699 /**
3700 * result
3701 */
3702
3703 if (data.benchmark == 0)
3704 {
3705 check_cracked (device_param, salt_pos);
3706 }
3707
3708 /**
3709 * progress
3710 */
3711
3712 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3713
3714 hc_thread_mutex_lock (mux_counter);
3715
3716 data.words_progress_done[salt_pos] += perf_sum_all;
3717
3718 hc_thread_mutex_unlock (mux_counter);
3719
3720 /**
3721 * speed
3722 */
3723
3724 double speed_ms;
3725
3726 hc_timer_get (device_param->timer_speed, speed_ms);
3727
3728 hc_timer_set (&device_param->timer_speed);
3729
3730 // current speed
3731
3732 //hc_thread_mutex_lock (mux_display);
3733
3734 device_param->speed_cnt[speed_pos] = perf_sum_all;
3735
3736 device_param->speed_ms[speed_pos] = speed_ms;
3737
3738 //hc_thread_mutex_unlock (mux_display);
3739
3740 speed_pos++;
3741
3742 if (speed_pos == SPEED_CACHE)
3743 {
3744 speed_pos = 0;
3745 }
3746
3747 /**
3748 * benchmark
3749 */
3750
3751 if (data.benchmark == 1) break;
3752 }
3753 }
3754
3755 device_param->speed_pos = speed_pos;
3756
3757 myfree (line_buf);
3758 }
3759
3760 static void load_segment (wl_data_t *wl_data, FILE *fd)
3761 {
3762 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3763
3764 wl_data->pos = 0;
3765
3766 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3767
3768 wl_data->buf[wl_data->cnt] = 0;
3769
3770 if (wl_data->cnt == 0) return;
3771
3772 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3773
3774 while (!feof (fd))
3775 {
3776 if (wl_data->cnt == wl_data->avail)
3777 {
3778 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3779
3780 wl_data->avail += wl_data->incr;
3781 }
3782
3783 const int c = fgetc (fd);
3784
3785 if (c == EOF) break;
3786
3787 wl_data->buf[wl_data->cnt] = (char) c;
3788
3789 wl_data->cnt++;
3790
3791 if (c == '\n') break;
3792 }
3793
3794 // ensure stream ends with a newline
3795
3796 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3797 {
3798 wl_data->cnt++;
3799
3800 wl_data->buf[wl_data->cnt - 1] = '\n';
3801 }
3802
3803 return;
3804 }
3805
3806 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3807 {
3808 char *ptr = buf;
3809
3810 for (u32 i = 0; i < sz; i++, ptr++)
3811 {
3812 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3813
3814 if (i == 7)
3815 {
3816 *off = i;
3817 *len = i;
3818
3819 return;
3820 }
3821
3822 if (*ptr != '\n') continue;
3823
3824 *off = i + 1;
3825
3826 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3827
3828 *len = i;
3829
3830 return;
3831 }
3832
3833 *off = sz;
3834 *len = sz;
3835 }
3836
3837 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3838 {
3839 char *ptr = buf;
3840
3841 for (u32 i = 0; i < sz; i++, ptr++)
3842 {
3843 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3844
3845 if (*ptr != '\n') continue;
3846
3847 *off = i + 1;
3848
3849 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3850
3851 *len = i;
3852
3853 return;
3854 }
3855
3856 *off = sz;
3857 *len = sz;
3858 }
3859
3860 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3861 {
3862 char *ptr = buf;
3863
3864 for (u32 i = 0; i < sz; i++, ptr++)
3865 {
3866 if (*ptr != '\n') continue;
3867
3868 *off = i + 1;
3869
3870 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3871
3872 *len = i;
3873
3874 return;
3875 }
3876
3877 *off = sz;
3878 *len = sz;
3879 }
3880
3881 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3882 {
3883 while (wl_data->pos < wl_data->cnt)
3884 {
3885 uint off;
3886 uint len;
3887
3888 char *ptr = wl_data->buf + wl_data->pos;
3889
3890 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3891
3892 wl_data->pos += off;
3893
3894 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3895 {
3896 char rule_buf_out[BLOCK_SIZE] = { 0 };
3897
3898 int rule_len_out = -1;
3899
3900 if (len < BLOCK_SIZE)
3901 {
3902 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3903 }
3904
3905 if (rule_len_out < 0)
3906 {
3907 continue;
3908 }
3909
3910 if (rule_len_out > PW_MAX)
3911 {
3912 continue;
3913 }
3914 }
3915 else
3916 {
3917 if (len > PW_MAX)
3918 {
3919 continue;
3920 }
3921 }
3922
3923 *out_buf = ptr;
3924 *out_len = len;
3925
3926 return;
3927 }
3928
3929 if (feof (fd))
3930 {
3931 fprintf (stderr, "BUG feof()!!\n");
3932
3933 return;
3934 }
3935
3936 load_segment (wl_data, fd);
3937
3938 get_next_word (wl_data, fd, out_buf, out_len);
3939 }
3940
3941 #ifdef _POSIX
3942 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3943 #endif
3944
3945 #ifdef _WIN
3946 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3947 #endif
3948 {
3949 hc_signal (NULL);
3950
3951 dictstat_t d;
3952
3953 d.cnt = 0;
3954
3955 #ifdef _POSIX
3956 fstat (fileno (fd), &d.stat);
3957 #endif
3958
3959 #ifdef _WIN
3960 _fstat64 (fileno (fd), &d.stat);
3961 #endif
3962
3963 d.stat.st_mode = 0;
3964 d.stat.st_nlink = 0;
3965 d.stat.st_uid = 0;
3966 d.stat.st_gid = 0;
3967 d.stat.st_rdev = 0;
3968 d.stat.st_atime = 0;
3969
3970 #ifdef _POSIX
3971 d.stat.st_blksize = 0;
3972 d.stat.st_blocks = 0;
3973 #endif
3974
3975 if (d.stat.st_size == 0) return 0;
3976
3977 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3978
3979 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3980 {
3981 if (d_cache)
3982 {
3983 u64 cnt = d_cache->cnt;
3984
3985 u64 keyspace = cnt;
3986
3987 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3988 {
3989 keyspace *= data.kernel_rules_cnt;
3990 }
3991 else if (data.attack_kern == ATTACK_KERN_COMBI)
3992 {
3993 keyspace *= data.combs_cnt;
3994 }
3995
3996 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);
3997 if (data.quiet == 0) log_info ("");
3998
3999 hc_signal (sigHandler_default);
4000
4001 return (keyspace);
4002 }
4003 }
4004
4005 time_t now = 0;
4006 time_t prev = 0;
4007
4008 u64 comp = 0;
4009 u64 cnt = 0;
4010 u64 cnt2 = 0;
4011
4012 while (!feof (fd))
4013 {
4014 load_segment (wl_data, fd);
4015
4016 comp += wl_data->cnt;
4017
4018 u32 i = 0;
4019
4020 while (i < wl_data->cnt)
4021 {
4022 u32 len;
4023 u32 off;
4024
4025 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
4026
4027 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4028 {
4029 char rule_buf_out[BLOCK_SIZE] = { 0 };
4030
4031 int rule_len_out = -1;
4032
4033 if (len < BLOCK_SIZE)
4034 {
4035 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
4036 }
4037
4038 if (rule_len_out < 0)
4039 {
4040 len = PW_MAX1;
4041 }
4042 else
4043 {
4044 len = rule_len_out;
4045 }
4046 }
4047
4048 if (len < PW_MAX1)
4049 {
4050 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4051 {
4052 cnt += data.kernel_rules_cnt;
4053 }
4054 else if (data.attack_kern == ATTACK_KERN_COMBI)
4055 {
4056 cnt += data.combs_cnt;
4057 }
4058
4059 d.cnt++;
4060 }
4061
4062 i += off;
4063
4064 cnt2++;
4065 }
4066
4067 time (&now);
4068
4069 if ((now - prev) == 0) continue;
4070
4071 float percent = (float) comp / (float) d.stat.st_size;
4072
4073 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);
4074
4075 time (&prev);
4076 }
4077
4078 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);
4079 if (data.quiet == 0) log_info ("");
4080
4081 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4082
4083 hc_signal (sigHandler_default);
4084
4085 return (cnt);
4086 }
4087
4088 static void *thread_monitor (void *p)
4089 {
4090 uint runtime_check = 0;
4091 uint remove_check = 0;
4092 uint status_check = 0;
4093 uint restore_check = 0;
4094
4095 uint restore_left = data.restore_timer;
4096 uint remove_left = data.remove_timer;
4097 uint status_left = data.status_timer;
4098
4099 #ifdef HAVE_HWMON
4100 uint hwmon_check = 0;
4101
4102 int slowdown_warnings = 0;
4103
4104 // these variables are mainly used for fan control
4105
4106 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4107
4108 // temperature controller "loopback" values
4109
4110 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4111 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4112
4113 int temp_threshold = 1; // degrees celcius
4114
4115 int fan_speed_min = 15; // in percentage
4116 int fan_speed_max = 100;
4117
4118 time_t last_temp_check_time;
4119 #endif // HAVE_HWMON
4120
4121 uint sleep_time = 1;
4122
4123 if (data.runtime)
4124 {
4125 runtime_check = 1;
4126 }
4127
4128 if (data.restore_timer)
4129 {
4130 restore_check = 1;
4131 }
4132
4133 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4134 {
4135 remove_check = 1;
4136 }
4137
4138 if (data.status == 1)
4139 {
4140 status_check = 1;
4141 }
4142
4143 #ifdef HAVE_HWMON
4144 if (data.gpu_temp_disable == 0)
4145 {
4146 time (&last_temp_check_time);
4147
4148 hwmon_check = 1;
4149 }
4150 #endif
4151
4152 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4153 {
4154 #ifdef HAVE_HWMON
4155 if (hwmon_check == 0)
4156 #endif
4157 return (p);
4158 }
4159
4160 while (data.shutdown_inner == 0)
4161 {
4162 hc_sleep (sleep_time);
4163
4164 if (data.devices_status != STATUS_RUNNING) continue;
4165
4166 #ifdef HAVE_HWMON
4167
4168 if (hwmon_check == 1)
4169 {
4170 hc_thread_mutex_lock (mux_adl);
4171
4172 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4173 {
4174 hc_device_param_t *device_param = &data.devices_param[device_id];
4175
4176 if (device_param->skipped) continue;
4177
4178 if (device_param->device_vendor_id == VENDOR_ID_NV)
4179 {
4180 if (data.hm_nvapi)
4181 {
4182 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
4183 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
4184
4185 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4186 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4187
4188 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4189
4190 perfPolicies_status.info_value = perfPolicies_info.info_value;
4191
4192 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4193
4194 if (perfPolicies_status.throttle & 2)
4195 {
4196 if (slowdown_warnings < 3)
4197 {
4198 if (data.quiet == 0) clear_prompt ();
4199
4200 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4201
4202 if (slowdown_warnings == 2)
4203 {
4204 log_info ("");
4205 }
4206
4207 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4208 if (data.quiet == 0) fflush (stdout);
4209
4210 slowdown_warnings++;
4211 }
4212 }
4213 else
4214 {
4215 slowdown_warnings = 0;
4216 }
4217 }
4218 }
4219 }
4220
4221 hc_thread_mutex_unlock (mux_adl);
4222 }
4223
4224 if (hwmon_check == 1)
4225 {
4226 hc_thread_mutex_lock (mux_adl);
4227
4228 time_t temp_check_time;
4229
4230 time (&temp_check_time);
4231
4232 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4233
4234 if (Ta == 0) Ta = 1;
4235
4236 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4237 {
4238 hc_device_param_t *device_param = &data.devices_param[device_id];
4239
4240 if (device_param->skipped) continue;
4241
4242 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4243
4244 const int temperature = hm_get_temperature_with_device_id (device_id);
4245
4246 if (temperature > (int) data.gpu_temp_abort)
4247 {
4248 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4249
4250 if (data.devices_status != STATUS_QUIT) myabort ();
4251
4252 break;
4253 }
4254
4255 const int gpu_temp_retain = data.gpu_temp_retain;
4256
4257 if (gpu_temp_retain)
4258 {
4259 if (data.hm_device[device_id].fan_set_supported == 1)
4260 {
4261 int temp_cur = temperature;
4262
4263 int temp_diff_new = gpu_temp_retain - temp_cur;
4264
4265 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4266
4267 // calculate Ta value (time difference in seconds between the last check and this check)
4268
4269 last_temp_check_time = temp_check_time;
4270
4271 float Kp = 1.8;
4272 float Ki = 0.005;
4273 float Kd = 6;
4274
4275 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4276
4277 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);
4278
4279 if (abs (fan_diff_required) >= temp_threshold)
4280 {
4281 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4282
4283 int fan_speed_level = fan_speed_cur;
4284
4285 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4286
4287 int fan_speed_new = fan_speed_level - fan_diff_required;
4288
4289 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4290 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4291
4292 if (fan_speed_new != fan_speed_cur)
4293 {
4294 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4295 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4296
4297 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4298 {
4299 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4300 {
4301 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4302 }
4303 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4304 {
4305 #ifdef WIN
4306 hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1);
4307 #endif
4308
4309 #ifdef LINUX
4310 hm_set_fanspeed_with_device_id_xnvctrl (device_id, fan_speed_new);
4311 #endif
4312 }
4313
4314 fan_speed_chgd[device_id] = 1;
4315 }
4316
4317 temp_diff_old[device_id] = temp_diff_new;
4318 }
4319 }
4320 }
4321 }
4322 }
4323
4324 hc_thread_mutex_unlock (mux_adl);
4325 }
4326 #endif // HAVE_HWMON
4327
4328 if (restore_check == 1)
4329 {
4330 restore_left--;
4331
4332 if (restore_left == 0)
4333 {
4334 if (data.restore_disable == 0) cycle_restore ();
4335
4336 restore_left = data.restore_timer;
4337 }
4338 }
4339
4340 if ((runtime_check == 1) && (data.runtime_start > 0))
4341 {
4342 time_t runtime_cur;
4343
4344 time (&runtime_cur);
4345
4346 int runtime_left = data.proc_start + data.runtime - runtime_cur;
4347
4348 if (runtime_left <= 0)
4349 {
4350 if (data.benchmark == 0)
4351 {
4352 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4353 }
4354
4355 if (data.devices_status != STATUS_QUIT) myabort ();
4356 }
4357 }
4358
4359 if (remove_check == 1)
4360 {
4361 remove_left--;
4362
4363 if (remove_left == 0)
4364 {
4365 if (data.digests_saved != data.digests_done)
4366 {
4367 data.digests_saved = data.digests_done;
4368
4369 save_hash ();
4370 }
4371
4372 remove_left = data.remove_timer;
4373 }
4374 }
4375
4376 if (status_check == 1)
4377 {
4378 status_left--;
4379
4380 if (status_left == 0)
4381 {
4382 hc_thread_mutex_lock (mux_display);
4383
4384 if (data.quiet == 0) clear_prompt ();
4385
4386 if (data.quiet == 0) log_info ("");
4387
4388 status_display ();
4389
4390 if (data.quiet == 0) log_info ("");
4391
4392 hc_thread_mutex_unlock (mux_display);
4393
4394 status_left = data.status_timer;
4395 }
4396 }
4397 }
4398
4399 #ifdef HAVE_HWMON
4400 myfree (fan_speed_chgd);
4401
4402 myfree (temp_diff_old);
4403 myfree (temp_diff_sum);
4404 #endif
4405
4406 p = NULL;
4407
4408 return (p);
4409 }
4410
4411 static void *thread_outfile_remove (void *p)
4412 {
4413 // some hash-dependent constants
4414 char *outfile_dir = data.outfile_check_directory;
4415 uint dgst_size = data.dgst_size;
4416 uint isSalted = data.isSalted;
4417 uint esalt_size = data.esalt_size;
4418 uint hash_mode = data.hash_mode;
4419
4420 uint outfile_check_timer = data.outfile_check_timer;
4421
4422 char separator = data.separator;
4423
4424 // some hash-dependent functions
4425 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4426 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4427
4428 // buffers
4429 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4430
4431 hash_buf.digest = mymalloc (dgst_size);
4432
4433 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4434
4435 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4436
4437 uint digest_buf[64] = { 0 };
4438
4439 outfile_data_t *out_info = NULL;
4440
4441 char **out_files = NULL;
4442
4443 time_t folder_mtime = 0;
4444
4445 int out_cnt = 0;
4446
4447 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4448
4449 while (data.shutdown_inner == 0)
4450 {
4451 hc_sleep (1);
4452
4453 if (data.devices_status != STATUS_RUNNING) continue;
4454
4455 check_left--;
4456
4457 if (check_left == 0)
4458 {
4459 struct stat outfile_check_stat;
4460
4461 if (stat (outfile_dir, &outfile_check_stat) == 0)
4462 {
4463 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4464
4465 if (is_dir == 1)
4466 {
4467 if (outfile_check_stat.st_mtime > folder_mtime)
4468 {
4469 char **out_files_new = scan_directory (outfile_dir);
4470
4471 int out_cnt_new = count_dictionaries (out_files_new);
4472
4473 outfile_data_t *out_info_new = NULL;
4474
4475 if (out_cnt_new > 0)
4476 {
4477 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4478
4479 for (int i = 0; i < out_cnt_new; i++)
4480 {
4481 out_info_new[i].file_name = out_files_new[i];
4482
4483 // check if there are files that we have seen/checked before (and not changed)
4484
4485 for (int j = 0; j < out_cnt; j++)
4486 {
4487 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4488 {
4489 struct stat outfile_stat;
4490
4491 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4492 {
4493 if (outfile_stat.st_ctime == out_info[j].ctime)
4494 {
4495 out_info_new[i].ctime = out_info[j].ctime;
4496 out_info_new[i].seek = out_info[j].seek;
4497 }
4498 }
4499 }
4500 }
4501 }
4502 }
4503
4504 local_free (out_info);
4505 local_free (out_files);
4506
4507 out_files = out_files_new;
4508 out_cnt = out_cnt_new;
4509 out_info = out_info_new;
4510
4511 folder_mtime = outfile_check_stat.st_mtime;
4512 }
4513
4514 for (int j = 0; j < out_cnt; j++)
4515 {
4516 FILE *fp = fopen (out_info[j].file_name, "rb");
4517
4518 if (fp != NULL)
4519 {
4520 //hc_thread_mutex_lock (mux_display);
4521
4522 #ifdef _POSIX
4523 struct stat outfile_stat;
4524
4525 fstat (fileno (fp), &outfile_stat);
4526 #endif
4527
4528 #ifdef _WIN
4529 struct stat64 outfile_stat;
4530
4531 _fstat64 (fileno (fp), &outfile_stat);
4532 #endif
4533
4534 if (outfile_stat.st_ctime > out_info[j].ctime)
4535 {
4536 out_info[j].ctime = outfile_stat.st_ctime;
4537 out_info[j].seek = 0;
4538 }
4539
4540 fseek (fp, out_info[j].seek, SEEK_SET);
4541
4542 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4543
4544 while (!feof (fp))
4545 {
4546 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4547
4548 if (ptr == NULL) break;
4549
4550 int line_len = strlen (line_buf);
4551
4552 if (line_len <= 0) continue;
4553
4554 int iter = MAX_CUT_TRIES;
4555
4556 for (uint i = line_len - 1; i && iter; i--, line_len--)
4557 {
4558 if (line_buf[i] != separator) continue;
4559
4560 int parser_status = PARSER_OK;
4561
4562 if ((hash_mode != 2500) && (hash_mode != 6800))
4563 {
4564 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4565 }
4566
4567 uint found = 0;
4568
4569 if (parser_status == PARSER_OK)
4570 {
4571 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4572 {
4573 if (data.salts_shown[salt_pos] == 1) continue;
4574
4575 salt_t *salt_buf = &data.salts_buf[salt_pos];
4576
4577 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4578 {
4579 uint idx = salt_buf->digests_offset + digest_pos;
4580
4581 if (data.digests_shown[idx] == 1) continue;
4582
4583 uint cracked = 0;
4584
4585 if (hash_mode == 6800)
4586 {
4587 if (i == salt_buf->salt_len)
4588 {
4589 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4590 }
4591 }
4592 else if (hash_mode == 2500)
4593 {
4594 // BSSID : MAC1 : MAC2 (:plain)
4595 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4596 {
4597 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4598
4599 if (!cracked) continue;
4600
4601 // now compare MAC1 and MAC2 too, since we have this additional info
4602 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4603 char *mac2_pos = mac1_pos + 12 + 1;
4604
4605 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4606 wpa_t *wpa = &wpas[salt_pos];
4607
4608 // compare hex string(s) vs binary MAC address(es)
4609
4610 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4611 {
4612 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4613 {
4614 cracked = 0;
4615
4616 break;
4617 }
4618 }
4619
4620 // early skip ;)
4621 if (!cracked) continue;
4622
4623 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4624 {
4625 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4626 {
4627 cracked = 0;
4628
4629 break;
4630 }
4631 }
4632 }
4633 }
4634 else
4635 {
4636 char *digests_buf_ptr = (char *) data.digests_buf;
4637
4638 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4639
4640 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4641 }
4642
4643 if (cracked == 1)
4644 {
4645 found = 1;
4646
4647 data.digests_shown[idx] = 1;
4648
4649 data.digests_done++;
4650
4651 salt_buf->digests_done++;
4652
4653 if (salt_buf->digests_done == salt_buf->digests_cnt)
4654 {
4655 data.salts_shown[salt_pos] = 1;
4656
4657 data.salts_done++;
4658
4659 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4660 }
4661 }
4662 }
4663
4664 if (data.devices_status == STATUS_CRACKED) break;
4665 }
4666 }
4667
4668 if (found) break;
4669
4670 if (data.devices_status == STATUS_CRACKED) break;
4671
4672 iter--;
4673 }
4674
4675 if (data.devices_status == STATUS_CRACKED) break;
4676 }
4677
4678 myfree (line_buf);
4679
4680 out_info[j].seek = ftell (fp);
4681
4682 //hc_thread_mutex_unlock (mux_display);
4683
4684 fclose (fp);
4685 }
4686 }
4687 }
4688 }
4689
4690 check_left = outfile_check_timer;
4691 }
4692 }
4693
4694 if (esalt_size) local_free (hash_buf.esalt);
4695
4696 if (isSalted) local_free (hash_buf.salt);
4697
4698 local_free (hash_buf.digest);
4699
4700 local_free (out_info);
4701
4702 local_free (out_files);
4703
4704 p = NULL;
4705
4706 return (p);
4707 }
4708
4709 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4710 {
4711 //if (device_param->pws_cnt < device_param->kernel_power)
4712 //{
4713 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4714
4715 u8 *ptr = (u8 *) pw->i;
4716
4717 memcpy (ptr, pw_buf, pw_len);
4718
4719 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4720
4721 pw->pw_len = pw_len;
4722
4723 device_param->pws_cnt++;
4724 //}
4725 //else
4726 //{
4727 // fprintf (stderr, "BUG pw_add()!!\n");
4728 //
4729 // return;
4730 //}
4731 }
4732
4733 static void set_kernel_power_final (const u64 kernel_power_final)
4734 {
4735 if (data.quiet == 0)
4736 {
4737 clear_prompt ();
4738
4739 //log_info ("");
4740
4741 log_info ("INFO: approaching final keyspace, workload adjusted");
4742 log_info ("");
4743
4744 fprintf (stdout, "%s", PROMPT);
4745
4746 fflush (stdout);
4747 }
4748
4749 data.kernel_power_final = kernel_power_final;
4750 }
4751
4752 static u32 get_power (hc_device_param_t *device_param)
4753 {
4754 const u64 kernel_power_final = data.kernel_power_final;
4755
4756 if (kernel_power_final)
4757 {
4758 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4759
4760 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4761
4762 // work should be at least the hardware power available without any accelerator
4763
4764 const u64 work = MAX (words_left_device, device_param->hardware_power);
4765
4766 return work;
4767 }
4768
4769 return device_param->kernel_power;
4770 }
4771
4772 static uint get_work (hc_device_param_t *device_param, const u64 max)
4773 {
4774 hc_thread_mutex_lock (mux_dispatcher);
4775
4776 const u64 words_cur = data.words_cur;
4777 const u64 words_base = (data.limit == 0) ? data.words_base : MIN (data.limit, data.words_base);
4778
4779 device_param->words_off = words_cur;
4780
4781 const u64 kernel_power_all = data.kernel_power_all;
4782
4783 const u64 words_left = words_base - words_cur;
4784
4785 if (words_left < kernel_power_all)
4786 {
4787 if (data.kernel_power_final == 0)
4788 {
4789 set_kernel_power_final (words_left);
4790 }
4791 }
4792
4793 const u32 kernel_power = get_power (device_param);
4794
4795 uint work = MIN (words_left, kernel_power);
4796
4797 work = MIN (work, max);
4798
4799 data.words_cur += work;
4800
4801 hc_thread_mutex_unlock (mux_dispatcher);
4802
4803 return work;
4804 }
4805
4806 static void *thread_autotune (void *p)
4807 {
4808 hc_device_param_t *device_param = (hc_device_param_t *) p;
4809
4810 if (device_param->skipped) return NULL;
4811
4812 autotune (device_param);
4813
4814 return NULL;
4815 }
4816
4817 static void *thread_calc_stdin (void *p)
4818 {
4819 hc_device_param_t *device_param = (hc_device_param_t *) p;
4820
4821 if (device_param->skipped) return NULL;
4822
4823 char *buf = (char *) mymalloc (HCBUFSIZ);
4824
4825 const uint attack_kern = data.attack_kern;
4826
4827 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4828 {
4829 hc_thread_mutex_lock (mux_dispatcher);
4830
4831 if (feof (stdin) != 0)
4832 {
4833 hc_thread_mutex_unlock (mux_dispatcher);
4834
4835 break;
4836 }
4837
4838 uint words_cur = 0;
4839
4840 while (words_cur < device_param->kernel_power)
4841 {
4842 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4843
4844 if (line_buf == NULL) break;
4845
4846 uint line_len = in_superchop (line_buf);
4847
4848 line_len = convert_from_hex (line_buf, line_len);
4849
4850 // post-process rule engine
4851
4852 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4853 {
4854 char rule_buf_out[BLOCK_SIZE] = { 0 };
4855
4856 int rule_len_out = -1;
4857
4858 if (line_len < BLOCK_SIZE)
4859 {
4860 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4861 }
4862
4863 if (rule_len_out < 0) continue;
4864
4865 line_buf = rule_buf_out;
4866 line_len = rule_len_out;
4867 }
4868
4869 if (line_len > PW_MAX)
4870 {
4871 continue;
4872 }
4873
4874 // hmm that's always the case, or?
4875
4876 if (attack_kern == ATTACK_KERN_STRAIGHT)
4877 {
4878 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4879 {
4880 hc_thread_mutex_lock (mux_counter);
4881
4882 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4883 {
4884 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4885 }
4886
4887 hc_thread_mutex_unlock (mux_counter);
4888
4889 continue;
4890 }
4891 }
4892
4893 pw_add (device_param, (u8 *) line_buf, line_len);
4894
4895 words_cur++;
4896
4897 if (data.devices_status == STATUS_CRACKED) break;
4898 if (data.devices_status == STATUS_ABORTED) break;
4899 if (data.devices_status == STATUS_QUIT) break;
4900 if (data.devices_status == STATUS_BYPASS) break;
4901 }
4902
4903 hc_thread_mutex_unlock (mux_dispatcher);
4904
4905 if (data.devices_status == STATUS_CRACKED) break;
4906 if (data.devices_status == STATUS_ABORTED) break;
4907 if (data.devices_status == STATUS_QUIT) break;
4908 if (data.devices_status == STATUS_BYPASS) break;
4909
4910 // flush
4911
4912 const uint pws_cnt = device_param->pws_cnt;
4913
4914 if (pws_cnt)
4915 {
4916 run_copy (device_param, pws_cnt);
4917
4918 run_cracker (device_param, pws_cnt);
4919
4920 device_param->pws_cnt = 0;
4921
4922 /*
4923 still required?
4924 if (attack_kern == ATTACK_KERN_STRAIGHT)
4925 {
4926 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4927 }
4928 else if (attack_kern == ATTACK_KERN_COMBI)
4929 {
4930 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4931 }
4932 */
4933 }
4934 }
4935
4936 device_param->kernel_accel = 0;
4937 device_param->kernel_loops = 0;
4938
4939 myfree (buf);
4940
4941 return NULL;
4942 }
4943
4944 static void *thread_calc (void *p)
4945 {
4946 hc_device_param_t *device_param = (hc_device_param_t *) p;
4947
4948 if (device_param->skipped) return NULL;
4949
4950 const uint attack_mode = data.attack_mode;
4951 const uint attack_kern = data.attack_kern;
4952
4953 if (attack_mode == ATTACK_MODE_BF)
4954 {
4955 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4956 {
4957 const uint work = get_work (device_param, -1);
4958
4959 if (work == 0) break;
4960
4961 const u64 words_off = device_param->words_off;
4962 const u64 words_fin = words_off + work;
4963
4964 const uint pws_cnt = work;
4965
4966 device_param->pws_cnt = pws_cnt;
4967
4968 if (pws_cnt)
4969 {
4970 run_copy (device_param, pws_cnt);
4971
4972 run_cracker (device_param, pws_cnt);
4973
4974 device_param->pws_cnt = 0;
4975
4976 /*
4977 still required?
4978 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4979 */
4980 }
4981
4982 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4983
4984 if (data.devices_status == STATUS_CRACKED) break;
4985 if (data.devices_status == STATUS_ABORTED) break;
4986 if (data.devices_status == STATUS_QUIT) break;
4987 if (data.devices_status == STATUS_BYPASS) break;
4988
4989 if (data.benchmark == 1) break;
4990
4991 device_param->words_done = words_fin;
4992 }
4993 }
4994 else
4995 {
4996 const uint segment_size = data.segment_size;
4997
4998 char *dictfile = data.dictfile;
4999
5000 if (attack_mode == ATTACK_MODE_COMBI)
5001 {
5002 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5003 {
5004 dictfile = data.dictfile2;
5005 }
5006 }
5007
5008 FILE *fd = fopen (dictfile, "rb");
5009
5010 if (fd == NULL)
5011 {
5012 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
5013
5014 return NULL;
5015 }
5016
5017 if (attack_mode == ATTACK_MODE_COMBI)
5018 {
5019 const uint combs_mode = data.combs_mode;
5020
5021 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
5022 {
5023 const char *dictfilec = data.dictfile2;
5024
5025 FILE *combs_fp = fopen (dictfilec, "rb");
5026
5027 if (combs_fp == NULL)
5028 {
5029 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5030
5031 fclose (fd);
5032
5033 return NULL;
5034 }
5035
5036 device_param->combs_fp = combs_fp;
5037 }
5038 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5039 {
5040 const char *dictfilec = data.dictfile;
5041
5042 FILE *combs_fp = fopen (dictfilec, "rb");
5043
5044 if (combs_fp == NULL)
5045 {
5046 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5047
5048 fclose (fd);
5049
5050 return NULL;
5051 }
5052
5053 device_param->combs_fp = combs_fp;
5054 }
5055 }
5056
5057 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
5058
5059 wl_data->buf = (char *) mymalloc (segment_size);
5060 wl_data->avail = segment_size;
5061 wl_data->incr = segment_size;
5062 wl_data->cnt = 0;
5063 wl_data->pos = 0;
5064
5065 u64 words_cur = 0;
5066
5067 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5068 {
5069 u64 words_off = 0;
5070 u64 words_fin = 0;
5071
5072 u64 max = -1;
5073
5074 while (max)
5075 {
5076 const uint work = get_work (device_param, max);
5077
5078 if (work == 0) break;
5079
5080 max = 0;
5081
5082 words_off = device_param->words_off;
5083 words_fin = words_off + work;
5084
5085 char *line_buf;
5086 uint line_len;
5087
5088 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5089
5090 for ( ; words_cur < words_fin; words_cur++)
5091 {
5092 get_next_word (wl_data, fd, &line_buf, &line_len);
5093
5094 line_len = convert_from_hex (line_buf, line_len);
5095
5096 // post-process rule engine
5097
5098 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5099 {
5100 char rule_buf_out[BLOCK_SIZE] = { 0 };
5101
5102 int rule_len_out = -1;
5103
5104 if (line_len < BLOCK_SIZE)
5105 {
5106 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5107 }
5108
5109 if (rule_len_out < 0) continue;
5110
5111 line_buf = rule_buf_out;
5112 line_len = rule_len_out;
5113 }
5114
5115 if (attack_kern == ATTACK_KERN_STRAIGHT)
5116 {
5117 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5118 {
5119 max++;
5120
5121 hc_thread_mutex_lock (mux_counter);
5122
5123 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5124 {
5125 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5126 }
5127
5128 hc_thread_mutex_unlock (mux_counter);
5129
5130 continue;
5131 }
5132 }
5133 else if (attack_kern == ATTACK_KERN_COMBI)
5134 {
5135 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5136 // since we still need to combine the plains
5137
5138 if (line_len > data.pw_max)
5139 {
5140 max++;
5141
5142 hc_thread_mutex_lock (mux_counter);
5143
5144 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5145 {
5146 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5147 }
5148
5149 hc_thread_mutex_unlock (mux_counter);
5150
5151 continue;
5152 }
5153 }
5154
5155 pw_add (device_param, (u8 *) line_buf, line_len);
5156
5157 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5158
5159 if (data.devices_status == STATUS_CRACKED) break;
5160 if (data.devices_status == STATUS_ABORTED) break;
5161 if (data.devices_status == STATUS_QUIT) break;
5162 if (data.devices_status == STATUS_BYPASS) break;
5163 }
5164
5165 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5166
5167 if (data.devices_status == STATUS_CRACKED) break;
5168 if (data.devices_status == STATUS_ABORTED) break;
5169 if (data.devices_status == STATUS_QUIT) break;
5170 if (data.devices_status == STATUS_BYPASS) break;
5171 }
5172
5173 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5174
5175 if (data.devices_status == STATUS_CRACKED) break;
5176 if (data.devices_status == STATUS_ABORTED) break;
5177 if (data.devices_status == STATUS_QUIT) break;
5178 if (data.devices_status == STATUS_BYPASS) break;
5179
5180 //
5181 // flush
5182 //
5183
5184 const uint pws_cnt = device_param->pws_cnt;
5185
5186 if (pws_cnt)
5187 {
5188 run_copy (device_param, pws_cnt);
5189
5190 run_cracker (device_param, pws_cnt);
5191
5192 device_param->pws_cnt = 0;
5193
5194 /*
5195 still required?
5196 if (attack_kern == ATTACK_KERN_STRAIGHT)
5197 {
5198 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5199 }
5200 else if (attack_kern == ATTACK_KERN_COMBI)
5201 {
5202 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5203 }
5204 */
5205 }
5206
5207 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5208
5209 if (data.devices_status == STATUS_CRACKED) break;
5210 if (data.devices_status == STATUS_ABORTED) break;
5211 if (data.devices_status == STATUS_QUIT) break;
5212 if (data.devices_status == STATUS_BYPASS) break;
5213
5214 if (words_fin == 0) break;
5215
5216 device_param->words_done = words_fin;
5217 }
5218
5219 if (attack_mode == ATTACK_MODE_COMBI)
5220 {
5221 fclose (device_param->combs_fp);
5222 }
5223
5224 free (wl_data->buf);
5225 free (wl_data);
5226
5227 fclose (fd);
5228 }
5229
5230 device_param->kernel_accel = 0;
5231 device_param->kernel_loops = 0;
5232
5233 return NULL;
5234 }
5235
5236 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5237 {
5238 if (!device_param)
5239 {
5240 log_error ("ERROR: %s : Invalid argument", __func__);
5241
5242 exit (-1);
5243 }
5244
5245 salt_t *salt_buf = &data.salts_buf[salt_pos];
5246
5247 device_param->kernel_params_buf32[24] = salt_pos;
5248 device_param->kernel_params_buf32[27] = 1;
5249 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
5250 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
5251 device_param->kernel_params_buf32[30] = 0;
5252 device_param->kernel_params_buf32[31] = 1;
5253
5254 char *dictfile_old = data.dictfile;
5255
5256 const char *weak_hash_check = "weak-hash-check";
5257
5258 data.dictfile = (char *) weak_hash_check;
5259
5260 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5261
5262 data.kernel_rules_buf[0].cmds[0] = 0;
5263
5264 /**
5265 * run the kernel
5266 */
5267
5268 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5269 {
5270 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5271 }
5272 else
5273 {
5274 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5275
5276 uint loop_step = 16;
5277
5278 const uint iter = salt_buf->salt_iter;
5279
5280 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5281 {
5282 uint loop_left = iter - loop_pos;
5283
5284 loop_left = MIN (loop_left, loop_step);
5285
5286 device_param->kernel_params_buf32[25] = loop_pos;
5287 device_param->kernel_params_buf32[26] = loop_left;
5288
5289 run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5290 }
5291
5292 run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5293 }
5294
5295 /**
5296 * result
5297 */
5298
5299 check_cracked (device_param, salt_pos);
5300
5301 /**
5302 * cleanup
5303 */
5304
5305 device_param->kernel_params_buf32[24] = 0;
5306 device_param->kernel_params_buf32[25] = 0;
5307 device_param->kernel_params_buf32[26] = 0;
5308 device_param->kernel_params_buf32[27] = 0;
5309 device_param->kernel_params_buf32[28] = 0;
5310 device_param->kernel_params_buf32[29] = 0;
5311 device_param->kernel_params_buf32[30] = 0;
5312 device_param->kernel_params_buf32[31] = 0;
5313
5314 data.dictfile = dictfile_old;
5315
5316 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5317 }
5318
5319 // hlfmt hashcat
5320
5321 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5322 {
5323 if (data.username == 0)
5324 {
5325 *hashbuf_pos = line_buf;
5326 *hashbuf_len = line_len;
5327 }
5328 else
5329 {
5330 char *pos = line_buf;
5331 int len = line_len;
5332
5333 for (int i = 0; i < line_len; i++, pos++, len--)
5334 {
5335 if (line_buf[i] == data.separator)
5336 {
5337 pos++;
5338
5339 len--;
5340
5341 break;
5342 }
5343 }
5344
5345 *hashbuf_pos = pos;
5346 *hashbuf_len = len;
5347 }
5348 }
5349
5350 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5351 {
5352 char *pos = NULL;
5353 int len = 0;
5354
5355 int sep_cnt = 0;
5356
5357 for (int i = 0; i < line_len; i++)
5358 {
5359 if (line_buf[i] == data.separator)
5360 {
5361 sep_cnt++;
5362
5363 continue;
5364 }
5365
5366 if (sep_cnt == 0)
5367 {
5368 if (pos == NULL) pos = line_buf + i;
5369
5370 len++;
5371 }
5372 }
5373
5374 *userbuf_pos = pos;
5375 *userbuf_len = len;
5376 }
5377
5378 // hlfmt pwdump
5379
5380 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5381 {
5382 int sep_cnt = 0;
5383
5384 int sep2_len = 0;
5385 int sep3_len = 0;
5386
5387 for (int i = 0; i < line_len; i++)
5388 {
5389 if (line_buf[i] == ':')
5390 {
5391 sep_cnt++;
5392
5393 continue;
5394 }
5395
5396 if (sep_cnt == 2) sep2_len++;
5397 if (sep_cnt == 3) sep3_len++;
5398 }
5399
5400 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5401
5402 return 0;
5403 }
5404
5405 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5406 {
5407 char *pos = NULL;
5408 int len = 0;
5409
5410 int sep_cnt = 0;
5411
5412 for (int i = 0; i < line_len; i++)
5413 {
5414 if (line_buf[i] == ':')
5415 {
5416 sep_cnt++;
5417
5418 continue;
5419 }
5420
5421 if (data.hash_mode == 1000)
5422 {
5423 if (sep_cnt == 3)
5424 {
5425 if (pos == NULL) pos = line_buf + i;
5426
5427 len++;
5428 }
5429 }
5430 else if (data.hash_mode == 3000)
5431 {
5432 if (sep_cnt == 2)
5433 {
5434 if (pos == NULL) pos = line_buf + i;
5435
5436 len++;
5437 }
5438 }
5439 }
5440
5441 *hashbuf_pos = pos;
5442 *hashbuf_len = len;
5443 }
5444
5445 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5446 {
5447 char *pos = NULL;
5448 int len = 0;
5449
5450 int sep_cnt = 0;
5451
5452 for (int i = 0; i < line_len; i++)
5453 {
5454 if (line_buf[i] == ':')
5455 {
5456 sep_cnt++;
5457
5458 continue;
5459 }
5460
5461 if (sep_cnt == 0)
5462 {
5463 if (pos == NULL) pos = line_buf + i;
5464
5465 len++;
5466 }
5467 }
5468
5469 *userbuf_pos = pos;
5470 *userbuf_len = len;
5471 }
5472
5473 // hlfmt passwd
5474
5475 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5476 {
5477 int sep_cnt = 0;
5478
5479 char sep5_first = 0;
5480 char sep6_first = 0;
5481
5482 for (int i = 0; i < line_len; i++)
5483 {
5484 if (line_buf[i] == ':')
5485 {
5486 sep_cnt++;
5487
5488 continue;
5489 }
5490
5491 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5492 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5493 }
5494
5495 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5496
5497 return 0;
5498 }
5499
5500 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5501 {
5502 char *pos = NULL;
5503 int len = 0;
5504
5505 int sep_cnt = 0;
5506
5507 for (int i = 0; i < line_len; i++)
5508 {
5509 if (line_buf[i] == ':')
5510 {
5511 sep_cnt++;
5512
5513 continue;
5514 }
5515
5516 if (sep_cnt == 1)
5517 {
5518 if (pos == NULL) pos = line_buf + i;
5519
5520 len++;
5521 }
5522 }
5523
5524 *hashbuf_pos = pos;
5525 *hashbuf_len = len;
5526 }
5527
5528 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5529 {
5530 char *pos = NULL;
5531 int len = 0;
5532
5533 int sep_cnt = 0;
5534
5535 for (int i = 0; i < line_len; i++)
5536 {
5537 if (line_buf[i] == ':')
5538 {
5539 sep_cnt++;
5540
5541 continue;
5542 }
5543
5544 if (sep_cnt == 0)
5545 {
5546 if (pos == NULL) pos = line_buf + i;
5547
5548 len++;
5549 }
5550 }
5551
5552 *userbuf_pos = pos;
5553 *userbuf_len = len;
5554 }
5555
5556 // hlfmt shadow
5557
5558 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5559 {
5560 int sep_cnt = 0;
5561
5562 for (int i = 0; i < line_len; i++)
5563 {
5564 if (line_buf[i] == ':') sep_cnt++;
5565 }
5566
5567 if (sep_cnt == 8) return 1;
5568
5569 return 0;
5570 }
5571
5572 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5573 {
5574 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5575 }
5576
5577 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5578 {
5579 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5580 }
5581
5582 // hlfmt main
5583
5584 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5585 {
5586 switch (hashfile_format)
5587 {
5588 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5589 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5590 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5591 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5592 }
5593 }
5594
5595 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5596 {
5597 switch (hashfile_format)
5598 {
5599 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5600 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5601 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5602 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5603 }
5604 }
5605
5606 char *strhlfmt (const uint hashfile_format)
5607 {
5608 switch (hashfile_format)
5609 {
5610 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5611 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5612 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5613 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5614 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5615 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5616 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5617 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5618 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5619 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5620 }
5621
5622 return ((char *) "Unknown");
5623 }
5624
5625 static uint hlfmt_detect (FILE *fp, uint max_check)
5626 {
5627 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5628
5629 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5630 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5631
5632 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5633
5634 uint num_check = 0;
5635
5636 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5637
5638 while (!feof (fp))
5639 {
5640 int line_len = fgetl (fp, line_buf);
5641
5642 if (line_len == 0) continue;
5643
5644 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5645 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5646 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5647
5648 if (num_check == max_check) break;
5649
5650 num_check++;
5651 }
5652
5653 myfree (line_buf);
5654
5655 uint hashlist_format = HLFMT_HASHCAT;
5656
5657 for (int i = 1; i < HLFMTS_CNT; i++)
5658 {
5659 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5660
5661 hashlist_format = i;
5662 }
5663
5664 free (formats_cnt);
5665
5666 return hashlist_format;
5667 }
5668
5669 /**
5670 * some further helper function
5671 */
5672
5673 // wrapper around mymalloc for ADL
5674
5675 #if defined(HAVE_HWMON)
5676 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5677 {
5678 return mymalloc (iSize);
5679 }
5680 #endif
5681
5682 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)
5683 {
5684 u64 collisions = 0;
5685
5686 const uint dgst_pos0 = data.dgst_pos0;
5687 const uint dgst_pos1 = data.dgst_pos1;
5688 const uint dgst_pos2 = data.dgst_pos2;
5689 const uint dgst_pos3 = data.dgst_pos3;
5690
5691 memset (bitmap_a, 0, bitmap_size);
5692 memset (bitmap_b, 0, bitmap_size);
5693 memset (bitmap_c, 0, bitmap_size);
5694 memset (bitmap_d, 0, bitmap_size);
5695
5696 for (uint i = 0; i < digests_cnt; i++)
5697 {
5698 uint *digest_ptr = (uint *) digests_buf_ptr;
5699
5700 digests_buf_ptr += dgst_size;
5701
5702 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5703 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5704 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5705 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5706
5707 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5708 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5709 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5710 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5711
5712 if (bitmap_a[idx0] & val0) collisions++;
5713 if (bitmap_b[idx1] & val1) collisions++;
5714 if (bitmap_c[idx2] & val2) collisions++;
5715 if (bitmap_d[idx3] & val3) collisions++;
5716
5717 bitmap_a[idx0] |= val0;
5718 bitmap_b[idx1] |= val1;
5719 bitmap_c[idx2] |= val2;
5720 bitmap_d[idx3] |= val3;
5721
5722 if (collisions >= collisions_max) return 0x7fffffff;
5723 }
5724
5725 return collisions;
5726 }
5727
5728 /**
5729 * main
5730 */
5731
5732 #ifdef WIN
5733 void SetConsoleWindowSize (const int x)
5734 {
5735 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5736
5737 if (h == INVALID_HANDLE_VALUE) return;
5738
5739 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5740
5741 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5742
5743 SMALL_RECT *sr = &bufferInfo.srWindow;
5744
5745 sr->Right = MAX (sr->Right, x - 1);
5746
5747 COORD co;
5748
5749 co.X = sr->Right + 1;
5750 co.Y = 9999;
5751
5752 if (!SetConsoleScreenBufferSize (h, co)) return;
5753
5754 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5755 }
5756 #endif
5757
5758 int main (int argc, char **argv)
5759 {
5760 #ifdef WIN
5761 SetConsoleWindowSize (132);
5762 #endif
5763
5764 /**
5765 * To help users a bit
5766 */
5767
5768 char *compute = getenv ("COMPUTE");
5769
5770 if (compute)
5771 {
5772 static char display[100];
5773
5774 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5775
5776 putenv (display);
5777 }
5778 else
5779 {
5780 if (getenv ("DISPLAY") == NULL)
5781 putenv ((char *) "DISPLAY=:0");
5782 }
5783
5784 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5785 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5786
5787 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5788 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5789
5790 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5791 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5792
5793 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5794 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5795
5796 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5797 putenv ((char *) "POCL_KERNEL_CACHE=0");
5798
5799 umask (077);
5800
5801 /**
5802 * Real init
5803 */
5804
5805 memset (&data, 0, sizeof (hc_global_data_t));
5806
5807 time_t proc_start;
5808
5809 time (&proc_start);
5810
5811 data.proc_start = proc_start;
5812
5813 int myargc = argc;
5814 char **myargv = argv;
5815
5816 hc_thread_mutex_init (mux_dispatcher);
5817 hc_thread_mutex_init (mux_counter);
5818 hc_thread_mutex_init (mux_display);
5819 hc_thread_mutex_init (mux_adl);
5820
5821 /**
5822 * commandline parameters
5823 */
5824
5825 uint usage = USAGE;
5826 uint version = VERSION;
5827 uint quiet = QUIET;
5828 uint benchmark = BENCHMARK;
5829 uint stdout_flag = STDOUT_FLAG;
5830 uint show = SHOW;
5831 uint left = LEFT;
5832 uint username = USERNAME;
5833 uint remove = REMOVE;
5834 uint remove_timer = REMOVE_TIMER;
5835 u64 skip = SKIP;
5836 u64 limit = LIMIT;
5837 uint keyspace = KEYSPACE;
5838 uint potfile_disable = POTFILE_DISABLE;
5839 char *potfile_path = NULL;
5840 uint debug_mode = DEBUG_MODE;
5841 char *debug_file = NULL;
5842 char *induction_dir = NULL;
5843 char *outfile_check_dir = NULL;
5844 uint force = FORCE;
5845 uint runtime = RUNTIME;
5846 uint hash_mode = HASH_MODE;
5847 uint attack_mode = ATTACK_MODE;
5848 uint markov_disable = MARKOV_DISABLE;
5849 uint markov_classic = MARKOV_CLASSIC;
5850 uint markov_threshold = MARKOV_THRESHOLD;
5851 char *markov_hcstat = NULL;
5852 char *outfile = NULL;
5853 uint outfile_format = OUTFILE_FORMAT;
5854 uint outfile_autohex = OUTFILE_AUTOHEX;
5855 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5856 uint restore = RESTORE;
5857 uint restore_timer = RESTORE_TIMER;
5858 uint restore_disable = RESTORE_DISABLE;
5859 uint status = STATUS;
5860 uint status_timer = STATUS_TIMER;
5861 uint machine_readable = MACHINE_READABLE;
5862 uint loopback = LOOPBACK;
5863 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5864 char *session = NULL;
5865 uint hex_charset = HEX_CHARSET;
5866 uint hex_salt = HEX_SALT;
5867 uint hex_wordlist = HEX_WORDLIST;
5868 uint rp_gen = RP_GEN;
5869 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5870 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5871 uint rp_gen_seed = RP_GEN_SEED;
5872 char *rule_buf_l = (char *) RULE_BUF_L;
5873 char *rule_buf_r = (char *) RULE_BUF_R;
5874 uint increment = INCREMENT;
5875 uint increment_min = INCREMENT_MIN;
5876 uint increment_max = INCREMENT_MAX;
5877 char *cpu_affinity = NULL;
5878 OCL_PTR *ocl = NULL;
5879 char *opencl_devices = NULL;
5880 char *opencl_platforms = NULL;
5881 char *opencl_device_types = NULL;
5882 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5883 char *truecrypt_keyfiles = NULL;
5884 char *veracrypt_keyfiles = NULL;
5885 uint veracrypt_pim = 0;
5886 uint workload_profile = WORKLOAD_PROFILE;
5887 uint kernel_accel = KERNEL_ACCEL;
5888 uint kernel_loops = KERNEL_LOOPS;
5889 uint nvidia_spin_damp = NVIDIA_SPIN_DAMP;
5890 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5891 #ifdef HAVE_HWMON
5892 uint gpu_temp_abort = GPU_TEMP_ABORT;
5893 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5894 uint powertune_enable = POWERTUNE_ENABLE;
5895 #endif
5896 uint logfile_disable = LOGFILE_DISABLE;
5897 uint segment_size = SEGMENT_SIZE;
5898 uint scrypt_tmto = SCRYPT_TMTO;
5899 char separator = SEPARATOR;
5900 uint bitmap_min = BITMAP_MIN;
5901 uint bitmap_max = BITMAP_MAX;
5902 char *custom_charset_1 = NULL;
5903 char *custom_charset_2 = NULL;
5904 char *custom_charset_3 = NULL;
5905 char *custom_charset_4 = NULL;
5906
5907 #define IDX_HELP 'h'
5908 #define IDX_VERSION 'V'
5909 #define IDX_VERSION_LOWER 'v'
5910 #define IDX_QUIET 0xff02
5911 #define IDX_SHOW 0xff03
5912 #define IDX_LEFT 0xff04
5913 #define IDX_REMOVE 0xff05
5914 #define IDX_REMOVE_TIMER 0xff37
5915 #define IDX_SKIP 's'
5916 #define IDX_LIMIT 'l'
5917 #define IDX_KEYSPACE 0xff35
5918 #define IDX_POTFILE_DISABLE 0xff06
5919 #define IDX_POTFILE_PATH 0xffe0
5920 #define IDX_DEBUG_MODE 0xff43
5921 #define IDX_DEBUG_FILE 0xff44
5922 #define IDX_INDUCTION_DIR 0xff46
5923 #define IDX_OUTFILE_CHECK_DIR 0xff47
5924 #define IDX_USERNAME 0xff07
5925 #define IDX_FORCE 0xff08
5926 #define IDX_RUNTIME 0xff09
5927 #define IDX_BENCHMARK 'b'
5928 #define IDX_STDOUT_FLAG 0xff77
5929 #define IDX_HASH_MODE 'm'
5930 #define IDX_ATTACK_MODE 'a'
5931 #define IDX_RP_FILE 'r'
5932 #define IDX_RP_GEN 'g'
5933 #define IDX_RP_GEN_FUNC_MIN 0xff10
5934 #define IDX_RP_GEN_FUNC_MAX 0xff11
5935 #define IDX_RP_GEN_SEED 0xff34
5936 #define IDX_RULE_BUF_L 'j'
5937 #define IDX_RULE_BUF_R 'k'
5938 #define IDX_INCREMENT 'i'
5939 #define IDX_INCREMENT_MIN 0xff12
5940 #define IDX_INCREMENT_MAX 0xff13
5941 #define IDX_OUTFILE 'o'
5942 #define IDX_OUTFILE_FORMAT 0xff14
5943 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5944 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5945 #define IDX_RESTORE 0xff15
5946 #define IDX_RESTORE_DISABLE 0xff27
5947 #define IDX_STATUS 0xff17
5948 #define IDX_STATUS_TIMER 0xff18
5949 #define IDX_MACHINE_READABLE 0xff50
5950 #define IDX_LOOPBACK 0xff38
5951 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5952 #define IDX_SESSION 0xff19
5953 #define IDX_HEX_CHARSET 0xff20
5954 #define IDX_HEX_SALT 0xff21
5955 #define IDX_HEX_WORDLIST 0xff40
5956 #define IDX_MARKOV_DISABLE 0xff22
5957 #define IDX_MARKOV_CLASSIC 0xff23
5958 #define IDX_MARKOV_THRESHOLD 't'
5959 #define IDX_MARKOV_HCSTAT 0xff24
5960 #define IDX_CPU_AFFINITY 0xff25
5961 #define IDX_OPENCL_DEVICES 'd'
5962 #define IDX_OPENCL_PLATFORMS 0xff72
5963 #define IDX_OPENCL_DEVICE_TYPES 'D'
5964 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5965 #define IDX_WORKLOAD_PROFILE 'w'
5966 #define IDX_KERNEL_ACCEL 'n'
5967 #define IDX_KERNEL_LOOPS 'u'
5968 #define IDX_NVIDIA_SPIN_DAMP 0xff79
5969 #define IDX_GPU_TEMP_DISABLE 0xff29
5970 #define IDX_GPU_TEMP_ABORT 0xff30
5971 #define IDX_GPU_TEMP_RETAIN 0xff31
5972 #define IDX_POWERTUNE_ENABLE 0xff41
5973 #define IDX_LOGFILE_DISABLE 0xff51
5974 #define IDX_TRUECRYPT_KEYFILES 0xff52
5975 #define IDX_VERACRYPT_KEYFILES 0xff53
5976 #define IDX_VERACRYPT_PIM 0xff54
5977 #define IDX_SCRYPT_TMTO 0xff61
5978 #define IDX_SEGMENT_SIZE 'c'
5979 #define IDX_SEPARATOR 'p'
5980 #define IDX_BITMAP_MIN 0xff70
5981 #define IDX_BITMAP_MAX 0xff71
5982 #define IDX_CUSTOM_CHARSET_1 '1'
5983 #define IDX_CUSTOM_CHARSET_2 '2'
5984 #define IDX_CUSTOM_CHARSET_3 '3'
5985 #define IDX_CUSTOM_CHARSET_4 '4'
5986
5987 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:D:n:u:c:p:s:l:1:2:3:4:ibw:";
5988
5989 struct option long_options[] =
5990 {
5991 {"help", no_argument, 0, IDX_HELP},
5992 {"version", no_argument, 0, IDX_VERSION},
5993 {"quiet", no_argument, 0, IDX_QUIET},
5994 {"show", no_argument, 0, IDX_SHOW},
5995 {"left", no_argument, 0, IDX_LEFT},
5996 {"username", no_argument, 0, IDX_USERNAME},
5997 {"remove", no_argument, 0, IDX_REMOVE},
5998 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5999 {"skip", required_argument, 0, IDX_SKIP},
6000 {"limit", required_argument, 0, IDX_LIMIT},
6001 {"keyspace", no_argument, 0, IDX_KEYSPACE},
6002 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
6003 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
6004 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
6005 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
6006 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
6007 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
6008 {"force", no_argument, 0, IDX_FORCE},
6009 {"benchmark", no_argument, 0, IDX_BENCHMARK},
6010 {"stdout", no_argument, 0, IDX_STDOUT_FLAG},
6011 {"restore", no_argument, 0, IDX_RESTORE},
6012 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
6013 {"status", no_argument, 0, IDX_STATUS},
6014 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
6015 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
6016 {"loopback", no_argument, 0, IDX_LOOPBACK},
6017 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
6018 {"session", required_argument, 0, IDX_SESSION},
6019 {"runtime", required_argument, 0, IDX_RUNTIME},
6020 {"generate-rules", required_argument, 0, IDX_RP_GEN},
6021 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
6022 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
6023 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
6024 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
6025 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
6026 {"hash-type", required_argument, 0, IDX_HASH_MODE},
6027 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
6028 {"rules-file", required_argument, 0, IDX_RP_FILE},
6029 {"outfile", required_argument, 0, IDX_OUTFILE},
6030 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
6031 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
6032 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
6033 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
6034 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
6035 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
6036 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
6037 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
6038 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
6039 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
6040 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
6041 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
6042 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
6043 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
6044 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
6045 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
6046 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
6047 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
6048 {"nvidia-spin-damp", required_argument, 0, IDX_NVIDIA_SPIN_DAMP},
6049 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
6050 #ifdef HAVE_HWMON
6051 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
6052 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
6053 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
6054 #endif // HAVE_HWMON
6055 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
6056 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
6057 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
6058 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
6059 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
6060 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
6061 {"seperator", required_argument, 0, IDX_SEPARATOR},
6062 {"separator", required_argument, 0, IDX_SEPARATOR},
6063 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
6064 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
6065 {"increment", no_argument, 0, IDX_INCREMENT},
6066 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
6067 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
6068 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
6069 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
6070 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
6071 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
6072 {0, 0, 0, 0}
6073 };
6074
6075 uint rp_files_cnt = 0;
6076
6077 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6078
6079 int option_index = 0;
6080 int c = -1;
6081
6082 optind = 1;
6083 optopt = 0;
6084
6085 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6086 {
6087 switch (c)
6088 {
6089 case IDX_HELP: usage = 1; break;
6090 case IDX_VERSION:
6091 case IDX_VERSION_LOWER: version = 1; break;
6092 case IDX_RESTORE: restore = 1; break;
6093 case IDX_SESSION: session = optarg; break;
6094 case IDX_SHOW: show = 1; break;
6095 case IDX_LEFT: left = 1; break;
6096 case '?': return (-1);
6097 }
6098 }
6099
6100 if (optopt != 0)
6101 {
6102 log_error ("ERROR: Invalid argument specified");
6103
6104 return (-1);
6105 }
6106
6107 /**
6108 * exit functions
6109 */
6110
6111 if (version)
6112 {
6113 log_info ("%s", VERSION_TAG);
6114
6115 return (0);
6116 }
6117
6118 if (usage)
6119 {
6120 usage_big_print (PROGNAME);
6121
6122 return (0);
6123 }
6124
6125 /**
6126 * session needs to be set, always!
6127 */
6128
6129 if (session == NULL) session = (char *) PROGNAME;
6130
6131 /**
6132 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6133 */
6134
6135 char *exec_path = get_exec_path ();
6136
6137 #ifdef LINUX
6138
6139 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6140 char *resolved_exec_path = realpath (exec_path, NULL);
6141
6142 char *install_dir = get_install_dir (resolved_exec_path);
6143 char *profile_dir = NULL;
6144 char *session_dir = NULL;
6145 char *shared_dir = NULL;
6146
6147 if (strcmp (install_dir, resolved_install_folder) == 0)
6148 {
6149 struct passwd *pw = getpwuid (getuid ());
6150
6151 const char *homedir = pw->pw_dir;
6152
6153 profile_dir = get_profile_dir (homedir);
6154 session_dir = get_session_dir (profile_dir);
6155 shared_dir = strdup (SHARED_FOLDER);
6156
6157 mkdir (profile_dir, 0700);
6158 mkdir (session_dir, 0700);
6159 }
6160 else
6161 {
6162 profile_dir = install_dir;
6163 session_dir = install_dir;
6164 shared_dir = install_dir;
6165 }
6166
6167 myfree (resolved_install_folder);
6168 myfree (resolved_exec_path);
6169
6170 #else
6171
6172 char *install_dir = get_install_dir (exec_path);
6173 char *profile_dir = install_dir;
6174 char *session_dir = install_dir;
6175 char *shared_dir = install_dir;
6176
6177 #endif
6178
6179 data.install_dir = install_dir;
6180 data.profile_dir = profile_dir;
6181 data.session_dir = session_dir;
6182 data.shared_dir = shared_dir;
6183
6184 myfree (exec_path);
6185
6186 /**
6187 * kernel cache, we need to make sure folder exist
6188 */
6189
6190 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6191
6192 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6193
6194 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6195
6196 mkdir (kernels_folder, 0700);
6197
6198 myfree (kernels_folder);
6199
6200 /**
6201 * session
6202 */
6203
6204 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6205
6206 data.session = session;
6207
6208 char *eff_restore_file = (char *) mymalloc (session_size);
6209 char *new_restore_file = (char *) mymalloc (session_size);
6210
6211 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
6212 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6213
6214 data.eff_restore_file = eff_restore_file;
6215 data.new_restore_file = new_restore_file;
6216
6217 if (((show == 1) || (left == 1)) && (restore == 1))
6218 {
6219 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6220 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6221
6222 return (-1);
6223 }
6224
6225 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6226 if ((show == 1) || (left == 1))
6227 {
6228 restore_disable = 1;
6229
6230 restore = 0;
6231 }
6232
6233 data.restore_disable = restore_disable;
6234
6235 restore_data_t *rd = init_restore (argc, argv);
6236
6237 data.rd = rd;
6238
6239 /**
6240 * restore file
6241 */
6242
6243 if (restore == 1)
6244 {
6245 read_restore (eff_restore_file, rd);
6246
6247 if (rd->version_bin < RESTORE_MIN)
6248 {
6249 log_error ("ERROR: Incompatible restore-file version");
6250
6251 return (-1);
6252 }
6253
6254 myargc = rd->argc;
6255 myargv = rd->argv;
6256
6257 #ifdef _POSIX
6258 rd->pid = getpid ();
6259 #elif _WIN
6260 rd->pid = GetCurrentProcessId ();
6261 #endif
6262 }
6263
6264 uint hash_mode_chgd = 0;
6265 uint runtime_chgd = 0;
6266 uint kernel_loops_chgd = 0;
6267 uint kernel_accel_chgd = 0;
6268 uint nvidia_spin_damp_chgd = 0;
6269 uint attack_mode_chgd = 0;
6270 uint outfile_format_chgd = 0;
6271 uint rp_gen_seed_chgd = 0;
6272 uint remove_timer_chgd = 0;
6273 uint increment_min_chgd = 0;
6274 uint increment_max_chgd = 0;
6275 uint workload_profile_chgd = 0;
6276 uint opencl_vector_width_chgd = 0;
6277
6278 optind = 1;
6279 optopt = 0;
6280 option_index = 0;
6281
6282 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6283 {
6284 switch (c)
6285 {
6286 //case IDX_HELP: usage = 1; break;
6287 //case IDX_VERSION: version = 1; break;
6288 //case IDX_RESTORE: restore = 1; break;
6289 case IDX_QUIET: quiet = 1; break;
6290 //case IDX_SHOW: show = 1; break;
6291 case IDX_SHOW: break;
6292 //case IDX_LEFT: left = 1; break;
6293 case IDX_LEFT: break;
6294 case IDX_USERNAME: username = 1; break;
6295 case IDX_REMOVE: remove = 1; break;
6296 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6297 remove_timer_chgd = 1; break;
6298 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6299 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6300 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6301 case IDX_DEBUG_FILE: debug_file = optarg; break;
6302 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6303 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6304 case IDX_FORCE: force = 1; break;
6305 case IDX_SKIP: skip = atoll (optarg); break;
6306 case IDX_LIMIT: limit = atoll (optarg); break;
6307 case IDX_KEYSPACE: keyspace = 1; break;
6308 case IDX_BENCHMARK: benchmark = 1; break;
6309 case IDX_STDOUT_FLAG: stdout_flag = 1; break;
6310 case IDX_RESTORE: break;
6311 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6312 case IDX_STATUS: status = 1; break;
6313 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6314 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6315 case IDX_LOOPBACK: loopback = 1; break;
6316 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6317 //case IDX_SESSION: session = optarg; break;
6318 case IDX_SESSION: break;
6319 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6320 hash_mode_chgd = 1; break;
6321 case IDX_RUNTIME: runtime = atoi (optarg);
6322 runtime_chgd = 1; break;
6323 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6324 attack_mode_chgd = 1; break;
6325 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6326 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6327 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6328 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6329 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6330 rp_gen_seed_chgd = 1; break;
6331 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6332 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6333 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6334 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6335 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6336 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6337 case IDX_OUTFILE: outfile = optarg; break;
6338 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6339 outfile_format_chgd = 1; break;
6340 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6341 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6342 case IDX_HEX_CHARSET: hex_charset = 1; break;
6343 case IDX_HEX_SALT: hex_salt = 1; break;
6344 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6345 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6346 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6347 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6348 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6349 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6350 opencl_vector_width_chgd = 1; break;
6351 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6352 workload_profile_chgd = 1; break;
6353 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6354 kernel_accel_chgd = 1; break;
6355 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6356 kernel_loops_chgd = 1; break;
6357 case IDX_NVIDIA_SPIN_DAMP: nvidia_spin_damp = atoi (optarg);
6358 nvidia_spin_damp_chgd = 1; break;
6359 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6360 #ifdef HAVE_HWMON
6361 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6362 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6363 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6364 #endif // HAVE_HWMON
6365 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6366 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6367 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6368 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6369 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6370 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6371 case IDX_SEPARATOR: separator = optarg[0]; break;
6372 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6373 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6374 case IDX_INCREMENT: increment = 1; break;
6375 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6376 increment_min_chgd = 1; break;
6377 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6378 increment_max_chgd = 1; break;
6379 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6380 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6381 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6382 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6383
6384 default:
6385 log_error ("ERROR: Invalid argument specified");
6386 return (-1);
6387 }
6388 }
6389
6390 if (optopt != 0)
6391 {
6392 log_error ("ERROR: Invalid argument specified");
6393
6394 return (-1);
6395 }
6396
6397 /**
6398 * Inform user things getting started,
6399 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6400 * - we do not need to check algorithm_pos
6401 */
6402
6403 if (quiet == 0)
6404 {
6405 if (benchmark == 1)
6406 {
6407 if (machine_readable == 0)
6408 {
6409 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6410 log_info ("");
6411 }
6412 else
6413 {
6414 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6415 }
6416 }
6417 else if (restore == 1)
6418 {
6419 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6420 log_info ("");
6421 }
6422 else if (stdout_flag == 1)
6423 {
6424 // do nothing
6425 }
6426 else if (keyspace == 1)
6427 {
6428 // do nothing
6429 }
6430 else
6431 {
6432 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6433 log_info ("");
6434 }
6435 }
6436
6437 /**
6438 * sanity check
6439 */
6440
6441 if (attack_mode > 7)
6442 {
6443 log_error ("ERROR: Invalid attack-mode specified");
6444
6445 return (-1);
6446 }
6447
6448 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6449 {
6450 log_error ("ERROR: Invalid runtime specified");
6451
6452 return (-1);
6453 }
6454
6455 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6456 {
6457 log_error ("ERROR: Invalid hash-type specified");
6458
6459 return (-1);
6460 }
6461
6462 // renamed hash modes
6463
6464 if (hash_mode_chgd)
6465 {
6466 int n = -1;
6467
6468 switch (hash_mode)
6469 {
6470 case 123: n = 124;
6471 break;
6472 }
6473
6474 if (n >= 0)
6475 {
6476 log_error ("Old -m specified, use -m %d instead", n);
6477
6478 return (-1);
6479 }
6480 }
6481
6482 if (username == 1)
6483 {
6484 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6485 {
6486 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6487
6488 return (-1);
6489 }
6490 }
6491
6492 if (outfile_format > 16)
6493 {
6494 log_error ("ERROR: Invalid outfile-format specified");
6495
6496 return (-1);
6497 }
6498
6499 if (left == 1)
6500 {
6501 if (outfile_format_chgd == 1)
6502 {
6503 if (outfile_format > 1)
6504 {
6505 log_error ("ERROR: Mixing outfile-format > 1 with left parameter is not allowed");
6506
6507 return (-1);
6508 }
6509 }
6510 else
6511 {
6512 outfile_format = OUTFILE_FMT_HASH;
6513 }
6514 }
6515
6516 if (show == 1)
6517 {
6518 if (outfile_format_chgd == 1)
6519 {
6520 if ((outfile_format > 7) && (outfile_format < 16))
6521 {
6522 log_error ("ERROR: Mixing outfile-format > 7 with show parameter is not allowed");
6523
6524 return (-1);
6525 }
6526 }
6527 }
6528
6529 if (increment_min < INCREMENT_MIN)
6530 {
6531 log_error ("ERROR: Invalid increment-min specified");
6532
6533 return (-1);
6534 }
6535
6536 if (increment_max > INCREMENT_MAX)
6537 {
6538 log_error ("ERROR: Invalid increment-max specified");
6539
6540 return (-1);
6541 }
6542
6543 if (increment_min > increment_max)
6544 {
6545 log_error ("ERROR: Invalid increment-min specified");
6546
6547 return (-1);
6548 }
6549
6550 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6551 {
6552 log_error ("ERROR: Increment is not allowed in attack-mode 0");
6553
6554 return (-1);
6555 }
6556
6557 if ((increment == 0) && (increment_min_chgd == 1))
6558 {
6559 log_error ("ERROR: Increment-min is only supported combined with increment switch");
6560
6561 return (-1);
6562 }
6563
6564 if ((increment == 0) && (increment_max_chgd == 1))
6565 {
6566 log_error ("ERROR: Increment-max is only supported combined with increment switch");
6567
6568 return (-1);
6569 }
6570
6571 if (rp_files_cnt && rp_gen)
6572 {
6573 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6574
6575 return (-1);
6576 }
6577
6578 if (rp_files_cnt || rp_gen)
6579 {
6580 if (attack_mode != ATTACK_MODE_STRAIGHT)
6581 {
6582 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6583
6584 return (-1);
6585 }
6586 }
6587
6588 if (rp_gen_func_min > rp_gen_func_max)
6589 {
6590 log_error ("ERROR: Invalid rp-gen-func-min specified");
6591
6592 return (-1);
6593 }
6594
6595 if (kernel_accel_chgd == 1)
6596 {
6597 if (force == 0)
6598 {
6599 log_info ("The manual use of the -n option (or --kernel-accel) is outdated");
6600 log_info ("Please consider using the -w option instead");
6601 log_info ("You can use --force to override this but do not post error reports if you do so");
6602 log_info ("");
6603
6604 return (-1);
6605 }
6606
6607 if (kernel_accel < 1)
6608 {
6609 log_error ("ERROR: Invalid kernel-accel specified");
6610
6611 return (-1);
6612 }
6613
6614 if (kernel_accel > 1024)
6615 {
6616 log_error ("ERROR: Invalid kernel-accel specified");
6617
6618 return (-1);
6619 }
6620 }
6621
6622 if (kernel_loops_chgd == 1)
6623 {
6624 if (force == 0)
6625 {
6626 log_info ("The manual use of the -u option (or --kernel-loops) is outdated");
6627 log_info ("Please consider using the -w option instead");
6628 log_info ("You can use --force to override this but do not post error reports if you do so");
6629 log_info ("");
6630
6631 return (-1);
6632 }
6633
6634 if (kernel_loops < 1)
6635 {
6636 log_error ("ERROR: Invalid kernel-loops specified");
6637
6638 return (-1);
6639 }
6640
6641 if (kernel_loops > 1024)
6642 {
6643 log_error ("ERROR: Invalid kernel-loops specified");
6644
6645 return (-1);
6646 }
6647 }
6648
6649 if ((workload_profile < 1) || (workload_profile > 4))
6650 {
6651 log_error ("ERROR: workload-profile %i not available", workload_profile);
6652
6653 return (-1);
6654 }
6655
6656 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6657 {
6658 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6659
6660 return (-1);
6661 }
6662
6663 if (show == 1 || left == 1)
6664 {
6665 attack_mode = ATTACK_MODE_NONE;
6666
6667 if (remove == 1)
6668 {
6669 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6670
6671 return (-1);
6672 }
6673
6674 if (potfile_disable == 1)
6675 {
6676 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6677
6678 return (-1);
6679 }
6680 }
6681
6682 uint attack_kern = ATTACK_KERN_NONE;
6683
6684 switch (attack_mode)
6685 {
6686 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6687 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6688 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6689 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6690 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6691 }
6692
6693 if (benchmark == 1)
6694 {
6695 if (myargv[optind] != 0)
6696 {
6697 log_error ("ERROR: Invalid argument for benchmark mode specified");
6698
6699 return (-1);
6700 }
6701
6702 if (attack_mode_chgd == 1)
6703 {
6704 if (attack_mode != ATTACK_MODE_BF)
6705 {
6706 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6707
6708 return (-1);
6709 }
6710 }
6711 }
6712 else
6713 {
6714 if (stdout_flag == 1) // no hash here
6715 {
6716 optind--;
6717 }
6718
6719 if (keyspace == 1)
6720 {
6721 int num_additional_params = 1;
6722
6723 if (attack_kern == ATTACK_KERN_COMBI)
6724 {
6725 num_additional_params = 2;
6726 }
6727
6728 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6729
6730 if (keyspace_wordlist_specified == 0) optind--;
6731 }
6732
6733 if (attack_kern == ATTACK_KERN_NONE)
6734 {
6735 if ((optind + 1) != myargc)
6736 {
6737 usage_mini_print (myargv[0]);
6738
6739 return (-1);
6740 }
6741 }
6742 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6743 {
6744 if ((optind + 1) > myargc)
6745 {
6746 usage_mini_print (myargv[0]);
6747
6748 return (-1);
6749 }
6750 }
6751 else if (attack_kern == ATTACK_KERN_COMBI)
6752 {
6753 if ((optind + 3) != myargc)
6754 {
6755 usage_mini_print (myargv[0]);
6756
6757 return (-1);
6758 }
6759 }
6760 else if (attack_kern == ATTACK_KERN_BF)
6761 {
6762 if ((optind + 1) > myargc)
6763 {
6764 usage_mini_print (myargv[0]);
6765
6766 return (-1);
6767 }
6768 }
6769 else
6770 {
6771 usage_mini_print (myargv[0]);
6772
6773 return (-1);
6774 }
6775 }
6776
6777 if (skip != 0 && limit != 0)
6778 {
6779 limit += skip;
6780 }
6781
6782 if (keyspace == 1)
6783 {
6784 if (show == 1)
6785 {
6786 log_error ("ERROR: Combining show parameter with keyspace parameter is not allowed");
6787
6788 return (-1);
6789 }
6790 else if (left == 1)
6791 {
6792 log_error ("ERROR: Combining left parameter with keyspace parameter is not allowed");
6793
6794 return (-1);
6795 }
6796
6797 potfile_disable = 1;
6798
6799 restore_disable = 1;
6800
6801 restore = 0;
6802
6803 weak_hash_threshold = 0;
6804
6805 quiet = 1;
6806 }
6807
6808 if (stdout_flag == 1)
6809 {
6810 status_timer = 0;
6811 restore_timer = 0;
6812 restore_disable = 1;
6813 restore = 0;
6814 potfile_disable = 1;
6815 weak_hash_threshold = 0;
6816 gpu_temp_disable = 1;
6817 hash_mode = 2000;
6818 quiet = 1;
6819 outfile_format = OUTFILE_FMT_PLAIN;
6820 kernel_accel = 1024;
6821 kernel_loops = 1024;
6822 force = 1;
6823 outfile_check_timer = 0;
6824 session = "stdout";
6825 opencl_vector_width = 1;
6826 }
6827
6828 if (remove_timer_chgd == 1)
6829 {
6830 if (remove == 0)
6831 {
6832 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6833
6834 return (-1);
6835 }
6836
6837 if (remove_timer < 1)
6838 {
6839 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6840
6841 return (-1);
6842 }
6843 }
6844
6845 if (loopback == 1)
6846 {
6847 if (attack_mode == ATTACK_MODE_STRAIGHT)
6848 {
6849 if ((rp_files_cnt == 0) && (rp_gen == 0))
6850 {
6851 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6852
6853 return (-1);
6854 }
6855 }
6856 else
6857 {
6858 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6859
6860 return (-1);
6861 }
6862 }
6863
6864 if (debug_mode > 0)
6865 {
6866 if (attack_mode != ATTACK_MODE_STRAIGHT)
6867 {
6868 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6869
6870 return (-1);
6871 }
6872
6873 if ((rp_files_cnt == 0) && (rp_gen == 0))
6874 {
6875 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6876
6877 return (-1);
6878 }
6879 }
6880
6881 if (debug_mode > 4)
6882 {
6883 log_error ("ERROR: Invalid debug-mode specified");
6884
6885 return (-1);
6886 }
6887
6888 if (debug_file != NULL)
6889 {
6890 if (debug_mode < 1)
6891 {
6892 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6893
6894 return (-1);
6895 }
6896 }
6897
6898 if (induction_dir != NULL)
6899 {
6900 if (attack_mode == ATTACK_MODE_BF)
6901 {
6902 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6903
6904 return (-1);
6905 }
6906 }
6907
6908 if (attack_mode != ATTACK_MODE_STRAIGHT)
6909 {
6910 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6911 {
6912 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6913
6914 return (-1);
6915 }
6916
6917 weak_hash_threshold = 0;
6918 }
6919
6920 if (nvidia_spin_damp > 100)
6921 {
6922 log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)");
6923
6924 return (-1);
6925 }
6926
6927
6928 /**
6929 * induction directory
6930 */
6931
6932 char *induction_directory = NULL;
6933
6934 if (attack_mode != ATTACK_MODE_BF)
6935 {
6936 if (induction_dir == NULL)
6937 {
6938 induction_directory = (char *) mymalloc (session_size);
6939
6940 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6941
6942 // create induction folder if it does not already exist
6943
6944 if (keyspace == 0)
6945 {
6946 if (rmdir (induction_directory) == -1)
6947 {
6948 if (errno == ENOENT)
6949 {
6950 // good, we can ignore
6951 }
6952 else if (errno == ENOTEMPTY)
6953 {
6954 char *induction_directory_mv = (char *) mymalloc (session_size);
6955
6956 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6957
6958 if (rename (induction_directory, induction_directory_mv) != 0)
6959 {
6960 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6961
6962 return (-1);
6963 }
6964 }
6965 else
6966 {
6967 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6968
6969 return (-1);
6970 }
6971 }
6972
6973 if (mkdir (induction_directory, 0700) == -1)
6974 {
6975 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6976
6977 return (-1);
6978 }
6979 }
6980 }
6981 else
6982 {
6983 induction_directory = induction_dir;
6984 }
6985 }
6986
6987 data.induction_directory = induction_directory;
6988
6989 /**
6990 * loopback
6991 */
6992
6993 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6994
6995 char *loopback_file = (char *) mymalloc (loopback_size);
6996
6997 /**
6998 * tuning db
6999 */
7000
7001 char tuning_db_file[256] = { 0 };
7002
7003 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
7004
7005 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
7006
7007 /**
7008 * outfile-check directory
7009 */
7010
7011 char *outfile_check_directory = NULL;
7012
7013 if (outfile_check_dir == NULL)
7014 {
7015 outfile_check_directory = (char *) mymalloc (session_size);
7016
7017 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
7018 }
7019 else
7020 {
7021 outfile_check_directory = outfile_check_dir;
7022 }
7023
7024 data.outfile_check_directory = outfile_check_directory;
7025
7026 if (keyspace == 0)
7027 {
7028 struct stat outfile_check_stat;
7029
7030 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
7031 {
7032 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
7033
7034 if (is_dir == 0)
7035 {
7036 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
7037
7038 return (-1);
7039 }
7040 }
7041 else if (outfile_check_dir == NULL)
7042 {
7043 if (mkdir (outfile_check_directory, 0700) == -1)
7044 {
7045 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
7046
7047 return (-1);
7048 }
7049 }
7050 }
7051
7052 /**
7053 * special other stuff
7054 */
7055
7056 if (hash_mode == 9710)
7057 {
7058 outfile_format = 5;
7059 outfile_format_chgd = 1;
7060 }
7061
7062 if (hash_mode == 9810)
7063 {
7064 outfile_format = 5;
7065 outfile_format_chgd = 1;
7066 }
7067
7068 if (hash_mode == 10410)
7069 {
7070 outfile_format = 5;
7071 outfile_format_chgd = 1;
7072 }
7073
7074 /**
7075 * store stuff
7076 */
7077
7078 data.hash_mode = hash_mode;
7079 data.restore = restore;
7080 data.restore_timer = restore_timer;
7081 data.restore_disable = restore_disable;
7082 data.status = status;
7083 data.status_timer = status_timer;
7084 data.machine_readable = machine_readable;
7085 data.loopback = loopback;
7086 data.runtime = runtime;
7087 data.remove = remove;
7088 data.remove_timer = remove_timer;
7089 data.debug_mode = debug_mode;
7090 data.debug_file = debug_file;
7091 data.username = username;
7092 data.quiet = quiet;
7093 data.outfile = outfile;
7094 data.outfile_format = outfile_format;
7095 data.outfile_autohex = outfile_autohex;
7096 data.hex_charset = hex_charset;
7097 data.hex_salt = hex_salt;
7098 data.hex_wordlist = hex_wordlist;
7099 data.separator = separator;
7100 data.rp_files = rp_files;
7101 data.rp_files_cnt = rp_files_cnt;
7102 data.rp_gen = rp_gen;
7103 data.rp_gen_seed = rp_gen_seed;
7104 data.force = force;
7105 data.benchmark = benchmark;
7106 data.skip = skip;
7107 data.limit = limit;
7108 #ifdef HAVE_HWMON
7109 data.powertune_enable = powertune_enable;
7110 #endif
7111 data.logfile_disable = logfile_disable;
7112 data.truecrypt_keyfiles = truecrypt_keyfiles;
7113 data.veracrypt_keyfiles = veracrypt_keyfiles;
7114 data.veracrypt_pim = veracrypt_pim;
7115 data.scrypt_tmto = scrypt_tmto;
7116 data.workload_profile = workload_profile;
7117
7118 /**
7119 * cpu affinity
7120 */
7121
7122 if (cpu_affinity)
7123 {
7124 set_cpu_affinity (cpu_affinity);
7125 }
7126
7127 if (rp_gen_seed_chgd == 0)
7128 {
7129 srand (proc_start);
7130 }
7131 else
7132 {
7133 srand (rp_gen_seed);
7134 }
7135
7136 /**
7137 * logfile init
7138 */
7139
7140 if (logfile_disable == 0)
7141 {
7142 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7143
7144 char *logfile = (char *) mymalloc (logfile_size);
7145
7146 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7147
7148 data.logfile = logfile;
7149
7150 char *topid = logfile_generate_topid ();
7151
7152 data.topid = topid;
7153 }
7154
7155 // logfile_append() checks for logfile_disable internally to make it easier from here
7156
7157 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7158 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7159 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7160 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7161 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7162 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7163 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7164 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7165 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7166 #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));
7167
7168 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7169 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7170 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7171 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7172 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7173 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7174 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7175 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7176
7177 logfile_top_msg ("START");
7178
7179 logfile_top_uint (attack_mode);
7180 logfile_top_uint (attack_kern);
7181 logfile_top_uint (benchmark);
7182 logfile_top_uint (stdout_flag);
7183 logfile_top_uint (bitmap_min);
7184 logfile_top_uint (bitmap_max);
7185 logfile_top_uint (debug_mode);
7186 logfile_top_uint (force);
7187 logfile_top_uint (kernel_accel);
7188 logfile_top_uint (kernel_loops);
7189 logfile_top_uint (nvidia_spin_damp);
7190 logfile_top_uint (gpu_temp_disable);
7191 #ifdef HAVE_HWMON
7192 logfile_top_uint (gpu_temp_abort);
7193 logfile_top_uint (gpu_temp_retain);
7194 #endif
7195 logfile_top_uint (hash_mode);
7196 logfile_top_uint (hex_charset);
7197 logfile_top_uint (hex_salt);
7198 logfile_top_uint (hex_wordlist);
7199 logfile_top_uint (increment);
7200 logfile_top_uint (increment_max);
7201 logfile_top_uint (increment_min);
7202 logfile_top_uint (keyspace);
7203 logfile_top_uint (left);
7204 logfile_top_uint (logfile_disable);
7205 logfile_top_uint (loopback);
7206 logfile_top_uint (markov_classic);
7207 logfile_top_uint (markov_disable);
7208 logfile_top_uint (markov_threshold);
7209 logfile_top_uint (outfile_autohex);
7210 logfile_top_uint (outfile_check_timer);
7211 logfile_top_uint (outfile_format);
7212 logfile_top_uint (potfile_disable);
7213 logfile_top_string (potfile_path);
7214 #if defined(HAVE_HWMON)
7215 logfile_top_uint (powertune_enable);
7216 #endif
7217 logfile_top_uint (scrypt_tmto);
7218 logfile_top_uint (quiet);
7219 logfile_top_uint (remove);
7220 logfile_top_uint (remove_timer);
7221 logfile_top_uint (restore);
7222 logfile_top_uint (restore_disable);
7223 logfile_top_uint (restore_timer);
7224 logfile_top_uint (rp_gen);
7225 logfile_top_uint (rp_gen_func_max);
7226 logfile_top_uint (rp_gen_func_min);
7227 logfile_top_uint (rp_gen_seed);
7228 logfile_top_uint (runtime);
7229 logfile_top_uint (segment_size);
7230 logfile_top_uint (show);
7231 logfile_top_uint (status);
7232 logfile_top_uint (machine_readable);
7233 logfile_top_uint (status_timer);
7234 logfile_top_uint (usage);
7235 logfile_top_uint (username);
7236 logfile_top_uint (version);
7237 logfile_top_uint (weak_hash_threshold);
7238 logfile_top_uint (workload_profile);
7239 logfile_top_uint64 (limit);
7240 logfile_top_uint64 (skip);
7241 logfile_top_char (separator);
7242 logfile_top_string (cpu_affinity);
7243 logfile_top_string (custom_charset_1);
7244 logfile_top_string (custom_charset_2);
7245 logfile_top_string (custom_charset_3);
7246 logfile_top_string (custom_charset_4);
7247 logfile_top_string (debug_file);
7248 logfile_top_string (opencl_devices);
7249 logfile_top_string (opencl_platforms);
7250 logfile_top_string (opencl_device_types);
7251 logfile_top_uint (opencl_vector_width);
7252 logfile_top_string (induction_dir);
7253 logfile_top_string (markov_hcstat);
7254 logfile_top_string (outfile);
7255 logfile_top_string (outfile_check_dir);
7256 logfile_top_string (rule_buf_l);
7257 logfile_top_string (rule_buf_r);
7258 logfile_top_string (session);
7259 logfile_top_string (truecrypt_keyfiles);
7260 logfile_top_string (veracrypt_keyfiles);
7261 logfile_top_uint (veracrypt_pim);
7262
7263 /**
7264 * Init OpenCL library loader
7265 */
7266
7267 if (keyspace == 0)
7268 {
7269 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7270
7271 ocl_init (ocl);
7272
7273 data.ocl = ocl;
7274 }
7275
7276 /**
7277 * OpenCL platform selection
7278 */
7279
7280 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7281
7282 /**
7283 * OpenCL device selection
7284 */
7285
7286 u32 devices_filter = setup_devices_filter (opencl_devices);
7287
7288 /**
7289 * OpenCL device type selection
7290 */
7291
7292 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7293
7294 /**
7295 * benchmark
7296 */
7297
7298 if (benchmark == 1)
7299 {
7300 /**
7301 * disable useless stuff for benchmark
7302 */
7303
7304 status_timer = 0;
7305 restore_timer = 0;
7306 restore_disable = 1;
7307 potfile_disable = 1;
7308 weak_hash_threshold = 0;
7309 nvidia_spin_damp = 0;
7310 gpu_temp_disable = 1;
7311 outfile_check_timer = 0;
7312
7313 #ifdef HAVE_HWMON
7314 if (powertune_enable == 1)
7315 {
7316 gpu_temp_disable = 0;
7317 }
7318 #endif
7319
7320 data.status_timer = status_timer;
7321 data.restore_timer = restore_timer;
7322 data.restore_disable = restore_disable;
7323 data.outfile_check_timer = outfile_check_timer;
7324
7325 /**
7326 * force attack mode to be bruteforce
7327 */
7328
7329 attack_mode = ATTACK_MODE_BF;
7330 attack_kern = ATTACK_KERN_BF;
7331
7332 if (workload_profile_chgd == 0)
7333 {
7334 workload_profile = 3;
7335
7336 data.workload_profile = workload_profile;
7337 }
7338 }
7339
7340 /**
7341 * status, monitor and outfile remove threads
7342 */
7343
7344 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
7345
7346 data.wordlist_mode = wordlist_mode;
7347
7348 if (wordlist_mode == WL_MODE_STDIN)
7349 {
7350 status = 1;
7351
7352 data.status = status;
7353 }
7354
7355 uint outer_threads_cnt = 0;
7356
7357 hc_thread_t *outer_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
7358
7359 data.shutdown_outer = 0;
7360
7361 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
7362 {
7363 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
7364 {
7365 hc_thread_create (outer_threads[outer_threads_cnt], thread_keypress, NULL);
7366
7367 outer_threads_cnt++;
7368 }
7369 }
7370
7371 /**
7372 * config
7373 */
7374
7375 uint hash_type = 0;
7376 uint salt_type = 0;
7377 uint attack_exec = 0;
7378 uint opts_type = 0;
7379 uint kern_type = 0;
7380 uint dgst_size = 0;
7381 uint esalt_size = 0;
7382 uint opti_type = 0;
7383 uint dgst_pos0 = -1;
7384 uint dgst_pos1 = -1;
7385 uint dgst_pos2 = -1;
7386 uint dgst_pos3 = -1;
7387
7388 int (*parse_func) (char *, uint, hash_t *);
7389 int (*sort_by_digest) (const void *, const void *);
7390
7391 uint algorithm_pos = 0;
7392 uint algorithm_max = 1;
7393
7394 uint *algorithms = default_benchmark_algorithms;
7395
7396 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7397
7398 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7399 {
7400 /*
7401 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7402 * the following algos are skipped entirely
7403 */
7404
7405 if (algorithm_pos > 0)
7406 {
7407 local_free (rd);
7408
7409 rd = init_restore (argc, argv);
7410
7411 data.rd = rd;
7412 }
7413
7414 /**
7415 * update hash_mode in case of multihash benchmark
7416 */
7417
7418 if (benchmark == 1)
7419 {
7420 if (hash_mode_chgd == 0)
7421 {
7422 hash_mode = algorithms[algorithm_pos];
7423
7424 data.hash_mode = hash_mode;
7425 }
7426
7427 quiet = 1;
7428
7429 data.quiet = quiet;
7430 }
7431
7432 switch (hash_mode)
7433 {
7434 case 0: hash_type = HASH_TYPE_MD5;
7435 salt_type = SALT_TYPE_NONE;
7436 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7437 opts_type = OPTS_TYPE_PT_GENERATE_LE
7438 | OPTS_TYPE_PT_ADD80
7439 | OPTS_TYPE_PT_ADDBITS14;
7440 kern_type = KERN_TYPE_MD5;
7441 dgst_size = DGST_SIZE_4_4;
7442 parse_func = md5_parse_hash;
7443 sort_by_digest = sort_by_digest_4_4;
7444 opti_type = OPTI_TYPE_ZERO_BYTE
7445 | OPTI_TYPE_PRECOMPUTE_INIT
7446 | OPTI_TYPE_PRECOMPUTE_MERKLE
7447 | OPTI_TYPE_MEET_IN_MIDDLE
7448 | OPTI_TYPE_EARLY_SKIP
7449 | OPTI_TYPE_NOT_ITERATED
7450 | OPTI_TYPE_NOT_SALTED
7451 | OPTI_TYPE_RAW_HASH;
7452 dgst_pos0 = 0;
7453 dgst_pos1 = 3;
7454 dgst_pos2 = 2;
7455 dgst_pos3 = 1;
7456 break;
7457
7458 case 10: hash_type = HASH_TYPE_MD5;
7459 salt_type = SALT_TYPE_INTERN;
7460 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7461 opts_type = OPTS_TYPE_PT_GENERATE_LE
7462 | OPTS_TYPE_ST_ADD80
7463 | OPTS_TYPE_ST_ADDBITS14;
7464 kern_type = KERN_TYPE_MD5_PWSLT;
7465 dgst_size = DGST_SIZE_4_4;
7466 parse_func = md5s_parse_hash;
7467 sort_by_digest = sort_by_digest_4_4;
7468 opti_type = OPTI_TYPE_ZERO_BYTE
7469 | OPTI_TYPE_PRECOMPUTE_INIT
7470 | OPTI_TYPE_PRECOMPUTE_MERKLE
7471 | OPTI_TYPE_MEET_IN_MIDDLE
7472 | OPTI_TYPE_EARLY_SKIP
7473 | OPTI_TYPE_NOT_ITERATED
7474 | OPTI_TYPE_APPENDED_SALT
7475 | OPTI_TYPE_RAW_HASH;
7476 dgst_pos0 = 0;
7477 dgst_pos1 = 3;
7478 dgst_pos2 = 2;
7479 dgst_pos3 = 1;
7480 break;
7481
7482 case 11: hash_type = HASH_TYPE_MD5;
7483 salt_type = SALT_TYPE_INTERN;
7484 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7485 opts_type = OPTS_TYPE_PT_GENERATE_LE
7486 | OPTS_TYPE_ST_ADD80
7487 | OPTS_TYPE_ST_ADDBITS14;
7488 kern_type = KERN_TYPE_MD5_PWSLT;
7489 dgst_size = DGST_SIZE_4_4;
7490 parse_func = joomla_parse_hash;
7491 sort_by_digest = sort_by_digest_4_4;
7492 opti_type = OPTI_TYPE_ZERO_BYTE
7493 | OPTI_TYPE_PRECOMPUTE_INIT
7494 | OPTI_TYPE_PRECOMPUTE_MERKLE
7495 | OPTI_TYPE_MEET_IN_MIDDLE
7496 | OPTI_TYPE_EARLY_SKIP
7497 | OPTI_TYPE_NOT_ITERATED
7498 | OPTI_TYPE_APPENDED_SALT
7499 | OPTI_TYPE_RAW_HASH;
7500 dgst_pos0 = 0;
7501 dgst_pos1 = 3;
7502 dgst_pos2 = 2;
7503 dgst_pos3 = 1;
7504 break;
7505
7506 case 12: hash_type = HASH_TYPE_MD5;
7507 salt_type = SALT_TYPE_INTERN;
7508 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7509 opts_type = OPTS_TYPE_PT_GENERATE_LE
7510 | OPTS_TYPE_ST_ADD80
7511 | OPTS_TYPE_ST_ADDBITS14;
7512 kern_type = KERN_TYPE_MD5_PWSLT;
7513 dgst_size = DGST_SIZE_4_4;
7514 parse_func = postgresql_parse_hash;
7515 sort_by_digest = sort_by_digest_4_4;
7516 opti_type = OPTI_TYPE_ZERO_BYTE
7517 | OPTI_TYPE_PRECOMPUTE_INIT
7518 | OPTI_TYPE_PRECOMPUTE_MERKLE
7519 | OPTI_TYPE_MEET_IN_MIDDLE
7520 | OPTI_TYPE_EARLY_SKIP
7521 | OPTI_TYPE_NOT_ITERATED
7522 | OPTI_TYPE_APPENDED_SALT
7523 | OPTI_TYPE_RAW_HASH;
7524 dgst_pos0 = 0;
7525 dgst_pos1 = 3;
7526 dgst_pos2 = 2;
7527 dgst_pos3 = 1;
7528 break;
7529
7530 case 20: hash_type = HASH_TYPE_MD5;
7531 salt_type = SALT_TYPE_INTERN;
7532 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7533 opts_type = OPTS_TYPE_PT_GENERATE_LE
7534 | OPTS_TYPE_PT_ADD80
7535 | OPTS_TYPE_PT_ADDBITS14;
7536 kern_type = KERN_TYPE_MD5_SLTPW;
7537 dgst_size = DGST_SIZE_4_4;
7538 parse_func = md5s_parse_hash;
7539 sort_by_digest = sort_by_digest_4_4;
7540 opti_type = OPTI_TYPE_ZERO_BYTE
7541 | OPTI_TYPE_PRECOMPUTE_INIT
7542 | OPTI_TYPE_PRECOMPUTE_MERKLE
7543 | OPTI_TYPE_EARLY_SKIP
7544 | OPTI_TYPE_NOT_ITERATED
7545 | OPTI_TYPE_PREPENDED_SALT
7546 | OPTI_TYPE_RAW_HASH;
7547 dgst_pos0 = 0;
7548 dgst_pos1 = 3;
7549 dgst_pos2 = 2;
7550 dgst_pos3 = 1;
7551 break;
7552
7553 case 21: hash_type = HASH_TYPE_MD5;
7554 salt_type = SALT_TYPE_INTERN;
7555 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7556 opts_type = OPTS_TYPE_PT_GENERATE_LE
7557 | OPTS_TYPE_PT_ADD80
7558 | OPTS_TYPE_PT_ADDBITS14;
7559 kern_type = KERN_TYPE_MD5_SLTPW;
7560 dgst_size = DGST_SIZE_4_4;
7561 parse_func = osc_parse_hash;
7562 sort_by_digest = sort_by_digest_4_4;
7563 opti_type = OPTI_TYPE_ZERO_BYTE
7564 | OPTI_TYPE_PRECOMPUTE_INIT
7565 | OPTI_TYPE_PRECOMPUTE_MERKLE
7566 | OPTI_TYPE_EARLY_SKIP
7567 | OPTI_TYPE_NOT_ITERATED
7568 | OPTI_TYPE_PREPENDED_SALT
7569 | OPTI_TYPE_RAW_HASH;
7570 dgst_pos0 = 0;
7571 dgst_pos1 = 3;
7572 dgst_pos2 = 2;
7573 dgst_pos3 = 1;
7574 break;
7575
7576 case 22: hash_type = HASH_TYPE_MD5;
7577 salt_type = SALT_TYPE_EMBEDDED;
7578 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7579 opts_type = OPTS_TYPE_PT_GENERATE_LE
7580 | OPTS_TYPE_PT_ADD80
7581 | OPTS_TYPE_PT_ADDBITS14;
7582 kern_type = KERN_TYPE_MD5_SLTPW;
7583 dgst_size = DGST_SIZE_4_4;
7584 parse_func = netscreen_parse_hash;
7585 sort_by_digest = sort_by_digest_4_4;
7586 opti_type = OPTI_TYPE_ZERO_BYTE
7587 | OPTI_TYPE_PRECOMPUTE_INIT
7588 | OPTI_TYPE_PRECOMPUTE_MERKLE
7589 | OPTI_TYPE_EARLY_SKIP
7590 | OPTI_TYPE_NOT_ITERATED
7591 | OPTI_TYPE_PREPENDED_SALT
7592 | OPTI_TYPE_RAW_HASH;
7593 dgst_pos0 = 0;
7594 dgst_pos1 = 3;
7595 dgst_pos2 = 2;
7596 dgst_pos3 = 1;
7597 break;
7598
7599 case 23: hash_type = HASH_TYPE_MD5;
7600 salt_type = SALT_TYPE_EMBEDDED;
7601 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7602 opts_type = OPTS_TYPE_PT_GENERATE_LE
7603 | OPTS_TYPE_PT_ADD80
7604 | OPTS_TYPE_PT_ADDBITS14;
7605 kern_type = KERN_TYPE_MD5_SLTPW;
7606 dgst_size = DGST_SIZE_4_4;
7607 parse_func = skype_parse_hash;
7608 sort_by_digest = sort_by_digest_4_4;
7609 opti_type = OPTI_TYPE_ZERO_BYTE
7610 | OPTI_TYPE_PRECOMPUTE_INIT
7611 | OPTI_TYPE_PRECOMPUTE_MERKLE
7612 | OPTI_TYPE_EARLY_SKIP
7613 | OPTI_TYPE_NOT_ITERATED
7614 | OPTI_TYPE_PREPENDED_SALT
7615 | OPTI_TYPE_RAW_HASH;
7616 dgst_pos0 = 0;
7617 dgst_pos1 = 3;
7618 dgst_pos2 = 2;
7619 dgst_pos3 = 1;
7620 break;
7621
7622 case 30: hash_type = HASH_TYPE_MD5;
7623 salt_type = SALT_TYPE_INTERN;
7624 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7625 opts_type = OPTS_TYPE_PT_GENERATE_LE
7626 | OPTS_TYPE_PT_UNICODE
7627 | OPTS_TYPE_ST_ADD80
7628 | OPTS_TYPE_ST_ADDBITS14;
7629 kern_type = KERN_TYPE_MD5_PWUSLT;
7630 dgst_size = DGST_SIZE_4_4;
7631 parse_func = md5s_parse_hash;
7632 sort_by_digest = sort_by_digest_4_4;
7633 opti_type = OPTI_TYPE_ZERO_BYTE
7634 | OPTI_TYPE_PRECOMPUTE_INIT
7635 | OPTI_TYPE_PRECOMPUTE_MERKLE
7636 | OPTI_TYPE_MEET_IN_MIDDLE
7637 | OPTI_TYPE_EARLY_SKIP
7638 | OPTI_TYPE_NOT_ITERATED
7639 | OPTI_TYPE_APPENDED_SALT
7640 | OPTI_TYPE_RAW_HASH;
7641 dgst_pos0 = 0;
7642 dgst_pos1 = 3;
7643 dgst_pos2 = 2;
7644 dgst_pos3 = 1;
7645 break;
7646
7647 case 40: hash_type = HASH_TYPE_MD5;
7648 salt_type = SALT_TYPE_INTERN;
7649 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7650 opts_type = OPTS_TYPE_PT_GENERATE_LE
7651 | OPTS_TYPE_PT_ADD80
7652 | OPTS_TYPE_PT_ADDBITS14
7653 | OPTS_TYPE_PT_UNICODE;
7654 kern_type = KERN_TYPE_MD5_SLTPWU;
7655 dgst_size = DGST_SIZE_4_4;
7656 parse_func = md5s_parse_hash;
7657 sort_by_digest = sort_by_digest_4_4;
7658 opti_type = OPTI_TYPE_ZERO_BYTE
7659 | OPTI_TYPE_PRECOMPUTE_INIT
7660 | OPTI_TYPE_PRECOMPUTE_MERKLE
7661 | OPTI_TYPE_EARLY_SKIP
7662 | OPTI_TYPE_NOT_ITERATED
7663 | OPTI_TYPE_PREPENDED_SALT
7664 | OPTI_TYPE_RAW_HASH;
7665 dgst_pos0 = 0;
7666 dgst_pos1 = 3;
7667 dgst_pos2 = 2;
7668 dgst_pos3 = 1;
7669 break;
7670
7671 case 50: hash_type = HASH_TYPE_MD5;
7672 salt_type = SALT_TYPE_INTERN;
7673 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7674 opts_type = OPTS_TYPE_PT_GENERATE_LE
7675 | OPTS_TYPE_ST_ADD80
7676 | OPTS_TYPE_ST_ADDBITS14;
7677 kern_type = KERN_TYPE_HMACMD5_PW;
7678 dgst_size = DGST_SIZE_4_4;
7679 parse_func = hmacmd5_parse_hash;
7680 sort_by_digest = sort_by_digest_4_4;
7681 opti_type = OPTI_TYPE_ZERO_BYTE
7682 | OPTI_TYPE_NOT_ITERATED;
7683 dgst_pos0 = 0;
7684 dgst_pos1 = 3;
7685 dgst_pos2 = 2;
7686 dgst_pos3 = 1;
7687 break;
7688
7689 case 60: hash_type = HASH_TYPE_MD5;
7690 salt_type = SALT_TYPE_INTERN;
7691 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7692 opts_type = OPTS_TYPE_PT_GENERATE_LE
7693 | OPTS_TYPE_PT_ADD80
7694 | OPTS_TYPE_PT_ADDBITS14;
7695 kern_type = KERN_TYPE_HMACMD5_SLT;
7696 dgst_size = DGST_SIZE_4_4;
7697 parse_func = hmacmd5_parse_hash;
7698 sort_by_digest = sort_by_digest_4_4;
7699 opti_type = OPTI_TYPE_ZERO_BYTE
7700 | OPTI_TYPE_NOT_ITERATED;
7701 dgst_pos0 = 0;
7702 dgst_pos1 = 3;
7703 dgst_pos2 = 2;
7704 dgst_pos3 = 1;
7705 break;
7706
7707 case 100: hash_type = HASH_TYPE_SHA1;
7708 salt_type = SALT_TYPE_NONE;
7709 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7710 opts_type = OPTS_TYPE_PT_GENERATE_BE
7711 | OPTS_TYPE_PT_ADD80
7712 | OPTS_TYPE_PT_ADDBITS15;
7713 kern_type = KERN_TYPE_SHA1;
7714 dgst_size = DGST_SIZE_4_5;
7715 parse_func = sha1_parse_hash;
7716 sort_by_digest = sort_by_digest_4_5;
7717 opti_type = OPTI_TYPE_ZERO_BYTE
7718 | OPTI_TYPE_PRECOMPUTE_INIT
7719 | OPTI_TYPE_PRECOMPUTE_MERKLE
7720 | OPTI_TYPE_EARLY_SKIP
7721 | OPTI_TYPE_NOT_ITERATED
7722 | OPTI_TYPE_NOT_SALTED
7723 | OPTI_TYPE_RAW_HASH;
7724 dgst_pos0 = 3;
7725 dgst_pos1 = 4;
7726 dgst_pos2 = 2;
7727 dgst_pos3 = 1;
7728 break;
7729
7730 case 101: hash_type = HASH_TYPE_SHA1;
7731 salt_type = SALT_TYPE_NONE;
7732 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7733 opts_type = OPTS_TYPE_PT_GENERATE_BE
7734 | OPTS_TYPE_PT_ADD80
7735 | OPTS_TYPE_PT_ADDBITS15;
7736 kern_type = KERN_TYPE_SHA1;
7737 dgst_size = DGST_SIZE_4_5;
7738 parse_func = sha1b64_parse_hash;
7739 sort_by_digest = sort_by_digest_4_5;
7740 opti_type = OPTI_TYPE_ZERO_BYTE
7741 | OPTI_TYPE_PRECOMPUTE_INIT
7742 | OPTI_TYPE_PRECOMPUTE_MERKLE
7743 | OPTI_TYPE_EARLY_SKIP
7744 | OPTI_TYPE_NOT_ITERATED
7745 | OPTI_TYPE_NOT_SALTED
7746 | OPTI_TYPE_RAW_HASH;
7747 dgst_pos0 = 3;
7748 dgst_pos1 = 4;
7749 dgst_pos2 = 2;
7750 dgst_pos3 = 1;
7751 break;
7752
7753 case 110: hash_type = HASH_TYPE_SHA1;
7754 salt_type = SALT_TYPE_INTERN;
7755 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7756 opts_type = OPTS_TYPE_PT_GENERATE_BE
7757 | OPTS_TYPE_ST_ADD80
7758 | OPTS_TYPE_ST_ADDBITS15;
7759 kern_type = KERN_TYPE_SHA1_PWSLT;
7760 dgst_size = DGST_SIZE_4_5;
7761 parse_func = sha1s_parse_hash;
7762 sort_by_digest = sort_by_digest_4_5;
7763 opti_type = OPTI_TYPE_ZERO_BYTE
7764 | OPTI_TYPE_PRECOMPUTE_INIT
7765 | OPTI_TYPE_PRECOMPUTE_MERKLE
7766 | OPTI_TYPE_EARLY_SKIP
7767 | OPTI_TYPE_NOT_ITERATED
7768 | OPTI_TYPE_APPENDED_SALT
7769 | OPTI_TYPE_RAW_HASH;
7770 dgst_pos0 = 3;
7771 dgst_pos1 = 4;
7772 dgst_pos2 = 2;
7773 dgst_pos3 = 1;
7774 break;
7775
7776 case 111: hash_type = HASH_TYPE_SHA1;
7777 salt_type = SALT_TYPE_EMBEDDED;
7778 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7779 opts_type = OPTS_TYPE_PT_GENERATE_BE
7780 | OPTS_TYPE_ST_ADD80
7781 | OPTS_TYPE_ST_ADDBITS15;
7782 kern_type = KERN_TYPE_SHA1_PWSLT;
7783 dgst_size = DGST_SIZE_4_5;
7784 parse_func = sha1b64s_parse_hash;
7785 sort_by_digest = sort_by_digest_4_5;
7786 opti_type = OPTI_TYPE_ZERO_BYTE
7787 | OPTI_TYPE_PRECOMPUTE_INIT
7788 | OPTI_TYPE_PRECOMPUTE_MERKLE
7789 | OPTI_TYPE_EARLY_SKIP
7790 | OPTI_TYPE_NOT_ITERATED
7791 | OPTI_TYPE_APPENDED_SALT
7792 | OPTI_TYPE_RAW_HASH;
7793 dgst_pos0 = 3;
7794 dgst_pos1 = 4;
7795 dgst_pos2 = 2;
7796 dgst_pos3 = 1;
7797 break;
7798
7799 case 112: hash_type = HASH_TYPE_SHA1;
7800 salt_type = SALT_TYPE_INTERN;
7801 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7802 opts_type = OPTS_TYPE_PT_GENERATE_BE
7803 | OPTS_TYPE_ST_ADD80
7804 | OPTS_TYPE_ST_ADDBITS15
7805 | OPTS_TYPE_ST_HEX;
7806 kern_type = KERN_TYPE_SHA1_PWSLT;
7807 dgst_size = DGST_SIZE_4_5;
7808 parse_func = oracles_parse_hash;
7809 sort_by_digest = sort_by_digest_4_5;
7810 opti_type = OPTI_TYPE_ZERO_BYTE
7811 | OPTI_TYPE_PRECOMPUTE_INIT
7812 | OPTI_TYPE_PRECOMPUTE_MERKLE
7813 | OPTI_TYPE_EARLY_SKIP
7814 | OPTI_TYPE_NOT_ITERATED
7815 | OPTI_TYPE_APPENDED_SALT
7816 | OPTI_TYPE_RAW_HASH;
7817 dgst_pos0 = 3;
7818 dgst_pos1 = 4;
7819 dgst_pos2 = 2;
7820 dgst_pos3 = 1;
7821 break;
7822
7823 case 120: hash_type = HASH_TYPE_SHA1;
7824 salt_type = SALT_TYPE_INTERN;
7825 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7826 opts_type = OPTS_TYPE_PT_GENERATE_BE
7827 | OPTS_TYPE_PT_ADD80
7828 | OPTS_TYPE_PT_ADDBITS15;
7829 kern_type = KERN_TYPE_SHA1_SLTPW;
7830 dgst_size = DGST_SIZE_4_5;
7831 parse_func = sha1s_parse_hash;
7832 sort_by_digest = sort_by_digest_4_5;
7833 opti_type = OPTI_TYPE_ZERO_BYTE
7834 | OPTI_TYPE_PRECOMPUTE_INIT
7835 | OPTI_TYPE_PRECOMPUTE_MERKLE
7836 | OPTI_TYPE_EARLY_SKIP
7837 | OPTI_TYPE_NOT_ITERATED
7838 | OPTI_TYPE_PREPENDED_SALT
7839 | OPTI_TYPE_RAW_HASH;
7840 dgst_pos0 = 3;
7841 dgst_pos1 = 4;
7842 dgst_pos2 = 2;
7843 dgst_pos3 = 1;
7844 break;
7845
7846 case 121: hash_type = HASH_TYPE_SHA1;
7847 salt_type = SALT_TYPE_INTERN;
7848 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7849 opts_type = OPTS_TYPE_PT_GENERATE_BE
7850 | OPTS_TYPE_PT_ADD80
7851 | OPTS_TYPE_PT_ADDBITS15
7852 | OPTS_TYPE_ST_LOWER;
7853 kern_type = KERN_TYPE_SHA1_SLTPW;
7854 dgst_size = DGST_SIZE_4_5;
7855 parse_func = smf_parse_hash;
7856 sort_by_digest = sort_by_digest_4_5;
7857 opti_type = OPTI_TYPE_ZERO_BYTE
7858 | OPTI_TYPE_PRECOMPUTE_INIT
7859 | OPTI_TYPE_PRECOMPUTE_MERKLE
7860 | OPTI_TYPE_EARLY_SKIP
7861 | OPTI_TYPE_NOT_ITERATED
7862 | OPTI_TYPE_PREPENDED_SALT
7863 | OPTI_TYPE_RAW_HASH;
7864 dgst_pos0 = 3;
7865 dgst_pos1 = 4;
7866 dgst_pos2 = 2;
7867 dgst_pos3 = 1;
7868 break;
7869
7870 case 122: hash_type = HASH_TYPE_SHA1;
7871 salt_type = SALT_TYPE_EMBEDDED;
7872 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7873 opts_type = OPTS_TYPE_PT_GENERATE_BE
7874 | OPTS_TYPE_PT_ADD80
7875 | OPTS_TYPE_PT_ADDBITS15
7876 | OPTS_TYPE_ST_HEX;
7877 kern_type = KERN_TYPE_SHA1_SLTPW;
7878 dgst_size = DGST_SIZE_4_5;
7879 parse_func = osx1_parse_hash;
7880 sort_by_digest = sort_by_digest_4_5;
7881 opti_type = OPTI_TYPE_ZERO_BYTE
7882 | OPTI_TYPE_PRECOMPUTE_INIT
7883 | OPTI_TYPE_PRECOMPUTE_MERKLE
7884 | OPTI_TYPE_EARLY_SKIP
7885 | OPTI_TYPE_NOT_ITERATED
7886 | OPTI_TYPE_PREPENDED_SALT
7887 | OPTI_TYPE_RAW_HASH;
7888 dgst_pos0 = 3;
7889 dgst_pos1 = 4;
7890 dgst_pos2 = 2;
7891 dgst_pos3 = 1;
7892 break;
7893
7894 case 124: hash_type = HASH_TYPE_SHA1;
7895 salt_type = SALT_TYPE_EMBEDDED;
7896 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7897 opts_type = OPTS_TYPE_PT_GENERATE_BE
7898 | OPTS_TYPE_PT_ADD80
7899 | OPTS_TYPE_PT_ADDBITS15;
7900 kern_type = KERN_TYPE_SHA1_SLTPW;
7901 dgst_size = DGST_SIZE_4_5;
7902 parse_func = djangosha1_parse_hash;
7903 sort_by_digest = sort_by_digest_4_5;
7904 opti_type = OPTI_TYPE_ZERO_BYTE
7905 | OPTI_TYPE_PRECOMPUTE_INIT
7906 | OPTI_TYPE_PRECOMPUTE_MERKLE
7907 | OPTI_TYPE_EARLY_SKIP
7908 | OPTI_TYPE_NOT_ITERATED
7909 | OPTI_TYPE_PREPENDED_SALT
7910 | OPTI_TYPE_RAW_HASH;
7911 dgst_pos0 = 3;
7912 dgst_pos1 = 4;
7913 dgst_pos2 = 2;
7914 dgst_pos3 = 1;
7915 break;
7916
7917 case 125: hash_type = HASH_TYPE_SHA1;
7918 salt_type = SALT_TYPE_EMBEDDED;
7919 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7920 opts_type = OPTS_TYPE_PT_GENERATE_BE
7921 | OPTS_TYPE_PT_ADD80
7922 | OPTS_TYPE_PT_ADDBITS15
7923 | OPTS_TYPE_ST_HEX;
7924 kern_type = KERN_TYPE_SHA1_SLTPW;
7925 dgst_size = DGST_SIZE_4_5;
7926 parse_func = arubaos_parse_hash;
7927 sort_by_digest = sort_by_digest_4_5;
7928 opti_type = OPTI_TYPE_ZERO_BYTE
7929 | OPTI_TYPE_PRECOMPUTE_INIT
7930 | OPTI_TYPE_PRECOMPUTE_MERKLE
7931 | OPTI_TYPE_EARLY_SKIP
7932 | OPTI_TYPE_NOT_ITERATED
7933 | OPTI_TYPE_PREPENDED_SALT
7934 | OPTI_TYPE_RAW_HASH;
7935 dgst_pos0 = 3;
7936 dgst_pos1 = 4;
7937 dgst_pos2 = 2;
7938 dgst_pos3 = 1;
7939 break;
7940
7941 case 130: hash_type = HASH_TYPE_SHA1;
7942 salt_type = SALT_TYPE_INTERN;
7943 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7944 opts_type = OPTS_TYPE_PT_GENERATE_BE
7945 | OPTS_TYPE_PT_UNICODE
7946 | OPTS_TYPE_ST_ADD80
7947 | OPTS_TYPE_ST_ADDBITS15;
7948 kern_type = KERN_TYPE_SHA1_PWUSLT;
7949 dgst_size = DGST_SIZE_4_5;
7950 parse_func = sha1s_parse_hash;
7951 sort_by_digest = sort_by_digest_4_5;
7952 opti_type = OPTI_TYPE_ZERO_BYTE
7953 | OPTI_TYPE_PRECOMPUTE_INIT
7954 | OPTI_TYPE_PRECOMPUTE_MERKLE
7955 | OPTI_TYPE_EARLY_SKIP
7956 | OPTI_TYPE_NOT_ITERATED
7957 | OPTI_TYPE_APPENDED_SALT
7958 | OPTI_TYPE_RAW_HASH;
7959 dgst_pos0 = 3;
7960 dgst_pos1 = 4;
7961 dgst_pos2 = 2;
7962 dgst_pos3 = 1;
7963 break;
7964
7965 case 131: hash_type = HASH_TYPE_SHA1;
7966 salt_type = SALT_TYPE_EMBEDDED;
7967 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7968 opts_type = OPTS_TYPE_PT_GENERATE_BE
7969 | OPTS_TYPE_PT_UNICODE
7970 | OPTS_TYPE_PT_UPPER
7971 | OPTS_TYPE_ST_ADD80
7972 | OPTS_TYPE_ST_ADDBITS15
7973 | OPTS_TYPE_ST_HEX;
7974 kern_type = KERN_TYPE_SHA1_PWUSLT;
7975 dgst_size = DGST_SIZE_4_5;
7976 parse_func = mssql2000_parse_hash;
7977 sort_by_digest = sort_by_digest_4_5;
7978 opti_type = OPTI_TYPE_ZERO_BYTE
7979 | OPTI_TYPE_PRECOMPUTE_INIT
7980 | OPTI_TYPE_PRECOMPUTE_MERKLE
7981 | OPTI_TYPE_EARLY_SKIP
7982 | OPTI_TYPE_NOT_ITERATED
7983 | OPTI_TYPE_APPENDED_SALT
7984 | OPTI_TYPE_RAW_HASH;
7985 dgst_pos0 = 3;
7986 dgst_pos1 = 4;
7987 dgst_pos2 = 2;
7988 dgst_pos3 = 1;
7989 break;
7990
7991 case 132: hash_type = HASH_TYPE_SHA1;
7992 salt_type = SALT_TYPE_EMBEDDED;
7993 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7994 opts_type = OPTS_TYPE_PT_GENERATE_BE
7995 | OPTS_TYPE_PT_UNICODE
7996 | OPTS_TYPE_ST_ADD80
7997 | OPTS_TYPE_ST_ADDBITS15
7998 | OPTS_TYPE_ST_HEX;
7999 kern_type = KERN_TYPE_SHA1_PWUSLT;
8000 dgst_size = DGST_SIZE_4_5;
8001 parse_func = mssql2005_parse_hash;
8002 sort_by_digest = sort_by_digest_4_5;
8003 opti_type = OPTI_TYPE_ZERO_BYTE
8004 | OPTI_TYPE_PRECOMPUTE_INIT
8005 | OPTI_TYPE_PRECOMPUTE_MERKLE
8006 | OPTI_TYPE_EARLY_SKIP
8007 | OPTI_TYPE_NOT_ITERATED
8008 | OPTI_TYPE_APPENDED_SALT
8009 | OPTI_TYPE_RAW_HASH;
8010 dgst_pos0 = 3;
8011 dgst_pos1 = 4;
8012 dgst_pos2 = 2;
8013 dgst_pos3 = 1;
8014 break;
8015
8016 case 133: hash_type = HASH_TYPE_SHA1;
8017 salt_type = SALT_TYPE_EMBEDDED;
8018 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8019 opts_type = OPTS_TYPE_PT_GENERATE_BE
8020 | OPTS_TYPE_PT_UNICODE
8021 | OPTS_TYPE_ST_ADD80
8022 | OPTS_TYPE_ST_ADDBITS15;
8023 kern_type = KERN_TYPE_SHA1_PWUSLT;
8024 dgst_size = DGST_SIZE_4_5;
8025 parse_func = peoplesoft_parse_hash;
8026 sort_by_digest = sort_by_digest_4_5;
8027 opti_type = OPTI_TYPE_ZERO_BYTE
8028 | OPTI_TYPE_PRECOMPUTE_INIT
8029 | OPTI_TYPE_PRECOMPUTE_MERKLE
8030 | OPTI_TYPE_EARLY_SKIP
8031 | OPTI_TYPE_NOT_ITERATED
8032 | OPTI_TYPE_APPENDED_SALT
8033 | OPTI_TYPE_RAW_HASH;
8034 dgst_pos0 = 3;
8035 dgst_pos1 = 4;
8036 dgst_pos2 = 2;
8037 dgst_pos3 = 1;
8038 break;
8039
8040 case 140: hash_type = HASH_TYPE_SHA1;
8041 salt_type = SALT_TYPE_INTERN;
8042 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8043 opts_type = OPTS_TYPE_PT_GENERATE_BE
8044 | OPTS_TYPE_PT_ADD80
8045 | OPTS_TYPE_PT_ADDBITS15
8046 | OPTS_TYPE_PT_UNICODE;
8047 kern_type = KERN_TYPE_SHA1_SLTPWU;
8048 dgst_size = DGST_SIZE_4_5;
8049 parse_func = sha1s_parse_hash;
8050 sort_by_digest = sort_by_digest_4_5;
8051 opti_type = OPTI_TYPE_ZERO_BYTE
8052 | OPTI_TYPE_PRECOMPUTE_INIT
8053 | OPTI_TYPE_PRECOMPUTE_MERKLE
8054 | OPTI_TYPE_EARLY_SKIP
8055 | OPTI_TYPE_NOT_ITERATED
8056 | OPTI_TYPE_PREPENDED_SALT
8057 | OPTI_TYPE_RAW_HASH;
8058 dgst_pos0 = 3;
8059 dgst_pos1 = 4;
8060 dgst_pos2 = 2;
8061 dgst_pos3 = 1;
8062 break;
8063
8064 case 141: hash_type = HASH_TYPE_SHA1;
8065 salt_type = SALT_TYPE_EMBEDDED;
8066 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8067 opts_type = OPTS_TYPE_PT_GENERATE_BE
8068 | OPTS_TYPE_PT_ADD80
8069 | OPTS_TYPE_PT_ADDBITS15
8070 | OPTS_TYPE_PT_UNICODE
8071 | OPTS_TYPE_ST_BASE64;
8072 kern_type = KERN_TYPE_SHA1_SLTPWU;
8073 dgst_size = DGST_SIZE_4_5;
8074 parse_func = episerver_parse_hash;
8075 sort_by_digest = sort_by_digest_4_5;
8076 opti_type = OPTI_TYPE_ZERO_BYTE
8077 | OPTI_TYPE_PRECOMPUTE_INIT
8078 | OPTI_TYPE_PRECOMPUTE_MERKLE
8079 | OPTI_TYPE_EARLY_SKIP
8080 | OPTI_TYPE_NOT_ITERATED
8081 | OPTI_TYPE_PREPENDED_SALT
8082 | OPTI_TYPE_RAW_HASH;
8083 dgst_pos0 = 3;
8084 dgst_pos1 = 4;
8085 dgst_pos2 = 2;
8086 dgst_pos3 = 1;
8087 break;
8088
8089 case 150: hash_type = HASH_TYPE_SHA1;
8090 salt_type = SALT_TYPE_INTERN;
8091 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8092 opts_type = OPTS_TYPE_PT_GENERATE_BE
8093 | OPTS_TYPE_ST_ADD80
8094 | OPTS_TYPE_ST_ADDBITS15;
8095 kern_type = KERN_TYPE_HMACSHA1_PW;
8096 dgst_size = DGST_SIZE_4_5;
8097 parse_func = hmacsha1_parse_hash;
8098 sort_by_digest = sort_by_digest_4_5;
8099 opti_type = OPTI_TYPE_ZERO_BYTE
8100 | OPTI_TYPE_NOT_ITERATED;
8101 dgst_pos0 = 3;
8102 dgst_pos1 = 4;
8103 dgst_pos2 = 2;
8104 dgst_pos3 = 1;
8105 break;
8106
8107 case 160: hash_type = HASH_TYPE_SHA1;
8108 salt_type = SALT_TYPE_INTERN;
8109 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8110 opts_type = OPTS_TYPE_PT_GENERATE_BE
8111 | OPTS_TYPE_PT_ADD80
8112 | OPTS_TYPE_PT_ADDBITS15;
8113 kern_type = KERN_TYPE_HMACSHA1_SLT;
8114 dgst_size = DGST_SIZE_4_5;
8115 parse_func = hmacsha1_parse_hash;
8116 sort_by_digest = sort_by_digest_4_5;
8117 opti_type = OPTI_TYPE_ZERO_BYTE
8118 | OPTI_TYPE_NOT_ITERATED;
8119 dgst_pos0 = 3;
8120 dgst_pos1 = 4;
8121 dgst_pos2 = 2;
8122 dgst_pos3 = 1;
8123 break;
8124
8125 case 200: hash_type = HASH_TYPE_MYSQL;
8126 salt_type = SALT_TYPE_NONE;
8127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8128 opts_type = 0;
8129 kern_type = KERN_TYPE_MYSQL;
8130 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8131 parse_func = mysql323_parse_hash;
8132 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8133 opti_type = OPTI_TYPE_ZERO_BYTE;
8134 dgst_pos0 = 0;
8135 dgst_pos1 = 1;
8136 dgst_pos2 = 2;
8137 dgst_pos3 = 3;
8138 break;
8139
8140 case 300: hash_type = HASH_TYPE_SHA1;
8141 salt_type = SALT_TYPE_NONE;
8142 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8143 opts_type = OPTS_TYPE_PT_GENERATE_BE
8144 | OPTS_TYPE_PT_ADD80
8145 | OPTS_TYPE_PT_ADDBITS15;
8146 kern_type = KERN_TYPE_MYSQL41;
8147 dgst_size = DGST_SIZE_4_5;
8148 parse_func = sha1_parse_hash;
8149 sort_by_digest = sort_by_digest_4_5;
8150 opti_type = OPTI_TYPE_ZERO_BYTE
8151 | OPTI_TYPE_PRECOMPUTE_INIT
8152 | OPTI_TYPE_PRECOMPUTE_MERKLE
8153 | OPTI_TYPE_EARLY_SKIP
8154 | OPTI_TYPE_NOT_ITERATED
8155 | OPTI_TYPE_NOT_SALTED;
8156 dgst_pos0 = 3;
8157 dgst_pos1 = 4;
8158 dgst_pos2 = 2;
8159 dgst_pos3 = 1;
8160 break;
8161
8162 case 400: hash_type = HASH_TYPE_MD5;
8163 salt_type = SALT_TYPE_EMBEDDED;
8164 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8165 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8166 kern_type = KERN_TYPE_PHPASS;
8167 dgst_size = DGST_SIZE_4_4;
8168 parse_func = phpass_parse_hash;
8169 sort_by_digest = sort_by_digest_4_4;
8170 opti_type = OPTI_TYPE_ZERO_BYTE
8171 | OPTI_TYPE_SLOW_HASH_SIMD;
8172 dgst_pos0 = 0;
8173 dgst_pos1 = 1;
8174 dgst_pos2 = 2;
8175 dgst_pos3 = 3;
8176 break;
8177
8178 case 500: hash_type = HASH_TYPE_MD5;
8179 salt_type = SALT_TYPE_EMBEDDED;
8180 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8181 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8182 kern_type = KERN_TYPE_MD5CRYPT;
8183 dgst_size = DGST_SIZE_4_4;
8184 parse_func = md5crypt_parse_hash;
8185 sort_by_digest = sort_by_digest_4_4;
8186 opti_type = OPTI_TYPE_ZERO_BYTE;
8187 dgst_pos0 = 0;
8188 dgst_pos1 = 1;
8189 dgst_pos2 = 2;
8190 dgst_pos3 = 3;
8191 break;
8192
8193 case 501: hash_type = HASH_TYPE_MD5;
8194 salt_type = SALT_TYPE_EMBEDDED;
8195 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8196 opts_type = OPTS_TYPE_PT_GENERATE_LE
8197 | OPTS_TYPE_HASH_COPY;
8198 kern_type = KERN_TYPE_MD5CRYPT;
8199 dgst_size = DGST_SIZE_4_4;
8200 parse_func = juniper_parse_hash;
8201 sort_by_digest = sort_by_digest_4_4;
8202 opti_type = OPTI_TYPE_ZERO_BYTE;
8203 dgst_pos0 = 0;
8204 dgst_pos1 = 1;
8205 dgst_pos2 = 2;
8206 dgst_pos3 = 3;
8207 break;
8208
8209 case 900: hash_type = HASH_TYPE_MD4;
8210 salt_type = SALT_TYPE_NONE;
8211 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8212 opts_type = OPTS_TYPE_PT_GENERATE_LE
8213 | OPTS_TYPE_PT_ADD80
8214 | OPTS_TYPE_PT_ADDBITS14;
8215 kern_type = KERN_TYPE_MD4;
8216 dgst_size = DGST_SIZE_4_4;
8217 parse_func = md4_parse_hash;
8218 sort_by_digest = sort_by_digest_4_4;
8219 opti_type = OPTI_TYPE_ZERO_BYTE
8220 | OPTI_TYPE_PRECOMPUTE_INIT
8221 | OPTI_TYPE_PRECOMPUTE_MERKLE
8222 | OPTI_TYPE_MEET_IN_MIDDLE
8223 | OPTI_TYPE_EARLY_SKIP
8224 | OPTI_TYPE_NOT_ITERATED
8225 | OPTI_TYPE_NOT_SALTED
8226 | OPTI_TYPE_RAW_HASH;
8227 dgst_pos0 = 0;
8228 dgst_pos1 = 3;
8229 dgst_pos2 = 2;
8230 dgst_pos3 = 1;
8231 break;
8232
8233 case 1000: hash_type = HASH_TYPE_MD4;
8234 salt_type = SALT_TYPE_NONE;
8235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8236 opts_type = OPTS_TYPE_PT_GENERATE_LE
8237 | OPTS_TYPE_PT_ADD80
8238 | OPTS_TYPE_PT_ADDBITS14
8239 | OPTS_TYPE_PT_UNICODE;
8240 kern_type = KERN_TYPE_MD4_PWU;
8241 dgst_size = DGST_SIZE_4_4;
8242 parse_func = md4_parse_hash;
8243 sort_by_digest = sort_by_digest_4_4;
8244 opti_type = OPTI_TYPE_ZERO_BYTE
8245 | OPTI_TYPE_PRECOMPUTE_INIT
8246 | OPTI_TYPE_PRECOMPUTE_MERKLE
8247 | OPTI_TYPE_MEET_IN_MIDDLE
8248 | OPTI_TYPE_EARLY_SKIP
8249 | OPTI_TYPE_NOT_ITERATED
8250 | OPTI_TYPE_NOT_SALTED
8251 | OPTI_TYPE_RAW_HASH;
8252 dgst_pos0 = 0;
8253 dgst_pos1 = 3;
8254 dgst_pos2 = 2;
8255 dgst_pos3 = 1;
8256 break;
8257
8258 case 1100: hash_type = HASH_TYPE_MD4;
8259 salt_type = SALT_TYPE_INTERN;
8260 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8261 opts_type = OPTS_TYPE_PT_GENERATE_LE
8262 | OPTS_TYPE_PT_ADD80
8263 | OPTS_TYPE_PT_ADDBITS14
8264 | OPTS_TYPE_PT_UNICODE
8265 | OPTS_TYPE_ST_ADD80
8266 | OPTS_TYPE_ST_UNICODE
8267 | OPTS_TYPE_ST_LOWER;
8268 kern_type = KERN_TYPE_MD44_PWUSLT;
8269 dgst_size = DGST_SIZE_4_4;
8270 parse_func = dcc_parse_hash;
8271 sort_by_digest = sort_by_digest_4_4;
8272 opti_type = OPTI_TYPE_ZERO_BYTE
8273 | OPTI_TYPE_PRECOMPUTE_INIT
8274 | OPTI_TYPE_PRECOMPUTE_MERKLE
8275 | OPTI_TYPE_EARLY_SKIP
8276 | OPTI_TYPE_NOT_ITERATED;
8277 dgst_pos0 = 0;
8278 dgst_pos1 = 3;
8279 dgst_pos2 = 2;
8280 dgst_pos3 = 1;
8281 break;
8282
8283 case 1400: hash_type = HASH_TYPE_SHA256;
8284 salt_type = SALT_TYPE_NONE;
8285 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8286 opts_type = OPTS_TYPE_PT_GENERATE_BE
8287 | OPTS_TYPE_PT_ADD80
8288 | OPTS_TYPE_PT_ADDBITS15;
8289 kern_type = KERN_TYPE_SHA256;
8290 dgst_size = DGST_SIZE_4_8;
8291 parse_func = sha256_parse_hash;
8292 sort_by_digest = sort_by_digest_4_8;
8293 opti_type = OPTI_TYPE_ZERO_BYTE
8294 | OPTI_TYPE_PRECOMPUTE_INIT
8295 | OPTI_TYPE_PRECOMPUTE_MERKLE
8296 | OPTI_TYPE_EARLY_SKIP
8297 | OPTI_TYPE_NOT_ITERATED
8298 | OPTI_TYPE_NOT_SALTED
8299 | OPTI_TYPE_RAW_HASH;
8300 dgst_pos0 = 3;
8301 dgst_pos1 = 7;
8302 dgst_pos2 = 2;
8303 dgst_pos3 = 6;
8304 break;
8305
8306 case 1410: hash_type = HASH_TYPE_SHA256;
8307 salt_type = SALT_TYPE_INTERN;
8308 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8309 opts_type = OPTS_TYPE_PT_GENERATE_BE
8310 | OPTS_TYPE_ST_ADD80
8311 | OPTS_TYPE_ST_ADDBITS15;
8312 kern_type = KERN_TYPE_SHA256_PWSLT;
8313 dgst_size = DGST_SIZE_4_8;
8314 parse_func = sha256s_parse_hash;
8315 sort_by_digest = sort_by_digest_4_8;
8316 opti_type = OPTI_TYPE_ZERO_BYTE
8317 | OPTI_TYPE_PRECOMPUTE_INIT
8318 | OPTI_TYPE_PRECOMPUTE_MERKLE
8319 | OPTI_TYPE_EARLY_SKIP
8320 | OPTI_TYPE_NOT_ITERATED
8321 | OPTI_TYPE_APPENDED_SALT
8322 | OPTI_TYPE_RAW_HASH;
8323 dgst_pos0 = 3;
8324 dgst_pos1 = 7;
8325 dgst_pos2 = 2;
8326 dgst_pos3 = 6;
8327 break;
8328
8329 case 1420: hash_type = HASH_TYPE_SHA256;
8330 salt_type = SALT_TYPE_INTERN;
8331 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8332 opts_type = OPTS_TYPE_PT_GENERATE_BE
8333 | OPTS_TYPE_PT_ADD80
8334 | OPTS_TYPE_PT_ADDBITS15;
8335 kern_type = KERN_TYPE_SHA256_SLTPW;
8336 dgst_size = DGST_SIZE_4_8;
8337 parse_func = sha256s_parse_hash;
8338 sort_by_digest = sort_by_digest_4_8;
8339 opti_type = OPTI_TYPE_ZERO_BYTE
8340 | OPTI_TYPE_PRECOMPUTE_INIT
8341 | OPTI_TYPE_PRECOMPUTE_MERKLE
8342 | OPTI_TYPE_EARLY_SKIP
8343 | OPTI_TYPE_NOT_ITERATED
8344 | OPTI_TYPE_PREPENDED_SALT
8345 | OPTI_TYPE_RAW_HASH;
8346 dgst_pos0 = 3;
8347 dgst_pos1 = 7;
8348 dgst_pos2 = 2;
8349 dgst_pos3 = 6;
8350 break;
8351
8352 case 1421: hash_type = HASH_TYPE_SHA256;
8353 salt_type = SALT_TYPE_EMBEDDED;
8354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8355 opts_type = OPTS_TYPE_PT_GENERATE_BE
8356 | OPTS_TYPE_PT_ADD80
8357 | OPTS_TYPE_PT_ADDBITS15;
8358 kern_type = KERN_TYPE_SHA256_SLTPW;
8359 dgst_size = DGST_SIZE_4_8;
8360 parse_func = hmailserver_parse_hash;
8361 sort_by_digest = sort_by_digest_4_8;
8362 opti_type = OPTI_TYPE_ZERO_BYTE
8363 | OPTI_TYPE_PRECOMPUTE_INIT
8364 | OPTI_TYPE_PRECOMPUTE_MERKLE
8365 | OPTI_TYPE_EARLY_SKIP
8366 | OPTI_TYPE_NOT_ITERATED
8367 | OPTI_TYPE_PREPENDED_SALT
8368 | OPTI_TYPE_RAW_HASH;
8369 dgst_pos0 = 3;
8370 dgst_pos1 = 7;
8371 dgst_pos2 = 2;
8372 dgst_pos3 = 6;
8373 break;
8374
8375 case 1430: hash_type = HASH_TYPE_SHA256;
8376 salt_type = SALT_TYPE_INTERN;
8377 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8378 opts_type = OPTS_TYPE_PT_GENERATE_BE
8379 | OPTS_TYPE_PT_UNICODE
8380 | OPTS_TYPE_ST_ADD80
8381 | OPTS_TYPE_ST_ADDBITS15;
8382 kern_type = KERN_TYPE_SHA256_PWUSLT;
8383 dgst_size = DGST_SIZE_4_8;
8384 parse_func = sha256s_parse_hash;
8385 sort_by_digest = sort_by_digest_4_8;
8386 opti_type = OPTI_TYPE_ZERO_BYTE
8387 | OPTI_TYPE_PRECOMPUTE_INIT
8388 | OPTI_TYPE_PRECOMPUTE_MERKLE
8389 | OPTI_TYPE_EARLY_SKIP
8390 | OPTI_TYPE_NOT_ITERATED
8391 | OPTI_TYPE_APPENDED_SALT
8392 | OPTI_TYPE_RAW_HASH;
8393 dgst_pos0 = 3;
8394 dgst_pos1 = 7;
8395 dgst_pos2 = 2;
8396 dgst_pos3 = 6;
8397 break;
8398
8399 case 1440: hash_type = HASH_TYPE_SHA256;
8400 salt_type = SALT_TYPE_INTERN;
8401 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8402 opts_type = OPTS_TYPE_PT_GENERATE_BE
8403 | OPTS_TYPE_PT_ADD80
8404 | OPTS_TYPE_PT_ADDBITS15
8405 | OPTS_TYPE_PT_UNICODE;
8406 kern_type = KERN_TYPE_SHA256_SLTPWU;
8407 dgst_size = DGST_SIZE_4_8;
8408 parse_func = sha256s_parse_hash;
8409 sort_by_digest = sort_by_digest_4_8;
8410 opti_type = OPTI_TYPE_ZERO_BYTE
8411 | OPTI_TYPE_PRECOMPUTE_INIT
8412 | OPTI_TYPE_PRECOMPUTE_MERKLE
8413 | OPTI_TYPE_EARLY_SKIP
8414 | OPTI_TYPE_NOT_ITERATED
8415 | OPTI_TYPE_PREPENDED_SALT
8416 | OPTI_TYPE_RAW_HASH;
8417 dgst_pos0 = 3;
8418 dgst_pos1 = 7;
8419 dgst_pos2 = 2;
8420 dgst_pos3 = 6;
8421 break;
8422
8423 case 1441: hash_type = HASH_TYPE_SHA256;
8424 salt_type = SALT_TYPE_EMBEDDED;
8425 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8426 opts_type = OPTS_TYPE_PT_GENERATE_BE
8427 | OPTS_TYPE_PT_ADD80
8428 | OPTS_TYPE_PT_ADDBITS15
8429 | OPTS_TYPE_PT_UNICODE
8430 | OPTS_TYPE_ST_BASE64;
8431 kern_type = KERN_TYPE_SHA256_SLTPWU;
8432 dgst_size = DGST_SIZE_4_8;
8433 parse_func = episerver4_parse_hash;
8434 sort_by_digest = sort_by_digest_4_8;
8435 opti_type = OPTI_TYPE_ZERO_BYTE
8436 | OPTI_TYPE_PRECOMPUTE_INIT
8437 | OPTI_TYPE_PRECOMPUTE_MERKLE
8438 | OPTI_TYPE_EARLY_SKIP
8439 | OPTI_TYPE_NOT_ITERATED
8440 | OPTI_TYPE_PREPENDED_SALT
8441 | OPTI_TYPE_RAW_HASH;
8442 dgst_pos0 = 3;
8443 dgst_pos1 = 7;
8444 dgst_pos2 = 2;
8445 dgst_pos3 = 6;
8446 break;
8447
8448 case 1450: hash_type = HASH_TYPE_SHA256;
8449 salt_type = SALT_TYPE_INTERN;
8450 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8451 opts_type = OPTS_TYPE_PT_GENERATE_BE
8452 | OPTS_TYPE_ST_ADD80;
8453 kern_type = KERN_TYPE_HMACSHA256_PW;
8454 dgst_size = DGST_SIZE_4_8;
8455 parse_func = hmacsha256_parse_hash;
8456 sort_by_digest = sort_by_digest_4_8;
8457 opti_type = OPTI_TYPE_ZERO_BYTE
8458 | OPTI_TYPE_NOT_ITERATED;
8459 dgst_pos0 = 3;
8460 dgst_pos1 = 7;
8461 dgst_pos2 = 2;
8462 dgst_pos3 = 6;
8463 break;
8464
8465 case 1460: hash_type = HASH_TYPE_SHA256;
8466 salt_type = SALT_TYPE_INTERN;
8467 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8468 opts_type = OPTS_TYPE_PT_GENERATE_BE
8469 | OPTS_TYPE_PT_ADD80
8470 | OPTS_TYPE_PT_ADDBITS15;
8471 kern_type = KERN_TYPE_HMACSHA256_SLT;
8472 dgst_size = DGST_SIZE_4_8;
8473 parse_func = hmacsha256_parse_hash;
8474 sort_by_digest = sort_by_digest_4_8;
8475 opti_type = OPTI_TYPE_ZERO_BYTE
8476 | OPTI_TYPE_NOT_ITERATED;
8477 dgst_pos0 = 3;
8478 dgst_pos1 = 7;
8479 dgst_pos2 = 2;
8480 dgst_pos3 = 6;
8481 break;
8482
8483 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8484 salt_type = SALT_TYPE_EMBEDDED;
8485 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8486 opts_type = OPTS_TYPE_PT_GENERATE_LE
8487 | OPTS_TYPE_PT_BITSLICE;
8488 kern_type = KERN_TYPE_DESCRYPT;
8489 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8490 parse_func = descrypt_parse_hash;
8491 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8492 opti_type = OPTI_TYPE_ZERO_BYTE
8493 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8494 dgst_pos0 = 0;
8495 dgst_pos1 = 1;
8496 dgst_pos2 = 2;
8497 dgst_pos3 = 3;
8498 break;
8499
8500 case 1600: hash_type = HASH_TYPE_MD5;
8501 salt_type = SALT_TYPE_EMBEDDED;
8502 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8503 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8504 kern_type = KERN_TYPE_APR1CRYPT;
8505 dgst_size = DGST_SIZE_4_4;
8506 parse_func = md5apr1_parse_hash;
8507 sort_by_digest = sort_by_digest_4_4;
8508 opti_type = OPTI_TYPE_ZERO_BYTE;
8509 dgst_pos0 = 0;
8510 dgst_pos1 = 1;
8511 dgst_pos2 = 2;
8512 dgst_pos3 = 3;
8513 break;
8514
8515 case 1700: hash_type = HASH_TYPE_SHA512;
8516 salt_type = SALT_TYPE_NONE;
8517 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8518 opts_type = OPTS_TYPE_PT_GENERATE_BE
8519 | OPTS_TYPE_PT_ADD80
8520 | OPTS_TYPE_PT_ADDBITS15;
8521 kern_type = KERN_TYPE_SHA512;
8522 dgst_size = DGST_SIZE_8_8;
8523 parse_func = sha512_parse_hash;
8524 sort_by_digest = sort_by_digest_8_8;
8525 opti_type = OPTI_TYPE_ZERO_BYTE
8526 | OPTI_TYPE_PRECOMPUTE_INIT
8527 | OPTI_TYPE_PRECOMPUTE_MERKLE
8528 | OPTI_TYPE_EARLY_SKIP
8529 | OPTI_TYPE_NOT_ITERATED
8530 | OPTI_TYPE_NOT_SALTED
8531 | OPTI_TYPE_USES_BITS_64
8532 | OPTI_TYPE_RAW_HASH;
8533 dgst_pos0 = 14;
8534 dgst_pos1 = 15;
8535 dgst_pos2 = 6;
8536 dgst_pos3 = 7;
8537 break;
8538
8539 case 1710: hash_type = HASH_TYPE_SHA512;
8540 salt_type = SALT_TYPE_INTERN;
8541 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8542 opts_type = OPTS_TYPE_PT_GENERATE_BE
8543 | OPTS_TYPE_ST_ADD80
8544 | OPTS_TYPE_ST_ADDBITS15;
8545 kern_type = KERN_TYPE_SHA512_PWSLT;
8546 dgst_size = DGST_SIZE_8_8;
8547 parse_func = sha512s_parse_hash;
8548 sort_by_digest = sort_by_digest_8_8;
8549 opti_type = OPTI_TYPE_ZERO_BYTE
8550 | OPTI_TYPE_PRECOMPUTE_INIT
8551 | OPTI_TYPE_PRECOMPUTE_MERKLE
8552 | OPTI_TYPE_EARLY_SKIP
8553 | OPTI_TYPE_NOT_ITERATED
8554 | OPTI_TYPE_APPENDED_SALT
8555 | OPTI_TYPE_USES_BITS_64
8556 | OPTI_TYPE_RAW_HASH;
8557 dgst_pos0 = 14;
8558 dgst_pos1 = 15;
8559 dgst_pos2 = 6;
8560 dgst_pos3 = 7;
8561 break;
8562
8563 case 1711: hash_type = HASH_TYPE_SHA512;
8564 salt_type = SALT_TYPE_EMBEDDED;
8565 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8566 opts_type = OPTS_TYPE_PT_GENERATE_BE
8567 | OPTS_TYPE_ST_ADD80
8568 | OPTS_TYPE_ST_ADDBITS15;
8569 kern_type = KERN_TYPE_SHA512_PWSLT;
8570 dgst_size = DGST_SIZE_8_8;
8571 parse_func = sha512b64s_parse_hash;
8572 sort_by_digest = sort_by_digest_8_8;
8573 opti_type = OPTI_TYPE_ZERO_BYTE
8574 | OPTI_TYPE_PRECOMPUTE_INIT
8575 | OPTI_TYPE_PRECOMPUTE_MERKLE
8576 | OPTI_TYPE_EARLY_SKIP
8577 | OPTI_TYPE_NOT_ITERATED
8578 | OPTI_TYPE_APPENDED_SALT
8579 | OPTI_TYPE_USES_BITS_64
8580 | OPTI_TYPE_RAW_HASH;
8581 dgst_pos0 = 14;
8582 dgst_pos1 = 15;
8583 dgst_pos2 = 6;
8584 dgst_pos3 = 7;
8585 break;
8586
8587 case 1720: hash_type = HASH_TYPE_SHA512;
8588 salt_type = SALT_TYPE_INTERN;
8589 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8590 opts_type = OPTS_TYPE_PT_GENERATE_BE
8591 | OPTS_TYPE_PT_ADD80
8592 | OPTS_TYPE_PT_ADDBITS15;
8593 kern_type = KERN_TYPE_SHA512_SLTPW;
8594 dgst_size = DGST_SIZE_8_8;
8595 parse_func = sha512s_parse_hash;
8596 sort_by_digest = sort_by_digest_8_8;
8597 opti_type = OPTI_TYPE_ZERO_BYTE
8598 | OPTI_TYPE_PRECOMPUTE_INIT
8599 | OPTI_TYPE_PRECOMPUTE_MERKLE
8600 | OPTI_TYPE_EARLY_SKIP
8601 | OPTI_TYPE_NOT_ITERATED
8602 | OPTI_TYPE_PREPENDED_SALT
8603 | OPTI_TYPE_USES_BITS_64
8604 | OPTI_TYPE_RAW_HASH;
8605 dgst_pos0 = 14;
8606 dgst_pos1 = 15;
8607 dgst_pos2 = 6;
8608 dgst_pos3 = 7;
8609 break;
8610
8611 case 1722: hash_type = HASH_TYPE_SHA512;
8612 salt_type = SALT_TYPE_EMBEDDED;
8613 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8614 opts_type = OPTS_TYPE_PT_GENERATE_BE
8615 | OPTS_TYPE_PT_ADD80
8616 | OPTS_TYPE_PT_ADDBITS15
8617 | OPTS_TYPE_ST_HEX;
8618 kern_type = KERN_TYPE_SHA512_SLTPW;
8619 dgst_size = DGST_SIZE_8_8;
8620 parse_func = osx512_parse_hash;
8621 sort_by_digest = sort_by_digest_8_8;
8622 opti_type = OPTI_TYPE_ZERO_BYTE
8623 | OPTI_TYPE_PRECOMPUTE_INIT
8624 | OPTI_TYPE_PRECOMPUTE_MERKLE
8625 | OPTI_TYPE_EARLY_SKIP
8626 | OPTI_TYPE_NOT_ITERATED
8627 | OPTI_TYPE_PREPENDED_SALT
8628 | OPTI_TYPE_USES_BITS_64
8629 | OPTI_TYPE_RAW_HASH;
8630 dgst_pos0 = 14;
8631 dgst_pos1 = 15;
8632 dgst_pos2 = 6;
8633 dgst_pos3 = 7;
8634 break;
8635
8636 case 1730: hash_type = HASH_TYPE_SHA512;
8637 salt_type = SALT_TYPE_INTERN;
8638 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8639 opts_type = OPTS_TYPE_PT_GENERATE_BE
8640 | OPTS_TYPE_PT_UNICODE
8641 | OPTS_TYPE_ST_ADD80
8642 | OPTS_TYPE_ST_ADDBITS15;
8643 kern_type = KERN_TYPE_SHA512_PWSLTU;
8644 dgst_size = DGST_SIZE_8_8;
8645 parse_func = sha512s_parse_hash;
8646 sort_by_digest = sort_by_digest_8_8;
8647 opti_type = OPTI_TYPE_ZERO_BYTE
8648 | OPTI_TYPE_PRECOMPUTE_INIT
8649 | OPTI_TYPE_PRECOMPUTE_MERKLE
8650 | OPTI_TYPE_EARLY_SKIP
8651 | OPTI_TYPE_NOT_ITERATED
8652 | OPTI_TYPE_APPENDED_SALT
8653 | OPTI_TYPE_USES_BITS_64
8654 | OPTI_TYPE_RAW_HASH;
8655 dgst_pos0 = 14;
8656 dgst_pos1 = 15;
8657 dgst_pos2 = 6;
8658 dgst_pos3 = 7;
8659 break;
8660
8661 case 1731: hash_type = HASH_TYPE_SHA512;
8662 salt_type = SALT_TYPE_EMBEDDED;
8663 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8664 opts_type = OPTS_TYPE_PT_GENERATE_BE
8665 | OPTS_TYPE_PT_UNICODE
8666 | OPTS_TYPE_ST_ADD80
8667 | OPTS_TYPE_ST_ADDBITS15
8668 | OPTS_TYPE_ST_HEX;
8669 kern_type = KERN_TYPE_SHA512_PWSLTU;
8670 dgst_size = DGST_SIZE_8_8;
8671 parse_func = mssql2012_parse_hash;
8672 sort_by_digest = sort_by_digest_8_8;
8673 opti_type = OPTI_TYPE_ZERO_BYTE
8674 | OPTI_TYPE_PRECOMPUTE_INIT
8675 | OPTI_TYPE_PRECOMPUTE_MERKLE
8676 | OPTI_TYPE_EARLY_SKIP
8677 | OPTI_TYPE_NOT_ITERATED
8678 | OPTI_TYPE_APPENDED_SALT
8679 | OPTI_TYPE_USES_BITS_64
8680 | OPTI_TYPE_RAW_HASH;
8681 dgst_pos0 = 14;
8682 dgst_pos1 = 15;
8683 dgst_pos2 = 6;
8684 dgst_pos3 = 7;
8685 break;
8686
8687 case 1740: hash_type = HASH_TYPE_SHA512;
8688 salt_type = SALT_TYPE_INTERN;
8689 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8690 opts_type = OPTS_TYPE_PT_GENERATE_BE
8691 | OPTS_TYPE_PT_ADD80
8692 | OPTS_TYPE_PT_ADDBITS15
8693 | OPTS_TYPE_PT_UNICODE;
8694 kern_type = KERN_TYPE_SHA512_SLTPWU;
8695 dgst_size = DGST_SIZE_8_8;
8696 parse_func = sha512s_parse_hash;
8697 sort_by_digest = sort_by_digest_8_8;
8698 opti_type = OPTI_TYPE_ZERO_BYTE
8699 | OPTI_TYPE_PRECOMPUTE_INIT
8700 | OPTI_TYPE_PRECOMPUTE_MERKLE
8701 | OPTI_TYPE_EARLY_SKIP
8702 | OPTI_TYPE_NOT_ITERATED
8703 | OPTI_TYPE_PREPENDED_SALT
8704 | OPTI_TYPE_USES_BITS_64
8705 | OPTI_TYPE_RAW_HASH;
8706 dgst_pos0 = 14;
8707 dgst_pos1 = 15;
8708 dgst_pos2 = 6;
8709 dgst_pos3 = 7;
8710 break;
8711
8712 case 1750: hash_type = HASH_TYPE_SHA512;
8713 salt_type = SALT_TYPE_INTERN;
8714 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8715 opts_type = OPTS_TYPE_PT_GENERATE_BE
8716 | OPTS_TYPE_ST_ADD80;
8717 kern_type = KERN_TYPE_HMACSHA512_PW;
8718 dgst_size = DGST_SIZE_8_8;
8719 parse_func = hmacsha512_parse_hash;
8720 sort_by_digest = sort_by_digest_8_8;
8721 opti_type = OPTI_TYPE_ZERO_BYTE
8722 | OPTI_TYPE_USES_BITS_64
8723 | OPTI_TYPE_NOT_ITERATED;
8724 dgst_pos0 = 14;
8725 dgst_pos1 = 15;
8726 dgst_pos2 = 6;
8727 dgst_pos3 = 7;
8728 break;
8729
8730 case 1760: hash_type = HASH_TYPE_SHA512;
8731 salt_type = SALT_TYPE_INTERN;
8732 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8733 opts_type = OPTS_TYPE_PT_GENERATE_BE
8734 | OPTS_TYPE_PT_ADD80
8735 | OPTS_TYPE_PT_ADDBITS15;
8736 kern_type = KERN_TYPE_HMACSHA512_SLT;
8737 dgst_size = DGST_SIZE_8_8;
8738 parse_func = hmacsha512_parse_hash;
8739 sort_by_digest = sort_by_digest_8_8;
8740 opti_type = OPTI_TYPE_ZERO_BYTE
8741 | OPTI_TYPE_USES_BITS_64
8742 | OPTI_TYPE_NOT_ITERATED;
8743 dgst_pos0 = 14;
8744 dgst_pos1 = 15;
8745 dgst_pos2 = 6;
8746 dgst_pos3 = 7;
8747 break;
8748
8749 case 1800: hash_type = HASH_TYPE_SHA512;
8750 salt_type = SALT_TYPE_EMBEDDED;
8751 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8752 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8753 kern_type = KERN_TYPE_SHA512CRYPT;
8754 dgst_size = DGST_SIZE_8_8;
8755 parse_func = sha512crypt_parse_hash;
8756 sort_by_digest = sort_by_digest_8_8;
8757 opti_type = OPTI_TYPE_ZERO_BYTE
8758 | OPTI_TYPE_USES_BITS_64;
8759 dgst_pos0 = 0;
8760 dgst_pos1 = 1;
8761 dgst_pos2 = 2;
8762 dgst_pos3 = 3;
8763 break;
8764
8765 case 2000: hash_type = HASH_TYPE_STDOUT;
8766 salt_type = SALT_TYPE_NONE;
8767 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8768 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8769 kern_type = KERN_TYPE_STDOUT;
8770 dgst_size = DGST_SIZE_4_4;
8771 parse_func = NULL;
8772 sort_by_digest = NULL;
8773 opti_type = 0;
8774 dgst_pos0 = 0;
8775 dgst_pos1 = 0;
8776 dgst_pos2 = 0;
8777 dgst_pos3 = 0;
8778 break;
8779
8780 case 2100: hash_type = HASH_TYPE_DCC2;
8781 salt_type = SALT_TYPE_EMBEDDED;
8782 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8783 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8784 | OPTS_TYPE_ST_LOWER
8785 | OPTS_TYPE_ST_UNICODE;
8786 kern_type = KERN_TYPE_DCC2;
8787 dgst_size = DGST_SIZE_4_4;
8788 parse_func = dcc2_parse_hash;
8789 sort_by_digest = sort_by_digest_4_4;
8790 opti_type = OPTI_TYPE_ZERO_BYTE
8791 | OPTI_TYPE_SLOW_HASH_SIMD;
8792 dgst_pos0 = 0;
8793 dgst_pos1 = 1;
8794 dgst_pos2 = 2;
8795 dgst_pos3 = 3;
8796 break;
8797
8798 case 2400: hash_type = HASH_TYPE_MD5;
8799 salt_type = SALT_TYPE_NONE;
8800 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8801 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8802 kern_type = KERN_TYPE_MD5PIX;
8803 dgst_size = DGST_SIZE_4_4;
8804 parse_func = md5pix_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 | OPTI_TYPE_NOT_ITERATED
8811 | OPTI_TYPE_NOT_SALTED;
8812 dgst_pos0 = 0;
8813 dgst_pos1 = 3;
8814 dgst_pos2 = 2;
8815 dgst_pos3 = 1;
8816 break;
8817
8818 case 2410: hash_type = HASH_TYPE_MD5;
8819 salt_type = SALT_TYPE_INTERN;
8820 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8821 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8822 kern_type = KERN_TYPE_MD5ASA;
8823 dgst_size = DGST_SIZE_4_4;
8824 parse_func = md5asa_parse_hash;
8825 sort_by_digest = sort_by_digest_4_4;
8826 opti_type = OPTI_TYPE_ZERO_BYTE
8827 | OPTI_TYPE_PRECOMPUTE_INIT
8828 | OPTI_TYPE_PRECOMPUTE_MERKLE
8829 | OPTI_TYPE_EARLY_SKIP
8830 | OPTI_TYPE_NOT_ITERATED;
8831 dgst_pos0 = 0;
8832 dgst_pos1 = 3;
8833 dgst_pos2 = 2;
8834 dgst_pos3 = 1;
8835 break;
8836
8837 case 2500: hash_type = HASH_TYPE_WPA;
8838 salt_type = SALT_TYPE_EMBEDDED;
8839 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8840 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8841 kern_type = KERN_TYPE_WPA;
8842 dgst_size = DGST_SIZE_4_4;
8843 parse_func = wpa_parse_hash;
8844 sort_by_digest = sort_by_digest_4_4;
8845 opti_type = OPTI_TYPE_ZERO_BYTE
8846 | OPTI_TYPE_SLOW_HASH_SIMD;
8847 dgst_pos0 = 0;
8848 dgst_pos1 = 1;
8849 dgst_pos2 = 2;
8850 dgst_pos3 = 3;
8851 break;
8852
8853 case 2600: hash_type = HASH_TYPE_MD5;
8854 salt_type = SALT_TYPE_VIRTUAL;
8855 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8856 opts_type = OPTS_TYPE_PT_GENERATE_LE
8857 | OPTS_TYPE_PT_ADD80
8858 | OPTS_TYPE_PT_ADDBITS14
8859 | OPTS_TYPE_ST_ADD80;
8860 kern_type = KERN_TYPE_MD55_PWSLT1;
8861 dgst_size = DGST_SIZE_4_4;
8862 parse_func = md5md5_parse_hash;
8863 sort_by_digest = sort_by_digest_4_4;
8864 opti_type = OPTI_TYPE_ZERO_BYTE
8865 | OPTI_TYPE_PRECOMPUTE_INIT
8866 | OPTI_TYPE_PRECOMPUTE_MERKLE
8867 | OPTI_TYPE_EARLY_SKIP;
8868 dgst_pos0 = 0;
8869 dgst_pos1 = 3;
8870 dgst_pos2 = 2;
8871 dgst_pos3 = 1;
8872 break;
8873
8874 case 2611: hash_type = HASH_TYPE_MD5;
8875 salt_type = SALT_TYPE_INTERN;
8876 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8877 opts_type = OPTS_TYPE_PT_GENERATE_LE
8878 | OPTS_TYPE_PT_ADD80
8879 | OPTS_TYPE_PT_ADDBITS14
8880 | OPTS_TYPE_ST_ADD80;
8881 kern_type = KERN_TYPE_MD55_PWSLT1;
8882 dgst_size = DGST_SIZE_4_4;
8883 parse_func = vb3_parse_hash;
8884 sort_by_digest = sort_by_digest_4_4;
8885 opti_type = OPTI_TYPE_ZERO_BYTE
8886 | OPTI_TYPE_PRECOMPUTE_INIT
8887 | OPTI_TYPE_PRECOMPUTE_MERKLE
8888 | OPTI_TYPE_EARLY_SKIP;
8889 dgst_pos0 = 0;
8890 dgst_pos1 = 3;
8891 dgst_pos2 = 2;
8892 dgst_pos3 = 1;
8893 break;
8894
8895 case 2612: hash_type = HASH_TYPE_MD5;
8896 salt_type = SALT_TYPE_EMBEDDED;
8897 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8898 opts_type = OPTS_TYPE_PT_GENERATE_LE
8899 | OPTS_TYPE_PT_ADD80
8900 | OPTS_TYPE_PT_ADDBITS14
8901 | OPTS_TYPE_ST_ADD80
8902 | OPTS_TYPE_ST_HEX;
8903 kern_type = KERN_TYPE_MD55_PWSLT1;
8904 dgst_size = DGST_SIZE_4_4;
8905 parse_func = phps_parse_hash;
8906 sort_by_digest = sort_by_digest_4_4;
8907 opti_type = OPTI_TYPE_ZERO_BYTE
8908 | OPTI_TYPE_PRECOMPUTE_INIT
8909 | OPTI_TYPE_PRECOMPUTE_MERKLE
8910 | OPTI_TYPE_EARLY_SKIP;
8911 dgst_pos0 = 0;
8912 dgst_pos1 = 3;
8913 dgst_pos2 = 2;
8914 dgst_pos3 = 1;
8915 break;
8916
8917 case 2711: hash_type = HASH_TYPE_MD5;
8918 salt_type = SALT_TYPE_INTERN;
8919 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8920 opts_type = OPTS_TYPE_PT_GENERATE_LE
8921 | OPTS_TYPE_PT_ADD80
8922 | OPTS_TYPE_PT_ADDBITS14
8923 | OPTS_TYPE_ST_ADD80;
8924 kern_type = KERN_TYPE_MD55_PWSLT2;
8925 dgst_size = DGST_SIZE_4_4;
8926 parse_func = vb30_parse_hash;
8927 sort_by_digest = sort_by_digest_4_4;
8928 opti_type = OPTI_TYPE_ZERO_BYTE
8929 | OPTI_TYPE_PRECOMPUTE_INIT
8930 | OPTI_TYPE_EARLY_SKIP;
8931 dgst_pos0 = 0;
8932 dgst_pos1 = 3;
8933 dgst_pos2 = 2;
8934 dgst_pos3 = 1;
8935 break;
8936
8937 case 2811: hash_type = HASH_TYPE_MD5;
8938 salt_type = SALT_TYPE_INTERN;
8939 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8940 opts_type = OPTS_TYPE_PT_GENERATE_LE
8941 | OPTS_TYPE_PT_ADD80
8942 | OPTS_TYPE_PT_ADDBITS14;
8943 kern_type = KERN_TYPE_MD55_SLTPW;
8944 dgst_size = DGST_SIZE_4_4;
8945 parse_func = ipb2_parse_hash;
8946 sort_by_digest = sort_by_digest_4_4;
8947 opti_type = OPTI_TYPE_ZERO_BYTE
8948 | OPTI_TYPE_PRECOMPUTE_INIT
8949 | OPTI_TYPE_EARLY_SKIP;
8950 dgst_pos0 = 0;
8951 dgst_pos1 = 3;
8952 dgst_pos2 = 2;
8953 dgst_pos3 = 1;
8954 break;
8955
8956 case 3000: hash_type = HASH_TYPE_LM;
8957 salt_type = SALT_TYPE_NONE;
8958 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8959 opts_type = OPTS_TYPE_PT_GENERATE_LE
8960 | OPTS_TYPE_PT_UPPER
8961 | OPTS_TYPE_PT_BITSLICE;
8962 kern_type = KERN_TYPE_LM;
8963 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8964 parse_func = lm_parse_hash;
8965 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8966 opti_type = OPTI_TYPE_ZERO_BYTE
8967 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8968 dgst_pos0 = 0;
8969 dgst_pos1 = 1;
8970 dgst_pos2 = 2;
8971 dgst_pos3 = 3;
8972 break;
8973
8974 case 3100: hash_type = HASH_TYPE_ORACLEH;
8975 salt_type = SALT_TYPE_INTERN;
8976 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8977 opts_type = OPTS_TYPE_PT_GENERATE_LE
8978 | OPTS_TYPE_PT_UPPER
8979 | OPTS_TYPE_ST_UPPER;
8980 kern_type = KERN_TYPE_ORACLEH;
8981 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8982 parse_func = oracleh_parse_hash;
8983 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8984 opti_type = OPTI_TYPE_ZERO_BYTE;
8985 dgst_pos0 = 0;
8986 dgst_pos1 = 1;
8987 dgst_pos2 = 2;
8988 dgst_pos3 = 3;
8989 break;
8990
8991 case 3200: hash_type = HASH_TYPE_BCRYPT;
8992 salt_type = SALT_TYPE_EMBEDDED;
8993 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8994 opts_type = OPTS_TYPE_PT_GENERATE_LE
8995 | OPTS_TYPE_ST_GENERATE_LE;
8996 kern_type = KERN_TYPE_BCRYPT;
8997 dgst_size = DGST_SIZE_4_6;
8998 parse_func = bcrypt_parse_hash;
8999 sort_by_digest = sort_by_digest_4_6;
9000 opti_type = OPTI_TYPE_ZERO_BYTE;
9001 dgst_pos0 = 0;
9002 dgst_pos1 = 1;
9003 dgst_pos2 = 2;
9004 dgst_pos3 = 3;
9005 break;
9006
9007 case 3710: hash_type = HASH_TYPE_MD5;
9008 salt_type = SALT_TYPE_INTERN;
9009 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9010 opts_type = OPTS_TYPE_PT_GENERATE_LE
9011 | OPTS_TYPE_PT_ADD80
9012 | OPTS_TYPE_PT_ADDBITS14;
9013 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9014 dgst_size = DGST_SIZE_4_4;
9015 parse_func = md5s_parse_hash;
9016 sort_by_digest = sort_by_digest_4_4;
9017 opti_type = OPTI_TYPE_ZERO_BYTE
9018 | OPTI_TYPE_PRECOMPUTE_INIT
9019 | OPTI_TYPE_PRECOMPUTE_MERKLE
9020 | OPTI_TYPE_EARLY_SKIP;
9021 dgst_pos0 = 0;
9022 dgst_pos1 = 3;
9023 dgst_pos2 = 2;
9024 dgst_pos3 = 1;
9025 break;
9026
9027 case 3711: hash_type = HASH_TYPE_MD5;
9028 salt_type = SALT_TYPE_EMBEDDED;
9029 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9030 opts_type = OPTS_TYPE_PT_GENERATE_LE
9031 | OPTS_TYPE_PT_ADD80
9032 | OPTS_TYPE_PT_ADDBITS14;
9033 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9034 dgst_size = DGST_SIZE_4_4;
9035 parse_func = mediawiki_b_parse_hash;
9036 sort_by_digest = sort_by_digest_4_4;
9037 opti_type = OPTI_TYPE_ZERO_BYTE
9038 | OPTI_TYPE_PRECOMPUTE_INIT
9039 | OPTI_TYPE_PRECOMPUTE_MERKLE
9040 | OPTI_TYPE_EARLY_SKIP;
9041 dgst_pos0 = 0;
9042 dgst_pos1 = 3;
9043 dgst_pos2 = 2;
9044 dgst_pos3 = 1;
9045 break;
9046
9047 case 3800: hash_type = HASH_TYPE_MD5;
9048 salt_type = SALT_TYPE_INTERN;
9049 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9050 opts_type = OPTS_TYPE_PT_GENERATE_LE
9051 | OPTS_TYPE_ST_ADDBITS14;
9052 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
9053 dgst_size = DGST_SIZE_4_4;
9054 parse_func = md5s_parse_hash;
9055 sort_by_digest = sort_by_digest_4_4;
9056 opti_type = OPTI_TYPE_ZERO_BYTE
9057 | OPTI_TYPE_PRECOMPUTE_INIT
9058 | OPTI_TYPE_PRECOMPUTE_MERKLE
9059 | OPTI_TYPE_EARLY_SKIP
9060 | OPTI_TYPE_NOT_ITERATED
9061 | OPTI_TYPE_RAW_HASH;
9062 dgst_pos0 = 0;
9063 dgst_pos1 = 3;
9064 dgst_pos2 = 2;
9065 dgst_pos3 = 1;
9066 break;
9067
9068 case 4300: hash_type = HASH_TYPE_MD5;
9069 salt_type = SALT_TYPE_VIRTUAL;
9070 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9071 opts_type = OPTS_TYPE_PT_GENERATE_LE
9072 | OPTS_TYPE_PT_ADD80
9073 | OPTS_TYPE_PT_ADDBITS14
9074 | OPTS_TYPE_ST_ADD80;
9075 kern_type = KERN_TYPE_MD5U5_PWSLT1;
9076 dgst_size = DGST_SIZE_4_4;
9077 parse_func = md5md5_parse_hash;
9078 sort_by_digest = sort_by_digest_4_4;
9079 opti_type = OPTI_TYPE_ZERO_BYTE
9080 | OPTI_TYPE_PRECOMPUTE_INIT
9081 | OPTI_TYPE_PRECOMPUTE_MERKLE
9082 | OPTI_TYPE_EARLY_SKIP;
9083 dgst_pos0 = 0;
9084 dgst_pos1 = 3;
9085 dgst_pos2 = 2;
9086 dgst_pos3 = 1;
9087 break;
9088
9089
9090 case 4400: hash_type = HASH_TYPE_MD5;
9091 salt_type = SALT_TYPE_NONE;
9092 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9093 opts_type = OPTS_TYPE_PT_GENERATE_BE
9094 | OPTS_TYPE_PT_ADD80
9095 | OPTS_TYPE_PT_ADDBITS15;
9096 kern_type = KERN_TYPE_MD5_SHA1;
9097 dgst_size = DGST_SIZE_4_4;
9098 parse_func = md5_parse_hash;
9099 sort_by_digest = sort_by_digest_4_4;
9100 opti_type = OPTI_TYPE_ZERO_BYTE
9101 | OPTI_TYPE_PRECOMPUTE_INIT
9102 | OPTI_TYPE_PRECOMPUTE_MERKLE
9103 | OPTI_TYPE_EARLY_SKIP
9104 | OPTI_TYPE_NOT_ITERATED
9105 | OPTI_TYPE_NOT_SALTED
9106 | OPTI_TYPE_RAW_HASH;
9107 dgst_pos0 = 0;
9108 dgst_pos1 = 3;
9109 dgst_pos2 = 2;
9110 dgst_pos3 = 1;
9111 break;
9112
9113 case 4500: hash_type = HASH_TYPE_SHA1;
9114 salt_type = SALT_TYPE_NONE;
9115 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9116 opts_type = OPTS_TYPE_PT_GENERATE_BE
9117 | OPTS_TYPE_PT_ADD80
9118 | OPTS_TYPE_PT_ADDBITS15;
9119 kern_type = KERN_TYPE_SHA11;
9120 dgst_size = DGST_SIZE_4_5;
9121 parse_func = sha1_parse_hash;
9122 sort_by_digest = sort_by_digest_4_5;
9123 opti_type = OPTI_TYPE_ZERO_BYTE
9124 | OPTI_TYPE_PRECOMPUTE_INIT
9125 | OPTI_TYPE_PRECOMPUTE_MERKLE
9126 | OPTI_TYPE_EARLY_SKIP
9127 | OPTI_TYPE_NOT_SALTED;
9128 dgst_pos0 = 3;
9129 dgst_pos1 = 4;
9130 dgst_pos2 = 2;
9131 dgst_pos3 = 1;
9132 break;
9133
9134 case 4700: hash_type = HASH_TYPE_SHA1;
9135 salt_type = SALT_TYPE_NONE;
9136 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9137 opts_type = OPTS_TYPE_PT_GENERATE_LE
9138 | OPTS_TYPE_PT_ADD80
9139 | OPTS_TYPE_PT_ADDBITS14;
9140 kern_type = KERN_TYPE_SHA1_MD5;
9141 dgst_size = DGST_SIZE_4_5;
9142 parse_func = sha1_parse_hash;
9143 sort_by_digest = sort_by_digest_4_5;
9144 opti_type = OPTI_TYPE_ZERO_BYTE
9145 | OPTI_TYPE_PRECOMPUTE_INIT
9146 | OPTI_TYPE_PRECOMPUTE_MERKLE
9147 | OPTI_TYPE_EARLY_SKIP
9148 | OPTI_TYPE_NOT_ITERATED
9149 | OPTI_TYPE_NOT_SALTED
9150 | OPTI_TYPE_RAW_HASH;
9151 dgst_pos0 = 3;
9152 dgst_pos1 = 4;
9153 dgst_pos2 = 2;
9154 dgst_pos3 = 1;
9155 break;
9156
9157 case 4800: hash_type = HASH_TYPE_MD5;
9158 salt_type = SALT_TYPE_EMBEDDED;
9159 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9160 opts_type = OPTS_TYPE_PT_GENERATE_LE
9161 | OPTS_TYPE_PT_ADDBITS14;
9162 kern_type = KERN_TYPE_MD5_CHAP;
9163 dgst_size = DGST_SIZE_4_4;
9164 parse_func = chap_parse_hash;
9165 sort_by_digest = sort_by_digest_4_4;
9166 opti_type = OPTI_TYPE_ZERO_BYTE
9167 | OPTI_TYPE_PRECOMPUTE_INIT
9168 | OPTI_TYPE_PRECOMPUTE_MERKLE
9169 | OPTI_TYPE_MEET_IN_MIDDLE
9170 | OPTI_TYPE_EARLY_SKIP
9171 | OPTI_TYPE_NOT_ITERATED
9172 | OPTI_TYPE_RAW_HASH;
9173 dgst_pos0 = 0;
9174 dgst_pos1 = 3;
9175 dgst_pos2 = 2;
9176 dgst_pos3 = 1;
9177 break;
9178
9179 case 4900: hash_type = HASH_TYPE_SHA1;
9180 salt_type = SALT_TYPE_INTERN;
9181 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9182 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9183 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9184 dgst_size = DGST_SIZE_4_5;
9185 parse_func = sha1s_parse_hash;
9186 sort_by_digest = sort_by_digest_4_5;
9187 opti_type = OPTI_TYPE_ZERO_BYTE
9188 | OPTI_TYPE_PRECOMPUTE_INIT
9189 | OPTI_TYPE_PRECOMPUTE_MERKLE
9190 | OPTI_TYPE_EARLY_SKIP;
9191 dgst_pos0 = 3;
9192 dgst_pos1 = 4;
9193 dgst_pos2 = 2;
9194 dgst_pos3 = 1;
9195 break;
9196
9197 case 5000: hash_type = HASH_TYPE_KECCAK;
9198 salt_type = SALT_TYPE_EMBEDDED;
9199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9200 opts_type = OPTS_TYPE_PT_GENERATE_LE
9201 | OPTS_TYPE_PT_ADD01;
9202 kern_type = KERN_TYPE_KECCAK;
9203 dgst_size = DGST_SIZE_8_25;
9204 parse_func = keccak_parse_hash;
9205 sort_by_digest = sort_by_digest_8_25;
9206 opti_type = OPTI_TYPE_ZERO_BYTE
9207 | OPTI_TYPE_USES_BITS_64
9208 | OPTI_TYPE_RAW_HASH;
9209 dgst_pos0 = 2;
9210 dgst_pos1 = 3;
9211 dgst_pos2 = 4;
9212 dgst_pos3 = 5;
9213 break;
9214
9215 case 5100: hash_type = HASH_TYPE_MD5H;
9216 salt_type = SALT_TYPE_NONE;
9217 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9218 opts_type = OPTS_TYPE_PT_GENERATE_LE
9219 | OPTS_TYPE_PT_ADD80
9220 | OPTS_TYPE_PT_ADDBITS14;
9221 kern_type = KERN_TYPE_MD5H;
9222 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9223 parse_func = md5half_parse_hash;
9224 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9225 opti_type = OPTI_TYPE_ZERO_BYTE
9226 | OPTI_TYPE_RAW_HASH;
9227 dgst_pos0 = 0;
9228 dgst_pos1 = 1;
9229 dgst_pos2 = 2;
9230 dgst_pos3 = 3;
9231 break;
9232
9233 case 5200: hash_type = HASH_TYPE_SHA256;
9234 salt_type = SALT_TYPE_EMBEDDED;
9235 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9236 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9237 kern_type = KERN_TYPE_PSAFE3;
9238 dgst_size = DGST_SIZE_4_8;
9239 parse_func = psafe3_parse_hash;
9240 sort_by_digest = sort_by_digest_4_8;
9241 opti_type = OPTI_TYPE_ZERO_BYTE;
9242 dgst_pos0 = 0;
9243 dgst_pos1 = 1;
9244 dgst_pos2 = 2;
9245 dgst_pos3 = 3;
9246 break;
9247
9248 case 5300: hash_type = HASH_TYPE_MD5;
9249 salt_type = SALT_TYPE_EMBEDDED;
9250 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9251 opts_type = OPTS_TYPE_PT_GENERATE_LE
9252 | OPTS_TYPE_ST_ADD80;
9253 kern_type = KERN_TYPE_IKEPSK_MD5;
9254 dgst_size = DGST_SIZE_4_4;
9255 parse_func = ikepsk_md5_parse_hash;
9256 sort_by_digest = sort_by_digest_4_4;
9257 opti_type = OPTI_TYPE_ZERO_BYTE;
9258 dgst_pos0 = 0;
9259 dgst_pos1 = 3;
9260 dgst_pos2 = 2;
9261 dgst_pos3 = 1;
9262 break;
9263
9264 case 5400: hash_type = HASH_TYPE_SHA1;
9265 salt_type = SALT_TYPE_EMBEDDED;
9266 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9267 opts_type = OPTS_TYPE_PT_GENERATE_BE
9268 | OPTS_TYPE_ST_ADD80;
9269 kern_type = KERN_TYPE_IKEPSK_SHA1;
9270 dgst_size = DGST_SIZE_4_5;
9271 parse_func = ikepsk_sha1_parse_hash;
9272 sort_by_digest = sort_by_digest_4_5;
9273 opti_type = OPTI_TYPE_ZERO_BYTE;
9274 dgst_pos0 = 3;
9275 dgst_pos1 = 4;
9276 dgst_pos2 = 2;
9277 dgst_pos3 = 1;
9278 break;
9279
9280 case 5500: hash_type = HASH_TYPE_NETNTLM;
9281 salt_type = SALT_TYPE_EMBEDDED;
9282 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9283 opts_type = OPTS_TYPE_PT_GENERATE_LE
9284 | OPTS_TYPE_PT_ADD80
9285 | OPTS_TYPE_PT_ADDBITS14
9286 | OPTS_TYPE_PT_UNICODE
9287 | OPTS_TYPE_ST_HEX;
9288 kern_type = KERN_TYPE_NETNTLMv1;
9289 dgst_size = DGST_SIZE_4_4;
9290 parse_func = netntlmv1_parse_hash;
9291 sort_by_digest = sort_by_digest_4_4;
9292 opti_type = OPTI_TYPE_ZERO_BYTE
9293 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9294 dgst_pos0 = 0;
9295 dgst_pos1 = 1;
9296 dgst_pos2 = 2;
9297 dgst_pos3 = 3;
9298 break;
9299
9300 case 5600: hash_type = HASH_TYPE_MD5;
9301 salt_type = SALT_TYPE_EMBEDDED;
9302 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9303 opts_type = OPTS_TYPE_PT_GENERATE_LE
9304 | OPTS_TYPE_PT_ADD80
9305 | OPTS_TYPE_PT_ADDBITS14
9306 | OPTS_TYPE_PT_UNICODE;
9307 kern_type = KERN_TYPE_NETNTLMv2;
9308 dgst_size = DGST_SIZE_4_4;
9309 parse_func = netntlmv2_parse_hash;
9310 sort_by_digest = sort_by_digest_4_4;
9311 opti_type = OPTI_TYPE_ZERO_BYTE;
9312 dgst_pos0 = 0;
9313 dgst_pos1 = 3;
9314 dgst_pos2 = 2;
9315 dgst_pos3 = 1;
9316 break;
9317
9318 case 5700: hash_type = HASH_TYPE_SHA256;
9319 salt_type = SALT_TYPE_NONE;
9320 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9321 opts_type = OPTS_TYPE_PT_GENERATE_BE
9322 | OPTS_TYPE_PT_ADD80
9323 | OPTS_TYPE_PT_ADDBITS15;
9324 kern_type = KERN_TYPE_SHA256;
9325 dgst_size = DGST_SIZE_4_8;
9326 parse_func = cisco4_parse_hash;
9327 sort_by_digest = sort_by_digest_4_8;
9328 opti_type = OPTI_TYPE_ZERO_BYTE
9329 | OPTI_TYPE_PRECOMPUTE_INIT
9330 | OPTI_TYPE_PRECOMPUTE_MERKLE
9331 | OPTI_TYPE_EARLY_SKIP
9332 | OPTI_TYPE_NOT_ITERATED
9333 | OPTI_TYPE_NOT_SALTED
9334 | OPTI_TYPE_RAW_HASH;
9335 dgst_pos0 = 3;
9336 dgst_pos1 = 7;
9337 dgst_pos2 = 2;
9338 dgst_pos3 = 6;
9339 break;
9340
9341 case 5800: hash_type = HASH_TYPE_SHA1;
9342 salt_type = SALT_TYPE_INTERN;
9343 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9344 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9345 | OPTS_TYPE_ST_ADD80;
9346 kern_type = KERN_TYPE_ANDROIDPIN;
9347 dgst_size = DGST_SIZE_4_5;
9348 parse_func = androidpin_parse_hash;
9349 sort_by_digest = sort_by_digest_4_5;
9350 opti_type = OPTI_TYPE_ZERO_BYTE;
9351 dgst_pos0 = 0;
9352 dgst_pos1 = 1;
9353 dgst_pos2 = 2;
9354 dgst_pos3 = 3;
9355 break;
9356
9357 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9358 salt_type = SALT_TYPE_NONE;
9359 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9360 opts_type = OPTS_TYPE_PT_GENERATE_LE
9361 | OPTS_TYPE_PT_ADD80;
9362 kern_type = KERN_TYPE_RIPEMD160;
9363 dgst_size = DGST_SIZE_4_5;
9364 parse_func = ripemd160_parse_hash;
9365 sort_by_digest = sort_by_digest_4_5;
9366 opti_type = OPTI_TYPE_ZERO_BYTE;
9367 dgst_pos0 = 0;
9368 dgst_pos1 = 1;
9369 dgst_pos2 = 2;
9370 dgst_pos3 = 3;
9371 break;
9372
9373 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9374 salt_type = SALT_TYPE_NONE;
9375 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9376 opts_type = OPTS_TYPE_PT_GENERATE_BE
9377 | OPTS_TYPE_PT_ADD80;
9378 kern_type = KERN_TYPE_WHIRLPOOL;
9379 dgst_size = DGST_SIZE_4_16;
9380 parse_func = whirlpool_parse_hash;
9381 sort_by_digest = sort_by_digest_4_16;
9382 opti_type = OPTI_TYPE_ZERO_BYTE;
9383 dgst_pos0 = 0;
9384 dgst_pos1 = 1;
9385 dgst_pos2 = 2;
9386 dgst_pos3 = 3;
9387 break;
9388
9389 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9390 salt_type = SALT_TYPE_EMBEDDED;
9391 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9392 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9393 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9394 dgst_size = DGST_SIZE_4_5;
9395 parse_func = truecrypt_parse_hash_2k;
9396 sort_by_digest = sort_by_digest_4_5;
9397 opti_type = OPTI_TYPE_ZERO_BYTE;
9398 dgst_pos0 = 0;
9399 dgst_pos1 = 1;
9400 dgst_pos2 = 2;
9401 dgst_pos3 = 3;
9402 break;
9403
9404 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9405 salt_type = SALT_TYPE_EMBEDDED;
9406 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9407 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9408 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9409 dgst_size = DGST_SIZE_4_5;
9410 parse_func = truecrypt_parse_hash_2k;
9411 sort_by_digest = sort_by_digest_4_5;
9412 opti_type = OPTI_TYPE_ZERO_BYTE;
9413 dgst_pos0 = 0;
9414 dgst_pos1 = 1;
9415 dgst_pos2 = 2;
9416 dgst_pos3 = 3;
9417 break;
9418
9419 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9420 salt_type = SALT_TYPE_EMBEDDED;
9421 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9422 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9423 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9424 dgst_size = DGST_SIZE_4_5;
9425 parse_func = truecrypt_parse_hash_2k;
9426 sort_by_digest = sort_by_digest_4_5;
9427 opti_type = OPTI_TYPE_ZERO_BYTE;
9428 dgst_pos0 = 0;
9429 dgst_pos1 = 1;
9430 dgst_pos2 = 2;
9431 dgst_pos3 = 3;
9432 break;
9433
9434 case 6221: hash_type = HASH_TYPE_SHA512;
9435 salt_type = SALT_TYPE_EMBEDDED;
9436 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9437 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9438 kern_type = KERN_TYPE_TCSHA512_XTS512;
9439 dgst_size = DGST_SIZE_8_8;
9440 parse_func = truecrypt_parse_hash_1k;
9441 sort_by_digest = sort_by_digest_8_8;
9442 opti_type = OPTI_TYPE_ZERO_BYTE
9443 | OPTI_TYPE_USES_BITS_64;
9444 dgst_pos0 = 0;
9445 dgst_pos1 = 1;
9446 dgst_pos2 = 2;
9447 dgst_pos3 = 3;
9448 break;
9449
9450 case 6222: hash_type = HASH_TYPE_SHA512;
9451 salt_type = SALT_TYPE_EMBEDDED;
9452 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9453 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9454 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9455 dgst_size = DGST_SIZE_8_8;
9456 parse_func = truecrypt_parse_hash_1k;
9457 sort_by_digest = sort_by_digest_8_8;
9458 opti_type = OPTI_TYPE_ZERO_BYTE
9459 | OPTI_TYPE_USES_BITS_64;
9460 dgst_pos0 = 0;
9461 dgst_pos1 = 1;
9462 dgst_pos2 = 2;
9463 dgst_pos3 = 3;
9464 break;
9465
9466 case 6223: hash_type = HASH_TYPE_SHA512;
9467 salt_type = SALT_TYPE_EMBEDDED;
9468 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9469 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9470 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9471 dgst_size = DGST_SIZE_8_8;
9472 parse_func = truecrypt_parse_hash_1k;
9473 sort_by_digest = sort_by_digest_8_8;
9474 opti_type = OPTI_TYPE_ZERO_BYTE
9475 | OPTI_TYPE_USES_BITS_64;
9476 dgst_pos0 = 0;
9477 dgst_pos1 = 1;
9478 dgst_pos2 = 2;
9479 dgst_pos3 = 3;
9480 break;
9481
9482 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9483 salt_type = SALT_TYPE_EMBEDDED;
9484 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9485 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9486 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9487 dgst_size = DGST_SIZE_4_8;
9488 parse_func = truecrypt_parse_hash_1k;
9489 sort_by_digest = sort_by_digest_4_8;
9490 opti_type = OPTI_TYPE_ZERO_BYTE;
9491 dgst_pos0 = 0;
9492 dgst_pos1 = 1;
9493 dgst_pos2 = 2;
9494 dgst_pos3 = 3;
9495 break;
9496
9497 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9498 salt_type = SALT_TYPE_EMBEDDED;
9499 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9500 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9501 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9502 dgst_size = DGST_SIZE_4_8;
9503 parse_func = truecrypt_parse_hash_1k;
9504 sort_by_digest = sort_by_digest_4_8;
9505 opti_type = OPTI_TYPE_ZERO_BYTE;
9506 dgst_pos0 = 0;
9507 dgst_pos1 = 1;
9508 dgst_pos2 = 2;
9509 dgst_pos3 = 3;
9510 break;
9511
9512 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9513 salt_type = SALT_TYPE_EMBEDDED;
9514 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9515 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9516 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9517 dgst_size = DGST_SIZE_4_8;
9518 parse_func = truecrypt_parse_hash_1k;
9519 sort_by_digest = sort_by_digest_4_8;
9520 opti_type = OPTI_TYPE_ZERO_BYTE;
9521 dgst_pos0 = 0;
9522 dgst_pos1 = 1;
9523 dgst_pos2 = 2;
9524 dgst_pos3 = 3;
9525 break;
9526
9527 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9528 salt_type = SALT_TYPE_EMBEDDED;
9529 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9530 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9531 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9532 dgst_size = DGST_SIZE_4_5;
9533 parse_func = truecrypt_parse_hash_1k;
9534 sort_by_digest = sort_by_digest_4_5;
9535 opti_type = OPTI_TYPE_ZERO_BYTE;
9536 dgst_pos0 = 0;
9537 dgst_pos1 = 1;
9538 dgst_pos2 = 2;
9539 dgst_pos3 = 3;
9540 break;
9541
9542 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9543 salt_type = SALT_TYPE_EMBEDDED;
9544 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9545 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9546 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9547 dgst_size = DGST_SIZE_4_5;
9548 parse_func = truecrypt_parse_hash_1k;
9549 sort_by_digest = sort_by_digest_4_5;
9550 opti_type = OPTI_TYPE_ZERO_BYTE;
9551 dgst_pos0 = 0;
9552 dgst_pos1 = 1;
9553 dgst_pos2 = 2;
9554 dgst_pos3 = 3;
9555 break;
9556
9557 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9558 salt_type = SALT_TYPE_EMBEDDED;
9559 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9560 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9561 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9562 dgst_size = DGST_SIZE_4_5;
9563 parse_func = truecrypt_parse_hash_1k;
9564 sort_by_digest = sort_by_digest_4_5;
9565 opti_type = OPTI_TYPE_ZERO_BYTE;
9566 dgst_pos0 = 0;
9567 dgst_pos1 = 1;
9568 dgst_pos2 = 2;
9569 dgst_pos3 = 3;
9570 break;
9571
9572 case 6300: hash_type = HASH_TYPE_MD5;
9573 salt_type = SALT_TYPE_EMBEDDED;
9574 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9575 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9576 kern_type = KERN_TYPE_MD5AIX;
9577 dgst_size = DGST_SIZE_4_4;
9578 parse_func = md5aix_parse_hash;
9579 sort_by_digest = sort_by_digest_4_4;
9580 opti_type = OPTI_TYPE_ZERO_BYTE;
9581 dgst_pos0 = 0;
9582 dgst_pos1 = 1;
9583 dgst_pos2 = 2;
9584 dgst_pos3 = 3;
9585 break;
9586
9587 case 6400: hash_type = HASH_TYPE_SHA256;
9588 salt_type = SALT_TYPE_EMBEDDED;
9589 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9590 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9591 kern_type = KERN_TYPE_SHA256AIX;
9592 dgst_size = DGST_SIZE_4_8;
9593 parse_func = sha256aix_parse_hash;
9594 sort_by_digest = sort_by_digest_4_8;
9595 opti_type = OPTI_TYPE_ZERO_BYTE;
9596 dgst_pos0 = 0;
9597 dgst_pos1 = 1;
9598 dgst_pos2 = 2;
9599 dgst_pos3 = 3;
9600 break;
9601
9602 case 6500: hash_type = HASH_TYPE_SHA512;
9603 salt_type = SALT_TYPE_EMBEDDED;
9604 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9605 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9606 kern_type = KERN_TYPE_SHA512AIX;
9607 dgst_size = DGST_SIZE_8_8;
9608 parse_func = sha512aix_parse_hash;
9609 sort_by_digest = sort_by_digest_8_8;
9610 opti_type = OPTI_TYPE_ZERO_BYTE
9611 | OPTI_TYPE_USES_BITS_64;
9612 dgst_pos0 = 0;
9613 dgst_pos1 = 1;
9614 dgst_pos2 = 2;
9615 dgst_pos3 = 3;
9616 break;
9617
9618 case 6600: hash_type = HASH_TYPE_AES;
9619 salt_type = SALT_TYPE_EMBEDDED;
9620 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9621 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9622 kern_type = KERN_TYPE_AGILEKEY;
9623 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9624 parse_func = agilekey_parse_hash;
9625 sort_by_digest = sort_by_digest_4_5;
9626 opti_type = OPTI_TYPE_ZERO_BYTE;
9627 dgst_pos0 = 0;
9628 dgst_pos1 = 1;
9629 dgst_pos2 = 2;
9630 dgst_pos3 = 3;
9631 break;
9632
9633 case 6700: hash_type = HASH_TYPE_SHA1;
9634 salt_type = SALT_TYPE_EMBEDDED;
9635 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9636 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9637 kern_type = KERN_TYPE_SHA1AIX;
9638 dgst_size = DGST_SIZE_4_5;
9639 parse_func = sha1aix_parse_hash;
9640 sort_by_digest = sort_by_digest_4_5;
9641 opti_type = OPTI_TYPE_ZERO_BYTE;
9642 dgst_pos0 = 0;
9643 dgst_pos1 = 1;
9644 dgst_pos2 = 2;
9645 dgst_pos3 = 3;
9646 break;
9647
9648 case 6800: hash_type = HASH_TYPE_AES;
9649 salt_type = SALT_TYPE_EMBEDDED;
9650 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9651 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9652 kern_type = KERN_TYPE_LASTPASS;
9653 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9654 parse_func = lastpass_parse_hash;
9655 sort_by_digest = sort_by_digest_4_8;
9656 opti_type = OPTI_TYPE_ZERO_BYTE;
9657 dgst_pos0 = 0;
9658 dgst_pos1 = 1;
9659 dgst_pos2 = 2;
9660 dgst_pos3 = 3;
9661 break;
9662
9663 case 6900: hash_type = HASH_TYPE_GOST;
9664 salt_type = SALT_TYPE_NONE;
9665 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9666 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9667 kern_type = KERN_TYPE_GOST;
9668 dgst_size = DGST_SIZE_4_8;
9669 parse_func = gost_parse_hash;
9670 sort_by_digest = sort_by_digest_4_8;
9671 opti_type = OPTI_TYPE_ZERO_BYTE;
9672 dgst_pos0 = 0;
9673 dgst_pos1 = 1;
9674 dgst_pos2 = 2;
9675 dgst_pos3 = 3;
9676 break;
9677
9678 case 7100: hash_type = HASH_TYPE_SHA512;
9679 salt_type = SALT_TYPE_EMBEDDED;
9680 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9681 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9682 kern_type = KERN_TYPE_PBKDF2_SHA512;
9683 dgst_size = DGST_SIZE_8_16;
9684 parse_func = sha512osx_parse_hash;
9685 sort_by_digest = sort_by_digest_8_16;
9686 opti_type = OPTI_TYPE_ZERO_BYTE
9687 | OPTI_TYPE_USES_BITS_64
9688 | OPTI_TYPE_SLOW_HASH_SIMD;
9689 dgst_pos0 = 0;
9690 dgst_pos1 = 1;
9691 dgst_pos2 = 2;
9692 dgst_pos3 = 3;
9693 break;
9694
9695 case 7200: hash_type = HASH_TYPE_SHA512;
9696 salt_type = SALT_TYPE_EMBEDDED;
9697 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9698 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9699 kern_type = KERN_TYPE_PBKDF2_SHA512;
9700 dgst_size = DGST_SIZE_8_16;
9701 parse_func = sha512grub_parse_hash;
9702 sort_by_digest = sort_by_digest_8_16;
9703 opti_type = OPTI_TYPE_ZERO_BYTE
9704 | OPTI_TYPE_USES_BITS_64
9705 | OPTI_TYPE_SLOW_HASH_SIMD;
9706 dgst_pos0 = 0;
9707 dgst_pos1 = 1;
9708 dgst_pos2 = 2;
9709 dgst_pos3 = 3;
9710 break;
9711
9712 case 7300: hash_type = HASH_TYPE_SHA1;
9713 salt_type = SALT_TYPE_EMBEDDED;
9714 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9715 opts_type = OPTS_TYPE_PT_GENERATE_BE
9716 | OPTS_TYPE_ST_ADD80
9717 | OPTS_TYPE_ST_ADDBITS15;
9718 kern_type = KERN_TYPE_RAKP;
9719 dgst_size = DGST_SIZE_4_5;
9720 parse_func = rakp_parse_hash;
9721 sort_by_digest = sort_by_digest_4_5;
9722 opti_type = OPTI_TYPE_ZERO_BYTE
9723 | OPTI_TYPE_NOT_ITERATED;
9724 dgst_pos0 = 3;
9725 dgst_pos1 = 4;
9726 dgst_pos2 = 2;
9727 dgst_pos3 = 1;
9728 break;
9729
9730 case 7400: hash_type = HASH_TYPE_SHA256;
9731 salt_type = SALT_TYPE_EMBEDDED;
9732 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9733 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9734 kern_type = KERN_TYPE_SHA256CRYPT;
9735 dgst_size = DGST_SIZE_4_8;
9736 parse_func = sha256crypt_parse_hash;
9737 sort_by_digest = sort_by_digest_4_8;
9738 opti_type = OPTI_TYPE_ZERO_BYTE;
9739 dgst_pos0 = 0;
9740 dgst_pos1 = 1;
9741 dgst_pos2 = 2;
9742 dgst_pos3 = 3;
9743 break;
9744
9745 case 7500: hash_type = HASH_TYPE_KRB5PA;
9746 salt_type = SALT_TYPE_EMBEDDED;
9747 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9748 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9749 kern_type = KERN_TYPE_KRB5PA;
9750 dgst_size = DGST_SIZE_4_4;
9751 parse_func = krb5pa_parse_hash;
9752 sort_by_digest = sort_by_digest_4_4;
9753 opti_type = OPTI_TYPE_ZERO_BYTE
9754 | OPTI_TYPE_NOT_ITERATED;
9755 dgst_pos0 = 0;
9756 dgst_pos1 = 1;
9757 dgst_pos2 = 2;
9758 dgst_pos3 = 3;
9759 break;
9760
9761 case 7600: hash_type = HASH_TYPE_SHA1;
9762 salt_type = SALT_TYPE_INTERN;
9763 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9764 opts_type = OPTS_TYPE_PT_GENERATE_BE
9765 | OPTS_TYPE_PT_ADD80
9766 | OPTS_TYPE_PT_ADDBITS15;
9767 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9768 dgst_size = DGST_SIZE_4_5;
9769 parse_func = redmine_parse_hash;
9770 sort_by_digest = sort_by_digest_4_5;
9771 opti_type = OPTI_TYPE_ZERO_BYTE
9772 | OPTI_TYPE_PRECOMPUTE_INIT
9773 | OPTI_TYPE_EARLY_SKIP
9774 | OPTI_TYPE_NOT_ITERATED
9775 | OPTI_TYPE_PREPENDED_SALT;
9776 dgst_pos0 = 3;
9777 dgst_pos1 = 4;
9778 dgst_pos2 = 2;
9779 dgst_pos3 = 1;
9780 break;
9781
9782 case 7700: hash_type = HASH_TYPE_SAPB;
9783 salt_type = SALT_TYPE_EMBEDDED;
9784 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9785 opts_type = OPTS_TYPE_PT_GENERATE_LE
9786 | OPTS_TYPE_PT_UPPER
9787 | OPTS_TYPE_ST_UPPER;
9788 kern_type = KERN_TYPE_SAPB;
9789 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9790 parse_func = sapb_parse_hash;
9791 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9792 opti_type = OPTI_TYPE_ZERO_BYTE
9793 | OPTI_TYPE_PRECOMPUTE_INIT
9794 | OPTI_TYPE_NOT_ITERATED;
9795 dgst_pos0 = 0;
9796 dgst_pos1 = 1;
9797 dgst_pos2 = 2;
9798 dgst_pos3 = 3;
9799 break;
9800
9801 case 7800: hash_type = HASH_TYPE_SAPG;
9802 salt_type = SALT_TYPE_EMBEDDED;
9803 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9804 opts_type = OPTS_TYPE_PT_GENERATE_BE
9805 | OPTS_TYPE_ST_ADD80
9806 | OPTS_TYPE_ST_UPPER;
9807 kern_type = KERN_TYPE_SAPG;
9808 dgst_size = DGST_SIZE_4_5;
9809 parse_func = sapg_parse_hash;
9810 sort_by_digest = sort_by_digest_4_5;
9811 opti_type = OPTI_TYPE_ZERO_BYTE
9812 | OPTI_TYPE_PRECOMPUTE_INIT
9813 | OPTI_TYPE_NOT_ITERATED;
9814 dgst_pos0 = 3;
9815 dgst_pos1 = 4;
9816 dgst_pos2 = 2;
9817 dgst_pos3 = 1;
9818 break;
9819
9820 case 7900: hash_type = HASH_TYPE_SHA512;
9821 salt_type = SALT_TYPE_EMBEDDED;
9822 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9823 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9824 kern_type = KERN_TYPE_DRUPAL7;
9825 dgst_size = DGST_SIZE_8_8;
9826 parse_func = drupal7_parse_hash;
9827 sort_by_digest = sort_by_digest_8_8;
9828 opti_type = OPTI_TYPE_ZERO_BYTE
9829 | OPTI_TYPE_USES_BITS_64;
9830 dgst_pos0 = 0;
9831 dgst_pos1 = 1;
9832 dgst_pos2 = 2;
9833 dgst_pos3 = 3;
9834 break;
9835
9836 case 8000: hash_type = HASH_TYPE_SHA256;
9837 salt_type = SALT_TYPE_EMBEDDED;
9838 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9839 opts_type = OPTS_TYPE_PT_GENERATE_BE
9840 | OPTS_TYPE_PT_UNICODE
9841 | OPTS_TYPE_ST_ADD80
9842 | OPTS_TYPE_ST_HEX;
9843 kern_type = KERN_TYPE_SYBASEASE;
9844 dgst_size = DGST_SIZE_4_8;
9845 parse_func = sybasease_parse_hash;
9846 sort_by_digest = sort_by_digest_4_8;
9847 opti_type = OPTI_TYPE_ZERO_BYTE
9848 | OPTI_TYPE_PRECOMPUTE_INIT
9849 | OPTI_TYPE_EARLY_SKIP
9850 | OPTI_TYPE_NOT_ITERATED
9851 | OPTI_TYPE_RAW_HASH;
9852 dgst_pos0 = 3;
9853 dgst_pos1 = 7;
9854 dgst_pos2 = 2;
9855 dgst_pos3 = 6;
9856 break;
9857
9858 case 8100: hash_type = HASH_TYPE_SHA1;
9859 salt_type = SALT_TYPE_EMBEDDED;
9860 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9861 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9862 kern_type = KERN_TYPE_NETSCALER;
9863 dgst_size = DGST_SIZE_4_5;
9864 parse_func = netscaler_parse_hash;
9865 sort_by_digest = sort_by_digest_4_5;
9866 opti_type = OPTI_TYPE_ZERO_BYTE
9867 | OPTI_TYPE_PRECOMPUTE_INIT
9868 | OPTI_TYPE_PRECOMPUTE_MERKLE
9869 | OPTI_TYPE_EARLY_SKIP
9870 | OPTI_TYPE_NOT_ITERATED
9871 | OPTI_TYPE_PREPENDED_SALT
9872 | OPTI_TYPE_RAW_HASH;
9873 dgst_pos0 = 3;
9874 dgst_pos1 = 4;
9875 dgst_pos2 = 2;
9876 dgst_pos3 = 1;
9877 break;
9878
9879 case 8200: hash_type = HASH_TYPE_SHA256;
9880 salt_type = SALT_TYPE_EMBEDDED;
9881 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9882 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9883 kern_type = KERN_TYPE_CLOUDKEY;
9884 dgst_size = DGST_SIZE_4_8;
9885 parse_func = cloudkey_parse_hash;
9886 sort_by_digest = sort_by_digest_4_8;
9887 opti_type = OPTI_TYPE_ZERO_BYTE;
9888 dgst_pos0 = 0;
9889 dgst_pos1 = 1;
9890 dgst_pos2 = 2;
9891 dgst_pos3 = 3;
9892 break;
9893
9894 case 8300: hash_type = HASH_TYPE_SHA1;
9895 salt_type = SALT_TYPE_EMBEDDED;
9896 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9897 opts_type = OPTS_TYPE_PT_GENERATE_BE
9898 | OPTS_TYPE_ST_HEX
9899 | OPTS_TYPE_ST_ADD80;
9900 kern_type = KERN_TYPE_NSEC3;
9901 dgst_size = DGST_SIZE_4_5;
9902 parse_func = nsec3_parse_hash;
9903 sort_by_digest = sort_by_digest_4_5;
9904 opti_type = OPTI_TYPE_ZERO_BYTE;
9905 dgst_pos0 = 3;
9906 dgst_pos1 = 4;
9907 dgst_pos2 = 2;
9908 dgst_pos3 = 1;
9909 break;
9910
9911 case 8400: hash_type = HASH_TYPE_SHA1;
9912 salt_type = SALT_TYPE_INTERN;
9913 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9914 opts_type = OPTS_TYPE_PT_GENERATE_BE
9915 | OPTS_TYPE_PT_ADD80
9916 | OPTS_TYPE_PT_ADDBITS15;
9917 kern_type = KERN_TYPE_WBB3;
9918 dgst_size = DGST_SIZE_4_5;
9919 parse_func = wbb3_parse_hash;
9920 sort_by_digest = sort_by_digest_4_5;
9921 opti_type = OPTI_TYPE_ZERO_BYTE
9922 | OPTI_TYPE_PRECOMPUTE_INIT
9923 | OPTI_TYPE_NOT_ITERATED;
9924 dgst_pos0 = 3;
9925 dgst_pos1 = 4;
9926 dgst_pos2 = 2;
9927 dgst_pos3 = 1;
9928 break;
9929
9930 case 8500: hash_type = HASH_TYPE_DESRACF;
9931 salt_type = SALT_TYPE_EMBEDDED;
9932 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9933 opts_type = OPTS_TYPE_PT_GENERATE_LE
9934 | OPTS_TYPE_ST_UPPER;
9935 kern_type = KERN_TYPE_RACF;
9936 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9937 parse_func = racf_parse_hash;
9938 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9939 opti_type = OPTI_TYPE_ZERO_BYTE
9940 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9941 dgst_pos0 = 0;
9942 dgst_pos1 = 1;
9943 dgst_pos2 = 2;
9944 dgst_pos3 = 3;
9945 break;
9946
9947 case 8600: hash_type = HASH_TYPE_LOTUS5;
9948 salt_type = SALT_TYPE_NONE;
9949 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9950 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9951 kern_type = KERN_TYPE_LOTUS5;
9952 dgst_size = DGST_SIZE_4_4;
9953 parse_func = lotus5_parse_hash;
9954 sort_by_digest = sort_by_digest_4_4;
9955 opti_type = OPTI_TYPE_EARLY_SKIP
9956 | OPTI_TYPE_NOT_ITERATED
9957 | OPTI_TYPE_NOT_SALTED
9958 | OPTI_TYPE_RAW_HASH;
9959 dgst_pos0 = 0;
9960 dgst_pos1 = 1;
9961 dgst_pos2 = 2;
9962 dgst_pos3 = 3;
9963 break;
9964
9965 case 8700: hash_type = HASH_TYPE_LOTUS6;
9966 salt_type = SALT_TYPE_EMBEDDED;
9967 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9968 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9969 kern_type = KERN_TYPE_LOTUS6;
9970 dgst_size = DGST_SIZE_4_4;
9971 parse_func = lotus6_parse_hash;
9972 sort_by_digest = sort_by_digest_4_4;
9973 opti_type = OPTI_TYPE_EARLY_SKIP
9974 | OPTI_TYPE_NOT_ITERATED
9975 | OPTI_TYPE_RAW_HASH;
9976 dgst_pos0 = 0;
9977 dgst_pos1 = 1;
9978 dgst_pos2 = 2;
9979 dgst_pos3 = 3;
9980 break;
9981
9982 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9983 salt_type = SALT_TYPE_EMBEDDED;
9984 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9985 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9986 kern_type = KERN_TYPE_ANDROIDFDE;
9987 dgst_size = DGST_SIZE_4_4;
9988 parse_func = androidfde_parse_hash;
9989 sort_by_digest = sort_by_digest_4_4;
9990 opti_type = OPTI_TYPE_ZERO_BYTE;
9991 dgst_pos0 = 0;
9992 dgst_pos1 = 1;
9993 dgst_pos2 = 2;
9994 dgst_pos3 = 3;
9995 break;
9996
9997 case 8900: hash_type = HASH_TYPE_SCRYPT;
9998 salt_type = SALT_TYPE_EMBEDDED;
9999 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10000 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10001 kern_type = KERN_TYPE_SCRYPT;
10002 dgst_size = DGST_SIZE_4_8;
10003 parse_func = scrypt_parse_hash;
10004 sort_by_digest = sort_by_digest_4_8;
10005 opti_type = OPTI_TYPE_ZERO_BYTE;
10006 dgst_pos0 = 0;
10007 dgst_pos1 = 1;
10008 dgst_pos2 = 2;
10009 dgst_pos3 = 3;
10010 break;
10011
10012 case 9000: hash_type = HASH_TYPE_SHA1;
10013 salt_type = SALT_TYPE_EMBEDDED;
10014 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10015 opts_type = OPTS_TYPE_PT_GENERATE_LE
10016 | OPTS_TYPE_ST_GENERATE_LE;
10017 kern_type = KERN_TYPE_PSAFE2;
10018 dgst_size = DGST_SIZE_4_5;
10019 parse_func = psafe2_parse_hash;
10020 sort_by_digest = sort_by_digest_4_5;
10021 opti_type = OPTI_TYPE_ZERO_BYTE;
10022 dgst_pos0 = 0;
10023 dgst_pos1 = 1;
10024 dgst_pos2 = 2;
10025 dgst_pos3 = 3;
10026 break;
10027
10028 case 9100: hash_type = HASH_TYPE_LOTUS8;
10029 salt_type = SALT_TYPE_EMBEDDED;
10030 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10031 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10032 kern_type = KERN_TYPE_LOTUS8;
10033 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10034 parse_func = lotus8_parse_hash;
10035 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10036 opti_type = OPTI_TYPE_ZERO_BYTE;
10037 dgst_pos0 = 0;
10038 dgst_pos1 = 1;
10039 dgst_pos2 = 2;
10040 dgst_pos3 = 3;
10041 break;
10042
10043 case 9200: hash_type = HASH_TYPE_SHA256;
10044 salt_type = SALT_TYPE_EMBEDDED;
10045 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10046 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10047 kern_type = KERN_TYPE_PBKDF2_SHA256;
10048 dgst_size = DGST_SIZE_4_32;
10049 parse_func = cisco8_parse_hash;
10050 sort_by_digest = sort_by_digest_4_32;
10051 opti_type = OPTI_TYPE_ZERO_BYTE
10052 | OPTI_TYPE_SLOW_HASH_SIMD;
10053 dgst_pos0 = 0;
10054 dgst_pos1 = 1;
10055 dgst_pos2 = 2;
10056 dgst_pos3 = 3;
10057 break;
10058
10059 case 9300: hash_type = HASH_TYPE_SCRYPT;
10060 salt_type = SALT_TYPE_EMBEDDED;
10061 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10062 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10063 kern_type = KERN_TYPE_SCRYPT;
10064 dgst_size = DGST_SIZE_4_8;
10065 parse_func = cisco9_parse_hash;
10066 sort_by_digest = sort_by_digest_4_8;
10067 opti_type = OPTI_TYPE_ZERO_BYTE;
10068 dgst_pos0 = 0;
10069 dgst_pos1 = 1;
10070 dgst_pos2 = 2;
10071 dgst_pos3 = 3;
10072 break;
10073
10074 case 9400: hash_type = HASH_TYPE_OFFICE2007;
10075 salt_type = SALT_TYPE_EMBEDDED;
10076 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10077 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10078 kern_type = KERN_TYPE_OFFICE2007;
10079 dgst_size = DGST_SIZE_4_4;
10080 parse_func = office2007_parse_hash;
10081 sort_by_digest = sort_by_digest_4_4;
10082 opti_type = OPTI_TYPE_ZERO_BYTE;
10083 dgst_pos0 = 0;
10084 dgst_pos1 = 1;
10085 dgst_pos2 = 2;
10086 dgst_pos3 = 3;
10087 break;
10088
10089 case 9500: hash_type = HASH_TYPE_OFFICE2010;
10090 salt_type = SALT_TYPE_EMBEDDED;
10091 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10092 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10093 kern_type = KERN_TYPE_OFFICE2010;
10094 dgst_size = DGST_SIZE_4_4;
10095 parse_func = office2010_parse_hash;
10096 sort_by_digest = sort_by_digest_4_4;
10097 opti_type = OPTI_TYPE_ZERO_BYTE;
10098 dgst_pos0 = 0;
10099 dgst_pos1 = 1;
10100 dgst_pos2 = 2;
10101 dgst_pos3 = 3;
10102 break;
10103
10104 case 9600: hash_type = HASH_TYPE_OFFICE2013;
10105 salt_type = SALT_TYPE_EMBEDDED;
10106 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10107 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10108 kern_type = KERN_TYPE_OFFICE2013;
10109 dgst_size = DGST_SIZE_4_4;
10110 parse_func = office2013_parse_hash;
10111 sort_by_digest = sort_by_digest_4_4;
10112 opti_type = OPTI_TYPE_ZERO_BYTE;
10113 dgst_pos0 = 0;
10114 dgst_pos1 = 1;
10115 dgst_pos2 = 2;
10116 dgst_pos3 = 3;
10117 break;
10118
10119 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
10120 salt_type = SALT_TYPE_EMBEDDED;
10121 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10122 opts_type = OPTS_TYPE_PT_GENERATE_LE
10123 | OPTS_TYPE_PT_ADD80
10124 | OPTS_TYPE_PT_UNICODE;
10125 kern_type = KERN_TYPE_OLDOFFICE01;
10126 dgst_size = DGST_SIZE_4_4;
10127 parse_func = oldoffice01_parse_hash;
10128 sort_by_digest = sort_by_digest_4_4;
10129 opti_type = OPTI_TYPE_ZERO_BYTE
10130 | OPTI_TYPE_PRECOMPUTE_INIT
10131 | OPTI_TYPE_NOT_ITERATED;
10132 dgst_pos0 = 0;
10133 dgst_pos1 = 1;
10134 dgst_pos2 = 2;
10135 dgst_pos3 = 3;
10136 break;
10137
10138 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
10139 salt_type = SALT_TYPE_EMBEDDED;
10140 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10141 opts_type = OPTS_TYPE_PT_GENERATE_LE
10142 | OPTS_TYPE_PT_ADD80;
10143 kern_type = KERN_TYPE_OLDOFFICE01CM1;
10144 dgst_size = DGST_SIZE_4_4;
10145 parse_func = oldoffice01cm1_parse_hash;
10146 sort_by_digest = sort_by_digest_4_4;
10147 opti_type = OPTI_TYPE_ZERO_BYTE
10148 | OPTI_TYPE_PRECOMPUTE_INIT
10149 | OPTI_TYPE_NOT_ITERATED;
10150 dgst_pos0 = 0;
10151 dgst_pos1 = 1;
10152 dgst_pos2 = 2;
10153 dgst_pos3 = 3;
10154 break;
10155
10156 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
10157 salt_type = SALT_TYPE_EMBEDDED;
10158 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10159 opts_type = OPTS_TYPE_PT_GENERATE_LE
10160 | OPTS_TYPE_PT_ADD80
10161 | OPTS_TYPE_PT_UNICODE
10162 | OPTS_TYPE_PT_NEVERCRACK;
10163 kern_type = KERN_TYPE_OLDOFFICE01CM2;
10164 dgst_size = DGST_SIZE_4_4;
10165 parse_func = oldoffice01cm2_parse_hash;
10166 sort_by_digest = sort_by_digest_4_4;
10167 opti_type = OPTI_TYPE_ZERO_BYTE
10168 | OPTI_TYPE_PRECOMPUTE_INIT
10169 | OPTI_TYPE_NOT_ITERATED;
10170 dgst_pos0 = 0;
10171 dgst_pos1 = 1;
10172 dgst_pos2 = 2;
10173 dgst_pos3 = 3;
10174 break;
10175
10176 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
10177 salt_type = SALT_TYPE_EMBEDDED;
10178 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10179 opts_type = OPTS_TYPE_PT_GENERATE_BE
10180 | OPTS_TYPE_PT_ADD80
10181 | OPTS_TYPE_PT_UNICODE;
10182 kern_type = KERN_TYPE_OLDOFFICE34;
10183 dgst_size = DGST_SIZE_4_4;
10184 parse_func = oldoffice34_parse_hash;
10185 sort_by_digest = sort_by_digest_4_4;
10186 opti_type = OPTI_TYPE_ZERO_BYTE
10187 | OPTI_TYPE_PRECOMPUTE_INIT
10188 | OPTI_TYPE_NOT_ITERATED;
10189 dgst_pos0 = 0;
10190 dgst_pos1 = 1;
10191 dgst_pos2 = 2;
10192 dgst_pos3 = 3;
10193 break;
10194
10195 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10196 salt_type = SALT_TYPE_EMBEDDED;
10197 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10198 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10199 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10200 dgst_size = DGST_SIZE_4_4;
10201 parse_func = oldoffice34cm1_parse_hash;
10202 sort_by_digest = sort_by_digest_4_4;
10203 opti_type = OPTI_TYPE_ZERO_BYTE
10204 | OPTI_TYPE_PRECOMPUTE_INIT
10205 | OPTI_TYPE_NOT_ITERATED;
10206 dgst_pos0 = 0;
10207 dgst_pos1 = 1;
10208 dgst_pos2 = 2;
10209 dgst_pos3 = 3;
10210 break;
10211
10212 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10213 salt_type = SALT_TYPE_EMBEDDED;
10214 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10215 opts_type = OPTS_TYPE_PT_GENERATE_BE
10216 | OPTS_TYPE_PT_ADD80
10217 | OPTS_TYPE_PT_UNICODE
10218 | OPTS_TYPE_PT_NEVERCRACK;
10219 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10220 dgst_size = DGST_SIZE_4_4;
10221 parse_func = oldoffice34cm2_parse_hash;
10222 sort_by_digest = sort_by_digest_4_4;
10223 opti_type = OPTI_TYPE_ZERO_BYTE
10224 | OPTI_TYPE_PRECOMPUTE_INIT
10225 | OPTI_TYPE_NOT_ITERATED;
10226 dgst_pos0 = 0;
10227 dgst_pos1 = 1;
10228 dgst_pos2 = 2;
10229 dgst_pos3 = 3;
10230 break;
10231
10232 case 9900: hash_type = HASH_TYPE_MD5;
10233 salt_type = SALT_TYPE_NONE;
10234 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10235 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10236 kern_type = KERN_TYPE_RADMIN2;
10237 dgst_size = DGST_SIZE_4_4;
10238 parse_func = radmin2_parse_hash;
10239 sort_by_digest = sort_by_digest_4_4;
10240 opti_type = OPTI_TYPE_ZERO_BYTE
10241 | OPTI_TYPE_PRECOMPUTE_INIT
10242 | OPTI_TYPE_EARLY_SKIP
10243 | OPTI_TYPE_NOT_ITERATED
10244 | OPTI_TYPE_NOT_SALTED;
10245 dgst_pos0 = 0;
10246 dgst_pos1 = 3;
10247 dgst_pos2 = 2;
10248 dgst_pos3 = 1;
10249 break;
10250
10251 case 10000: hash_type = HASH_TYPE_SHA256;
10252 salt_type = SALT_TYPE_EMBEDDED;
10253 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10254 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10255 kern_type = KERN_TYPE_PBKDF2_SHA256;
10256 dgst_size = DGST_SIZE_4_32;
10257 parse_func = djangopbkdf2_parse_hash;
10258 sort_by_digest = sort_by_digest_4_32;
10259 opti_type = OPTI_TYPE_ZERO_BYTE
10260 | OPTI_TYPE_SLOW_HASH_SIMD;
10261 dgst_pos0 = 0;
10262 dgst_pos1 = 1;
10263 dgst_pos2 = 2;
10264 dgst_pos3 = 3;
10265 break;
10266
10267 case 10100: hash_type = HASH_TYPE_SIPHASH;
10268 salt_type = SALT_TYPE_EMBEDDED;
10269 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10270 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10271 kern_type = KERN_TYPE_SIPHASH;
10272 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10273 parse_func = siphash_parse_hash;
10274 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10275 opti_type = OPTI_TYPE_ZERO_BYTE
10276 | OPTI_TYPE_NOT_ITERATED
10277 | OPTI_TYPE_RAW_HASH;
10278 dgst_pos0 = 0;
10279 dgst_pos1 = 1;
10280 dgst_pos2 = 2;
10281 dgst_pos3 = 3;
10282 break;
10283
10284 case 10200: hash_type = HASH_TYPE_MD5;
10285 salt_type = SALT_TYPE_EMBEDDED;
10286 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10287 opts_type = OPTS_TYPE_PT_GENERATE_LE
10288 | OPTS_TYPE_ST_ADD80
10289 | OPTS_TYPE_ST_ADDBITS14;
10290 kern_type = KERN_TYPE_HMACMD5_PW;
10291 dgst_size = DGST_SIZE_4_4;
10292 parse_func = crammd5_parse_hash;
10293 sort_by_digest = sort_by_digest_4_4;
10294 opti_type = OPTI_TYPE_ZERO_BYTE
10295 | OPTI_TYPE_NOT_ITERATED;
10296 dgst_pos0 = 0;
10297 dgst_pos1 = 3;
10298 dgst_pos2 = 2;
10299 dgst_pos3 = 1;
10300 break;
10301
10302 case 10300: hash_type = HASH_TYPE_SHA1;
10303 salt_type = SALT_TYPE_EMBEDDED;
10304 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10305 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10306 kern_type = KERN_TYPE_SAPH_SHA1;
10307 dgst_size = DGST_SIZE_4_5;
10308 parse_func = saph_sha1_parse_hash;
10309 sort_by_digest = sort_by_digest_4_5;
10310 opti_type = OPTI_TYPE_ZERO_BYTE;
10311 dgst_pos0 = 0;
10312 dgst_pos1 = 1;
10313 dgst_pos2 = 2;
10314 dgst_pos3 = 3;
10315 break;
10316
10317 case 10400: hash_type = HASH_TYPE_PDFU16;
10318 salt_type = SALT_TYPE_EMBEDDED;
10319 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10320 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10321 kern_type = KERN_TYPE_PDF11;
10322 dgst_size = DGST_SIZE_4_4;
10323 parse_func = pdf11_parse_hash;
10324 sort_by_digest = sort_by_digest_4_4;
10325 opti_type = OPTI_TYPE_ZERO_BYTE
10326 | OPTI_TYPE_NOT_ITERATED;
10327 dgst_pos0 = 0;
10328 dgst_pos1 = 1;
10329 dgst_pos2 = 2;
10330 dgst_pos3 = 3;
10331 break;
10332
10333 case 10410: hash_type = HASH_TYPE_PDFU16;
10334 salt_type = SALT_TYPE_EMBEDDED;
10335 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10336 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10337 kern_type = KERN_TYPE_PDF11CM1;
10338 dgst_size = DGST_SIZE_4_4;
10339 parse_func = pdf11cm1_parse_hash;
10340 sort_by_digest = sort_by_digest_4_4;
10341 opti_type = OPTI_TYPE_ZERO_BYTE
10342 | OPTI_TYPE_NOT_ITERATED;
10343 dgst_pos0 = 0;
10344 dgst_pos1 = 1;
10345 dgst_pos2 = 2;
10346 dgst_pos3 = 3;
10347 break;
10348
10349 case 10420: hash_type = HASH_TYPE_PDFU16;
10350 salt_type = SALT_TYPE_EMBEDDED;
10351 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10352 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10353 kern_type = KERN_TYPE_PDF11CM2;
10354 dgst_size = DGST_SIZE_4_4;
10355 parse_func = pdf11cm2_parse_hash;
10356 sort_by_digest = sort_by_digest_4_4;
10357 opti_type = OPTI_TYPE_ZERO_BYTE
10358 | OPTI_TYPE_NOT_ITERATED;
10359 dgst_pos0 = 0;
10360 dgst_pos1 = 1;
10361 dgst_pos2 = 2;
10362 dgst_pos3 = 3;
10363 break;
10364
10365 case 10500: hash_type = HASH_TYPE_PDFU16;
10366 salt_type = SALT_TYPE_EMBEDDED;
10367 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10368 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10369 kern_type = KERN_TYPE_PDF14;
10370 dgst_size = DGST_SIZE_4_4;
10371 parse_func = pdf14_parse_hash;
10372 sort_by_digest = sort_by_digest_4_4;
10373 opti_type = OPTI_TYPE_ZERO_BYTE
10374 | OPTI_TYPE_NOT_ITERATED;
10375 dgst_pos0 = 0;
10376 dgst_pos1 = 1;
10377 dgst_pos2 = 2;
10378 dgst_pos3 = 3;
10379 break;
10380
10381 case 10600: hash_type = HASH_TYPE_SHA256;
10382 salt_type = SALT_TYPE_EMBEDDED;
10383 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10384 opts_type = OPTS_TYPE_PT_GENERATE_BE
10385 | OPTS_TYPE_ST_ADD80
10386 | OPTS_TYPE_ST_ADDBITS15
10387 | OPTS_TYPE_HASH_COPY;
10388 kern_type = KERN_TYPE_SHA256_PWSLT;
10389 dgst_size = DGST_SIZE_4_8;
10390 parse_func = pdf17l3_parse_hash;
10391 sort_by_digest = sort_by_digest_4_8;
10392 opti_type = OPTI_TYPE_ZERO_BYTE
10393 | OPTI_TYPE_PRECOMPUTE_INIT
10394 | OPTI_TYPE_PRECOMPUTE_MERKLE
10395 | OPTI_TYPE_EARLY_SKIP
10396 | OPTI_TYPE_NOT_ITERATED
10397 | OPTI_TYPE_APPENDED_SALT
10398 | OPTI_TYPE_RAW_HASH;
10399 dgst_pos0 = 3;
10400 dgst_pos1 = 7;
10401 dgst_pos2 = 2;
10402 dgst_pos3 = 6;
10403 break;
10404
10405 case 10700: hash_type = HASH_TYPE_PDFU32;
10406 salt_type = SALT_TYPE_EMBEDDED;
10407 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10408 opts_type = OPTS_TYPE_PT_GENERATE_LE
10409 | OPTS_TYPE_HASH_COPY;
10410 kern_type = KERN_TYPE_PDF17L8;
10411 dgst_size = DGST_SIZE_4_8;
10412 parse_func = pdf17l8_parse_hash;
10413 sort_by_digest = sort_by_digest_4_8;
10414 opti_type = OPTI_TYPE_ZERO_BYTE
10415 | OPTI_TYPE_NOT_ITERATED;
10416 dgst_pos0 = 0;
10417 dgst_pos1 = 1;
10418 dgst_pos2 = 2;
10419 dgst_pos3 = 3;
10420 break;
10421
10422 case 10800: hash_type = HASH_TYPE_SHA384;
10423 salt_type = SALT_TYPE_NONE;
10424 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10425 opts_type = OPTS_TYPE_PT_GENERATE_BE
10426 | OPTS_TYPE_PT_ADD80
10427 | OPTS_TYPE_PT_ADDBITS15;
10428 kern_type = KERN_TYPE_SHA384;
10429 dgst_size = DGST_SIZE_8_8;
10430 parse_func = sha384_parse_hash;
10431 sort_by_digest = sort_by_digest_8_8;
10432 opti_type = OPTI_TYPE_ZERO_BYTE
10433 | OPTI_TYPE_PRECOMPUTE_INIT
10434 | OPTI_TYPE_PRECOMPUTE_MERKLE
10435 | OPTI_TYPE_EARLY_SKIP
10436 | OPTI_TYPE_NOT_ITERATED
10437 | OPTI_TYPE_NOT_SALTED
10438 | OPTI_TYPE_USES_BITS_64
10439 | OPTI_TYPE_RAW_HASH;
10440 dgst_pos0 = 6;
10441 dgst_pos1 = 7;
10442 dgst_pos2 = 4;
10443 dgst_pos3 = 5;
10444 break;
10445
10446 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10447 salt_type = SALT_TYPE_EMBEDDED;
10448 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10449 opts_type = OPTS_TYPE_PT_GENERATE_LE
10450 | OPTS_TYPE_ST_BASE64
10451 | OPTS_TYPE_HASH_COPY;
10452 kern_type = KERN_TYPE_PBKDF2_SHA256;
10453 dgst_size = DGST_SIZE_4_32;
10454 parse_func = pbkdf2_sha256_parse_hash;
10455 sort_by_digest = sort_by_digest_4_32;
10456 opti_type = OPTI_TYPE_ZERO_BYTE
10457 | OPTI_TYPE_SLOW_HASH_SIMD;
10458 dgst_pos0 = 0;
10459 dgst_pos1 = 1;
10460 dgst_pos2 = 2;
10461 dgst_pos3 = 3;
10462 break;
10463
10464 case 11000: hash_type = HASH_TYPE_MD5;
10465 salt_type = SALT_TYPE_INTERN;
10466 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10467 opts_type = OPTS_TYPE_PT_GENERATE_LE
10468 | OPTS_TYPE_PT_ADD80;
10469 kern_type = KERN_TYPE_PRESTASHOP;
10470 dgst_size = DGST_SIZE_4_4;
10471 parse_func = prestashop_parse_hash;
10472 sort_by_digest = sort_by_digest_4_4;
10473 opti_type = OPTI_TYPE_ZERO_BYTE
10474 | OPTI_TYPE_PRECOMPUTE_INIT
10475 | OPTI_TYPE_NOT_ITERATED
10476 | OPTI_TYPE_PREPENDED_SALT;
10477 dgst_pos0 = 0;
10478 dgst_pos1 = 3;
10479 dgst_pos2 = 2;
10480 dgst_pos3 = 1;
10481 break;
10482
10483 case 11100: hash_type = HASH_TYPE_MD5;
10484 salt_type = SALT_TYPE_EMBEDDED;
10485 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10486 opts_type = OPTS_TYPE_PT_GENERATE_LE
10487 | OPTS_TYPE_ST_ADD80;
10488 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10489 dgst_size = DGST_SIZE_4_4;
10490 parse_func = postgresql_auth_parse_hash;
10491 sort_by_digest = sort_by_digest_4_4;
10492 opti_type = OPTI_TYPE_ZERO_BYTE
10493 | OPTI_TYPE_PRECOMPUTE_INIT
10494 | OPTI_TYPE_PRECOMPUTE_MERKLE
10495 | OPTI_TYPE_EARLY_SKIP;
10496 dgst_pos0 = 0;
10497 dgst_pos1 = 3;
10498 dgst_pos2 = 2;
10499 dgst_pos3 = 1;
10500 break;
10501
10502 case 11200: hash_type = HASH_TYPE_SHA1;
10503 salt_type = SALT_TYPE_EMBEDDED;
10504 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10505 opts_type = OPTS_TYPE_PT_GENERATE_BE
10506 | OPTS_TYPE_PT_ADD80
10507 | OPTS_TYPE_ST_HEX;
10508 kern_type = KERN_TYPE_MYSQL_AUTH;
10509 dgst_size = DGST_SIZE_4_5;
10510 parse_func = mysql_auth_parse_hash;
10511 sort_by_digest = sort_by_digest_4_5;
10512 opti_type = OPTI_TYPE_ZERO_BYTE
10513 | OPTI_TYPE_EARLY_SKIP;
10514 dgst_pos0 = 3;
10515 dgst_pos1 = 4;
10516 dgst_pos2 = 2;
10517 dgst_pos3 = 1;
10518 break;
10519
10520 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10521 salt_type = SALT_TYPE_EMBEDDED;
10522 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10523 opts_type = OPTS_TYPE_PT_GENERATE_LE
10524 | OPTS_TYPE_ST_HEX
10525 | OPTS_TYPE_ST_ADD80;
10526 kern_type = KERN_TYPE_BITCOIN_WALLET;
10527 dgst_size = DGST_SIZE_4_4;
10528 parse_func = bitcoin_wallet_parse_hash;
10529 sort_by_digest = sort_by_digest_4_4;
10530 opti_type = OPTI_TYPE_ZERO_BYTE;
10531 dgst_pos0 = 0;
10532 dgst_pos1 = 1;
10533 dgst_pos2 = 2;
10534 dgst_pos3 = 3;
10535 break;
10536
10537 case 11400: hash_type = HASH_TYPE_MD5;
10538 salt_type = SALT_TYPE_EMBEDDED;
10539 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10540 opts_type = OPTS_TYPE_PT_GENERATE_LE
10541 | OPTS_TYPE_PT_ADD80
10542 | OPTS_TYPE_HASH_COPY;
10543 kern_type = KERN_TYPE_SIP_AUTH;
10544 dgst_size = DGST_SIZE_4_4;
10545 parse_func = sip_auth_parse_hash;
10546 sort_by_digest = sort_by_digest_4_4;
10547 opti_type = OPTI_TYPE_ZERO_BYTE;
10548 dgst_pos0 = 0;
10549 dgst_pos1 = 3;
10550 dgst_pos2 = 2;
10551 dgst_pos3 = 1;
10552 break;
10553
10554 case 11500: hash_type = HASH_TYPE_CRC32;
10555 salt_type = SALT_TYPE_INTERN;
10556 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10557 opts_type = OPTS_TYPE_PT_GENERATE_LE
10558 | OPTS_TYPE_ST_GENERATE_LE
10559 | OPTS_TYPE_ST_HEX;
10560 kern_type = KERN_TYPE_CRC32;
10561 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10562 parse_func = crc32_parse_hash;
10563 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10564 opti_type = OPTI_TYPE_ZERO_BYTE;
10565 dgst_pos0 = 0;
10566 dgst_pos1 = 1;
10567 dgst_pos2 = 2;
10568 dgst_pos3 = 3;
10569 break;
10570
10571 case 11600: hash_type = HASH_TYPE_AES;
10572 salt_type = SALT_TYPE_EMBEDDED;
10573 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10574 opts_type = OPTS_TYPE_PT_GENERATE_LE
10575 | OPTS_TYPE_PT_NEVERCRACK;
10576 kern_type = KERN_TYPE_SEVEN_ZIP;
10577 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10578 parse_func = seven_zip_parse_hash;
10579 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10580 opti_type = OPTI_TYPE_ZERO_BYTE;
10581 dgst_pos0 = 0;
10582 dgst_pos1 = 1;
10583 dgst_pos2 = 2;
10584 dgst_pos3 = 3;
10585 break;
10586
10587 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10588 salt_type = SALT_TYPE_NONE;
10589 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10590 opts_type = OPTS_TYPE_PT_GENERATE_LE
10591 | OPTS_TYPE_PT_ADD01;
10592 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10593 dgst_size = DGST_SIZE_4_8;
10594 parse_func = gost2012sbog_256_parse_hash;
10595 sort_by_digest = sort_by_digest_4_8;
10596 opti_type = OPTI_TYPE_ZERO_BYTE;
10597 dgst_pos0 = 0;
10598 dgst_pos1 = 1;
10599 dgst_pos2 = 2;
10600 dgst_pos3 = 3;
10601 break;
10602
10603 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10604 salt_type = SALT_TYPE_NONE;
10605 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10606 opts_type = OPTS_TYPE_PT_GENERATE_LE
10607 | OPTS_TYPE_PT_ADD01;
10608 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10609 dgst_size = DGST_SIZE_4_16;
10610 parse_func = gost2012sbog_512_parse_hash;
10611 sort_by_digest = sort_by_digest_4_16;
10612 opti_type = OPTI_TYPE_ZERO_BYTE;
10613 dgst_pos0 = 0;
10614 dgst_pos1 = 1;
10615 dgst_pos2 = 2;
10616 dgst_pos3 = 3;
10617 break;
10618
10619 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10620 salt_type = SALT_TYPE_EMBEDDED;
10621 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10622 opts_type = OPTS_TYPE_PT_GENERATE_LE
10623 | OPTS_TYPE_ST_BASE64
10624 | OPTS_TYPE_HASH_COPY;
10625 kern_type = KERN_TYPE_PBKDF2_MD5;
10626 dgst_size = DGST_SIZE_4_32;
10627 parse_func = pbkdf2_md5_parse_hash;
10628 sort_by_digest = sort_by_digest_4_32;
10629 opti_type = OPTI_TYPE_ZERO_BYTE
10630 | OPTI_TYPE_SLOW_HASH_SIMD;
10631 dgst_pos0 = 0;
10632 dgst_pos1 = 1;
10633 dgst_pos2 = 2;
10634 dgst_pos3 = 3;
10635 break;
10636
10637 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10638 salt_type = SALT_TYPE_EMBEDDED;
10639 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10640 opts_type = OPTS_TYPE_PT_GENERATE_LE
10641 | OPTS_TYPE_ST_BASE64
10642 | OPTS_TYPE_HASH_COPY;
10643 kern_type = KERN_TYPE_PBKDF2_SHA1;
10644 dgst_size = DGST_SIZE_4_32;
10645 parse_func = pbkdf2_sha1_parse_hash;
10646 sort_by_digest = sort_by_digest_4_32;
10647 opti_type = OPTI_TYPE_ZERO_BYTE
10648 | OPTI_TYPE_SLOW_HASH_SIMD;
10649 dgst_pos0 = 0;
10650 dgst_pos1 = 1;
10651 dgst_pos2 = 2;
10652 dgst_pos3 = 3;
10653 break;
10654
10655 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10656 salt_type = SALT_TYPE_EMBEDDED;
10657 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10658 opts_type = OPTS_TYPE_PT_GENERATE_LE
10659 | OPTS_TYPE_ST_BASE64
10660 | OPTS_TYPE_HASH_COPY;
10661 kern_type = KERN_TYPE_PBKDF2_SHA512;
10662 dgst_size = DGST_SIZE_8_16;
10663 parse_func = pbkdf2_sha512_parse_hash;
10664 sort_by_digest = sort_by_digest_8_16;
10665 opti_type = OPTI_TYPE_ZERO_BYTE
10666 | OPTI_TYPE_USES_BITS_64
10667 | OPTI_TYPE_SLOW_HASH_SIMD;
10668 dgst_pos0 = 0;
10669 dgst_pos1 = 1;
10670 dgst_pos2 = 2;
10671 dgst_pos3 = 3;
10672 break;
10673
10674 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10675 salt_type = SALT_TYPE_EMBEDDED;
10676 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10677 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10678 kern_type = KERN_TYPE_ECRYPTFS;
10679 dgst_size = DGST_SIZE_8_8;
10680 parse_func = ecryptfs_parse_hash;
10681 sort_by_digest = sort_by_digest_8_8;
10682 opti_type = OPTI_TYPE_ZERO_BYTE
10683 | OPTI_TYPE_USES_BITS_64;
10684 dgst_pos0 = 0;
10685 dgst_pos1 = 1;
10686 dgst_pos2 = 2;
10687 dgst_pos3 = 3;
10688 break;
10689
10690 case 12300: hash_type = HASH_TYPE_ORACLET;
10691 salt_type = SALT_TYPE_EMBEDDED;
10692 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10693 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10694 kern_type = KERN_TYPE_ORACLET;
10695 dgst_size = DGST_SIZE_8_16;
10696 parse_func = oraclet_parse_hash;
10697 sort_by_digest = sort_by_digest_8_16;
10698 opti_type = OPTI_TYPE_ZERO_BYTE
10699 | OPTI_TYPE_USES_BITS_64;
10700 dgst_pos0 = 0;
10701 dgst_pos1 = 1;
10702 dgst_pos2 = 2;
10703 dgst_pos3 = 3;
10704 break;
10705
10706 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10707 salt_type = SALT_TYPE_EMBEDDED;
10708 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10709 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10710 kern_type = KERN_TYPE_BSDICRYPT;
10711 dgst_size = DGST_SIZE_4_4;
10712 parse_func = bsdicrypt_parse_hash;
10713 sort_by_digest = sort_by_digest_4_4;
10714 opti_type = OPTI_TYPE_ZERO_BYTE
10715 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10716 dgst_pos0 = 0;
10717 dgst_pos1 = 1;
10718 dgst_pos2 = 2;
10719 dgst_pos3 = 3;
10720 break;
10721
10722 case 12500: hash_type = HASH_TYPE_RAR3HP;
10723 salt_type = SALT_TYPE_EMBEDDED;
10724 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10725 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10726 kern_type = KERN_TYPE_RAR3;
10727 dgst_size = DGST_SIZE_4_4;
10728 parse_func = rar3hp_parse_hash;
10729 sort_by_digest = sort_by_digest_4_4;
10730 opti_type = OPTI_TYPE_ZERO_BYTE;
10731 dgst_pos0 = 0;
10732 dgst_pos1 = 1;
10733 dgst_pos2 = 2;
10734 dgst_pos3 = 3;
10735 break;
10736
10737 case 12600: hash_type = HASH_TYPE_SHA256;
10738 salt_type = SALT_TYPE_INTERN;
10739 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10740 opts_type = OPTS_TYPE_PT_GENERATE_BE
10741 | OPTS_TYPE_PT_ADD80;
10742 kern_type = KERN_TYPE_CF10;
10743 dgst_size = DGST_SIZE_4_8;
10744 parse_func = cf10_parse_hash;
10745 sort_by_digest = sort_by_digest_4_8;
10746 opti_type = OPTI_TYPE_ZERO_BYTE
10747 | OPTI_TYPE_PRECOMPUTE_INIT
10748 | OPTI_TYPE_EARLY_SKIP
10749 | OPTI_TYPE_NOT_ITERATED;
10750 dgst_pos0 = 3;
10751 dgst_pos1 = 7;
10752 dgst_pos2 = 2;
10753 dgst_pos3 = 6;
10754 break;
10755
10756 case 12700: hash_type = HASH_TYPE_AES;
10757 salt_type = SALT_TYPE_EMBEDDED;
10758 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10759 opts_type = OPTS_TYPE_PT_GENERATE_LE
10760 | OPTS_TYPE_HASH_COPY;
10761 kern_type = KERN_TYPE_MYWALLET;
10762 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10763 parse_func = mywallet_parse_hash;
10764 sort_by_digest = sort_by_digest_4_5;
10765 opti_type = OPTI_TYPE_ZERO_BYTE;
10766 dgst_pos0 = 0;
10767 dgst_pos1 = 1;
10768 dgst_pos2 = 2;
10769 dgst_pos3 = 3;
10770 break;
10771
10772 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10773 salt_type = SALT_TYPE_EMBEDDED;
10774 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10775 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10776 kern_type = KERN_TYPE_MS_DRSR;
10777 dgst_size = DGST_SIZE_4_8;
10778 parse_func = ms_drsr_parse_hash;
10779 sort_by_digest = sort_by_digest_4_8;
10780 opti_type = OPTI_TYPE_ZERO_BYTE;
10781 dgst_pos0 = 0;
10782 dgst_pos1 = 1;
10783 dgst_pos2 = 2;
10784 dgst_pos3 = 3;
10785 break;
10786
10787 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10788 salt_type = SALT_TYPE_EMBEDDED;
10789 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10790 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10791 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10792 dgst_size = DGST_SIZE_4_8;
10793 parse_func = androidfde_samsung_parse_hash;
10794 sort_by_digest = sort_by_digest_4_8;
10795 opti_type = OPTI_TYPE_ZERO_BYTE;
10796 dgst_pos0 = 0;
10797 dgst_pos1 = 1;
10798 dgst_pos2 = 2;
10799 dgst_pos3 = 3;
10800 break;
10801
10802 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10803 salt_type = SALT_TYPE_EMBEDDED;
10804 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10805 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10806 kern_type = KERN_TYPE_RAR5;
10807 dgst_size = DGST_SIZE_4_4;
10808 parse_func = rar5_parse_hash;
10809 sort_by_digest = sort_by_digest_4_4;
10810 opti_type = OPTI_TYPE_ZERO_BYTE;
10811 dgst_pos0 = 0;
10812 dgst_pos1 = 1;
10813 dgst_pos2 = 2;
10814 dgst_pos3 = 3;
10815 break;
10816
10817 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10818 salt_type = SALT_TYPE_EMBEDDED;
10819 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10820 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10821 kern_type = KERN_TYPE_KRB5TGS;
10822 dgst_size = DGST_SIZE_4_4;
10823 parse_func = krb5tgs_parse_hash;
10824 sort_by_digest = sort_by_digest_4_4;
10825 opti_type = OPTI_TYPE_ZERO_BYTE
10826 | OPTI_TYPE_NOT_ITERATED;
10827 dgst_pos0 = 0;
10828 dgst_pos1 = 1;
10829 dgst_pos2 = 2;
10830 dgst_pos3 = 3;
10831 break;
10832
10833 case 13200: hash_type = HASH_TYPE_AES;
10834 salt_type = SALT_TYPE_EMBEDDED;
10835 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10836 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10837 kern_type = KERN_TYPE_AXCRYPT;
10838 dgst_size = DGST_SIZE_4_4;
10839 parse_func = axcrypt_parse_hash;
10840 sort_by_digest = sort_by_digest_4_4;
10841 opti_type = OPTI_TYPE_ZERO_BYTE;
10842 dgst_pos0 = 0;
10843 dgst_pos1 = 1;
10844 dgst_pos2 = 2;
10845 dgst_pos3 = 3;
10846 break;
10847
10848 case 13300: hash_type = HASH_TYPE_SHA1;
10849 salt_type = SALT_TYPE_NONE;
10850 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10851 opts_type = OPTS_TYPE_PT_GENERATE_BE
10852 | OPTS_TYPE_PT_ADD80
10853 | OPTS_TYPE_PT_ADDBITS15;
10854 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10855 dgst_size = DGST_SIZE_4_5;
10856 parse_func = sha1axcrypt_parse_hash;
10857 sort_by_digest = sort_by_digest_4_5;
10858 opti_type = OPTI_TYPE_ZERO_BYTE
10859 | OPTI_TYPE_PRECOMPUTE_INIT
10860 | OPTI_TYPE_EARLY_SKIP
10861 | OPTI_TYPE_NOT_ITERATED
10862 | OPTI_TYPE_NOT_SALTED;
10863 dgst_pos0 = 0;
10864 dgst_pos1 = 4;
10865 dgst_pos2 = 3;
10866 dgst_pos3 = 2;
10867 break;
10868
10869 case 13400: hash_type = HASH_TYPE_AES;
10870 salt_type = SALT_TYPE_EMBEDDED;
10871 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10872 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10873 kern_type = KERN_TYPE_KEEPASS;
10874 dgst_size = DGST_SIZE_4_4;
10875 parse_func = keepass_parse_hash;
10876 sort_by_digest = sort_by_digest_4_4;
10877 opti_type = OPTI_TYPE_ZERO_BYTE;
10878 dgst_pos0 = 0;
10879 dgst_pos1 = 1;
10880 dgst_pos2 = 2;
10881 dgst_pos3 = 3;
10882 break;
10883
10884 case 13500: hash_type = HASH_TYPE_SHA1;
10885 salt_type = SALT_TYPE_EMBEDDED;
10886 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10887 opts_type = OPTS_TYPE_PT_GENERATE_BE
10888 | OPTS_TYPE_PT_UNICODE
10889 | OPTS_TYPE_PT_ADD80;
10890 kern_type = KERN_TYPE_PSTOKEN;
10891 dgst_size = DGST_SIZE_4_5;
10892 parse_func = pstoken_parse_hash;
10893 sort_by_digest = sort_by_digest_4_5;
10894 opti_type = OPTI_TYPE_ZERO_BYTE
10895 | OPTI_TYPE_PRECOMPUTE_INIT
10896 | OPTI_TYPE_EARLY_SKIP
10897 | OPTI_TYPE_NOT_ITERATED
10898 | OPTI_TYPE_PREPENDED_SALT
10899 | OPTI_TYPE_RAW_HASH;
10900 dgst_pos0 = 3;
10901 dgst_pos1 = 4;
10902 dgst_pos2 = 2;
10903 dgst_pos3 = 1;
10904 break;
10905
10906 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10907 salt_type = SALT_TYPE_EMBEDDED;
10908 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10909 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10910 kern_type = KERN_TYPE_ZIP2;
10911 dgst_size = DGST_SIZE_4_4;
10912 parse_func = zip2_parse_hash;
10913 sort_by_digest = sort_by_digest_4_4;
10914 opti_type = OPTI_TYPE_ZERO_BYTE;
10915 dgst_pos0 = 0;
10916 dgst_pos1 = 1;
10917 dgst_pos2 = 2;
10918 dgst_pos3 = 3;
10919 break;
10920
10921 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10922 salt_type = SALT_TYPE_EMBEDDED;
10923 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10924 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10925 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10926 dgst_size = DGST_SIZE_4_5;
10927 parse_func = veracrypt_parse_hash_655331;
10928 sort_by_digest = sort_by_digest_4_5;
10929 opti_type = OPTI_TYPE_ZERO_BYTE;
10930 dgst_pos0 = 0;
10931 dgst_pos1 = 1;
10932 dgst_pos2 = 2;
10933 dgst_pos3 = 3;
10934 break;
10935
10936 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10937 salt_type = SALT_TYPE_EMBEDDED;
10938 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10939 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10940 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10941 dgst_size = DGST_SIZE_4_5;
10942 parse_func = veracrypt_parse_hash_655331;
10943 sort_by_digest = sort_by_digest_4_5;
10944 opti_type = OPTI_TYPE_ZERO_BYTE;
10945 dgst_pos0 = 0;
10946 dgst_pos1 = 1;
10947 dgst_pos2 = 2;
10948 dgst_pos3 = 3;
10949 break;
10950
10951 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10952 salt_type = SALT_TYPE_EMBEDDED;
10953 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10954 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10955 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10956 dgst_size = DGST_SIZE_4_5;
10957 parse_func = veracrypt_parse_hash_655331;
10958 sort_by_digest = sort_by_digest_4_5;
10959 opti_type = OPTI_TYPE_ZERO_BYTE;
10960 dgst_pos0 = 0;
10961 dgst_pos1 = 1;
10962 dgst_pos2 = 2;
10963 dgst_pos3 = 3;
10964 break;
10965
10966 case 13721: hash_type = HASH_TYPE_SHA512;
10967 salt_type = SALT_TYPE_EMBEDDED;
10968 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10969 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10970 kern_type = KERN_TYPE_TCSHA512_XTS512;
10971 dgst_size = DGST_SIZE_8_8;
10972 parse_func = veracrypt_parse_hash_500000;
10973 sort_by_digest = sort_by_digest_8_8;
10974 opti_type = OPTI_TYPE_ZERO_BYTE
10975 | OPTI_TYPE_USES_BITS_64;
10976 dgst_pos0 = 0;
10977 dgst_pos1 = 1;
10978 dgst_pos2 = 2;
10979 dgst_pos3 = 3;
10980 break;
10981
10982 case 13722: hash_type = HASH_TYPE_SHA512;
10983 salt_type = SALT_TYPE_EMBEDDED;
10984 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10985 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10986 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10987 dgst_size = DGST_SIZE_8_8;
10988 parse_func = veracrypt_parse_hash_500000;
10989 sort_by_digest = sort_by_digest_8_8;
10990 opti_type = OPTI_TYPE_ZERO_BYTE
10991 | OPTI_TYPE_USES_BITS_64;
10992 dgst_pos0 = 0;
10993 dgst_pos1 = 1;
10994 dgst_pos2 = 2;
10995 dgst_pos3 = 3;
10996 break;
10997
10998 case 13723: hash_type = HASH_TYPE_SHA512;
10999 salt_type = SALT_TYPE_EMBEDDED;
11000 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11001 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11002 kern_type = KERN_TYPE_TCSHA512_XTS1536;
11003 dgst_size = DGST_SIZE_8_8;
11004 parse_func = veracrypt_parse_hash_500000;
11005 sort_by_digest = sort_by_digest_8_8;
11006 opti_type = OPTI_TYPE_ZERO_BYTE
11007 | OPTI_TYPE_USES_BITS_64;
11008 dgst_pos0 = 0;
11009 dgst_pos1 = 1;
11010 dgst_pos2 = 2;
11011 dgst_pos3 = 3;
11012 break;
11013
11014 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
11015 salt_type = SALT_TYPE_EMBEDDED;
11016 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11017 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11018 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
11019 dgst_size = DGST_SIZE_4_8;
11020 parse_func = veracrypt_parse_hash_500000;
11021 sort_by_digest = sort_by_digest_4_8;
11022 opti_type = OPTI_TYPE_ZERO_BYTE;
11023 dgst_pos0 = 0;
11024 dgst_pos1 = 1;
11025 dgst_pos2 = 2;
11026 dgst_pos3 = 3;
11027 break;
11028
11029 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
11030 salt_type = SALT_TYPE_EMBEDDED;
11031 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11032 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11033 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
11034 dgst_size = DGST_SIZE_4_8;
11035 parse_func = veracrypt_parse_hash_500000;
11036 sort_by_digest = sort_by_digest_4_8;
11037 opti_type = OPTI_TYPE_ZERO_BYTE;
11038 dgst_pos0 = 0;
11039 dgst_pos1 = 1;
11040 dgst_pos2 = 2;
11041 dgst_pos3 = 3;
11042 break;
11043
11044 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
11045 salt_type = SALT_TYPE_EMBEDDED;
11046 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11047 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11048 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
11049 dgst_size = DGST_SIZE_4_8;
11050 parse_func = veracrypt_parse_hash_500000;
11051 sort_by_digest = sort_by_digest_4_8;
11052 opti_type = OPTI_TYPE_ZERO_BYTE;
11053 dgst_pos0 = 0;
11054 dgst_pos1 = 1;
11055 dgst_pos2 = 2;
11056 dgst_pos3 = 3;
11057 break;
11058
11059 case 13741: hash_type = HASH_TYPE_RIPEMD160;
11060 salt_type = SALT_TYPE_EMBEDDED;
11061 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11062 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11063 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
11064 dgst_size = DGST_SIZE_4_5;
11065 parse_func = veracrypt_parse_hash_327661;
11066 sort_by_digest = sort_by_digest_4_5;
11067 opti_type = OPTI_TYPE_ZERO_BYTE;
11068 dgst_pos0 = 0;
11069 dgst_pos1 = 1;
11070 dgst_pos2 = 2;
11071 dgst_pos3 = 3;
11072 break;
11073
11074 case 13742: hash_type = HASH_TYPE_RIPEMD160;
11075 salt_type = SALT_TYPE_EMBEDDED;
11076 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11077 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11078 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
11079 dgst_size = DGST_SIZE_4_5;
11080 parse_func = veracrypt_parse_hash_327661;
11081 sort_by_digest = sort_by_digest_4_5;
11082 opti_type = OPTI_TYPE_ZERO_BYTE;
11083 dgst_pos0 = 0;
11084 dgst_pos1 = 1;
11085 dgst_pos2 = 2;
11086 dgst_pos3 = 3;
11087 break;
11088
11089 case 13743: hash_type = HASH_TYPE_RIPEMD160;
11090 salt_type = SALT_TYPE_EMBEDDED;
11091 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11092 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11093 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11094 dgst_size = DGST_SIZE_4_5;
11095 parse_func = veracrypt_parse_hash_327661;
11096 sort_by_digest = sort_by_digest_4_5;
11097 opti_type = OPTI_TYPE_ZERO_BYTE;
11098 dgst_pos0 = 0;
11099 dgst_pos1 = 1;
11100 dgst_pos2 = 2;
11101 dgst_pos3 = 3;
11102 break;
11103
11104 case 13751: hash_type = HASH_TYPE_SHA256;
11105 salt_type = SALT_TYPE_EMBEDDED;
11106 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11107 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11108 kern_type = KERN_TYPE_VCSHA256_XTS512;
11109 dgst_size = DGST_SIZE_4_8;
11110 parse_func = veracrypt_parse_hash_500000;
11111 sort_by_digest = sort_by_digest_4_8;
11112 opti_type = OPTI_TYPE_ZERO_BYTE;
11113 dgst_pos0 = 0;
11114 dgst_pos1 = 1;
11115 dgst_pos2 = 2;
11116 dgst_pos3 = 3;
11117 break;
11118
11119 case 13752: hash_type = HASH_TYPE_SHA256;
11120 salt_type = SALT_TYPE_EMBEDDED;
11121 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11122 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11123 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11124 dgst_size = DGST_SIZE_4_8;
11125 parse_func = veracrypt_parse_hash_500000;
11126 sort_by_digest = sort_by_digest_4_8;
11127 opti_type = OPTI_TYPE_ZERO_BYTE;
11128 dgst_pos0 = 0;
11129 dgst_pos1 = 1;
11130 dgst_pos2 = 2;
11131 dgst_pos3 = 3;
11132 break;
11133
11134 case 13753: hash_type = HASH_TYPE_SHA256;
11135 salt_type = SALT_TYPE_EMBEDDED;
11136 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11137 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11138 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11139 dgst_size = DGST_SIZE_4_8;
11140 parse_func = veracrypt_parse_hash_500000;
11141 sort_by_digest = sort_by_digest_4_8;
11142 opti_type = OPTI_TYPE_ZERO_BYTE;
11143 dgst_pos0 = 0;
11144 dgst_pos1 = 1;
11145 dgst_pos2 = 2;
11146 dgst_pos3 = 3;
11147 break;
11148
11149 case 13761: hash_type = HASH_TYPE_SHA256;
11150 salt_type = SALT_TYPE_EMBEDDED;
11151 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11152 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11153 kern_type = KERN_TYPE_VCSHA256_XTS512;
11154 dgst_size = DGST_SIZE_4_8;
11155 parse_func = veracrypt_parse_hash_200000;
11156 sort_by_digest = sort_by_digest_4_8;
11157 opti_type = OPTI_TYPE_ZERO_BYTE;
11158 dgst_pos0 = 0;
11159 dgst_pos1 = 1;
11160 dgst_pos2 = 2;
11161 dgst_pos3 = 3;
11162 break;
11163
11164 case 13762: hash_type = HASH_TYPE_SHA256;
11165 salt_type = SALT_TYPE_EMBEDDED;
11166 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11167 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11168 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11169 dgst_size = DGST_SIZE_4_8;
11170 parse_func = veracrypt_parse_hash_200000;
11171 sort_by_digest = sort_by_digest_4_8;
11172 opti_type = OPTI_TYPE_ZERO_BYTE;
11173 dgst_pos0 = 0;
11174 dgst_pos1 = 1;
11175 dgst_pos2 = 2;
11176 dgst_pos3 = 3;
11177 break;
11178
11179 case 13763: hash_type = HASH_TYPE_SHA256;
11180 salt_type = SALT_TYPE_EMBEDDED;
11181 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11182 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11183 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11184 dgst_size = DGST_SIZE_4_8;
11185 parse_func = veracrypt_parse_hash_200000;
11186 sort_by_digest = sort_by_digest_4_8;
11187 opti_type = OPTI_TYPE_ZERO_BYTE;
11188 dgst_pos0 = 0;
11189 dgst_pos1 = 1;
11190 dgst_pos2 = 2;
11191 dgst_pos3 = 3;
11192 break;
11193
11194 case 13800: hash_type = HASH_TYPE_SHA256;
11195 salt_type = SALT_TYPE_EMBEDDED;
11196 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11197 opts_type = OPTS_TYPE_PT_GENERATE_BE
11198 | OPTS_TYPE_PT_UNICODE;
11199 kern_type = KERN_TYPE_WIN8PHONE;
11200 dgst_size = DGST_SIZE_4_8;
11201 parse_func = win8phone_parse_hash;
11202 sort_by_digest = sort_by_digest_4_8;
11203 opti_type = OPTI_TYPE_ZERO_BYTE
11204 | OPTI_TYPE_PRECOMPUTE_INIT
11205 | OPTI_TYPE_EARLY_SKIP
11206 | OPTI_TYPE_NOT_ITERATED
11207 | OPTI_TYPE_RAW_HASH;
11208 dgst_pos0 = 3;
11209 dgst_pos1 = 7;
11210 dgst_pos2 = 2;
11211 dgst_pos3 = 6;
11212 break;
11213
11214 default: usage_mini_print (PROGNAME); return (-1);
11215 }
11216
11217 /**
11218 * parser
11219 */
11220
11221 data.parse_func = parse_func;
11222
11223 /**
11224 * misc stuff
11225 */
11226
11227 if (hex_salt)
11228 {
11229 if (salt_type == SALT_TYPE_INTERN)
11230 {
11231 opts_type |= OPTS_TYPE_ST_HEX;
11232 }
11233 else
11234 {
11235 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11236
11237 return (-1);
11238 }
11239 }
11240
11241 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11242 | (salt_type == SALT_TYPE_EXTERN)
11243 | (salt_type == SALT_TYPE_EMBEDDED)
11244 | (salt_type == SALT_TYPE_VIRTUAL));
11245
11246 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
11247
11248 data.hash_type = hash_type;
11249 data.attack_mode = attack_mode;
11250 data.attack_kern = attack_kern;
11251 data.attack_exec = attack_exec;
11252 data.kern_type = kern_type;
11253 data.opts_type = opts_type;
11254 data.dgst_size = dgst_size;
11255 data.salt_type = salt_type;
11256 data.isSalted = isSalted;
11257 data.sort_by_digest = sort_by_digest;
11258 data.dgst_pos0 = dgst_pos0;
11259 data.dgst_pos1 = dgst_pos1;
11260 data.dgst_pos2 = dgst_pos2;
11261 data.dgst_pos3 = dgst_pos3;
11262
11263 esalt_size = 0;
11264
11265 switch (hash_mode)
11266 {
11267 case 2500: esalt_size = sizeof (wpa_t); break;
11268 case 5300: esalt_size = sizeof (ikepsk_t); break;
11269 case 5400: esalt_size = sizeof (ikepsk_t); break;
11270 case 5500: esalt_size = sizeof (netntlm_t); break;
11271 case 5600: esalt_size = sizeof (netntlm_t); break;
11272 case 6211: esalt_size = sizeof (tc_t); break;
11273 case 6212: esalt_size = sizeof (tc_t); break;
11274 case 6213: esalt_size = sizeof (tc_t); break;
11275 case 6221: esalt_size = sizeof (tc_t); break;
11276 case 6222: esalt_size = sizeof (tc_t); break;
11277 case 6223: esalt_size = sizeof (tc_t); break;
11278 case 6231: esalt_size = sizeof (tc_t); break;
11279 case 6232: esalt_size = sizeof (tc_t); break;
11280 case 6233: esalt_size = sizeof (tc_t); break;
11281 case 6241: esalt_size = sizeof (tc_t); break;
11282 case 6242: esalt_size = sizeof (tc_t); break;
11283 case 6243: esalt_size = sizeof (tc_t); break;
11284 case 6600: esalt_size = sizeof (agilekey_t); break;
11285 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11286 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
11287 case 7300: esalt_size = sizeof (rakp_t); break;
11288 case 7500: esalt_size = sizeof (krb5pa_t); break;
11289 case 8200: esalt_size = sizeof (cloudkey_t); break;
11290 case 8800: esalt_size = sizeof (androidfde_t); break;
11291 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
11292 case 9400: esalt_size = sizeof (office2007_t); break;
11293 case 9500: esalt_size = sizeof (office2010_t); break;
11294 case 9600: esalt_size = sizeof (office2013_t); break;
11295 case 9700: esalt_size = sizeof (oldoffice01_t); break;
11296 case 9710: esalt_size = sizeof (oldoffice01_t); break;
11297 case 9720: esalt_size = sizeof (oldoffice01_t); break;
11298 case 9800: esalt_size = sizeof (oldoffice34_t); break;
11299 case 9810: esalt_size = sizeof (oldoffice34_t); break;
11300 case 9820: esalt_size = sizeof (oldoffice34_t); break;
11301 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
11302 case 10200: esalt_size = sizeof (cram_md5_t); break;
11303 case 10400: esalt_size = sizeof (pdf_t); break;
11304 case 10410: esalt_size = sizeof (pdf_t); break;
11305 case 10420: esalt_size = sizeof (pdf_t); break;
11306 case 10500: esalt_size = sizeof (pdf_t); break;
11307 case 10600: esalt_size = sizeof (pdf_t); break;
11308 case 10700: esalt_size = sizeof (pdf_t); break;
11309 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
11310 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
11311 case 11400: esalt_size = sizeof (sip_t); break;
11312 case 11600: esalt_size = sizeof (seven_zip_t); break;
11313 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
11314 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
11315 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11316 case 13000: esalt_size = sizeof (rar5_t); break;
11317 case 13100: esalt_size = sizeof (krb5tgs_t); break;
11318 case 13400: esalt_size = sizeof (keepass_t); break;
11319 case 13500: esalt_size = sizeof (pstoken_t); break;
11320 case 13600: esalt_size = sizeof (zip2_t); break;
11321 case 13711: esalt_size = sizeof (tc_t); break;
11322 case 13712: esalt_size = sizeof (tc_t); break;
11323 case 13713: esalt_size = sizeof (tc_t); break;
11324 case 13721: esalt_size = sizeof (tc_t); break;
11325 case 13722: esalt_size = sizeof (tc_t); break;
11326 case 13723: esalt_size = sizeof (tc_t); break;
11327 case 13731: esalt_size = sizeof (tc_t); break;
11328 case 13732: esalt_size = sizeof (tc_t); break;
11329 case 13733: esalt_size = sizeof (tc_t); break;
11330 case 13741: esalt_size = sizeof (tc_t); break;
11331 case 13742: esalt_size = sizeof (tc_t); break;
11332 case 13743: esalt_size = sizeof (tc_t); break;
11333 case 13751: esalt_size = sizeof (tc_t); break;
11334 case 13752: esalt_size = sizeof (tc_t); break;
11335 case 13753: esalt_size = sizeof (tc_t); break;
11336 case 13761: esalt_size = sizeof (tc_t); break;
11337 case 13762: esalt_size = sizeof (tc_t); break;
11338 case 13763: esalt_size = sizeof (tc_t); break;
11339 case 13800: esalt_size = sizeof (win8phone_t); break;
11340 }
11341
11342 data.esalt_size = esalt_size;
11343
11344 /**
11345 * choose dictionary parser
11346 */
11347
11348 if (hash_type == HASH_TYPE_LM)
11349 {
11350 get_next_word_func = get_next_word_lm;
11351 }
11352 else if (opts_type & OPTS_TYPE_PT_UPPER)
11353 {
11354 get_next_word_func = get_next_word_uc;
11355 }
11356 else
11357 {
11358 get_next_word_func = get_next_word_std;
11359 }
11360
11361 /**
11362 * dictstat
11363 */
11364
11365 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11366
11367 #ifdef _POSIX
11368 size_t dictstat_nmemb = 0;
11369 #endif
11370
11371 #ifdef _WIN
11372 uint dictstat_nmemb = 0;
11373 #endif
11374
11375 char dictstat[256] = { 0 };
11376
11377 FILE *dictstat_fp = NULL;
11378
11379 if (keyspace == 0)
11380 {
11381 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11382
11383 dictstat_fp = fopen (dictstat, "rb");
11384
11385 if (dictstat_fp)
11386 {
11387 #ifdef _POSIX
11388 struct stat tmpstat;
11389
11390 fstat (fileno (dictstat_fp), &tmpstat);
11391 #endif
11392
11393 #ifdef _WIN
11394 struct stat64 tmpstat;
11395
11396 _fstat64 (fileno (dictstat_fp), &tmpstat);
11397 #endif
11398
11399 if (tmpstat.st_mtime < COMPTIME)
11400 {
11401 /* with v0.15 the format changed so we have to ensure user is using a good version
11402 since there is no version-header in the dictstat file */
11403
11404 fclose (dictstat_fp);
11405
11406 unlink (dictstat);
11407 }
11408 else
11409 {
11410 while (!feof (dictstat_fp))
11411 {
11412 dictstat_t d;
11413
11414 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11415
11416 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11417
11418 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11419 {
11420 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11421
11422 return -1;
11423 }
11424 }
11425
11426 fclose (dictstat_fp);
11427 }
11428 }
11429 }
11430
11431 /**
11432 * potfile
11433 */
11434
11435 char potfile[256] = { 0 };
11436
11437 if (potfile_path == NULL)
11438 {
11439 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11440 }
11441 else
11442 {
11443 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11444 }
11445
11446 data.pot_fp = NULL;
11447
11448 FILE *out_fp = NULL;
11449 FILE *pot_fp = NULL;
11450
11451 if (show == 1 || left == 1)
11452 {
11453 pot_fp = fopen (potfile, "rb");
11454
11455 if (pot_fp == NULL)
11456 {
11457 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11458
11459 return (-1);
11460 }
11461
11462 if (outfile != NULL)
11463 {
11464 if ((out_fp = fopen (outfile, "ab")) == NULL)
11465 {
11466 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11467
11468 fclose (pot_fp);
11469
11470 return (-1);
11471 }
11472 }
11473 else
11474 {
11475 out_fp = stdout;
11476 }
11477 }
11478 else
11479 {
11480 if (potfile_disable == 0)
11481 {
11482 pot_fp = fopen (potfile, "ab");
11483
11484 if (pot_fp == NULL)
11485 {
11486 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11487
11488 return (-1);
11489 }
11490
11491 data.pot_fp = pot_fp;
11492 }
11493 }
11494
11495 pot_t *pot = NULL;
11496
11497 uint pot_cnt = 0;
11498 uint pot_avail = 0;
11499
11500 if (show == 1 || left == 1)
11501 {
11502 SUPPRESS_OUTPUT = 1;
11503
11504 pot_avail = count_lines (pot_fp);
11505
11506 rewind (pot_fp);
11507
11508 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11509
11510 uint pot_hashes_avail = 0;
11511
11512 uint line_num = 0;
11513
11514 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11515
11516 while (!feof (pot_fp))
11517 {
11518 line_num++;
11519
11520 int line_len = fgetl (pot_fp, line_buf);
11521
11522 if (line_len == 0) continue;
11523
11524 char *plain_buf = line_buf + line_len;
11525
11526 pot_t *pot_ptr = &pot[pot_cnt];
11527
11528 hash_t *hashes_buf = &pot_ptr->hash;
11529
11530 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11531 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11532
11533 if (pot_cnt == pot_hashes_avail)
11534 {
11535 uint pos = 0;
11536
11537 for (pos = 0; pos < INCR_POT; pos++)
11538 {
11539 if ((pot_cnt + pos) >= pot_avail) break;
11540
11541 pot_t *tmp_pot = &pot[pot_cnt + pos];
11542
11543 hash_t *tmp_hash = &tmp_pot->hash;
11544
11545 tmp_hash->digest = mymalloc (dgst_size);
11546
11547 if (isSalted)
11548 {
11549 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11550 }
11551
11552 if (esalt_size)
11553 {
11554 tmp_hash->esalt = mymalloc (esalt_size);
11555 }
11556
11557 pot_hashes_avail++;
11558 }
11559 }
11560
11561 int plain_len = 0;
11562
11563 int parser_status;
11564
11565 int iter = MAX_CUT_TRIES;
11566
11567 do
11568 {
11569 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11570 {
11571 if (line_buf[i] == ':')
11572 {
11573 line_len--;
11574
11575 break;
11576 }
11577 }
11578
11579 if (data.hash_mode != 2500)
11580 {
11581 parser_status = parse_func (line_buf, line_len, hashes_buf);
11582 }
11583 else
11584 {
11585 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11586
11587 if (line_len > max_salt_size)
11588 {
11589 parser_status = PARSER_GLOBAL_LENGTH;
11590 }
11591 else
11592 {
11593 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11594
11595 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11596
11597 hashes_buf->salt->salt_len = line_len;
11598
11599 parser_status = PARSER_OK;
11600 }
11601 }
11602
11603 // if NOT parsed without error, we add the ":" to the plain
11604
11605 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11606 {
11607 plain_len++;
11608 plain_buf--;
11609 }
11610
11611 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11612
11613 if (parser_status < PARSER_GLOBAL_ZERO)
11614 {
11615 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11616
11617 continue;
11618 }
11619
11620 if (plain_len >= 255) continue;
11621
11622 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11623
11624 pot_ptr->plain_len = plain_len;
11625
11626 pot_cnt++;
11627 }
11628
11629 myfree (line_buf);
11630
11631 fclose (pot_fp);
11632
11633 SUPPRESS_OUTPUT = 0;
11634
11635 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11636 }
11637
11638 /**
11639 * word len
11640 */
11641
11642 uint pw_min = PW_MIN;
11643 uint pw_max = PW_MAX;
11644
11645 switch (hash_mode)
11646 {
11647 case 125: if (pw_max > 32) pw_max = 32;
11648 break;
11649 case 400: if (pw_max > 40) pw_max = 40;
11650 break;
11651 case 500: if (pw_max > 16) pw_max = 16;
11652 break;
11653 case 1500: if (pw_max > 8) pw_max = 8;
11654 break;
11655 case 1600: if (pw_max > 16) pw_max = 16;
11656 break;
11657 case 1800: if (pw_max > 16) pw_max = 16;
11658 break;
11659 case 2100: if (pw_max > 16) pw_max = 16;
11660 break;
11661 case 2500: if (pw_min < 8) pw_min = 8;
11662 break;
11663 case 3000: if (pw_max > 7) pw_max = 7;
11664 break;
11665 case 5200: if (pw_max > 24) pw_max = 24;
11666 break;
11667 case 5800: if (pw_max > 16) pw_max = 16;
11668 break;
11669 case 6300: if (pw_max > 16) pw_max = 16;
11670 break;
11671 case 7400: if (pw_max > 16) pw_max = 16;
11672 break;
11673 case 7700: if (pw_max > 8) pw_max = 8;
11674 break;
11675 case 7900: if (pw_max > 48) pw_max = 48;
11676 break;
11677 case 8500: if (pw_max > 8) pw_max = 8;
11678 break;
11679 case 8600: if (pw_max > 16) pw_max = 16;
11680 break;
11681 case 9710: pw_min = 5;
11682 pw_max = 5;
11683 break;
11684 case 9810: pw_min = 5;
11685 pw_max = 5;
11686 break;
11687 case 10410: pw_min = 5;
11688 pw_max = 5;
11689 break;
11690 case 10300: if (pw_max < 3) pw_min = 3;
11691 if (pw_max > 40) pw_max = 40;
11692 break;
11693 case 10500: if (pw_max < 3) pw_min = 3;
11694 if (pw_max > 40) pw_max = 40;
11695 break;
11696 case 10700: if (pw_max > 16) pw_max = 16;
11697 break;
11698 case 11300: if (pw_max > 40) pw_max = 40;
11699 break;
11700 case 11600: if (pw_max > 32) pw_max = 32;
11701 break;
11702 case 12500: if (pw_max > 20) pw_max = 20;
11703 break;
11704 case 12800: if (pw_max > 24) pw_max = 24;
11705 break;
11706 }
11707
11708 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11709 {
11710 switch (attack_kern)
11711 {
11712 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11713 break;
11714 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11715 break;
11716 }
11717 }
11718
11719 /**
11720 * charsets : keep them together for more easy maintainnce
11721 */
11722
11723 cs_t mp_sys[6] = { { { 0 }, 0 } };
11724 cs_t mp_usr[4] = { { { 0 }, 0 } };
11725
11726 mp_setup_sys (mp_sys);
11727
11728 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11729 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11730 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11731 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11732
11733 /**
11734 * load hashes, part I: find input mode, count hashes
11735 */
11736
11737 uint hashlist_mode = 0;
11738 uint hashlist_format = HLFMT_HASHCAT;
11739
11740 uint hashes_avail = 0;
11741
11742 if ((benchmark == 0) && (stdout_flag == 0))
11743 {
11744 struct stat f;
11745
11746 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11747
11748 if ((hash_mode == 2500) ||
11749 (hash_mode == 5200) ||
11750 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11751 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11752 (hash_mode == 9000))
11753 {
11754 hashlist_mode = HL_MODE_ARG;
11755
11756 char *hashfile = myargv[optind];
11757
11758 data.hashfile = hashfile;
11759
11760 logfile_top_var_string ("target", hashfile);
11761 }
11762
11763 if (hashlist_mode == HL_MODE_ARG)
11764 {
11765 if (hash_mode == 2500)
11766 {
11767 struct stat st;
11768
11769 if (stat (data.hashfile, &st) == -1)
11770 {
11771 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11772
11773 return (-1);
11774 }
11775
11776 hashes_avail = st.st_size / sizeof (hccap_t);
11777 }
11778 else
11779 {
11780 hashes_avail = 1;
11781 }
11782 }
11783 else if (hashlist_mode == HL_MODE_FILE)
11784 {
11785 char *hashfile = myargv[optind];
11786
11787 data.hashfile = hashfile;
11788
11789 logfile_top_var_string ("target", hashfile);
11790
11791 FILE *fp = NULL;
11792
11793 if ((fp = fopen (hashfile, "rb")) == NULL)
11794 {
11795 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11796
11797 return (-1);
11798 }
11799
11800 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11801
11802 hashes_avail = count_lines (fp);
11803
11804 rewind (fp);
11805
11806 if (hashes_avail == 0)
11807 {
11808 log_error ("ERROR: hashfile is empty or corrupt");
11809
11810 fclose (fp);
11811
11812 return (-1);
11813 }
11814
11815 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11816
11817 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11818 {
11819 log_error ("ERROR: remove not supported in native hashfile-format mode");
11820
11821 fclose (fp);
11822
11823 return (-1);
11824 }
11825
11826 fclose (fp);
11827 }
11828 }
11829 else
11830 {
11831 hashlist_mode = HL_MODE_ARG;
11832
11833 hashes_avail = 1;
11834 }
11835
11836 if (hash_mode == 3000) hashes_avail *= 2;
11837
11838 data.hashlist_mode = hashlist_mode;
11839 data.hashlist_format = hashlist_format;
11840
11841 logfile_top_uint (hashlist_mode);
11842 logfile_top_uint (hashlist_format);
11843
11844 /**
11845 * load hashes, part II: allocate required memory, set pointers
11846 */
11847
11848 hash_t *hashes_buf = NULL;
11849 void *digests_buf = NULL;
11850 salt_t *salts_buf = NULL;
11851 void *esalts_buf = NULL;
11852
11853 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11854
11855 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11856
11857 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11858 {
11859 u32 hash_pos;
11860
11861 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11862 {
11863 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11864
11865 hashes_buf[hash_pos].hash_info = hash_info;
11866
11867 if (username && (remove || show || left))
11868 {
11869 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11870 }
11871
11872 if (benchmark)
11873 {
11874 hash_info->orighash = (char *) mymalloc (256);
11875 }
11876 }
11877 }
11878
11879 if (isSalted)
11880 {
11881 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11882
11883 if (esalt_size)
11884 {
11885 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11886 }
11887 }
11888 else
11889 {
11890 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11891 }
11892
11893 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11894 {
11895 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11896
11897 if (isSalted)
11898 {
11899 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11900
11901 if (esalt_size)
11902 {
11903 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11904 }
11905 }
11906 else
11907 {
11908 hashes_buf[hash_pos].salt = &salts_buf[0];
11909 }
11910 }
11911
11912 /**
11913 * load hashes, part III: parse hashes or generate them if benchmark
11914 */
11915
11916 uint hashes_cnt = 0;
11917
11918 if (benchmark == 0)
11919 {
11920 if (keyspace == 1)
11921 {
11922 // useless to read hash file for keyspace, cheat a little bit w/ optind
11923 }
11924 else if (stdout_flag == 1)
11925 {
11926 // useless to read hash file for stdout, cheat a little bit w/ optind
11927 }
11928 else if (hashes_avail == 0)
11929 {
11930 }
11931 else if (hashlist_mode == HL_MODE_ARG)
11932 {
11933 char *input_buf = myargv[optind];
11934
11935 uint input_len = strlen (input_buf);
11936
11937 logfile_top_var_string ("target", input_buf);
11938
11939 char *hash_buf = NULL;
11940 int hash_len = 0;
11941
11942 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11943
11944 bool hash_fmt_error = 0;
11945
11946 if (hash_len < 1) hash_fmt_error = 1;
11947 if (hash_buf == NULL) hash_fmt_error = 1;
11948
11949 if (hash_fmt_error)
11950 {
11951 log_info ("WARNING: Failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11952 }
11953 else
11954 {
11955 if (opts_type & OPTS_TYPE_HASH_COPY)
11956 {
11957 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11958
11959 hash_info_tmp->orighash = mystrdup (hash_buf);
11960 }
11961
11962 if (isSalted)
11963 {
11964 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11965 }
11966
11967 int parser_status = PARSER_OK;
11968
11969 if (hash_mode == 2500)
11970 {
11971 if (hash_len == 0)
11972 {
11973 log_error ("ERROR: hccap file not specified");
11974
11975 return (-1);
11976 }
11977
11978 hashlist_mode = HL_MODE_FILE;
11979
11980 data.hashlist_mode = hashlist_mode;
11981
11982 FILE *fp = fopen (hash_buf, "rb");
11983
11984 if (fp == NULL)
11985 {
11986 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11987
11988 return (-1);
11989 }
11990
11991 if (hashes_avail < 1)
11992 {
11993 log_error ("ERROR: hccap file is empty or corrupt");
11994
11995 fclose (fp);
11996
11997 return (-1);
11998 }
11999
12000 uint hccap_size = sizeof (hccap_t);
12001
12002 char *in = (char *) mymalloc (hccap_size);
12003
12004 while (!feof (fp))
12005 {
12006 int n = fread (in, hccap_size, 1, fp);
12007
12008 if (n != 1)
12009 {
12010 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
12011
12012 break;
12013 }
12014
12015 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
12016
12017 if (parser_status != PARSER_OK)
12018 {
12019 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
12020
12021 continue;
12022 }
12023
12024 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
12025
12026 if ((show == 1) || (left == 1))
12027 {
12028 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
12029
12030 char *salt_ptr = (char *) tmp_salt->salt_buf;
12031
12032 int cur_pos = tmp_salt->salt_len;
12033 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12034
12035 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
12036
12037 // do the appending task
12038
12039 snprintf (salt_ptr + cur_pos,
12040 rem_len,
12041 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
12042 wpa->orig_mac1[0],
12043 wpa->orig_mac1[1],
12044 wpa->orig_mac1[2],
12045 wpa->orig_mac1[3],
12046 wpa->orig_mac1[4],
12047 wpa->orig_mac1[5],
12048 wpa->orig_mac2[0],
12049 wpa->orig_mac2[1],
12050 wpa->orig_mac2[2],
12051 wpa->orig_mac2[3],
12052 wpa->orig_mac2[4],
12053 wpa->orig_mac2[5]);
12054
12055 // memset () the remaining part of the salt
12056
12057 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
12058 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12059
12060 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
12061
12062 tmp_salt->salt_len += 1 + 12 + 1 + 12;
12063 }
12064
12065 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);
12066 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);
12067
12068 hashes_cnt++;
12069 }
12070
12071 fclose (fp);
12072
12073 myfree (in);
12074 }
12075 else if (hash_mode == 3000)
12076 {
12077 if (hash_len == 32)
12078 {
12079 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12080
12081 hash_t *lm_hash_left = NULL;
12082
12083 if (parser_status == PARSER_OK)
12084 {
12085 lm_hash_left = &hashes_buf[hashes_cnt];
12086
12087 hashes_cnt++;
12088 }
12089 else
12090 {
12091 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12092 }
12093
12094 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12095
12096 hash_t *lm_hash_right = NULL;
12097
12098 if (parser_status == PARSER_OK)
12099 {
12100 lm_hash_right = &hashes_buf[hashes_cnt];
12101
12102 hashes_cnt++;
12103 }
12104 else
12105 {
12106 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12107 }
12108
12109 // show / left
12110
12111 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12112 {
12113 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);
12114 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);
12115 }
12116 }
12117 else
12118 {
12119 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12120
12121 if (parser_status == PARSER_OK)
12122 {
12123 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12124 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12125 }
12126
12127 if (parser_status == PARSER_OK)
12128 {
12129 hashes_cnt++;
12130 }
12131 else
12132 {
12133 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12134 }
12135 }
12136 }
12137 else
12138 {
12139 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12140
12141 if (parser_status == PARSER_OK)
12142 {
12143 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12144 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12145 }
12146
12147 if (parser_status == PARSER_OK)
12148 {
12149 hashes_cnt++;
12150 }
12151 else
12152 {
12153 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12154 }
12155 }
12156 }
12157 }
12158 else if (hashlist_mode == HL_MODE_FILE)
12159 {
12160 char *hashfile = data.hashfile;
12161
12162 FILE *fp;
12163
12164 if ((fp = fopen (hashfile, "rb")) == NULL)
12165 {
12166 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12167
12168 return (-1);
12169 }
12170
12171 uint line_num = 0;
12172
12173 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12174
12175 while (!feof (fp))
12176 {
12177 line_num++;
12178
12179 int line_len = fgetl (fp, line_buf);
12180
12181 if (line_len == 0) continue;
12182
12183 char *hash_buf = NULL;
12184 int hash_len = 0;
12185
12186 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12187
12188 bool hash_fmt_error = 0;
12189
12190 if (hash_len < 1) hash_fmt_error = 1;
12191 if (hash_buf == NULL) hash_fmt_error = 1;
12192
12193 if (hash_fmt_error)
12194 {
12195 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12196
12197 continue;
12198 }
12199
12200 if (username)
12201 {
12202 char *user_buf = NULL;
12203 int user_len = 0;
12204
12205 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12206
12207 if (remove || show)
12208 {
12209 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12210
12211 *user = (user_t *) mymalloc (sizeof (user_t));
12212
12213 user_t *user_ptr = *user;
12214
12215 if (user_buf != NULL)
12216 {
12217 user_ptr->user_name = mystrdup (user_buf);
12218 }
12219 else
12220 {
12221 user_ptr->user_name = mystrdup ("");
12222 }
12223
12224 user_ptr->user_len = user_len;
12225 }
12226 }
12227
12228 if (opts_type & OPTS_TYPE_HASH_COPY)
12229 {
12230 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12231
12232 hash_info_tmp->orighash = mystrdup (hash_buf);
12233 }
12234
12235 if (isSalted)
12236 {
12237 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12238 }
12239
12240 if (hash_mode == 3000)
12241 {
12242 if (hash_len == 32)
12243 {
12244 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12245
12246 if (parser_status < PARSER_GLOBAL_ZERO)
12247 {
12248 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12249
12250 continue;
12251 }
12252
12253 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12254
12255 hashes_cnt++;
12256
12257 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12258
12259 if (parser_status < PARSER_GLOBAL_ZERO)
12260 {
12261 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12262
12263 continue;
12264 }
12265
12266 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12267
12268 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);
12269
12270 hashes_cnt++;
12271
12272 // show / left
12273
12274 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);
12275 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);
12276 }
12277 else
12278 {
12279 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12280
12281 if (parser_status < PARSER_GLOBAL_ZERO)
12282 {
12283 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12284
12285 continue;
12286 }
12287
12288 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);
12289
12290 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12291 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12292
12293 hashes_cnt++;
12294 }
12295 }
12296 else
12297 {
12298 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12299
12300 if (parser_status < PARSER_GLOBAL_ZERO)
12301 {
12302 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12303
12304 continue;
12305 }
12306
12307 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);
12308
12309 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12310 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12311
12312 hashes_cnt++;
12313 }
12314 }
12315
12316 myfree (line_buf);
12317
12318 fclose (fp);
12319
12320 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12321
12322 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12323 }
12324 }
12325 else
12326 {
12327 if (isSalted)
12328 {
12329 hashes_buf[0].salt->salt_len = 8;
12330
12331 // special salt handling
12332
12333 switch (hash_mode)
12334 {
12335 case 1500: hashes_buf[0].salt->salt_len = 2;
12336 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12337 break;
12338 case 1731: hashes_buf[0].salt->salt_len = 4;
12339 break;
12340 case 2410: hashes_buf[0].salt->salt_len = 4;
12341 break;
12342 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12343 break;
12344 case 3100: hashes_buf[0].salt->salt_len = 1;
12345 break;
12346 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
12347 break;
12348 case 5800: hashes_buf[0].salt->salt_len = 16;
12349 break;
12350 case 6800: hashes_buf[0].salt->salt_len = 32;
12351 break;
12352 case 8400: hashes_buf[0].salt->salt_len = 40;
12353 break;
12354 case 8800: hashes_buf[0].salt->salt_len = 16;
12355 break;
12356 case 8900: hashes_buf[0].salt->salt_len = 16;
12357 hashes_buf[0].salt->scrypt_N = 1024;
12358 hashes_buf[0].salt->scrypt_r = 1;
12359 hashes_buf[0].salt->scrypt_p = 1;
12360 break;
12361 case 9100: hashes_buf[0].salt->salt_len = 16;
12362 break;
12363 case 9300: hashes_buf[0].salt->salt_len = 14;
12364 hashes_buf[0].salt->scrypt_N = 16384;
12365 hashes_buf[0].salt->scrypt_r = 1;
12366 hashes_buf[0].salt->scrypt_p = 1;
12367 break;
12368 case 9400: hashes_buf[0].salt->salt_len = 16;
12369 break;
12370 case 9500: hashes_buf[0].salt->salt_len = 16;
12371 break;
12372 case 9600: hashes_buf[0].salt->salt_len = 16;
12373 break;
12374 case 9700: hashes_buf[0].salt->salt_len = 16;
12375 break;
12376 case 9710: hashes_buf[0].salt->salt_len = 16;
12377 break;
12378 case 9720: hashes_buf[0].salt->salt_len = 16;
12379 break;
12380 case 9800: hashes_buf[0].salt->salt_len = 16;
12381 break;
12382 case 9810: hashes_buf[0].salt->salt_len = 16;
12383 break;
12384 case 9820: hashes_buf[0].salt->salt_len = 16;
12385 break;
12386 case 10300: hashes_buf[0].salt->salt_len = 12;
12387 break;
12388 case 11500: hashes_buf[0].salt->salt_len = 4;
12389 break;
12390 case 11600: hashes_buf[0].salt->salt_len = 4;
12391 break;
12392 case 12400: hashes_buf[0].salt->salt_len = 4;
12393 break;
12394 case 12500: hashes_buf[0].salt->salt_len = 8;
12395 break;
12396 case 12600: hashes_buf[0].salt->salt_len = 64;
12397 break;
12398 }
12399
12400 // special esalt handling
12401
12402 switch (hash_mode)
12403 {
12404 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12405 break;
12406 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12407 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12408 break;
12409 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12410 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12411 break;
12412 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12413 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12414 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12415 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12416 break;
12417 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12418 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12419 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12420 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12421 break;
12422 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12423 break;
12424 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12425 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12426 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12427 break;
12428 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12429 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12430 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12431 break;
12432 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12433 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12434 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12435 break;
12436 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12437 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12438 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12439 break;
12440 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12441 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12442 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12443 break;
12444 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12445 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12446 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12447 break;
12448 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12449 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12450 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12451 break;
12452 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12453 break;
12454 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12455 break;
12456 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12457 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12458 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12459 break;
12460 }
12461 }
12462
12463 // set hashfile
12464
12465 switch (hash_mode)
12466 {
12467 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12468 break;
12469 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12470 break;
12471 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12472 break;
12473 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12474 break;
12475 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12476 break;
12477 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12478 break;
12479 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12480 break;
12481 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12482 break;
12483 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12484 break;
12485 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12486 break;
12487 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12488 break;
12489 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12490 break;
12491 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12492 break;
12493 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12494 break;
12495 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12496 break;
12497 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12498 break;
12499 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12500 break;
12501 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12502 break;
12503 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12504 break;
12505 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12506 break;
12507 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12508 break;
12509 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12510 break;
12511 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12512 break;
12513 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12514 break;
12515 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12516 break;
12517 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12518 break;
12519 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12520 break;
12521 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12522 break;
12523 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12524 break;
12525 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12526 break;
12527 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12528 break;
12529 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12530 break;
12531 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12532 break;
12533 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12534 break;
12535 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12536 break;
12537 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12538 break;
12539 }
12540
12541 // set default iterations
12542
12543 switch (hash_mode)
12544 {
12545 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12546 break;
12547 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12548 break;
12549 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12550 break;
12551 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12552 break;
12553 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12554 break;
12555 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12556 break;
12557 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12558 break;
12559 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12560 break;
12561 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12562 break;
12563 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12564 break;
12565 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12566 break;
12567 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12568 break;
12569 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12570 break;
12571 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12572 break;
12573 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12574 break;
12575 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12576 break;
12577 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12578 break;
12579 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12580 break;
12581 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12582 break;
12583 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12584 break;
12585 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12586 break;
12587 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12588 break;
12589 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12590 break;
12591 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12592 break;
12593 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12594 break;
12595 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12596 break;
12597 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12598 break;
12599 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12600 break;
12601 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12602 break;
12603 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12604 break;
12605 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12606 break;
12607 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12608 break;
12609 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12610 break;
12611 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12612 break;
12613 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12614 break;
12615 case 8900: hashes_buf[0].salt->salt_iter = 1;
12616 break;
12617 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12618 break;
12619 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12620 break;
12621 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12622 break;
12623 case 9300: hashes_buf[0].salt->salt_iter = 1;
12624 break;
12625 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12626 break;
12627 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12628 break;
12629 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12630 break;
12631 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12632 break;
12633 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12634 break;
12635 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12636 break;
12637 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12638 break;
12639 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12640 break;
12641 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12642 break;
12643 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12644 break;
12645 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12646 break;
12647 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12648 break;
12649 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12650 break;
12651 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12652 break;
12653 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12654 break;
12655 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12656 break;
12657 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12658 break;
12659 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12660 break;
12661 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12662 break;
12663 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12664 break;
12665 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12666 break;
12667 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12668 break;
12669 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12670 break;
12671 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12672 break;
12673 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12674 break;
12675 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12676 break;
12677 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12678 break;
12679 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12680 break;
12681 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12682 break;
12683 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12684 break;
12685 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12686 break;
12687 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12688 break;
12689 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12690 break;
12691 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12692 break;
12693 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12694 break;
12695 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12696 break;
12697 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12698 break;
12699 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12700 break;
12701 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12702 break;
12703 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12704 break;
12705 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12706 break;
12707 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12708 break;
12709 }
12710
12711 hashes_cnt = 1;
12712 }
12713
12714 if (show == 1 || left == 1)
12715 {
12716 for (uint i = 0; i < pot_cnt; i++)
12717 {
12718 pot_t *pot_ptr = &pot[i];
12719
12720 hash_t *hashes_buf = &pot_ptr->hash;
12721
12722 local_free (hashes_buf->digest);
12723
12724 if (isSalted)
12725 {
12726 local_free (hashes_buf->salt);
12727 }
12728 }
12729
12730 local_free (pot);
12731
12732 if (data.quiet == 0) log_info_nn ("");
12733
12734 return (0);
12735 }
12736
12737 if ((keyspace == 0) && (stdout_flag == 0))
12738 {
12739 if (hashes_cnt == 0)
12740 {
12741 log_error ("ERROR: No hashes loaded");
12742
12743 return (-1);
12744 }
12745 }
12746
12747 /**
12748 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12749 */
12750
12751 if (data.outfile != NULL)
12752 {
12753 if (data.hashfile != NULL)
12754 {
12755 #ifdef _POSIX
12756 struct stat tmpstat_outfile;
12757 struct stat tmpstat_hashfile;
12758 #endif
12759
12760 #ifdef _WIN
12761 struct stat64 tmpstat_outfile;
12762 struct stat64 tmpstat_hashfile;
12763 #endif
12764
12765 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12766
12767 if (tmp_outfile_fp)
12768 {
12769 #ifdef _POSIX
12770 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12771 #endif
12772
12773 #ifdef _WIN
12774 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12775 #endif
12776
12777 fclose (tmp_outfile_fp);
12778 }
12779
12780 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12781
12782 if (tmp_hashfile_fp)
12783 {
12784 #ifdef _POSIX
12785 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12786 #endif
12787
12788 #ifdef _WIN
12789 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12790 #endif
12791
12792 fclose (tmp_hashfile_fp);
12793 }
12794
12795 if (tmp_outfile_fp && tmp_outfile_fp)
12796 {
12797 tmpstat_outfile.st_mode = 0;
12798 tmpstat_outfile.st_nlink = 0;
12799 tmpstat_outfile.st_uid = 0;
12800 tmpstat_outfile.st_gid = 0;
12801 tmpstat_outfile.st_rdev = 0;
12802 tmpstat_outfile.st_atime = 0;
12803
12804 tmpstat_hashfile.st_mode = 0;
12805 tmpstat_hashfile.st_nlink = 0;
12806 tmpstat_hashfile.st_uid = 0;
12807 tmpstat_hashfile.st_gid = 0;
12808 tmpstat_hashfile.st_rdev = 0;
12809 tmpstat_hashfile.st_atime = 0;
12810
12811 #ifdef _POSIX
12812 tmpstat_outfile.st_blksize = 0;
12813 tmpstat_outfile.st_blocks = 0;
12814
12815 tmpstat_hashfile.st_blksize = 0;
12816 tmpstat_hashfile.st_blocks = 0;
12817 #endif
12818
12819 #ifdef _POSIX
12820 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12821 {
12822 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12823
12824 return (-1);
12825 }
12826 #endif
12827
12828 #ifdef _WIN
12829 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12830 {
12831 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12832
12833 return (-1);
12834 }
12835 #endif
12836 }
12837 }
12838 }
12839
12840 /**
12841 * Remove duplicates
12842 */
12843
12844 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12845
12846 if (isSalted)
12847 {
12848 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12849 }
12850 else
12851 {
12852 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12853 }
12854
12855 uint hashes_cnt_orig = hashes_cnt;
12856
12857 hashes_cnt = 1;
12858
12859 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12860 {
12861 if (isSalted)
12862 {
12863 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12864 {
12865 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12866 }
12867 }
12868 else
12869 {
12870 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12871 }
12872
12873 if (hashes_pos > hashes_cnt)
12874 {
12875 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12876 }
12877
12878 hashes_cnt++;
12879 }
12880
12881 /**
12882 * Potfile removes
12883 */
12884
12885 uint potfile_remove_cracks = 0;
12886
12887 if (potfile_disable == 0)
12888 {
12889 hash_t hash_buf;
12890
12891 hash_buf.digest = mymalloc (dgst_size);
12892 hash_buf.salt = NULL;
12893 hash_buf.esalt = NULL;
12894 hash_buf.hash_info = NULL;
12895 hash_buf.cracked = 0;
12896
12897 if (isSalted)
12898 {
12899 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12900 }
12901
12902 if (esalt_size)
12903 {
12904 hash_buf.esalt = mymalloc (esalt_size);
12905 }
12906
12907 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12908
12909 // no solution for these special hash types (for instane because they use hashfile in output etc)
12910 if ((hash_mode != 5200) &&
12911 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12912 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12913 (hash_mode != 9000))
12914 {
12915 FILE *fp = fopen (potfile, "rb");
12916
12917 if (fp != NULL)
12918 {
12919 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12920
12921 // to be safe work with a copy (because of line_len loop, i etc)
12922 // moved up here because it's easier to handle continue case
12923 // it's just 64kb
12924
12925 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12926
12927 while (!feof (fp))
12928 {
12929 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12930
12931 if (ptr == NULL) break;
12932
12933 int line_len = strlen (line_buf);
12934
12935 if (line_len == 0) continue;
12936
12937 int iter = MAX_CUT_TRIES;
12938
12939 for (int i = line_len - 1; i && iter; i--, line_len--)
12940 {
12941 if (line_buf[i] != ':') continue;
12942
12943 if (isSalted)
12944 {
12945 memset (hash_buf.salt, 0, sizeof (salt_t));
12946 }
12947
12948 hash_t *found = NULL;
12949
12950 if (hash_mode == 6800)
12951 {
12952 if (i < 64) // 64 = 16 * uint in salt_buf[]
12953 {
12954 // manipulate salt_buf
12955 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12956
12957 hash_buf.salt->salt_len = i;
12958
12959 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12960 }
12961 }
12962 else if (hash_mode == 2500)
12963 {
12964 if (i < 64) // 64 = 16 * uint in salt_buf[]
12965 {
12966 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12967 // manipulate salt_buf
12968
12969 memcpy (line_buf_cpy, line_buf, i);
12970
12971 char *mac2_pos = strrchr (line_buf_cpy, ':');
12972
12973 if (mac2_pos == NULL) continue;
12974
12975 mac2_pos[0] = 0;
12976 mac2_pos++;
12977
12978 if (strlen (mac2_pos) != 12) continue;
12979
12980 char *mac1_pos = strrchr (line_buf_cpy, ':');
12981
12982 if (mac1_pos == NULL) continue;
12983
12984 mac1_pos[0] = 0;
12985 mac1_pos++;
12986
12987 if (strlen (mac1_pos) != 12) continue;
12988
12989 uint essid_length = mac1_pos - line_buf_cpy - 1;
12990
12991 // here we need the ESSID
12992 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12993
12994 hash_buf.salt->salt_len = essid_length;
12995
12996 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12997
12998 if (found)
12999 {
13000 wpa_t *wpa = (wpa_t *) found->esalt;
13001
13002 // compare hex string(s) vs binary MAC address(es)
13003
13004 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13005 {
13006 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
13007 {
13008 found = NULL;
13009
13010 break;
13011 }
13012 }
13013
13014 // early skip ;)
13015 if (!found) continue;
13016
13017 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13018 {
13019 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
13020 {
13021 found = NULL;
13022
13023 break;
13024 }
13025 }
13026 }
13027 }
13028 }
13029 else
13030 {
13031 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
13032
13033 if (parser_status == PARSER_OK)
13034 {
13035 if (isSalted)
13036 {
13037 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
13038 }
13039 else
13040 {
13041 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
13042 }
13043 }
13044 }
13045
13046 if (found == NULL) continue;
13047
13048 if (!found->cracked) potfile_remove_cracks++;
13049
13050 found->cracked = 1;
13051
13052 if (found) break;
13053
13054 iter--;
13055 }
13056 }
13057
13058 myfree (line_buf_cpy);
13059
13060 myfree (line_buf);
13061
13062 fclose (fp);
13063 }
13064 }
13065
13066 if (esalt_size)
13067 {
13068 local_free (hash_buf.esalt);
13069 }
13070
13071 if (isSalted)
13072 {
13073 local_free (hash_buf.salt);
13074 }
13075
13076 local_free (hash_buf.digest);
13077 }
13078
13079 /**
13080 * Now generate all the buffers required for later
13081 */
13082
13083 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
13084
13085 salt_t *salts_buf_new = NULL;
13086 void *esalts_buf_new = NULL;
13087
13088 if (isSalted)
13089 {
13090 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
13091
13092 if (esalt_size)
13093 {
13094 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
13095 }
13096 }
13097 else
13098 {
13099 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13100 }
13101
13102 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13103
13104 uint digests_cnt = hashes_cnt;
13105 uint digests_done = 0;
13106
13107 size_t size_digests = digests_cnt * dgst_size;
13108 size_t size_shown = digests_cnt * sizeof (uint);
13109
13110 uint *digests_shown = (uint *) mymalloc (size_shown);
13111 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13112
13113 uint salts_cnt = 0;
13114 uint salts_done = 0;
13115
13116 hashinfo_t **hash_info = NULL;
13117
13118 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13119 {
13120 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13121
13122 if (username && (remove || show))
13123 {
13124 uint user_pos;
13125
13126 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13127 {
13128 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13129
13130 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13131 }
13132 }
13133 }
13134
13135 uint *salts_shown = (uint *) mymalloc (size_shown);
13136
13137 salt_t *salt_buf;
13138
13139 {
13140 // copied from inner loop
13141
13142 salt_buf = &salts_buf_new[salts_cnt];
13143
13144 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13145
13146 if (esalt_size)
13147 {
13148 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13149 }
13150
13151 salt_buf->digests_cnt = 0;
13152 salt_buf->digests_done = 0;
13153 salt_buf->digests_offset = 0;
13154
13155 salts_cnt++;
13156 }
13157
13158 if (hashes_buf[0].cracked == 1)
13159 {
13160 digests_shown[0] = 1;
13161
13162 digests_done++;
13163
13164 salt_buf->digests_done++;
13165 }
13166
13167 salt_buf->digests_cnt++;
13168
13169 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13170
13171 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13172 {
13173 hash_info[0] = hashes_buf[0].hash_info;
13174 }
13175
13176 // copy from inner loop
13177
13178 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13179 {
13180 if (isSalted)
13181 {
13182 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13183 {
13184 salt_buf = &salts_buf_new[salts_cnt];
13185
13186 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13187
13188 if (esalt_size)
13189 {
13190 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13191 }
13192
13193 salt_buf->digests_cnt = 0;
13194 salt_buf->digests_done = 0;
13195 salt_buf->digests_offset = hashes_pos;
13196
13197 salts_cnt++;
13198 }
13199 }
13200
13201 if (hashes_buf[hashes_pos].cracked == 1)
13202 {
13203 digests_shown[hashes_pos] = 1;
13204
13205 digests_done++;
13206
13207 salt_buf->digests_done++;
13208 }
13209
13210 salt_buf->digests_cnt++;
13211
13212 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13213
13214 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13215 {
13216 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13217 }
13218 }
13219
13220 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13221 {
13222 salt_t *salt_buf = &salts_buf_new[salt_pos];
13223
13224 if (salt_buf->digests_done == salt_buf->digests_cnt)
13225 {
13226 salts_shown[salt_pos] = 1;
13227
13228 salts_done++;
13229 }
13230
13231 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13232 }
13233
13234 local_free (digests_buf);
13235 local_free (salts_buf);
13236 local_free (esalts_buf);
13237
13238 digests_buf = digests_buf_new;
13239 salts_buf = salts_buf_new;
13240 esalts_buf = esalts_buf_new;
13241
13242 local_free (hashes_buf);
13243
13244 /**
13245 * special modification not set from parser
13246 */
13247
13248 switch (hash_mode)
13249 {
13250 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13251 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13252 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13253 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13254 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13255 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13256 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13257 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13258 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13259 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13260 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13261 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13262 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13263 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13264 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13265 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13266 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13267 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13268 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13269 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13270 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13271 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13272 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13273 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13274 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13275 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13276 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13277 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13278 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13279 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13280 }
13281
13282 if (truecrypt_keyfiles)
13283 {
13284 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13285
13286 char *keyfiles = strdup (truecrypt_keyfiles);
13287
13288 char *keyfile = strtok (keyfiles, ",");
13289
13290 do
13291 {
13292 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13293
13294 } while ((keyfile = strtok (NULL, ",")) != NULL);
13295
13296 free (keyfiles);
13297 }
13298
13299 if (veracrypt_keyfiles)
13300 {
13301 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13302
13303 char *keyfiles = strdup (veracrypt_keyfiles);
13304
13305 char *keyfile = strtok (keyfiles, ",");
13306
13307 do
13308 {
13309 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13310
13311 } while ((keyfile = strtok (NULL, ",")) != NULL);
13312
13313 free (keyfiles);
13314 }
13315
13316 data.digests_cnt = digests_cnt;
13317 data.digests_done = digests_done;
13318 data.digests_buf = digests_buf;
13319 data.digests_shown = digests_shown;
13320 data.digests_shown_tmp = digests_shown_tmp;
13321
13322 data.salts_cnt = salts_cnt;
13323 data.salts_done = salts_done;
13324 data.salts_buf = salts_buf;
13325 data.salts_shown = salts_shown;
13326
13327 data.esalts_buf = esalts_buf;
13328 data.hash_info = hash_info;
13329
13330 /**
13331 * Automatic Optimizers
13332 */
13333
13334 if (salts_cnt == 1)
13335 opti_type |= OPTI_TYPE_SINGLE_SALT;
13336
13337 if (digests_cnt == 1)
13338 opti_type |= OPTI_TYPE_SINGLE_HASH;
13339
13340 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13341 opti_type |= OPTI_TYPE_NOT_ITERATED;
13342
13343 if (attack_mode == ATTACK_MODE_BF)
13344 opti_type |= OPTI_TYPE_BRUTE_FORCE;
13345
13346 data.opti_type = opti_type;
13347
13348 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13349 {
13350 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13351 {
13352 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13353 {
13354 if (opts_type & OPTS_TYPE_ST_ADD80)
13355 {
13356 opts_type &= ~OPTS_TYPE_ST_ADD80;
13357 opts_type |= OPTS_TYPE_PT_ADD80;
13358 }
13359
13360 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13361 {
13362 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13363 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13364 }
13365
13366 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13367 {
13368 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13369 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13370 }
13371 }
13372 }
13373 }
13374
13375 /**
13376 * Some algorithm, like descrypt, can benefit from JIT compilation
13377 */
13378
13379 int force_jit_compilation = -1;
13380
13381 if (hash_mode == 8900)
13382 {
13383 force_jit_compilation = 8900;
13384 }
13385 else if (hash_mode == 9300)
13386 {
13387 force_jit_compilation = 8900;
13388 }
13389 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13390 {
13391 force_jit_compilation = 1500;
13392 }
13393
13394 /**
13395 * generate bitmap tables
13396 */
13397
13398 const uint bitmap_shift1 = 5;
13399 const uint bitmap_shift2 = 13;
13400
13401 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13402
13403 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13404 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13405 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13406 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13407 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13408 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13409 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13410 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13411
13412 uint bitmap_bits;
13413 uint bitmap_nums;
13414 uint bitmap_mask;
13415 uint bitmap_size;
13416
13417 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13418 {
13419 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13420
13421 bitmap_nums = 1 << bitmap_bits;
13422
13423 bitmap_mask = bitmap_nums - 1;
13424
13425 bitmap_size = bitmap_nums * sizeof (uint);
13426
13427 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13428
13429 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;
13430 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;
13431
13432 break;
13433 }
13434
13435 bitmap_nums = 1 << bitmap_bits;
13436
13437 bitmap_mask = bitmap_nums - 1;
13438
13439 bitmap_size = bitmap_nums * sizeof (uint);
13440
13441 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);
13442 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);
13443
13444 /**
13445 * prepare quick rule
13446 */
13447
13448 data.rule_buf_l = rule_buf_l;
13449 data.rule_buf_r = rule_buf_r;
13450
13451 int rule_len_l = (int) strlen (rule_buf_l);
13452 int rule_len_r = (int) strlen (rule_buf_r);
13453
13454 data.rule_len_l = rule_len_l;
13455 data.rule_len_r = rule_len_r;
13456
13457 /**
13458 * load rules
13459 */
13460
13461 uint *all_kernel_rules_cnt = NULL;
13462
13463 kernel_rule_t **all_kernel_rules_buf = NULL;
13464
13465 if (rp_files_cnt)
13466 {
13467 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13468
13469 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13470 }
13471
13472 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13473
13474 int rule_len = 0;
13475
13476 for (uint i = 0; i < rp_files_cnt; i++)
13477 {
13478 uint kernel_rules_avail = 0;
13479
13480 uint kernel_rules_cnt = 0;
13481
13482 kernel_rule_t *kernel_rules_buf = NULL;
13483
13484 char *rp_file = rp_files[i];
13485
13486 char in[BLOCK_SIZE] = { 0 };
13487 char out[BLOCK_SIZE] = { 0 };
13488
13489 FILE *fp = NULL;
13490
13491 uint rule_line = 0;
13492
13493 if ((fp = fopen (rp_file, "rb")) == NULL)
13494 {
13495 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13496
13497 return (-1);
13498 }
13499
13500 while (!feof (fp))
13501 {
13502 memset (rule_buf, 0, HCBUFSIZ);
13503
13504 rule_len = fgetl (fp, rule_buf);
13505
13506 rule_line++;
13507
13508 if (rule_len == 0) continue;
13509
13510 if (rule_buf[0] == '#') continue;
13511
13512 if (kernel_rules_avail == kernel_rules_cnt)
13513 {
13514 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13515
13516 kernel_rules_avail += INCR_RULES;
13517 }
13518
13519 memset (in, 0, BLOCK_SIZE);
13520 memset (out, 0, BLOCK_SIZE);
13521
13522 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13523
13524 if (result == -1)
13525 {
13526 log_info ("WARNING: Skipping invalid or unsupported rule in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13527
13528 continue;
13529 }
13530
13531 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13532 {
13533 log_info ("WARNING: Cannot convert rule for use on OpenCL device in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13534
13535 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13536
13537 continue;
13538 }
13539
13540 /* its so slow
13541 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13542 {
13543 log_info ("Duplicate rule for use on OpenCL device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13544
13545 continue;
13546 }
13547 */
13548
13549 kernel_rules_cnt++;
13550 }
13551
13552 fclose (fp);
13553
13554 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13555
13556 all_kernel_rules_buf[i] = kernel_rules_buf;
13557 }
13558
13559 /**
13560 * merge rules or automatic rule generator
13561 */
13562
13563 uint kernel_rules_cnt = 0;
13564
13565 kernel_rule_t *kernel_rules_buf = NULL;
13566
13567 if (attack_mode == ATTACK_MODE_STRAIGHT)
13568 {
13569 if (rp_files_cnt)
13570 {
13571 kernel_rules_cnt = 1;
13572
13573 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13574
13575 repeats[0] = kernel_rules_cnt;
13576
13577 for (uint i = 0; i < rp_files_cnt; i++)
13578 {
13579 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13580
13581 repeats[i + 1] = kernel_rules_cnt;
13582 }
13583
13584 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13585
13586 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13587
13588 for (uint i = 0; i < kernel_rules_cnt; i++)
13589 {
13590 uint out_pos = 0;
13591
13592 kernel_rule_t *out = &kernel_rules_buf[i];
13593
13594 for (uint j = 0; j < rp_files_cnt; j++)
13595 {
13596 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13597 uint in_pos;
13598
13599 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13600
13601 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13602 {
13603 if (out_pos == RULES_MAX - 1)
13604 {
13605 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13606
13607 break;
13608 }
13609
13610 out->cmds[out_pos] = in->cmds[in_pos];
13611 }
13612 }
13613 }
13614
13615 local_free (repeats);
13616 }
13617 else if (rp_gen)
13618 {
13619 uint kernel_rules_avail = 0;
13620
13621 while (kernel_rules_cnt < rp_gen)
13622 {
13623 if (kernel_rules_avail == kernel_rules_cnt)
13624 {
13625 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13626
13627 kernel_rules_avail += INCR_RULES;
13628 }
13629
13630 memset (rule_buf, 0, HCBUFSIZ);
13631
13632 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13633
13634 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13635
13636 kernel_rules_cnt++;
13637 }
13638 }
13639 }
13640
13641 myfree (rule_buf);
13642
13643 /**
13644 * generate NOP rules
13645 */
13646
13647 if ((rp_files_cnt == 0) && (rp_gen == 0))
13648 {
13649 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13650
13651 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13652
13653 kernel_rules_cnt++;
13654 }
13655
13656 data.kernel_rules_cnt = kernel_rules_cnt;
13657 data.kernel_rules_buf = kernel_rules_buf;
13658
13659 if (kernel_rules_cnt == 0)
13660 {
13661 log_error ("ERROR: No valid rules left");
13662
13663 return (-1);
13664 }
13665
13666 /**
13667 * OpenCL platforms: detect
13668 */
13669
13670 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13671 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13672
13673 cl_uint platforms_cnt = 0;
13674 cl_uint platform_devices_cnt = 0;
13675
13676 if (keyspace == 0)
13677 {
13678 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13679
13680 if (platforms_cnt == 0)
13681 {
13682 log_info ("");
13683 log_info ("ATTENTION! No OpenCL compatible platform found");
13684 log_info ("");
13685 log_info ("You're probably missing the OpenCL runtime installation");
13686 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13687 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13688 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13689 log_info ("");
13690
13691 return (-1);
13692 }
13693
13694 if (opencl_platforms_filter != (uint) -1)
13695 {
13696 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13697
13698 if (opencl_platforms_filter > platform_cnt_mask)
13699 {
13700 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13701
13702 return (-1);
13703 }
13704 }
13705 }
13706
13707 if (opencl_device_types == NULL)
13708 {
13709 /**
13710 * OpenCL device types:
13711 * 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.
13712 */
13713
13714 cl_device_type device_types_all = 0;
13715
13716 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13717 {
13718 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13719
13720 cl_platform_id platform = platforms[platform_id];
13721
13722 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13723
13724 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13725 {
13726 cl_device_id device = platform_devices[platform_devices_id];
13727
13728 cl_device_type device_type;
13729
13730 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13731
13732 device_types_all |= device_type;
13733 }
13734 }
13735
13736 // In such a case, automatically enable CPU device type support, since it's disabled by default.
13737
13738 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13739 {
13740 device_types_filter |= CL_DEVICE_TYPE_CPU;
13741 }
13742
13743 // In another case, when the user uses --stdout, using CPU devices is much faster to setup
13744 // If we have a CPU device, force it to be used
13745
13746 if (stdout_flag == 1)
13747 {
13748 if (device_types_all & CL_DEVICE_TYPE_CPU)
13749 {
13750 device_types_filter = CL_DEVICE_TYPE_CPU;
13751 }
13752 }
13753 }
13754
13755 /**
13756 * OpenCL devices: simply push all devices from all platforms into the same device array
13757 */
13758
13759 int need_adl = 0;
13760 int need_nvapi = 0;
13761 int need_nvml = 0;
13762 int need_xnvctrl = 0;
13763
13764 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13765
13766 data.devices_param = devices_param;
13767
13768 uint devices_cnt = 0;
13769
13770 uint devices_active = 0;
13771
13772 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13773 {
13774 cl_platform_id platform = platforms[platform_id];
13775
13776 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13777
13778 char platform_vendor[INFOSZ] = { 0 };
13779
13780 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13781
13782 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13783 // this causes trouble with vendor id based macros
13784 // we'll assign generic to those without special optimization available
13785
13786 cl_uint platform_vendor_id = 0;
13787
13788 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13789 {
13790 platform_vendor_id = VENDOR_ID_AMD;
13791 }
13792 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13793 {
13794 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13795 }
13796 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13797 {
13798 platform_vendor_id = VENDOR_ID_APPLE;
13799 }
13800 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13801 {
13802 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13803 }
13804 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13805 {
13806 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13807 }
13808 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13809 {
13810 platform_vendor_id = VENDOR_ID_MESA;
13811 }
13812 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13813 {
13814 platform_vendor_id = VENDOR_ID_NV;
13815 }
13816 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13817 {
13818 platform_vendor_id = VENDOR_ID_POCL;
13819 }
13820 else
13821 {
13822 platform_vendor_id = VENDOR_ID_GENERIC;
13823 }
13824
13825 const uint platform_skipped = ((opencl_platforms_filter & (1 << platform_id)) == 0);
13826
13827 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13828 {
13829 if (machine_readable == 0)
13830 {
13831 if (platform_skipped == 0)
13832 {
13833 const int len = log_info ("OpenCL Platform #%u: %s", platform_id + 1, platform_vendor);
13834
13835 char line[256] = { 0 };
13836
13837 for (int i = 0; i < len; i++) line[i] = '=';
13838
13839 log_info (line);
13840 }
13841 else
13842 {
13843 log_info ("OpenCL Platform #%u: %s, skipped", platform_id + 1, platform_vendor);
13844 log_info ("");
13845 }
13846 }
13847 }
13848
13849 if (platform_skipped == 1) continue;
13850
13851 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13852 {
13853 size_t param_value_size = 0;
13854
13855 const uint device_id = devices_cnt;
13856
13857 hc_device_param_t *device_param = &data.devices_param[device_id];
13858
13859 device_param->platform_vendor_id = platform_vendor_id;
13860
13861 device_param->device = platform_devices[platform_devices_id];
13862
13863 device_param->device_id = device_id;
13864
13865 device_param->platform_devices_id = platform_devices_id;
13866
13867 // device_type
13868
13869 cl_device_type device_type;
13870
13871 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13872
13873 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13874
13875 device_param->device_type = device_type;
13876
13877 // device_name
13878
13879 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13880
13881 char *device_name = (char *) mymalloc (param_value_size);
13882
13883 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13884
13885 device_param->device_name = device_name;
13886
13887 // device_vendor
13888
13889 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13890
13891 char *device_vendor = (char *) mymalloc (param_value_size);
13892
13893 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13894
13895 device_param->device_vendor = device_vendor;
13896
13897 cl_uint device_vendor_id = 0;
13898
13899 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13900 {
13901 device_vendor_id = VENDOR_ID_AMD;
13902 }
13903 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13904 {
13905 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13906 }
13907 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13908 {
13909 device_vendor_id = VENDOR_ID_APPLE;
13910 }
13911 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13912 {
13913 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13914 }
13915 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13916 {
13917 device_vendor_id = VENDOR_ID_INTEL_SDK;
13918 }
13919 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13920 {
13921 device_vendor_id = VENDOR_ID_MESA;
13922 }
13923 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13924 {
13925 device_vendor_id = VENDOR_ID_NV;
13926 }
13927 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13928 {
13929 device_vendor_id = VENDOR_ID_POCL;
13930 }
13931 else
13932 {
13933 device_vendor_id = VENDOR_ID_GENERIC;
13934 }
13935
13936 device_param->device_vendor_id = device_vendor_id;
13937
13938 // tuning db
13939
13940 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13941
13942 // device_version
13943
13944 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13945
13946 char *device_version = (char *) mymalloc (param_value_size);
13947
13948 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13949
13950 device_param->device_version = device_version;
13951
13952 // device_opencl_version
13953
13954 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13955
13956 char *device_opencl_version = (char *) mymalloc (param_value_size);
13957
13958 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13959
13960 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13961
13962 myfree (device_opencl_version);
13963
13964 // vector_width
13965
13966 cl_uint vector_width;
13967
13968 if (opencl_vector_width_chgd == 0)
13969 {
13970 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13971 {
13972 if (opti_type & OPTI_TYPE_USES_BITS_64)
13973 {
13974 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13975 }
13976 else
13977 {
13978 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13979 }
13980 }
13981 else
13982 {
13983 vector_width = (cl_uint) tuningdb_entry->vector_width;
13984 }
13985 }
13986 else
13987 {
13988 vector_width = opencl_vector_width;
13989 }
13990
13991 if (vector_width > 16) vector_width = 16;
13992
13993 device_param->vector_width = vector_width;
13994
13995 // max_compute_units
13996
13997 cl_uint device_processors;
13998
13999 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
14000
14001 device_param->device_processors = device_processors;
14002
14003 // device_maxmem_alloc
14004 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
14005
14006 cl_ulong device_maxmem_alloc;
14007
14008 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
14009
14010 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
14011
14012 // device_global_mem
14013
14014 cl_ulong device_global_mem;
14015
14016 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
14017
14018 device_param->device_global_mem = device_global_mem;
14019
14020 // max_work_group_size
14021
14022 size_t device_maxworkgroup_size;
14023
14024 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
14025
14026 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
14027
14028 // max_clock_frequency
14029
14030 cl_uint device_maxclock_frequency;
14031
14032 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
14033
14034 device_param->device_maxclock_frequency = device_maxclock_frequency;
14035
14036 // device_endian_little
14037
14038 cl_bool device_endian_little;
14039
14040 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
14041
14042 if (device_endian_little == CL_FALSE)
14043 {
14044 log_info ("- Device #%u: WARNING: Not a little endian device", device_id + 1);
14045
14046 device_param->skipped = 1;
14047 }
14048
14049 // device_available
14050
14051 cl_bool device_available;
14052
14053 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
14054
14055 if (device_available == CL_FALSE)
14056 {
14057 log_info ("- Device #%u: WARNING: Device not available", device_id + 1);
14058
14059 device_param->skipped = 1;
14060 }
14061
14062 // device_compiler_available
14063
14064 cl_bool device_compiler_available;
14065
14066 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
14067
14068 if (device_compiler_available == CL_FALSE)
14069 {
14070 log_info ("- Device #%u: WARNING: No compiler available for device", device_id + 1);
14071
14072 device_param->skipped = 1;
14073 }
14074
14075 // device_execution_capabilities
14076
14077 cl_device_exec_capabilities device_execution_capabilities;
14078
14079 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
14080
14081 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
14082 {
14083 log_info ("- Device #%u: WARNING: Device does not support executing kernels", device_id + 1);
14084
14085 device_param->skipped = 1;
14086 }
14087
14088 // device_extensions
14089
14090 size_t device_extensions_size;
14091
14092 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
14093
14094 char *device_extensions = mymalloc (device_extensions_size + 1);
14095
14096 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
14097
14098 if (strstr (device_extensions, "base_atomics") == 0)
14099 {
14100 log_info ("- Device #%u: WARNING: Device does not support base atomics", device_id + 1);
14101
14102 device_param->skipped = 1;
14103 }
14104
14105 if (strstr (device_extensions, "byte_addressable_store") == 0)
14106 {
14107 log_info ("- Device #%u: WARNING: Device does not support byte addressable store", device_id + 1);
14108
14109 device_param->skipped = 1;
14110 }
14111
14112 myfree (device_extensions);
14113
14114 // device_local_mem_size
14115
14116 cl_ulong device_local_mem_size;
14117
14118 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
14119
14120 if (device_local_mem_size < 32768)
14121 {
14122 log_info ("- Device #%u: WARNING: Device local mem size is too small", device_id + 1);
14123
14124 device_param->skipped = 1;
14125 }
14126
14127 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
14128 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
14129 // This results in both utilizing it for 50%
14130 // However, Intel has much better SIMD control over their own hardware
14131 // It makes sense to give them full control over their own hardware
14132
14133 if (device_type & CL_DEVICE_TYPE_CPU)
14134 {
14135 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14136 {
14137 if (data.force == 0)
14138 {
14139 if (algorithm_pos == 0)
14140 {
14141 log_info ("- Device #%u: WARNING: Not a native Intel OpenCL runtime, expect massive speed loss", device_id + 1);
14142 log_info (" You can use --force to override this but do not post error reports if you do so");
14143 }
14144
14145 device_param->skipped = 1;
14146 }
14147 }
14148 }
14149
14150 // skipped
14151
14152 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14153 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14154
14155 // driver_version
14156
14157 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14158
14159 char *driver_version = (char *) mymalloc (param_value_size);
14160
14161 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14162
14163 device_param->driver_version = driver_version;
14164
14165 // device_name_chksum
14166
14167 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14168
14169 #if __x86_64__
14170 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);
14171 #else
14172 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);
14173 #endif
14174
14175 uint device_name_digest[4] = { 0 };
14176
14177 md5_64 ((uint *) device_name_chksum, device_name_digest);
14178
14179 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14180
14181 device_param->device_name_chksum = device_name_chksum;
14182
14183 // vendor specific
14184
14185 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14186 {
14187 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14188 {
14189 need_adl = 1;
14190 }
14191
14192 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14193 {
14194 need_nvml = 1;
14195
14196 #ifdef LINUX
14197 need_xnvctrl = 1;
14198 #endif
14199
14200 #ifdef WIN
14201 need_nvapi = 1;
14202 #endif
14203 }
14204 }
14205
14206 if (device_type & CL_DEVICE_TYPE_GPU)
14207 {
14208 if (device_vendor_id == VENDOR_ID_NV)
14209 {
14210 cl_uint kernel_exec_timeout = 0;
14211
14212 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14213
14214 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14215
14216 device_param->kernel_exec_timeout = kernel_exec_timeout;
14217
14218 cl_uint sm_minor = 0;
14219 cl_uint sm_major = 0;
14220
14221 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14222 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14223
14224 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14225 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14226
14227 device_param->sm_minor = sm_minor;
14228 device_param->sm_major = sm_major;
14229
14230 // CPU burning loop damper
14231 // Value is given as number between 0-100
14232 // By default 100%
14233
14234 device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14235
14236 if (nvidia_spin_damp_chgd == 0)
14237 {
14238 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14239 {
14240 /**
14241 * the workaround is not a friend of rule based attacks
14242 * the words from the wordlist combined with fast and slow rules cause
14243 * fluctuations which cause inaccurate wait time estimations
14244 * using a reduced damping percentage almost compensates this
14245 */
14246
14247 device_param->nvidia_spin_damp = 64;
14248 }
14249 }
14250
14251 device_param->nvidia_spin_damp /= 100;
14252 }
14253 }
14254
14255 // display results
14256
14257 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14258 {
14259 if (machine_readable == 0)
14260 {
14261 if (device_param->skipped == 0)
14262 {
14263 log_info ("- Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14264 device_id + 1,
14265 device_name,
14266 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14267 (unsigned int) (device_global_mem / 1024 / 1024),
14268 (unsigned int) device_processors);
14269 }
14270 else
14271 {
14272 log_info ("- Device #%u: %s, skipped",
14273 device_id + 1,
14274 device_name);
14275 }
14276 }
14277 }
14278
14279 // common driver check
14280
14281 if (device_param->skipped == 0)
14282 {
14283 if (device_type & CL_DEVICE_TYPE_GPU)
14284 {
14285 if (platform_vendor_id == VENDOR_ID_AMD)
14286 {
14287 int catalyst_check = (force == 1) ? 0 : 1;
14288
14289 int catalyst_warn = 0;
14290
14291 int catalyst_broken = 0;
14292
14293 if (catalyst_check == 1)
14294 {
14295 catalyst_warn = 1;
14296
14297 // v14.9 and higher
14298 if (atoi (device_param->driver_version) >= 1573)
14299 {
14300 catalyst_warn = 0;
14301 }
14302
14303 catalyst_check = 0;
14304 }
14305
14306 if (catalyst_broken == 1)
14307 {
14308 log_info ("");
14309 log_info ("ATTENTION! The Catalyst driver installed on your system is known to be broken!");
14310 log_info ("It passes over cracked hashes and will not report them as cracked");
14311 log_info ("You are STRONGLY encouraged not to use it");
14312 log_info ("You can use --force to override this but do not post error reports if you do so");
14313 log_info ("");
14314
14315 return (-1);
14316 }
14317
14318 if (catalyst_warn == 1)
14319 {
14320 log_info ("");
14321 log_info ("ATTENTION! Unsupported or incorrectly installed Catalyst driver detected!");
14322 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver");
14323 log_info ("See hashcat's homepage for official supported catalyst drivers");
14324 #ifdef _WIN
14325 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14326 #endif
14327 log_info ("You can use --force to override this but do not post error reports if you do so");
14328 log_info ("");
14329
14330 return (-1);
14331 }
14332 }
14333 else if (platform_vendor_id == VENDOR_ID_NV)
14334 {
14335 if (device_param->kernel_exec_timeout != 0)
14336 {
14337 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);
14338 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14339 }
14340 }
14341 }
14342
14343 /* turns out pocl still creates segfaults (because of llvm)
14344 if (device_type & CL_DEVICE_TYPE_CPU)
14345 {
14346 if (platform_vendor_id == VENDOR_ID_AMD)
14347 {
14348 if (force == 0)
14349 {
14350 log_info ("");
14351 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14352 log_info ("You are STRONGLY encouraged not to use it");
14353 log_info ("You can use --force to override this but do not post error reports if you do so");
14354 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14355 log_info ("");
14356
14357 return (-1);
14358 }
14359 }
14360 }
14361 */
14362
14363 /**
14364 * kernel accel and loops tuning db adjustment
14365 */
14366
14367 device_param->kernel_accel_min = 1;
14368 device_param->kernel_accel_max = 1024;
14369
14370 device_param->kernel_loops_min = 1;
14371 device_param->kernel_loops_max = 1024;
14372
14373 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14374
14375 if (tuningdb_entry)
14376 {
14377 u32 _kernel_accel = tuningdb_entry->kernel_accel;
14378 u32 _kernel_loops = tuningdb_entry->kernel_loops;
14379
14380 if (_kernel_accel)
14381 {
14382 device_param->kernel_accel_min = _kernel_accel;
14383 device_param->kernel_accel_max = _kernel_accel;
14384 }
14385
14386 if (_kernel_loops)
14387 {
14388 if (workload_profile == 1)
14389 {
14390 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14391 }
14392 else if (workload_profile == 2)
14393 {
14394 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14395 }
14396
14397 device_param->kernel_loops_min = _kernel_loops;
14398 device_param->kernel_loops_max = _kernel_loops;
14399 }
14400 }
14401
14402 // commandline parameters overwrite tuningdb entries
14403
14404 if (kernel_accel)
14405 {
14406 device_param->kernel_accel_min = kernel_accel;
14407 device_param->kernel_accel_max = kernel_accel;
14408 }
14409
14410 if (kernel_loops)
14411 {
14412 device_param->kernel_loops_min = kernel_loops;
14413 device_param->kernel_loops_max = kernel_loops;
14414 }
14415
14416 /**
14417 * activate device
14418 */
14419
14420 devices_active++;
14421 }
14422
14423 // next please
14424
14425 devices_cnt++;
14426 }
14427
14428 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14429 {
14430 if (machine_readable == 0)
14431 {
14432 log_info ("");
14433 }
14434 }
14435 }
14436
14437 if (keyspace == 0 && devices_active == 0)
14438 {
14439 log_error ("ERROR: No devices found/left");
14440
14441 return (-1);
14442 }
14443
14444 // 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)
14445
14446 if (devices_filter != (uint) -1)
14447 {
14448 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14449
14450 if (devices_filter > devices_cnt_mask)
14451 {
14452 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14453
14454 return (-1);
14455 }
14456 }
14457
14458 data.devices_cnt = devices_cnt;
14459
14460 data.devices_active = devices_active;
14461
14462 /**
14463 * HM devices: init
14464 */
14465
14466 #ifdef HAVE_HWMON
14467 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14468 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14469 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14470 hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX] = { { 0 } };
14471
14472 if (gpu_temp_disable == 0)
14473 {
14474 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14475 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14476 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14477 XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));
14478
14479 data.hm_adl = NULL;
14480 data.hm_nvapi = NULL;
14481 data.hm_nvml = NULL;
14482 data.hm_xnvctrl = NULL;
14483
14484 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14485 {
14486 data.hm_nvml = nvml;
14487 }
14488
14489 if (data.hm_nvml)
14490 {
14491 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14492 {
14493 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14494
14495 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14496
14497 int tmp_out = 0;
14498
14499 for (int i = 0; i < tmp_in; i++)
14500 {
14501 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14502 }
14503
14504 for (int i = 0; i < tmp_out; i++)
14505 {
14506 unsigned int speed;
14507
14508 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14509
14510 // doesn't seem to create any advantages
14511 //hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14512 //hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14513 }
14514 }
14515 }
14516
14517 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14518 {
14519 data.hm_nvapi = nvapi;
14520 }
14521
14522 if (data.hm_nvapi)
14523 {
14524 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14525 {
14526 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14527
14528 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14529
14530 int tmp_out = 0;
14531
14532 for (int i = 0; i < tmp_in; i++)
14533 {
14534 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14535 }
14536 }
14537 }
14538
14539 if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0))
14540 {
14541 data.hm_xnvctrl = xnvctrl;
14542 }
14543
14544 if (data.hm_xnvctrl)
14545 {
14546 if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
14547 {
14548 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14549 {
14550 hc_device_param_t *device_param = &data.devices_param[device_id];
14551
14552 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14553
14554 hm_adapters_xnvctrl[device_id].xnvctrl = device_id;
14555
14556 int speed = 0;
14557
14558 if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
14559 }
14560 }
14561 }
14562
14563 if ((need_adl == 1) && (adl_init (adl) == 0))
14564 {
14565 data.hm_adl = adl;
14566 }
14567
14568 if (data.hm_adl)
14569 {
14570 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14571 {
14572 // total number of adapters
14573
14574 int hm_adapters_num;
14575
14576 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14577
14578 // adapter info
14579
14580 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14581
14582 if (lpAdapterInfo == NULL) return (-1);
14583
14584 // get a list (of ids of) valid/usable adapters
14585
14586 int num_adl_adapters = 0;
14587
14588 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14589
14590 if (num_adl_adapters > 0)
14591 {
14592 hc_thread_mutex_lock (mux_adl);
14593
14594 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14595
14596 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14597
14598 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14599 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14600
14601 hc_thread_mutex_unlock (mux_adl);
14602 }
14603
14604 myfree (valid_adl_device_list);
14605 myfree (lpAdapterInfo);
14606 }
14607 }
14608
14609 if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14610 {
14611 gpu_temp_disable = 1;
14612 }
14613 }
14614
14615 /**
14616 * OpenCL devices: allocate buffer for device specific information
14617 */
14618
14619 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14620
14621 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14622
14623 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14624
14625 /**
14626 * User-defined GPU temp handling
14627 */
14628
14629 if (gpu_temp_disable == 1)
14630 {
14631 gpu_temp_abort = 0;
14632 gpu_temp_retain = 0;
14633 }
14634
14635 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14636 {
14637 if (gpu_temp_abort < gpu_temp_retain)
14638 {
14639 log_error ("ERROR: Invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14640
14641 return (-1);
14642 }
14643 }
14644
14645 data.gpu_temp_disable = gpu_temp_disable;
14646 data.gpu_temp_abort = gpu_temp_abort;
14647 data.gpu_temp_retain = gpu_temp_retain;
14648 #endif
14649
14650 /**
14651 * enable custom signal handler(s)
14652 */
14653
14654 if (benchmark == 0)
14655 {
14656 hc_signal (sigHandler_default);
14657 }
14658 else
14659 {
14660 hc_signal (sigHandler_benchmark);
14661 }
14662
14663 /**
14664 * inform the user
14665 */
14666
14667 if (data.quiet == 0)
14668 {
14669 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14670
14671 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);
14672
14673 if (attack_mode == ATTACK_MODE_STRAIGHT)
14674 {
14675 log_info ("Rules: %u", kernel_rules_cnt);
14676 }
14677
14678 if (opti_type)
14679 {
14680 log_info ("Applicable Optimizers:");
14681
14682 for (uint i = 0; i < 32; i++)
14683 {
14684 const uint opti_bit = 1u << i;
14685
14686 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14687 }
14688 }
14689
14690 /**
14691 * Watchdog and Temperature balance
14692 */
14693
14694 #ifdef HAVE_HWMON
14695 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14696 {
14697 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14698 }
14699
14700 if (gpu_temp_abort == 0)
14701 {
14702 log_info ("Watchdog: Temperature abort trigger disabled");
14703 }
14704 else
14705 {
14706 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14707 }
14708
14709 if (gpu_temp_retain == 0)
14710 {
14711 log_info ("Watchdog: Temperature retain trigger disabled");
14712 }
14713 else
14714 {
14715 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14716 }
14717
14718 if (data.quiet == 0) log_info ("");
14719 #endif
14720 }
14721
14722 #ifdef HAVE_HWMON
14723
14724 /**
14725 * HM devices: copy
14726 */
14727
14728 if (gpu_temp_disable == 0)
14729 {
14730 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14731 {
14732 hc_device_param_t *device_param = &data.devices_param[device_id];
14733
14734 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14735
14736 if (device_param->skipped) continue;
14737
14738 const uint platform_devices_id = device_param->platform_devices_id;
14739
14740 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14741 {
14742 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14743 data.hm_device[device_id].nvapi = 0;
14744 data.hm_device[device_id].nvml = 0;
14745 data.hm_device[device_id].xnvctrl = 0;
14746 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14747 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14748 data.hm_device[device_id].fan_set_supported = 0;
14749 }
14750
14751 if (device_param->device_vendor_id == VENDOR_ID_NV)
14752 {
14753 data.hm_device[device_id].adl = 0;
14754 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14755 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14756 data.hm_device[device_id].xnvctrl = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
14757 data.hm_device[device_id].od_version = 0;
14758 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14759 data.hm_device[device_id].fan_set_supported = 0;
14760 }
14761 }
14762 }
14763
14764 /**
14765 * powertune on user request
14766 */
14767
14768 if (powertune_enable == 1)
14769 {
14770 hc_thread_mutex_lock (mux_adl);
14771
14772 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14773 {
14774 hc_device_param_t *device_param = &data.devices_param[device_id];
14775
14776 if (device_param->skipped) continue;
14777
14778 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14779 {
14780 /**
14781 * Temporary fix:
14782 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14783 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14784 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14785 * Driver / ADL bug?
14786 */
14787
14788 if (data.hm_device[device_id].od_version == 6)
14789 {
14790 int ADL_rc;
14791
14792 // check powertune capabilities first, if not available then skip device
14793
14794 int powertune_supported = 0;
14795
14796 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14797 {
14798 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14799
14800 return (-1);
14801 }
14802
14803 // first backup current value, we will restore it later
14804
14805 if (powertune_supported != 0)
14806 {
14807 // powercontrol settings
14808
14809 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14810
14811 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14812 {
14813 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14814 }
14815
14816 if (ADL_rc != ADL_OK)
14817 {
14818 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14819
14820 return (-1);
14821 }
14822
14823 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14824 {
14825 log_error ("ERROR: Failed to set new ADL PowerControl values");
14826
14827 return (-1);
14828 }
14829
14830 // clocks
14831
14832 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14833
14834 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14835
14836 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)
14837 {
14838 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14839
14840 return (-1);
14841 }
14842
14843 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14844
14845 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14846
14847 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14848 {
14849 log_error ("ERROR: Failed to get ADL device capabilities");
14850
14851 return (-1);
14852 }
14853
14854 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14855 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14856
14857 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14858 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14859
14860 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14861 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14862
14863 // warning if profile has too low max values
14864
14865 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14866 {
14867 log_info ("WARN: The custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14868 }
14869
14870 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14871 {
14872 log_info ("WARN: The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14873 }
14874
14875 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14876
14877 performance_state->iNumberOfPerformanceLevels = 2;
14878
14879 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14880 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14881 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14882 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14883
14884 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)
14885 {
14886 log_info ("ERROR: Failed to set ADL performance state");
14887
14888 return (-1);
14889 }
14890
14891 local_free (performance_state);
14892 }
14893
14894 // set powertune value only
14895
14896 if (powertune_supported != 0)
14897 {
14898 // powertune set
14899 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14900
14901 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14902 {
14903 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14904
14905 return (-1);
14906 }
14907
14908 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14909 {
14910 log_error ("ERROR: Failed to set new ADL PowerControl values");
14911
14912 return (-1);
14913 }
14914 }
14915 }
14916 }
14917
14918 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14919 {
14920 // first backup current value, we will restore it later
14921
14922 unsigned int limit;
14923
14924 int powertune_supported = 0;
14925
14926 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14927 {
14928 powertune_supported = 1;
14929 }
14930
14931 // if backup worked, activate the maximum allowed
14932
14933 if (powertune_supported != 0)
14934 {
14935 unsigned int minLimit;
14936 unsigned int maxLimit;
14937
14938 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14939 {
14940 if (maxLimit > 0)
14941 {
14942 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14943 {
14944 // now we can be sure we need to reset later
14945
14946 nvml_power_limit[device_id] = limit;
14947 }
14948 }
14949 }
14950 }
14951 }
14952 }
14953
14954 hc_thread_mutex_unlock (mux_adl);
14955 }
14956
14957 #endif // HAVE_HWMON
14958
14959 #ifdef DEBUG
14960 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14961 #endif
14962
14963 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14964
14965 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14966 {
14967 /**
14968 * host buffer
14969 */
14970
14971 hc_device_param_t *device_param = &data.devices_param[device_id];
14972
14973 if (device_param->skipped) continue;
14974
14975 /**
14976 * device properties
14977 */
14978
14979 const char *device_name_chksum = device_param->device_name_chksum;
14980 const u32 device_processors = device_param->device_processors;
14981
14982 /**
14983 * create context for each device
14984 */
14985
14986 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14987
14988 /**
14989 * create command-queue
14990 */
14991
14992 // not supported with NV
14993 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14994
14995 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14996
14997 /**
14998 * kernel threads: some algorithms need a fixed kernel-threads count
14999 * because of shared memory usage or bitslice
15000 * there needs to be some upper limit, otherwise there's too much overhead
15001 */
15002
15003 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
15004
15005 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
15006 {
15007 kernel_threads = KERNEL_THREADS_MAX_CPU;
15008 }
15009
15010 if (hash_mode == 1500) kernel_threads = 64; // DES
15011 if (hash_mode == 3000) kernel_threads = 64; // DES
15012 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
15013 if (hash_mode == 7500) kernel_threads = 64; // RC4
15014 if (hash_mode == 8900) kernel_threads = 32; // scrypt
15015 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
15016 if (hash_mode == 9300) kernel_threads = 32; // scrypt
15017 if (hash_mode == 9700) kernel_threads = 64; // RC4
15018 if (hash_mode == 9710) kernel_threads = 64; // RC4
15019 if (hash_mode == 9800) kernel_threads = 64; // RC4
15020 if (hash_mode == 9810) kernel_threads = 64; // RC4
15021 if (hash_mode == 10400) kernel_threads = 64; // RC4
15022 if (hash_mode == 10410) kernel_threads = 64; // RC4
15023 if (hash_mode == 10500) kernel_threads = 64; // RC4
15024 if (hash_mode == 13100) kernel_threads = 64; // RC4
15025
15026 device_param->kernel_threads = kernel_threads;
15027
15028 device_param->hardware_power = device_processors * kernel_threads;
15029
15030 /**
15031 * create input buffers on device : calculate size of fixed memory buffers
15032 */
15033
15034 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
15035 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
15036
15037 device_param->size_root_css = size_root_css;
15038 device_param->size_markov_css = size_markov_css;
15039
15040 size_t size_results = sizeof (uint);
15041
15042 device_param->size_results = size_results;
15043
15044 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
15045 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
15046
15047 size_t size_plains = digests_cnt * sizeof (plain_t);
15048 size_t size_salts = salts_cnt * sizeof (salt_t);
15049 size_t size_esalts = salts_cnt * esalt_size;
15050
15051 device_param->size_plains = size_plains;
15052 device_param->size_digests = size_digests;
15053 device_param->size_shown = size_shown;
15054 device_param->size_salts = size_salts;
15055
15056 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
15057 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
15058 size_t size_tm = 32 * sizeof (bs_word_t);
15059
15060 // scryptV stuff
15061
15062 size_t size_scryptV = 1;
15063
15064 if ((hash_mode == 8900) || (hash_mode == 9300))
15065 {
15066 uint tmto_start = 0;
15067 uint tmto_stop = 10;
15068
15069 if (scrypt_tmto)
15070 {
15071 tmto_start = scrypt_tmto;
15072 }
15073 else
15074 {
15075 // in case the user did not specify the tmto manually
15076 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
15077 // but set the lower end only in case the user has a device with too less memory
15078
15079 if (hash_mode == 8900)
15080 {
15081 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15082 {
15083 tmto_start = 1;
15084 }
15085 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15086 {
15087 tmto_start = 2;
15088 }
15089 }
15090 else if (hash_mode == 9300)
15091 {
15092 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15093 {
15094 tmto_start = 2;
15095 }
15096 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15097 {
15098 tmto_start = 2;
15099 }
15100 }
15101 }
15102
15103 device_param->kernel_accel_min = 1;
15104 device_param->kernel_accel_max = 8;
15105
15106 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
15107 {
15108 // TODO: in theory the following calculation needs to be done per salt, not global
15109 // we assume all hashes have the same scrypt settings
15110
15111 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
15112
15113 size_scryptV /= 1 << tmto;
15114
15115 size_scryptV *= device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel_max;
15116
15117 if (size_scryptV > device_param->device_maxmem_alloc)
15118 {
15119 if (quiet == 0) log_info ("WARNING: Not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15120
15121 continue;
15122 }
15123
15124 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
15125 {
15126 data.salts_buf[salts_pos].scrypt_tmto = tmto;
15127 data.salts_buf[salts_pos].scrypt_phy = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel_max;
15128 }
15129
15130 break;
15131 }
15132
15133 if (data.salts_buf[0].scrypt_phy == 0)
15134 {
15135 log_error ("ERROR: Can't allocate enough device memory");
15136
15137 return -1;
15138 }
15139
15140 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
15141 }
15142
15143 /**
15144 * some algorithms need a fixed kernel-loops count
15145 */
15146
15147 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15148 {
15149 const u32 kernel_loops_fixed = 1024;
15150
15151 device_param->kernel_loops_min = kernel_loops_fixed;
15152 device_param->kernel_loops_max = kernel_loops_fixed;
15153 }
15154
15155 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15156 {
15157 const u32 kernel_loops_fixed = 1024;
15158
15159 device_param->kernel_loops_min = kernel_loops_fixed;
15160 device_param->kernel_loops_max = kernel_loops_fixed;
15161 }
15162
15163 if (hash_mode == 8900)
15164 {
15165 const u32 kernel_loops_fixed = 1;
15166
15167 device_param->kernel_loops_min = kernel_loops_fixed;
15168 device_param->kernel_loops_max = kernel_loops_fixed;
15169 }
15170
15171 if (hash_mode == 9300)
15172 {
15173 const u32 kernel_loops_fixed = 1;
15174
15175 device_param->kernel_loops_min = kernel_loops_fixed;
15176 device_param->kernel_loops_max = kernel_loops_fixed;
15177 }
15178
15179 if (hash_mode == 12500)
15180 {
15181 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15182
15183 device_param->kernel_loops_min = kernel_loops_fixed;
15184 device_param->kernel_loops_max = kernel_loops_fixed;
15185 }
15186
15187 /**
15188 * some algorithms have a maximum kernel-loops count
15189 */
15190
15191 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15192 {
15193 u32 innerloop_cnt = 0;
15194
15195 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15196 {
15197 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15198 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15199 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15200 }
15201 else
15202 {
15203 innerloop_cnt = data.salts_buf[0].salt_iter;
15204 }
15205
15206 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15207 (innerloop_cnt <= device_param->kernel_loops_max))
15208 {
15209 device_param->kernel_loops_max = innerloop_cnt;
15210 }
15211 }
15212
15213 u32 kernel_accel_min = device_param->kernel_accel_min;
15214 u32 kernel_accel_max = device_param->kernel_accel_max;
15215
15216 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15217
15218 size_t size_pws = 4;
15219 size_t size_tmps = 4;
15220 size_t size_hooks = 4;
15221
15222 while (kernel_accel_max >= kernel_accel_min)
15223 {
15224 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15225
15226 // size_pws
15227
15228 size_pws = kernel_power_max * sizeof (pw_t);
15229
15230 // size_tmps
15231
15232 switch (hash_mode)
15233 {
15234 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15235 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15236 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15237 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15238 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15239 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15240 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15241 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15242 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15243 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15244 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15245 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15246 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15247 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15248 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15249 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15250 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15251 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15252 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15253 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15254 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15255 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15256 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15257 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
15258 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
15259 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
15260 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
15261 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
15262 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15263 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15264 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
15265 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
15266 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15267 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
15268 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15269 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
15270 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
15271 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15272 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15273 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
15274 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
15275 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
15276 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15277 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
15278 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
15279 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
15280 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
15281 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15282 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
15283 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
15284 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
15285 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15286 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15287 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
15288 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
15289 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
15290 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
15291 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
15292 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15293 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15294 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15295 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
15296 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
15297 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15298 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15299 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15300 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15301 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15302 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15303 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15304 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15305 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15306 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15307 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15308 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15309 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15310 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15311 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15312 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15313 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15314 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15315 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15316 };
15317
15318 // size_hooks
15319
15320 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15321 {
15322 switch (hash_mode)
15323 {
15324 }
15325 }
15326
15327 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15328 // if not, decrease amplifier and try again
15329
15330 int memory_limit_hit = 0;
15331
15332 if (size_pws > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15333 if (size_tmps > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15334 if (size_hooks > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15335
15336 const u64 size_total
15337 = bitmap_size
15338 + bitmap_size
15339 + bitmap_size
15340 + bitmap_size
15341 + bitmap_size
15342 + bitmap_size
15343 + bitmap_size
15344 + bitmap_size
15345 + size_bfs
15346 + size_combs
15347 + size_digests
15348 + size_esalts
15349 + size_hooks
15350 + size_markov_css
15351 + size_plains
15352 + size_pws
15353 + size_pws // not a bug
15354 + size_results
15355 + size_root_css
15356 + size_rules
15357 + size_rules_c
15358 + size_salts
15359 + size_scryptV
15360 + size_shown
15361 + size_tm
15362 + size_tmps;
15363
15364 if (size_total > device_param->device_global_mem) memory_limit_hit = 1;
15365
15366 if (memory_limit_hit == 1)
15367 {
15368 kernel_accel_max--;
15369
15370 continue;
15371 }
15372
15373 break;
15374 }
15375
15376 if (kernel_accel_max < kernel_accel_min)
15377 {
15378 log_error ("- Device #%u: Device does not provide enough allocatable device-memory to handle this attack", device_id + 1);
15379
15380 return -1;
15381 }
15382
15383 device_param->kernel_accel_min = kernel_accel_min;
15384 device_param->kernel_accel_max = kernel_accel_max;
15385
15386 /*
15387 if (kernel_accel_max < kernel_accel)
15388 {
15389 if (quiet == 0) log_info ("- Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
15390
15391 device_param->kernel_accel = kernel_accel_max;
15392 }
15393 */
15394
15395 device_param->size_bfs = size_bfs;
15396 device_param->size_combs = size_combs;
15397 device_param->size_rules = size_rules;
15398 device_param->size_rules_c = size_rules_c;
15399 device_param->size_pws = size_pws;
15400 device_param->size_tmps = size_tmps;
15401 device_param->size_hooks = size_hooks;
15402
15403 /**
15404 * default building options
15405 */
15406
15407 char cpath[1024] = { 0 };
15408
15409 char build_opts[1024] = { 0 };
15410
15411 #if _WIN
15412
15413 snprintf (cpath, sizeof (cpath) - 1, "%s\\OpenCL\\", shared_dir);
15414
15415 char *cpath_real = mymalloc (MAX_PATH);
15416
15417 if (GetFullPathName (cpath, MAX_PATH, cpath_real, NULL) == 0)
15418 {
15419 log_error ("ERROR: %s: %s", cpath, "GetFullPathName()");
15420
15421 return -1;
15422 }
15423
15424 naive_replace (cpath_real, '\\', '/');
15425
15426 // not escaping here, windows has quotes
15427
15428 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\"", cpath_real);
15429
15430 #else
15431
15432 snprintf (cpath, sizeof (cpath) - 1, "%s/OpenCL/", shared_dir);
15433
15434 char *cpath_real = mymalloc (PATH_MAX);
15435
15436 if (realpath (cpath, cpath_real) == NULL)
15437 {
15438 log_error ("ERROR: %s: %s", cpath, strerror (errno));
15439
15440 return -1;
15441 }
15442
15443 naive_escape (cpath_real, PATH_MAX, ' ', '\\');
15444
15445 snprintf (build_opts, sizeof (build_opts) - 1, "-I %s", cpath_real);
15446
15447 #endif
15448
15449 // include check
15450 // this test needs to be done manually because of osx opencl runtime
15451 // if there's a problem with permission, its not reporting back and erroring out silently
15452
15453 #define files_cnt 15
15454
15455 const char *files_names[files_cnt] =
15456 {
15457 "inc_cipher_aes256.cl",
15458 "inc_cipher_serpent256.cl",
15459 "inc_cipher_twofish256.cl",
15460 "inc_common.cl",
15461 "inc_comp_multi_bs.cl",
15462 "inc_comp_multi.cl",
15463 "inc_comp_single_bs.cl",
15464 "inc_comp_single.cl",
15465 "inc_hash_constants.h",
15466 "inc_hash_functions.cl",
15467 "inc_rp.cl",
15468 "inc_rp.h",
15469 "inc_simd.cl",
15470 "inc_types.cl",
15471 "inc_vendor.cl",
15472 };
15473
15474 for (int i = 0; i < files_cnt; i++)
15475 {
15476 char path[1024] = { 0 };
15477
15478 snprintf (path, sizeof (path) - 1, "%s/%s", cpath_real, files_names[i]);
15479
15480 FILE *fd = fopen (path, "r");
15481
15482 if (fd == NULL)
15483 {
15484 log_error ("ERROR: %s: fopen(): %s", path, strerror (errno));
15485
15486 return -1;
15487 }
15488
15489 char buf[1];
15490
15491 size_t n = fread (buf, 1, 1, fd);
15492
15493 if (n != 1)
15494 {
15495 log_error ("ERROR: %s: fread(): %s", path, strerror (errno));
15496
15497 return -1;
15498 }
15499
15500 fclose (fd);
15501 }
15502
15503 myfree (cpath_real);
15504
15505 // we don't have sm_* on vendors not NV but it doesn't matter
15506
15507 char build_opts_new[1024] = { 0 };
15508
15509 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -D VENDOR_ID=%u -D CUDA_ARCH=%d -D VECT_SIZE=%u -D DEVICE_TYPE=%u -D DGST_R0=%u -D DGST_R1=%u -D DGST_R2=%u -D DGST_R3=%u -D DGST_ELEM=%u -D KERN_TYPE=%u -D _unroll -cl-std=CL1.1", build_opts, device_param->device_vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, data.dgst_pos0, data.dgst_pos1, data.dgst_pos2, data.dgst_pos3, data.dgst_size / 4, kern_type);
15510
15511 strncpy (build_opts, build_opts_new, sizeof (build_opts));
15512
15513 #ifdef DEBUG
15514 log_info ("- Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15515 #endif
15516
15517 /**
15518 * main kernel
15519 */
15520
15521 {
15522 /**
15523 * kernel source filename
15524 */
15525
15526 char source_file[256] = { 0 };
15527
15528 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15529
15530 struct stat sst;
15531
15532 if (stat (source_file, &sst) == -1)
15533 {
15534 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15535
15536 return -1;
15537 }
15538
15539 /**
15540 * kernel cached filename
15541 */
15542
15543 char cached_file[256] = { 0 };
15544
15545 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15546
15547 int cached = 1;
15548
15549 struct stat cst;
15550
15551 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15552 {
15553 cached = 0;
15554 }
15555
15556 /**
15557 * kernel compile or load
15558 */
15559
15560 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15561
15562 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15563
15564 if (force_jit_compilation == -1)
15565 {
15566 if (cached == 0)
15567 {
15568 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));
15569
15570 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15571
15572 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15573
15574 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15575
15576 #ifdef DEBUG
15577 size_t build_log_size = 0;
15578
15579 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15580
15581 if (build_log_size > 1)
15582 {
15583 char *build_log = (char *) malloc (build_log_size + 1);
15584
15585 memset (build_log, 0, build_log_size + 1);
15586
15587 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15588
15589 puts (build_log);
15590
15591 free (build_log);
15592 }
15593 #endif
15594
15595 if (rc != 0)
15596 {
15597 device_param->skipped = true;
15598
15599 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15600
15601 continue;
15602 }
15603
15604 size_t binary_size;
15605
15606 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15607
15608 u8 *binary = (u8 *) mymalloc (binary_size);
15609
15610 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15611
15612 writeProgramBin (cached_file, binary, binary_size);
15613
15614 local_free (binary);
15615 }
15616 else
15617 {
15618 #ifdef DEBUG
15619 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15620 #endif
15621
15622 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15623
15624 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15625
15626 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15627 }
15628 }
15629 else
15630 {
15631 #ifdef DEBUG
15632 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15633 #endif
15634
15635 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15636
15637 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15638
15639 char build_opts_update[1024] = { 0 };
15640
15641 if (force_jit_compilation == 1500)
15642 {
15643 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15644 }
15645 else if (force_jit_compilation == 8900)
15646 {
15647 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);
15648 }
15649 else
15650 {
15651 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15652 }
15653
15654 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15655
15656 #ifdef DEBUG
15657 size_t build_log_size = 0;
15658
15659 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15660
15661 if (build_log_size > 1)
15662 {
15663 char *build_log = (char *) malloc (build_log_size + 1);
15664
15665 memset (build_log, 0, build_log_size + 1);
15666
15667 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15668
15669 puts (build_log);
15670
15671 free (build_log);
15672 }
15673 #endif
15674
15675 if (rc != 0)
15676 {
15677 device_param->skipped = true;
15678
15679 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15680 }
15681 }
15682
15683 local_free (kernel_lengths);
15684 local_free (kernel_sources[0]);
15685 local_free (kernel_sources);
15686 }
15687
15688 /**
15689 * word generator kernel
15690 */
15691
15692 if (attack_mode != ATTACK_MODE_STRAIGHT)
15693 {
15694 /**
15695 * kernel mp source filename
15696 */
15697
15698 char source_file[256] = { 0 };
15699
15700 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15701
15702 struct stat sst;
15703
15704 if (stat (source_file, &sst) == -1)
15705 {
15706 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15707
15708 return -1;
15709 }
15710
15711 /**
15712 * kernel mp cached filename
15713 */
15714
15715 char cached_file[256] = { 0 };
15716
15717 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15718
15719 int cached = 1;
15720
15721 struct stat cst;
15722
15723 if (stat (cached_file, &cst) == -1)
15724 {
15725 cached = 0;
15726 }
15727
15728 /**
15729 * kernel compile or load
15730 */
15731
15732 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15733
15734 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15735
15736 if (cached == 0)
15737 {
15738 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));
15739 if (quiet == 0) log_info ("");
15740
15741 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15742
15743 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15744
15745 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15746
15747 if (rc != 0)
15748 {
15749 device_param->skipped = true;
15750
15751 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15752
15753 continue;
15754 }
15755
15756 size_t binary_size;
15757
15758 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15759
15760 u8 *binary = (u8 *) mymalloc (binary_size);
15761
15762 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15763
15764 writeProgramBin (cached_file, binary, binary_size);
15765
15766 local_free (binary);
15767 }
15768 else
15769 {
15770 #ifdef DEBUG
15771 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15772 #endif
15773
15774 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15775
15776 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15777
15778 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15779 }
15780
15781 local_free (kernel_lengths);
15782 local_free (kernel_sources[0]);
15783 local_free (kernel_sources);
15784 }
15785
15786 /**
15787 * amplifier kernel
15788 */
15789
15790 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15791 {
15792
15793 }
15794 else
15795 {
15796 /**
15797 * kernel amp source filename
15798 */
15799
15800 char source_file[256] = { 0 };
15801
15802 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15803
15804 struct stat sst;
15805
15806 if (stat (source_file, &sst) == -1)
15807 {
15808 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15809
15810 return -1;
15811 }
15812
15813 /**
15814 * kernel amp cached filename
15815 */
15816
15817 char cached_file[256] = { 0 };
15818
15819 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15820
15821 int cached = 1;
15822
15823 struct stat cst;
15824
15825 if (stat (cached_file, &cst) == -1)
15826 {
15827 cached = 0;
15828 }
15829
15830 /**
15831 * kernel compile or load
15832 */
15833
15834 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15835
15836 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15837
15838 if (cached == 0)
15839 {
15840 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));
15841 if (quiet == 0) log_info ("");
15842
15843 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15844
15845 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15846
15847 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15848
15849 if (rc != 0)
15850 {
15851 device_param->skipped = true;
15852
15853 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15854
15855 continue;
15856 }
15857
15858 size_t binary_size;
15859
15860 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15861
15862 u8 *binary = (u8 *) mymalloc (binary_size);
15863
15864 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15865
15866 writeProgramBin (cached_file, binary, binary_size);
15867
15868 local_free (binary);
15869 }
15870 else
15871 {
15872 #ifdef DEBUG
15873 if (quiet == 0) log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15874 #endif
15875
15876 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15877
15878 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15879
15880 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15881 }
15882
15883 local_free (kernel_lengths);
15884 local_free (kernel_sources[0]);
15885 local_free (kernel_sources);
15886 }
15887
15888 // some algorithm collide too fast, make that impossible
15889
15890 if (benchmark == 1)
15891 {
15892 ((uint *) digests_buf)[0] = -1;
15893 ((uint *) digests_buf)[1] = -1;
15894 ((uint *) digests_buf)[2] = -1;
15895 ((uint *) digests_buf)[3] = -1;
15896 }
15897
15898 /**
15899 * global buffers
15900 */
15901
15902 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15903 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15904 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15905 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15906 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15907 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15908 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15909 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15910 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15911 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15912 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15913 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15914 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15915 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15916 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15917 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15918 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15919 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15920
15921 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);
15922 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);
15923 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);
15924 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);
15925 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);
15926 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);
15927 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);
15928 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);
15929 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15930 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15931 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15932
15933 /**
15934 * special buffers
15935 */
15936
15937 if (attack_kern == ATTACK_KERN_STRAIGHT)
15938 {
15939 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15940 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15941
15942 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15943 }
15944 else if (attack_kern == ATTACK_KERN_COMBI)
15945 {
15946 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15947 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15948 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15949 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15950 }
15951 else if (attack_kern == ATTACK_KERN_BF)
15952 {
15953 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15954 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15955 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15956 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15957 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15958 }
15959
15960 if (size_esalts)
15961 {
15962 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15963
15964 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15965 }
15966
15967 /**
15968 * main host data
15969 */
15970
15971 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15972
15973 device_param->pws_buf = pws_buf;
15974
15975 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15976
15977 device_param->combs_buf = combs_buf;
15978
15979 void *hooks_buf = mymalloc (size_hooks);
15980
15981 device_param->hooks_buf = hooks_buf;
15982
15983 /**
15984 * kernel args
15985 */
15986
15987 device_param->kernel_params_buf32[21] = bitmap_mask;
15988 device_param->kernel_params_buf32[22] = bitmap_shift1;
15989 device_param->kernel_params_buf32[23] = bitmap_shift2;
15990 device_param->kernel_params_buf32[24] = 0; // salt_pos
15991 device_param->kernel_params_buf32[25] = 0; // loop_pos
15992 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15993 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15994 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15995 device_param->kernel_params_buf32[29] = 0; // digests_offset
15996 device_param->kernel_params_buf32[30] = 0; // combs_mode
15997 device_param->kernel_params_buf32[31] = 0; // gid_max
15998
15999 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16000 ? &device_param->d_pws_buf
16001 : &device_param->d_pws_amp_buf;
16002 device_param->kernel_params[ 1] = &device_param->d_rules_c;
16003 device_param->kernel_params[ 2] = &device_param->d_combs_c;
16004 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
16005 device_param->kernel_params[ 4] = &device_param->d_tmps;
16006 device_param->kernel_params[ 5] = &device_param->d_hooks;
16007 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
16008 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
16009 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
16010 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
16011 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
16012 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
16013 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
16014 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
16015 device_param->kernel_params[14] = &device_param->d_plain_bufs;
16016 device_param->kernel_params[15] = &device_param->d_digests_buf;
16017 device_param->kernel_params[16] = &device_param->d_digests_shown;
16018 device_param->kernel_params[17] = &device_param->d_salt_bufs;
16019 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
16020 device_param->kernel_params[19] = &device_param->d_result;
16021 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
16022 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
16023 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
16024 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
16025 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
16026 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
16027 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
16028 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
16029 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
16030 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
16031 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
16032 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
16033
16034 device_param->kernel_params_mp_buf64[3] = 0;
16035 device_param->kernel_params_mp_buf32[4] = 0;
16036 device_param->kernel_params_mp_buf32[5] = 0;
16037 device_param->kernel_params_mp_buf32[6] = 0;
16038 device_param->kernel_params_mp_buf32[7] = 0;
16039 device_param->kernel_params_mp_buf32[8] = 0;
16040
16041 device_param->kernel_params_mp[0] = NULL;
16042 device_param->kernel_params_mp[1] = NULL;
16043 device_param->kernel_params_mp[2] = NULL;
16044 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
16045 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
16046 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
16047 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
16048 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
16049 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
16050
16051 device_param->kernel_params_mp_l_buf64[3] = 0;
16052 device_param->kernel_params_mp_l_buf32[4] = 0;
16053 device_param->kernel_params_mp_l_buf32[5] = 0;
16054 device_param->kernel_params_mp_l_buf32[6] = 0;
16055 device_param->kernel_params_mp_l_buf32[7] = 0;
16056 device_param->kernel_params_mp_l_buf32[8] = 0;
16057 device_param->kernel_params_mp_l_buf32[9] = 0;
16058
16059 device_param->kernel_params_mp_l[0] = NULL;
16060 device_param->kernel_params_mp_l[1] = NULL;
16061 device_param->kernel_params_mp_l[2] = NULL;
16062 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
16063 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
16064 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
16065 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
16066 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
16067 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
16068 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
16069
16070 device_param->kernel_params_mp_r_buf64[3] = 0;
16071 device_param->kernel_params_mp_r_buf32[4] = 0;
16072 device_param->kernel_params_mp_r_buf32[5] = 0;
16073 device_param->kernel_params_mp_r_buf32[6] = 0;
16074 device_param->kernel_params_mp_r_buf32[7] = 0;
16075 device_param->kernel_params_mp_r_buf32[8] = 0;
16076
16077 device_param->kernel_params_mp_r[0] = NULL;
16078 device_param->kernel_params_mp_r[1] = NULL;
16079 device_param->kernel_params_mp_r[2] = NULL;
16080 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
16081 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
16082 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
16083 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
16084 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
16085 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
16086
16087 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
16088 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
16089
16090 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
16091 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
16092 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
16093 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
16094 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
16095 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
16096 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
16097
16098 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
16099 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
16100
16101 device_param->kernel_params_memset_buf32[1] = 0; // value
16102 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
16103
16104 device_param->kernel_params_memset[0] = NULL;
16105 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
16106 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
16107
16108 /**
16109 * kernel name
16110 */
16111
16112 size_t kernel_wgs_tmp;
16113
16114 char kernel_name[64] = { 0 };
16115
16116 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16117 {
16118 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16119 {
16120 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
16121
16122 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16123
16124 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
16125
16126 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16127
16128 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
16129
16130 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16131 }
16132 else
16133 {
16134 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
16135
16136 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16137
16138 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
16139
16140 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16141
16142 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
16143
16144 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16145 }
16146
16147 if (data.attack_mode == ATTACK_MODE_BF)
16148 {
16149 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16150 {
16151 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
16152
16153 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16154
16155 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);
16156 }
16157 }
16158 }
16159 else
16160 {
16161 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
16162
16163 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16164
16165 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
16166
16167 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16168
16169 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
16170
16171 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16172
16173 if (opts_type & OPTS_TYPE_HOOK12)
16174 {
16175 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
16176
16177 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16178
16179 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);
16180 }
16181
16182 if (opts_type & OPTS_TYPE_HOOK23)
16183 {
16184 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
16185
16186 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16187
16188 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);
16189 }
16190 }
16191
16192 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);
16193 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);
16194 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);
16195
16196 for (uint i = 0; i <= 20; i++)
16197 {
16198 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
16199 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
16200 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
16201
16202 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
16203 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
16204 }
16205
16206 for (uint i = 21; i <= 31; i++)
16207 {
16208 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
16209 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
16210 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
16211
16212 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
16213 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
16214 }
16215
16216 // GPU memset
16217
16218 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
16219
16220 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);
16221
16222 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
16223 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
16224 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
16225
16226 // MP start
16227
16228 if (attack_mode == ATTACK_MODE_BF)
16229 {
16230 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
16231 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
16232
16233 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);
16234 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);
16235
16236 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16237 {
16238 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
16239 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
16240 }
16241 }
16242 else if (attack_mode == ATTACK_MODE_HYBRID1)
16243 {
16244 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16245
16246 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);
16247 }
16248 else if (attack_mode == ATTACK_MODE_HYBRID2)
16249 {
16250 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16251
16252 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);
16253 }
16254
16255 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16256 {
16257 // nothing to do
16258 }
16259 else
16260 {
16261 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
16262
16263 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);
16264 }
16265
16266 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16267 {
16268 // nothing to do
16269 }
16270 else
16271 {
16272 for (uint i = 0; i < 5; i++)
16273 {
16274 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
16275 }
16276
16277 for (uint i = 5; i < 7; i++)
16278 {
16279 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
16280 }
16281 }
16282
16283 // maybe this has been updated by clGetKernelWorkGroupInfo()
16284 // value can only be decreased, so we don't need to reallocate buffers
16285
16286 device_param->kernel_threads = kernel_threads;
16287
16288 // zero some data buffers
16289
16290 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
16291 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
16292 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
16293 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
16294 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
16295 run_kernel_bzero (device_param, device_param->d_result, size_results);
16296
16297 /**
16298 * special buffers
16299 */
16300
16301 if (attack_kern == ATTACK_KERN_STRAIGHT)
16302 {
16303 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
16304 }
16305 else if (attack_kern == ATTACK_KERN_COMBI)
16306 {
16307 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
16308 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
16309 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16310 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16311 }
16312 else if (attack_kern == ATTACK_KERN_BF)
16313 {
16314 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
16315 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
16316 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
16317 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16318 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16319 }
16320
16321 #if defined(HAVE_HWMON)
16322
16323 /**
16324 * Store initial fanspeed if gpu_temp_retain is enabled
16325 */
16326
16327 if (gpu_temp_disable == 0)
16328 {
16329 if (gpu_temp_retain != 0)
16330 {
16331 hc_thread_mutex_lock (mux_adl);
16332
16333 if (data.hm_device[device_id].fan_get_supported == 1)
16334 {
16335 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
16336 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
16337
16338 // we also set it to tell the OS we take control over the fan and it's automatic controller
16339 // if it was set to automatic. we do not control user-defined fanspeeds.
16340
16341 if (fanpolicy == 1)
16342 {
16343 data.hm_device[device_id].fan_set_supported = 1;
16344
16345 int rc = -1;
16346
16347 if (device_param->device_vendor_id == VENDOR_ID_AMD)
16348 {
16349 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
16350 }
16351 else if (device_param->device_vendor_id == VENDOR_ID_NV)
16352 {
16353 #ifdef LINUX
16354 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE);
16355 #endif
16356
16357 #ifdef WIN
16358 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
16359 #endif
16360 }
16361
16362 if (rc == 0)
16363 {
16364 data.hm_device[device_id].fan_set_supported = 1;
16365 }
16366 else
16367 {
16368 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
16369
16370 data.hm_device[device_id].fan_set_supported = 0;
16371 }
16372 }
16373 else
16374 {
16375 data.hm_device[device_id].fan_set_supported = 0;
16376 }
16377 }
16378
16379 hc_thread_mutex_unlock (mux_adl);
16380 }
16381 }
16382
16383 #endif // HAVE_HWMON
16384 }
16385
16386 if (data.quiet == 0) log_info_nn ("");
16387
16388 /**
16389 * In benchmark-mode, inform user which algorithm is checked
16390 */
16391
16392 if (benchmark == 1)
16393 {
16394 if (machine_readable == 0)
16395 {
16396 quiet = 0;
16397
16398 data.quiet = quiet;
16399
16400 char *hash_type = strhashtype (data.hash_mode); // not a bug
16401
16402 log_info ("Hashtype: %s", hash_type);
16403 log_info ("");
16404 }
16405 }
16406
16407 /**
16408 * keep track of the progress
16409 */
16410
16411 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16412 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16413 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16414
16415 /**
16416 * open filehandles
16417 */
16418
16419 #if _WIN
16420 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
16421 {
16422 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
16423
16424 return (-1);
16425 }
16426
16427 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
16428 {
16429 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
16430
16431 return (-1);
16432 }
16433
16434 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
16435 {
16436 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
16437
16438 return (-1);
16439 }
16440 #endif
16441
16442 /**
16443 * dictionary pad
16444 */
16445
16446 segment_size *= (1024 * 1024);
16447
16448 data.segment_size = segment_size;
16449
16450 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
16451
16452 wl_data->buf = (char *) mymalloc (segment_size);
16453 wl_data->avail = segment_size;
16454 wl_data->incr = segment_size;
16455 wl_data->cnt = 0;
16456 wl_data->pos = 0;
16457
16458 cs_t *css_buf = NULL;
16459 uint css_cnt = 0;
16460 uint dictcnt = 0;
16461 uint maskcnt = 1;
16462 char **masks = NULL;
16463 char **dictfiles = NULL;
16464
16465 uint mask_from_file = 0;
16466
16467 if (attack_mode == ATTACK_MODE_STRAIGHT)
16468 {
16469 if (wordlist_mode == WL_MODE_FILE)
16470 {
16471 int wls_left = myargc - (optind + 1);
16472
16473 for (int i = 0; i < wls_left; i++)
16474 {
16475 char *l0_filename = myargv[optind + 1 + i];
16476
16477 struct stat l0_stat;
16478
16479 if (stat (l0_filename, &l0_stat) == -1)
16480 {
16481 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
16482
16483 return (-1);
16484 }
16485
16486 uint is_dir = S_ISDIR (l0_stat.st_mode);
16487
16488 if (is_dir == 0)
16489 {
16490 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16491
16492 dictcnt++;
16493
16494 dictfiles[dictcnt - 1] = l0_filename;
16495 }
16496 else
16497 {
16498 // do not allow --keyspace w/ a directory
16499
16500 if (keyspace == 1)
16501 {
16502 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16503
16504 return (-1);
16505 }
16506
16507 char **dictionary_files = NULL;
16508
16509 dictionary_files = scan_directory (l0_filename);
16510
16511 if (dictionary_files != NULL)
16512 {
16513 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16514
16515 for (int d = 0; dictionary_files[d] != NULL; d++)
16516 {
16517 char *l1_filename = dictionary_files[d];
16518
16519 struct stat l1_stat;
16520
16521 if (stat (l1_filename, &l1_stat) == -1)
16522 {
16523 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16524
16525 return (-1);
16526 }
16527
16528 if (S_ISREG (l1_stat.st_mode))
16529 {
16530 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16531
16532 dictcnt++;
16533
16534 dictfiles[dictcnt - 1] = strdup (l1_filename);
16535 }
16536 }
16537 }
16538
16539 local_free (dictionary_files);
16540 }
16541 }
16542
16543 if (dictcnt < 1)
16544 {
16545 log_error ("ERROR: No usable dictionary file found.");
16546
16547 return (-1);
16548 }
16549 }
16550 else if (wordlist_mode == WL_MODE_STDIN)
16551 {
16552 dictcnt = 1;
16553 }
16554 }
16555 else if (attack_mode == ATTACK_MODE_COMBI)
16556 {
16557 // display
16558
16559 char *dictfile1 = myargv[optind + 1 + 0];
16560 char *dictfile2 = myargv[optind + 1 + 1];
16561
16562 // find the bigger dictionary and use as base
16563
16564 FILE *fp1 = NULL;
16565 FILE *fp2 = NULL;
16566
16567 struct stat tmp_stat;
16568
16569 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16570 {
16571 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16572
16573 return (-1);
16574 }
16575
16576 if (stat (dictfile1, &tmp_stat) == -1)
16577 {
16578 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16579
16580 fclose (fp1);
16581
16582 return (-1);
16583 }
16584
16585 if (S_ISDIR (tmp_stat.st_mode))
16586 {
16587 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16588
16589 fclose (fp1);
16590
16591 return (-1);
16592 }
16593
16594 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16595 {
16596 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16597
16598 fclose (fp1);
16599
16600 return (-1);
16601 }
16602
16603 if (stat (dictfile2, &tmp_stat) == -1)
16604 {
16605 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16606
16607 fclose (fp1);
16608 fclose (fp2);
16609
16610 return (-1);
16611 }
16612
16613 if (S_ISDIR (tmp_stat.st_mode))
16614 {
16615 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16616
16617 fclose (fp1);
16618 fclose (fp2);
16619
16620 return (-1);
16621 }
16622
16623 data.combs_cnt = 1;
16624
16625 data.quiet = 1;
16626
16627 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16628
16629 data.quiet = quiet;
16630
16631 if (words1_cnt == 0)
16632 {
16633 log_error ("ERROR: %s: empty file", dictfile1);
16634
16635 fclose (fp1);
16636 fclose (fp2);
16637
16638 return (-1);
16639 }
16640
16641 data.combs_cnt = 1;
16642
16643 data.quiet = 1;
16644
16645 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16646
16647 data.quiet = quiet;
16648
16649 if (words2_cnt == 0)
16650 {
16651 log_error ("ERROR: %s: empty file", dictfile2);
16652
16653 fclose (fp1);
16654 fclose (fp2);
16655
16656 return (-1);
16657 }
16658
16659 fclose (fp1);
16660 fclose (fp2);
16661
16662 data.dictfile = dictfile1;
16663 data.dictfile2 = dictfile2;
16664
16665 if (words1_cnt >= words2_cnt)
16666 {
16667 data.combs_cnt = words2_cnt;
16668 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16669
16670 dictfiles = &data.dictfile;
16671
16672 dictcnt = 1;
16673 }
16674 else
16675 {
16676 data.combs_cnt = words1_cnt;
16677 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16678
16679 dictfiles = &data.dictfile2;
16680
16681 dictcnt = 1;
16682
16683 // we also have to switch wordlist related rules!
16684
16685 char *tmpc = data.rule_buf_l;
16686
16687 data.rule_buf_l = data.rule_buf_r;
16688 data.rule_buf_r = tmpc;
16689
16690 int tmpi = data.rule_len_l;
16691
16692 data.rule_len_l = data.rule_len_r;
16693 data.rule_len_r = tmpi;
16694 }
16695 }
16696 else if (attack_mode == ATTACK_MODE_BF)
16697 {
16698 char *mask = NULL;
16699
16700 maskcnt = 0;
16701
16702 if (benchmark == 0)
16703 {
16704 mask = myargv[optind + 1];
16705
16706 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16707
16708 if ((optind + 2) <= myargc)
16709 {
16710 struct stat file_stat;
16711
16712 if (stat (mask, &file_stat) == -1)
16713 {
16714 maskcnt = 1;
16715
16716 masks[maskcnt - 1] = mystrdup (mask);
16717 }
16718 else
16719 {
16720 int wls_left = myargc - (optind + 1);
16721
16722 uint masks_avail = INCR_MASKS;
16723
16724 for (int i = 0; i < wls_left; i++)
16725 {
16726 if (i != 0)
16727 {
16728 mask = myargv[optind + 1 + i];
16729
16730 if (stat (mask, &file_stat) == -1)
16731 {
16732 log_error ("ERROR: %s: %s", mask, strerror (errno));
16733
16734 return (-1);
16735 }
16736 }
16737
16738 uint is_file = S_ISREG (file_stat.st_mode);
16739
16740 if (is_file == 1)
16741 {
16742 FILE *mask_fp;
16743
16744 if ((mask_fp = fopen (mask, "r")) == NULL)
16745 {
16746 log_error ("ERROR: %s: %s", mask, strerror (errno));
16747
16748 return (-1);
16749 }
16750
16751 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16752
16753 while (!feof (mask_fp))
16754 {
16755 memset (line_buf, 0, HCBUFSIZ);
16756
16757 int line_len = fgetl (mask_fp, line_buf);
16758
16759 if (line_len == 0) continue;
16760
16761 if (line_buf[0] == '#') continue;
16762
16763 if (masks_avail == maskcnt)
16764 {
16765 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16766
16767 masks_avail += INCR_MASKS;
16768 }
16769
16770 masks[maskcnt] = mystrdup (line_buf);
16771
16772 maskcnt++;
16773 }
16774
16775 myfree (line_buf);
16776
16777 fclose (mask_fp);
16778 }
16779 else
16780 {
16781 log_error ("ERROR: %s: unsupported file-type", mask);
16782
16783 return (-1);
16784 }
16785 }
16786
16787 mask_from_file = 1;
16788 }
16789 }
16790 else
16791 {
16792 custom_charset_1 = (char *) "?l?d?u";
16793 custom_charset_2 = (char *) "?l?d";
16794 custom_charset_3 = (char *) "?l?d*!$@_";
16795
16796 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16797 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16798 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16799
16800 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16801
16802 wordlist_mode = WL_MODE_MASK;
16803
16804 data.wordlist_mode = wordlist_mode;
16805
16806 increment = 1;
16807
16808 maskcnt = 1;
16809 }
16810 }
16811 else
16812 {
16813 /**
16814 * generate full masks and charsets
16815 */
16816
16817 masks = (char **) mymalloc (sizeof (char *));
16818
16819 switch (hash_mode)
16820 {
16821 case 1731: pw_min = 5;
16822 pw_max = 5;
16823 mask = mystrdup ("?b?b?b?b?b");
16824 break;
16825 case 12500: pw_min = 5;
16826 pw_max = 5;
16827 mask = mystrdup ("?b?b?b?b?b");
16828 break;
16829 default: pw_min = 7;
16830 pw_max = 7;
16831 mask = mystrdup ("?b?b?b?b?b?b?b");
16832 break;
16833 }
16834
16835 maskcnt = 1;
16836
16837 masks[maskcnt - 1] = mystrdup (mask);
16838
16839 wordlist_mode = WL_MODE_MASK;
16840
16841 data.wordlist_mode = wordlist_mode;
16842
16843 increment = 1;
16844 }
16845
16846 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16847
16848 if (increment)
16849 {
16850 if (increment_min > pw_min) pw_min = increment_min;
16851
16852 if (increment_max < pw_max) pw_max = increment_max;
16853 }
16854 }
16855 else if (attack_mode == ATTACK_MODE_HYBRID1)
16856 {
16857 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16858
16859 // display
16860
16861 char *mask = myargv[myargc - 1];
16862
16863 maskcnt = 0;
16864
16865 masks = (char **) mymalloc (1 * sizeof (char *));
16866
16867 // mod
16868
16869 struct stat file_stat;
16870
16871 if (stat (mask, &file_stat) == -1)
16872 {
16873 maskcnt = 1;
16874
16875 masks[maskcnt - 1] = mystrdup (mask);
16876 }
16877 else
16878 {
16879 uint is_file = S_ISREG (file_stat.st_mode);
16880
16881 if (is_file == 1)
16882 {
16883 FILE *mask_fp;
16884
16885 if ((mask_fp = fopen (mask, "r")) == NULL)
16886 {
16887 log_error ("ERROR: %s: %s", mask, strerror (errno));
16888
16889 return (-1);
16890 }
16891
16892 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16893
16894 uint masks_avail = 1;
16895
16896 while (!feof (mask_fp))
16897 {
16898 memset (line_buf, 0, HCBUFSIZ);
16899
16900 int line_len = fgetl (mask_fp, line_buf);
16901
16902 if (line_len == 0) continue;
16903
16904 if (line_buf[0] == '#') continue;
16905
16906 if (masks_avail == maskcnt)
16907 {
16908 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16909
16910 masks_avail += INCR_MASKS;
16911 }
16912
16913 masks[maskcnt] = mystrdup (line_buf);
16914
16915 maskcnt++;
16916 }
16917
16918 myfree (line_buf);
16919
16920 fclose (mask_fp);
16921
16922 mask_from_file = 1;
16923 }
16924 else
16925 {
16926 maskcnt = 1;
16927
16928 masks[maskcnt - 1] = mystrdup (mask);
16929 }
16930 }
16931
16932 // base
16933
16934 int wls_left = myargc - (optind + 2);
16935
16936 for (int i = 0; i < wls_left; i++)
16937 {
16938 char *filename = myargv[optind + 1 + i];
16939
16940 struct stat file_stat;
16941
16942 if (stat (filename, &file_stat) == -1)
16943 {
16944 log_error ("ERROR: %s: %s", filename, strerror (errno));
16945
16946 return (-1);
16947 }
16948
16949 uint is_dir = S_ISDIR (file_stat.st_mode);
16950
16951 if (is_dir == 0)
16952 {
16953 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16954
16955 dictcnt++;
16956
16957 dictfiles[dictcnt - 1] = filename;
16958 }
16959 else
16960 {
16961 // do not allow --keyspace w/ a directory
16962
16963 if (keyspace == 1)
16964 {
16965 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16966
16967 return (-1);
16968 }
16969
16970 char **dictionary_files = NULL;
16971
16972 dictionary_files = scan_directory (filename);
16973
16974 if (dictionary_files != NULL)
16975 {
16976 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16977
16978 for (int d = 0; dictionary_files[d] != NULL; d++)
16979 {
16980 char *l1_filename = dictionary_files[d];
16981
16982 struct stat l1_stat;
16983
16984 if (stat (l1_filename, &l1_stat) == -1)
16985 {
16986 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16987
16988 return (-1);
16989 }
16990
16991 if (S_ISREG (l1_stat.st_mode))
16992 {
16993 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16994
16995 dictcnt++;
16996
16997 dictfiles[dictcnt - 1] = strdup (l1_filename);
16998 }
16999 }
17000 }
17001
17002 local_free (dictionary_files);
17003 }
17004 }
17005
17006 if (dictcnt < 1)
17007 {
17008 log_error ("ERROR: No usable dictionary file found.");
17009
17010 return (-1);
17011 }
17012
17013 if (increment)
17014 {
17015 maskcnt = 0;
17016
17017 uint mask_min = increment_min; // we can't reject smaller masks here
17018 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17019
17020 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17021 {
17022 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17023
17024 if (cur_mask == NULL) break;
17025
17026 masks[maskcnt] = cur_mask;
17027
17028 maskcnt++;
17029
17030 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17031 }
17032 }
17033 }
17034 else if (attack_mode == ATTACK_MODE_HYBRID2)
17035 {
17036 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
17037
17038 // display
17039
17040 char *mask = myargv[optind + 1 + 0];
17041
17042 maskcnt = 0;
17043
17044 masks = (char **) mymalloc (1 * sizeof (char *));
17045
17046 // mod
17047
17048 struct stat file_stat;
17049
17050 if (stat (mask, &file_stat) == -1)
17051 {
17052 maskcnt = 1;
17053
17054 masks[maskcnt - 1] = mystrdup (mask);
17055 }
17056 else
17057 {
17058 uint is_file = S_ISREG (file_stat.st_mode);
17059
17060 if (is_file == 1)
17061 {
17062 FILE *mask_fp;
17063
17064 if ((mask_fp = fopen (mask, "r")) == NULL)
17065 {
17066 log_error ("ERROR: %s: %s", mask, strerror (errno));
17067
17068 return (-1);
17069 }
17070
17071 char *line_buf = (char *) mymalloc (HCBUFSIZ);
17072
17073 uint masks_avail = 1;
17074
17075 while (!feof (mask_fp))
17076 {
17077 memset (line_buf, 0, HCBUFSIZ);
17078
17079 int line_len = fgetl (mask_fp, line_buf);
17080
17081 if (line_len == 0) continue;
17082
17083 if (line_buf[0] == '#') continue;
17084
17085 if (masks_avail == maskcnt)
17086 {
17087 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
17088
17089 masks_avail += INCR_MASKS;
17090 }
17091
17092 masks[maskcnt] = mystrdup (line_buf);
17093
17094 maskcnt++;
17095 }
17096
17097 myfree (line_buf);
17098
17099 fclose (mask_fp);
17100
17101 mask_from_file = 1;
17102 }
17103 else
17104 {
17105 maskcnt = 1;
17106
17107 masks[maskcnt - 1] = mystrdup (mask);
17108 }
17109 }
17110
17111 // base
17112
17113 int wls_left = myargc - (optind + 2);
17114
17115 for (int i = 0; i < wls_left; i++)
17116 {
17117 char *filename = myargv[optind + 2 + i];
17118
17119 struct stat file_stat;
17120
17121 if (stat (filename, &file_stat) == -1)
17122 {
17123 log_error ("ERROR: %s: %s", filename, strerror (errno));
17124
17125 return (-1);
17126 }
17127
17128 uint is_dir = S_ISDIR (file_stat.st_mode);
17129
17130 if (is_dir == 0)
17131 {
17132 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17133
17134 dictcnt++;
17135
17136 dictfiles[dictcnt - 1] = filename;
17137 }
17138 else
17139 {
17140 // do not allow --keyspace w/ a directory
17141
17142 if (keyspace == 1)
17143 {
17144 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17145
17146 return (-1);
17147 }
17148
17149 char **dictionary_files = NULL;
17150
17151 dictionary_files = scan_directory (filename);
17152
17153 if (dictionary_files != NULL)
17154 {
17155 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17156
17157 for (int d = 0; dictionary_files[d] != NULL; d++)
17158 {
17159 char *l1_filename = dictionary_files[d];
17160
17161 struct stat l1_stat;
17162
17163 if (stat (l1_filename, &l1_stat) == -1)
17164 {
17165 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17166
17167 return (-1);
17168 }
17169
17170 if (S_ISREG (l1_stat.st_mode))
17171 {
17172 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17173
17174 dictcnt++;
17175
17176 dictfiles[dictcnt - 1] = strdup (l1_filename);
17177 }
17178 }
17179 }
17180
17181 local_free (dictionary_files);
17182 }
17183 }
17184
17185 if (dictcnt < 1)
17186 {
17187 log_error ("ERROR: No usable dictionary file found.");
17188
17189 return (-1);
17190 }
17191
17192 if (increment)
17193 {
17194 maskcnt = 0;
17195
17196 uint mask_min = increment_min; // we can't reject smaller masks here
17197 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17198
17199 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17200 {
17201 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17202
17203 if (cur_mask == NULL) break;
17204
17205 masks[maskcnt] = cur_mask;
17206
17207 maskcnt++;
17208
17209 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17210 }
17211 }
17212 }
17213
17214 data.pw_min = pw_min;
17215 data.pw_max = pw_max;
17216
17217 /**
17218 * weak hash check
17219 */
17220
17221 if (weak_hash_threshold >= salts_cnt)
17222 {
17223 hc_device_param_t *device_param = NULL;
17224
17225 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17226 {
17227 device_param = &data.devices_param[device_id];
17228
17229 if (device_param->skipped) continue;
17230
17231 break;
17232 }
17233
17234 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
17235
17236 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
17237 {
17238 weak_hash_check (device_param, salt_pos);
17239 }
17240
17241 // Display hack, guarantee that there is at least one \r before real start
17242
17243 //if (data.quiet == 0) log_info ("");
17244 }
17245
17246 /**
17247 * status and monitor threads
17248 */
17249
17250 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17251 {
17252 data.devices_status = STATUS_STARTING;
17253 }
17254
17255 uint inner_threads_cnt = 0;
17256
17257 hc_thread_t *inner_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17258
17259 data.shutdown_inner = 0;
17260
17261 /**
17262 * Outfile remove
17263 */
17264
17265 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
17266 {
17267 hc_thread_create (inner_threads[inner_threads_cnt], thread_monitor, NULL);
17268
17269 inner_threads_cnt++;
17270
17271 if (outfile_check_timer != 0)
17272 {
17273 if (data.outfile_check_directory != NULL)
17274 {
17275 if ((hash_mode != 5200) &&
17276 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
17277 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
17278 (hash_mode != 9000))
17279 {
17280 hc_thread_create (inner_threads[inner_threads_cnt], thread_outfile_remove, NULL);
17281
17282 inner_threads_cnt++;
17283 }
17284 else
17285 {
17286 outfile_check_timer = 0;
17287 }
17288 }
17289 else
17290 {
17291 outfile_check_timer = 0;
17292 }
17293 }
17294 }
17295
17296 /**
17297 * Inform the user if we got some hashes remove because of the pot file remove feature
17298 */
17299
17300 if (data.quiet == 0)
17301 {
17302 if (potfile_remove_cracks > 0)
17303 {
17304 if (potfile_remove_cracks == 1) log_info ("INFO: Removed 1 hash found in pot file\n");
17305 else log_info ("INFO: Removed %u hashes found in pot file\n", potfile_remove_cracks);
17306 }
17307 }
17308
17309 data.outfile_check_timer = outfile_check_timer;
17310
17311 /**
17312 * main loop
17313 */
17314
17315 char **induction_dictionaries = NULL;
17316
17317 int induction_dictionaries_cnt = 0;
17318
17319 hcstat_table_t *root_table_buf = NULL;
17320 hcstat_table_t *markov_table_buf = NULL;
17321
17322 uint initial_restore_done = 0;
17323
17324 data.maskcnt = maskcnt;
17325
17326 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
17327 {
17328 if (data.devices_status == STATUS_CRACKED) continue;
17329 if (data.devices_status == STATUS_ABORTED) continue;
17330 if (data.devices_status == STATUS_QUIT) continue;
17331
17332 if (maskpos > rd->maskpos)
17333 {
17334 rd->dictpos = 0;
17335 }
17336
17337 rd->maskpos = maskpos;
17338 data.maskpos = maskpos;
17339
17340 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
17341 {
17342 char *mask = masks[maskpos];
17343
17344 if (mask_from_file == 1)
17345 {
17346 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
17347
17348 char *str_ptr;
17349 uint str_pos;
17350
17351 uint mask_offset = 0;
17352
17353 uint separator_cnt;
17354
17355 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
17356 {
17357 str_ptr = strstr (mask + mask_offset, ",");
17358
17359 if (str_ptr == NULL) break;
17360
17361 str_pos = str_ptr - mask;
17362
17363 // escaped separator, i.e. "\,"
17364
17365 if (str_pos > 0)
17366 {
17367 if (mask[str_pos - 1] == '\\')
17368 {
17369 separator_cnt --;
17370
17371 mask_offset = str_pos + 1;
17372
17373 continue;
17374 }
17375 }
17376
17377 // reset the offset
17378
17379 mask_offset = 0;
17380
17381 mask[str_pos] = '\0';
17382
17383 switch (separator_cnt)
17384 {
17385 case 0:
17386 mp_reset_usr (mp_usr, 0);
17387
17388 custom_charset_1 = mask;
17389 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17390 break;
17391
17392 case 1:
17393 mp_reset_usr (mp_usr, 1);
17394
17395 custom_charset_2 = mask;
17396 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17397 break;
17398
17399 case 2:
17400 mp_reset_usr (mp_usr, 2);
17401
17402 custom_charset_3 = mask;
17403 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17404 break;
17405
17406 case 3:
17407 mp_reset_usr (mp_usr, 3);
17408
17409 custom_charset_4 = mask;
17410 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
17411 break;
17412 }
17413
17414 mask = mask + str_pos + 1;
17415 }
17416 }
17417
17418 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17419 {
17420 if (maskpos > 0)
17421 {
17422 local_free (css_buf);
17423 local_free (data.root_css_buf);
17424 local_free (data.markov_css_buf);
17425
17426 local_free (masks[maskpos - 1]);
17427 }
17428
17429 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17430
17431 data.mask = mask;
17432 data.css_cnt = css_cnt;
17433 data.css_buf = css_buf;
17434
17435 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17436
17437 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17438
17439 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17440 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17441
17442 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17443
17444 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17445
17446 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17447 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17448
17449 data.root_css_buf = root_css_buf;
17450 data.markov_css_buf = markov_css_buf;
17451
17452 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17453
17454 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17455
17456 local_free (root_table_buf);
17457 local_free (markov_table_buf);
17458
17459 // args
17460
17461 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17462 {
17463 hc_device_param_t *device_param = &data.devices_param[device_id];
17464
17465 if (device_param->skipped) continue;
17466
17467 device_param->kernel_params_mp[0] = &device_param->d_combs;
17468 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
17469 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
17470
17471 device_param->kernel_params_mp_buf64[3] = 0;
17472 device_param->kernel_params_mp_buf32[4] = css_cnt;
17473 device_param->kernel_params_mp_buf32[5] = 0;
17474 device_param->kernel_params_mp_buf32[6] = 0;
17475 device_param->kernel_params_mp_buf32[7] = 0;
17476
17477 if (attack_mode == ATTACK_MODE_HYBRID1)
17478 {
17479 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
17480 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
17481 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
17482 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
17483 }
17484 else if (attack_mode == ATTACK_MODE_HYBRID2)
17485 {
17486 device_param->kernel_params_mp_buf32[5] = 0;
17487 device_param->kernel_params_mp_buf32[6] = 0;
17488 device_param->kernel_params_mp_buf32[7] = 0;
17489 }
17490
17491 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]);
17492 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]);
17493 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]);
17494
17495 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);
17496 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);
17497 }
17498 }
17499 else if (attack_mode == ATTACK_MODE_BF)
17500 {
17501 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
17502
17503 if (increment)
17504 {
17505 for (uint i = 0; i < dictcnt; i++)
17506 {
17507 local_free (dictfiles[i]);
17508 }
17509
17510 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17511 {
17512 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17513
17514 if (l1_filename == NULL) break;
17515
17516 dictcnt++;
17517
17518 dictfiles[dictcnt - 1] = l1_filename;
17519 }
17520 }
17521 else
17522 {
17523 dictcnt++;
17524
17525 dictfiles[dictcnt - 1] = mask;
17526 }
17527
17528 if (dictcnt == 0)
17529 {
17530 log_error ("ERROR: Mask is too small");
17531
17532 return (-1);
17533 }
17534 }
17535 }
17536
17537 free (induction_dictionaries);
17538
17539 // induction_dictionaries_cnt = 0; // implied
17540
17541 if (attack_mode != ATTACK_MODE_BF)
17542 {
17543 if (keyspace == 0)
17544 {
17545 induction_dictionaries = scan_directory (induction_directory);
17546
17547 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17548 }
17549 }
17550
17551 if (induction_dictionaries_cnt)
17552 {
17553 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17554 }
17555
17556 /**
17557 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17558 */
17559 if (keyspace == 1)
17560 {
17561 if ((maskcnt > 1) || (dictcnt > 1))
17562 {
17563 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17564
17565 return (-1);
17566 }
17567 }
17568
17569 for (uint dictpos = rd->dictpos; dictpos < dictcnt; dictpos++)
17570 {
17571 if (data.devices_status == STATUS_CRACKED) continue;
17572 if (data.devices_status == STATUS_ABORTED) continue;
17573 if (data.devices_status == STATUS_QUIT) continue;
17574
17575 rd->dictpos = dictpos;
17576
17577 char *subid = logfile_generate_subid ();
17578
17579 data.subid = subid;
17580
17581 logfile_sub_msg ("START");
17582
17583 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17584 {
17585 data.devices_status = STATUS_INIT;
17586 }
17587
17588 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17589 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17590 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17591
17592 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17593
17594 data.cpt_pos = 0;
17595
17596 data.cpt_start = time (NULL);
17597
17598 data.cpt_total = 0;
17599
17600 if (data.restore == 0)
17601 {
17602 rd->words_cur = skip;
17603
17604 skip = 0;
17605
17606 data.skip = 0;
17607 }
17608
17609 data.ms_paused = 0;
17610
17611 data.kernel_power_final = 0;
17612
17613 data.words_cur = rd->words_cur;
17614
17615 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17616 {
17617 hc_device_param_t *device_param = &data.devices_param[device_id];
17618
17619 if (device_param->skipped) continue;
17620
17621 device_param->speed_pos = 0;
17622
17623 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17624 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17625
17626 device_param->exec_pos = 0;
17627
17628 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17629
17630 device_param->outerloop_pos = 0;
17631 device_param->outerloop_left = 0;
17632 device_param->innerloop_pos = 0;
17633 device_param->innerloop_left = 0;
17634
17635 // some more resets:
17636
17637 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17638
17639 device_param->pws_cnt = 0;
17640
17641 device_param->words_off = 0;
17642 device_param->words_done = 0;
17643 }
17644
17645 // figure out some workload
17646
17647 if (attack_mode == ATTACK_MODE_STRAIGHT)
17648 {
17649 if (data.wordlist_mode == WL_MODE_FILE)
17650 {
17651 char *dictfile = NULL;
17652
17653 if (induction_dictionaries_cnt)
17654 {
17655 dictfile = induction_dictionaries[0];
17656 }
17657 else
17658 {
17659 dictfile = dictfiles[dictpos];
17660 }
17661
17662 data.dictfile = dictfile;
17663
17664 logfile_sub_string (dictfile);
17665
17666 for (uint i = 0; i < rp_files_cnt; i++)
17667 {
17668 logfile_sub_var_string ("rulefile", rp_files[i]);
17669 }
17670
17671 FILE *fd2 = fopen (dictfile, "rb");
17672
17673 if (fd2 == NULL)
17674 {
17675 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17676
17677 return (-1);
17678 }
17679
17680 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17681
17682 fclose (fd2);
17683
17684 if (data.words_cnt == 0)
17685 {
17686 logfile_sub_msg ("STOP");
17687
17688 continue;
17689 }
17690 }
17691 }
17692 else if (attack_mode == ATTACK_MODE_COMBI)
17693 {
17694 char *dictfile = data.dictfile;
17695 char *dictfile2 = data.dictfile2;
17696
17697 logfile_sub_string (dictfile);
17698 logfile_sub_string (dictfile2);
17699
17700 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17701 {
17702 FILE *fd2 = fopen (dictfile, "rb");
17703
17704 if (fd2 == NULL)
17705 {
17706 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17707
17708 return (-1);
17709 }
17710
17711 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17712
17713 fclose (fd2);
17714 }
17715 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17716 {
17717 FILE *fd2 = fopen (dictfile2, "rb");
17718
17719 if (fd2 == NULL)
17720 {
17721 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17722
17723 return (-1);
17724 }
17725
17726 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17727
17728 fclose (fd2);
17729 }
17730
17731 if (data.words_cnt == 0)
17732 {
17733 logfile_sub_msg ("STOP");
17734
17735 continue;
17736 }
17737 }
17738 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17739 {
17740 char *dictfile = NULL;
17741
17742 if (induction_dictionaries_cnt)
17743 {
17744 dictfile = induction_dictionaries[0];
17745 }
17746 else
17747 {
17748 dictfile = dictfiles[dictpos];
17749 }
17750
17751 data.dictfile = dictfile;
17752
17753 char *mask = data.mask;
17754
17755 logfile_sub_string (dictfile);
17756 logfile_sub_string (mask);
17757
17758 FILE *fd2 = fopen (dictfile, "rb");
17759
17760 if (fd2 == NULL)
17761 {
17762 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17763
17764 return (-1);
17765 }
17766
17767 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17768
17769 fclose (fd2);
17770
17771 if (data.words_cnt == 0)
17772 {
17773 logfile_sub_msg ("STOP");
17774
17775 continue;
17776 }
17777 }
17778 else if (attack_mode == ATTACK_MODE_BF)
17779 {
17780 local_free (css_buf);
17781 local_free (data.root_css_buf);
17782 local_free (data.markov_css_buf);
17783
17784 char *mask = dictfiles[dictpos];
17785
17786 logfile_sub_string (mask);
17787
17788 // base
17789
17790 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17791
17792 if (opts_type & OPTS_TYPE_PT_UNICODE)
17793 {
17794 uint css_cnt_unicode = css_cnt * 2;
17795
17796 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17797
17798 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17799 {
17800 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17801
17802 css_buf_unicode[j + 1].cs_buf[0] = 0;
17803 css_buf_unicode[j + 1].cs_len = 1;
17804 }
17805
17806 free (css_buf);
17807
17808 css_buf = css_buf_unicode;
17809 css_cnt = css_cnt_unicode;
17810 }
17811
17812 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17813
17814 uint mask_min = pw_min;
17815 uint mask_max = pw_max;
17816
17817 if (opts_type & OPTS_TYPE_PT_UNICODE)
17818 {
17819 mask_min *= 2;
17820 mask_max *= 2;
17821 }
17822
17823 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17824 {
17825 if (css_cnt < mask_min)
17826 {
17827 log_info ("WARNING: Skipping mask '%s' because it is smaller than the minimum password length", mask);
17828 }
17829
17830 if (css_cnt > mask_max)
17831 {
17832 log_info ("WARNING: Skipping mask '%s' because it is larger than the maximum password length", mask);
17833 }
17834
17835 // skip to next mask
17836
17837 logfile_sub_msg ("STOP");
17838
17839 continue;
17840 }
17841
17842 uint save_css_cnt = css_cnt;
17843
17844 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17845 {
17846 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17847 {
17848 uint salt_len = (uint) data.salts_buf[0].salt_len;
17849 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17850
17851 uint css_cnt_salt = css_cnt + salt_len;
17852
17853 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17854
17855 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17856
17857 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17858 {
17859 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17860 css_buf_salt[j].cs_len = 1;
17861 }
17862
17863 free (css_buf);
17864
17865 css_buf = css_buf_salt;
17866 css_cnt = css_cnt_salt;
17867 }
17868 }
17869
17870 data.mask = mask;
17871 data.css_cnt = css_cnt;
17872 data.css_buf = css_buf;
17873
17874 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17875
17876 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17877
17878 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17879
17880 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17881 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17882
17883 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17884
17885 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17886
17887 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17888 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17889
17890 data.root_css_buf = root_css_buf;
17891 data.markov_css_buf = markov_css_buf;
17892
17893 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17894
17895 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17896
17897 local_free (root_table_buf);
17898 local_free (markov_table_buf);
17899
17900 // copy + args
17901
17902 uint css_cnt_l = css_cnt;
17903 uint css_cnt_r;
17904
17905 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17906 {
17907 if (save_css_cnt < 6)
17908 {
17909 css_cnt_r = 1;
17910 }
17911 else if (save_css_cnt == 6)
17912 {
17913 css_cnt_r = 2;
17914 }
17915 else
17916 {
17917 if (opts_type & OPTS_TYPE_PT_UNICODE)
17918 {
17919 if (save_css_cnt == 8 || save_css_cnt == 10)
17920 {
17921 css_cnt_r = 2;
17922 }
17923 else
17924 {
17925 css_cnt_r = 4;
17926 }
17927 }
17928 else
17929 {
17930 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17931 {
17932 css_cnt_r = 3;
17933 }
17934 else
17935 {
17936 css_cnt_r = 4;
17937 }
17938 }
17939 }
17940 }
17941 else
17942 {
17943 css_cnt_r = 1;
17944
17945 /* unfinished code?
17946 int sum = css_buf[css_cnt_r - 1].cs_len;
17947
17948 for (uint i = 1; i < 4 && i < css_cnt; i++)
17949 {
17950 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17951
17952 css_cnt_r++;
17953
17954 sum *= css_buf[css_cnt_r - 1].cs_len;
17955 }
17956 */
17957 }
17958
17959 css_cnt_l -= css_cnt_r;
17960
17961 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17962
17963 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17964 {
17965 hc_device_param_t *device_param = &data.devices_param[device_id];
17966
17967 if (device_param->skipped) continue;
17968
17969 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17970 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17971 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17972
17973 device_param->kernel_params_mp_l_buf64[3] = 0;
17974 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17975 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17976 device_param->kernel_params_mp_l_buf32[6] = 0;
17977 device_param->kernel_params_mp_l_buf32[7] = 0;
17978 device_param->kernel_params_mp_l_buf32[8] = 0;
17979
17980 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17981 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17982 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17983 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17984
17985 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17986 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17987 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17988
17989 device_param->kernel_params_mp_r_buf64[3] = 0;
17990 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17991 device_param->kernel_params_mp_r_buf32[5] = 0;
17992 device_param->kernel_params_mp_r_buf32[6] = 0;
17993 device_param->kernel_params_mp_r_buf32[7] = 0;
17994
17995 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]);
17996 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]);
17997 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]);
17998
17999 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]);
18000 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]);
18001 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]);
18002
18003 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);
18004 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);
18005 }
18006 }
18007
18008 u64 words_base = data.words_cnt;
18009
18010 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18011 {
18012 if (data.kernel_rules_cnt)
18013 {
18014 words_base /= data.kernel_rules_cnt;
18015 }
18016 }
18017 else if (data.attack_kern == ATTACK_KERN_COMBI)
18018 {
18019 if (data.combs_cnt)
18020 {
18021 words_base /= data.combs_cnt;
18022 }
18023 }
18024 else if (data.attack_kern == ATTACK_KERN_BF)
18025 {
18026 if (data.bfs_cnt)
18027 {
18028 words_base /= data.bfs_cnt;
18029 }
18030 }
18031
18032 data.words_base = words_base;
18033
18034 if (keyspace == 1)
18035 {
18036 log_info ("%llu", (unsigned long long int) words_base);
18037
18038 return (0);
18039 }
18040
18041 if (data.words_cur > data.words_base)
18042 {
18043 log_error ("ERROR: Restore value greater keyspace");
18044
18045 return (-1);
18046 }
18047
18048 if (data.words_cur)
18049 {
18050 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18051 {
18052 for (uint i = 0; i < data.salts_cnt; i++)
18053 {
18054 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
18055 }
18056 }
18057 else if (data.attack_kern == ATTACK_KERN_COMBI)
18058 {
18059 for (uint i = 0; i < data.salts_cnt; i++)
18060 {
18061 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
18062 }
18063 }
18064 else if (data.attack_kern == ATTACK_KERN_BF)
18065 {
18066 for (uint i = 0; i < data.salts_cnt; i++)
18067 {
18068 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
18069 }
18070 }
18071 }
18072
18073 /*
18074 * Update loopback file
18075 */
18076
18077 if (loopback == 1)
18078 {
18079 time_t now;
18080
18081 time (&now);
18082
18083 uint random_num = get_random_num (0, 9999);
18084
18085 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
18086
18087 data.loopback_file = loopback_file;
18088 }
18089
18090 /*
18091 * Update dictionary statistic
18092 */
18093
18094 if (keyspace == 0)
18095 {
18096 dictstat_fp = fopen (dictstat, "wb");
18097
18098 if (dictstat_fp)
18099 {
18100 lock_file (dictstat_fp);
18101
18102 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
18103
18104 fclose (dictstat_fp);
18105 }
18106 }
18107
18108 /**
18109 * create autotune threads
18110 */
18111
18112 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
18113
18114 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18115 {
18116 data.devices_status = STATUS_AUTOTUNE;
18117 }
18118
18119 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18120 {
18121 hc_device_param_t *device_param = &devices_param[device_id];
18122
18123 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
18124 }
18125
18126 hc_thread_wait (data.devices_cnt, c_threads);
18127
18128 /*
18129 * Inform user about possible slow speeds
18130 */
18131
18132 uint hardware_power_all = 0;
18133
18134 uint kernel_power_all = 0;
18135
18136 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18137 {
18138 hc_device_param_t *device_param = &devices_param[device_id];
18139
18140 hardware_power_all += device_param->hardware_power;
18141
18142 kernel_power_all += device_param->kernel_power;
18143 }
18144
18145 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
18146
18147 data.kernel_power_all = kernel_power_all;
18148
18149 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18150 {
18151 if (data.words_base < kernel_power_all)
18152 {
18153 if (quiet == 0)
18154 {
18155 clear_prompt ();
18156
18157 log_info ("ATTENTION!");
18158 log_info (" The wordlist or mask you are using is too small.");
18159 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
18160 log_info (" The cracking speed will drop.");
18161 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
18162 log_info ("");
18163 }
18164 }
18165 }
18166
18167 /**
18168 * create cracker threads
18169 */
18170
18171 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18172 {
18173 data.devices_status = STATUS_RUNNING;
18174 }
18175
18176 if (initial_restore_done == 0)
18177 {
18178 if (data.restore_disable == 0) cycle_restore ();
18179
18180 initial_restore_done = 1;
18181 }
18182
18183 hc_timer_set (&data.timer_running);
18184
18185 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18186 {
18187 if ((quiet == 0) && (status == 0) && (benchmark == 0))
18188 {
18189 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
18190 if (quiet == 0) fflush (stdout);
18191 }
18192 }
18193 else if (wordlist_mode == WL_MODE_STDIN)
18194 {
18195 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
18196 if (data.quiet == 0) log_info ("");
18197 }
18198
18199 time_t runtime_start;
18200
18201 time (&runtime_start);
18202
18203 data.runtime_start = runtime_start;
18204
18205 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18206 {
18207 hc_device_param_t *device_param = &devices_param[device_id];
18208
18209 if (wordlist_mode == WL_MODE_STDIN)
18210 {
18211 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
18212 }
18213 else
18214 {
18215 hc_thread_create (c_threads[device_id], thread_calc, device_param);
18216 }
18217 }
18218
18219 hc_thread_wait (data.devices_cnt, c_threads);
18220
18221 local_free (c_threads);
18222
18223 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18224 {
18225 data.devices_status = STATUS_EXHAUSTED;
18226 }
18227
18228 logfile_sub_var_uint ("status-after-work", data.devices_status);
18229
18230 data.restore = 0;
18231
18232 if (induction_dictionaries_cnt)
18233 {
18234 unlink (induction_dictionaries[0]);
18235 }
18236
18237 free (induction_dictionaries);
18238
18239 if (attack_mode != ATTACK_MODE_BF)
18240 {
18241 induction_dictionaries = scan_directory (induction_directory);
18242
18243 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18244 }
18245
18246 if (benchmark == 1)
18247 {
18248 status_benchmark ();
18249
18250 if (machine_readable == 0)
18251 {
18252 log_info ("");
18253 }
18254 }
18255 else
18256 {
18257 if (quiet == 0)
18258 {
18259 clear_prompt ();
18260
18261 log_info ("");
18262
18263 if (stdout_flag == 0) status_display ();
18264
18265 log_info ("");
18266 }
18267 }
18268
18269 if (induction_dictionaries_cnt)
18270 {
18271 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18272 }
18273
18274 time_t runtime_stop;
18275
18276 time (&runtime_stop);
18277
18278 data.runtime_stop = runtime_stop;
18279
18280 logfile_sub_uint (runtime_start);
18281 logfile_sub_uint (runtime_stop);
18282
18283 logfile_sub_msg ("STOP");
18284
18285 global_free (subid);
18286
18287 // from this point we handle bypass as running
18288
18289 if (data.devices_status == STATUS_BYPASS)
18290 {
18291 data.devices_status = STATUS_RUNNING;
18292 }
18293
18294 // and overwrite benchmark aborts as well
18295
18296 if (data.benchmark == 1)
18297 {
18298 if (data.devices_status == STATUS_ABORTED)
18299 {
18300 data.devices_status = STATUS_RUNNING;
18301 }
18302 }
18303
18304 // finalize task
18305
18306 if (data.devices_status == STATUS_CRACKED) break;
18307 if (data.devices_status == STATUS_ABORTED) break;
18308 if (data.devices_status == STATUS_QUIT) break;
18309 }
18310
18311 if (data.devices_status == STATUS_CRACKED) break;
18312 if (data.devices_status == STATUS_ABORTED) break;
18313 if (data.devices_status == STATUS_QUIT) break;
18314 }
18315
18316 // 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
18317 if (attack_mode == ATTACK_MODE_STRAIGHT)
18318 {
18319 if (data.wordlist_mode == WL_MODE_FILE)
18320 {
18321 if (data.dictfile == NULL)
18322 {
18323 if (dictfiles != NULL)
18324 {
18325 data.dictfile = dictfiles[0];
18326
18327 hc_timer_set (&data.timer_running);
18328 }
18329 }
18330 }
18331 }
18332 // NOTE: combi is okay because it is already set beforehand
18333 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
18334 {
18335 if (data.dictfile == NULL)
18336 {
18337 if (dictfiles != NULL)
18338 {
18339 hc_timer_set (&data.timer_running);
18340
18341 data.dictfile = dictfiles[0];
18342 }
18343 }
18344 }
18345 else if (attack_mode == ATTACK_MODE_BF)
18346 {
18347 if (data.mask == NULL)
18348 {
18349 hc_timer_set (&data.timer_running);
18350
18351 data.mask = masks[0];
18352 }
18353 }
18354
18355 // if cracked / aborted remove last induction dictionary
18356
18357 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
18358 {
18359 struct stat induct_stat;
18360
18361 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
18362 {
18363 unlink (induction_dictionaries[file_pos]);
18364 }
18365 }
18366
18367 // wait for inner threads
18368
18369 data.shutdown_inner = 1;
18370
18371 for (uint thread_idx = 0; thread_idx < inner_threads_cnt; thread_idx++)
18372 {
18373 hc_thread_wait (1, &inner_threads[thread_idx]);
18374 }
18375
18376 local_free (inner_threads);
18377
18378 // we dont need restore file anymore
18379 if (data.restore_disable == 0)
18380 {
18381 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
18382 {
18383 unlink (eff_restore_file);
18384 unlink (new_restore_file);
18385 }
18386 else
18387 {
18388 cycle_restore ();
18389 }
18390 }
18391
18392 // finally save left hashes
18393
18394 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
18395 {
18396 save_hash ();
18397 }
18398
18399 /**
18400 * Clean up
18401 */
18402
18403 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18404 {
18405 hc_device_param_t *device_param = &data.devices_param[device_id];
18406
18407 if (device_param->skipped) continue;
18408
18409 local_free (device_param->combs_buf);
18410 local_free (device_param->hooks_buf);
18411 local_free (device_param->device_name);
18412 local_free (device_param->device_name_chksum);
18413 local_free (device_param->device_version);
18414 local_free (device_param->driver_version);
18415
18416 if (device_param->pws_buf) myfree (device_param->pws_buf);
18417 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
18418 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
18419 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
18420 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
18421 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
18422 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
18423 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
18424 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
18425 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
18426 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
18427 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
18428 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
18429 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
18430 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
18431 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
18432 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
18433 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
18434 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
18435 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
18436 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
18437 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
18438 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
18439 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
18440 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
18441 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
18442 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
18443 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
18444 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
18445
18446 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
18447 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
18448 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
18449 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
18450 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
18451 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
18452 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
18453 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
18454 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
18455 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
18456 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
18457
18458 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
18459 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
18460 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
18461
18462 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
18463 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
18464 }
18465
18466 // reset default fan speed
18467
18468 #ifdef HAVE_HWMON
18469 if (gpu_temp_disable == 0)
18470 {
18471 if (gpu_temp_retain != 0)
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.hm_device[device_id].fan_set_supported == 1)
18482 {
18483 int rc = -1;
18484
18485 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18486 {
18487 rc = hm_set_fanspeed_with_device_id_adl (device_id, 100, 0);
18488 }
18489 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18490 {
18491 #ifdef LINUX
18492 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE);
18493 #endif
18494
18495 #ifdef WIN
18496 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, 100, 0);
18497 #endif
18498 }
18499
18500 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18501 }
18502 }
18503
18504 hc_thread_mutex_unlock (mux_adl);
18505 }
18506 }
18507
18508 // reset power tuning
18509
18510 if (powertune_enable == 1)
18511 {
18512 hc_thread_mutex_lock (mux_adl);
18513
18514 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18515 {
18516 hc_device_param_t *device_param = &data.devices_param[device_id];
18517
18518 if (device_param->skipped) continue;
18519
18520 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18521 {
18522 if (data.hm_device[device_id].od_version == 6)
18523 {
18524 // check powertune capabilities first, if not available then skip device
18525
18526 int powertune_supported = 0;
18527
18528 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18529 {
18530 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18531
18532 return (-1);
18533 }
18534
18535 if (powertune_supported != 0)
18536 {
18537 // powercontrol settings
18538
18539 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18540 {
18541 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18542
18543 return (-1);
18544 }
18545
18546 // clocks
18547
18548 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18549
18550 performance_state->iNumberOfPerformanceLevels = 2;
18551
18552 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18553 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18554 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18555 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18556
18557 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18558 {
18559 log_info ("ERROR: Failed to restore ADL performance state");
18560
18561 return (-1);
18562 }
18563
18564 local_free (performance_state);
18565 }
18566 }
18567 }
18568
18569 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18570 {
18571 unsigned int limit = nvml_power_limit[device_id];
18572
18573 if (limit > 0)
18574 {
18575 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18576 }
18577 }
18578 }
18579
18580 hc_thread_mutex_unlock (mux_adl);
18581 }
18582
18583 if (gpu_temp_disable == 0)
18584 {
18585 if (data.hm_nvml)
18586 {
18587 hm_NVML_nvmlShutdown (data.hm_nvml);
18588
18589 nvml_close (data.hm_nvml);
18590
18591 data.hm_nvml = NULL;
18592 }
18593
18594 if (data.hm_nvapi)
18595 {
18596 hm_NvAPI_Unload (data.hm_nvapi);
18597
18598 nvapi_close (data.hm_nvapi);
18599
18600 data.hm_nvapi = NULL;
18601 }
18602
18603 if (data.hm_xnvctrl)
18604 {
18605 hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);
18606
18607 xnvctrl_close (data.hm_xnvctrl);
18608
18609 data.hm_xnvctrl = NULL;
18610 }
18611
18612 if (data.hm_adl)
18613 {
18614 hm_ADL_Main_Control_Destroy (data.hm_adl);
18615
18616 adl_close (data.hm_adl);
18617
18618 data.hm_adl = NULL;
18619 }
18620 }
18621 #endif // HAVE_HWMON
18622
18623 // free memory
18624
18625 local_free (masks);
18626
18627 local_free (dictstat_base);
18628
18629 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18630 {
18631 pot_t *pot_ptr = &pot[pot_pos];
18632
18633 hash_t *hash = &pot_ptr->hash;
18634
18635 local_free (hash->digest);
18636
18637 if (isSalted)
18638 {
18639 local_free (hash->salt);
18640 }
18641 }
18642
18643 local_free (pot);
18644
18645 local_free (all_kernel_rules_cnt);
18646 local_free (all_kernel_rules_buf);
18647
18648 local_free (wl_data->buf);
18649 local_free (wl_data);
18650
18651 local_free (bitmap_s1_a);
18652 local_free (bitmap_s1_b);
18653 local_free (bitmap_s1_c);
18654 local_free (bitmap_s1_d);
18655 local_free (bitmap_s2_a);
18656 local_free (bitmap_s2_b);
18657 local_free (bitmap_s2_c);
18658 local_free (bitmap_s2_d);
18659
18660 #ifdef HAVE_HWMON
18661 local_free (od_clock_mem_status);
18662 local_free (od_power_control_status);
18663 local_free (nvml_power_limit);
18664 #endif
18665
18666 global_free (devices_param);
18667
18668 global_free (kernel_rules_buf);
18669
18670 global_free (root_css_buf);
18671 global_free (markov_css_buf);
18672
18673 global_free (digests_buf);
18674 global_free (digests_shown);
18675 global_free (digests_shown_tmp);
18676
18677 global_free (salts_buf);
18678 global_free (salts_shown);
18679
18680 global_free (esalts_buf);
18681
18682 global_free (words_progress_done);
18683 global_free (words_progress_rejected);
18684 global_free (words_progress_restored);
18685
18686 if (pot_fp) fclose (pot_fp);
18687
18688 if (data.devices_status == STATUS_QUIT) break;
18689 }
18690
18691 // wait for outer threads
18692
18693 data.shutdown_outer = 1;
18694
18695 for (uint thread_idx = 0; thread_idx < outer_threads_cnt; thread_idx++)
18696 {
18697 hc_thread_wait (1, &outer_threads[thread_idx]);
18698 }
18699
18700 local_free (outer_threads);
18701
18702 // destroy others mutex
18703
18704 hc_thread_mutex_delete (mux_dispatcher);
18705 hc_thread_mutex_delete (mux_counter);
18706 hc_thread_mutex_delete (mux_display);
18707 hc_thread_mutex_delete (mux_adl);
18708
18709 // free memory
18710
18711 local_free (eff_restore_file);
18712 local_free (new_restore_file);
18713
18714 local_free (rd);
18715
18716 // tuning db
18717
18718 tuning_db_destroy (tuning_db);
18719
18720 // loopback
18721
18722 local_free (loopback_file);
18723
18724 if (loopback == 1) unlink (loopback_file);
18725
18726 // induction directory
18727
18728 if (induction_dir == NULL)
18729 {
18730 if (attack_mode != ATTACK_MODE_BF)
18731 {
18732 if (rmdir (induction_directory) == -1)
18733 {
18734 if (errno == ENOENT)
18735 {
18736 // good, we can ignore
18737 }
18738 else if (errno == ENOTEMPTY)
18739 {
18740 // good, we can ignore
18741 }
18742 else
18743 {
18744 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18745
18746 return (-1);
18747 }
18748 }
18749
18750 local_free (induction_directory);
18751 }
18752 }
18753
18754 // outfile-check directory
18755
18756 if (outfile_check_dir == NULL)
18757 {
18758 if (rmdir (outfile_check_directory) == -1)
18759 {
18760 if (errno == ENOENT)
18761 {
18762 // good, we can ignore
18763 }
18764 else if (errno == ENOTEMPTY)
18765 {
18766 // good, we can ignore
18767 }
18768 else
18769 {
18770 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18771
18772 return (-1);
18773 }
18774 }
18775
18776 local_free (outfile_check_directory);
18777 }
18778
18779 time_t proc_stop;
18780
18781 time (&proc_stop);
18782
18783 logfile_top_uint (proc_start);
18784 logfile_top_uint (proc_stop);
18785
18786 logfile_top_msg ("STOP");
18787
18788 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18789 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18790
18791 if (data.ocl) ocl_close (data.ocl);
18792
18793 if (data.devices_status == STATUS_ABORTED) return 2;
18794 if (data.devices_status == STATUS_QUIT) return 2;
18795 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18796 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18797 if (data.devices_status == STATUS_CRACKED) return 0;
18798
18799 return -1;
18800 }
Hashcat additions to support pwdhash