projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Clean end-of-line output usage (not actually POSIX)
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define STDOUT_FLAG 0
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define MACHINE_READABLE 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define NVIDIA_SPIN_DAMP 100
79 #define GPU_TEMP_DISABLE 0
80 #define GPU_TEMP_ABORT 90
81 #define GPU_TEMP_RETAIN 65
82 #define WORKLOAD_PROFILE 2
83 #define KERNEL_ACCEL 0
84 #define KERNEL_LOOPS 0
85 #define KERNEL_RULES 1024
86 #define KERNEL_COMBS 1024
87 #define KERNEL_BFS 1024
88 #define KERNEL_THREADS_MAX 256
89 #define KERNEL_THREADS_MAX_CPU 16
90 #define POWERTUNE_ENABLE 0
91 #define LOGFILE_DISABLE 0
92 #define SCRYPT_TMTO 0
93 #define OPENCL_VECTOR_WIDTH 0
94
95 #define WL_MODE_STDIN 1
96 #define WL_MODE_FILE 2
97 #define WL_MODE_MASK 3
98
99 #define HL_MODE_FILE 4
100 #define HL_MODE_ARG 5
101
102 #define HLFMTS_CNT 11
103 #define HLFMT_HASHCAT 0
104 #define HLFMT_PWDUMP 1
105 #define HLFMT_PASSWD 2
106 #define HLFMT_SHADOW 3
107 #define HLFMT_DCC 4
108 #define HLFMT_DCC2 5
109 #define HLFMT_NETNTLM1 7
110 #define HLFMT_NETNTLM2 8
111 #define HLFMT_NSLDAP 9
112 #define HLFMT_NSLDAPS 10
113
114 #define HLFMT_TEXT_HASHCAT "native hashcat"
115 #define HLFMT_TEXT_PWDUMP "pwdump"
116 #define HLFMT_TEXT_PASSWD "passwd"
117 #define HLFMT_TEXT_SHADOW "shadow"
118 #define HLFMT_TEXT_DCC "DCC"
119 #define HLFMT_TEXT_DCC2 "DCC 2"
120 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
121 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
122 #define HLFMT_TEXT_NSLDAP "nsldap"
123 #define HLFMT_TEXT_NSLDAPS "nsldaps"
124
125 #define ATTACK_MODE_STRAIGHT 0
126 #define ATTACK_MODE_COMBI 1
127 #define ATTACK_MODE_TOGGLE 2
128 #define ATTACK_MODE_BF 3
129 #define ATTACK_MODE_PERM 4
130 #define ATTACK_MODE_TABLE 5
131 #define ATTACK_MODE_HYBRID1 6
132 #define ATTACK_MODE_HYBRID2 7
133 #define ATTACK_MODE_NONE 100
134
135 #define ATTACK_KERN_STRAIGHT 0
136 #define ATTACK_KERN_COMBI 1
137 #define ATTACK_KERN_BF 3
138 #define ATTACK_KERN_NONE 100
139
140 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
141 #define ATTACK_EXEC_INSIDE_KERNEL 11
142
143 #define COMBINATOR_MODE_BASE_LEFT 10001
144 #define COMBINATOR_MODE_BASE_RIGHT 10002
145
146 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
147 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
148
149 #define MAX_CUT_TRIES 4
150
151 #define MAX_DICTSTAT 10000
152
153 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
154
155 #define NVIDIA_100PERCENTCPU_WORKAROUND 100
156
157 #define global_free(attr) \
158 { \
159 myfree ((void *) data.attr); \
160 \
161 data.attr = NULL; \
162 }
163
164 #define local_free(attr) \
165 { \
166 myfree ((void *) attr); \
167 \
168 attr = NULL; \
169 }
170
171 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
172 #define HC_API_CALL __stdcall
173 #else
174 #define HC_API_CALL
175 #endif
176
177 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
178 {
179 900,
180 0,
181 5100,
182 100,
183 1400,
184 10800,
185 1700,
186 5000,
187 10100,
188 6000,
189 6100,
190 6900,
191 11700,
192 11800,
193 400,
194 8900,
195 11900,
196 12000,
197 10900,
198 12100,
199 23,
200 2500,
201 5300,
202 5400,
203 5500,
204 5600,
205 7300,
206 7500,
207 13100,
208 8300,
209 11100,
210 11200,
211 11400,
212 121,
213 2611,
214 2711,
215 2811,
216 8400,
217 11,
218 2612,
219 7900,
220 21,
221 11000,
222 124,
223 10000,
224 3711,
225 7600,
226 12,
227 131,
228 132,
229 1731,
230 200,
231 300,
232 3100,
233 112,
234 12300,
235 8000,
236 141,
237 1441,
238 1600,
239 12600,
240 1421,
241 101,
242 111,
243 1711,
244 3000,
245 1000,
246 1100,
247 2100,
248 12800,
249 1500,
250 12400,
251 500,
252 3200,
253 7400,
254 1800,
255 122,
256 1722,
257 7100,
258 6300,
259 6700,
260 6400,
261 6500,
262 2400,
263 2410,
264 5700,
265 9200,
266 9300,
267 22,
268 501,
269 5800,
270 8100,
271 8500,
272 7200,
273 9900,
274 7700,
275 7800,
276 10300,
277 8600,
278 8700,
279 9100,
280 133,
281 13500,
282 11600,
283 13600,
284 12500,
285 13000,
286 13200,
287 13300,
288 6211,
289 6221,
290 6231,
291 6241,
292 13711,
293 13721,
294 13731,
295 13741,
296 13751,
297 13761,
298 8800,
299 12900,
300 12200,
301 9700,
302 9710,
303 9800,
304 9810,
305 9400,
306 9500,
307 9600,
308 10400,
309 10410,
310 10500,
311 10600,
312 10700,
313 9000,
314 5200,
315 6800,
316 6600,
317 8200,
318 11300,
319 12700,
320 13400,
321 125
322 };
323
324 /**
325 * types
326 */
327
328 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
329
330 /**
331 * globals
332 */
333
334 static unsigned int full01 = 0x01010101;
335 static unsigned int full80 = 0x80808080;
336
337 int SUPPRESS_OUTPUT = 0;
338
339 hc_thread_mutex_t mux_adl;
340 hc_thread_mutex_t mux_counter;
341 hc_thread_mutex_t mux_dispatcher;
342 hc_thread_mutex_t mux_display;
343
344 hc_global_data_t data;
345
346 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
347
348 const char *USAGE_MINI[] =
349 {
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "Try --help for more help.",
353 NULL
354 };
355
356 const char *USAGE_BIG[] =
357 {
358 "%s, advanced password recovery",
359 "",
360 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
361 "",
362 "- [ Options ] -",
363 "",
364 " Options Short / Long | Type | Description | Example",
365 "===============================|======|======================================================|=======================",
366 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
367 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
368 " -V, --version | | Print version |",
369 " -h, --help | | Print help |",
370 " --quiet | | Suppress output |",
371 " --hex-charset | | Assume charset is given in hex |",
372 " --hex-salt | | Assume salt is given in hex |",
373 " --hex-wordlist | | Assume words in wordlist is given in hex |",
374 " --force | | Ignore warnings |",
375 " --status | | Enable automatic update of the status-screen |",
376 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
377 " --machine-readable | | Display the status view in a machine readable format |",
378 " --loopback | | Add new plains to induct directory |",
379 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
380 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
381 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
382 " --markov-classic | | Enables classic markov-chains, no per-position |",
383 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
384 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
385 " --session | Str | Define specific session name | --session=mysession",
386 " --restore | | Restore session from --session |",
387 " --restore-disable | | Do not write restore file |",
388 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
389 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
390 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
391 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
392 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
393 " --stdout | | Do not crack a hash, instead print candidates only |",
394 " --show | | Show cracked passwords only |",
395 " --left | | Show un-cracked passwords only |",
396 " --username | | Enable ignoring of usernames in hashfile |",
397 " --remove | | Enable remove of hash once it is cracked |",
398 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
399 " --potfile-disable | | Do not write potfile |",
400 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
401 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
402 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
403 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
404 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
405 " --logfile-disable | | Disable the logfile |",
406 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
407 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
408 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
409 " -b, --benchmark | | Run benchmark |",
410 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
411 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
412 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
413 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
414 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
415 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
416 " -D, --opencl-device-types | Str | OpenCL device-types to use, separate with comma | -D 1",
417 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
418 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
419 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
420 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
421 " --nvidia-spin-damp | Num | Workaround NVidias CPU burning loop bug, in percent | --nvidia-spin-damp=50",
422 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
423 #ifdef HAVE_HWMON
424 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
425 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
426 " --powertune-enable | | Enable power tuning, restores settings when finished |",
427 #endif
428 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
429 " -s, --skip | Num | Skip X words from the start | -s 1000000",
430 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
431 " --keyspace | | Show keyspace base:mod values and quit |",
432 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
433 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
434 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
435 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
436 " --generate-rules-func-min | Num | Force min X funcs per rule |",
437 " --generate-rules-func-max | Num | Force max X funcs per rule |",
438 " --generate-rules-seed | Num | Force RNG seed set to X |",
439 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
440 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
441 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
442 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
443 " -i, --increment | | Enable mask increment mode |",
444 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
445 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
446 "",
447 "- [ Hash modes ] -",
448 "",
449 " # | Name | Category",
450 " ======+==================================================+======================================",
451 " 900 | MD4 | Raw Hash",
452 " 0 | MD5 | Raw Hash",
453 " 5100 | Half MD5 | Raw Hash",
454 " 100 | SHA1 | Raw Hash",
455 " 10800 | SHA-384 | Raw Hash",
456 " 1400 | SHA-256 | Raw Hash",
457 " 1700 | SHA-512 | Raw Hash",
458 " 5000 | SHA-3(Keccak) | Raw Hash",
459 " 10100 | SipHash | Raw Hash",
460 " 6000 | RipeMD160 | Raw Hash",
461 " 6100 | Whirlpool | Raw Hash",
462 " 6900 | GOST R 34.11-94 | Raw Hash",
463 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
464 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
465 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
466 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
467 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
468 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
469 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
470 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
471 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
472 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
473 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
474 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
475 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
476 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
477 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
478 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
479 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
480 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
481 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
482 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
483 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
484 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
485 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
486 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
487 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
488 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
489 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
490 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
491 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
492 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
493 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
494 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
495 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
496 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
497 " 400 | phpass | Generic KDF",
498 " 8900 | scrypt | Generic KDF",
499 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
500 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
501 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
502 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
503 " 23 | Skype | Network protocols",
504 " 2500 | WPA/WPA2 | Network protocols",
505 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
506 " 5300 | IKE-PSK MD5 | Network protocols",
507 " 5400 | IKE-PSK SHA1 | Network protocols",
508 " 5500 | NetNTLMv1 | Network protocols",
509 " 5500 | NetNTLMv1 + ESS | Network protocols",
510 " 5600 | NetNTLMv2 | Network protocols",
511 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
512 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
513 " 8300 | DNSSEC (NSEC3) | Network protocols",
514 " 10200 | Cram MD5 | Network protocols",
515 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
516 " 11200 | MySQL CRAM (SHA1) | Network protocols",
517 " 11400 | SIP digest authentication (MD5) | Network protocols",
518 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
519 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
520 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
521 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
522 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
523 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
524 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
525 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
526 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
527 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
528 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
529 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
530 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
531 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
532 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
533 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
534 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
535 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
536 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
537 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
538 " 12 | PostgreSQL | Database Server",
539 " 131 | MSSQL(2000) | Database Server",
540 " 132 | MSSQL(2005) | Database Server",
541 " 1731 | MSSQL(2012) | Database Server",
542 " 1731 | MSSQL(2014) | Database Server",
543 " 200 | MySQL323 | Database Server",
544 " 300 | MySQL4.1/MySQL5 | Database Server",
545 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
546 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
547 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
548 " 8000 | Sybase ASE | Database Server",
549 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
550 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
551 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
552 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
553 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
554 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
555 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
556 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
557 " 11500 | CRC32 | Checksums",
558 " 3000 | LM | Operating-Systems",
559 " 1000 | NTLM | Operating-Systems",
560 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
561 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
562 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
563 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
564 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
565 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
566 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
567 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
568 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
569 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
570 " 1722 | OSX v10.7 | Operating-Systems",
571 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
572 " 6300 | AIX {smd5} | Operating-Systems",
573 " 6700 | AIX {ssha1} | Operating-Systems",
574 " 6400 | AIX {ssha256} | Operating-Systems",
575 " 6500 | AIX {ssha512} | Operating-Systems",
576 " 2400 | Cisco-PIX | Operating-Systems",
577 " 2410 | Cisco-ASA | Operating-Systems",
578 " 500 | Cisco-IOS $1$ | Operating-Systems",
579 " 5700 | Cisco-IOS $4$ | Operating-Systems",
580 " 9200 | Cisco-IOS $8$ | Operating-Systems",
581 " 9300 | Cisco-IOS $9$ | Operating-Systems",
582 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
583 " 501 | Juniper IVE | Operating-Systems",
584 " 5800 | Android PIN | Operating-Systems",
585 " 13800 | Windows 8+ phone PIN/Password | Operating-Systems",
586 " 8100 | Citrix Netscaler | Operating-Systems",
587 " 8500 | RACF | Operating-Systems",
588 " 7200 | GRUB 2 | Operating-Systems",
589 " 9900 | Radmin2 | Operating-Systems",
590 " 125 | ArubaOS | Operating-Systems",
591 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
592 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
593 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
594 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
595 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
596 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
597 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
598 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
599 " 11600 | 7-Zip | Archives",
600 " 12500 | RAR3-hp | Archives",
601 " 13000 | RAR5 | Archives",
602 " 13200 | AxCrypt | Archives",
603 " 13300 | AxCrypt in memory SHA1 | Archives",
604 " 13600 | WinZip | Archives",
605 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
606 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
607 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
608 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
609 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
610 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
611 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
612 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
613 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
614 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
615 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
616 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
617 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
618 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
619 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
620 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
621 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
622 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
623 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
624 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
625 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
626 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
627 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
628 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
629 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
630 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
631 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
632 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
633 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
634 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
635 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
636 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
637 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
638 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
639 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
640 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
641 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
642 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
643 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
644 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
645 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
646 " 9400 | MS Office 2007 | Documents",
647 " 9500 | MS Office 2010 | Documents",
648 " 9600 | MS Office 2013 | Documents",
649 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
650 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
651 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
652 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
653 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
654 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
655 " 9000 | Password Safe v2 | Password Managers",
656 " 5200 | Password Safe v3 | Password Managers",
657 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
658 " 6600 | 1Password, agilekeychain | Password Managers",
659 " 8200 | 1Password, cloudkeychain | Password Managers",
660 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
661 " 12700 | Blockchain, My Wallet | Password Managers",
662 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
663 "",
664 "- [ Outfile Formats ] -",
665 "",
666 " # | Format",
667 " ===+========",
668 " 1 | hash[:salt]",
669 " 2 | plain",
670 " 3 | hash[:salt]:plain",
671 " 4 | hex_plain",
672 " 5 | hash[:salt]:hex_plain",
673 " 6 | plain:hex_plain",
674 " 7 | hash[:salt]:plain:hex_plain",
675 " 8 | crackpos",
676 " 9 | hash[:salt]:crack_pos",
677 " 10 | plain:crack_pos",
678 " 11 | hash[:salt]:plain:crack_pos",
679 " 12 | hex_plain:crack_pos",
680 " 13 | hash[:salt]:hex_plain:crack_pos",
681 " 14 | plain:hex_plain:crack_pos",
682 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
683 "",
684 "- [ Rule Debugging Modes ] -",
685 "",
686 " # | Format",
687 " ===+========",
688 " 1 | Finding-Rule",
689 " 2 | Original-Word",
690 " 3 | Original-Word:Finding-Rule",
691 " 4 | Original-Word:Finding-Rule:Processed-Word",
692 "",
693 "- [ Attack Modes ] -",
694 "",
695 " # | Mode",
696 " ===+======",
697 " 0 | Straight",
698 " 1 | Combination",
699 " 3 | Brute-force",
700 " 6 | Hybrid Wordlist + Mask",
701 " 7 | Hybrid Mask + Wordlist",
702 "",
703 "- [ Built-in Charsets ] -",
704 "",
705 " ? | Charset",
706 " ===+=========",
707 " l | abcdefghijklmnopqrstuvwxyz",
708 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
709 " d | 0123456789",
710 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
711 " a | ?l?u?d?s",
712 " b | 0x00 - 0xff",
713 "",
714 "- [ OpenCL Device Types ] -",
715 "",
716 " # | Device Type",
717 " ===+=============",
718 " 1 | CPU",
719 " 2 | GPU",
720 " 3 | FPGA, DSP, Co-Processor",
721 "",
722 "- [ Workload Profiles ] -",
723 "",
724 " # | Performance | Runtime | Power Consumption | Desktop Impact",
725 " ===+=============+=========+===================+=================",
726 " 1 | Low | 2 ms | Low | Minimal",
727 " 2 | Default | 12 ms | Economic | Noticeable",
728 " 3 | High | 96 ms | High | Unresponsive",
729 " 4 | Nightmare | 480 ms | Insane | Headless",
730 "",
731 "If you have no idea what just happened then visit the following pages:",
732 "",
733 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
734 "* https://hashcat.net/wiki/#frequently_asked_questions",
735 "",
736 NULL
737 };
738
739 /**
740 * hashcat specific functions
741 */
742
743 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
744 {
745 int exec_pos = (int) device_param->exec_pos - last_num_entries;
746
747 if (exec_pos < 0) exec_pos += EXEC_CACHE;
748
749 double exec_ms_sum = 0;
750
751 int exec_ms_cnt = 0;
752
753 for (int i = 0; i < last_num_entries; i++)
754 {
755 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
756
757 if (exec_ms)
758 {
759 exec_ms_sum += exec_ms;
760
761 exec_ms_cnt++;
762 }
763 }
764
765 if (exec_ms_cnt == 0) return 0;
766
767 return exec_ms_sum / exec_ms_cnt;
768 }
769
770 void status_display_machine_readable ()
771 {
772 FILE *out = stdout;
773
774 fprintf (out, "STATUS\t%u\t", data.devices_status);
775
776 /**
777 * speed new
778 */
779
780 fprintf (out, "SPEED\t");
781
782 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
783 {
784 hc_device_param_t *device_param = &data.devices_param[device_id];
785
786 if (device_param->skipped) continue;
787
788 u64 speed_cnt = 0;
789 double speed_ms = 0;
790
791 for (int i = 0; i < SPEED_CACHE; i++)
792 {
793 speed_cnt += device_param->speed_cnt[i];
794 speed_ms += device_param->speed_ms[i];
795 }
796
797 speed_cnt /= SPEED_CACHE;
798 speed_ms /= SPEED_CACHE;
799
800 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
801 }
802
803 /**
804 * exec time
805 */
806
807 fprintf (out, "EXEC_RUNTIME\t");
808
809 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
810 {
811 hc_device_param_t *device_param = &data.devices_param[device_id];
812
813 if (device_param->skipped) continue;
814
815 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
816
817 fprintf (out, "%f\t", exec_ms_avg);
818 }
819
820 /**
821 * words_cur
822 */
823
824 u64 words_cur = get_lowest_words_done ();
825
826 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
827
828 /**
829 * counter
830 */
831
832 u64 progress_total = data.words_cnt * data.salts_cnt;
833
834 u64 all_done = 0;
835 u64 all_rejected = 0;
836 u64 all_restored = 0;
837
838 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
839 {
840 all_done += data.words_progress_done[salt_pos];
841 all_rejected += data.words_progress_rejected[salt_pos];
842 all_restored += data.words_progress_restored[salt_pos];
843 }
844
845 u64 progress_cur = all_restored + all_done + all_rejected;
846 u64 progress_end = progress_total;
847
848 u64 progress_skip = 0;
849
850 if (data.skip)
851 {
852 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
853
854 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
855 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
856 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
857 }
858
859 if (data.limit)
860 {
861 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
862
863 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
864 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
865 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
866 }
867
868 u64 progress_cur_relative_skip = progress_cur - progress_skip;
869 u64 progress_end_relative_skip = progress_end - progress_skip;
870
871 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
872
873 /**
874 * cracks
875 */
876
877 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
878 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
879
880 /**
881 * temperature
882 */
883
884 #ifdef HAVE_HWMON
885 if (data.gpu_temp_disable == 0)
886 {
887 fprintf (out, "TEMP\t");
888
889 hc_thread_mutex_lock (mux_adl);
890
891 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
892 {
893 hc_device_param_t *device_param = &data.devices_param[device_id];
894
895 if (device_param->skipped) continue;
896
897 int temp = hm_get_temperature_with_device_id (device_id);
898
899 fprintf (out, "%d\t", temp);
900 }
901
902 hc_thread_mutex_unlock (mux_adl);
903 }
904 #endif // HAVE_HWMON
905
906 /**
907 * flush
908 */
909
910 fputs (EOL, out);
911 fflush (out);
912 }
913
914 void status_display ()
915 {
916 if (data.devices_status == STATUS_INIT) return;
917 if (data.devices_status == STATUS_STARTING) return;
918 if (data.devices_status == STATUS_BYPASS) return;
919
920 if (data.machine_readable == 1)
921 {
922 status_display_machine_readable ();
923
924 return;
925 }
926
927 char tmp_buf[1000] = { 0 };
928
929 uint tmp_len = 0;
930
931 log_info ("Session.Name...: %s", data.session);
932
933 char *status_type = strstatus (data.devices_status);
934
935 uint hash_mode = data.hash_mode;
936
937 char *hash_type = strhashtype (hash_mode); // not a bug
938
939 log_info ("Status.........: %s", status_type);
940
941 /**
942 * show rules
943 */
944
945 if (data.rp_files_cnt)
946 {
947 uint i;
948
949 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
950 {
951 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
952 }
953
954 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
955
956 log_info ("Rules.Type.....: %s", tmp_buf);
957
958 tmp_len = 0;
959 }
960
961 if (data.rp_gen)
962 {
963 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
964
965 if (data.rp_gen_seed)
966 {
967 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
968 }
969 }
970
971 /**
972 * show input
973 */
974
975 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
976 {
977 if (data.wordlist_mode == WL_MODE_FILE)
978 {
979 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
980 }
981 else if (data.wordlist_mode == WL_MODE_STDIN)
982 {
983 log_info ("Input.Mode.....: Pipe");
984 }
985 }
986 else if (data.attack_mode == ATTACK_MODE_COMBI)
987 {
988 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
989 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
990 }
991 else if (data.attack_mode == ATTACK_MODE_BF)
992 {
993 char *mask = data.mask;
994
995 if (mask != NULL)
996 {
997 uint mask_len = data.css_cnt;
998
999 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1000
1001 if (mask_len > 0)
1002 {
1003 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1004 {
1005 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1006 {
1007 mask_len -= data.salts_buf[0].salt_len;
1008 }
1009 }
1010
1011 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1012
1013 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1014 }
1015
1016 if (data.maskcnt > 1)
1017 {
1018 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1019
1020 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1021 }
1022
1023 log_info ("Input.Mode.....: %s", tmp_buf);
1024 }
1025
1026 tmp_len = 0;
1027 }
1028 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1029 {
1030 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1031 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1032 }
1033 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1034 {
1035 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1036 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1037 }
1038
1039 if (data.digests_cnt == 1)
1040 {
1041 if (data.hash_mode == 2500)
1042 {
1043 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1044
1045 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1046 (char *) data.salts_buf[0].salt_buf,
1047 wpa->orig_mac1[0],
1048 wpa->orig_mac1[1],
1049 wpa->orig_mac1[2],
1050 wpa->orig_mac1[3],
1051 wpa->orig_mac1[4],
1052 wpa->orig_mac1[5],
1053 wpa->orig_mac2[0],
1054 wpa->orig_mac2[1],
1055 wpa->orig_mac2[2],
1056 wpa->orig_mac2[3],
1057 wpa->orig_mac2[4],
1058 wpa->orig_mac2[5]);
1059 }
1060 else if (data.hash_mode == 5200)
1061 {
1062 log_info ("Hash.Target....: File (%s)", data.hashfile);
1063 }
1064 else if (data.hash_mode == 9000)
1065 {
1066 log_info ("Hash.Target....: File (%s)", data.hashfile);
1067 }
1068 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1069 {
1070 log_info ("Hash.Target....: File (%s)", data.hashfile);
1071 }
1072 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1073 {
1074 log_info ("Hash.Target....: File (%s)", data.hashfile);
1075 }
1076 else
1077 {
1078 char out_buf[HCBUFSIZ] = { 0 };
1079
1080 ascii_digest (out_buf, 0, 0);
1081
1082 // limit length
1083 if (strlen (out_buf) > 40)
1084 {
1085 out_buf[41] = '.';
1086 out_buf[42] = '.';
1087 out_buf[43] = '.';
1088 out_buf[44] = 0;
1089 }
1090
1091 log_info ("Hash.Target....: %s", out_buf);
1092 }
1093 }
1094 else
1095 {
1096 if (data.hash_mode == 3000)
1097 {
1098 char out_buf1[32] = { 0 };
1099 char out_buf2[32] = { 0 };
1100
1101 ascii_digest (out_buf1, 0, 0);
1102 ascii_digest (out_buf2, 0, 1);
1103
1104 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1105 }
1106 else
1107 {
1108 log_info ("Hash.Target....: File (%s)", data.hashfile);
1109 }
1110 }
1111
1112 log_info ("Hash.Type......: %s", hash_type);
1113
1114 /**
1115 * speed new
1116 */
1117
1118 u64 speed_cnt[DEVICES_MAX] = { 0 };
1119 double speed_ms[DEVICES_MAX] = { 0 };
1120
1121 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1122 {
1123 hc_device_param_t *device_param = &data.devices_param[device_id];
1124
1125 if (device_param->skipped) continue;
1126
1127 speed_cnt[device_id] = 0;
1128 speed_ms[device_id] = 0;
1129
1130 for (int i = 0; i < SPEED_CACHE; i++)
1131 {
1132 speed_cnt[device_id] += device_param->speed_cnt[i];
1133 speed_ms[device_id] += device_param->speed_ms[i];
1134 }
1135
1136 speed_cnt[device_id] /= SPEED_CACHE;
1137 speed_ms[device_id] /= SPEED_CACHE;
1138 }
1139
1140 double hashes_all_ms = 0;
1141
1142 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1143
1144 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1145 {
1146 hc_device_param_t *device_param = &data.devices_param[device_id];
1147
1148 if (device_param->skipped) continue;
1149
1150 hashes_dev_ms[device_id] = 0;
1151
1152 if (speed_ms[device_id])
1153 {
1154 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1155
1156 hashes_all_ms += hashes_dev_ms[device_id];
1157 }
1158 }
1159
1160 /**
1161 * exec time
1162 */
1163
1164 double exec_all_ms[DEVICES_MAX] = { 0 };
1165
1166 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1167 {
1168 hc_device_param_t *device_param = &data.devices_param[device_id];
1169
1170 if (device_param->skipped) continue;
1171
1172 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1173
1174 exec_all_ms[device_id] = exec_ms_avg;
1175 }
1176
1177 /**
1178 * timers
1179 */
1180
1181 double ms_running = 0;
1182
1183 hc_timer_get (data.timer_running, ms_running);
1184
1185 double ms_paused = data.ms_paused;
1186
1187 if (data.devices_status == STATUS_PAUSED)
1188 {
1189 double ms_paused_tmp = 0;
1190
1191 hc_timer_get (data.timer_paused, ms_paused_tmp);
1192
1193 ms_paused += ms_paused_tmp;
1194 }
1195
1196 #ifdef WIN
1197
1198 __time64_t sec_run = ms_running / 1000;
1199
1200 #else
1201
1202 time_t sec_run = ms_running / 1000;
1203
1204 #endif
1205
1206 if (sec_run)
1207 {
1208 char display_run[32] = { 0 };
1209
1210 struct tm tm_run;
1211
1212 struct tm *tmp = NULL;
1213
1214 #ifdef WIN
1215
1216 tmp = _gmtime64 (&sec_run);
1217
1218 #else
1219
1220 tmp = gmtime (&sec_run);
1221
1222 #endif
1223
1224 if (tmp != NULL)
1225 {
1226 memset (&tm_run, 0, sizeof (tm_run));
1227
1228 memcpy (&tm_run, tmp, sizeof (tm_run));
1229
1230 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1231
1232 char *start = ctime (&data.proc_start);
1233
1234 size_t start_len = strlen (start);
1235
1236 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1237 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1238
1239 log_info ("Time.Started...: %s (%s)", start, display_run);
1240 }
1241 }
1242 else
1243 {
1244 log_info ("Time.Started...: 0 secs");
1245 }
1246
1247 /**
1248 * counters
1249 */
1250
1251 u64 progress_total = data.words_cnt * data.salts_cnt;
1252
1253 u64 all_done = 0;
1254 u64 all_rejected = 0;
1255 u64 all_restored = 0;
1256
1257 u64 progress_noneed = 0;
1258
1259 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1260 {
1261 all_done += data.words_progress_done[salt_pos];
1262 all_rejected += data.words_progress_rejected[salt_pos];
1263 all_restored += data.words_progress_restored[salt_pos];
1264
1265 // Important for ETA only
1266
1267 if (data.salts_shown[salt_pos] == 1)
1268 {
1269 const u64 all = data.words_progress_done[salt_pos]
1270 + data.words_progress_rejected[salt_pos]
1271 + data.words_progress_restored[salt_pos];
1272
1273 const u64 left = data.words_cnt - all;
1274
1275 progress_noneed += left;
1276 }
1277 }
1278
1279 u64 progress_cur = all_restored + all_done + all_rejected;
1280 u64 progress_end = progress_total;
1281
1282 u64 progress_skip = 0;
1283
1284 if (data.skip)
1285 {
1286 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1287
1288 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1289 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1290 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1291 }
1292
1293 if (data.limit)
1294 {
1295 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1296
1297 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1298 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1299 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1300 }
1301
1302 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1303 u64 progress_end_relative_skip = progress_end - progress_skip;
1304
1305 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1306 {
1307 if (data.devices_status != STATUS_CRACKED)
1308 {
1309 #ifdef WIN
1310 __time64_t sec_etc = 0;
1311 #else
1312 time_t sec_etc = 0;
1313 #endif
1314
1315 if (hashes_all_ms)
1316 {
1317 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1318
1319 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1320
1321 sec_etc = ms_left / 1000;
1322 }
1323
1324 if (sec_etc == 0)
1325 {
1326 //log_info ("Time.Estimated.: 0 secs");
1327 }
1328 else if ((u64) sec_etc > ETC_MAX)
1329 {
1330 log_info ("Time.Estimated.: > 10 Years");
1331 }
1332 else
1333 {
1334 char display_etc[32] = { 0 };
1335
1336 struct tm tm_etc;
1337
1338 struct tm *tmp = NULL;
1339
1340 #ifdef WIN
1341
1342 tmp = _gmtime64 (&sec_etc);
1343
1344 #else
1345
1346 tmp = gmtime (&sec_etc);
1347
1348 #endif
1349
1350 if (tmp != NULL)
1351 {
1352 memset (&tm_etc, 0, sizeof (tm_etc));
1353
1354 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1355
1356 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1357
1358 time_t now;
1359
1360 time (&now);
1361
1362 now += sec_etc;
1363
1364 char *etc = ctime (&now);
1365
1366 size_t etc_len = strlen (etc);
1367
1368 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1369 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1370
1371 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1372 }
1373 }
1374 }
1375 }
1376
1377 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1378 {
1379 hc_device_param_t *device_param = &data.devices_param[device_id];
1380
1381 if (device_param->skipped) continue;
1382
1383 char display_dev_cur[16] = { 0 };
1384
1385 strncpy (display_dev_cur, "0.00", 4);
1386
1387 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1388
1389 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1390 }
1391
1392 char display_all_cur[16] = { 0 };
1393
1394 strncpy (display_all_cur, "0.00", 4);
1395
1396 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1397
1398 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1399
1400 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1401 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1402
1403 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);
1404
1405 // crack-per-time
1406
1407 if (data.digests_cnt > 100)
1408 {
1409 time_t now = time (NULL);
1410
1411 int cpt_cur_min = 0;
1412 int cpt_cur_hour = 0;
1413 int cpt_cur_day = 0;
1414
1415 for (int i = 0; i < CPT_BUF; i++)
1416 {
1417 const uint cracked = data.cpt_buf[i].cracked;
1418 const time_t timestamp = data.cpt_buf[i].timestamp;
1419
1420 if ((timestamp + 60) > now)
1421 {
1422 cpt_cur_min += cracked;
1423 }
1424
1425 if ((timestamp + 3600) > now)
1426 {
1427 cpt_cur_hour += cracked;
1428 }
1429
1430 if ((timestamp + 86400) > now)
1431 {
1432 cpt_cur_day += cracked;
1433 }
1434 }
1435
1436 double ms_real = ms_running - ms_paused;
1437
1438 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1439 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1440 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1441
1442 if ((data.cpt_start + 86400) < now)
1443 {
1444 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1445 cpt_cur_min,
1446 cpt_cur_hour,
1447 cpt_cur_day,
1448 cpt_avg_min,
1449 cpt_avg_hour,
1450 cpt_avg_day);
1451 }
1452 else if ((data.cpt_start + 3600) < now)
1453 {
1454 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1455 cpt_cur_min,
1456 cpt_cur_hour,
1457 cpt_avg_min,
1458 cpt_avg_hour,
1459 cpt_avg_day);
1460 }
1461 else if ((data.cpt_start + 60) < now)
1462 {
1463 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1464 cpt_cur_min,
1465 cpt_avg_min,
1466 cpt_avg_hour,
1467 cpt_avg_day);
1468 }
1469 else
1470 {
1471 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1472 cpt_avg_min,
1473 cpt_avg_hour,
1474 cpt_avg_day);
1475 }
1476 }
1477
1478 // Restore point
1479
1480 u64 restore_point = get_lowest_words_done ();
1481
1482 u64 restore_total = data.words_base;
1483
1484 float percent_restore = 0;
1485
1486 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1487
1488 if (progress_end_relative_skip)
1489 {
1490 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1491 {
1492 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1493 float percent_rejected = 0.0;
1494
1495 if (progress_cur)
1496 {
1497 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1498 }
1499
1500 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);
1501 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1502
1503 if (data.restore_disable == 0)
1504 {
1505 if (percent_finished != 1)
1506 {
1507 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1508 }
1509 }
1510 }
1511 }
1512 else
1513 {
1514 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1515 {
1516 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1517 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1518
1519 if (data.restore_disable == 0)
1520 {
1521 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1522 }
1523 }
1524 else
1525 {
1526 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1527 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1528
1529 // --restore not allowed if stdin is used -- really? why?
1530
1531 //if (data.restore_disable == 0)
1532 //{
1533 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1534 //}
1535 }
1536 }
1537
1538 #ifdef HAVE_HWMON
1539
1540 if (data.devices_status == STATUS_EXHAUSTED) return;
1541 if (data.devices_status == STATUS_CRACKED) return;
1542 if (data.devices_status == STATUS_ABORTED) return;
1543 if (data.devices_status == STATUS_QUIT) return;
1544
1545 if (data.gpu_temp_disable == 0)
1546 {
1547 hc_thread_mutex_lock (mux_adl);
1548
1549 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1550 {
1551 hc_device_param_t *device_param = &data.devices_param[device_id];
1552
1553 if (device_param->skipped) continue;
1554
1555 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1556 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1557 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1558 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1559 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1560 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1561 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1562
1563 char output_buf[256] = { 0 };
1564
1565 int output_len = 0;
1566
1567 if (num_temperature >= 0)
1568 {
1569 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1570
1571 output_len = strlen (output_buf);
1572 }
1573
1574 if (num_fanspeed >= 0)
1575 {
1576 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1577
1578 output_len = strlen (output_buf);
1579 }
1580
1581 if (num_utilization >= 0)
1582 {
1583 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1584
1585 output_len = strlen (output_buf);
1586 }
1587
1588 if (num_corespeed >= 0)
1589 {
1590 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1591
1592 output_len = strlen (output_buf);
1593 }
1594
1595 if (num_memoryspeed >= 0)
1596 {
1597 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1598
1599 output_len = strlen (output_buf);
1600 }
1601
1602 if (num_buslanes >= 0)
1603 {
1604 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1605
1606 output_len = strlen (output_buf);
1607 }
1608
1609 if (num_throttle == 1)
1610 {
1611 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1612
1613 output_len = strlen (output_buf);
1614 }
1615
1616 if (output_len == 0)
1617 {
1618 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1619
1620 output_len = strlen (output_buf);
1621 }
1622
1623 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1624 }
1625
1626 hc_thread_mutex_unlock (mux_adl);
1627 }
1628
1629 #endif // HAVE_HWMON
1630 }
1631
1632 static void status_benchmark_automate ()
1633 {
1634 u64 speed_cnt[DEVICES_MAX] = { 0 };
1635 double speed_ms[DEVICES_MAX] = { 0 };
1636
1637 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1638 {
1639 hc_device_param_t *device_param = &data.devices_param[device_id];
1640
1641 if (device_param->skipped) continue;
1642
1643 speed_cnt[device_id] = device_param->speed_cnt[0];
1644 speed_ms[device_id] = device_param->speed_ms[0];
1645 }
1646
1647 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1648
1649 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1650 {
1651 hc_device_param_t *device_param = &data.devices_param[device_id];
1652
1653 if (device_param->skipped) continue;
1654
1655 hashes_dev_ms[device_id] = 0;
1656
1657 if (speed_ms[device_id])
1658 {
1659 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1660 }
1661 }
1662
1663 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1664 {
1665 hc_device_param_t *device_param = &data.devices_param[device_id];
1666
1667 if (device_param->skipped) continue;
1668
1669 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1670 }
1671 }
1672
1673 static void status_benchmark ()
1674 {
1675 if (data.devices_status == STATUS_INIT) return;
1676 if (data.devices_status == STATUS_STARTING) return;
1677 if (data.devices_status == STATUS_BYPASS) return;
1678
1679 if (data.machine_readable == 1)
1680 {
1681 status_benchmark_automate ();
1682
1683 return;
1684 }
1685
1686 u64 speed_cnt[DEVICES_MAX] = { 0 };
1687 double speed_ms[DEVICES_MAX] = { 0 };
1688
1689 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1690 {
1691 hc_device_param_t *device_param = &data.devices_param[device_id];
1692
1693 if (device_param->skipped) continue;
1694
1695 speed_cnt[device_id] = device_param->speed_cnt[0];
1696 speed_ms[device_id] = device_param->speed_ms[0];
1697 }
1698
1699 double hashes_all_ms = 0;
1700
1701 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1702
1703 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1704 {
1705 hc_device_param_t *device_param = &data.devices_param[device_id];
1706
1707 if (device_param->skipped) continue;
1708
1709 hashes_dev_ms[device_id] = 0;
1710
1711 if (speed_ms[device_id])
1712 {
1713 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1714
1715 hashes_all_ms += hashes_dev_ms[device_id];
1716 }
1717 }
1718
1719 /**
1720 * exec time
1721 */
1722
1723 double exec_all_ms[DEVICES_MAX] = { 0 };
1724
1725 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1726 {
1727 hc_device_param_t *device_param = &data.devices_param[device_id];
1728
1729 if (device_param->skipped) continue;
1730
1731 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1732
1733 exec_all_ms[device_id] = exec_ms_avg;
1734 }
1735
1736 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1737 {
1738 hc_device_param_t *device_param = &data.devices_param[device_id];
1739
1740 if (device_param->skipped) continue;
1741
1742 char display_dev_cur[16] = { 0 };
1743
1744 strncpy (display_dev_cur, "0.00", 4);
1745
1746 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1747
1748 if (data.devices_active >= 10)
1749 {
1750 log_info ("Speed.Dev.#%d: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1751 }
1752 else
1753 {
1754 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1755 }
1756 }
1757
1758 char display_all_cur[16] = { 0 };
1759
1760 strncpy (display_all_cur, "0.00", 4);
1761
1762 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1763
1764 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1765 }
1766
1767 /**
1768 * hashcat -only- functions
1769 */
1770
1771 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1772 {
1773 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1774 {
1775 if (attack_kern == ATTACK_KERN_STRAIGHT)
1776 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1777 else if (attack_kern == ATTACK_KERN_COMBI)
1778 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1779 else if (attack_kern == ATTACK_KERN_BF)
1780 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1781 }
1782 else
1783 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1784 }
1785
1786 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)
1787 {
1788 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1789 {
1790 if (attack_kern == ATTACK_KERN_STRAIGHT)
1791 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1792 else if (attack_kern == ATTACK_KERN_COMBI)
1793 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1794 else if (attack_kern == ATTACK_KERN_BF)
1795 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1796 }
1797 else
1798 {
1799 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1800 }
1801 }
1802
1803 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1804 {
1805 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1806 {
1807 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1808 }
1809 else
1810 {
1811 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1812 }
1813 }
1814
1815 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)
1816 {
1817 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1818 {
1819 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1820 }
1821 else
1822 {
1823 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1824 }
1825 }
1826
1827 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1828 {
1829 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1830 }
1831
1832 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1833 {
1834 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1835 }
1836
1837 static char *filename_from_filepath (char *filepath)
1838 {
1839 char *ptr = NULL;
1840
1841 if ((ptr = strrchr (filepath, '/')) != NULL)
1842 {
1843 ptr++;
1844 }
1845 else if ((ptr = strrchr (filepath, '\\')) != NULL)
1846 {
1847 ptr++;
1848 }
1849 else
1850 {
1851 ptr = filepath;
1852 }
1853
1854 return ptr;
1855 }
1856
1857 static uint convert_from_hex (char *line_buf, const uint line_len)
1858 {
1859 if (line_len & 1) return (line_len); // not in hex
1860
1861 if (data.hex_wordlist == 1)
1862 {
1863 uint i;
1864 uint j;
1865
1866 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1867 {
1868 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1869 }
1870
1871 memset (line_buf + i, 0, line_len - i);
1872
1873 return (i);
1874 }
1875 else if (line_len >= 6) // $HEX[] = 6
1876 {
1877 if (line_buf[0] != '$') return (line_len);
1878 if (line_buf[1] != 'H') return (line_len);
1879 if (line_buf[2] != 'E') return (line_len);
1880 if (line_buf[3] != 'X') return (line_len);
1881 if (line_buf[4] != '[') return (line_len);
1882 if (line_buf[line_len - 1] != ']') return (line_len);
1883
1884 uint i;
1885 uint j;
1886
1887 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1888 {
1889 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1890 }
1891
1892 memset (line_buf + i, 0, line_len - i);
1893
1894 return (i);
1895 }
1896
1897 return (line_len);
1898 }
1899
1900 static void clear_prompt ()
1901 {
1902 fputc ('\r', stdout);
1903
1904 for (size_t i = 0; i < strlen (PROMPT); i++)
1905 {
1906 fputc (' ', stdout);
1907 }
1908
1909 fputc ('\r', stdout);
1910
1911 fflush (stdout);
1912 }
1913
1914 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1915 {
1916 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);
1917 }
1918
1919 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1920 {
1921 char *outfile = data.outfile;
1922 uint quiet = data.quiet;
1923 FILE *pot_fp = data.pot_fp;
1924 uint loopback = data.loopback;
1925 uint debug_mode = data.debug_mode;
1926 char *debug_file = data.debug_file;
1927
1928 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1929 int debug_rule_len = 0; // -1 error
1930 uint debug_plain_len = 0;
1931
1932 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1933
1934 // hash
1935
1936 char out_buf[HCBUFSIZ] = { 0 };
1937
1938 const u32 salt_pos = plain->salt_pos;
1939 const u32 digest_pos = plain->digest_pos; // relative
1940 const u32 gidvid = plain->gidvid;
1941 const u32 il_pos = plain->il_pos;
1942
1943 ascii_digest (out_buf, salt_pos, digest_pos);
1944
1945 // plain
1946
1947 u64 crackpos = device_param->words_off;
1948
1949 uint plain_buf[16] = { 0 };
1950
1951 u8 *plain_ptr = (u8 *) plain_buf;
1952
1953 unsigned int plain_len = 0;
1954
1955 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1956 {
1957 pw_t pw;
1958
1959 gidd_to_pw_t (device_param, gidvid, &pw);
1960
1961 for (int i = 0; i < 16; i++)
1962 {
1963 plain_buf[i] = pw.i[i];
1964 }
1965
1966 plain_len = pw.pw_len;
1967
1968 const uint off = device_param->innerloop_pos + il_pos;
1969
1970 if (debug_mode > 0)
1971 {
1972 debug_rule_len = 0;
1973
1974 // save rule
1975 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1976 {
1977 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1978
1979 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1980 }
1981
1982 // save plain
1983 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1984 {
1985 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1986
1987 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1988
1989 debug_plain_len = plain_len;
1990 }
1991 }
1992
1993 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1994
1995 crackpos += gidvid;
1996 crackpos *= data.kernel_rules_cnt;
1997 crackpos += device_param->innerloop_pos + il_pos;
1998
1999 if (plain_len > data.pw_max) plain_len = data.pw_max;
2000 }
2001 else if (data.attack_mode == ATTACK_MODE_COMBI)
2002 {
2003 pw_t pw;
2004
2005 gidd_to_pw_t (device_param, gidvid, &pw);
2006
2007 for (int i = 0; i < 16; i++)
2008 {
2009 plain_buf[i] = pw.i[i];
2010 }
2011
2012 plain_len = pw.pw_len;
2013
2014 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2015 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2016
2017 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2018 {
2019 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2020 }
2021 else
2022 {
2023 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2024
2025 memcpy (plain_ptr, comb_buf, comb_len);
2026 }
2027
2028 plain_len += comb_len;
2029
2030 crackpos += gidvid;
2031 crackpos *= data.combs_cnt;
2032 crackpos += device_param->innerloop_pos + il_pos;
2033
2034 if (data.pw_max != PW_DICTMAX1)
2035 {
2036 if (plain_len > data.pw_max) plain_len = data.pw_max;
2037 }
2038 }
2039 else if (data.attack_mode == ATTACK_MODE_BF)
2040 {
2041 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2042 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2043
2044 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2045 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2046
2047 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2048 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2049
2050 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2051 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2052
2053 plain_len = data.css_cnt;
2054
2055 crackpos += gidvid;
2056 crackpos *= data.bfs_cnt;
2057 crackpos += device_param->innerloop_pos + il_pos;
2058 }
2059 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2060 {
2061 pw_t pw;
2062
2063 gidd_to_pw_t (device_param, gidvid, &pw);
2064
2065 for (int i = 0; i < 16; i++)
2066 {
2067 plain_buf[i] = pw.i[i];
2068 }
2069
2070 plain_len = pw.pw_len;
2071
2072 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2073
2074 uint start = 0;
2075 uint stop = device_param->kernel_params_mp_buf32[4];
2076
2077 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2078
2079 plain_len += start + stop;
2080
2081 crackpos += gidvid;
2082 crackpos *= data.combs_cnt;
2083 crackpos += device_param->innerloop_pos + il_pos;
2084
2085 if (data.pw_max != PW_DICTMAX1)
2086 {
2087 if (plain_len > data.pw_max) plain_len = data.pw_max;
2088 }
2089 }
2090 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2091 {
2092 pw_t pw;
2093
2094 gidd_to_pw_t (device_param, gidvid, &pw);
2095
2096 for (int i = 0; i < 16; i++)
2097 {
2098 plain_buf[i] = pw.i[i];
2099 }
2100
2101 plain_len = pw.pw_len;
2102
2103 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2104
2105 uint start = 0;
2106 uint stop = device_param->kernel_params_mp_buf32[4];
2107
2108 memmove (plain_ptr + stop, plain_ptr, plain_len);
2109
2110 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2111
2112 plain_len += start + stop;
2113
2114 crackpos += gidvid;
2115 crackpos *= data.combs_cnt;
2116 crackpos += device_param->innerloop_pos + il_pos;
2117
2118 if (data.pw_max != PW_DICTMAX1)
2119 {
2120 if (plain_len > data.pw_max) plain_len = data.pw_max;
2121 }
2122 }
2123
2124 if (data.attack_mode == ATTACK_MODE_BF)
2125 {
2126 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2127 {
2128 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2129 {
2130 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2131 {
2132 plain_len = plain_len - data.salts_buf[0].salt_len;
2133 }
2134 }
2135
2136 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2137 {
2138 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2139 {
2140 plain_ptr[j] = plain_ptr[i];
2141 }
2142
2143 plain_len = plain_len / 2;
2144 }
2145 }
2146 }
2147
2148 // if enabled, update also the potfile
2149
2150 if (pot_fp)
2151 {
2152 lock_file (pot_fp);
2153
2154 fprintf (pot_fp, "%s:", out_buf);
2155
2156 format_plain (pot_fp, plain_ptr, plain_len, 1);
2157
2158 fputc ('\n', pot_fp);
2159
2160 fflush (pot_fp);
2161
2162 unlock_file (pot_fp);
2163 }
2164
2165 // outfile
2166
2167 FILE *out_fp = NULL;
2168
2169 if (outfile != NULL)
2170 {
2171 if ((out_fp = fopen (outfile, "ab")) == NULL)
2172 {
2173 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2174
2175 out_fp = stdout;
2176 }
2177
2178 lock_file (out_fp);
2179 }
2180 else
2181 {
2182 out_fp = stdout;
2183
2184 if (quiet == 0) clear_prompt ();
2185 }
2186
2187 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2188
2189 if (outfile != NULL)
2190 {
2191 if (out_fp != stdout)
2192 {
2193 fclose (out_fp);
2194 }
2195 }
2196 else
2197 {
2198 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2199 {
2200 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2201 {
2202 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2203 if (quiet == 0) fflush (stdout);
2204 }
2205 }
2206 }
2207
2208 // loopback
2209
2210 if (loopback)
2211 {
2212 char *loopback_file = data.loopback_file;
2213
2214 FILE *fb_fp = NULL;
2215
2216 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2217 {
2218 lock_file (fb_fp);
2219
2220 format_plain (fb_fp, plain_ptr, plain_len, 1);
2221
2222 fputc ('\n', fb_fp);
2223
2224 fclose (fb_fp);
2225 }
2226 }
2227
2228 // (rule) debug mode
2229
2230 // the next check implies that:
2231 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2232 // - debug_mode > 0
2233
2234 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2235 {
2236 if (debug_rule_len < 0) debug_rule_len = 0;
2237
2238 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2239
2240 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2241
2242 if ((quiet == 0) && (debug_file == NULL))
2243 {
2244 fprintf (stdout, "%s", PROMPT);
2245
2246 fflush (stdout);
2247 }
2248 }
2249 }
2250
2251 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2252 {
2253 salt_t *salt_buf = &data.salts_buf[salt_pos];
2254
2255 u32 num_cracked;
2256
2257 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2258
2259 if (num_cracked)
2260 {
2261 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2262
2263 log_info_nn ("");
2264
2265 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2266
2267 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);
2268
2269 uint cpt_cracked = 0;
2270
2271 hc_thread_mutex_lock (mux_display);
2272
2273 for (uint i = 0; i < num_cracked; i++)
2274 {
2275 const uint hash_pos = cracked[i].hash_pos;
2276
2277 if (data.digests_shown[hash_pos] == 1) continue;
2278
2279 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2280 {
2281 data.digests_shown[hash_pos] = 1;
2282
2283 data.digests_done++;
2284
2285 cpt_cracked++;
2286
2287 salt_buf->digests_done++;
2288
2289 if (salt_buf->digests_done == salt_buf->digests_cnt)
2290 {
2291 data.salts_shown[salt_pos] = 1;
2292
2293 data.salts_done++;
2294 }
2295 }
2296
2297 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2298
2299 check_hash (device_param, &cracked[i]);
2300 }
2301
2302 hc_thread_mutex_unlock (mux_display);
2303
2304 myfree (cracked);
2305
2306 if (cpt_cracked > 0)
2307 {
2308 hc_thread_mutex_lock (mux_display);
2309
2310 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2311 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2312
2313 data.cpt_pos++;
2314
2315 data.cpt_total += cpt_cracked;
2316
2317 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2318
2319 hc_thread_mutex_unlock (mux_display);
2320 }
2321
2322 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2323 {
2324 // we need to reset cracked state on the device
2325 // otherwise host thinks again and again the hash was cracked
2326 // and returns invalid password each time
2327
2328 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2329
2330 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);
2331 }
2332
2333 num_cracked = 0;
2334
2335 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2336 }
2337 }
2338
2339 // stolen from princeprocessor ;)
2340
2341 typedef struct
2342 {
2343 FILE *fp;
2344
2345 char buf[BUFSIZ];
2346 int len;
2347
2348 } out_t;
2349
2350 static void out_flush (out_t *out)
2351 {
2352 fwrite (out->buf, 1, out->len, out->fp);
2353
2354 out->len = 0;
2355 }
2356
2357 static void out_push (out_t *out, const u8 *pw_buf, const int pw_len)
2358 {
2359 char *ptr = out->buf + out->len;
2360
2361 memcpy (ptr, pw_buf, pw_len);
2362
2363 ptr[pw_len] = '\n';
2364
2365 out->len += pw_len + 1;
2366
2367 if (out->len >= BUFSIZ - 100)
2368 {
2369 out_flush (out);
2370 }
2371 }
2372
2373 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2374 {
2375 out_t out;
2376
2377 out.fp = stdout;
2378 out.len = 0;
2379
2380 uint plain_buf[16] = { 0 };
2381
2382 u8 *plain_ptr = (u8 *) plain_buf;
2383
2384 uint plain_len = 0;
2385
2386 const uint il_cnt = device_param->kernel_params_buf32[27]; // ugly, i know
2387
2388 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2389 {
2390 pw_t pw;
2391
2392 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2393 {
2394 gidd_to_pw_t (device_param, gidvid, &pw);
2395
2396 const uint pos = device_param->innerloop_pos;
2397
2398 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2399 {
2400 for (int i = 0; i < 8; i++)
2401 {
2402 plain_buf[i] = pw.i[i];
2403 }
2404
2405 plain_len = pw.pw_len;
2406
2407 plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2408
2409 if (plain_len > data.pw_max) plain_len = data.pw_max;
2410
2411 out_push (&out, plain_ptr, plain_len);
2412 }
2413 }
2414 }
2415 else if (data.attack_mode == ATTACK_MODE_COMBI)
2416 {
2417 pw_t pw;
2418
2419 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2420 {
2421 gidd_to_pw_t (device_param, gidvid, &pw);
2422
2423 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2424 {
2425 for (int i = 0; i < 8; i++)
2426 {
2427 plain_buf[i] = pw.i[i];
2428 }
2429
2430 plain_len = pw.pw_len;
2431
2432 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2433 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2434
2435 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2436 {
2437 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2438 }
2439 else
2440 {
2441 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2442
2443 memcpy (plain_ptr, comb_buf, comb_len);
2444 }
2445
2446 plain_len += comb_len;
2447
2448 if (data.pw_max != PW_DICTMAX1)
2449 {
2450 if (plain_len > data.pw_max) plain_len = data.pw_max;
2451 }
2452
2453 out_push (&out, plain_ptr, plain_len);
2454 }
2455 }
2456 }
2457 else if (data.attack_mode == ATTACK_MODE_BF)
2458 {
2459 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2460 {
2461 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2462 {
2463 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2464 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2465
2466 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2467 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2468
2469 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2470 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2471
2472 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2473 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2474
2475 plain_len = data.css_cnt;
2476
2477 out_push (&out, plain_ptr, plain_len);
2478 }
2479 }
2480 }
2481 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2482 {
2483 pw_t pw;
2484
2485 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2486 {
2487 gidd_to_pw_t (device_param, gidvid, &pw);
2488
2489 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2490 {
2491 for (int i = 0; i < 8; i++)
2492 {
2493 plain_buf[i] = pw.i[i];
2494 }
2495
2496 plain_len = pw.pw_len;
2497
2498 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2499
2500 uint start = 0;
2501 uint stop = device_param->kernel_params_mp_buf32[4];
2502
2503 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2504
2505 plain_len += start + stop;
2506
2507 out_push (&out, plain_ptr, plain_len);
2508 }
2509 }
2510 }
2511 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2512 {
2513 pw_t pw;
2514
2515 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2516 {
2517 gidd_to_pw_t (device_param, gidvid, &pw);
2518
2519 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2520 {
2521 for (int i = 0; i < 8; i++)
2522 {
2523 plain_buf[i] = pw.i[i];
2524 }
2525
2526 plain_len = pw.pw_len;
2527
2528 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2529
2530 uint start = 0;
2531 uint stop = device_param->kernel_params_mp_buf32[4];
2532
2533 memmove (plain_ptr + stop, plain_ptr, plain_len);
2534
2535 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2536
2537 plain_len += start + stop;
2538
2539 out_push (&out, plain_ptr, plain_len);
2540 }
2541 }
2542 }
2543
2544 out_flush (&out);
2545 }
2546
2547 static void save_hash ()
2548 {
2549 char *hashfile = data.hashfile;
2550
2551 char new_hashfile[256] = { 0 };
2552 char old_hashfile[256] = { 0 };
2553
2554 snprintf (new_hashfile, 255, "%s.new", hashfile);
2555 snprintf (old_hashfile, 255, "%s.old", hashfile);
2556
2557 unlink (new_hashfile);
2558
2559 char separator = data.separator;
2560
2561 FILE *fp = fopen (new_hashfile, "wb");
2562
2563 if (fp == NULL)
2564 {
2565 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2566
2567 exit (-1);
2568 }
2569
2570 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2571 {
2572 if (data.salts_shown[salt_pos] == 1) continue;
2573
2574 salt_t *salt_buf = &data.salts_buf[salt_pos];
2575
2576 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2577 {
2578 uint idx = salt_buf->digests_offset + digest_pos;
2579
2580 if (data.digests_shown[idx] == 1) continue;
2581
2582 if (data.hash_mode != 2500)
2583 {
2584 if (data.username == 1)
2585 {
2586 user_t *user = data.hash_info[idx]->user;
2587
2588 uint i;
2589
2590 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2591
2592 fputc (separator, fp);
2593 }
2594
2595 char out_buf[HCBUFSIZ]; // scratch buffer
2596
2597 out_buf[0] = 0;
2598
2599 ascii_digest (out_buf, salt_pos, digest_pos);
2600
2601 fputs (out_buf, fp);
2602
2603 fputc ('\n', fp);
2604 }
2605 else
2606 {
2607 hccap_t hccap;
2608
2609 to_hccap_t (&hccap, salt_pos, digest_pos);
2610
2611 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2612 }
2613 }
2614 }
2615
2616 fflush (fp);
2617
2618 fclose (fp);
2619
2620 unlink (old_hashfile);
2621
2622 if (rename (hashfile, old_hashfile) != 0)
2623 {
2624 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2625
2626 exit (-1);
2627 }
2628
2629 unlink (hashfile);
2630
2631 if (rename (new_hashfile, hashfile) != 0)
2632 {
2633 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2634
2635 exit (-1);
2636 }
2637
2638 unlink (old_hashfile);
2639 }
2640
2641 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2642 {
2643 uint num_elements = num;
2644
2645 device_param->kernel_params_buf32[30] = data.combs_mode;
2646 device_param->kernel_params_buf32[31] = num;
2647
2648 uint kernel_threads = device_param->kernel_threads;
2649
2650 while (num_elements % kernel_threads) num_elements++;
2651
2652 cl_kernel kernel = NULL;
2653
2654 switch (kern_run)
2655 {
2656 case KERN_RUN_1: kernel = device_param->kernel1; break;
2657 case KERN_RUN_12: kernel = device_param->kernel12; break;
2658 case KERN_RUN_2: kernel = device_param->kernel2; break;
2659 case KERN_RUN_23: kernel = device_param->kernel23; break;
2660 case KERN_RUN_3: kernel = device_param->kernel3; break;
2661 }
2662
2663 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2664 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2665 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2666 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2667 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2668 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2669 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2670 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2671 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2672 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2673 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2674
2675 cl_event event;
2676
2677 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2678 {
2679 const size_t global_work_size[3] = { num_elements, 32, 1 };
2680 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2681
2682 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2683 }
2684 else
2685 {
2686 if (kern_run == KERN_RUN_2)
2687 {
2688 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2689 {
2690 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2691 }
2692 }
2693
2694 while (num_elements % kernel_threads) num_elements++;
2695
2696 const size_t global_work_size[3] = { num_elements, 1, 1 };
2697 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2698
2699 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2700 }
2701
2702 hc_clFlush (data.ocl, device_param->command_queue);
2703
2704 if (device_param->nvidia_spin_damp)
2705 {
2706 if (data.devices_status == STATUS_RUNNING)
2707 {
2708 if (iteration < EXPECTED_ITERATIONS)
2709 {
2710 switch (kern_run)
2711 {
2712 case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration] * device_param->nvidia_spin_damp); break;
2713 case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration] * device_param->nvidia_spin_damp); break;
2714 case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration] * device_param->nvidia_spin_damp); break;
2715 }
2716 }
2717 }
2718 }
2719
2720 hc_clWaitForEvents (data.ocl, 1, &event);
2721
2722 cl_ulong time_start;
2723 cl_ulong time_end;
2724
2725 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2726 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2727
2728 const double exec_us = (double) (time_end - time_start) / 1000;
2729
2730 if (data.devices_status == STATUS_RUNNING)
2731 {
2732 if (iteration < EXPECTED_ITERATIONS)
2733 {
2734 switch (kern_run)
2735 {
2736 case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2737 case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2738 case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2739 }
2740 }
2741 }
2742
2743 if (event_update)
2744 {
2745 uint exec_pos = device_param->exec_pos;
2746
2747 device_param->exec_ms[exec_pos] = exec_us / 1000;
2748
2749 exec_pos++;
2750
2751 if (exec_pos == EXEC_CACHE)
2752 {
2753 exec_pos = 0;
2754 }
2755
2756 device_param->exec_pos = exec_pos;
2757 }
2758
2759 hc_clReleaseEvent (data.ocl, event);
2760
2761 hc_clFinish (data.ocl, device_param->command_queue);
2762 }
2763
2764 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2765 {
2766 uint num_elements = num;
2767
2768 switch (kern_run)
2769 {
2770 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2771 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2772 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2773 }
2774
2775 // causes problems with special threads like in bcrypt
2776 // const uint kernel_threads = device_param->kernel_threads;
2777
2778 uint kernel_threads = device_param->kernel_threads;
2779
2780 while (num_elements % kernel_threads) num_elements++;
2781
2782 cl_kernel kernel = NULL;
2783
2784 switch (kern_run)
2785 {
2786 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2787 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2788 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2789 }
2790
2791 switch (kern_run)
2792 {
2793 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2794 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2795 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2796 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2797 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2798 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2799 break;
2800 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2801 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2802 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2803 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2804 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2805 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2806 break;
2807 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2808 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2809 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2810 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2811 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2812 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2813 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2814 break;
2815 }
2816
2817 const size_t global_work_size[3] = { num_elements, 1, 1 };
2818 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2819
2820 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2821
2822 hc_clFlush (data.ocl, device_param->command_queue);
2823
2824 hc_clFinish (data.ocl, device_param->command_queue);
2825 }
2826
2827 static void run_kernel_tm (hc_device_param_t *device_param)
2828 {
2829 const uint num_elements = 1024; // fixed
2830
2831 uint kernel_threads = 32;
2832
2833 cl_kernel kernel = device_param->kernel_tm;
2834
2835 const size_t global_work_size[3] = { num_elements, 1, 1 };
2836 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2837
2838 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2839
2840 hc_clFlush (data.ocl, device_param->command_queue);
2841
2842 hc_clFinish (data.ocl, device_param->command_queue);
2843 }
2844
2845 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2846 {
2847 uint num_elements = num;
2848
2849 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2850 device_param->kernel_params_amp_buf32[6] = num_elements;
2851
2852 // causes problems with special threads like in bcrypt
2853 // const uint kernel_threads = device_param->kernel_threads;
2854
2855 uint kernel_threads = device_param->kernel_threads;
2856
2857 while (num_elements % kernel_threads) num_elements++;
2858
2859 cl_kernel kernel = device_param->kernel_amp;
2860
2861 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2862 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2863
2864 const size_t global_work_size[3] = { num_elements, 1, 1 };
2865 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2866
2867 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2868
2869 hc_clFlush (data.ocl, device_param->command_queue);
2870
2871 hc_clFinish (data.ocl, device_param->command_queue);
2872 }
2873
2874 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2875 {
2876 const u32 num16d = num / 16;
2877 const u32 num16m = num % 16;
2878
2879 if (num16d)
2880 {
2881 device_param->kernel_params_memset_buf32[1] = value;
2882 device_param->kernel_params_memset_buf32[2] = num16d;
2883
2884 uint kernel_threads = device_param->kernel_threads;
2885
2886 uint num_elements = num16d;
2887
2888 while (num_elements % kernel_threads) num_elements++;
2889
2890 cl_kernel kernel = device_param->kernel_memset;
2891
2892 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2893 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2894 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2895
2896 const size_t global_work_size[3] = { num_elements, 1, 1 };
2897 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2898
2899 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2900
2901 hc_clFlush (data.ocl, device_param->command_queue);
2902
2903 hc_clFinish (data.ocl, device_param->command_queue);
2904 }
2905
2906 if (num16m)
2907 {
2908 u32 tmp[4];
2909
2910 tmp[0] = value;
2911 tmp[1] = value;
2912 tmp[2] = value;
2913 tmp[3] = value;
2914
2915 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2916 }
2917 }
2918
2919 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2920 {
2921 run_kernel_memset (device_param, buf, 0, size);
2922
2923 /*
2924 int rc = -1;
2925
2926 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2927 {
2928 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2929
2930 const cl_uchar zero = 0;
2931
2932 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2933 }
2934
2935 if (rc != 0)
2936 {
2937 // NOTE: clEnqueueFillBuffer () always fails with -59
2938 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2939 // How's that possible, OpenCL 1.2 support is advertised??
2940 // We need to workaround...
2941
2942 #define FILLSZ 0x100000
2943
2944 char *tmp = (char *) mymalloc (FILLSZ);
2945
2946 for (size_t i = 0; i < size; i += FILLSZ)
2947 {
2948 const size_t left = size - i;
2949
2950 const size_t fillsz = MIN (FILLSZ, left);
2951
2952 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2953 }
2954
2955 myfree (tmp);
2956 }
2957 */
2958 }
2959
2960 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)
2961 {
2962 if (data.hash_mode == 2000)
2963 {
2964 process_stdout (device_param, pws_cnt);
2965
2966 return;
2967 }
2968
2969 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2970 {
2971 if (attack_mode == ATTACK_MODE_BF)
2972 {
2973 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2974 {
2975 const uint size_tm = 32 * sizeof (bs_word_t);
2976
2977 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2978
2979 run_kernel_tm (device_param);
2980
2981 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);
2982 }
2983 }
2984
2985 if (highest_pw_len < 16)
2986 {
2987 run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
2988 }
2989 else if (highest_pw_len < 32)
2990 {
2991 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
2992 }
2993 else
2994 {
2995 run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
2996 }
2997 }
2998 else
2999 {
3000 run_kernel_amp (device_param, pws_cnt);
3001
3002 run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
3003
3004 if (opts_type & OPTS_TYPE_HOOK12)
3005 {
3006 run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
3007
3008 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);
3009
3010 // do something with data
3011
3012 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);
3013 }
3014
3015 uint iter = salt_buf->salt_iter;
3016
3017 uint loop_step = device_param->kernel_loops;
3018
3019 for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
3020 {
3021 uint loop_left = iter - loop_pos;
3022
3023 loop_left = MIN (loop_left, loop_step);
3024
3025 device_param->kernel_params_buf32[25] = loop_pos;
3026 device_param->kernel_params_buf32[26] = loop_left;
3027
3028 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
3029
3030 if (data.devices_status == STATUS_CRACKED) break;
3031 if (data.devices_status == STATUS_ABORTED) break;
3032 if (data.devices_status == STATUS_QUIT) break;
3033
3034 /**
3035 * speed
3036 */
3037
3038 const float iter_part = (float) (loop_pos + loop_left) / iter;
3039
3040 const u64 perf_sum_all = pws_cnt * iter_part;
3041
3042 double speed_ms;
3043
3044 hc_timer_get (device_param->timer_speed, speed_ms);
3045
3046 const u32 speed_pos = device_param->speed_pos;
3047
3048 device_param->speed_cnt[speed_pos] = perf_sum_all;
3049
3050 device_param->speed_ms[speed_pos] = speed_ms;
3051
3052 if (data.benchmark == 1)
3053 {
3054 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
3055 }
3056 }
3057
3058 if (opts_type & OPTS_TYPE_HOOK23)
3059 {
3060 run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
3061
3062 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);
3063
3064 // do something with data
3065
3066 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);
3067 }
3068
3069 run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3070 }
3071 }
3072
3073 static int run_rule_engine (const int rule_len, const char *rule_buf)
3074 {
3075 if (rule_len == 0)
3076 {
3077 return 0;
3078 }
3079 else if (rule_len == 1)
3080 {
3081 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3082 }
3083
3084 return 1;
3085 }
3086
3087 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3088 {
3089 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3090 {
3091 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);
3092 }
3093 else if (data.attack_kern == ATTACK_KERN_COMBI)
3094 {
3095 if (data.attack_mode == ATTACK_MODE_COMBI)
3096 {
3097 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3098 {
3099 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3100 {
3101 for (u32 i = 0; i < pws_cnt; i++)
3102 {
3103 const u32 pw_len = device_param->pws_buf[i].pw_len;
3104
3105 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3106
3107 ptr[pw_len] = 0x01;
3108 }
3109 }
3110 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3111 {
3112 for (u32 i = 0; i < pws_cnt; i++)
3113 {
3114 const u32 pw_len = device_param->pws_buf[i].pw_len;
3115
3116 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3117
3118 ptr[pw_len] = 0x80;
3119 }
3120 }
3121 }
3122 }
3123 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3124 {
3125 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3126 {
3127 for (u32 i = 0; i < pws_cnt; i++)
3128 {
3129 const u32 pw_len = device_param->pws_buf[i].pw_len;
3130
3131 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3132
3133 ptr[pw_len] = 0x01;
3134 }
3135 }
3136 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3137 {
3138 for (u32 i = 0; i < pws_cnt; i++)
3139 {
3140 const u32 pw_len = device_param->pws_buf[i].pw_len;
3141
3142 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3143
3144 ptr[pw_len] = 0x80;
3145 }
3146 }
3147 }
3148
3149 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);
3150 }
3151 else if (data.attack_kern == ATTACK_KERN_BF)
3152 {
3153 const u64 off = device_param->words_off;
3154
3155 device_param->kernel_params_mp_l_buf64[3] = off;
3156
3157 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3158 }
3159 }
3160
3161 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3162 {
3163 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3164
3165 device_param->kernel_params_buf32[25] = 0;
3166 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
3167 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3168
3169 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3170 {
3171 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3172 }
3173 else
3174 {
3175 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3176 }
3177
3178 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3179
3180 return exec_ms_prev;
3181 }
3182
3183 static void autotune (hc_device_param_t *device_param)
3184 {
3185 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3186
3187 const u32 kernel_accel_min = device_param->kernel_accel_min;
3188 const u32 kernel_accel_max = device_param->kernel_accel_max;
3189
3190 const u32 kernel_loops_min = device_param->kernel_loops_min;
3191 const u32 kernel_loops_max = device_param->kernel_loops_max;
3192
3193 u32 kernel_accel = kernel_accel_min;
3194 u32 kernel_loops = kernel_loops_min;
3195
3196 // in this case the user specified a fixed -u and -n on the commandline
3197 // no way to tune anything
3198 // but we need to run a few caching rounds
3199
3200 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3201 {
3202 if (data.hash_mode != 2000)
3203 {
3204 try_run (device_param, kernel_accel, kernel_loops);
3205 try_run (device_param, kernel_accel, kernel_loops);
3206 try_run (device_param, kernel_accel, kernel_loops);
3207 try_run (device_param, kernel_accel, kernel_loops);
3208 }
3209
3210 device_param->kernel_accel = kernel_accel;
3211 device_param->kernel_loops = kernel_loops;
3212
3213 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3214
3215 device_param->kernel_power = kernel_power;
3216
3217 return;
3218 }
3219
3220 // from here it's clear we are allowed to autotune
3221 // so let's init some fake words
3222
3223 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3224
3225 if (data.attack_kern == ATTACK_KERN_BF)
3226 {
3227 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3228 }
3229 else
3230 {
3231 for (u32 i = 0; i < kernel_power_max; i++)
3232 {
3233 device_param->pws_buf[i].i[0] = i;
3234 device_param->pws_buf[i].i[1] = 0x01234567;
3235 device_param->pws_buf[i].pw_len = 7 + (i & 7);
3236 }
3237
3238 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);
3239 }
3240
3241 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3242 {
3243 if (data.kernel_rules_cnt > 1)
3244 {
3245 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);
3246 }
3247 }
3248 else
3249 {
3250 run_kernel_amp (device_param, kernel_power_max);
3251 }
3252
3253 #define VERIFIER_CNT 1
3254
3255 // first find out highest kernel-loops that stays below target_ms
3256
3257 if (kernel_loops_min < kernel_loops_max)
3258 {
3259 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3260 {
3261 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3262
3263 for (int i = 0; i < VERIFIER_CNT; i++)
3264 {
3265 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3266
3267 exec_ms = MIN (exec_ms, exec_ms_v);
3268 }
3269
3270 if (exec_ms < target_ms) break;
3271 }
3272 }
3273
3274 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3275
3276 #define STEPS_CNT 10
3277
3278 if (kernel_accel_min < kernel_accel_max)
3279 {
3280 for (int i = 0; i < STEPS_CNT; i++)
3281 {
3282 const u32 kernel_accel_try = 1 << i;
3283
3284 if (kernel_accel_try < kernel_accel_min) continue;
3285 if (kernel_accel_try > kernel_accel_max) break;
3286
3287 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3288
3289 for (int i = 0; i < VERIFIER_CNT; i++)
3290 {
3291 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3292
3293 exec_ms = MIN (exec_ms, exec_ms_v);
3294 }
3295
3296 if (exec_ms > target_ms) break;
3297
3298 kernel_accel = kernel_accel_try;
3299 }
3300 }
3301
3302 // at this point we want to know the actual runtime for the following reason:
3303 // we need a reference for the balancing loop following up, and this
3304 // the balancing loop can have an effect that the creates a new opportunity, for example:
3305 // if the target is 95 ms and the current runtime is 48ms the above loop
3306 // stopped the execution because the previous exec_ms was > 95ms
3307 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3308 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3309
3310 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3311
3312 for (int i = 0; i < VERIFIER_CNT; i++)
3313 {
3314 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3315
3316 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3317 }
3318
3319 u32 diff = kernel_loops - kernel_accel;
3320
3321 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3322 {
3323 u32 kernel_accel_orig = kernel_accel;
3324 u32 kernel_loops_orig = kernel_loops;
3325
3326 for (u32 f = 1; f < 1024; f++)
3327 {
3328 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3329 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3330
3331 if (kernel_accel_try > kernel_accel_max) break;
3332 if (kernel_loops_try < kernel_loops_min) break;
3333
3334 u32 diff_new = kernel_loops_try - kernel_accel_try;
3335
3336 if (diff_new > diff) break;
3337
3338 diff_new = diff;
3339
3340 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3341
3342 for (int i = 0; i < VERIFIER_CNT; i++)
3343 {
3344 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3345
3346 exec_ms = MIN (exec_ms, exec_ms_v);
3347 }
3348
3349 if (exec_ms < exec_ms_pre_final)
3350 {
3351 exec_ms_pre_final = exec_ms;
3352
3353 kernel_accel = kernel_accel_try;
3354 kernel_loops = kernel_loops_try;
3355 }
3356 }
3357 }
3358
3359 const double exec_left = target_ms / exec_ms_pre_final;
3360
3361 const double accel_left = kernel_accel_max / kernel_accel;
3362
3363 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3364
3365 if (exec_accel_min >= 1.0)
3366 {
3367 // this is safe to not overflow kernel_accel_max because of accel_left
3368
3369 kernel_accel = (double) kernel_accel * exec_accel_min;
3370 }
3371
3372 // reset them fake words
3373
3374 /*
3375 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3376
3377 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);
3378 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);
3379 */
3380
3381 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3382
3383 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3384 {
3385 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3386 }
3387
3388 // reset timer
3389
3390 device_param->exec_pos = 0;
3391
3392 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3393
3394 memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3395 memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3396 memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3397
3398 // store
3399
3400 device_param->kernel_accel = kernel_accel;
3401 device_param->kernel_loops = kernel_loops;
3402
3403 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3404
3405 device_param->kernel_power = kernel_power;
3406
3407 #ifdef DEBUG
3408
3409 if (data.quiet == 0)
3410 {
3411 clear_prompt ();
3412
3413 log_info ("- Device #%u: autotuned kernel-accel to %u\n"
3414 "- Device #%u: autotuned kernel-loops to %u\n",
3415 device_param->device_id + 1, kernel_accel,
3416 device_param->device_id + 1, kernel_loops);
3417
3418 fprintf (stdout, "%s", PROMPT);
3419
3420 fflush (stdout);
3421 }
3422
3423 #endif
3424 }
3425
3426 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3427 {
3428 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3429
3430 // init speed timer
3431
3432 uint speed_pos = device_param->speed_pos;
3433
3434 #ifdef _POSIX
3435 if (device_param->timer_speed.tv_sec == 0)
3436 {
3437 hc_timer_set (&device_param->timer_speed);
3438 }
3439 #endif
3440
3441 #ifdef _WIN
3442 if (device_param->timer_speed.QuadPart == 0)
3443 {
3444 hc_timer_set (&device_param->timer_speed);
3445 }
3446 #endif
3447
3448 // find higest password length, this is for optimization stuff
3449
3450 uint highest_pw_len = 0;
3451
3452 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3453 {
3454 }
3455 else if (data.attack_kern == ATTACK_KERN_COMBI)
3456 {
3457 }
3458 else if (data.attack_kern == ATTACK_KERN_BF)
3459 {
3460 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3461 + device_param->kernel_params_mp_l_buf32[5];
3462 }
3463
3464 // iteration type
3465
3466 uint innerloop_step = 0;
3467 uint innerloop_cnt = 0;
3468
3469 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3470 else innerloop_step = 1;
3471
3472 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3473 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3474 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3475
3476 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3477
3478 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3479 {
3480 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3481
3482 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3483
3484 if (data.devices_status == STATUS_CRACKED) break;
3485 if (data.devices_status == STATUS_ABORTED) break;
3486 if (data.devices_status == STATUS_QUIT) break;
3487 if (data.devices_status == STATUS_BYPASS) break;
3488
3489 salt_t *salt_buf = &data.salts_buf[salt_pos];
3490
3491 device_param->kernel_params_buf32[24] = salt_pos;
3492 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3493 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3494
3495 FILE *combs_fp = device_param->combs_fp;
3496
3497 if (data.attack_mode == ATTACK_MODE_COMBI)
3498 {
3499 rewind (combs_fp);
3500 }
3501
3502 // innerloops
3503
3504 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3505 {
3506 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3507
3508 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3509
3510 if (data.devices_status == STATUS_CRACKED) break;
3511 if (data.devices_status == STATUS_ABORTED) break;
3512 if (data.devices_status == STATUS_QUIT) break;
3513 if (data.devices_status == STATUS_BYPASS) break;
3514
3515 uint fast_iteration = 0;
3516
3517 uint innerloop_left = innerloop_cnt - innerloop_pos;
3518
3519 if (innerloop_left > innerloop_step)
3520 {
3521 innerloop_left = innerloop_step;
3522
3523 fast_iteration = 1;
3524 }
3525
3526 device_param->innerloop_pos = innerloop_pos;
3527 device_param->innerloop_left = innerloop_left;
3528
3529 device_param->kernel_params_buf32[27] = innerloop_left;
3530
3531 // i think we can get rid of this
3532 if (innerloop_left == 0)
3533 {
3534 puts ("bug, how should this happen????\n");
3535
3536 continue;
3537 }
3538
3539 if (data.salts_shown[salt_pos] == 1)
3540 {
3541 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3542
3543 continue;
3544 }
3545
3546 // initialize amplifiers
3547
3548 if (data.attack_mode == ATTACK_MODE_COMBI)
3549 {
3550 uint i = 0;
3551
3552 while (i < innerloop_left)
3553 {
3554 if (feof (combs_fp)) break;
3555
3556 int line_len = fgetl (combs_fp, line_buf);
3557
3558 if (line_len >= PW_MAX1) continue;
3559
3560 line_len = convert_from_hex (line_buf, line_len);
3561
3562 char *line_buf_new = line_buf;
3563
3564 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3565 {
3566 char rule_buf_out[BLOCK_SIZE] = { 0 };
3567
3568 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3569
3570 if (rule_len_out < 0)
3571 {
3572 data.words_progress_rejected[salt_pos] += pws_cnt;
3573
3574 continue;
3575 }
3576
3577 line_len = rule_len_out;
3578
3579 line_buf_new = rule_buf_out;
3580 }
3581
3582 line_len = MIN (line_len, PW_DICTMAX);
3583
3584 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3585
3586 memcpy (ptr, line_buf_new, line_len);
3587
3588 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3589
3590 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3591 {
3592 uppercase (ptr, line_len);
3593 }
3594
3595 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3596 {
3597 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3598 {
3599 ptr[line_len] = 0x80;
3600 }
3601
3602 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3603 {
3604 ptr[line_len] = 0x01;
3605 }
3606 }
3607
3608 device_param->combs_buf[i].pw_len = line_len;
3609
3610 i++;
3611 }
3612
3613 for (uint j = i; j < innerloop_left; j++)
3614 {
3615 device_param->combs_buf[j].i[0] = 0;
3616 device_param->combs_buf[j].i[1] = 0;
3617 device_param->combs_buf[j].i[2] = 0;
3618 device_param->combs_buf[j].i[3] = 0;
3619 device_param->combs_buf[j].i[4] = 0;
3620 device_param->combs_buf[j].i[5] = 0;
3621 device_param->combs_buf[j].i[6] = 0;
3622 device_param->combs_buf[j].i[7] = 0;
3623
3624 device_param->combs_buf[j].pw_len = 0;
3625 }
3626
3627 innerloop_left = i;
3628 }
3629 else if (data.attack_mode == ATTACK_MODE_BF)
3630 {
3631 u64 off = innerloop_pos;
3632
3633 device_param->kernel_params_mp_r_buf64[3] = off;
3634
3635 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3636 }
3637 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3638 {
3639 u64 off = innerloop_pos;
3640
3641 device_param->kernel_params_mp_buf64[3] = off;
3642
3643 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3644 }
3645 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
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
3654 // copy amplifiers
3655
3656 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3657 {
3658 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);
3659 }
3660 else if (data.attack_mode == ATTACK_MODE_COMBI)
3661 {
3662 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);
3663 }
3664 else if (data.attack_mode == ATTACK_MODE_BF)
3665 {
3666 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);
3667 }
3668 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3669 {
3670 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);
3671 }
3672 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3673 {
3674 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);
3675 }
3676
3677 if (data.benchmark == 1)
3678 {
3679 hc_timer_set (&device_param->timer_speed);
3680 }
3681
3682 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
3683
3684 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3685
3686 if (data.devices_status == STATUS_CRACKED) break;
3687 if (data.devices_status == STATUS_ABORTED) break;
3688 if (data.devices_status == STATUS_QUIT) break;
3689
3690 /**
3691 * result
3692 */
3693
3694 if (data.benchmark == 0)
3695 {
3696 check_cracked (device_param, salt_pos);
3697 }
3698
3699 /**
3700 * progress
3701 */
3702
3703 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3704
3705 hc_thread_mutex_lock (mux_counter);
3706
3707 data.words_progress_done[salt_pos] += perf_sum_all;
3708
3709 hc_thread_mutex_unlock (mux_counter);
3710
3711 /**
3712 * speed
3713 */
3714
3715 double speed_ms;
3716
3717 hc_timer_get (device_param->timer_speed, speed_ms);
3718
3719 hc_timer_set (&device_param->timer_speed);
3720
3721 // current speed
3722
3723 //hc_thread_mutex_lock (mux_display);
3724
3725 device_param->speed_cnt[speed_pos] = perf_sum_all;
3726
3727 device_param->speed_ms[speed_pos] = speed_ms;
3728
3729 //hc_thread_mutex_unlock (mux_display);
3730
3731 speed_pos++;
3732
3733 if (speed_pos == SPEED_CACHE)
3734 {
3735 speed_pos = 0;
3736 }
3737
3738 /**
3739 * benchmark
3740 */
3741
3742 if (data.benchmark == 1) break;
3743 }
3744 }
3745
3746 device_param->speed_pos = speed_pos;
3747
3748 myfree (line_buf);
3749 }
3750
3751 static void load_segment (wl_data_t *wl_data, FILE *fd)
3752 {
3753 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3754
3755 wl_data->pos = 0;
3756
3757 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3758
3759 wl_data->buf[wl_data->cnt] = 0;
3760
3761 if (wl_data->cnt == 0) return;
3762
3763 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3764
3765 while (!feof (fd))
3766 {
3767 if (wl_data->cnt == wl_data->avail)
3768 {
3769 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3770
3771 wl_data->avail += wl_data->incr;
3772 }
3773
3774 const int c = fgetc (fd);
3775
3776 if (c == EOF) break;
3777
3778 wl_data->buf[wl_data->cnt] = (char) c;
3779
3780 wl_data->cnt++;
3781
3782 if (c == '\n') break;
3783 }
3784
3785 // ensure stream ends with a newline
3786
3787 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3788 {
3789 wl_data->cnt++;
3790
3791 wl_data->buf[wl_data->cnt - 1] = '\n';
3792 }
3793
3794 return;
3795 }
3796
3797 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3798 {
3799 char *ptr = buf;
3800
3801 for (u32 i = 0; i < sz; i++, ptr++)
3802 {
3803 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3804
3805 if (i == 7)
3806 {
3807 *off = i;
3808 *len = i;
3809
3810 return;
3811 }
3812
3813 if (*ptr != '\n') continue;
3814
3815 *off = i + 1;
3816
3817 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3818
3819 *len = i;
3820
3821 return;
3822 }
3823
3824 *off = sz;
3825 *len = sz;
3826 }
3827
3828 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3829 {
3830 char *ptr = buf;
3831
3832 for (u32 i = 0; i < sz; i++, ptr++)
3833 {
3834 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3835
3836 if (*ptr != '\n') continue;
3837
3838 *off = i + 1;
3839
3840 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3841
3842 *len = i;
3843
3844 return;
3845 }
3846
3847 *off = sz;
3848 *len = sz;
3849 }
3850
3851 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3852 {
3853 char *ptr = buf;
3854
3855 for (u32 i = 0; i < sz; i++, ptr++)
3856 {
3857 if (*ptr != '\n') continue;
3858
3859 *off = i + 1;
3860
3861 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3862
3863 *len = i;
3864
3865 return;
3866 }
3867
3868 *off = sz;
3869 *len = sz;
3870 }
3871
3872 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3873 {
3874 while (wl_data->pos < wl_data->cnt)
3875 {
3876 uint off;
3877 uint len;
3878
3879 char *ptr = wl_data->buf + wl_data->pos;
3880
3881 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3882
3883 wl_data->pos += off;
3884
3885 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3886 {
3887 char rule_buf_out[BLOCK_SIZE] = { 0 };
3888
3889 int rule_len_out = -1;
3890
3891 if (len < BLOCK_SIZE)
3892 {
3893 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3894 }
3895
3896 if (rule_len_out < 0)
3897 {
3898 continue;
3899 }
3900
3901 if (rule_len_out > PW_MAX)
3902 {
3903 continue;
3904 }
3905 }
3906 else
3907 {
3908 if (len > PW_MAX)
3909 {
3910 continue;
3911 }
3912 }
3913
3914 *out_buf = ptr;
3915 *out_len = len;
3916
3917 return;
3918 }
3919
3920 if (feof (fd))
3921 {
3922 fprintf (stderr, "BUG feof()!!\n");
3923
3924 return;
3925 }
3926
3927 load_segment (wl_data, fd);
3928
3929 get_next_word (wl_data, fd, out_buf, out_len);
3930 }
3931
3932 #ifdef _POSIX
3933 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3934 #endif
3935
3936 #ifdef _WIN
3937 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3938 #endif
3939 {
3940 hc_signal (NULL);
3941
3942 dictstat_t d;
3943
3944 d.cnt = 0;
3945
3946 #ifdef _POSIX
3947 fstat (fileno (fd), &d.stat);
3948 #endif
3949
3950 #ifdef _WIN
3951 _fstat64 (fileno (fd), &d.stat);
3952 #endif
3953
3954 d.stat.st_mode = 0;
3955 d.stat.st_nlink = 0;
3956 d.stat.st_uid = 0;
3957 d.stat.st_gid = 0;
3958 d.stat.st_rdev = 0;
3959 d.stat.st_atime = 0;
3960
3961 #ifdef _POSIX
3962 d.stat.st_blksize = 0;
3963 d.stat.st_blocks = 0;
3964 #endif
3965
3966 if (d.stat.st_size == 0) return 0;
3967
3968 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3969
3970 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3971 {
3972 if (d_cache)
3973 {
3974 u64 cnt = d_cache->cnt;
3975
3976 u64 keyspace = cnt;
3977
3978 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3979 {
3980 keyspace *= data.kernel_rules_cnt;
3981 }
3982 else if (data.attack_kern == ATTACK_KERN_COMBI)
3983 {
3984 keyspace *= data.combs_cnt;
3985 }
3986
3987 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);
3988 if (data.quiet == 0) log_info ("");
3989
3990 hc_signal (sigHandler_default);
3991
3992 return (keyspace);
3993 }
3994 }
3995
3996 time_t now = 0;
3997 time_t prev = 0;
3998
3999 u64 comp = 0;
4000 u64 cnt = 0;
4001 u64 cnt2 = 0;
4002
4003 while (!feof (fd))
4004 {
4005 load_segment (wl_data, fd);
4006
4007 comp += wl_data->cnt;
4008
4009 u32 i = 0;
4010
4011 while (i < wl_data->cnt)
4012 {
4013 u32 len;
4014 u32 off;
4015
4016 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
4017
4018 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4019 {
4020 char rule_buf_out[BLOCK_SIZE] = { 0 };
4021
4022 int rule_len_out = -1;
4023
4024 if (len < BLOCK_SIZE)
4025 {
4026 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
4027 }
4028
4029 if (rule_len_out < 0)
4030 {
4031 len = PW_MAX1;
4032 }
4033 else
4034 {
4035 len = rule_len_out;
4036 }
4037 }
4038
4039 if (len < PW_MAX1)
4040 {
4041 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4042 {
4043 cnt += data.kernel_rules_cnt;
4044 }
4045 else if (data.attack_kern == ATTACK_KERN_COMBI)
4046 {
4047 cnt += data.combs_cnt;
4048 }
4049
4050 d.cnt++;
4051 }
4052
4053 i += off;
4054
4055 cnt2++;
4056 }
4057
4058 time (&now);
4059
4060 if ((now - prev) == 0) continue;
4061
4062 float percent = (float) comp / (float) d.stat.st_size;
4063
4064 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);
4065
4066 time (&prev);
4067 }
4068
4069 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);
4070 if (data.quiet == 0) log_info ("");
4071
4072 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4073
4074 hc_signal (sigHandler_default);
4075
4076 return (cnt);
4077 }
4078
4079 static void *thread_monitor (void *p)
4080 {
4081 uint runtime_check = 0;
4082 uint remove_check = 0;
4083 uint status_check = 0;
4084 uint restore_check = 0;
4085
4086 uint restore_left = data.restore_timer;
4087 uint remove_left = data.remove_timer;
4088 uint status_left = data.status_timer;
4089
4090 #ifdef HAVE_HWMON
4091 uint hwmon_check = 0;
4092
4093 int slowdown_warnings = 0;
4094
4095 // these variables are mainly used for fan control
4096
4097 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4098
4099 // temperature controller "loopback" values
4100
4101 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4102 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4103
4104 int temp_threshold = 1; // degrees celcius
4105
4106 int fan_speed_min = 15; // in percentage
4107 int fan_speed_max = 100;
4108
4109 time_t last_temp_check_time;
4110 #endif // HAVE_HWMON
4111
4112 uint sleep_time = 1;
4113
4114 if (data.runtime)
4115 {
4116 runtime_check = 1;
4117 }
4118
4119 if (data.restore_timer)
4120 {
4121 restore_check = 1;
4122 }
4123
4124 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4125 {
4126 remove_check = 1;
4127 }
4128
4129 if (data.status == 1)
4130 {
4131 status_check = 1;
4132 }
4133
4134 #ifdef HAVE_HWMON
4135 if (data.gpu_temp_disable == 0)
4136 {
4137 time (&last_temp_check_time);
4138
4139 hwmon_check = 1;
4140 }
4141 #endif
4142
4143 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4144 {
4145 #ifdef HAVE_HWMON
4146 if (hwmon_check == 0)
4147 #endif
4148 return (p);
4149 }
4150
4151 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4152 {
4153 hc_sleep (sleep_time);
4154
4155 if (data.devices_status != STATUS_RUNNING) continue;
4156
4157 #ifdef HAVE_HWMON
4158
4159 if (hwmon_check == 1)
4160 {
4161 hc_thread_mutex_lock (mux_adl);
4162
4163 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4164 {
4165 hc_device_param_t *device_param = &data.devices_param[device_id];
4166
4167 if (device_param->skipped) continue;
4168
4169 if (device_param->device_vendor_id == VENDOR_ID_NV)
4170 {
4171 if (data.hm_nvapi)
4172 {
4173 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
4174 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
4175
4176 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4177 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4178
4179 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4180
4181 perfPolicies_status.info_value = perfPolicies_info.info_value;
4182
4183 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4184
4185 if (perfPolicies_status.throttle & 2)
4186 {
4187 if (slowdown_warnings < 3)
4188 {
4189 if (data.quiet == 0) clear_prompt ();
4190
4191 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4192
4193 if (slowdown_warnings == 2)
4194 {
4195 log_info ("");
4196 }
4197
4198 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4199 if (data.quiet == 0) fflush (stdout);
4200
4201 slowdown_warnings++;
4202 }
4203 }
4204 else
4205 {
4206 slowdown_warnings = 0;
4207 }
4208 }
4209 }
4210 }
4211
4212 hc_thread_mutex_unlock (mux_adl);
4213 }
4214
4215 if (hwmon_check == 1)
4216 {
4217 hc_thread_mutex_lock (mux_adl);
4218
4219 time_t temp_check_time;
4220
4221 time (&temp_check_time);
4222
4223 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4224
4225 if (Ta == 0) Ta = 1;
4226
4227 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4228 {
4229 hc_device_param_t *device_param = &data.devices_param[device_id];
4230
4231 if (device_param->skipped) continue;
4232
4233 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4234
4235 const int temperature = hm_get_temperature_with_device_id (device_id);
4236
4237 if (temperature > (int) data.gpu_temp_abort)
4238 {
4239 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4240
4241 if (data.devices_status != STATUS_QUIT) myabort ();
4242
4243 break;
4244 }
4245
4246 const int gpu_temp_retain = data.gpu_temp_retain;
4247
4248 if (gpu_temp_retain)
4249 {
4250 if (data.hm_device[device_id].fan_set_supported == 1)
4251 {
4252 int temp_cur = temperature;
4253
4254 int temp_diff_new = gpu_temp_retain - temp_cur;
4255
4256 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4257
4258 // calculate Ta value (time difference in seconds between the last check and this check)
4259
4260 last_temp_check_time = temp_check_time;
4261
4262 float Kp = 1.8;
4263 float Ki = 0.005;
4264 float Kd = 6;
4265
4266 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4267
4268 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);
4269
4270 if (abs (fan_diff_required) >= temp_threshold)
4271 {
4272 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4273
4274 int fan_speed_level = fan_speed_cur;
4275
4276 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4277
4278 int fan_speed_new = fan_speed_level - fan_diff_required;
4279
4280 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4281 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4282
4283 if (fan_speed_new != fan_speed_cur)
4284 {
4285 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4286 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4287
4288 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4289 {
4290 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4291 {
4292 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4293 }
4294 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4295 {
4296 #ifdef WIN
4297 hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1);
4298 #endif
4299
4300 #ifdef LINUX
4301 hm_set_fanspeed_with_device_id_xnvctrl (device_id, fan_speed_new);
4302 #endif
4303 }
4304
4305 fan_speed_chgd[device_id] = 1;
4306 }
4307
4308 temp_diff_old[device_id] = temp_diff_new;
4309 }
4310 }
4311 }
4312 }
4313 }
4314
4315 hc_thread_mutex_unlock (mux_adl);
4316 }
4317 #endif // HAVE_HWMON
4318
4319 if (restore_check == 1)
4320 {
4321 restore_left--;
4322
4323 if (restore_left == 0)
4324 {
4325 if (data.restore_disable == 0) cycle_restore ();
4326
4327 restore_left = data.restore_timer;
4328 }
4329 }
4330
4331 if ((runtime_check == 1) && (data.runtime_start > 0))
4332 {
4333 time_t runtime_cur;
4334
4335 time (&runtime_cur);
4336
4337 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4338
4339 if (runtime_left <= 0)
4340 {
4341 if (data.benchmark == 0)
4342 {
4343 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4344 }
4345
4346 if (data.devices_status != STATUS_QUIT) myabort ();
4347 }
4348 }
4349
4350 if (remove_check == 1)
4351 {
4352 remove_left--;
4353
4354 if (remove_left == 0)
4355 {
4356 if (data.digests_saved != data.digests_done)
4357 {
4358 data.digests_saved = data.digests_done;
4359
4360 save_hash ();
4361 }
4362
4363 remove_left = data.remove_timer;
4364 }
4365 }
4366
4367 if (status_check == 1)
4368 {
4369 status_left--;
4370
4371 if (status_left == 0)
4372 {
4373 //hc_thread_mutex_lock (mux_display);
4374
4375 if (data.quiet == 0) clear_prompt ();
4376
4377 if (data.quiet == 0) log_info ("");
4378
4379 status_display ();
4380
4381 if (data.quiet == 0) log_info ("");
4382
4383 //hc_thread_mutex_unlock (mux_display);
4384
4385 status_left = data.status_timer;
4386 }
4387 }
4388 }
4389
4390 #ifdef HAVE_HWMON
4391 myfree (fan_speed_chgd);
4392
4393 myfree (temp_diff_old);
4394 myfree (temp_diff_sum);
4395 #endif
4396
4397 p = NULL;
4398
4399 return (p);
4400 }
4401
4402 static void *thread_outfile_remove (void *p)
4403 {
4404 // some hash-dependent constants
4405 char *outfile_dir = data.outfile_check_directory;
4406 uint dgst_size = data.dgst_size;
4407 uint isSalted = data.isSalted;
4408 uint esalt_size = data.esalt_size;
4409 uint hash_mode = data.hash_mode;
4410
4411 uint outfile_check_timer = data.outfile_check_timer;
4412
4413 char separator = data.separator;
4414
4415 // some hash-dependent functions
4416 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4417 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4418
4419 // buffers
4420 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4421
4422 hash_buf.digest = mymalloc (dgst_size);
4423
4424 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4425
4426 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4427
4428 uint digest_buf[64] = { 0 };
4429
4430 outfile_data_t *out_info = NULL;
4431
4432 char **out_files = NULL;
4433
4434 time_t folder_mtime = 0;
4435
4436 int out_cnt = 0;
4437
4438 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4439
4440 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4441 {
4442 hc_sleep (1);
4443
4444 if (data.devices_status != STATUS_RUNNING) continue;
4445
4446 check_left--;
4447
4448 if (check_left == 0)
4449 {
4450 struct stat outfile_check_stat;
4451
4452 if (stat (outfile_dir, &outfile_check_stat) == 0)
4453 {
4454 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4455
4456 if (is_dir == 1)
4457 {
4458 if (outfile_check_stat.st_mtime > folder_mtime)
4459 {
4460 char **out_files_new = scan_directory (outfile_dir);
4461
4462 int out_cnt_new = count_dictionaries (out_files_new);
4463
4464 outfile_data_t *out_info_new = NULL;
4465
4466 if (out_cnt_new > 0)
4467 {
4468 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4469
4470 for (int i = 0; i < out_cnt_new; i++)
4471 {
4472 out_info_new[i].file_name = out_files_new[i];
4473
4474 // check if there are files that we have seen/checked before (and not changed)
4475
4476 for (int j = 0; j < out_cnt; j++)
4477 {
4478 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4479 {
4480 struct stat outfile_stat;
4481
4482 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4483 {
4484 if (outfile_stat.st_ctime == out_info[j].ctime)
4485 {
4486 out_info_new[i].ctime = out_info[j].ctime;
4487 out_info_new[i].seek = out_info[j].seek;
4488 }
4489 }
4490 }
4491 }
4492 }
4493 }
4494
4495 local_free (out_info);
4496 local_free (out_files);
4497
4498 out_files = out_files_new;
4499 out_cnt = out_cnt_new;
4500 out_info = out_info_new;
4501
4502 folder_mtime = outfile_check_stat.st_mtime;
4503 }
4504
4505 for (int j = 0; j < out_cnt; j++)
4506 {
4507 FILE *fp = fopen (out_info[j].file_name, "rb");
4508
4509 if (fp != NULL)
4510 {
4511 //hc_thread_mutex_lock (mux_display);
4512
4513 #ifdef _POSIX
4514 struct stat outfile_stat;
4515
4516 fstat (fileno (fp), &outfile_stat);
4517 #endif
4518
4519 #ifdef _WIN
4520 struct stat64 outfile_stat;
4521
4522 _fstat64 (fileno (fp), &outfile_stat);
4523 #endif
4524
4525 if (outfile_stat.st_ctime > out_info[j].ctime)
4526 {
4527 out_info[j].ctime = outfile_stat.st_ctime;
4528 out_info[j].seek = 0;
4529 }
4530
4531 fseek (fp, out_info[j].seek, SEEK_SET);
4532
4533 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4534
4535 while (!feof (fp))
4536 {
4537 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4538
4539 if (ptr == NULL) break;
4540
4541 int line_len = strlen (line_buf);
4542
4543 if (line_len <= 0) continue;
4544
4545 int iter = MAX_CUT_TRIES;
4546
4547 for (uint i = line_len - 1; i && iter; i--, line_len--)
4548 {
4549 if (line_buf[i] != separator) continue;
4550
4551 int parser_status = PARSER_OK;
4552
4553 if ((hash_mode != 2500) && (hash_mode != 6800))
4554 {
4555 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4556 }
4557
4558 uint found = 0;
4559
4560 if (parser_status == PARSER_OK)
4561 {
4562 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4563 {
4564 if (data.salts_shown[salt_pos] == 1) continue;
4565
4566 salt_t *salt_buf = &data.salts_buf[salt_pos];
4567
4568 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4569 {
4570 uint idx = salt_buf->digests_offset + digest_pos;
4571
4572 if (data.digests_shown[idx] == 1) continue;
4573
4574 uint cracked = 0;
4575
4576 if (hash_mode == 6800)
4577 {
4578 if (i == salt_buf->salt_len)
4579 {
4580 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4581 }
4582 }
4583 else if (hash_mode == 2500)
4584 {
4585 // BSSID : MAC1 : MAC2 (:plain)
4586 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4587 {
4588 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4589
4590 if (!cracked) continue;
4591
4592 // now compare MAC1 and MAC2 too, since we have this additional info
4593 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4594 char *mac2_pos = mac1_pos + 12 + 1;
4595
4596 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4597 wpa_t *wpa = &wpas[salt_pos];
4598
4599 // compare hex string(s) vs binary MAC address(es)
4600
4601 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4602 {
4603 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4604 {
4605 cracked = 0;
4606
4607 break;
4608 }
4609 }
4610
4611 // early skip ;)
4612 if (!cracked) continue;
4613
4614 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4615 {
4616 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4617 {
4618 cracked = 0;
4619
4620 break;
4621 }
4622 }
4623 }
4624 }
4625 else
4626 {
4627 char *digests_buf_ptr = (char *) data.digests_buf;
4628
4629 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4630
4631 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4632 }
4633
4634 if (cracked == 1)
4635 {
4636 found = 1;
4637
4638 data.digests_shown[idx] = 1;
4639
4640 data.digests_done++;
4641
4642 salt_buf->digests_done++;
4643
4644 if (salt_buf->digests_done == salt_buf->digests_cnt)
4645 {
4646 data.salts_shown[salt_pos] = 1;
4647
4648 data.salts_done++;
4649
4650 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4651 }
4652 }
4653 }
4654
4655 if (data.devices_status == STATUS_CRACKED) break;
4656 }
4657 }
4658
4659 if (found) break;
4660
4661 if (data.devices_status == STATUS_CRACKED) break;
4662
4663 iter--;
4664 }
4665
4666 if (data.devices_status == STATUS_CRACKED) break;
4667 }
4668
4669 myfree (line_buf);
4670
4671 out_info[j].seek = ftell (fp);
4672
4673 //hc_thread_mutex_unlock (mux_display);
4674
4675 fclose (fp);
4676 }
4677 }
4678 }
4679 }
4680
4681 check_left = outfile_check_timer;
4682 }
4683 }
4684
4685 if (esalt_size) local_free (hash_buf.esalt);
4686
4687 if (isSalted) local_free (hash_buf.salt);
4688
4689 local_free (hash_buf.digest);
4690
4691 local_free (out_info);
4692
4693 local_free (out_files);
4694
4695 p = NULL;
4696
4697 return (p);
4698 }
4699
4700 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4701 {
4702 //if (device_param->pws_cnt < device_param->kernel_power)
4703 //{
4704 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4705
4706 u8 *ptr = (u8 *) pw->i;
4707
4708 memcpy (ptr, pw_buf, pw_len);
4709
4710 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4711
4712 pw->pw_len = pw_len;
4713
4714 device_param->pws_cnt++;
4715 //}
4716 //else
4717 //{
4718 // fprintf (stderr, "BUG pw_add()!!\n");
4719 //
4720 // return;
4721 //}
4722 }
4723
4724 static void set_kernel_power_final (const u64 kernel_power_final)
4725 {
4726 if (data.quiet == 0)
4727 {
4728 clear_prompt ();
4729
4730 //log_info ("");
4731
4732 log_info ("INFO: approaching final keyspace, workload adjusted");
4733 log_info ("");
4734
4735 fprintf (stdout, "%s", PROMPT);
4736
4737 fflush (stdout);
4738 }
4739
4740 data.kernel_power_final = kernel_power_final;
4741 }
4742
4743 static u32 get_power (hc_device_param_t *device_param)
4744 {
4745 const u64 kernel_power_final = data.kernel_power_final;
4746
4747 if (kernel_power_final)
4748 {
4749 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4750
4751 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4752
4753 // work should be at least the hardware power available without any accelerator
4754
4755 const u64 work = MAX (words_left_device, device_param->hardware_power);
4756
4757 return work;
4758 }
4759
4760 return device_param->kernel_power;
4761 }
4762
4763 static uint get_work (hc_device_param_t *device_param, const u64 max)
4764 {
4765 hc_thread_mutex_lock (mux_dispatcher);
4766
4767 const u64 words_cur = data.words_cur;
4768 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4769
4770 device_param->words_off = words_cur;
4771
4772 const u64 kernel_power_all = data.kernel_power_all;
4773
4774 const u64 words_left = words_base - words_cur;
4775
4776 if (words_left < kernel_power_all)
4777 {
4778 if (data.kernel_power_final == 0)
4779 {
4780 set_kernel_power_final (words_left);
4781 }
4782 }
4783
4784 const u32 kernel_power = get_power (device_param);
4785
4786 uint work = MIN (words_left, kernel_power);
4787
4788 work = MIN (work, max);
4789
4790 data.words_cur += work;
4791
4792 hc_thread_mutex_unlock (mux_dispatcher);
4793
4794 return work;
4795 }
4796
4797 static void *thread_autotune (void *p)
4798 {
4799 hc_device_param_t *device_param = (hc_device_param_t *) p;
4800
4801 if (device_param->skipped) return NULL;
4802
4803 autotune (device_param);
4804
4805 return NULL;
4806 }
4807
4808 static void *thread_calc_stdin (void *p)
4809 {
4810 hc_device_param_t *device_param = (hc_device_param_t *) p;
4811
4812 if (device_param->skipped) return NULL;
4813
4814 char *buf = (char *) mymalloc (HCBUFSIZ);
4815
4816 const uint attack_kern = data.attack_kern;
4817
4818 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4819 {
4820 hc_thread_mutex_lock (mux_dispatcher);
4821
4822 if (feof (stdin) != 0)
4823 {
4824 hc_thread_mutex_unlock (mux_dispatcher);
4825
4826 break;
4827 }
4828
4829 uint words_cur = 0;
4830
4831 while (words_cur < device_param->kernel_power)
4832 {
4833 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4834
4835 if (line_buf == NULL) break;
4836
4837 uint line_len = in_superchop (line_buf);
4838
4839 line_len = convert_from_hex (line_buf, line_len);
4840
4841 // post-process rule engine
4842
4843 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4844 {
4845 char rule_buf_out[BLOCK_SIZE] = { 0 };
4846
4847 int rule_len_out = -1;
4848
4849 if (line_len < BLOCK_SIZE)
4850 {
4851 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4852 }
4853
4854 if (rule_len_out < 0) continue;
4855
4856 line_buf = rule_buf_out;
4857 line_len = rule_len_out;
4858 }
4859
4860 if (line_len > PW_MAX)
4861 {
4862 continue;
4863 }
4864
4865 // hmm that's always the case, or?
4866
4867 if (attack_kern == ATTACK_KERN_STRAIGHT)
4868 {
4869 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4870 {
4871 hc_thread_mutex_lock (mux_counter);
4872
4873 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4874 {
4875 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4876 }
4877
4878 hc_thread_mutex_unlock (mux_counter);
4879
4880 continue;
4881 }
4882 }
4883
4884 pw_add (device_param, (u8 *) line_buf, line_len);
4885
4886 words_cur++;
4887
4888 if (data.devices_status == STATUS_CRACKED) break;
4889 if (data.devices_status == STATUS_ABORTED) break;
4890 if (data.devices_status == STATUS_QUIT) break;
4891 if (data.devices_status == STATUS_BYPASS) break;
4892 }
4893
4894 hc_thread_mutex_unlock (mux_dispatcher);
4895
4896 if (data.devices_status == STATUS_CRACKED) break;
4897 if (data.devices_status == STATUS_ABORTED) break;
4898 if (data.devices_status == STATUS_QUIT) break;
4899 if (data.devices_status == STATUS_BYPASS) break;
4900
4901 // flush
4902
4903 const uint pws_cnt = device_param->pws_cnt;
4904
4905 if (pws_cnt)
4906 {
4907 run_copy (device_param, pws_cnt);
4908
4909 run_cracker (device_param, pws_cnt);
4910
4911 device_param->pws_cnt = 0;
4912
4913 /*
4914 still required?
4915 if (attack_kern == ATTACK_KERN_STRAIGHT)
4916 {
4917 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4918 }
4919 else if (attack_kern == ATTACK_KERN_COMBI)
4920 {
4921 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4922 }
4923 */
4924 }
4925 }
4926
4927 device_param->kernel_accel = 0;
4928 device_param->kernel_loops = 0;
4929
4930 myfree (buf);
4931
4932 return NULL;
4933 }
4934
4935 static void *thread_calc (void *p)
4936 {
4937 hc_device_param_t *device_param = (hc_device_param_t *) p;
4938
4939 if (device_param->skipped) return NULL;
4940
4941 const uint attack_mode = data.attack_mode;
4942 const uint attack_kern = data.attack_kern;
4943
4944 if (attack_mode == ATTACK_MODE_BF)
4945 {
4946 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4947 {
4948 const uint work = get_work (device_param, -1);
4949
4950 if (work == 0) break;
4951
4952 const u64 words_off = device_param->words_off;
4953 const u64 words_fin = words_off + work;
4954
4955 const uint pws_cnt = work;
4956
4957 device_param->pws_cnt = pws_cnt;
4958
4959 if (pws_cnt)
4960 {
4961 run_copy (device_param, pws_cnt);
4962
4963 run_cracker (device_param, pws_cnt);
4964
4965 device_param->pws_cnt = 0;
4966
4967 /*
4968 still required?
4969 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4970 */
4971 }
4972
4973 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4974
4975 if (data.devices_status == STATUS_CRACKED) break;
4976 if (data.devices_status == STATUS_ABORTED) break;
4977 if (data.devices_status == STATUS_QUIT) break;
4978 if (data.devices_status == STATUS_BYPASS) break;
4979
4980 if (data.benchmark == 1) break;
4981
4982 device_param->words_done = words_fin;
4983 }
4984 }
4985 else
4986 {
4987 const uint segment_size = data.segment_size;
4988
4989 char *dictfile = data.dictfile;
4990
4991 if (attack_mode == ATTACK_MODE_COMBI)
4992 {
4993 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4994 {
4995 dictfile = data.dictfile2;
4996 }
4997 }
4998
4999 FILE *fd = fopen (dictfile, "rb");
5000
5001 if (fd == NULL)
5002 {
5003 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
5004
5005 return NULL;
5006 }
5007
5008 if (attack_mode == ATTACK_MODE_COMBI)
5009 {
5010 const uint combs_mode = data.combs_mode;
5011
5012 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
5013 {
5014 const char *dictfilec = data.dictfile2;
5015
5016 FILE *combs_fp = fopen (dictfilec, "rb");
5017
5018 if (combs_fp == NULL)
5019 {
5020 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5021
5022 fclose (fd);
5023
5024 return NULL;
5025 }
5026
5027 device_param->combs_fp = combs_fp;
5028 }
5029 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5030 {
5031 const char *dictfilec = data.dictfile;
5032
5033 FILE *combs_fp = fopen (dictfilec, "rb");
5034
5035 if (combs_fp == NULL)
5036 {
5037 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5038
5039 fclose (fd);
5040
5041 return NULL;
5042 }
5043
5044 device_param->combs_fp = combs_fp;
5045 }
5046 }
5047
5048 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
5049
5050 wl_data->buf = (char *) mymalloc (segment_size);
5051 wl_data->avail = segment_size;
5052 wl_data->incr = segment_size;
5053 wl_data->cnt = 0;
5054 wl_data->pos = 0;
5055
5056 u64 words_cur = 0;
5057
5058 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5059 {
5060 u64 words_off = 0;
5061 u64 words_fin = 0;
5062
5063 u64 max = -1;
5064
5065 while (max)
5066 {
5067 const uint work = get_work (device_param, max);
5068
5069 if (work == 0) break;
5070
5071 max = 0;
5072
5073 words_off = device_param->words_off;
5074 words_fin = words_off + work;
5075
5076 char *line_buf;
5077 uint line_len;
5078
5079 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5080
5081 for ( ; words_cur < words_fin; words_cur++)
5082 {
5083 get_next_word (wl_data, fd, &line_buf, &line_len);
5084
5085 line_len = convert_from_hex (line_buf, line_len);
5086
5087 // post-process rule engine
5088
5089 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5090 {
5091 char rule_buf_out[BLOCK_SIZE] = { 0 };
5092
5093 int rule_len_out = -1;
5094
5095 if (line_len < BLOCK_SIZE)
5096 {
5097 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5098 }
5099
5100 if (rule_len_out < 0) continue;
5101
5102 line_buf = rule_buf_out;
5103 line_len = rule_len_out;
5104 }
5105
5106 if (attack_kern == ATTACK_KERN_STRAIGHT)
5107 {
5108 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5109 {
5110 max++;
5111
5112 hc_thread_mutex_lock (mux_counter);
5113
5114 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5115 {
5116 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5117 }
5118
5119 hc_thread_mutex_unlock (mux_counter);
5120
5121 continue;
5122 }
5123 }
5124 else if (attack_kern == ATTACK_KERN_COMBI)
5125 {
5126 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5127 // since we still need to combine the plains
5128
5129 if (line_len > data.pw_max)
5130 {
5131 max++;
5132
5133 hc_thread_mutex_lock (mux_counter);
5134
5135 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5136 {
5137 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5138 }
5139
5140 hc_thread_mutex_unlock (mux_counter);
5141
5142 continue;
5143 }
5144 }
5145
5146 pw_add (device_param, (u8 *) line_buf, line_len);
5147
5148 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5149
5150 if (data.devices_status == STATUS_CRACKED) break;
5151 if (data.devices_status == STATUS_ABORTED) break;
5152 if (data.devices_status == STATUS_QUIT) break;
5153 if (data.devices_status == STATUS_BYPASS) break;
5154 }
5155
5156 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5157
5158 if (data.devices_status == STATUS_CRACKED) break;
5159 if (data.devices_status == STATUS_ABORTED) break;
5160 if (data.devices_status == STATUS_QUIT) break;
5161 if (data.devices_status == STATUS_BYPASS) break;
5162 }
5163
5164 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5165
5166 if (data.devices_status == STATUS_CRACKED) break;
5167 if (data.devices_status == STATUS_ABORTED) break;
5168 if (data.devices_status == STATUS_QUIT) break;
5169 if (data.devices_status == STATUS_BYPASS) break;
5170
5171 //
5172 // flush
5173 //
5174
5175 const uint pws_cnt = device_param->pws_cnt;
5176
5177 if (pws_cnt)
5178 {
5179 run_copy (device_param, pws_cnt);
5180
5181 run_cracker (device_param, pws_cnt);
5182
5183 device_param->pws_cnt = 0;
5184
5185 /*
5186 still required?
5187 if (attack_kern == ATTACK_KERN_STRAIGHT)
5188 {
5189 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5190 }
5191 else if (attack_kern == ATTACK_KERN_COMBI)
5192 {
5193 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5194 }
5195 */
5196 }
5197
5198 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5199
5200 if (data.devices_status == STATUS_CRACKED) break;
5201 if (data.devices_status == STATUS_ABORTED) break;
5202 if (data.devices_status == STATUS_QUIT) break;
5203 if (data.devices_status == STATUS_BYPASS) break;
5204
5205 if (words_fin == 0) break;
5206
5207 device_param->words_done = words_fin;
5208 }
5209
5210 if (attack_mode == ATTACK_MODE_COMBI)
5211 {
5212 fclose (device_param->combs_fp);
5213 }
5214
5215 free (wl_data->buf);
5216 free (wl_data);
5217
5218 fclose (fd);
5219 }
5220
5221 device_param->kernel_accel = 0;
5222 device_param->kernel_loops = 0;
5223
5224 return NULL;
5225 }
5226
5227 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5228 {
5229 if (!device_param)
5230 {
5231 log_error ("ERROR: %s : Invalid argument", __func__);
5232
5233 exit (-1);
5234 }
5235
5236 salt_t *salt_buf = &data.salts_buf[salt_pos];
5237
5238 device_param->kernel_params_buf32[24] = salt_pos;
5239 device_param->kernel_params_buf32[27] = 1;
5240 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
5241 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
5242 device_param->kernel_params_buf32[30] = 0;
5243 device_param->kernel_params_buf32[31] = 1;
5244
5245 char *dictfile_old = data.dictfile;
5246
5247 const char *weak_hash_check = "weak-hash-check";
5248
5249 data.dictfile = (char *) weak_hash_check;
5250
5251 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5252
5253 data.kernel_rules_buf[0].cmds[0] = 0;
5254
5255 /**
5256 * run the kernel
5257 */
5258
5259 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5260 {
5261 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5262 }
5263 else
5264 {
5265 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5266
5267 uint loop_step = 16;
5268
5269 const uint iter = salt_buf->salt_iter;
5270
5271 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5272 {
5273 uint loop_left = iter - loop_pos;
5274
5275 loop_left = MIN (loop_left, loop_step);
5276
5277 device_param->kernel_params_buf32[25] = loop_pos;
5278 device_param->kernel_params_buf32[26] = loop_left;
5279
5280 run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5281 }
5282
5283 run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5284 }
5285
5286 /**
5287 * result
5288 */
5289
5290 check_cracked (device_param, salt_pos);
5291
5292 /**
5293 * cleanup
5294 */
5295
5296 device_param->kernel_params_buf32[24] = 0;
5297 device_param->kernel_params_buf32[25] = 0;
5298 device_param->kernel_params_buf32[26] = 0;
5299 device_param->kernel_params_buf32[27] = 0;
5300 device_param->kernel_params_buf32[28] = 0;
5301 device_param->kernel_params_buf32[29] = 0;
5302 device_param->kernel_params_buf32[30] = 0;
5303 device_param->kernel_params_buf32[31] = 0;
5304
5305 data.dictfile = dictfile_old;
5306
5307 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5308 }
5309
5310 // hlfmt hashcat
5311
5312 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5313 {
5314 if (data.username == 0)
5315 {
5316 *hashbuf_pos = line_buf;
5317 *hashbuf_len = line_len;
5318 }
5319 else
5320 {
5321 char *pos = line_buf;
5322 int len = line_len;
5323
5324 for (int i = 0; i < line_len; i++, pos++, len--)
5325 {
5326 if (line_buf[i] == data.separator)
5327 {
5328 pos++;
5329
5330 len--;
5331
5332 break;
5333 }
5334 }
5335
5336 *hashbuf_pos = pos;
5337 *hashbuf_len = len;
5338 }
5339 }
5340
5341 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5342 {
5343 char *pos = NULL;
5344 int len = 0;
5345
5346 int sep_cnt = 0;
5347
5348 for (int i = 0; i < line_len; i++)
5349 {
5350 if (line_buf[i] == data.separator)
5351 {
5352 sep_cnt++;
5353
5354 continue;
5355 }
5356
5357 if (sep_cnt == 0)
5358 {
5359 if (pos == NULL) pos = line_buf + i;
5360
5361 len++;
5362 }
5363 }
5364
5365 *userbuf_pos = pos;
5366 *userbuf_len = len;
5367 }
5368
5369 // hlfmt pwdump
5370
5371 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5372 {
5373 int sep_cnt = 0;
5374
5375 int sep2_len = 0;
5376 int sep3_len = 0;
5377
5378 for (int i = 0; i < line_len; i++)
5379 {
5380 if (line_buf[i] == ':')
5381 {
5382 sep_cnt++;
5383
5384 continue;
5385 }
5386
5387 if (sep_cnt == 2) sep2_len++;
5388 if (sep_cnt == 3) sep3_len++;
5389 }
5390
5391 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5392
5393 return 0;
5394 }
5395
5396 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5397 {
5398 char *pos = NULL;
5399 int len = 0;
5400
5401 int sep_cnt = 0;
5402
5403 for (int i = 0; i < line_len; i++)
5404 {
5405 if (line_buf[i] == ':')
5406 {
5407 sep_cnt++;
5408
5409 continue;
5410 }
5411
5412 if (data.hash_mode == 1000)
5413 {
5414 if (sep_cnt == 3)
5415 {
5416 if (pos == NULL) pos = line_buf + i;
5417
5418 len++;
5419 }
5420 }
5421 else if (data.hash_mode == 3000)
5422 {
5423 if (sep_cnt == 2)
5424 {
5425 if (pos == NULL) pos = line_buf + i;
5426
5427 len++;
5428 }
5429 }
5430 }
5431
5432 *hashbuf_pos = pos;
5433 *hashbuf_len = len;
5434 }
5435
5436 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5437 {
5438 char *pos = NULL;
5439 int len = 0;
5440
5441 int sep_cnt = 0;
5442
5443 for (int i = 0; i < line_len; i++)
5444 {
5445 if (line_buf[i] == ':')
5446 {
5447 sep_cnt++;
5448
5449 continue;
5450 }
5451
5452 if (sep_cnt == 0)
5453 {
5454 if (pos == NULL) pos = line_buf + i;
5455
5456 len++;
5457 }
5458 }
5459
5460 *userbuf_pos = pos;
5461 *userbuf_len = len;
5462 }
5463
5464 // hlfmt passwd
5465
5466 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5467 {
5468 int sep_cnt = 0;
5469
5470 char sep5_first = 0;
5471 char sep6_first = 0;
5472
5473 for (int i = 0; i < line_len; i++)
5474 {
5475 if (line_buf[i] == ':')
5476 {
5477 sep_cnt++;
5478
5479 continue;
5480 }
5481
5482 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5483 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5484 }
5485
5486 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5487
5488 return 0;
5489 }
5490
5491 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5492 {
5493 char *pos = NULL;
5494 int len = 0;
5495
5496 int sep_cnt = 0;
5497
5498 for (int i = 0; i < line_len; i++)
5499 {
5500 if (line_buf[i] == ':')
5501 {
5502 sep_cnt++;
5503
5504 continue;
5505 }
5506
5507 if (sep_cnt == 1)
5508 {
5509 if (pos == NULL) pos = line_buf + i;
5510
5511 len++;
5512 }
5513 }
5514
5515 *hashbuf_pos = pos;
5516 *hashbuf_len = len;
5517 }
5518
5519 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5520 {
5521 char *pos = NULL;
5522 int len = 0;
5523
5524 int sep_cnt = 0;
5525
5526 for (int i = 0; i < line_len; i++)
5527 {
5528 if (line_buf[i] == ':')
5529 {
5530 sep_cnt++;
5531
5532 continue;
5533 }
5534
5535 if (sep_cnt == 0)
5536 {
5537 if (pos == NULL) pos = line_buf + i;
5538
5539 len++;
5540 }
5541 }
5542
5543 *userbuf_pos = pos;
5544 *userbuf_len = len;
5545 }
5546
5547 // hlfmt shadow
5548
5549 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5550 {
5551 int sep_cnt = 0;
5552
5553 for (int i = 0; i < line_len; i++)
5554 {
5555 if (line_buf[i] == ':') sep_cnt++;
5556 }
5557
5558 if (sep_cnt == 8) return 1;
5559
5560 return 0;
5561 }
5562
5563 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5564 {
5565 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5566 }
5567
5568 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5569 {
5570 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5571 }
5572
5573 // hlfmt main
5574
5575 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5576 {
5577 switch (hashfile_format)
5578 {
5579 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5580 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5581 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5582 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5583 }
5584 }
5585
5586 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5587 {
5588 switch (hashfile_format)
5589 {
5590 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5591 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5592 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5593 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5594 }
5595 }
5596
5597 char *strhlfmt (const uint hashfile_format)
5598 {
5599 switch (hashfile_format)
5600 {
5601 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5602 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5603 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5604 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5605 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5606 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5607 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5608 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5609 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5610 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5611 }
5612
5613 return ((char *) "Unknown");
5614 }
5615
5616 static uint hlfmt_detect (FILE *fp, uint max_check)
5617 {
5618 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5619
5620 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5621 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5622
5623 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5624
5625 uint num_check = 0;
5626
5627 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5628
5629 while (!feof (fp))
5630 {
5631 int line_len = fgetl (fp, line_buf);
5632
5633 if (line_len == 0) continue;
5634
5635 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5636 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5637 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5638
5639 if (num_check == max_check) break;
5640
5641 num_check++;
5642 }
5643
5644 myfree (line_buf);
5645
5646 uint hashlist_format = HLFMT_HASHCAT;
5647
5648 for (int i = 1; i < HLFMTS_CNT; i++)
5649 {
5650 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5651
5652 hashlist_format = i;
5653 }
5654
5655 free (formats_cnt);
5656
5657 return hashlist_format;
5658 }
5659
5660 /**
5661 * some further helper function
5662 */
5663
5664 // wrapper around mymalloc for ADL
5665
5666 #if defined(HAVE_HWMON)
5667 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5668 {
5669 return mymalloc (iSize);
5670 }
5671 #endif
5672
5673 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)
5674 {
5675 u64 collisions = 0;
5676
5677 const uint dgst_pos0 = data.dgst_pos0;
5678 const uint dgst_pos1 = data.dgst_pos1;
5679 const uint dgst_pos2 = data.dgst_pos2;
5680 const uint dgst_pos3 = data.dgst_pos3;
5681
5682 memset (bitmap_a, 0, bitmap_size);
5683 memset (bitmap_b, 0, bitmap_size);
5684 memset (bitmap_c, 0, bitmap_size);
5685 memset (bitmap_d, 0, bitmap_size);
5686
5687 for (uint i = 0; i < digests_cnt; i++)
5688 {
5689 uint *digest_ptr = (uint *) digests_buf_ptr;
5690
5691 digests_buf_ptr += dgst_size;
5692
5693 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5694 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5695 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5696 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5697
5698 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5699 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5700 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5701 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5702
5703 if (bitmap_a[idx0] & val0) collisions++;
5704 if (bitmap_b[idx1] & val1) collisions++;
5705 if (bitmap_c[idx2] & val2) collisions++;
5706 if (bitmap_d[idx3] & val3) collisions++;
5707
5708 bitmap_a[idx0] |= val0;
5709 bitmap_b[idx1] |= val1;
5710 bitmap_c[idx2] |= val2;
5711 bitmap_d[idx3] |= val3;
5712
5713 if (collisions >= collisions_max) return 0x7fffffff;
5714 }
5715
5716 return collisions;
5717 }
5718
5719 /**
5720 * main
5721 */
5722
5723 #ifdef WIN
5724 void SetConsoleWindowSize (const int x)
5725 {
5726 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5727
5728 if (h == INVALID_HANDLE_VALUE) return;
5729
5730 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5731
5732 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5733
5734 SMALL_RECT *sr = &bufferInfo.srWindow;
5735
5736 sr->Right = MAX (sr->Right, x - 1);
5737
5738 COORD co;
5739
5740 co.X = sr->Right + 1;
5741 co.Y = 9999;
5742
5743 if (!SetConsoleScreenBufferSize (h, co)) return;
5744
5745 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5746 }
5747 #endif
5748
5749 int main (int argc, char **argv)
5750 {
5751 #ifdef WIN
5752 SetConsoleWindowSize (132);
5753 #endif
5754
5755 /**
5756 * To help users a bit
5757 */
5758
5759 char *compute = getenv ("COMPUTE");
5760
5761 if (compute)
5762 {
5763 static char display[100];
5764
5765 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5766
5767 putenv (display);
5768 }
5769 else
5770 {
5771 if (getenv ("DISPLAY") == NULL)
5772 putenv ((char *) "DISPLAY=:0");
5773 }
5774
5775 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5776 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5777
5778 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5779 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5780
5781 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5782 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5783
5784 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5785 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5786
5787 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5788 putenv ((char *) "POCL_KERNEL_CACHE=0");
5789
5790 umask (077);
5791
5792 /**
5793 * Real init
5794 */
5795
5796 memset (&data, 0, sizeof (hc_global_data_t));
5797
5798 time_t proc_start;
5799
5800 time (&proc_start);
5801
5802 data.proc_start = proc_start;
5803
5804 int myargc = argc;
5805 char **myargv = argv;
5806
5807 hc_thread_mutex_init (mux_dispatcher);
5808 hc_thread_mutex_init (mux_counter);
5809 hc_thread_mutex_init (mux_display);
5810 hc_thread_mutex_init (mux_adl);
5811
5812 /**
5813 * commandline parameters
5814 */
5815
5816 uint usage = USAGE;
5817 uint version = VERSION;
5818 uint quiet = QUIET;
5819 uint benchmark = BENCHMARK;
5820 uint stdout_flag = STDOUT_FLAG;
5821 uint show = SHOW;
5822 uint left = LEFT;
5823 uint username = USERNAME;
5824 uint remove = REMOVE;
5825 uint remove_timer = REMOVE_TIMER;
5826 u64 skip = SKIP;
5827 u64 limit = LIMIT;
5828 uint keyspace = KEYSPACE;
5829 uint potfile_disable = POTFILE_DISABLE;
5830 char *potfile_path = NULL;
5831 uint debug_mode = DEBUG_MODE;
5832 char *debug_file = NULL;
5833 char *induction_dir = NULL;
5834 char *outfile_check_dir = NULL;
5835 uint force = FORCE;
5836 uint runtime = RUNTIME;
5837 uint hash_mode = HASH_MODE;
5838 uint attack_mode = ATTACK_MODE;
5839 uint markov_disable = MARKOV_DISABLE;
5840 uint markov_classic = MARKOV_CLASSIC;
5841 uint markov_threshold = MARKOV_THRESHOLD;
5842 char *markov_hcstat = NULL;
5843 char *outfile = NULL;
5844 uint outfile_format = OUTFILE_FORMAT;
5845 uint outfile_autohex = OUTFILE_AUTOHEX;
5846 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5847 uint restore = RESTORE;
5848 uint restore_timer = RESTORE_TIMER;
5849 uint restore_disable = RESTORE_DISABLE;
5850 uint status = STATUS;
5851 uint status_timer = STATUS_TIMER;
5852 uint machine_readable = MACHINE_READABLE;
5853 uint loopback = LOOPBACK;
5854 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5855 char *session = NULL;
5856 uint hex_charset = HEX_CHARSET;
5857 uint hex_salt = HEX_SALT;
5858 uint hex_wordlist = HEX_WORDLIST;
5859 uint rp_gen = RP_GEN;
5860 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5861 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5862 uint rp_gen_seed = RP_GEN_SEED;
5863 char *rule_buf_l = (char *) RULE_BUF_L;
5864 char *rule_buf_r = (char *) RULE_BUF_R;
5865 uint increment = INCREMENT;
5866 uint increment_min = INCREMENT_MIN;
5867 uint increment_max = INCREMENT_MAX;
5868 char *cpu_affinity = NULL;
5869 OCL_PTR *ocl = NULL;
5870 char *opencl_devices = NULL;
5871 char *opencl_platforms = NULL;
5872 char *opencl_device_types = NULL;
5873 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5874 char *truecrypt_keyfiles = NULL;
5875 char *veracrypt_keyfiles = NULL;
5876 uint veracrypt_pim = 0;
5877 uint workload_profile = WORKLOAD_PROFILE;
5878 uint kernel_accel = KERNEL_ACCEL;
5879 uint kernel_loops = KERNEL_LOOPS;
5880 uint nvidia_spin_damp = NVIDIA_SPIN_DAMP;
5881 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5882 #ifdef HAVE_HWMON
5883 uint gpu_temp_abort = GPU_TEMP_ABORT;
5884 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5885 uint powertune_enable = POWERTUNE_ENABLE;
5886 #endif
5887 uint logfile_disable = LOGFILE_DISABLE;
5888 uint segment_size = SEGMENT_SIZE;
5889 uint scrypt_tmto = SCRYPT_TMTO;
5890 char separator = SEPARATOR;
5891 uint bitmap_min = BITMAP_MIN;
5892 uint bitmap_max = BITMAP_MAX;
5893 char *custom_charset_1 = NULL;
5894 char *custom_charset_2 = NULL;
5895 char *custom_charset_3 = NULL;
5896 char *custom_charset_4 = NULL;
5897
5898 #define IDX_HELP 'h'
5899 #define IDX_VERSION 'V'
5900 #define IDX_VERSION_LOWER 'v'
5901 #define IDX_QUIET 0xff02
5902 #define IDX_SHOW 0xff03
5903 #define IDX_LEFT 0xff04
5904 #define IDX_REMOVE 0xff05
5905 #define IDX_REMOVE_TIMER 0xff37
5906 #define IDX_SKIP 's'
5907 #define IDX_LIMIT 'l'
5908 #define IDX_KEYSPACE 0xff35
5909 #define IDX_POTFILE_DISABLE 0xff06
5910 #define IDX_POTFILE_PATH 0xffe0
5911 #define IDX_DEBUG_MODE 0xff43
5912 #define IDX_DEBUG_FILE 0xff44
5913 #define IDX_INDUCTION_DIR 0xff46
5914 #define IDX_OUTFILE_CHECK_DIR 0xff47
5915 #define IDX_USERNAME 0xff07
5916 #define IDX_FORCE 0xff08
5917 #define IDX_RUNTIME 0xff09
5918 #define IDX_BENCHMARK 'b'
5919 #define IDX_STDOUT_FLAG 0xff77
5920 #define IDX_HASH_MODE 'm'
5921 #define IDX_ATTACK_MODE 'a'
5922 #define IDX_RP_FILE 'r'
5923 #define IDX_RP_GEN 'g'
5924 #define IDX_RP_GEN_FUNC_MIN 0xff10
5925 #define IDX_RP_GEN_FUNC_MAX 0xff11
5926 #define IDX_RP_GEN_SEED 0xff34
5927 #define IDX_RULE_BUF_L 'j'
5928 #define IDX_RULE_BUF_R 'k'
5929 #define IDX_INCREMENT 'i'
5930 #define IDX_INCREMENT_MIN 0xff12
5931 #define IDX_INCREMENT_MAX 0xff13
5932 #define IDX_OUTFILE 'o'
5933 #define IDX_OUTFILE_FORMAT 0xff14
5934 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5935 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5936 #define IDX_RESTORE 0xff15
5937 #define IDX_RESTORE_DISABLE 0xff27
5938 #define IDX_STATUS 0xff17
5939 #define IDX_STATUS_TIMER 0xff18
5940 #define IDX_MACHINE_READABLE 0xff50
5941 #define IDX_LOOPBACK 0xff38
5942 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5943 #define IDX_SESSION 0xff19
5944 #define IDX_HEX_CHARSET 0xff20
5945 #define IDX_HEX_SALT 0xff21
5946 #define IDX_HEX_WORDLIST 0xff40
5947 #define IDX_MARKOV_DISABLE 0xff22
5948 #define IDX_MARKOV_CLASSIC 0xff23
5949 #define IDX_MARKOV_THRESHOLD 't'
5950 #define IDX_MARKOV_HCSTAT 0xff24
5951 #define IDX_CPU_AFFINITY 0xff25
5952 #define IDX_OPENCL_DEVICES 'd'
5953 #define IDX_OPENCL_PLATFORMS 0xff72
5954 #define IDX_OPENCL_DEVICE_TYPES 'D'
5955 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5956 #define IDX_WORKLOAD_PROFILE 'w'
5957 #define IDX_KERNEL_ACCEL 'n'
5958 #define IDX_KERNEL_LOOPS 'u'
5959 #define IDX_NVIDIA_SPIN_DAMP 0xff79
5960 #define IDX_GPU_TEMP_DISABLE 0xff29
5961 #define IDX_GPU_TEMP_ABORT 0xff30
5962 #define IDX_GPU_TEMP_RETAIN 0xff31
5963 #define IDX_POWERTUNE_ENABLE 0xff41
5964 #define IDX_LOGFILE_DISABLE 0xff51
5965 #define IDX_TRUECRYPT_KEYFILES 0xff52
5966 #define IDX_VERACRYPT_KEYFILES 0xff53
5967 #define IDX_VERACRYPT_PIM 0xff54
5968 #define IDX_SCRYPT_TMTO 0xff61
5969 #define IDX_SEGMENT_SIZE 'c'
5970 #define IDX_SEPARATOR 'p'
5971 #define IDX_BITMAP_MIN 0xff70
5972 #define IDX_BITMAP_MAX 0xff71
5973 #define IDX_CUSTOM_CHARSET_1 '1'
5974 #define IDX_CUSTOM_CHARSET_2 '2'
5975 #define IDX_CUSTOM_CHARSET_3 '3'
5976 #define IDX_CUSTOM_CHARSET_4 '4'
5977
5978 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:D:n:u:c:p:s:l:1:2:3:4:ibw:";
5979
5980 struct option long_options[] =
5981 {
5982 {"help", no_argument, 0, IDX_HELP},
5983 {"version", no_argument, 0, IDX_VERSION},
5984 {"quiet", no_argument, 0, IDX_QUIET},
5985 {"show", no_argument, 0, IDX_SHOW},
5986 {"left", no_argument, 0, IDX_LEFT},
5987 {"username", no_argument, 0, IDX_USERNAME},
5988 {"remove", no_argument, 0, IDX_REMOVE},
5989 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5990 {"skip", required_argument, 0, IDX_SKIP},
5991 {"limit", required_argument, 0, IDX_LIMIT},
5992 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5993 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5994 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5995 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5996 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5997 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5998 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5999 {"force", no_argument, 0, IDX_FORCE},
6000 {"benchmark", no_argument, 0, IDX_BENCHMARK},
6001 {"stdout", no_argument, 0, IDX_STDOUT_FLAG},
6002 {"restore", no_argument, 0, IDX_RESTORE},
6003 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
6004 {"status", no_argument, 0, IDX_STATUS},
6005 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
6006 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
6007 {"loopback", no_argument, 0, IDX_LOOPBACK},
6008 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
6009 {"session", required_argument, 0, IDX_SESSION},
6010 {"runtime", required_argument, 0, IDX_RUNTIME},
6011 {"generate-rules", required_argument, 0, IDX_RP_GEN},
6012 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
6013 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
6014 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
6015 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
6016 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
6017 {"hash-type", required_argument, 0, IDX_HASH_MODE},
6018 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
6019 {"rules-file", required_argument, 0, IDX_RP_FILE},
6020 {"outfile", required_argument, 0, IDX_OUTFILE},
6021 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
6022 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
6023 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
6024 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
6025 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
6026 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
6027 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
6028 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
6029 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
6030 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
6031 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
6032 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
6033 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
6034 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
6035 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
6036 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
6037 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
6038 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
6039 {"nvidia-spin-damp", required_argument, 0, IDX_NVIDIA_SPIN_DAMP},
6040 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
6041 #ifdef HAVE_HWMON
6042 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
6043 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
6044 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
6045 #endif // HAVE_HWMON
6046 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
6047 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
6048 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
6049 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
6050 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
6051 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
6052 {"seperator", required_argument, 0, IDX_SEPARATOR},
6053 {"separator", required_argument, 0, IDX_SEPARATOR},
6054 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
6055 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
6056 {"increment", no_argument, 0, IDX_INCREMENT},
6057 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
6058 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
6059 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
6060 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
6061 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
6062 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
6063 {0, 0, 0, 0}
6064 };
6065
6066 uint rp_files_cnt = 0;
6067
6068 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6069
6070 int option_index = 0;
6071 int c = -1;
6072
6073 optind = 1;
6074 optopt = 0;
6075
6076 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6077 {
6078 switch (c)
6079 {
6080 case IDX_HELP: usage = 1; break;
6081 case IDX_VERSION:
6082 case IDX_VERSION_LOWER: version = 1; break;
6083 case IDX_RESTORE: restore = 1; break;
6084 case IDX_SESSION: session = optarg; break;
6085 case IDX_SHOW: show = 1; break;
6086 case IDX_LEFT: left = 1; break;
6087 case '?': return (-1);
6088 }
6089 }
6090
6091 if (optopt != 0)
6092 {
6093 log_error ("ERROR: Invalid argument specified");
6094
6095 return (-1);
6096 }
6097
6098 /**
6099 * exit functions
6100 */
6101
6102 if (version)
6103 {
6104 log_info ("%s", VERSION_TAG);
6105
6106 return (0);
6107 }
6108
6109 if (usage)
6110 {
6111 usage_big_print (PROGNAME);
6112
6113 return (0);
6114 }
6115
6116 /**
6117 * session needs to be set, always!
6118 */
6119
6120 if (session == NULL) session = (char *) PROGNAME;
6121
6122 /**
6123 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6124 */
6125
6126 char *exec_path = get_exec_path ();
6127
6128 #ifdef LINUX
6129
6130 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6131 char *resolved_exec_path = realpath (exec_path, NULL);
6132
6133 char *install_dir = get_install_dir (resolved_exec_path);
6134 char *profile_dir = NULL;
6135 char *session_dir = NULL;
6136 char *shared_dir = NULL;
6137
6138 if (strcmp (install_dir, resolved_install_folder) == 0)
6139 {
6140 struct passwd *pw = getpwuid (getuid ());
6141
6142 const char *homedir = pw->pw_dir;
6143
6144 profile_dir = get_profile_dir (homedir);
6145 session_dir = get_session_dir (profile_dir);
6146 shared_dir = strdup (SHARED_FOLDER);
6147
6148 mkdir (profile_dir, 0700);
6149 mkdir (session_dir, 0700);
6150 }
6151 else
6152 {
6153 profile_dir = install_dir;
6154 session_dir = install_dir;
6155 shared_dir = install_dir;
6156 }
6157
6158 myfree (resolved_install_folder);
6159 myfree (resolved_exec_path);
6160
6161 #else
6162
6163 char *install_dir = get_install_dir (exec_path);
6164 char *profile_dir = install_dir;
6165 char *session_dir = install_dir;
6166 char *shared_dir = install_dir;
6167
6168 #endif
6169
6170 data.install_dir = install_dir;
6171 data.profile_dir = profile_dir;
6172 data.session_dir = session_dir;
6173 data.shared_dir = shared_dir;
6174
6175 myfree (exec_path);
6176
6177 /**
6178 * kernel cache, we need to make sure folder exist
6179 */
6180
6181 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6182
6183 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6184
6185 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6186
6187 mkdir (kernels_folder, 0700);
6188
6189 myfree (kernels_folder);
6190
6191 /**
6192 * session
6193 */
6194
6195 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6196
6197 data.session = session;
6198
6199 char *eff_restore_file = (char *) mymalloc (session_size);
6200 char *new_restore_file = (char *) mymalloc (session_size);
6201
6202 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
6203 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6204
6205 data.eff_restore_file = eff_restore_file;
6206 data.new_restore_file = new_restore_file;
6207
6208 if (((show == 1) || (left == 1)) && (restore == 1))
6209 {
6210 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6211 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6212
6213 return (-1);
6214 }
6215
6216 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6217 if ((show == 1) || (left == 1))
6218 {
6219 restore_disable = 1;
6220
6221 restore = 0;
6222 }
6223
6224 data.restore_disable = restore_disable;
6225
6226 restore_data_t *rd = init_restore (argc, argv);
6227
6228 data.rd = rd;
6229
6230 /**
6231 * restore file
6232 */
6233
6234 if (restore == 1)
6235 {
6236 read_restore (eff_restore_file, rd);
6237
6238 if (rd->version_bin < RESTORE_MIN)
6239 {
6240 log_error ("ERROR: Incompatible restore-file version");
6241
6242 return (-1);
6243 }
6244
6245 myargc = rd->argc;
6246 myargv = rd->argv;
6247
6248 #ifdef _POSIX
6249 rd->pid = getpid ();
6250 #elif _WIN
6251 rd->pid = GetCurrentProcessId ();
6252 #endif
6253 }
6254
6255 uint hash_mode_chgd = 0;
6256 uint runtime_chgd = 0;
6257 uint kernel_loops_chgd = 0;
6258 uint kernel_accel_chgd = 0;
6259 uint nvidia_spin_damp_chgd = 0;
6260 uint attack_mode_chgd = 0;
6261 uint outfile_format_chgd = 0;
6262 uint rp_gen_seed_chgd = 0;
6263 uint remove_timer_chgd = 0;
6264 uint increment_min_chgd = 0;
6265 uint increment_max_chgd = 0;
6266 uint workload_profile_chgd = 0;
6267 uint opencl_vector_width_chgd = 0;
6268
6269 optind = 1;
6270 optopt = 0;
6271 option_index = 0;
6272
6273 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6274 {
6275 switch (c)
6276 {
6277 //case IDX_HELP: usage = 1; break;
6278 //case IDX_VERSION: version = 1; break;
6279 //case IDX_RESTORE: restore = 1; break;
6280 case IDX_QUIET: quiet = 1; break;
6281 //case IDX_SHOW: show = 1; break;
6282 case IDX_SHOW: break;
6283 //case IDX_LEFT: left = 1; break;
6284 case IDX_LEFT: break;
6285 case IDX_USERNAME: username = 1; break;
6286 case IDX_REMOVE: remove = 1; break;
6287 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6288 remove_timer_chgd = 1; break;
6289 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6290 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6291 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6292 case IDX_DEBUG_FILE: debug_file = optarg; break;
6293 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6294 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6295 case IDX_FORCE: force = 1; break;
6296 case IDX_SKIP: skip = atoll (optarg); break;
6297 case IDX_LIMIT: limit = atoll (optarg); break;
6298 case IDX_KEYSPACE: keyspace = 1; break;
6299 case IDX_BENCHMARK: benchmark = 1; break;
6300 case IDX_STDOUT_FLAG: stdout_flag = 1; break;
6301 case IDX_RESTORE: break;
6302 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6303 case IDX_STATUS: status = 1; break;
6304 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6305 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6306 case IDX_LOOPBACK: loopback = 1; break;
6307 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6308 //case IDX_SESSION: session = optarg; break;
6309 case IDX_SESSION: break;
6310 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6311 hash_mode_chgd = 1; break;
6312 case IDX_RUNTIME: runtime = atoi (optarg);
6313 runtime_chgd = 1; break;
6314 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6315 attack_mode_chgd = 1; break;
6316 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6317 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6318 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6319 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6320 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6321 rp_gen_seed_chgd = 1; break;
6322 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6323 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6324 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6325 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6326 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6327 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6328 case IDX_OUTFILE: outfile = optarg; break;
6329 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6330 outfile_format_chgd = 1; break;
6331 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6332 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6333 case IDX_HEX_CHARSET: hex_charset = 1; break;
6334 case IDX_HEX_SALT: hex_salt = 1; break;
6335 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6336 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6337 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6338 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6339 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6340 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6341 opencl_vector_width_chgd = 1; break;
6342 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6343 workload_profile_chgd = 1; break;
6344 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6345 kernel_accel_chgd = 1; break;
6346 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6347 kernel_loops_chgd = 1; break;
6348 case IDX_NVIDIA_SPIN_DAMP: nvidia_spin_damp = atoi (optarg);
6349 nvidia_spin_damp_chgd = 1; break;
6350 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6351 #ifdef HAVE_HWMON
6352 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6353 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6354 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6355 #endif // HAVE_HWMON
6356 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6357 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6358 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6359 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6360 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6361 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6362 case IDX_SEPARATOR: separator = optarg[0]; break;
6363 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6364 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6365 case IDX_INCREMENT: increment = 1; break;
6366 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6367 increment_min_chgd = 1; break;
6368 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6369 increment_max_chgd = 1; break;
6370 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6371 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6372 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6373 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6374
6375 default:
6376 log_error ("ERROR: Invalid argument specified");
6377 return (-1);
6378 }
6379 }
6380
6381 if (optopt != 0)
6382 {
6383 log_error ("ERROR: Invalid argument specified");
6384
6385 return (-1);
6386 }
6387
6388 /**
6389 * Inform user things getting started,
6390 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6391 * - we do not need to check algorithm_pos
6392 */
6393
6394 if (quiet == 0)
6395 {
6396 if (benchmark == 1)
6397 {
6398 if (machine_readable == 0)
6399 {
6400 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6401 log_info ("");
6402 }
6403 else
6404 {
6405 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6406 }
6407 }
6408 else if (restore == 1)
6409 {
6410 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6411 log_info ("");
6412 }
6413 else if (stdout_flag == 1)
6414 {
6415 // do nothing
6416 }
6417 else
6418 {
6419 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6420 log_info ("");
6421 }
6422 }
6423
6424 /**
6425 * sanity check
6426 */
6427
6428 if (attack_mode > 7)
6429 {
6430 log_error ("ERROR: Invalid attack-mode specified");
6431
6432 return (-1);
6433 }
6434
6435 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6436 {
6437 log_error ("ERROR: Invalid runtime specified");
6438
6439 return (-1);
6440 }
6441
6442 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6443 {
6444 log_error ("ERROR: Invalid hash-type specified");
6445
6446 return (-1);
6447 }
6448
6449 // renamed hash modes
6450
6451 if (hash_mode_chgd)
6452 {
6453 int n = -1;
6454
6455 switch (hash_mode)
6456 {
6457 case 123: n = 124;
6458 break;
6459 }
6460
6461 if (n >= 0)
6462 {
6463 log_error ("Old -m specified, use -m %d instead", n);
6464
6465 return (-1);
6466 }
6467 }
6468
6469 if (username == 1)
6470 {
6471 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6472 {
6473 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6474
6475 return (-1);
6476 }
6477 }
6478
6479 if (outfile_format > 16)
6480 {
6481 log_error ("ERROR: Invalid outfile-format specified");
6482
6483 return (-1);
6484 }
6485
6486 if (left == 1)
6487 {
6488 if (outfile_format_chgd == 1)
6489 {
6490 if (outfile_format > 1)
6491 {
6492 log_error ("ERROR: Mixing outfile-format > 1 with left parameter is not allowed");
6493
6494 return (-1);
6495 }
6496 }
6497 else
6498 {
6499 outfile_format = OUTFILE_FMT_HASH;
6500 }
6501 }
6502
6503 if (show == 1)
6504 {
6505 if (outfile_format_chgd == 1)
6506 {
6507 if ((outfile_format > 7) && (outfile_format < 16))
6508 {
6509 log_error ("ERROR: Mixing outfile-format > 7 with show parameter is not allowed");
6510
6511 return (-1);
6512 }
6513 }
6514 }
6515
6516 if (increment_min < INCREMENT_MIN)
6517 {
6518 log_error ("ERROR: Invalid increment-min specified");
6519
6520 return (-1);
6521 }
6522
6523 if (increment_max > INCREMENT_MAX)
6524 {
6525 log_error ("ERROR: Invalid increment-max specified");
6526
6527 return (-1);
6528 }
6529
6530 if (increment_min > increment_max)
6531 {
6532 log_error ("ERROR: Invalid increment-min specified");
6533
6534 return (-1);
6535 }
6536
6537 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6538 {
6539 log_error ("ERROR: Increment is not allowed in attack-mode 0");
6540
6541 return (-1);
6542 }
6543
6544 if ((increment == 0) && (increment_min_chgd == 1))
6545 {
6546 log_error ("ERROR: Increment-min is only supported combined with increment switch");
6547
6548 return (-1);
6549 }
6550
6551 if ((increment == 0) && (increment_max_chgd == 1))
6552 {
6553 log_error ("ERROR: Increment-max is only supported combined with increment switch");
6554
6555 return (-1);
6556 }
6557
6558 if (rp_files_cnt && rp_gen)
6559 {
6560 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6561
6562 return (-1);
6563 }
6564
6565 if (rp_files_cnt || rp_gen)
6566 {
6567 if (attack_mode != ATTACK_MODE_STRAIGHT)
6568 {
6569 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6570
6571 return (-1);
6572 }
6573 }
6574
6575 if (rp_gen_func_min > rp_gen_func_max)
6576 {
6577 log_error ("ERROR: Invalid rp-gen-func-min specified");
6578
6579 return (-1);
6580 }
6581
6582 if (kernel_accel_chgd == 1)
6583 {
6584 if (force == 0)
6585 {
6586 log_info ("The manual use of the -n option (or --kernel-accel) is outdated");
6587 log_info ("Please consider using the -w option instead");
6588 log_info ("You can use --force to override this but do not post error reports if you do so");
6589 log_info ("");
6590
6591 return (-1);
6592 }
6593
6594 if (kernel_accel < 1)
6595 {
6596 log_error ("ERROR: Invalid kernel-accel specified");
6597
6598 return (-1);
6599 }
6600
6601 if (kernel_accel > 1024)
6602 {
6603 log_error ("ERROR: Invalid kernel-accel specified");
6604
6605 return (-1);
6606 }
6607 }
6608
6609 if (kernel_loops_chgd == 1)
6610 {
6611 if (force == 0)
6612 {
6613 log_info ("The manual use of the -u option (or --kernel-loops) is outdated");
6614 log_info ("Please consider using the -w option instead");
6615 log_info ("You can use --force to override this but do not post error reports if you do so");
6616 log_info ("");
6617
6618 return (-1);
6619 }
6620
6621 if (kernel_loops < 1)
6622 {
6623 log_error ("ERROR: Invalid kernel-loops specified");
6624
6625 return (-1);
6626 }
6627
6628 if (kernel_loops > 1024)
6629 {
6630 log_error ("ERROR: Invalid kernel-loops specified");
6631
6632 return (-1);
6633 }
6634 }
6635
6636 if ((workload_profile < 1) || (workload_profile > 4))
6637 {
6638 log_error ("ERROR: workload-profile %i not available", workload_profile);
6639
6640 return (-1);
6641 }
6642
6643 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6644 {
6645 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6646
6647 return (-1);
6648 }
6649
6650 if (show == 1 || left == 1)
6651 {
6652 attack_mode = ATTACK_MODE_NONE;
6653
6654 if (remove == 1)
6655 {
6656 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6657
6658 return (-1);
6659 }
6660
6661 if (potfile_disable == 1)
6662 {
6663 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6664
6665 return (-1);
6666 }
6667 }
6668
6669 uint attack_kern = ATTACK_KERN_NONE;
6670
6671 switch (attack_mode)
6672 {
6673 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6674 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6675 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6676 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6677 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6678 }
6679
6680 if (benchmark == 1)
6681 {
6682 if (myargv[optind] != 0)
6683 {
6684 log_error ("ERROR: Invalid argument for benchmark mode specified");
6685
6686 return (-1);
6687 }
6688
6689 if (attack_mode_chgd == 1)
6690 {
6691 if (attack_mode != ATTACK_MODE_BF)
6692 {
6693 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6694
6695 return (-1);
6696 }
6697 }
6698 }
6699 else
6700 {
6701 if (stdout_flag == 1) // no hash here
6702 {
6703 optind--;
6704 }
6705
6706 if (keyspace == 1)
6707 {
6708 int num_additional_params = 1;
6709
6710 if (attack_kern == ATTACK_KERN_COMBI)
6711 {
6712 num_additional_params = 2;
6713 }
6714
6715 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6716
6717 if (keyspace_wordlist_specified == 0) optind--;
6718 }
6719
6720 if (attack_kern == ATTACK_KERN_NONE)
6721 {
6722 if ((optind + 1) != myargc)
6723 {
6724 usage_mini_print (myargv[0]);
6725
6726 return (-1);
6727 }
6728 }
6729 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6730 {
6731 if ((optind + 1) > myargc)
6732 {
6733 usage_mini_print (myargv[0]);
6734
6735 return (-1);
6736 }
6737 }
6738 else if (attack_kern == ATTACK_KERN_COMBI)
6739 {
6740 if ((optind + 3) != myargc)
6741 {
6742 usage_mini_print (myargv[0]);
6743
6744 return (-1);
6745 }
6746 }
6747 else if (attack_kern == ATTACK_KERN_BF)
6748 {
6749 if ((optind + 1) > myargc)
6750 {
6751 usage_mini_print (myargv[0]);
6752
6753 return (-1);
6754 }
6755 }
6756 else
6757 {
6758 usage_mini_print (myargv[0]);
6759
6760 return (-1);
6761 }
6762 }
6763
6764 if (skip != 0 && limit != 0)
6765 {
6766 limit += skip;
6767 }
6768
6769 if (keyspace == 1)
6770 {
6771 if (show == 1)
6772 {
6773 log_error ("ERROR: Combining show parameter with keyspace parameter is not allowed");
6774
6775 return (-1);
6776 }
6777 else if (left == 1)
6778 {
6779 log_error ("ERROR: Combining left parameter with keyspace parameter is not allowed");
6780
6781 return (-1);
6782 }
6783
6784 potfile_disable = 1;
6785
6786 restore_disable = 1;
6787
6788 restore = 0;
6789
6790 weak_hash_threshold = 0;
6791
6792 quiet = 1;
6793 }
6794
6795 if (stdout_flag == 1)
6796 {
6797 status_timer = 0;
6798 restore_timer = 0;
6799 restore_disable = 1;
6800 restore = 0;
6801 potfile_disable = 1;
6802 weak_hash_threshold = 0;
6803 gpu_temp_disable = 1;
6804 hash_mode = 2000;
6805 quiet = 1;
6806 outfile_format = OUTFILE_FMT_PLAIN;
6807 kernel_accel = 1024;
6808 kernel_loops = 1024;
6809 force = 1;
6810 outfile_check_timer = 0;
6811 session = "stdout";
6812 opencl_vector_width = 1;
6813 }
6814
6815 if (remove_timer_chgd == 1)
6816 {
6817 if (remove == 0)
6818 {
6819 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6820
6821 return (-1);
6822 }
6823
6824 if (remove_timer < 1)
6825 {
6826 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6827
6828 return (-1);
6829 }
6830 }
6831
6832 if (loopback == 1)
6833 {
6834 if (attack_mode == ATTACK_MODE_STRAIGHT)
6835 {
6836 if ((rp_files_cnt == 0) && (rp_gen == 0))
6837 {
6838 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6839
6840 return (-1);
6841 }
6842 }
6843 else
6844 {
6845 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6846
6847 return (-1);
6848 }
6849 }
6850
6851 if (debug_mode > 0)
6852 {
6853 if (attack_mode != ATTACK_MODE_STRAIGHT)
6854 {
6855 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6856
6857 return (-1);
6858 }
6859
6860 if ((rp_files_cnt == 0) && (rp_gen == 0))
6861 {
6862 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6863
6864 return (-1);
6865 }
6866 }
6867
6868 if (debug_mode > 4)
6869 {
6870 log_error ("ERROR: Invalid debug-mode specified");
6871
6872 return (-1);
6873 }
6874
6875 if (debug_file != NULL)
6876 {
6877 if (debug_mode < 1)
6878 {
6879 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6880
6881 return (-1);
6882 }
6883 }
6884
6885 if (induction_dir != NULL)
6886 {
6887 if (attack_mode == ATTACK_MODE_BF)
6888 {
6889 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6890
6891 return (-1);
6892 }
6893 }
6894
6895 if (attack_mode != ATTACK_MODE_STRAIGHT)
6896 {
6897 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6898 {
6899 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6900
6901 return (-1);
6902 }
6903
6904 weak_hash_threshold = 0;
6905 }
6906
6907 if (nvidia_spin_damp > 100)
6908 {
6909 log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)");
6910
6911 return (-1);
6912 }
6913
6914
6915 /**
6916 * induction directory
6917 */
6918
6919 char *induction_directory = NULL;
6920
6921 if (attack_mode != ATTACK_MODE_BF)
6922 {
6923 if (induction_dir == NULL)
6924 {
6925 induction_directory = (char *) mymalloc (session_size);
6926
6927 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6928
6929 // create induction folder if it does not already exist
6930
6931 if (keyspace == 0)
6932 {
6933 if (rmdir (induction_directory) == -1)
6934 {
6935 if (errno == ENOENT)
6936 {
6937 // good, we can ignore
6938 }
6939 else if (errno == ENOTEMPTY)
6940 {
6941 char *induction_directory_mv = (char *) mymalloc (session_size);
6942
6943 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6944
6945 if (rename (induction_directory, induction_directory_mv) != 0)
6946 {
6947 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6948
6949 return (-1);
6950 }
6951 }
6952 else
6953 {
6954 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6955
6956 return (-1);
6957 }
6958 }
6959
6960 if (mkdir (induction_directory, 0700) == -1)
6961 {
6962 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6963
6964 return (-1);
6965 }
6966 }
6967 }
6968 else
6969 {
6970 induction_directory = induction_dir;
6971 }
6972 }
6973
6974 data.induction_directory = induction_directory;
6975
6976 /**
6977 * loopback
6978 */
6979
6980 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6981
6982 char *loopback_file = (char *) mymalloc (loopback_size);
6983
6984 /**
6985 * tuning db
6986 */
6987
6988 char tuning_db_file[256] = { 0 };
6989
6990 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6991
6992 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6993
6994 /**
6995 * outfile-check directory
6996 */
6997
6998 char *outfile_check_directory = NULL;
6999
7000 if (outfile_check_dir == NULL)
7001 {
7002 outfile_check_directory = (char *) mymalloc (session_size);
7003
7004 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
7005 }
7006 else
7007 {
7008 outfile_check_directory = outfile_check_dir;
7009 }
7010
7011 data.outfile_check_directory = outfile_check_directory;
7012
7013 if (keyspace == 0)
7014 {
7015 struct stat outfile_check_stat;
7016
7017 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
7018 {
7019 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
7020
7021 if (is_dir == 0)
7022 {
7023 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
7024
7025 return (-1);
7026 }
7027 }
7028 else if (outfile_check_dir == NULL)
7029 {
7030 if (mkdir (outfile_check_directory, 0700) == -1)
7031 {
7032 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
7033
7034 return (-1);
7035 }
7036 }
7037 }
7038
7039 /**
7040 * special other stuff
7041 */
7042
7043 if (hash_mode == 9710)
7044 {
7045 outfile_format = 5;
7046 outfile_format_chgd = 1;
7047 }
7048
7049 if (hash_mode == 9810)
7050 {
7051 outfile_format = 5;
7052 outfile_format_chgd = 1;
7053 }
7054
7055 if (hash_mode == 10410)
7056 {
7057 outfile_format = 5;
7058 outfile_format_chgd = 1;
7059 }
7060
7061 /**
7062 * store stuff
7063 */
7064
7065 data.hash_mode = hash_mode;
7066 data.restore = restore;
7067 data.restore_timer = restore_timer;
7068 data.restore_disable = restore_disable;
7069 data.status = status;
7070 data.status_timer = status_timer;
7071 data.machine_readable = machine_readable;
7072 data.loopback = loopback;
7073 data.runtime = runtime;
7074 data.remove = remove;
7075 data.remove_timer = remove_timer;
7076 data.debug_mode = debug_mode;
7077 data.debug_file = debug_file;
7078 data.username = username;
7079 data.quiet = quiet;
7080 data.outfile = outfile;
7081 data.outfile_format = outfile_format;
7082 data.outfile_autohex = outfile_autohex;
7083 data.hex_charset = hex_charset;
7084 data.hex_salt = hex_salt;
7085 data.hex_wordlist = hex_wordlist;
7086 data.separator = separator;
7087 data.rp_files = rp_files;
7088 data.rp_files_cnt = rp_files_cnt;
7089 data.rp_gen = rp_gen;
7090 data.rp_gen_seed = rp_gen_seed;
7091 data.force = force;
7092 data.benchmark = benchmark;
7093 data.skip = skip;
7094 data.limit = limit;
7095 #ifdef HAVE_HWMON
7096 data.powertune_enable = powertune_enable;
7097 #endif
7098 data.logfile_disable = logfile_disable;
7099 data.truecrypt_keyfiles = truecrypt_keyfiles;
7100 data.veracrypt_keyfiles = veracrypt_keyfiles;
7101 data.veracrypt_pim = veracrypt_pim;
7102 data.scrypt_tmto = scrypt_tmto;
7103 data.workload_profile = workload_profile;
7104
7105 /**
7106 * cpu affinity
7107 */
7108
7109 if (cpu_affinity)
7110 {
7111 set_cpu_affinity (cpu_affinity);
7112 }
7113
7114 if (rp_gen_seed_chgd == 0)
7115 {
7116 srand (proc_start);
7117 }
7118 else
7119 {
7120 srand (rp_gen_seed);
7121 }
7122
7123 /**
7124 * logfile init
7125 */
7126
7127 if (logfile_disable == 0)
7128 {
7129 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7130
7131 char *logfile = (char *) mymalloc (logfile_size);
7132
7133 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7134
7135 data.logfile = logfile;
7136
7137 char *topid = logfile_generate_topid ();
7138
7139 data.topid = topid;
7140 }
7141
7142 // logfile_append() checks for logfile_disable internally to make it easier from here
7143
7144 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7145 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7146 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7147 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7148 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7149 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7150 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7151 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7152 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7153 #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));
7154
7155 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7156 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7157 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7158 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7159 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7160 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7161 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7162 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7163
7164 logfile_top_msg ("START");
7165
7166 logfile_top_uint (attack_mode);
7167 logfile_top_uint (attack_kern);
7168 logfile_top_uint (benchmark);
7169 logfile_top_uint (stdout_flag);
7170 logfile_top_uint (bitmap_min);
7171 logfile_top_uint (bitmap_max);
7172 logfile_top_uint (debug_mode);
7173 logfile_top_uint (force);
7174 logfile_top_uint (kernel_accel);
7175 logfile_top_uint (kernel_loops);
7176 logfile_top_uint (nvidia_spin_damp);
7177 logfile_top_uint (gpu_temp_disable);
7178 #ifdef HAVE_HWMON
7179 logfile_top_uint (gpu_temp_abort);
7180 logfile_top_uint (gpu_temp_retain);
7181 #endif
7182 logfile_top_uint (hash_mode);
7183 logfile_top_uint (hex_charset);
7184 logfile_top_uint (hex_salt);
7185 logfile_top_uint (hex_wordlist);
7186 logfile_top_uint (increment);
7187 logfile_top_uint (increment_max);
7188 logfile_top_uint (increment_min);
7189 logfile_top_uint (keyspace);
7190 logfile_top_uint (left);
7191 logfile_top_uint (logfile_disable);
7192 logfile_top_uint (loopback);
7193 logfile_top_uint (markov_classic);
7194 logfile_top_uint (markov_disable);
7195 logfile_top_uint (markov_threshold);
7196 logfile_top_uint (outfile_autohex);
7197 logfile_top_uint (outfile_check_timer);
7198 logfile_top_uint (outfile_format);
7199 logfile_top_uint (potfile_disable);
7200 logfile_top_string (potfile_path);
7201 #if defined(HAVE_HWMON)
7202 logfile_top_uint (powertune_enable);
7203 #endif
7204 logfile_top_uint (scrypt_tmto);
7205 logfile_top_uint (quiet);
7206 logfile_top_uint (remove);
7207 logfile_top_uint (remove_timer);
7208 logfile_top_uint (restore);
7209 logfile_top_uint (restore_disable);
7210 logfile_top_uint (restore_timer);
7211 logfile_top_uint (rp_gen);
7212 logfile_top_uint (rp_gen_func_max);
7213 logfile_top_uint (rp_gen_func_min);
7214 logfile_top_uint (rp_gen_seed);
7215 logfile_top_uint (runtime);
7216 logfile_top_uint (segment_size);
7217 logfile_top_uint (show);
7218 logfile_top_uint (status);
7219 logfile_top_uint (machine_readable);
7220 logfile_top_uint (status_timer);
7221 logfile_top_uint (usage);
7222 logfile_top_uint (username);
7223 logfile_top_uint (version);
7224 logfile_top_uint (weak_hash_threshold);
7225 logfile_top_uint (workload_profile);
7226 logfile_top_uint64 (limit);
7227 logfile_top_uint64 (skip);
7228 logfile_top_char (separator);
7229 logfile_top_string (cpu_affinity);
7230 logfile_top_string (custom_charset_1);
7231 logfile_top_string (custom_charset_2);
7232 logfile_top_string (custom_charset_3);
7233 logfile_top_string (custom_charset_4);
7234 logfile_top_string (debug_file);
7235 logfile_top_string (opencl_devices);
7236 logfile_top_string (opencl_platforms);
7237 logfile_top_string (opencl_device_types);
7238 logfile_top_uint (opencl_vector_width);
7239 logfile_top_string (induction_dir);
7240 logfile_top_string (markov_hcstat);
7241 logfile_top_string (outfile);
7242 logfile_top_string (outfile_check_dir);
7243 logfile_top_string (rule_buf_l);
7244 logfile_top_string (rule_buf_r);
7245 logfile_top_string (session);
7246 logfile_top_string (truecrypt_keyfiles);
7247 logfile_top_string (veracrypt_keyfiles);
7248 logfile_top_uint (veracrypt_pim);
7249
7250 /**
7251 * Init OpenCL library loader
7252 */
7253
7254 if (keyspace == 0)
7255 {
7256 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7257
7258 ocl_init (ocl);
7259
7260 data.ocl = ocl;
7261 }
7262
7263 /**
7264 * OpenCL platform selection
7265 */
7266
7267 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7268
7269 /**
7270 * OpenCL device selection
7271 */
7272
7273 u32 devices_filter = setup_devices_filter (opencl_devices);
7274
7275 /**
7276 * OpenCL device type selection
7277 */
7278
7279 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7280
7281 /**
7282 * benchmark
7283 */
7284
7285 if (benchmark == 1)
7286 {
7287 /**
7288 * disable useless stuff for benchmark
7289 */
7290
7291 status_timer = 0;
7292 restore_timer = 0;
7293 restore_disable = 1;
7294 potfile_disable = 1;
7295 weak_hash_threshold = 0;
7296 nvidia_spin_damp = 0;
7297 gpu_temp_disable = 1;
7298 outfile_check_timer = 0;
7299
7300 #ifdef HAVE_HWMON
7301 if (powertune_enable == 1)
7302 {
7303 gpu_temp_disable = 0;
7304 }
7305 #endif
7306
7307 data.status_timer = status_timer;
7308 data.restore_timer = restore_timer;
7309 data.restore_disable = restore_disable;
7310 data.outfile_check_timer = outfile_check_timer;
7311
7312 /**
7313 * force attack mode to be bruteforce
7314 */
7315
7316 attack_mode = ATTACK_MODE_BF;
7317 attack_kern = ATTACK_KERN_BF;
7318
7319 if (workload_profile_chgd == 0)
7320 {
7321 workload_profile = 3;
7322
7323 data.workload_profile = workload_profile;
7324 }
7325 }
7326
7327 /**
7328 * config
7329 */
7330
7331 uint hash_type = 0;
7332 uint salt_type = 0;
7333 uint attack_exec = 0;
7334 uint opts_type = 0;
7335 uint kern_type = 0;
7336 uint dgst_size = 0;
7337 uint esalt_size = 0;
7338 uint opti_type = 0;
7339 uint dgst_pos0 = -1;
7340 uint dgst_pos1 = -1;
7341 uint dgst_pos2 = -1;
7342 uint dgst_pos3 = -1;
7343
7344 int (*parse_func) (char *, uint, hash_t *);
7345 int (*sort_by_digest) (const void *, const void *);
7346
7347 uint algorithm_pos = 0;
7348 uint algorithm_max = 1;
7349
7350 uint *algorithms = default_benchmark_algorithms;
7351
7352 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7353
7354 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7355 {
7356 /*
7357 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7358 * the following algos are skipped entirely
7359 */
7360
7361 if (algorithm_pos > 0)
7362 {
7363 local_free (rd);
7364
7365 rd = init_restore (argc, argv);
7366
7367 data.rd = rd;
7368 }
7369
7370 /**
7371 * update hash_mode in case of multihash benchmark
7372 */
7373
7374 if (benchmark == 1)
7375 {
7376 if (hash_mode_chgd == 0)
7377 {
7378 hash_mode = algorithms[algorithm_pos];
7379
7380 data.hash_mode = hash_mode;
7381 }
7382
7383 quiet = 1;
7384
7385 data.quiet = quiet;
7386 }
7387
7388 switch (hash_mode)
7389 {
7390 case 0: hash_type = HASH_TYPE_MD5;
7391 salt_type = SALT_TYPE_NONE;
7392 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7393 opts_type = OPTS_TYPE_PT_GENERATE_LE
7394 | OPTS_TYPE_PT_ADD80
7395 | OPTS_TYPE_PT_ADDBITS14;
7396 kern_type = KERN_TYPE_MD5;
7397 dgst_size = DGST_SIZE_4_4;
7398 parse_func = md5_parse_hash;
7399 sort_by_digest = sort_by_digest_4_4;
7400 opti_type = OPTI_TYPE_ZERO_BYTE
7401 | OPTI_TYPE_PRECOMPUTE_INIT
7402 | OPTI_TYPE_PRECOMPUTE_MERKLE
7403 | OPTI_TYPE_MEET_IN_MIDDLE
7404 | OPTI_TYPE_EARLY_SKIP
7405 | OPTI_TYPE_NOT_ITERATED
7406 | OPTI_TYPE_NOT_SALTED
7407 | OPTI_TYPE_RAW_HASH;
7408 dgst_pos0 = 0;
7409 dgst_pos1 = 3;
7410 dgst_pos2 = 2;
7411 dgst_pos3 = 1;
7412 break;
7413
7414 case 10: hash_type = HASH_TYPE_MD5;
7415 salt_type = SALT_TYPE_INTERN;
7416 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7417 opts_type = OPTS_TYPE_PT_GENERATE_LE
7418 | OPTS_TYPE_ST_ADD80
7419 | OPTS_TYPE_ST_ADDBITS14;
7420 kern_type = KERN_TYPE_MD5_PWSLT;
7421 dgst_size = DGST_SIZE_4_4;
7422 parse_func = md5s_parse_hash;
7423 sort_by_digest = sort_by_digest_4_4;
7424 opti_type = OPTI_TYPE_ZERO_BYTE
7425 | OPTI_TYPE_PRECOMPUTE_INIT
7426 | OPTI_TYPE_PRECOMPUTE_MERKLE
7427 | OPTI_TYPE_MEET_IN_MIDDLE
7428 | OPTI_TYPE_EARLY_SKIP
7429 | OPTI_TYPE_NOT_ITERATED
7430 | OPTI_TYPE_APPENDED_SALT
7431 | OPTI_TYPE_RAW_HASH;
7432 dgst_pos0 = 0;
7433 dgst_pos1 = 3;
7434 dgst_pos2 = 2;
7435 dgst_pos3 = 1;
7436 break;
7437
7438 case 11: hash_type = HASH_TYPE_MD5;
7439 salt_type = SALT_TYPE_INTERN;
7440 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7441 opts_type = OPTS_TYPE_PT_GENERATE_LE
7442 | OPTS_TYPE_ST_ADD80
7443 | OPTS_TYPE_ST_ADDBITS14;
7444 kern_type = KERN_TYPE_MD5_PWSLT;
7445 dgst_size = DGST_SIZE_4_4;
7446 parse_func = joomla_parse_hash;
7447 sort_by_digest = sort_by_digest_4_4;
7448 opti_type = OPTI_TYPE_ZERO_BYTE
7449 | OPTI_TYPE_PRECOMPUTE_INIT
7450 | OPTI_TYPE_PRECOMPUTE_MERKLE
7451 | OPTI_TYPE_MEET_IN_MIDDLE
7452 | OPTI_TYPE_EARLY_SKIP
7453 | OPTI_TYPE_NOT_ITERATED
7454 | OPTI_TYPE_APPENDED_SALT
7455 | OPTI_TYPE_RAW_HASH;
7456 dgst_pos0 = 0;
7457 dgst_pos1 = 3;
7458 dgst_pos2 = 2;
7459 dgst_pos3 = 1;
7460 break;
7461
7462 case 12: hash_type = HASH_TYPE_MD5;
7463 salt_type = SALT_TYPE_INTERN;
7464 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7465 opts_type = OPTS_TYPE_PT_GENERATE_LE
7466 | OPTS_TYPE_ST_ADD80
7467 | OPTS_TYPE_ST_ADDBITS14;
7468 kern_type = KERN_TYPE_MD5_PWSLT;
7469 dgst_size = DGST_SIZE_4_4;
7470 parse_func = postgresql_parse_hash;
7471 sort_by_digest = sort_by_digest_4_4;
7472 opti_type = OPTI_TYPE_ZERO_BYTE
7473 | OPTI_TYPE_PRECOMPUTE_INIT
7474 | OPTI_TYPE_PRECOMPUTE_MERKLE
7475 | OPTI_TYPE_MEET_IN_MIDDLE
7476 | OPTI_TYPE_EARLY_SKIP
7477 | OPTI_TYPE_NOT_ITERATED
7478 | OPTI_TYPE_APPENDED_SALT
7479 | OPTI_TYPE_RAW_HASH;
7480 dgst_pos0 = 0;
7481 dgst_pos1 = 3;
7482 dgst_pos2 = 2;
7483 dgst_pos3 = 1;
7484 break;
7485
7486 case 20: hash_type = HASH_TYPE_MD5;
7487 salt_type = SALT_TYPE_INTERN;
7488 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7489 opts_type = OPTS_TYPE_PT_GENERATE_LE
7490 | OPTS_TYPE_PT_ADD80
7491 | OPTS_TYPE_PT_ADDBITS14;
7492 kern_type = KERN_TYPE_MD5_SLTPW;
7493 dgst_size = DGST_SIZE_4_4;
7494 parse_func = md5s_parse_hash;
7495 sort_by_digest = sort_by_digest_4_4;
7496 opti_type = OPTI_TYPE_ZERO_BYTE
7497 | OPTI_TYPE_PRECOMPUTE_INIT
7498 | OPTI_TYPE_PRECOMPUTE_MERKLE
7499 | OPTI_TYPE_EARLY_SKIP
7500 | OPTI_TYPE_NOT_ITERATED
7501 | OPTI_TYPE_PREPENDED_SALT
7502 | OPTI_TYPE_RAW_HASH;
7503 dgst_pos0 = 0;
7504 dgst_pos1 = 3;
7505 dgst_pos2 = 2;
7506 dgst_pos3 = 1;
7507 break;
7508
7509 case 21: hash_type = HASH_TYPE_MD5;
7510 salt_type = SALT_TYPE_INTERN;
7511 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7512 opts_type = OPTS_TYPE_PT_GENERATE_LE
7513 | OPTS_TYPE_PT_ADD80
7514 | OPTS_TYPE_PT_ADDBITS14;
7515 kern_type = KERN_TYPE_MD5_SLTPW;
7516 dgst_size = DGST_SIZE_4_4;
7517 parse_func = osc_parse_hash;
7518 sort_by_digest = sort_by_digest_4_4;
7519 opti_type = OPTI_TYPE_ZERO_BYTE
7520 | OPTI_TYPE_PRECOMPUTE_INIT
7521 | OPTI_TYPE_PRECOMPUTE_MERKLE
7522 | OPTI_TYPE_EARLY_SKIP
7523 | OPTI_TYPE_NOT_ITERATED
7524 | OPTI_TYPE_PREPENDED_SALT
7525 | OPTI_TYPE_RAW_HASH;
7526 dgst_pos0 = 0;
7527 dgst_pos1 = 3;
7528 dgst_pos2 = 2;
7529 dgst_pos3 = 1;
7530 break;
7531
7532 case 22: hash_type = HASH_TYPE_MD5;
7533 salt_type = SALT_TYPE_EMBEDDED;
7534 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7535 opts_type = OPTS_TYPE_PT_GENERATE_LE
7536 | OPTS_TYPE_PT_ADD80
7537 | OPTS_TYPE_PT_ADDBITS14;
7538 kern_type = KERN_TYPE_MD5_SLTPW;
7539 dgst_size = DGST_SIZE_4_4;
7540 parse_func = netscreen_parse_hash;
7541 sort_by_digest = sort_by_digest_4_4;
7542 opti_type = OPTI_TYPE_ZERO_BYTE
7543 | OPTI_TYPE_PRECOMPUTE_INIT
7544 | OPTI_TYPE_PRECOMPUTE_MERKLE
7545 | OPTI_TYPE_EARLY_SKIP
7546 | OPTI_TYPE_NOT_ITERATED
7547 | OPTI_TYPE_PREPENDED_SALT
7548 | OPTI_TYPE_RAW_HASH;
7549 dgst_pos0 = 0;
7550 dgst_pos1 = 3;
7551 dgst_pos2 = 2;
7552 dgst_pos3 = 1;
7553 break;
7554
7555 case 23: hash_type = HASH_TYPE_MD5;
7556 salt_type = SALT_TYPE_EMBEDDED;
7557 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7558 opts_type = OPTS_TYPE_PT_GENERATE_LE
7559 | OPTS_TYPE_PT_ADD80
7560 | OPTS_TYPE_PT_ADDBITS14;
7561 kern_type = KERN_TYPE_MD5_SLTPW;
7562 dgst_size = DGST_SIZE_4_4;
7563 parse_func = skype_parse_hash;
7564 sort_by_digest = sort_by_digest_4_4;
7565 opti_type = OPTI_TYPE_ZERO_BYTE
7566 | OPTI_TYPE_PRECOMPUTE_INIT
7567 | OPTI_TYPE_PRECOMPUTE_MERKLE
7568 | OPTI_TYPE_EARLY_SKIP
7569 | OPTI_TYPE_NOT_ITERATED
7570 | OPTI_TYPE_PREPENDED_SALT
7571 | OPTI_TYPE_RAW_HASH;
7572 dgst_pos0 = 0;
7573 dgst_pos1 = 3;
7574 dgst_pos2 = 2;
7575 dgst_pos3 = 1;
7576 break;
7577
7578 case 30: hash_type = HASH_TYPE_MD5;
7579 salt_type = SALT_TYPE_INTERN;
7580 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7581 opts_type = OPTS_TYPE_PT_GENERATE_LE
7582 | OPTS_TYPE_PT_UNICODE
7583 | OPTS_TYPE_ST_ADD80
7584 | OPTS_TYPE_ST_ADDBITS14;
7585 kern_type = KERN_TYPE_MD5_PWUSLT;
7586 dgst_size = DGST_SIZE_4_4;
7587 parse_func = md5s_parse_hash;
7588 sort_by_digest = sort_by_digest_4_4;
7589 opti_type = OPTI_TYPE_ZERO_BYTE
7590 | OPTI_TYPE_PRECOMPUTE_INIT
7591 | OPTI_TYPE_PRECOMPUTE_MERKLE
7592 | OPTI_TYPE_MEET_IN_MIDDLE
7593 | OPTI_TYPE_EARLY_SKIP
7594 | OPTI_TYPE_NOT_ITERATED
7595 | OPTI_TYPE_APPENDED_SALT
7596 | OPTI_TYPE_RAW_HASH;
7597 dgst_pos0 = 0;
7598 dgst_pos1 = 3;
7599 dgst_pos2 = 2;
7600 dgst_pos3 = 1;
7601 break;
7602
7603 case 40: hash_type = HASH_TYPE_MD5;
7604 salt_type = SALT_TYPE_INTERN;
7605 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7606 opts_type = OPTS_TYPE_PT_GENERATE_LE
7607 | OPTS_TYPE_PT_ADD80
7608 | OPTS_TYPE_PT_ADDBITS14
7609 | OPTS_TYPE_PT_UNICODE;
7610 kern_type = KERN_TYPE_MD5_SLTPWU;
7611 dgst_size = DGST_SIZE_4_4;
7612 parse_func = md5s_parse_hash;
7613 sort_by_digest = sort_by_digest_4_4;
7614 opti_type = OPTI_TYPE_ZERO_BYTE
7615 | OPTI_TYPE_PRECOMPUTE_INIT
7616 | OPTI_TYPE_PRECOMPUTE_MERKLE
7617 | OPTI_TYPE_EARLY_SKIP
7618 | OPTI_TYPE_NOT_ITERATED
7619 | OPTI_TYPE_PREPENDED_SALT
7620 | OPTI_TYPE_RAW_HASH;
7621 dgst_pos0 = 0;
7622 dgst_pos1 = 3;
7623 dgst_pos2 = 2;
7624 dgst_pos3 = 1;
7625 break;
7626
7627 case 50: hash_type = HASH_TYPE_MD5;
7628 salt_type = SALT_TYPE_INTERN;
7629 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7630 opts_type = OPTS_TYPE_PT_GENERATE_LE
7631 | OPTS_TYPE_ST_ADD80
7632 | OPTS_TYPE_ST_ADDBITS14;
7633 kern_type = KERN_TYPE_HMACMD5_PW;
7634 dgst_size = DGST_SIZE_4_4;
7635 parse_func = hmacmd5_parse_hash;
7636 sort_by_digest = sort_by_digest_4_4;
7637 opti_type = OPTI_TYPE_ZERO_BYTE
7638 | OPTI_TYPE_NOT_ITERATED;
7639 dgst_pos0 = 0;
7640 dgst_pos1 = 3;
7641 dgst_pos2 = 2;
7642 dgst_pos3 = 1;
7643 break;
7644
7645 case 60: hash_type = HASH_TYPE_MD5;
7646 salt_type = SALT_TYPE_INTERN;
7647 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7648 opts_type = OPTS_TYPE_PT_GENERATE_LE
7649 | OPTS_TYPE_PT_ADD80
7650 | OPTS_TYPE_PT_ADDBITS14;
7651 kern_type = KERN_TYPE_HMACMD5_SLT;
7652 dgst_size = DGST_SIZE_4_4;
7653 parse_func = hmacmd5_parse_hash;
7654 sort_by_digest = sort_by_digest_4_4;
7655 opti_type = OPTI_TYPE_ZERO_BYTE
7656 | OPTI_TYPE_NOT_ITERATED;
7657 dgst_pos0 = 0;
7658 dgst_pos1 = 3;
7659 dgst_pos2 = 2;
7660 dgst_pos3 = 1;
7661 break;
7662
7663 case 100: hash_type = HASH_TYPE_SHA1;
7664 salt_type = SALT_TYPE_NONE;
7665 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7666 opts_type = OPTS_TYPE_PT_GENERATE_BE
7667 | OPTS_TYPE_PT_ADD80
7668 | OPTS_TYPE_PT_ADDBITS15;
7669 kern_type = KERN_TYPE_SHA1;
7670 dgst_size = DGST_SIZE_4_5;
7671 parse_func = sha1_parse_hash;
7672 sort_by_digest = sort_by_digest_4_5;
7673 opti_type = OPTI_TYPE_ZERO_BYTE
7674 | OPTI_TYPE_PRECOMPUTE_INIT
7675 | OPTI_TYPE_PRECOMPUTE_MERKLE
7676 | OPTI_TYPE_EARLY_SKIP
7677 | OPTI_TYPE_NOT_ITERATED
7678 | OPTI_TYPE_NOT_SALTED
7679 | OPTI_TYPE_RAW_HASH;
7680 dgst_pos0 = 3;
7681 dgst_pos1 = 4;
7682 dgst_pos2 = 2;
7683 dgst_pos3 = 1;
7684 break;
7685
7686 case 101: hash_type = HASH_TYPE_SHA1;
7687 salt_type = SALT_TYPE_NONE;
7688 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7689 opts_type = OPTS_TYPE_PT_GENERATE_BE
7690 | OPTS_TYPE_PT_ADD80
7691 | OPTS_TYPE_PT_ADDBITS15;
7692 kern_type = KERN_TYPE_SHA1;
7693 dgst_size = DGST_SIZE_4_5;
7694 parse_func = sha1b64_parse_hash;
7695 sort_by_digest = sort_by_digest_4_5;
7696 opti_type = OPTI_TYPE_ZERO_BYTE
7697 | OPTI_TYPE_PRECOMPUTE_INIT
7698 | OPTI_TYPE_PRECOMPUTE_MERKLE
7699 | OPTI_TYPE_EARLY_SKIP
7700 | OPTI_TYPE_NOT_ITERATED
7701 | OPTI_TYPE_NOT_SALTED
7702 | OPTI_TYPE_RAW_HASH;
7703 dgst_pos0 = 3;
7704 dgst_pos1 = 4;
7705 dgst_pos2 = 2;
7706 dgst_pos3 = 1;
7707 break;
7708
7709 case 110: hash_type = HASH_TYPE_SHA1;
7710 salt_type = SALT_TYPE_INTERN;
7711 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7712 opts_type = OPTS_TYPE_PT_GENERATE_BE
7713 | OPTS_TYPE_ST_ADD80
7714 | OPTS_TYPE_ST_ADDBITS15;
7715 kern_type = KERN_TYPE_SHA1_PWSLT;
7716 dgst_size = DGST_SIZE_4_5;
7717 parse_func = sha1s_parse_hash;
7718 sort_by_digest = sort_by_digest_4_5;
7719 opti_type = OPTI_TYPE_ZERO_BYTE
7720 | OPTI_TYPE_PRECOMPUTE_INIT
7721 | OPTI_TYPE_PRECOMPUTE_MERKLE
7722 | OPTI_TYPE_EARLY_SKIP
7723 | OPTI_TYPE_NOT_ITERATED
7724 | OPTI_TYPE_APPENDED_SALT
7725 | OPTI_TYPE_RAW_HASH;
7726 dgst_pos0 = 3;
7727 dgst_pos1 = 4;
7728 dgst_pos2 = 2;
7729 dgst_pos3 = 1;
7730 break;
7731
7732 case 111: hash_type = HASH_TYPE_SHA1;
7733 salt_type = SALT_TYPE_EMBEDDED;
7734 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7735 opts_type = OPTS_TYPE_PT_GENERATE_BE
7736 | OPTS_TYPE_ST_ADD80
7737 | OPTS_TYPE_ST_ADDBITS15;
7738 kern_type = KERN_TYPE_SHA1_PWSLT;
7739 dgst_size = DGST_SIZE_4_5;
7740 parse_func = sha1b64s_parse_hash;
7741 sort_by_digest = sort_by_digest_4_5;
7742 opti_type = OPTI_TYPE_ZERO_BYTE
7743 | OPTI_TYPE_PRECOMPUTE_INIT
7744 | OPTI_TYPE_PRECOMPUTE_MERKLE
7745 | OPTI_TYPE_EARLY_SKIP
7746 | OPTI_TYPE_NOT_ITERATED
7747 | OPTI_TYPE_APPENDED_SALT
7748 | OPTI_TYPE_RAW_HASH;
7749 dgst_pos0 = 3;
7750 dgst_pos1 = 4;
7751 dgst_pos2 = 2;
7752 dgst_pos3 = 1;
7753 break;
7754
7755 case 112: hash_type = HASH_TYPE_SHA1;
7756 salt_type = SALT_TYPE_INTERN;
7757 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7758 opts_type = OPTS_TYPE_PT_GENERATE_BE
7759 | OPTS_TYPE_ST_ADD80
7760 | OPTS_TYPE_ST_ADDBITS15
7761 | OPTS_TYPE_ST_HEX;
7762 kern_type = KERN_TYPE_SHA1_PWSLT;
7763 dgst_size = DGST_SIZE_4_5;
7764 parse_func = oracles_parse_hash;
7765 sort_by_digest = sort_by_digest_4_5;
7766 opti_type = OPTI_TYPE_ZERO_BYTE
7767 | OPTI_TYPE_PRECOMPUTE_INIT
7768 | OPTI_TYPE_PRECOMPUTE_MERKLE
7769 | OPTI_TYPE_EARLY_SKIP
7770 | OPTI_TYPE_NOT_ITERATED
7771 | OPTI_TYPE_APPENDED_SALT
7772 | OPTI_TYPE_RAW_HASH;
7773 dgst_pos0 = 3;
7774 dgst_pos1 = 4;
7775 dgst_pos2 = 2;
7776 dgst_pos3 = 1;
7777 break;
7778
7779 case 120: hash_type = HASH_TYPE_SHA1;
7780 salt_type = SALT_TYPE_INTERN;
7781 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7782 opts_type = OPTS_TYPE_PT_GENERATE_BE
7783 | OPTS_TYPE_PT_ADD80
7784 | OPTS_TYPE_PT_ADDBITS15;
7785 kern_type = KERN_TYPE_SHA1_SLTPW;
7786 dgst_size = DGST_SIZE_4_5;
7787 parse_func = sha1s_parse_hash;
7788 sort_by_digest = sort_by_digest_4_5;
7789 opti_type = OPTI_TYPE_ZERO_BYTE
7790 | OPTI_TYPE_PRECOMPUTE_INIT
7791 | OPTI_TYPE_PRECOMPUTE_MERKLE
7792 | OPTI_TYPE_EARLY_SKIP
7793 | OPTI_TYPE_NOT_ITERATED
7794 | OPTI_TYPE_PREPENDED_SALT
7795 | OPTI_TYPE_RAW_HASH;
7796 dgst_pos0 = 3;
7797 dgst_pos1 = 4;
7798 dgst_pos2 = 2;
7799 dgst_pos3 = 1;
7800 break;
7801
7802 case 121: hash_type = HASH_TYPE_SHA1;
7803 salt_type = SALT_TYPE_INTERN;
7804 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7805 opts_type = OPTS_TYPE_PT_GENERATE_BE
7806 | OPTS_TYPE_PT_ADD80
7807 | OPTS_TYPE_PT_ADDBITS15
7808 | OPTS_TYPE_ST_LOWER;
7809 kern_type = KERN_TYPE_SHA1_SLTPW;
7810 dgst_size = DGST_SIZE_4_5;
7811 parse_func = smf_parse_hash;
7812 sort_by_digest = sort_by_digest_4_5;
7813 opti_type = OPTI_TYPE_ZERO_BYTE
7814 | OPTI_TYPE_PRECOMPUTE_INIT
7815 | OPTI_TYPE_PRECOMPUTE_MERKLE
7816 | OPTI_TYPE_EARLY_SKIP
7817 | OPTI_TYPE_NOT_ITERATED
7818 | OPTI_TYPE_PREPENDED_SALT
7819 | OPTI_TYPE_RAW_HASH;
7820 dgst_pos0 = 3;
7821 dgst_pos1 = 4;
7822 dgst_pos2 = 2;
7823 dgst_pos3 = 1;
7824 break;
7825
7826 case 122: hash_type = HASH_TYPE_SHA1;
7827 salt_type = SALT_TYPE_EMBEDDED;
7828 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7829 opts_type = OPTS_TYPE_PT_GENERATE_BE
7830 | OPTS_TYPE_PT_ADD80
7831 | OPTS_TYPE_PT_ADDBITS15
7832 | OPTS_TYPE_ST_HEX;
7833 kern_type = KERN_TYPE_SHA1_SLTPW;
7834 dgst_size = DGST_SIZE_4_5;
7835 parse_func = osx1_parse_hash;
7836 sort_by_digest = sort_by_digest_4_5;
7837 opti_type = OPTI_TYPE_ZERO_BYTE
7838 | OPTI_TYPE_PRECOMPUTE_INIT
7839 | OPTI_TYPE_PRECOMPUTE_MERKLE
7840 | OPTI_TYPE_EARLY_SKIP
7841 | OPTI_TYPE_NOT_ITERATED
7842 | OPTI_TYPE_PREPENDED_SALT
7843 | OPTI_TYPE_RAW_HASH;
7844 dgst_pos0 = 3;
7845 dgst_pos1 = 4;
7846 dgst_pos2 = 2;
7847 dgst_pos3 = 1;
7848 break;
7849
7850 case 124: hash_type = HASH_TYPE_SHA1;
7851 salt_type = SALT_TYPE_EMBEDDED;
7852 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7853 opts_type = OPTS_TYPE_PT_GENERATE_BE
7854 | OPTS_TYPE_PT_ADD80
7855 | OPTS_TYPE_PT_ADDBITS15;
7856 kern_type = KERN_TYPE_SHA1_SLTPW;
7857 dgst_size = DGST_SIZE_4_5;
7858 parse_func = djangosha1_parse_hash;
7859 sort_by_digest = sort_by_digest_4_5;
7860 opti_type = OPTI_TYPE_ZERO_BYTE
7861 | OPTI_TYPE_PRECOMPUTE_INIT
7862 | OPTI_TYPE_PRECOMPUTE_MERKLE
7863 | OPTI_TYPE_EARLY_SKIP
7864 | OPTI_TYPE_NOT_ITERATED
7865 | OPTI_TYPE_PREPENDED_SALT
7866 | OPTI_TYPE_RAW_HASH;
7867 dgst_pos0 = 3;
7868 dgst_pos1 = 4;
7869 dgst_pos2 = 2;
7870 dgst_pos3 = 1;
7871 break;
7872
7873 case 125: hash_type = HASH_TYPE_SHA1;
7874 salt_type = SALT_TYPE_EMBEDDED;
7875 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7876 opts_type = OPTS_TYPE_PT_GENERATE_BE
7877 | OPTS_TYPE_PT_ADD80
7878 | OPTS_TYPE_PT_ADDBITS15
7879 | OPTS_TYPE_ST_HEX;
7880 kern_type = KERN_TYPE_SHA1_SLTPW;
7881 dgst_size = DGST_SIZE_4_5;
7882 parse_func = arubaos_parse_hash;
7883 sort_by_digest = sort_by_digest_4_5;
7884 opti_type = OPTI_TYPE_ZERO_BYTE
7885 | OPTI_TYPE_PRECOMPUTE_INIT
7886 | OPTI_TYPE_PRECOMPUTE_MERKLE
7887 | OPTI_TYPE_EARLY_SKIP
7888 | OPTI_TYPE_NOT_ITERATED
7889 | OPTI_TYPE_PREPENDED_SALT
7890 | OPTI_TYPE_RAW_HASH;
7891 dgst_pos0 = 3;
7892 dgst_pos1 = 4;
7893 dgst_pos2 = 2;
7894 dgst_pos3 = 1;
7895 break;
7896
7897 case 130: hash_type = HASH_TYPE_SHA1;
7898 salt_type = SALT_TYPE_INTERN;
7899 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7900 opts_type = OPTS_TYPE_PT_GENERATE_BE
7901 | OPTS_TYPE_PT_UNICODE
7902 | OPTS_TYPE_ST_ADD80
7903 | OPTS_TYPE_ST_ADDBITS15;
7904 kern_type = KERN_TYPE_SHA1_PWUSLT;
7905 dgst_size = DGST_SIZE_4_5;
7906 parse_func = sha1s_parse_hash;
7907 sort_by_digest = sort_by_digest_4_5;
7908 opti_type = OPTI_TYPE_ZERO_BYTE
7909 | OPTI_TYPE_PRECOMPUTE_INIT
7910 | OPTI_TYPE_PRECOMPUTE_MERKLE
7911 | OPTI_TYPE_EARLY_SKIP
7912 | OPTI_TYPE_NOT_ITERATED
7913 | OPTI_TYPE_APPENDED_SALT
7914 | OPTI_TYPE_RAW_HASH;
7915 dgst_pos0 = 3;
7916 dgst_pos1 = 4;
7917 dgst_pos2 = 2;
7918 dgst_pos3 = 1;
7919 break;
7920
7921 case 131: hash_type = HASH_TYPE_SHA1;
7922 salt_type = SALT_TYPE_EMBEDDED;
7923 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7924 opts_type = OPTS_TYPE_PT_GENERATE_BE
7925 | OPTS_TYPE_PT_UNICODE
7926 | OPTS_TYPE_PT_UPPER
7927 | OPTS_TYPE_ST_ADD80
7928 | OPTS_TYPE_ST_ADDBITS15
7929 | OPTS_TYPE_ST_HEX;
7930 kern_type = KERN_TYPE_SHA1_PWUSLT;
7931 dgst_size = DGST_SIZE_4_5;
7932 parse_func = mssql2000_parse_hash;
7933 sort_by_digest = sort_by_digest_4_5;
7934 opti_type = OPTI_TYPE_ZERO_BYTE
7935 | OPTI_TYPE_PRECOMPUTE_INIT
7936 | OPTI_TYPE_PRECOMPUTE_MERKLE
7937 | OPTI_TYPE_EARLY_SKIP
7938 | OPTI_TYPE_NOT_ITERATED
7939 | OPTI_TYPE_APPENDED_SALT
7940 | OPTI_TYPE_RAW_HASH;
7941 dgst_pos0 = 3;
7942 dgst_pos1 = 4;
7943 dgst_pos2 = 2;
7944 dgst_pos3 = 1;
7945 break;
7946
7947 case 132: hash_type = HASH_TYPE_SHA1;
7948 salt_type = SALT_TYPE_EMBEDDED;
7949 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7950 opts_type = OPTS_TYPE_PT_GENERATE_BE
7951 | OPTS_TYPE_PT_UNICODE
7952 | OPTS_TYPE_ST_ADD80
7953 | OPTS_TYPE_ST_ADDBITS15
7954 | OPTS_TYPE_ST_HEX;
7955 kern_type = KERN_TYPE_SHA1_PWUSLT;
7956 dgst_size = DGST_SIZE_4_5;
7957 parse_func = mssql2005_parse_hash;
7958 sort_by_digest = sort_by_digest_4_5;
7959 opti_type = OPTI_TYPE_ZERO_BYTE
7960 | OPTI_TYPE_PRECOMPUTE_INIT
7961 | OPTI_TYPE_PRECOMPUTE_MERKLE
7962 | OPTI_TYPE_EARLY_SKIP
7963 | OPTI_TYPE_NOT_ITERATED
7964 | OPTI_TYPE_APPENDED_SALT
7965 | OPTI_TYPE_RAW_HASH;
7966 dgst_pos0 = 3;
7967 dgst_pos1 = 4;
7968 dgst_pos2 = 2;
7969 dgst_pos3 = 1;
7970 break;
7971
7972 case 133: hash_type = HASH_TYPE_SHA1;
7973 salt_type = SALT_TYPE_EMBEDDED;
7974 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7975 opts_type = OPTS_TYPE_PT_GENERATE_BE
7976 | OPTS_TYPE_PT_UNICODE
7977 | OPTS_TYPE_ST_ADD80
7978 | OPTS_TYPE_ST_ADDBITS15;
7979 kern_type = KERN_TYPE_SHA1_PWUSLT;
7980 dgst_size = DGST_SIZE_4_5;
7981 parse_func = peoplesoft_parse_hash;
7982 sort_by_digest = sort_by_digest_4_5;
7983 opti_type = OPTI_TYPE_ZERO_BYTE
7984 | OPTI_TYPE_PRECOMPUTE_INIT
7985 | OPTI_TYPE_PRECOMPUTE_MERKLE
7986 | OPTI_TYPE_EARLY_SKIP
7987 | OPTI_TYPE_NOT_ITERATED
7988 | OPTI_TYPE_APPENDED_SALT
7989 | OPTI_TYPE_RAW_HASH;
7990 dgst_pos0 = 3;
7991 dgst_pos1 = 4;
7992 dgst_pos2 = 2;
7993 dgst_pos3 = 1;
7994 break;
7995
7996 case 140: hash_type = HASH_TYPE_SHA1;
7997 salt_type = SALT_TYPE_INTERN;
7998 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7999 opts_type = OPTS_TYPE_PT_GENERATE_BE
8000 | OPTS_TYPE_PT_ADD80
8001 | OPTS_TYPE_PT_ADDBITS15
8002 | OPTS_TYPE_PT_UNICODE;
8003 kern_type = KERN_TYPE_SHA1_SLTPWU;
8004 dgst_size = DGST_SIZE_4_5;
8005 parse_func = sha1s_parse_hash;
8006 sort_by_digest = sort_by_digest_4_5;
8007 opti_type = OPTI_TYPE_ZERO_BYTE
8008 | OPTI_TYPE_PRECOMPUTE_INIT
8009 | OPTI_TYPE_PRECOMPUTE_MERKLE
8010 | OPTI_TYPE_EARLY_SKIP
8011 | OPTI_TYPE_NOT_ITERATED
8012 | OPTI_TYPE_PREPENDED_SALT
8013 | OPTI_TYPE_RAW_HASH;
8014 dgst_pos0 = 3;
8015 dgst_pos1 = 4;
8016 dgst_pos2 = 2;
8017 dgst_pos3 = 1;
8018 break;
8019
8020 case 141: hash_type = HASH_TYPE_SHA1;
8021 salt_type = SALT_TYPE_EMBEDDED;
8022 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8023 opts_type = OPTS_TYPE_PT_GENERATE_BE
8024 | OPTS_TYPE_PT_ADD80
8025 | OPTS_TYPE_PT_ADDBITS15
8026 | OPTS_TYPE_PT_UNICODE
8027 | OPTS_TYPE_ST_BASE64;
8028 kern_type = KERN_TYPE_SHA1_SLTPWU;
8029 dgst_size = DGST_SIZE_4_5;
8030 parse_func = episerver_parse_hash;
8031 sort_by_digest = sort_by_digest_4_5;
8032 opti_type = OPTI_TYPE_ZERO_BYTE
8033 | OPTI_TYPE_PRECOMPUTE_INIT
8034 | OPTI_TYPE_PRECOMPUTE_MERKLE
8035 | OPTI_TYPE_EARLY_SKIP
8036 | OPTI_TYPE_NOT_ITERATED
8037 | OPTI_TYPE_PREPENDED_SALT
8038 | OPTI_TYPE_RAW_HASH;
8039 dgst_pos0 = 3;
8040 dgst_pos1 = 4;
8041 dgst_pos2 = 2;
8042 dgst_pos3 = 1;
8043 break;
8044
8045 case 150: hash_type = HASH_TYPE_SHA1;
8046 salt_type = SALT_TYPE_INTERN;
8047 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8048 opts_type = OPTS_TYPE_PT_GENERATE_BE
8049 | OPTS_TYPE_ST_ADD80
8050 | OPTS_TYPE_ST_ADDBITS15;
8051 kern_type = KERN_TYPE_HMACSHA1_PW;
8052 dgst_size = DGST_SIZE_4_5;
8053 parse_func = hmacsha1_parse_hash;
8054 sort_by_digest = sort_by_digest_4_5;
8055 opti_type = OPTI_TYPE_ZERO_BYTE
8056 | OPTI_TYPE_NOT_ITERATED;
8057 dgst_pos0 = 3;
8058 dgst_pos1 = 4;
8059 dgst_pos2 = 2;
8060 dgst_pos3 = 1;
8061 break;
8062
8063 case 160: hash_type = HASH_TYPE_SHA1;
8064 salt_type = SALT_TYPE_INTERN;
8065 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8066 opts_type = OPTS_TYPE_PT_GENERATE_BE
8067 | OPTS_TYPE_PT_ADD80
8068 | OPTS_TYPE_PT_ADDBITS15;
8069 kern_type = KERN_TYPE_HMACSHA1_SLT;
8070 dgst_size = DGST_SIZE_4_5;
8071 parse_func = hmacsha1_parse_hash;
8072 sort_by_digest = sort_by_digest_4_5;
8073 opti_type = OPTI_TYPE_ZERO_BYTE
8074 | OPTI_TYPE_NOT_ITERATED;
8075 dgst_pos0 = 3;
8076 dgst_pos1 = 4;
8077 dgst_pos2 = 2;
8078 dgst_pos3 = 1;
8079 break;
8080
8081 case 200: hash_type = HASH_TYPE_MYSQL;
8082 salt_type = SALT_TYPE_NONE;
8083 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8084 opts_type = 0;
8085 kern_type = KERN_TYPE_MYSQL;
8086 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8087 parse_func = mysql323_parse_hash;
8088 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8089 opti_type = OPTI_TYPE_ZERO_BYTE;
8090 dgst_pos0 = 0;
8091 dgst_pos1 = 1;
8092 dgst_pos2 = 2;
8093 dgst_pos3 = 3;
8094 break;
8095
8096 case 300: hash_type = HASH_TYPE_SHA1;
8097 salt_type = SALT_TYPE_NONE;
8098 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8099 opts_type = OPTS_TYPE_PT_GENERATE_BE
8100 | OPTS_TYPE_PT_ADD80
8101 | OPTS_TYPE_PT_ADDBITS15;
8102 kern_type = KERN_TYPE_MYSQL41;
8103 dgst_size = DGST_SIZE_4_5;
8104 parse_func = sha1_parse_hash;
8105 sort_by_digest = sort_by_digest_4_5;
8106 opti_type = OPTI_TYPE_ZERO_BYTE
8107 | OPTI_TYPE_PRECOMPUTE_INIT
8108 | OPTI_TYPE_PRECOMPUTE_MERKLE
8109 | OPTI_TYPE_EARLY_SKIP
8110 | OPTI_TYPE_NOT_ITERATED
8111 | OPTI_TYPE_NOT_SALTED;
8112 dgst_pos0 = 3;
8113 dgst_pos1 = 4;
8114 dgst_pos2 = 2;
8115 dgst_pos3 = 1;
8116 break;
8117
8118 case 400: hash_type = HASH_TYPE_MD5;
8119 salt_type = SALT_TYPE_EMBEDDED;
8120 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8121 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8122 kern_type = KERN_TYPE_PHPASS;
8123 dgst_size = DGST_SIZE_4_4;
8124 parse_func = phpass_parse_hash;
8125 sort_by_digest = sort_by_digest_4_4;
8126 opti_type = OPTI_TYPE_ZERO_BYTE
8127 | OPTI_TYPE_SLOW_HASH_SIMD;
8128 dgst_pos0 = 0;
8129 dgst_pos1 = 1;
8130 dgst_pos2 = 2;
8131 dgst_pos3 = 3;
8132 break;
8133
8134 case 500: hash_type = HASH_TYPE_MD5;
8135 salt_type = SALT_TYPE_EMBEDDED;
8136 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8137 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8138 kern_type = KERN_TYPE_MD5CRYPT;
8139 dgst_size = DGST_SIZE_4_4;
8140 parse_func = md5crypt_parse_hash;
8141 sort_by_digest = sort_by_digest_4_4;
8142 opti_type = OPTI_TYPE_ZERO_BYTE;
8143 dgst_pos0 = 0;
8144 dgst_pos1 = 1;
8145 dgst_pos2 = 2;
8146 dgst_pos3 = 3;
8147 break;
8148
8149 case 501: hash_type = HASH_TYPE_MD5;
8150 salt_type = SALT_TYPE_EMBEDDED;
8151 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8152 opts_type = OPTS_TYPE_PT_GENERATE_LE
8153 | OPTS_TYPE_HASH_COPY;
8154 kern_type = KERN_TYPE_MD5CRYPT;
8155 dgst_size = DGST_SIZE_4_4;
8156 parse_func = juniper_parse_hash;
8157 sort_by_digest = sort_by_digest_4_4;
8158 opti_type = OPTI_TYPE_ZERO_BYTE;
8159 dgst_pos0 = 0;
8160 dgst_pos1 = 1;
8161 dgst_pos2 = 2;
8162 dgst_pos3 = 3;
8163 break;
8164
8165 case 900: hash_type = HASH_TYPE_MD4;
8166 salt_type = SALT_TYPE_NONE;
8167 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8168 opts_type = OPTS_TYPE_PT_GENERATE_LE
8169 | OPTS_TYPE_PT_ADD80
8170 | OPTS_TYPE_PT_ADDBITS14;
8171 kern_type = KERN_TYPE_MD4;
8172 dgst_size = DGST_SIZE_4_4;
8173 parse_func = md4_parse_hash;
8174 sort_by_digest = sort_by_digest_4_4;
8175 opti_type = OPTI_TYPE_ZERO_BYTE
8176 | OPTI_TYPE_PRECOMPUTE_INIT
8177 | OPTI_TYPE_PRECOMPUTE_MERKLE
8178 | OPTI_TYPE_MEET_IN_MIDDLE
8179 | OPTI_TYPE_EARLY_SKIP
8180 | OPTI_TYPE_NOT_ITERATED
8181 | OPTI_TYPE_NOT_SALTED
8182 | OPTI_TYPE_RAW_HASH;
8183 dgst_pos0 = 0;
8184 dgst_pos1 = 3;
8185 dgst_pos2 = 2;
8186 dgst_pos3 = 1;
8187 break;
8188
8189 case 1000: hash_type = HASH_TYPE_MD4;
8190 salt_type = SALT_TYPE_NONE;
8191 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8192 opts_type = OPTS_TYPE_PT_GENERATE_LE
8193 | OPTS_TYPE_PT_ADD80
8194 | OPTS_TYPE_PT_ADDBITS14
8195 | OPTS_TYPE_PT_UNICODE;
8196 kern_type = KERN_TYPE_MD4_PWU;
8197 dgst_size = DGST_SIZE_4_4;
8198 parse_func = md4_parse_hash;
8199 sort_by_digest = sort_by_digest_4_4;
8200 opti_type = OPTI_TYPE_ZERO_BYTE
8201 | OPTI_TYPE_PRECOMPUTE_INIT
8202 | OPTI_TYPE_PRECOMPUTE_MERKLE
8203 | OPTI_TYPE_MEET_IN_MIDDLE
8204 | OPTI_TYPE_EARLY_SKIP
8205 | OPTI_TYPE_NOT_ITERATED
8206 | OPTI_TYPE_NOT_SALTED
8207 | OPTI_TYPE_RAW_HASH;
8208 dgst_pos0 = 0;
8209 dgst_pos1 = 3;
8210 dgst_pos2 = 2;
8211 dgst_pos3 = 1;
8212 break;
8213
8214 case 1100: hash_type = HASH_TYPE_MD4;
8215 salt_type = SALT_TYPE_INTERN;
8216 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8217 opts_type = OPTS_TYPE_PT_GENERATE_LE
8218 | OPTS_TYPE_PT_ADD80
8219 | OPTS_TYPE_PT_ADDBITS14
8220 | OPTS_TYPE_PT_UNICODE
8221 | OPTS_TYPE_ST_ADD80
8222 | OPTS_TYPE_ST_UNICODE
8223 | OPTS_TYPE_ST_LOWER;
8224 kern_type = KERN_TYPE_MD44_PWUSLT;
8225 dgst_size = DGST_SIZE_4_4;
8226 parse_func = dcc_parse_hash;
8227 sort_by_digest = sort_by_digest_4_4;
8228 opti_type = OPTI_TYPE_ZERO_BYTE
8229 | OPTI_TYPE_PRECOMPUTE_INIT
8230 | OPTI_TYPE_PRECOMPUTE_MERKLE
8231 | OPTI_TYPE_EARLY_SKIP
8232 | OPTI_TYPE_NOT_ITERATED;
8233 dgst_pos0 = 0;
8234 dgst_pos1 = 3;
8235 dgst_pos2 = 2;
8236 dgst_pos3 = 1;
8237 break;
8238
8239 case 1400: hash_type = HASH_TYPE_SHA256;
8240 salt_type = SALT_TYPE_NONE;
8241 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8242 opts_type = OPTS_TYPE_PT_GENERATE_BE
8243 | OPTS_TYPE_PT_ADD80
8244 | OPTS_TYPE_PT_ADDBITS15;
8245 kern_type = KERN_TYPE_SHA256;
8246 dgst_size = DGST_SIZE_4_8;
8247 parse_func = sha256_parse_hash;
8248 sort_by_digest = sort_by_digest_4_8;
8249 opti_type = OPTI_TYPE_ZERO_BYTE
8250 | OPTI_TYPE_PRECOMPUTE_INIT
8251 | OPTI_TYPE_PRECOMPUTE_MERKLE
8252 | OPTI_TYPE_EARLY_SKIP
8253 | OPTI_TYPE_NOT_ITERATED
8254 | OPTI_TYPE_NOT_SALTED
8255 | OPTI_TYPE_RAW_HASH;
8256 dgst_pos0 = 3;
8257 dgst_pos1 = 7;
8258 dgst_pos2 = 2;
8259 dgst_pos3 = 6;
8260 break;
8261
8262 case 1410: hash_type = HASH_TYPE_SHA256;
8263 salt_type = SALT_TYPE_INTERN;
8264 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8265 opts_type = OPTS_TYPE_PT_GENERATE_BE
8266 | OPTS_TYPE_ST_ADD80
8267 | OPTS_TYPE_ST_ADDBITS15;
8268 kern_type = KERN_TYPE_SHA256_PWSLT;
8269 dgst_size = DGST_SIZE_4_8;
8270 parse_func = sha256s_parse_hash;
8271 sort_by_digest = sort_by_digest_4_8;
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 | OPTI_TYPE_APPENDED_SALT
8278 | OPTI_TYPE_RAW_HASH;
8279 dgst_pos0 = 3;
8280 dgst_pos1 = 7;
8281 dgst_pos2 = 2;
8282 dgst_pos3 = 6;
8283 break;
8284
8285 case 1420: hash_type = HASH_TYPE_SHA256;
8286 salt_type = SALT_TYPE_INTERN;
8287 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8288 opts_type = OPTS_TYPE_PT_GENERATE_BE
8289 | OPTS_TYPE_PT_ADD80
8290 | OPTS_TYPE_PT_ADDBITS15;
8291 kern_type = KERN_TYPE_SHA256_SLTPW;
8292 dgst_size = DGST_SIZE_4_8;
8293 parse_func = sha256s_parse_hash;
8294 sort_by_digest = sort_by_digest_4_8;
8295 opti_type = OPTI_TYPE_ZERO_BYTE
8296 | OPTI_TYPE_PRECOMPUTE_INIT
8297 | OPTI_TYPE_PRECOMPUTE_MERKLE
8298 | OPTI_TYPE_EARLY_SKIP
8299 | OPTI_TYPE_NOT_ITERATED
8300 | OPTI_TYPE_PREPENDED_SALT
8301 | OPTI_TYPE_RAW_HASH;
8302 dgst_pos0 = 3;
8303 dgst_pos1 = 7;
8304 dgst_pos2 = 2;
8305 dgst_pos3 = 6;
8306 break;
8307
8308 case 1421: hash_type = HASH_TYPE_SHA256;
8309 salt_type = SALT_TYPE_EMBEDDED;
8310 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8311 opts_type = OPTS_TYPE_PT_GENERATE_BE
8312 | OPTS_TYPE_PT_ADD80
8313 | OPTS_TYPE_PT_ADDBITS15;
8314 kern_type = KERN_TYPE_SHA256_SLTPW;
8315 dgst_size = DGST_SIZE_4_8;
8316 parse_func = hmailserver_parse_hash;
8317 sort_by_digest = sort_by_digest_4_8;
8318 opti_type = OPTI_TYPE_ZERO_BYTE
8319 | OPTI_TYPE_PRECOMPUTE_INIT
8320 | OPTI_TYPE_PRECOMPUTE_MERKLE
8321 | OPTI_TYPE_EARLY_SKIP
8322 | OPTI_TYPE_NOT_ITERATED
8323 | OPTI_TYPE_PREPENDED_SALT
8324 | OPTI_TYPE_RAW_HASH;
8325 dgst_pos0 = 3;
8326 dgst_pos1 = 7;
8327 dgst_pos2 = 2;
8328 dgst_pos3 = 6;
8329 break;
8330
8331 case 1430: hash_type = HASH_TYPE_SHA256;
8332 salt_type = SALT_TYPE_INTERN;
8333 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8334 opts_type = OPTS_TYPE_PT_GENERATE_BE
8335 | OPTS_TYPE_PT_UNICODE
8336 | OPTS_TYPE_ST_ADD80
8337 | OPTS_TYPE_ST_ADDBITS15;
8338 kern_type = KERN_TYPE_SHA256_PWUSLT;
8339 dgst_size = DGST_SIZE_4_8;
8340 parse_func = sha256s_parse_hash;
8341 sort_by_digest = sort_by_digest_4_8;
8342 opti_type = OPTI_TYPE_ZERO_BYTE
8343 | OPTI_TYPE_PRECOMPUTE_INIT
8344 | OPTI_TYPE_PRECOMPUTE_MERKLE
8345 | OPTI_TYPE_EARLY_SKIP
8346 | OPTI_TYPE_NOT_ITERATED
8347 | OPTI_TYPE_APPENDED_SALT
8348 | OPTI_TYPE_RAW_HASH;
8349 dgst_pos0 = 3;
8350 dgst_pos1 = 7;
8351 dgst_pos2 = 2;
8352 dgst_pos3 = 6;
8353 break;
8354
8355 case 1440: hash_type = HASH_TYPE_SHA256;
8356 salt_type = SALT_TYPE_INTERN;
8357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8358 opts_type = OPTS_TYPE_PT_GENERATE_BE
8359 | OPTS_TYPE_PT_ADD80
8360 | OPTS_TYPE_PT_ADDBITS15
8361 | OPTS_TYPE_PT_UNICODE;
8362 kern_type = KERN_TYPE_SHA256_SLTPWU;
8363 dgst_size = DGST_SIZE_4_8;
8364 parse_func = sha256s_parse_hash;
8365 sort_by_digest = sort_by_digest_4_8;
8366 opti_type = OPTI_TYPE_ZERO_BYTE
8367 | OPTI_TYPE_PRECOMPUTE_INIT
8368 | OPTI_TYPE_PRECOMPUTE_MERKLE
8369 | OPTI_TYPE_EARLY_SKIP
8370 | OPTI_TYPE_NOT_ITERATED
8371 | OPTI_TYPE_PREPENDED_SALT
8372 | OPTI_TYPE_RAW_HASH;
8373 dgst_pos0 = 3;
8374 dgst_pos1 = 7;
8375 dgst_pos2 = 2;
8376 dgst_pos3 = 6;
8377 break;
8378
8379 case 1441: hash_type = HASH_TYPE_SHA256;
8380 salt_type = SALT_TYPE_EMBEDDED;
8381 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8382 opts_type = OPTS_TYPE_PT_GENERATE_BE
8383 | OPTS_TYPE_PT_ADD80
8384 | OPTS_TYPE_PT_ADDBITS15
8385 | OPTS_TYPE_PT_UNICODE
8386 | OPTS_TYPE_ST_BASE64;
8387 kern_type = KERN_TYPE_SHA256_SLTPWU;
8388 dgst_size = DGST_SIZE_4_8;
8389 parse_func = episerver4_parse_hash;
8390 sort_by_digest = sort_by_digest_4_8;
8391 opti_type = OPTI_TYPE_ZERO_BYTE
8392 | OPTI_TYPE_PRECOMPUTE_INIT
8393 | OPTI_TYPE_PRECOMPUTE_MERKLE
8394 | OPTI_TYPE_EARLY_SKIP
8395 | OPTI_TYPE_NOT_ITERATED
8396 | OPTI_TYPE_PREPENDED_SALT
8397 | OPTI_TYPE_RAW_HASH;
8398 dgst_pos0 = 3;
8399 dgst_pos1 = 7;
8400 dgst_pos2 = 2;
8401 dgst_pos3 = 6;
8402 break;
8403
8404 case 1450: hash_type = HASH_TYPE_SHA256;
8405 salt_type = SALT_TYPE_INTERN;
8406 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8407 opts_type = OPTS_TYPE_PT_GENERATE_BE
8408 | OPTS_TYPE_ST_ADD80;
8409 kern_type = KERN_TYPE_HMACSHA256_PW;
8410 dgst_size = DGST_SIZE_4_8;
8411 parse_func = hmacsha256_parse_hash;
8412 sort_by_digest = sort_by_digest_4_8;
8413 opti_type = OPTI_TYPE_ZERO_BYTE
8414 | OPTI_TYPE_NOT_ITERATED;
8415 dgst_pos0 = 3;
8416 dgst_pos1 = 7;
8417 dgst_pos2 = 2;
8418 dgst_pos3 = 6;
8419 break;
8420
8421 case 1460: hash_type = HASH_TYPE_SHA256;
8422 salt_type = SALT_TYPE_INTERN;
8423 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8424 opts_type = OPTS_TYPE_PT_GENERATE_BE
8425 | OPTS_TYPE_PT_ADD80
8426 | OPTS_TYPE_PT_ADDBITS15;
8427 kern_type = KERN_TYPE_HMACSHA256_SLT;
8428 dgst_size = DGST_SIZE_4_8;
8429 parse_func = hmacsha256_parse_hash;
8430 sort_by_digest = sort_by_digest_4_8;
8431 opti_type = OPTI_TYPE_ZERO_BYTE
8432 | OPTI_TYPE_NOT_ITERATED;
8433 dgst_pos0 = 3;
8434 dgst_pos1 = 7;
8435 dgst_pos2 = 2;
8436 dgst_pos3 = 6;
8437 break;
8438
8439 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8440 salt_type = SALT_TYPE_EMBEDDED;
8441 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8442 opts_type = OPTS_TYPE_PT_GENERATE_LE
8443 | OPTS_TYPE_PT_BITSLICE;
8444 kern_type = KERN_TYPE_DESCRYPT;
8445 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8446 parse_func = descrypt_parse_hash;
8447 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8448 opti_type = OPTI_TYPE_ZERO_BYTE
8449 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8450 dgst_pos0 = 0;
8451 dgst_pos1 = 1;
8452 dgst_pos2 = 2;
8453 dgst_pos3 = 3;
8454 break;
8455
8456 case 1600: hash_type = HASH_TYPE_MD5;
8457 salt_type = SALT_TYPE_EMBEDDED;
8458 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8459 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8460 kern_type = KERN_TYPE_APR1CRYPT;
8461 dgst_size = DGST_SIZE_4_4;
8462 parse_func = md5apr1_parse_hash;
8463 sort_by_digest = sort_by_digest_4_4;
8464 opti_type = OPTI_TYPE_ZERO_BYTE;
8465 dgst_pos0 = 0;
8466 dgst_pos1 = 1;
8467 dgst_pos2 = 2;
8468 dgst_pos3 = 3;
8469 break;
8470
8471 case 1700: hash_type = HASH_TYPE_SHA512;
8472 salt_type = SALT_TYPE_NONE;
8473 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8474 opts_type = OPTS_TYPE_PT_GENERATE_BE
8475 | OPTS_TYPE_PT_ADD80
8476 | OPTS_TYPE_PT_ADDBITS15;
8477 kern_type = KERN_TYPE_SHA512;
8478 dgst_size = DGST_SIZE_8_8;
8479 parse_func = sha512_parse_hash;
8480 sort_by_digest = sort_by_digest_8_8;
8481 opti_type = OPTI_TYPE_ZERO_BYTE
8482 | OPTI_TYPE_PRECOMPUTE_INIT
8483 | OPTI_TYPE_PRECOMPUTE_MERKLE
8484 | OPTI_TYPE_EARLY_SKIP
8485 | OPTI_TYPE_NOT_ITERATED
8486 | OPTI_TYPE_NOT_SALTED
8487 | OPTI_TYPE_USES_BITS_64
8488 | OPTI_TYPE_RAW_HASH;
8489 dgst_pos0 = 14;
8490 dgst_pos1 = 15;
8491 dgst_pos2 = 6;
8492 dgst_pos3 = 7;
8493 break;
8494
8495 case 1710: hash_type = HASH_TYPE_SHA512;
8496 salt_type = SALT_TYPE_INTERN;
8497 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8498 opts_type = OPTS_TYPE_PT_GENERATE_BE
8499 | OPTS_TYPE_ST_ADD80
8500 | OPTS_TYPE_ST_ADDBITS15;
8501 kern_type = KERN_TYPE_SHA512_PWSLT;
8502 dgst_size = DGST_SIZE_8_8;
8503 parse_func = sha512s_parse_hash;
8504 sort_by_digest = sort_by_digest_8_8;
8505 opti_type = OPTI_TYPE_ZERO_BYTE
8506 | OPTI_TYPE_PRECOMPUTE_INIT
8507 | OPTI_TYPE_PRECOMPUTE_MERKLE
8508 | OPTI_TYPE_EARLY_SKIP
8509 | OPTI_TYPE_NOT_ITERATED
8510 | OPTI_TYPE_APPENDED_SALT
8511 | OPTI_TYPE_USES_BITS_64
8512 | OPTI_TYPE_RAW_HASH;
8513 dgst_pos0 = 14;
8514 dgst_pos1 = 15;
8515 dgst_pos2 = 6;
8516 dgst_pos3 = 7;
8517 break;
8518
8519 case 1711: hash_type = HASH_TYPE_SHA512;
8520 salt_type = SALT_TYPE_EMBEDDED;
8521 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8522 opts_type = OPTS_TYPE_PT_GENERATE_BE
8523 | OPTS_TYPE_ST_ADD80
8524 | OPTS_TYPE_ST_ADDBITS15;
8525 kern_type = KERN_TYPE_SHA512_PWSLT;
8526 dgst_size = DGST_SIZE_8_8;
8527 parse_func = sha512b64s_parse_hash;
8528 sort_by_digest = sort_by_digest_8_8;
8529 opti_type = OPTI_TYPE_ZERO_BYTE
8530 | OPTI_TYPE_PRECOMPUTE_INIT
8531 | OPTI_TYPE_PRECOMPUTE_MERKLE
8532 | OPTI_TYPE_EARLY_SKIP
8533 | OPTI_TYPE_NOT_ITERATED
8534 | OPTI_TYPE_APPENDED_SALT
8535 | OPTI_TYPE_USES_BITS_64
8536 | OPTI_TYPE_RAW_HASH;
8537 dgst_pos0 = 14;
8538 dgst_pos1 = 15;
8539 dgst_pos2 = 6;
8540 dgst_pos3 = 7;
8541 break;
8542
8543 case 1720: hash_type = HASH_TYPE_SHA512;
8544 salt_type = SALT_TYPE_INTERN;
8545 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8546 opts_type = OPTS_TYPE_PT_GENERATE_BE
8547 | OPTS_TYPE_PT_ADD80
8548 | OPTS_TYPE_PT_ADDBITS15;
8549 kern_type = KERN_TYPE_SHA512_SLTPW;
8550 dgst_size = DGST_SIZE_8_8;
8551 parse_func = sha512s_parse_hash;
8552 sort_by_digest = sort_by_digest_8_8;
8553 opti_type = OPTI_TYPE_ZERO_BYTE
8554 | OPTI_TYPE_PRECOMPUTE_INIT
8555 | OPTI_TYPE_PRECOMPUTE_MERKLE
8556 | OPTI_TYPE_EARLY_SKIP
8557 | OPTI_TYPE_NOT_ITERATED
8558 | OPTI_TYPE_PREPENDED_SALT
8559 | OPTI_TYPE_USES_BITS_64
8560 | OPTI_TYPE_RAW_HASH;
8561 dgst_pos0 = 14;
8562 dgst_pos1 = 15;
8563 dgst_pos2 = 6;
8564 dgst_pos3 = 7;
8565 break;
8566
8567 case 1722: hash_type = HASH_TYPE_SHA512;
8568 salt_type = SALT_TYPE_EMBEDDED;
8569 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8570 opts_type = OPTS_TYPE_PT_GENERATE_BE
8571 | OPTS_TYPE_PT_ADD80
8572 | OPTS_TYPE_PT_ADDBITS15
8573 | OPTS_TYPE_ST_HEX;
8574 kern_type = KERN_TYPE_SHA512_SLTPW;
8575 dgst_size = DGST_SIZE_8_8;
8576 parse_func = osx512_parse_hash;
8577 sort_by_digest = sort_by_digest_8_8;
8578 opti_type = OPTI_TYPE_ZERO_BYTE
8579 | OPTI_TYPE_PRECOMPUTE_INIT
8580 | OPTI_TYPE_PRECOMPUTE_MERKLE
8581 | OPTI_TYPE_EARLY_SKIP
8582 | OPTI_TYPE_NOT_ITERATED
8583 | OPTI_TYPE_PREPENDED_SALT
8584 | OPTI_TYPE_USES_BITS_64
8585 | OPTI_TYPE_RAW_HASH;
8586 dgst_pos0 = 14;
8587 dgst_pos1 = 15;
8588 dgst_pos2 = 6;
8589 dgst_pos3 = 7;
8590 break;
8591
8592 case 1730: hash_type = HASH_TYPE_SHA512;
8593 salt_type = SALT_TYPE_INTERN;
8594 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8595 opts_type = OPTS_TYPE_PT_GENERATE_BE
8596 | OPTS_TYPE_PT_UNICODE
8597 | OPTS_TYPE_ST_ADD80
8598 | OPTS_TYPE_ST_ADDBITS15;
8599 kern_type = KERN_TYPE_SHA512_PWSLTU;
8600 dgst_size = DGST_SIZE_8_8;
8601 parse_func = sha512s_parse_hash;
8602 sort_by_digest = sort_by_digest_8_8;
8603 opti_type = OPTI_TYPE_ZERO_BYTE
8604 | OPTI_TYPE_PRECOMPUTE_INIT
8605 | OPTI_TYPE_PRECOMPUTE_MERKLE
8606 | OPTI_TYPE_EARLY_SKIP
8607 | OPTI_TYPE_NOT_ITERATED
8608 | OPTI_TYPE_APPENDED_SALT
8609 | OPTI_TYPE_USES_BITS_64
8610 | OPTI_TYPE_RAW_HASH;
8611 dgst_pos0 = 14;
8612 dgst_pos1 = 15;
8613 dgst_pos2 = 6;
8614 dgst_pos3 = 7;
8615 break;
8616
8617 case 1731: hash_type = HASH_TYPE_SHA512;
8618 salt_type = SALT_TYPE_EMBEDDED;
8619 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8620 opts_type = OPTS_TYPE_PT_GENERATE_BE
8621 | OPTS_TYPE_PT_UNICODE
8622 | OPTS_TYPE_ST_ADD80
8623 | OPTS_TYPE_ST_ADDBITS15
8624 | OPTS_TYPE_ST_HEX;
8625 kern_type = KERN_TYPE_SHA512_PWSLTU;
8626 dgst_size = DGST_SIZE_8_8;
8627 parse_func = mssql2012_parse_hash;
8628 sort_by_digest = sort_by_digest_8_8;
8629 opti_type = OPTI_TYPE_ZERO_BYTE
8630 | OPTI_TYPE_PRECOMPUTE_INIT
8631 | OPTI_TYPE_PRECOMPUTE_MERKLE
8632 | OPTI_TYPE_EARLY_SKIP
8633 | OPTI_TYPE_NOT_ITERATED
8634 | OPTI_TYPE_APPENDED_SALT
8635 | OPTI_TYPE_USES_BITS_64
8636 | OPTI_TYPE_RAW_HASH;
8637 dgst_pos0 = 14;
8638 dgst_pos1 = 15;
8639 dgst_pos2 = 6;
8640 dgst_pos3 = 7;
8641 break;
8642
8643 case 1740: hash_type = HASH_TYPE_SHA512;
8644 salt_type = SALT_TYPE_INTERN;
8645 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8646 opts_type = OPTS_TYPE_PT_GENERATE_BE
8647 | OPTS_TYPE_PT_ADD80
8648 | OPTS_TYPE_PT_ADDBITS15
8649 | OPTS_TYPE_PT_UNICODE;
8650 kern_type = KERN_TYPE_SHA512_SLTPWU;
8651 dgst_size = DGST_SIZE_8_8;
8652 parse_func = sha512s_parse_hash;
8653 sort_by_digest = sort_by_digest_8_8;
8654 opti_type = OPTI_TYPE_ZERO_BYTE
8655 | OPTI_TYPE_PRECOMPUTE_INIT
8656 | OPTI_TYPE_PRECOMPUTE_MERKLE
8657 | OPTI_TYPE_EARLY_SKIP
8658 | OPTI_TYPE_NOT_ITERATED
8659 | OPTI_TYPE_PREPENDED_SALT
8660 | OPTI_TYPE_USES_BITS_64
8661 | OPTI_TYPE_RAW_HASH;
8662 dgst_pos0 = 14;
8663 dgst_pos1 = 15;
8664 dgst_pos2 = 6;
8665 dgst_pos3 = 7;
8666 break;
8667
8668 case 1750: hash_type = HASH_TYPE_SHA512;
8669 salt_type = SALT_TYPE_INTERN;
8670 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8671 opts_type = OPTS_TYPE_PT_GENERATE_BE
8672 | OPTS_TYPE_ST_ADD80;
8673 kern_type = KERN_TYPE_HMACSHA512_PW;
8674 dgst_size = DGST_SIZE_8_8;
8675 parse_func = hmacsha512_parse_hash;
8676 sort_by_digest = sort_by_digest_8_8;
8677 opti_type = OPTI_TYPE_ZERO_BYTE
8678 | OPTI_TYPE_USES_BITS_64
8679 | OPTI_TYPE_NOT_ITERATED;
8680 dgst_pos0 = 14;
8681 dgst_pos1 = 15;
8682 dgst_pos2 = 6;
8683 dgst_pos3 = 7;
8684 break;
8685
8686 case 1760: hash_type = HASH_TYPE_SHA512;
8687 salt_type = SALT_TYPE_INTERN;
8688 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8689 opts_type = OPTS_TYPE_PT_GENERATE_BE
8690 | OPTS_TYPE_PT_ADD80
8691 | OPTS_TYPE_PT_ADDBITS15;
8692 kern_type = KERN_TYPE_HMACSHA512_SLT;
8693 dgst_size = DGST_SIZE_8_8;
8694 parse_func = hmacsha512_parse_hash;
8695 sort_by_digest = sort_by_digest_8_8;
8696 opti_type = OPTI_TYPE_ZERO_BYTE
8697 | OPTI_TYPE_USES_BITS_64
8698 | OPTI_TYPE_NOT_ITERATED;
8699 dgst_pos0 = 14;
8700 dgst_pos1 = 15;
8701 dgst_pos2 = 6;
8702 dgst_pos3 = 7;
8703 break;
8704
8705 case 1800: hash_type = HASH_TYPE_SHA512;
8706 salt_type = SALT_TYPE_EMBEDDED;
8707 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8708 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8709 kern_type = KERN_TYPE_SHA512CRYPT;
8710 dgst_size = DGST_SIZE_8_8;
8711 parse_func = sha512crypt_parse_hash;
8712 sort_by_digest = sort_by_digest_8_8;
8713 opti_type = OPTI_TYPE_ZERO_BYTE
8714 | OPTI_TYPE_USES_BITS_64;
8715 dgst_pos0 = 0;
8716 dgst_pos1 = 1;
8717 dgst_pos2 = 2;
8718 dgst_pos3 = 3;
8719 break;
8720
8721 case 2000: hash_type = HASH_TYPE_STDOUT;
8722 salt_type = SALT_TYPE_NONE;
8723 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8724 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8725 kern_type = KERN_TYPE_STDOUT;
8726 dgst_size = DGST_SIZE_4_4;
8727 parse_func = NULL;
8728 sort_by_digest = NULL;
8729 opti_type = 0;
8730 dgst_pos0 = 0;
8731 dgst_pos1 = 0;
8732 dgst_pos2 = 0;
8733 dgst_pos3 = 0;
8734 break;
8735
8736 case 2100: hash_type = HASH_TYPE_DCC2;
8737 salt_type = SALT_TYPE_EMBEDDED;
8738 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8739 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8740 | OPTS_TYPE_ST_LOWER
8741 | OPTS_TYPE_ST_UNICODE;
8742 kern_type = KERN_TYPE_DCC2;
8743 dgst_size = DGST_SIZE_4_4;
8744 parse_func = dcc2_parse_hash;
8745 sort_by_digest = sort_by_digest_4_4;
8746 opti_type = OPTI_TYPE_ZERO_BYTE
8747 | OPTI_TYPE_SLOW_HASH_SIMD;
8748 dgst_pos0 = 0;
8749 dgst_pos1 = 1;
8750 dgst_pos2 = 2;
8751 dgst_pos3 = 3;
8752 break;
8753
8754 case 2400: hash_type = HASH_TYPE_MD5;
8755 salt_type = SALT_TYPE_NONE;
8756 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8757 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8758 kern_type = KERN_TYPE_MD5PIX;
8759 dgst_size = DGST_SIZE_4_4;
8760 parse_func = md5pix_parse_hash;
8761 sort_by_digest = sort_by_digest_4_4;
8762 opti_type = OPTI_TYPE_ZERO_BYTE
8763 | OPTI_TYPE_PRECOMPUTE_INIT
8764 | OPTI_TYPE_PRECOMPUTE_MERKLE
8765 | OPTI_TYPE_EARLY_SKIP
8766 | OPTI_TYPE_NOT_ITERATED
8767 | OPTI_TYPE_NOT_SALTED;
8768 dgst_pos0 = 0;
8769 dgst_pos1 = 3;
8770 dgst_pos2 = 2;
8771 dgst_pos3 = 1;
8772 break;
8773
8774 case 2410: hash_type = HASH_TYPE_MD5;
8775 salt_type = SALT_TYPE_INTERN;
8776 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8777 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8778 kern_type = KERN_TYPE_MD5ASA;
8779 dgst_size = DGST_SIZE_4_4;
8780 parse_func = md5asa_parse_hash;
8781 sort_by_digest = sort_by_digest_4_4;
8782 opti_type = OPTI_TYPE_ZERO_BYTE
8783 | OPTI_TYPE_PRECOMPUTE_INIT
8784 | OPTI_TYPE_PRECOMPUTE_MERKLE
8785 | OPTI_TYPE_EARLY_SKIP
8786 | OPTI_TYPE_NOT_ITERATED;
8787 dgst_pos0 = 0;
8788 dgst_pos1 = 3;
8789 dgst_pos2 = 2;
8790 dgst_pos3 = 1;
8791 break;
8792
8793 case 2500: hash_type = HASH_TYPE_WPA;
8794 salt_type = SALT_TYPE_EMBEDDED;
8795 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8796 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8797 kern_type = KERN_TYPE_WPA;
8798 dgst_size = DGST_SIZE_4_4;
8799 parse_func = wpa_parse_hash;
8800 sort_by_digest = sort_by_digest_4_4;
8801 opti_type = OPTI_TYPE_ZERO_BYTE
8802 | OPTI_TYPE_SLOW_HASH_SIMD;
8803 dgst_pos0 = 0;
8804 dgst_pos1 = 1;
8805 dgst_pos2 = 2;
8806 dgst_pos3 = 3;
8807 break;
8808
8809 case 2600: hash_type = HASH_TYPE_MD5;
8810 salt_type = SALT_TYPE_VIRTUAL;
8811 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8812 opts_type = OPTS_TYPE_PT_GENERATE_LE
8813 | OPTS_TYPE_PT_ADD80
8814 | OPTS_TYPE_PT_ADDBITS14
8815 | OPTS_TYPE_ST_ADD80;
8816 kern_type = KERN_TYPE_MD55_PWSLT1;
8817 dgst_size = DGST_SIZE_4_4;
8818 parse_func = md5md5_parse_hash;
8819 sort_by_digest = sort_by_digest_4_4;
8820 opti_type = OPTI_TYPE_ZERO_BYTE
8821 | OPTI_TYPE_PRECOMPUTE_INIT
8822 | OPTI_TYPE_PRECOMPUTE_MERKLE
8823 | OPTI_TYPE_EARLY_SKIP;
8824 dgst_pos0 = 0;
8825 dgst_pos1 = 3;
8826 dgst_pos2 = 2;
8827 dgst_pos3 = 1;
8828 break;
8829
8830 case 2611: hash_type = HASH_TYPE_MD5;
8831 salt_type = SALT_TYPE_INTERN;
8832 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8833 opts_type = OPTS_TYPE_PT_GENERATE_LE
8834 | OPTS_TYPE_PT_ADD80
8835 | OPTS_TYPE_PT_ADDBITS14
8836 | OPTS_TYPE_ST_ADD80;
8837 kern_type = KERN_TYPE_MD55_PWSLT1;
8838 dgst_size = DGST_SIZE_4_4;
8839 parse_func = vb3_parse_hash;
8840 sort_by_digest = sort_by_digest_4_4;
8841 opti_type = OPTI_TYPE_ZERO_BYTE
8842 | OPTI_TYPE_PRECOMPUTE_INIT
8843 | OPTI_TYPE_PRECOMPUTE_MERKLE
8844 | OPTI_TYPE_EARLY_SKIP;
8845 dgst_pos0 = 0;
8846 dgst_pos1 = 3;
8847 dgst_pos2 = 2;
8848 dgst_pos3 = 1;
8849 break;
8850
8851 case 2612: hash_type = HASH_TYPE_MD5;
8852 salt_type = SALT_TYPE_EMBEDDED;
8853 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8854 opts_type = OPTS_TYPE_PT_GENERATE_LE
8855 | OPTS_TYPE_PT_ADD80
8856 | OPTS_TYPE_PT_ADDBITS14
8857 | OPTS_TYPE_ST_ADD80
8858 | OPTS_TYPE_ST_HEX;
8859 kern_type = KERN_TYPE_MD55_PWSLT1;
8860 dgst_size = DGST_SIZE_4_4;
8861 parse_func = phps_parse_hash;
8862 sort_by_digest = sort_by_digest_4_4;
8863 opti_type = OPTI_TYPE_ZERO_BYTE
8864 | OPTI_TYPE_PRECOMPUTE_INIT
8865 | OPTI_TYPE_PRECOMPUTE_MERKLE
8866 | OPTI_TYPE_EARLY_SKIP;
8867 dgst_pos0 = 0;
8868 dgst_pos1 = 3;
8869 dgst_pos2 = 2;
8870 dgst_pos3 = 1;
8871 break;
8872
8873 case 2711: hash_type = HASH_TYPE_MD5;
8874 salt_type = SALT_TYPE_INTERN;
8875 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8876 opts_type = OPTS_TYPE_PT_GENERATE_LE
8877 | OPTS_TYPE_PT_ADD80
8878 | OPTS_TYPE_PT_ADDBITS14
8879 | OPTS_TYPE_ST_ADD80;
8880 kern_type = KERN_TYPE_MD55_PWSLT2;
8881 dgst_size = DGST_SIZE_4_4;
8882 parse_func = vb30_parse_hash;
8883 sort_by_digest = sort_by_digest_4_4;
8884 opti_type = OPTI_TYPE_ZERO_BYTE
8885 | OPTI_TYPE_PRECOMPUTE_INIT
8886 | OPTI_TYPE_EARLY_SKIP;
8887 dgst_pos0 = 0;
8888 dgst_pos1 = 3;
8889 dgst_pos2 = 2;
8890 dgst_pos3 = 1;
8891 break;
8892
8893 case 2811: hash_type = HASH_TYPE_MD5;
8894 salt_type = SALT_TYPE_INTERN;
8895 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8896 opts_type = OPTS_TYPE_PT_GENERATE_LE
8897 | OPTS_TYPE_PT_ADD80
8898 | OPTS_TYPE_PT_ADDBITS14;
8899 kern_type = KERN_TYPE_MD55_SLTPW;
8900 dgst_size = DGST_SIZE_4_4;
8901 parse_func = ipb2_parse_hash;
8902 sort_by_digest = sort_by_digest_4_4;
8903 opti_type = OPTI_TYPE_ZERO_BYTE
8904 | OPTI_TYPE_PRECOMPUTE_INIT
8905 | OPTI_TYPE_EARLY_SKIP;
8906 dgst_pos0 = 0;
8907 dgst_pos1 = 3;
8908 dgst_pos2 = 2;
8909 dgst_pos3 = 1;
8910 break;
8911
8912 case 3000: hash_type = HASH_TYPE_LM;
8913 salt_type = SALT_TYPE_NONE;
8914 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8915 opts_type = OPTS_TYPE_PT_GENERATE_LE
8916 | OPTS_TYPE_PT_UPPER
8917 | OPTS_TYPE_PT_BITSLICE;
8918 kern_type = KERN_TYPE_LM;
8919 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8920 parse_func = lm_parse_hash;
8921 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8922 opti_type = OPTI_TYPE_ZERO_BYTE
8923 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8924 dgst_pos0 = 0;
8925 dgst_pos1 = 1;
8926 dgst_pos2 = 2;
8927 dgst_pos3 = 3;
8928 break;
8929
8930 case 3100: hash_type = HASH_TYPE_ORACLEH;
8931 salt_type = SALT_TYPE_INTERN;
8932 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8933 opts_type = OPTS_TYPE_PT_GENERATE_LE
8934 | OPTS_TYPE_PT_UPPER
8935 | OPTS_TYPE_ST_UPPER;
8936 kern_type = KERN_TYPE_ORACLEH;
8937 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8938 parse_func = oracleh_parse_hash;
8939 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8940 opti_type = OPTI_TYPE_ZERO_BYTE;
8941 dgst_pos0 = 0;
8942 dgst_pos1 = 1;
8943 dgst_pos2 = 2;
8944 dgst_pos3 = 3;
8945 break;
8946
8947 case 3200: hash_type = HASH_TYPE_BCRYPT;
8948 salt_type = SALT_TYPE_EMBEDDED;
8949 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8950 opts_type = OPTS_TYPE_PT_GENERATE_LE
8951 | OPTS_TYPE_ST_GENERATE_LE;
8952 kern_type = KERN_TYPE_BCRYPT;
8953 dgst_size = DGST_SIZE_4_6;
8954 parse_func = bcrypt_parse_hash;
8955 sort_by_digest = sort_by_digest_4_6;
8956 opti_type = OPTI_TYPE_ZERO_BYTE;
8957 dgst_pos0 = 0;
8958 dgst_pos1 = 1;
8959 dgst_pos2 = 2;
8960 dgst_pos3 = 3;
8961 break;
8962
8963 case 3710: hash_type = HASH_TYPE_MD5;
8964 salt_type = SALT_TYPE_INTERN;
8965 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8966 opts_type = OPTS_TYPE_PT_GENERATE_LE
8967 | OPTS_TYPE_PT_ADD80
8968 | OPTS_TYPE_PT_ADDBITS14;
8969 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8970 dgst_size = DGST_SIZE_4_4;
8971 parse_func = md5s_parse_hash;
8972 sort_by_digest = sort_by_digest_4_4;
8973 opti_type = OPTI_TYPE_ZERO_BYTE
8974 | OPTI_TYPE_PRECOMPUTE_INIT
8975 | OPTI_TYPE_PRECOMPUTE_MERKLE
8976 | OPTI_TYPE_EARLY_SKIP;
8977 dgst_pos0 = 0;
8978 dgst_pos1 = 3;
8979 dgst_pos2 = 2;
8980 dgst_pos3 = 1;
8981 break;
8982
8983 case 3711: hash_type = HASH_TYPE_MD5;
8984 salt_type = SALT_TYPE_EMBEDDED;
8985 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8986 opts_type = OPTS_TYPE_PT_GENERATE_LE
8987 | OPTS_TYPE_PT_ADD80
8988 | OPTS_TYPE_PT_ADDBITS14;
8989 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8990 dgst_size = DGST_SIZE_4_4;
8991 parse_func = mediawiki_b_parse_hash;
8992 sort_by_digest = sort_by_digest_4_4;
8993 opti_type = OPTI_TYPE_ZERO_BYTE
8994 | OPTI_TYPE_PRECOMPUTE_INIT
8995 | OPTI_TYPE_PRECOMPUTE_MERKLE
8996 | OPTI_TYPE_EARLY_SKIP;
8997 dgst_pos0 = 0;
8998 dgst_pos1 = 3;
8999 dgst_pos2 = 2;
9000 dgst_pos3 = 1;
9001 break;
9002
9003 case 3800: hash_type = HASH_TYPE_MD5;
9004 salt_type = SALT_TYPE_INTERN;
9005 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9006 opts_type = OPTS_TYPE_PT_GENERATE_LE
9007 | OPTS_TYPE_ST_ADDBITS14;
9008 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
9009 dgst_size = DGST_SIZE_4_4;
9010 parse_func = md5s_parse_hash;
9011 sort_by_digest = sort_by_digest_4_4;
9012 opti_type = OPTI_TYPE_ZERO_BYTE
9013 | OPTI_TYPE_PRECOMPUTE_INIT
9014 | OPTI_TYPE_PRECOMPUTE_MERKLE
9015 | OPTI_TYPE_EARLY_SKIP
9016 | OPTI_TYPE_NOT_ITERATED
9017 | OPTI_TYPE_RAW_HASH;
9018 dgst_pos0 = 0;
9019 dgst_pos1 = 3;
9020 dgst_pos2 = 2;
9021 dgst_pos3 = 1;
9022 break;
9023
9024 case 4300: hash_type = HASH_TYPE_MD5;
9025 salt_type = SALT_TYPE_VIRTUAL;
9026 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9027 opts_type = OPTS_TYPE_PT_GENERATE_LE
9028 | OPTS_TYPE_PT_ADD80
9029 | OPTS_TYPE_PT_ADDBITS14
9030 | OPTS_TYPE_ST_ADD80;
9031 kern_type = KERN_TYPE_MD5U5_PWSLT1;
9032 dgst_size = DGST_SIZE_4_4;
9033 parse_func = md5md5_parse_hash;
9034 sort_by_digest = sort_by_digest_4_4;
9035 opti_type = OPTI_TYPE_ZERO_BYTE
9036 | OPTI_TYPE_PRECOMPUTE_INIT
9037 | OPTI_TYPE_PRECOMPUTE_MERKLE
9038 | OPTI_TYPE_EARLY_SKIP;
9039 dgst_pos0 = 0;
9040 dgst_pos1 = 3;
9041 dgst_pos2 = 2;
9042 dgst_pos3 = 1;
9043 break;
9044
9045
9046 case 4400: hash_type = HASH_TYPE_MD5;
9047 salt_type = SALT_TYPE_NONE;
9048 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9049 opts_type = OPTS_TYPE_PT_GENERATE_BE
9050 | OPTS_TYPE_PT_ADD80
9051 | OPTS_TYPE_PT_ADDBITS15;
9052 kern_type = KERN_TYPE_MD5_SHA1;
9053 dgst_size = DGST_SIZE_4_4;
9054 parse_func = md5_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_NOT_SALTED
9062 | OPTI_TYPE_RAW_HASH;
9063 dgst_pos0 = 0;
9064 dgst_pos1 = 3;
9065 dgst_pos2 = 2;
9066 dgst_pos3 = 1;
9067 break;
9068
9069 case 4500: hash_type = HASH_TYPE_SHA1;
9070 salt_type = SALT_TYPE_NONE;
9071 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9072 opts_type = OPTS_TYPE_PT_GENERATE_BE
9073 | OPTS_TYPE_PT_ADD80
9074 | OPTS_TYPE_PT_ADDBITS15;
9075 kern_type = KERN_TYPE_SHA11;
9076 dgst_size = DGST_SIZE_4_5;
9077 parse_func = sha1_parse_hash;
9078 sort_by_digest = sort_by_digest_4_5;
9079 opti_type = OPTI_TYPE_ZERO_BYTE
9080 | OPTI_TYPE_PRECOMPUTE_INIT
9081 | OPTI_TYPE_PRECOMPUTE_MERKLE
9082 | OPTI_TYPE_EARLY_SKIP
9083 | OPTI_TYPE_NOT_SALTED;
9084 dgst_pos0 = 3;
9085 dgst_pos1 = 4;
9086 dgst_pos2 = 2;
9087 dgst_pos3 = 1;
9088 break;
9089
9090 case 4700: hash_type = HASH_TYPE_SHA1;
9091 salt_type = SALT_TYPE_NONE;
9092 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9093 opts_type = OPTS_TYPE_PT_GENERATE_LE
9094 | OPTS_TYPE_PT_ADD80
9095 | OPTS_TYPE_PT_ADDBITS14;
9096 kern_type = KERN_TYPE_SHA1_MD5;
9097 dgst_size = DGST_SIZE_4_5;
9098 parse_func = sha1_parse_hash;
9099 sort_by_digest = sort_by_digest_4_5;
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 = 3;
9108 dgst_pos1 = 4;
9109 dgst_pos2 = 2;
9110 dgst_pos3 = 1;
9111 break;
9112
9113 case 4800: hash_type = HASH_TYPE_MD5;
9114 salt_type = SALT_TYPE_EMBEDDED;
9115 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9116 opts_type = OPTS_TYPE_PT_GENERATE_LE
9117 | OPTS_TYPE_PT_ADDBITS14;
9118 kern_type = KERN_TYPE_MD5_CHAP;
9119 dgst_size = DGST_SIZE_4_4;
9120 parse_func = chap_parse_hash;
9121 sort_by_digest = sort_by_digest_4_4;
9122 opti_type = OPTI_TYPE_ZERO_BYTE
9123 | OPTI_TYPE_PRECOMPUTE_INIT
9124 | OPTI_TYPE_PRECOMPUTE_MERKLE
9125 | OPTI_TYPE_MEET_IN_MIDDLE
9126 | OPTI_TYPE_EARLY_SKIP
9127 | OPTI_TYPE_NOT_ITERATED
9128 | OPTI_TYPE_RAW_HASH;
9129 dgst_pos0 = 0;
9130 dgst_pos1 = 3;
9131 dgst_pos2 = 2;
9132 dgst_pos3 = 1;
9133 break;
9134
9135 case 4900: hash_type = HASH_TYPE_SHA1;
9136 salt_type = SALT_TYPE_INTERN;
9137 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9138 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9139 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9140 dgst_size = DGST_SIZE_4_5;
9141 parse_func = sha1s_parse_hash;
9142 sort_by_digest = sort_by_digest_4_5;
9143 opti_type = OPTI_TYPE_ZERO_BYTE
9144 | OPTI_TYPE_PRECOMPUTE_INIT
9145 | OPTI_TYPE_PRECOMPUTE_MERKLE
9146 | OPTI_TYPE_EARLY_SKIP;
9147 dgst_pos0 = 3;
9148 dgst_pos1 = 4;
9149 dgst_pos2 = 2;
9150 dgst_pos3 = 1;
9151 break;
9152
9153 case 5000: hash_type = HASH_TYPE_KECCAK;
9154 salt_type = SALT_TYPE_EMBEDDED;
9155 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9156 opts_type = OPTS_TYPE_PT_GENERATE_LE
9157 | OPTS_TYPE_PT_ADD01;
9158 kern_type = KERN_TYPE_KECCAK;
9159 dgst_size = DGST_SIZE_8_25;
9160 parse_func = keccak_parse_hash;
9161 sort_by_digest = sort_by_digest_8_25;
9162 opti_type = OPTI_TYPE_ZERO_BYTE
9163 | OPTI_TYPE_USES_BITS_64
9164 | OPTI_TYPE_RAW_HASH;
9165 dgst_pos0 = 2;
9166 dgst_pos1 = 3;
9167 dgst_pos2 = 4;
9168 dgst_pos3 = 5;
9169 break;
9170
9171 case 5100: hash_type = HASH_TYPE_MD5H;
9172 salt_type = SALT_TYPE_NONE;
9173 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9174 opts_type = OPTS_TYPE_PT_GENERATE_LE
9175 | OPTS_TYPE_PT_ADD80
9176 | OPTS_TYPE_PT_ADDBITS14;
9177 kern_type = KERN_TYPE_MD5H;
9178 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9179 parse_func = md5half_parse_hash;
9180 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9181 opti_type = OPTI_TYPE_ZERO_BYTE
9182 | OPTI_TYPE_RAW_HASH;
9183 dgst_pos0 = 0;
9184 dgst_pos1 = 1;
9185 dgst_pos2 = 2;
9186 dgst_pos3 = 3;
9187 break;
9188
9189 case 5200: hash_type = HASH_TYPE_SHA256;
9190 salt_type = SALT_TYPE_EMBEDDED;
9191 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9192 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9193 kern_type = KERN_TYPE_PSAFE3;
9194 dgst_size = DGST_SIZE_4_8;
9195 parse_func = psafe3_parse_hash;
9196 sort_by_digest = sort_by_digest_4_8;
9197 opti_type = OPTI_TYPE_ZERO_BYTE;
9198 dgst_pos0 = 0;
9199 dgst_pos1 = 1;
9200 dgst_pos2 = 2;
9201 dgst_pos3 = 3;
9202 break;
9203
9204 case 5300: hash_type = HASH_TYPE_MD5;
9205 salt_type = SALT_TYPE_EMBEDDED;
9206 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9207 opts_type = OPTS_TYPE_PT_GENERATE_LE
9208 | OPTS_TYPE_ST_ADD80;
9209 kern_type = KERN_TYPE_IKEPSK_MD5;
9210 dgst_size = DGST_SIZE_4_4;
9211 parse_func = ikepsk_md5_parse_hash;
9212 sort_by_digest = sort_by_digest_4_4;
9213 opti_type = OPTI_TYPE_ZERO_BYTE;
9214 dgst_pos0 = 0;
9215 dgst_pos1 = 3;
9216 dgst_pos2 = 2;
9217 dgst_pos3 = 1;
9218 break;
9219
9220 case 5400: hash_type = HASH_TYPE_SHA1;
9221 salt_type = SALT_TYPE_EMBEDDED;
9222 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9223 opts_type = OPTS_TYPE_PT_GENERATE_BE
9224 | OPTS_TYPE_ST_ADD80;
9225 kern_type = KERN_TYPE_IKEPSK_SHA1;
9226 dgst_size = DGST_SIZE_4_5;
9227 parse_func = ikepsk_sha1_parse_hash;
9228 sort_by_digest = sort_by_digest_4_5;
9229 opti_type = OPTI_TYPE_ZERO_BYTE;
9230 dgst_pos0 = 3;
9231 dgst_pos1 = 4;
9232 dgst_pos2 = 2;
9233 dgst_pos3 = 1;
9234 break;
9235
9236 case 5500: hash_type = HASH_TYPE_NETNTLM;
9237 salt_type = SALT_TYPE_EMBEDDED;
9238 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9239 opts_type = OPTS_TYPE_PT_GENERATE_LE
9240 | OPTS_TYPE_PT_ADD80
9241 | OPTS_TYPE_PT_ADDBITS14
9242 | OPTS_TYPE_PT_UNICODE
9243 | OPTS_TYPE_ST_HEX;
9244 kern_type = KERN_TYPE_NETNTLMv1;
9245 dgst_size = DGST_SIZE_4_4;
9246 parse_func = netntlmv1_parse_hash;
9247 sort_by_digest = sort_by_digest_4_4;
9248 opti_type = OPTI_TYPE_ZERO_BYTE
9249 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9250 dgst_pos0 = 0;
9251 dgst_pos1 = 1;
9252 dgst_pos2 = 2;
9253 dgst_pos3 = 3;
9254 break;
9255
9256 case 5600: hash_type = HASH_TYPE_MD5;
9257 salt_type = SALT_TYPE_EMBEDDED;
9258 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9259 opts_type = OPTS_TYPE_PT_GENERATE_LE
9260 | OPTS_TYPE_PT_ADD80
9261 | OPTS_TYPE_PT_ADDBITS14
9262 | OPTS_TYPE_PT_UNICODE;
9263 kern_type = KERN_TYPE_NETNTLMv2;
9264 dgst_size = DGST_SIZE_4_4;
9265 parse_func = netntlmv2_parse_hash;
9266 sort_by_digest = sort_by_digest_4_4;
9267 opti_type = OPTI_TYPE_ZERO_BYTE;
9268 dgst_pos0 = 0;
9269 dgst_pos1 = 3;
9270 dgst_pos2 = 2;
9271 dgst_pos3 = 1;
9272 break;
9273
9274 case 5700: hash_type = HASH_TYPE_SHA256;
9275 salt_type = SALT_TYPE_NONE;
9276 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9277 opts_type = OPTS_TYPE_PT_GENERATE_BE
9278 | OPTS_TYPE_PT_ADD80
9279 | OPTS_TYPE_PT_ADDBITS15;
9280 kern_type = KERN_TYPE_SHA256;
9281 dgst_size = DGST_SIZE_4_8;
9282 parse_func = cisco4_parse_hash;
9283 sort_by_digest = sort_by_digest_4_8;
9284 opti_type = OPTI_TYPE_ZERO_BYTE
9285 | OPTI_TYPE_PRECOMPUTE_INIT
9286 | OPTI_TYPE_PRECOMPUTE_MERKLE
9287 | OPTI_TYPE_EARLY_SKIP
9288 | OPTI_TYPE_NOT_ITERATED
9289 | OPTI_TYPE_NOT_SALTED
9290 | OPTI_TYPE_RAW_HASH;
9291 dgst_pos0 = 3;
9292 dgst_pos1 = 7;
9293 dgst_pos2 = 2;
9294 dgst_pos3 = 6;
9295 break;
9296
9297 case 5800: hash_type = HASH_TYPE_SHA1;
9298 salt_type = SALT_TYPE_INTERN;
9299 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9300 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9301 | OPTS_TYPE_ST_ADD80;
9302 kern_type = KERN_TYPE_ANDROIDPIN;
9303 dgst_size = DGST_SIZE_4_5;
9304 parse_func = androidpin_parse_hash;
9305 sort_by_digest = sort_by_digest_4_5;
9306 opti_type = OPTI_TYPE_ZERO_BYTE;
9307 dgst_pos0 = 0;
9308 dgst_pos1 = 1;
9309 dgst_pos2 = 2;
9310 dgst_pos3 = 3;
9311 break;
9312
9313 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9314 salt_type = SALT_TYPE_NONE;
9315 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9316 opts_type = OPTS_TYPE_PT_GENERATE_LE
9317 | OPTS_TYPE_PT_ADD80;
9318 kern_type = KERN_TYPE_RIPEMD160;
9319 dgst_size = DGST_SIZE_4_5;
9320 parse_func = ripemd160_parse_hash;
9321 sort_by_digest = sort_by_digest_4_5;
9322 opti_type = OPTI_TYPE_ZERO_BYTE;
9323 dgst_pos0 = 0;
9324 dgst_pos1 = 1;
9325 dgst_pos2 = 2;
9326 dgst_pos3 = 3;
9327 break;
9328
9329 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9330 salt_type = SALT_TYPE_NONE;
9331 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9332 opts_type = OPTS_TYPE_PT_GENERATE_BE
9333 | OPTS_TYPE_PT_ADD80;
9334 kern_type = KERN_TYPE_WHIRLPOOL;
9335 dgst_size = DGST_SIZE_4_16;
9336 parse_func = whirlpool_parse_hash;
9337 sort_by_digest = sort_by_digest_4_16;
9338 opti_type = OPTI_TYPE_ZERO_BYTE;
9339 dgst_pos0 = 0;
9340 dgst_pos1 = 1;
9341 dgst_pos2 = 2;
9342 dgst_pos3 = 3;
9343 break;
9344
9345 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9346 salt_type = SALT_TYPE_EMBEDDED;
9347 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9348 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9349 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9350 dgst_size = DGST_SIZE_4_5;
9351 parse_func = truecrypt_parse_hash_2k;
9352 sort_by_digest = sort_by_digest_4_5;
9353 opti_type = OPTI_TYPE_ZERO_BYTE;
9354 dgst_pos0 = 0;
9355 dgst_pos1 = 1;
9356 dgst_pos2 = 2;
9357 dgst_pos3 = 3;
9358 break;
9359
9360 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9361 salt_type = SALT_TYPE_EMBEDDED;
9362 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9363 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9364 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9365 dgst_size = DGST_SIZE_4_5;
9366 parse_func = truecrypt_parse_hash_2k;
9367 sort_by_digest = sort_by_digest_4_5;
9368 opti_type = OPTI_TYPE_ZERO_BYTE;
9369 dgst_pos0 = 0;
9370 dgst_pos1 = 1;
9371 dgst_pos2 = 2;
9372 dgst_pos3 = 3;
9373 break;
9374
9375 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9376 salt_type = SALT_TYPE_EMBEDDED;
9377 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9378 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9379 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9380 dgst_size = DGST_SIZE_4_5;
9381 parse_func = truecrypt_parse_hash_2k;
9382 sort_by_digest = sort_by_digest_4_5;
9383 opti_type = OPTI_TYPE_ZERO_BYTE;
9384 dgst_pos0 = 0;
9385 dgst_pos1 = 1;
9386 dgst_pos2 = 2;
9387 dgst_pos3 = 3;
9388 break;
9389
9390 case 6221: hash_type = HASH_TYPE_SHA512;
9391 salt_type = SALT_TYPE_EMBEDDED;
9392 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9393 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9394 kern_type = KERN_TYPE_TCSHA512_XTS512;
9395 dgst_size = DGST_SIZE_8_8;
9396 parse_func = truecrypt_parse_hash_1k;
9397 sort_by_digest = sort_by_digest_8_8;
9398 opti_type = OPTI_TYPE_ZERO_BYTE
9399 | OPTI_TYPE_USES_BITS_64;
9400 dgst_pos0 = 0;
9401 dgst_pos1 = 1;
9402 dgst_pos2 = 2;
9403 dgst_pos3 = 3;
9404 break;
9405
9406 case 6222: hash_type = HASH_TYPE_SHA512;
9407 salt_type = SALT_TYPE_EMBEDDED;
9408 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9409 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9410 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9411 dgst_size = DGST_SIZE_8_8;
9412 parse_func = truecrypt_parse_hash_1k;
9413 sort_by_digest = sort_by_digest_8_8;
9414 opti_type = OPTI_TYPE_ZERO_BYTE
9415 | OPTI_TYPE_USES_BITS_64;
9416 dgst_pos0 = 0;
9417 dgst_pos1 = 1;
9418 dgst_pos2 = 2;
9419 dgst_pos3 = 3;
9420 break;
9421
9422 case 6223: hash_type = HASH_TYPE_SHA512;
9423 salt_type = SALT_TYPE_EMBEDDED;
9424 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9425 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9426 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9427 dgst_size = DGST_SIZE_8_8;
9428 parse_func = truecrypt_parse_hash_1k;
9429 sort_by_digest = sort_by_digest_8_8;
9430 opti_type = OPTI_TYPE_ZERO_BYTE
9431 | OPTI_TYPE_USES_BITS_64;
9432 dgst_pos0 = 0;
9433 dgst_pos1 = 1;
9434 dgst_pos2 = 2;
9435 dgst_pos3 = 3;
9436 break;
9437
9438 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9439 salt_type = SALT_TYPE_EMBEDDED;
9440 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9441 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9442 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9443 dgst_size = DGST_SIZE_4_8;
9444 parse_func = truecrypt_parse_hash_1k;
9445 sort_by_digest = sort_by_digest_4_8;
9446 opti_type = OPTI_TYPE_ZERO_BYTE;
9447 dgst_pos0 = 0;
9448 dgst_pos1 = 1;
9449 dgst_pos2 = 2;
9450 dgst_pos3 = 3;
9451 break;
9452
9453 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9454 salt_type = SALT_TYPE_EMBEDDED;
9455 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9456 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9457 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9458 dgst_size = DGST_SIZE_4_8;
9459 parse_func = truecrypt_parse_hash_1k;
9460 sort_by_digest = sort_by_digest_4_8;
9461 opti_type = OPTI_TYPE_ZERO_BYTE;
9462 dgst_pos0 = 0;
9463 dgst_pos1 = 1;
9464 dgst_pos2 = 2;
9465 dgst_pos3 = 3;
9466 break;
9467
9468 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9469 salt_type = SALT_TYPE_EMBEDDED;
9470 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9471 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9472 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9473 dgst_size = DGST_SIZE_4_8;
9474 parse_func = truecrypt_parse_hash_1k;
9475 sort_by_digest = sort_by_digest_4_8;
9476 opti_type = OPTI_TYPE_ZERO_BYTE;
9477 dgst_pos0 = 0;
9478 dgst_pos1 = 1;
9479 dgst_pos2 = 2;
9480 dgst_pos3 = 3;
9481 break;
9482
9483 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9484 salt_type = SALT_TYPE_EMBEDDED;
9485 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9486 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9487 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9488 dgst_size = DGST_SIZE_4_5;
9489 parse_func = truecrypt_parse_hash_1k;
9490 sort_by_digest = sort_by_digest_4_5;
9491 opti_type = OPTI_TYPE_ZERO_BYTE;
9492 dgst_pos0 = 0;
9493 dgst_pos1 = 1;
9494 dgst_pos2 = 2;
9495 dgst_pos3 = 3;
9496 break;
9497
9498 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9499 salt_type = SALT_TYPE_EMBEDDED;
9500 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9501 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9502 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9503 dgst_size = DGST_SIZE_4_5;
9504 parse_func = truecrypt_parse_hash_1k;
9505 sort_by_digest = sort_by_digest_4_5;
9506 opti_type = OPTI_TYPE_ZERO_BYTE;
9507 dgst_pos0 = 0;
9508 dgst_pos1 = 1;
9509 dgst_pos2 = 2;
9510 dgst_pos3 = 3;
9511 break;
9512
9513 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9514 salt_type = SALT_TYPE_EMBEDDED;
9515 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9516 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9517 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9518 dgst_size = DGST_SIZE_4_5;
9519 parse_func = truecrypt_parse_hash_1k;
9520 sort_by_digest = sort_by_digest_4_5;
9521 opti_type = OPTI_TYPE_ZERO_BYTE;
9522 dgst_pos0 = 0;
9523 dgst_pos1 = 1;
9524 dgst_pos2 = 2;
9525 dgst_pos3 = 3;
9526 break;
9527
9528 case 6300: hash_type = HASH_TYPE_MD5;
9529 salt_type = SALT_TYPE_EMBEDDED;
9530 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9531 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9532 kern_type = KERN_TYPE_MD5AIX;
9533 dgst_size = DGST_SIZE_4_4;
9534 parse_func = md5aix_parse_hash;
9535 sort_by_digest = sort_by_digest_4_4;
9536 opti_type = OPTI_TYPE_ZERO_BYTE;
9537 dgst_pos0 = 0;
9538 dgst_pos1 = 1;
9539 dgst_pos2 = 2;
9540 dgst_pos3 = 3;
9541 break;
9542
9543 case 6400: hash_type = HASH_TYPE_SHA256;
9544 salt_type = SALT_TYPE_EMBEDDED;
9545 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9546 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9547 kern_type = KERN_TYPE_SHA256AIX;
9548 dgst_size = DGST_SIZE_4_8;
9549 parse_func = sha256aix_parse_hash;
9550 sort_by_digest = sort_by_digest_4_8;
9551 opti_type = OPTI_TYPE_ZERO_BYTE;
9552 dgst_pos0 = 0;
9553 dgst_pos1 = 1;
9554 dgst_pos2 = 2;
9555 dgst_pos3 = 3;
9556 break;
9557
9558 case 6500: hash_type = HASH_TYPE_SHA512;
9559 salt_type = SALT_TYPE_EMBEDDED;
9560 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9561 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9562 kern_type = KERN_TYPE_SHA512AIX;
9563 dgst_size = DGST_SIZE_8_8;
9564 parse_func = sha512aix_parse_hash;
9565 sort_by_digest = sort_by_digest_8_8;
9566 opti_type = OPTI_TYPE_ZERO_BYTE
9567 | OPTI_TYPE_USES_BITS_64;
9568 dgst_pos0 = 0;
9569 dgst_pos1 = 1;
9570 dgst_pos2 = 2;
9571 dgst_pos3 = 3;
9572 break;
9573
9574 case 6600: hash_type = HASH_TYPE_AES;
9575 salt_type = SALT_TYPE_EMBEDDED;
9576 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9577 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9578 kern_type = KERN_TYPE_AGILEKEY;
9579 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9580 parse_func = agilekey_parse_hash;
9581 sort_by_digest = sort_by_digest_4_5;
9582 opti_type = OPTI_TYPE_ZERO_BYTE;
9583 dgst_pos0 = 0;
9584 dgst_pos1 = 1;
9585 dgst_pos2 = 2;
9586 dgst_pos3 = 3;
9587 break;
9588
9589 case 6700: hash_type = HASH_TYPE_SHA1;
9590 salt_type = SALT_TYPE_EMBEDDED;
9591 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9592 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9593 kern_type = KERN_TYPE_SHA1AIX;
9594 dgst_size = DGST_SIZE_4_5;
9595 parse_func = sha1aix_parse_hash;
9596 sort_by_digest = sort_by_digest_4_5;
9597 opti_type = OPTI_TYPE_ZERO_BYTE;
9598 dgst_pos0 = 0;
9599 dgst_pos1 = 1;
9600 dgst_pos2 = 2;
9601 dgst_pos3 = 3;
9602 break;
9603
9604 case 6800: hash_type = HASH_TYPE_AES;
9605 salt_type = SALT_TYPE_EMBEDDED;
9606 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9607 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9608 kern_type = KERN_TYPE_LASTPASS;
9609 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9610 parse_func = lastpass_parse_hash;
9611 sort_by_digest = sort_by_digest_4_8;
9612 opti_type = OPTI_TYPE_ZERO_BYTE;
9613 dgst_pos0 = 0;
9614 dgst_pos1 = 1;
9615 dgst_pos2 = 2;
9616 dgst_pos3 = 3;
9617 break;
9618
9619 case 6900: hash_type = HASH_TYPE_GOST;
9620 salt_type = SALT_TYPE_NONE;
9621 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9622 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9623 kern_type = KERN_TYPE_GOST;
9624 dgst_size = DGST_SIZE_4_8;
9625 parse_func = gost_parse_hash;
9626 sort_by_digest = sort_by_digest_4_8;
9627 opti_type = OPTI_TYPE_ZERO_BYTE;
9628 dgst_pos0 = 0;
9629 dgst_pos1 = 1;
9630 dgst_pos2 = 2;
9631 dgst_pos3 = 3;
9632 break;
9633
9634 case 7100: hash_type = HASH_TYPE_SHA512;
9635 salt_type = SALT_TYPE_EMBEDDED;
9636 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9637 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9638 kern_type = KERN_TYPE_PBKDF2_SHA512;
9639 dgst_size = DGST_SIZE_8_16;
9640 parse_func = sha512osx_parse_hash;
9641 sort_by_digest = sort_by_digest_8_16;
9642 opti_type = OPTI_TYPE_ZERO_BYTE
9643 | OPTI_TYPE_USES_BITS_64
9644 | OPTI_TYPE_SLOW_HASH_SIMD;
9645 dgst_pos0 = 0;
9646 dgst_pos1 = 1;
9647 dgst_pos2 = 2;
9648 dgst_pos3 = 3;
9649 break;
9650
9651 case 7200: hash_type = HASH_TYPE_SHA512;
9652 salt_type = SALT_TYPE_EMBEDDED;
9653 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9654 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9655 kern_type = KERN_TYPE_PBKDF2_SHA512;
9656 dgst_size = DGST_SIZE_8_16;
9657 parse_func = sha512grub_parse_hash;
9658 sort_by_digest = sort_by_digest_8_16;
9659 opti_type = OPTI_TYPE_ZERO_BYTE
9660 | OPTI_TYPE_USES_BITS_64
9661 | OPTI_TYPE_SLOW_HASH_SIMD;
9662 dgst_pos0 = 0;
9663 dgst_pos1 = 1;
9664 dgst_pos2 = 2;
9665 dgst_pos3 = 3;
9666 break;
9667
9668 case 7300: hash_type = HASH_TYPE_SHA1;
9669 salt_type = SALT_TYPE_EMBEDDED;
9670 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9671 opts_type = OPTS_TYPE_PT_GENERATE_BE
9672 | OPTS_TYPE_ST_ADD80
9673 | OPTS_TYPE_ST_ADDBITS15;
9674 kern_type = KERN_TYPE_RAKP;
9675 dgst_size = DGST_SIZE_4_5;
9676 parse_func = rakp_parse_hash;
9677 sort_by_digest = sort_by_digest_4_5;
9678 opti_type = OPTI_TYPE_ZERO_BYTE
9679 | OPTI_TYPE_NOT_ITERATED;
9680 dgst_pos0 = 3;
9681 dgst_pos1 = 4;
9682 dgst_pos2 = 2;
9683 dgst_pos3 = 1;
9684 break;
9685
9686 case 7400: hash_type = HASH_TYPE_SHA256;
9687 salt_type = SALT_TYPE_EMBEDDED;
9688 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9689 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9690 kern_type = KERN_TYPE_SHA256CRYPT;
9691 dgst_size = DGST_SIZE_4_8;
9692 parse_func = sha256crypt_parse_hash;
9693 sort_by_digest = sort_by_digest_4_8;
9694 opti_type = OPTI_TYPE_ZERO_BYTE;
9695 dgst_pos0 = 0;
9696 dgst_pos1 = 1;
9697 dgst_pos2 = 2;
9698 dgst_pos3 = 3;
9699 break;
9700
9701 case 7500: hash_type = HASH_TYPE_KRB5PA;
9702 salt_type = SALT_TYPE_EMBEDDED;
9703 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9704 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9705 kern_type = KERN_TYPE_KRB5PA;
9706 dgst_size = DGST_SIZE_4_4;
9707 parse_func = krb5pa_parse_hash;
9708 sort_by_digest = sort_by_digest_4_4;
9709 opti_type = OPTI_TYPE_ZERO_BYTE
9710 | OPTI_TYPE_NOT_ITERATED;
9711 dgst_pos0 = 0;
9712 dgst_pos1 = 1;
9713 dgst_pos2 = 2;
9714 dgst_pos3 = 3;
9715 break;
9716
9717 case 7600: hash_type = HASH_TYPE_SHA1;
9718 salt_type = SALT_TYPE_INTERN;
9719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9720 opts_type = OPTS_TYPE_PT_GENERATE_BE
9721 | OPTS_TYPE_PT_ADD80
9722 | OPTS_TYPE_PT_ADDBITS15;
9723 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9724 dgst_size = DGST_SIZE_4_5;
9725 parse_func = redmine_parse_hash;
9726 sort_by_digest = sort_by_digest_4_5;
9727 opti_type = OPTI_TYPE_ZERO_BYTE
9728 | OPTI_TYPE_PRECOMPUTE_INIT
9729 | OPTI_TYPE_EARLY_SKIP
9730 | OPTI_TYPE_NOT_ITERATED
9731 | OPTI_TYPE_PREPENDED_SALT;
9732 dgst_pos0 = 3;
9733 dgst_pos1 = 4;
9734 dgst_pos2 = 2;
9735 dgst_pos3 = 1;
9736 break;
9737
9738 case 7700: hash_type = HASH_TYPE_SAPB;
9739 salt_type = SALT_TYPE_EMBEDDED;
9740 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9741 opts_type = OPTS_TYPE_PT_GENERATE_LE
9742 | OPTS_TYPE_PT_UPPER
9743 | OPTS_TYPE_ST_UPPER;
9744 kern_type = KERN_TYPE_SAPB;
9745 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9746 parse_func = sapb_parse_hash;
9747 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9748 opti_type = OPTI_TYPE_ZERO_BYTE
9749 | OPTI_TYPE_PRECOMPUTE_INIT
9750 | OPTI_TYPE_NOT_ITERATED;
9751 dgst_pos0 = 0;
9752 dgst_pos1 = 1;
9753 dgst_pos2 = 2;
9754 dgst_pos3 = 3;
9755 break;
9756
9757 case 7800: hash_type = HASH_TYPE_SAPG;
9758 salt_type = SALT_TYPE_EMBEDDED;
9759 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9760 opts_type = OPTS_TYPE_PT_GENERATE_BE
9761 | OPTS_TYPE_ST_ADD80
9762 | OPTS_TYPE_ST_UPPER;
9763 kern_type = KERN_TYPE_SAPG;
9764 dgst_size = DGST_SIZE_4_5;
9765 parse_func = sapg_parse_hash;
9766 sort_by_digest = sort_by_digest_4_5;
9767 opti_type = OPTI_TYPE_ZERO_BYTE
9768 | OPTI_TYPE_PRECOMPUTE_INIT
9769 | OPTI_TYPE_NOT_ITERATED;
9770 dgst_pos0 = 3;
9771 dgst_pos1 = 4;
9772 dgst_pos2 = 2;
9773 dgst_pos3 = 1;
9774 break;
9775
9776 case 7900: hash_type = HASH_TYPE_SHA512;
9777 salt_type = SALT_TYPE_EMBEDDED;
9778 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9779 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9780 kern_type = KERN_TYPE_DRUPAL7;
9781 dgst_size = DGST_SIZE_8_8;
9782 parse_func = drupal7_parse_hash;
9783 sort_by_digest = sort_by_digest_8_8;
9784 opti_type = OPTI_TYPE_ZERO_BYTE
9785 | OPTI_TYPE_USES_BITS_64;
9786 dgst_pos0 = 0;
9787 dgst_pos1 = 1;
9788 dgst_pos2 = 2;
9789 dgst_pos3 = 3;
9790 break;
9791
9792 case 8000: hash_type = HASH_TYPE_SHA256;
9793 salt_type = SALT_TYPE_EMBEDDED;
9794 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9795 opts_type = OPTS_TYPE_PT_GENERATE_BE
9796 | OPTS_TYPE_PT_UNICODE
9797 | OPTS_TYPE_ST_ADD80
9798 | OPTS_TYPE_ST_HEX;
9799 kern_type = KERN_TYPE_SYBASEASE;
9800 dgst_size = DGST_SIZE_4_8;
9801 parse_func = sybasease_parse_hash;
9802 sort_by_digest = sort_by_digest_4_8;
9803 opti_type = OPTI_TYPE_ZERO_BYTE
9804 | OPTI_TYPE_PRECOMPUTE_INIT
9805 | OPTI_TYPE_EARLY_SKIP
9806 | OPTI_TYPE_NOT_ITERATED
9807 | OPTI_TYPE_RAW_HASH;
9808 dgst_pos0 = 3;
9809 dgst_pos1 = 7;
9810 dgst_pos2 = 2;
9811 dgst_pos3 = 6;
9812 break;
9813
9814 case 8100: hash_type = HASH_TYPE_SHA1;
9815 salt_type = SALT_TYPE_EMBEDDED;
9816 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9817 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9818 kern_type = KERN_TYPE_NETSCALER;
9819 dgst_size = DGST_SIZE_4_5;
9820 parse_func = netscaler_parse_hash;
9821 sort_by_digest = sort_by_digest_4_5;
9822 opti_type = OPTI_TYPE_ZERO_BYTE
9823 | OPTI_TYPE_PRECOMPUTE_INIT
9824 | OPTI_TYPE_PRECOMPUTE_MERKLE
9825 | OPTI_TYPE_EARLY_SKIP
9826 | OPTI_TYPE_NOT_ITERATED
9827 | OPTI_TYPE_PREPENDED_SALT
9828 | OPTI_TYPE_RAW_HASH;
9829 dgst_pos0 = 3;
9830 dgst_pos1 = 4;
9831 dgst_pos2 = 2;
9832 dgst_pos3 = 1;
9833 break;
9834
9835 case 8200: hash_type = HASH_TYPE_SHA256;
9836 salt_type = SALT_TYPE_EMBEDDED;
9837 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9838 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9839 kern_type = KERN_TYPE_CLOUDKEY;
9840 dgst_size = DGST_SIZE_4_8;
9841 parse_func = cloudkey_parse_hash;
9842 sort_by_digest = sort_by_digest_4_8;
9843 opti_type = OPTI_TYPE_ZERO_BYTE;
9844 dgst_pos0 = 0;
9845 dgst_pos1 = 1;
9846 dgst_pos2 = 2;
9847 dgst_pos3 = 3;
9848 break;
9849
9850 case 8300: hash_type = HASH_TYPE_SHA1;
9851 salt_type = SALT_TYPE_EMBEDDED;
9852 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9853 opts_type = OPTS_TYPE_PT_GENERATE_BE
9854 | OPTS_TYPE_ST_HEX
9855 | OPTS_TYPE_ST_ADD80;
9856 kern_type = KERN_TYPE_NSEC3;
9857 dgst_size = DGST_SIZE_4_5;
9858 parse_func = nsec3_parse_hash;
9859 sort_by_digest = sort_by_digest_4_5;
9860 opti_type = OPTI_TYPE_ZERO_BYTE;
9861 dgst_pos0 = 3;
9862 dgst_pos1 = 4;
9863 dgst_pos2 = 2;
9864 dgst_pos3 = 1;
9865 break;
9866
9867 case 8400: hash_type = HASH_TYPE_SHA1;
9868 salt_type = SALT_TYPE_INTERN;
9869 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9870 opts_type = OPTS_TYPE_PT_GENERATE_BE
9871 | OPTS_TYPE_PT_ADD80
9872 | OPTS_TYPE_PT_ADDBITS15;
9873 kern_type = KERN_TYPE_WBB3;
9874 dgst_size = DGST_SIZE_4_5;
9875 parse_func = wbb3_parse_hash;
9876 sort_by_digest = sort_by_digest_4_5;
9877 opti_type = OPTI_TYPE_ZERO_BYTE
9878 | OPTI_TYPE_PRECOMPUTE_INIT
9879 | OPTI_TYPE_NOT_ITERATED;
9880 dgst_pos0 = 3;
9881 dgst_pos1 = 4;
9882 dgst_pos2 = 2;
9883 dgst_pos3 = 1;
9884 break;
9885
9886 case 8500: hash_type = HASH_TYPE_DESRACF;
9887 salt_type = SALT_TYPE_EMBEDDED;
9888 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9889 opts_type = OPTS_TYPE_PT_GENERATE_LE
9890 | OPTS_TYPE_ST_UPPER;
9891 kern_type = KERN_TYPE_RACF;
9892 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9893 parse_func = racf_parse_hash;
9894 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9895 opti_type = OPTI_TYPE_ZERO_BYTE
9896 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9897 dgst_pos0 = 0;
9898 dgst_pos1 = 1;
9899 dgst_pos2 = 2;
9900 dgst_pos3 = 3;
9901 break;
9902
9903 case 8600: hash_type = HASH_TYPE_LOTUS5;
9904 salt_type = SALT_TYPE_NONE;
9905 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9906 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9907 kern_type = KERN_TYPE_LOTUS5;
9908 dgst_size = DGST_SIZE_4_4;
9909 parse_func = lotus5_parse_hash;
9910 sort_by_digest = sort_by_digest_4_4;
9911 opti_type = OPTI_TYPE_EARLY_SKIP
9912 | OPTI_TYPE_NOT_ITERATED
9913 | OPTI_TYPE_NOT_SALTED
9914 | OPTI_TYPE_RAW_HASH;
9915 dgst_pos0 = 0;
9916 dgst_pos1 = 1;
9917 dgst_pos2 = 2;
9918 dgst_pos3 = 3;
9919 break;
9920
9921 case 8700: hash_type = HASH_TYPE_LOTUS6;
9922 salt_type = SALT_TYPE_EMBEDDED;
9923 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9924 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9925 kern_type = KERN_TYPE_LOTUS6;
9926 dgst_size = DGST_SIZE_4_4;
9927 parse_func = lotus6_parse_hash;
9928 sort_by_digest = sort_by_digest_4_4;
9929 opti_type = OPTI_TYPE_EARLY_SKIP
9930 | OPTI_TYPE_NOT_ITERATED
9931 | OPTI_TYPE_RAW_HASH;
9932 dgst_pos0 = 0;
9933 dgst_pos1 = 1;
9934 dgst_pos2 = 2;
9935 dgst_pos3 = 3;
9936 break;
9937
9938 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9939 salt_type = SALT_TYPE_EMBEDDED;
9940 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9941 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9942 kern_type = KERN_TYPE_ANDROIDFDE;
9943 dgst_size = DGST_SIZE_4_4;
9944 parse_func = androidfde_parse_hash;
9945 sort_by_digest = sort_by_digest_4_4;
9946 opti_type = OPTI_TYPE_ZERO_BYTE;
9947 dgst_pos0 = 0;
9948 dgst_pos1 = 1;
9949 dgst_pos2 = 2;
9950 dgst_pos3 = 3;
9951 break;
9952
9953 case 8900: hash_type = HASH_TYPE_SCRYPT;
9954 salt_type = SALT_TYPE_EMBEDDED;
9955 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9956 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9957 kern_type = KERN_TYPE_SCRYPT;
9958 dgst_size = DGST_SIZE_4_8;
9959 parse_func = scrypt_parse_hash;
9960 sort_by_digest = sort_by_digest_4_8;
9961 opti_type = OPTI_TYPE_ZERO_BYTE;
9962 dgst_pos0 = 0;
9963 dgst_pos1 = 1;
9964 dgst_pos2 = 2;
9965 dgst_pos3 = 3;
9966 break;
9967
9968 case 9000: hash_type = HASH_TYPE_SHA1;
9969 salt_type = SALT_TYPE_EMBEDDED;
9970 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9971 opts_type = OPTS_TYPE_PT_GENERATE_LE
9972 | OPTS_TYPE_ST_GENERATE_LE;
9973 kern_type = KERN_TYPE_PSAFE2;
9974 dgst_size = DGST_SIZE_4_5;
9975 parse_func = psafe2_parse_hash;
9976 sort_by_digest = sort_by_digest_4_5;
9977 opti_type = OPTI_TYPE_ZERO_BYTE;
9978 dgst_pos0 = 0;
9979 dgst_pos1 = 1;
9980 dgst_pos2 = 2;
9981 dgst_pos3 = 3;
9982 break;
9983
9984 case 9100: hash_type = HASH_TYPE_LOTUS8;
9985 salt_type = SALT_TYPE_EMBEDDED;
9986 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9987 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9988 kern_type = KERN_TYPE_LOTUS8;
9989 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9990 parse_func = lotus8_parse_hash;
9991 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9992 opti_type = OPTI_TYPE_ZERO_BYTE;
9993 dgst_pos0 = 0;
9994 dgst_pos1 = 1;
9995 dgst_pos2 = 2;
9996 dgst_pos3 = 3;
9997 break;
9998
9999 case 9200: hash_type = HASH_TYPE_SHA256;
10000 salt_type = SALT_TYPE_EMBEDDED;
10001 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10002 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10003 kern_type = KERN_TYPE_PBKDF2_SHA256;
10004 dgst_size = DGST_SIZE_4_32;
10005 parse_func = cisco8_parse_hash;
10006 sort_by_digest = sort_by_digest_4_32;
10007 opti_type = OPTI_TYPE_ZERO_BYTE
10008 | OPTI_TYPE_SLOW_HASH_SIMD;
10009 dgst_pos0 = 0;
10010 dgst_pos1 = 1;
10011 dgst_pos2 = 2;
10012 dgst_pos3 = 3;
10013 break;
10014
10015 case 9300: hash_type = HASH_TYPE_SCRYPT;
10016 salt_type = SALT_TYPE_EMBEDDED;
10017 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10018 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10019 kern_type = KERN_TYPE_SCRYPT;
10020 dgst_size = DGST_SIZE_4_8;
10021 parse_func = cisco9_parse_hash;
10022 sort_by_digest = sort_by_digest_4_8;
10023 opti_type = OPTI_TYPE_ZERO_BYTE;
10024 dgst_pos0 = 0;
10025 dgst_pos1 = 1;
10026 dgst_pos2 = 2;
10027 dgst_pos3 = 3;
10028 break;
10029
10030 case 9400: hash_type = HASH_TYPE_OFFICE2007;
10031 salt_type = SALT_TYPE_EMBEDDED;
10032 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10033 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10034 kern_type = KERN_TYPE_OFFICE2007;
10035 dgst_size = DGST_SIZE_4_4;
10036 parse_func = office2007_parse_hash;
10037 sort_by_digest = sort_by_digest_4_4;
10038 opti_type = OPTI_TYPE_ZERO_BYTE;
10039 dgst_pos0 = 0;
10040 dgst_pos1 = 1;
10041 dgst_pos2 = 2;
10042 dgst_pos3 = 3;
10043 break;
10044
10045 case 9500: hash_type = HASH_TYPE_OFFICE2010;
10046 salt_type = SALT_TYPE_EMBEDDED;
10047 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10048 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10049 kern_type = KERN_TYPE_OFFICE2010;
10050 dgst_size = DGST_SIZE_4_4;
10051 parse_func = office2010_parse_hash;
10052 sort_by_digest = sort_by_digest_4_4;
10053 opti_type = OPTI_TYPE_ZERO_BYTE;
10054 dgst_pos0 = 0;
10055 dgst_pos1 = 1;
10056 dgst_pos2 = 2;
10057 dgst_pos3 = 3;
10058 break;
10059
10060 case 9600: hash_type = HASH_TYPE_OFFICE2013;
10061 salt_type = SALT_TYPE_EMBEDDED;
10062 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10063 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10064 kern_type = KERN_TYPE_OFFICE2013;
10065 dgst_size = DGST_SIZE_4_4;
10066 parse_func = office2013_parse_hash;
10067 sort_by_digest = sort_by_digest_4_4;
10068 opti_type = OPTI_TYPE_ZERO_BYTE;
10069 dgst_pos0 = 0;
10070 dgst_pos1 = 1;
10071 dgst_pos2 = 2;
10072 dgst_pos3 = 3;
10073 break;
10074
10075 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
10076 salt_type = SALT_TYPE_EMBEDDED;
10077 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10078 opts_type = OPTS_TYPE_PT_GENERATE_LE
10079 | OPTS_TYPE_PT_ADD80
10080 | OPTS_TYPE_PT_UNICODE;
10081 kern_type = KERN_TYPE_OLDOFFICE01;
10082 dgst_size = DGST_SIZE_4_4;
10083 parse_func = oldoffice01_parse_hash;
10084 sort_by_digest = sort_by_digest_4_4;
10085 opti_type = OPTI_TYPE_ZERO_BYTE
10086 | OPTI_TYPE_PRECOMPUTE_INIT
10087 | OPTI_TYPE_NOT_ITERATED;
10088 dgst_pos0 = 0;
10089 dgst_pos1 = 1;
10090 dgst_pos2 = 2;
10091 dgst_pos3 = 3;
10092 break;
10093
10094 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
10095 salt_type = SALT_TYPE_EMBEDDED;
10096 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10097 opts_type = OPTS_TYPE_PT_GENERATE_LE
10098 | OPTS_TYPE_PT_ADD80;
10099 kern_type = KERN_TYPE_OLDOFFICE01CM1;
10100 dgst_size = DGST_SIZE_4_4;
10101 parse_func = oldoffice01cm1_parse_hash;
10102 sort_by_digest = sort_by_digest_4_4;
10103 opti_type = OPTI_TYPE_ZERO_BYTE
10104 | OPTI_TYPE_PRECOMPUTE_INIT
10105 | OPTI_TYPE_NOT_ITERATED;
10106 dgst_pos0 = 0;
10107 dgst_pos1 = 1;
10108 dgst_pos2 = 2;
10109 dgst_pos3 = 3;
10110 break;
10111
10112 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
10113 salt_type = SALT_TYPE_EMBEDDED;
10114 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10115 opts_type = OPTS_TYPE_PT_GENERATE_LE
10116 | OPTS_TYPE_PT_ADD80
10117 | OPTS_TYPE_PT_UNICODE
10118 | OPTS_TYPE_PT_NEVERCRACK;
10119 kern_type = KERN_TYPE_OLDOFFICE01CM2;
10120 dgst_size = DGST_SIZE_4_4;
10121 parse_func = oldoffice01cm2_parse_hash;
10122 sort_by_digest = sort_by_digest_4_4;
10123 opti_type = OPTI_TYPE_ZERO_BYTE
10124 | OPTI_TYPE_PRECOMPUTE_INIT
10125 | OPTI_TYPE_NOT_ITERATED;
10126 dgst_pos0 = 0;
10127 dgst_pos1 = 1;
10128 dgst_pos2 = 2;
10129 dgst_pos3 = 3;
10130 break;
10131
10132 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
10133 salt_type = SALT_TYPE_EMBEDDED;
10134 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10135 opts_type = OPTS_TYPE_PT_GENERATE_BE
10136 | OPTS_TYPE_PT_ADD80
10137 | OPTS_TYPE_PT_UNICODE;
10138 kern_type = KERN_TYPE_OLDOFFICE34;
10139 dgst_size = DGST_SIZE_4_4;
10140 parse_func = oldoffice34_parse_hash;
10141 sort_by_digest = sort_by_digest_4_4;
10142 opti_type = OPTI_TYPE_ZERO_BYTE
10143 | OPTI_TYPE_PRECOMPUTE_INIT
10144 | OPTI_TYPE_NOT_ITERATED;
10145 dgst_pos0 = 0;
10146 dgst_pos1 = 1;
10147 dgst_pos2 = 2;
10148 dgst_pos3 = 3;
10149 break;
10150
10151 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10152 salt_type = SALT_TYPE_EMBEDDED;
10153 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10154 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10155 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10156 dgst_size = DGST_SIZE_4_4;
10157 parse_func = oldoffice34cm1_parse_hash;
10158 sort_by_digest = sort_by_digest_4_4;
10159 opti_type = OPTI_TYPE_ZERO_BYTE
10160 | OPTI_TYPE_PRECOMPUTE_INIT
10161 | OPTI_TYPE_NOT_ITERATED;
10162 dgst_pos0 = 0;
10163 dgst_pos1 = 1;
10164 dgst_pos2 = 2;
10165 dgst_pos3 = 3;
10166 break;
10167
10168 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10169 salt_type = SALT_TYPE_EMBEDDED;
10170 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10171 opts_type = OPTS_TYPE_PT_GENERATE_BE
10172 | OPTS_TYPE_PT_ADD80
10173 | OPTS_TYPE_PT_UNICODE
10174 | OPTS_TYPE_PT_NEVERCRACK;
10175 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10176 dgst_size = DGST_SIZE_4_4;
10177 parse_func = oldoffice34cm2_parse_hash;
10178 sort_by_digest = sort_by_digest_4_4;
10179 opti_type = OPTI_TYPE_ZERO_BYTE
10180 | OPTI_TYPE_PRECOMPUTE_INIT
10181 | OPTI_TYPE_NOT_ITERATED;
10182 dgst_pos0 = 0;
10183 dgst_pos1 = 1;
10184 dgst_pos2 = 2;
10185 dgst_pos3 = 3;
10186 break;
10187
10188 case 9900: hash_type = HASH_TYPE_MD5;
10189 salt_type = SALT_TYPE_NONE;
10190 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10191 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10192 kern_type = KERN_TYPE_RADMIN2;
10193 dgst_size = DGST_SIZE_4_4;
10194 parse_func = radmin2_parse_hash;
10195 sort_by_digest = sort_by_digest_4_4;
10196 opti_type = OPTI_TYPE_ZERO_BYTE
10197 | OPTI_TYPE_PRECOMPUTE_INIT
10198 | OPTI_TYPE_EARLY_SKIP
10199 | OPTI_TYPE_NOT_ITERATED
10200 | OPTI_TYPE_NOT_SALTED;
10201 dgst_pos0 = 0;
10202 dgst_pos1 = 3;
10203 dgst_pos2 = 2;
10204 dgst_pos3 = 1;
10205 break;
10206
10207 case 10000: hash_type = HASH_TYPE_SHA256;
10208 salt_type = SALT_TYPE_EMBEDDED;
10209 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10210 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10211 kern_type = KERN_TYPE_PBKDF2_SHA256;
10212 dgst_size = DGST_SIZE_4_32;
10213 parse_func = djangopbkdf2_parse_hash;
10214 sort_by_digest = sort_by_digest_4_32;
10215 opti_type = OPTI_TYPE_ZERO_BYTE
10216 | OPTI_TYPE_SLOW_HASH_SIMD;
10217 dgst_pos0 = 0;
10218 dgst_pos1 = 1;
10219 dgst_pos2 = 2;
10220 dgst_pos3 = 3;
10221 break;
10222
10223 case 10100: hash_type = HASH_TYPE_SIPHASH;
10224 salt_type = SALT_TYPE_EMBEDDED;
10225 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10226 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10227 kern_type = KERN_TYPE_SIPHASH;
10228 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10229 parse_func = siphash_parse_hash;
10230 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10231 opti_type = OPTI_TYPE_ZERO_BYTE
10232 | OPTI_TYPE_NOT_ITERATED
10233 | OPTI_TYPE_RAW_HASH;
10234 dgst_pos0 = 0;
10235 dgst_pos1 = 1;
10236 dgst_pos2 = 2;
10237 dgst_pos3 = 3;
10238 break;
10239
10240 case 10200: hash_type = HASH_TYPE_MD5;
10241 salt_type = SALT_TYPE_EMBEDDED;
10242 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10243 opts_type = OPTS_TYPE_PT_GENERATE_LE
10244 | OPTS_TYPE_ST_ADD80
10245 | OPTS_TYPE_ST_ADDBITS14;
10246 kern_type = KERN_TYPE_HMACMD5_PW;
10247 dgst_size = DGST_SIZE_4_4;
10248 parse_func = crammd5_parse_hash;
10249 sort_by_digest = sort_by_digest_4_4;
10250 opti_type = OPTI_TYPE_ZERO_BYTE
10251 | OPTI_TYPE_NOT_ITERATED;
10252 dgst_pos0 = 0;
10253 dgst_pos1 = 3;
10254 dgst_pos2 = 2;
10255 dgst_pos3 = 1;
10256 break;
10257
10258 case 10300: hash_type = HASH_TYPE_SHA1;
10259 salt_type = SALT_TYPE_EMBEDDED;
10260 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10261 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10262 kern_type = KERN_TYPE_SAPH_SHA1;
10263 dgst_size = DGST_SIZE_4_5;
10264 parse_func = saph_sha1_parse_hash;
10265 sort_by_digest = sort_by_digest_4_5;
10266 opti_type = OPTI_TYPE_ZERO_BYTE;
10267 dgst_pos0 = 0;
10268 dgst_pos1 = 1;
10269 dgst_pos2 = 2;
10270 dgst_pos3 = 3;
10271 break;
10272
10273 case 10400: hash_type = HASH_TYPE_PDFU16;
10274 salt_type = SALT_TYPE_EMBEDDED;
10275 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10276 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10277 kern_type = KERN_TYPE_PDF11;
10278 dgst_size = DGST_SIZE_4_4;
10279 parse_func = pdf11_parse_hash;
10280 sort_by_digest = sort_by_digest_4_4;
10281 opti_type = OPTI_TYPE_ZERO_BYTE
10282 | OPTI_TYPE_NOT_ITERATED;
10283 dgst_pos0 = 0;
10284 dgst_pos1 = 1;
10285 dgst_pos2 = 2;
10286 dgst_pos3 = 3;
10287 break;
10288
10289 case 10410: hash_type = HASH_TYPE_PDFU16;
10290 salt_type = SALT_TYPE_EMBEDDED;
10291 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10292 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10293 kern_type = KERN_TYPE_PDF11CM1;
10294 dgst_size = DGST_SIZE_4_4;
10295 parse_func = pdf11cm1_parse_hash;
10296 sort_by_digest = sort_by_digest_4_4;
10297 opti_type = OPTI_TYPE_ZERO_BYTE
10298 | OPTI_TYPE_NOT_ITERATED;
10299 dgst_pos0 = 0;
10300 dgst_pos1 = 1;
10301 dgst_pos2 = 2;
10302 dgst_pos3 = 3;
10303 break;
10304
10305 case 10420: hash_type = HASH_TYPE_PDFU16;
10306 salt_type = SALT_TYPE_EMBEDDED;
10307 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10308 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10309 kern_type = KERN_TYPE_PDF11CM2;
10310 dgst_size = DGST_SIZE_4_4;
10311 parse_func = pdf11cm2_parse_hash;
10312 sort_by_digest = sort_by_digest_4_4;
10313 opti_type = OPTI_TYPE_ZERO_BYTE
10314 | OPTI_TYPE_NOT_ITERATED;
10315 dgst_pos0 = 0;
10316 dgst_pos1 = 1;
10317 dgst_pos2 = 2;
10318 dgst_pos3 = 3;
10319 break;
10320
10321 case 10500: hash_type = HASH_TYPE_PDFU16;
10322 salt_type = SALT_TYPE_EMBEDDED;
10323 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10324 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10325 kern_type = KERN_TYPE_PDF14;
10326 dgst_size = DGST_SIZE_4_4;
10327 parse_func = pdf14_parse_hash;
10328 sort_by_digest = sort_by_digest_4_4;
10329 opti_type = OPTI_TYPE_ZERO_BYTE
10330 | OPTI_TYPE_NOT_ITERATED;
10331 dgst_pos0 = 0;
10332 dgst_pos1 = 1;
10333 dgst_pos2 = 2;
10334 dgst_pos3 = 3;
10335 break;
10336
10337 case 10600: hash_type = HASH_TYPE_SHA256;
10338 salt_type = SALT_TYPE_EMBEDDED;
10339 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10340 opts_type = OPTS_TYPE_PT_GENERATE_BE
10341 | OPTS_TYPE_ST_ADD80
10342 | OPTS_TYPE_ST_ADDBITS15
10343 | OPTS_TYPE_HASH_COPY;
10344 kern_type = KERN_TYPE_SHA256_PWSLT;
10345 dgst_size = DGST_SIZE_4_8;
10346 parse_func = pdf17l3_parse_hash;
10347 sort_by_digest = sort_by_digest_4_8;
10348 opti_type = OPTI_TYPE_ZERO_BYTE
10349 | OPTI_TYPE_PRECOMPUTE_INIT
10350 | OPTI_TYPE_PRECOMPUTE_MERKLE
10351 | OPTI_TYPE_EARLY_SKIP
10352 | OPTI_TYPE_NOT_ITERATED
10353 | OPTI_TYPE_APPENDED_SALT
10354 | OPTI_TYPE_RAW_HASH;
10355 dgst_pos0 = 3;
10356 dgst_pos1 = 7;
10357 dgst_pos2 = 2;
10358 dgst_pos3 = 6;
10359 break;
10360
10361 case 10700: hash_type = HASH_TYPE_PDFU32;
10362 salt_type = SALT_TYPE_EMBEDDED;
10363 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10364 opts_type = OPTS_TYPE_PT_GENERATE_LE
10365 | OPTS_TYPE_HASH_COPY;
10366 kern_type = KERN_TYPE_PDF17L8;
10367 dgst_size = DGST_SIZE_4_8;
10368 parse_func = pdf17l8_parse_hash;
10369 sort_by_digest = sort_by_digest_4_8;
10370 opti_type = OPTI_TYPE_ZERO_BYTE
10371 | OPTI_TYPE_NOT_ITERATED;
10372 dgst_pos0 = 0;
10373 dgst_pos1 = 1;
10374 dgst_pos2 = 2;
10375 dgst_pos3 = 3;
10376 break;
10377
10378 case 10800: hash_type = HASH_TYPE_SHA384;
10379 salt_type = SALT_TYPE_NONE;
10380 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10381 opts_type = OPTS_TYPE_PT_GENERATE_BE
10382 | OPTS_TYPE_PT_ADD80
10383 | OPTS_TYPE_PT_ADDBITS15;
10384 kern_type = KERN_TYPE_SHA384;
10385 dgst_size = DGST_SIZE_8_8;
10386 parse_func = sha384_parse_hash;
10387 sort_by_digest = sort_by_digest_8_8;
10388 opti_type = OPTI_TYPE_ZERO_BYTE
10389 | OPTI_TYPE_PRECOMPUTE_INIT
10390 | OPTI_TYPE_PRECOMPUTE_MERKLE
10391 | OPTI_TYPE_EARLY_SKIP
10392 | OPTI_TYPE_NOT_ITERATED
10393 | OPTI_TYPE_NOT_SALTED
10394 | OPTI_TYPE_USES_BITS_64
10395 | OPTI_TYPE_RAW_HASH;
10396 dgst_pos0 = 6;
10397 dgst_pos1 = 7;
10398 dgst_pos2 = 4;
10399 dgst_pos3 = 5;
10400 break;
10401
10402 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10403 salt_type = SALT_TYPE_EMBEDDED;
10404 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10405 opts_type = OPTS_TYPE_PT_GENERATE_LE
10406 | OPTS_TYPE_ST_BASE64
10407 | OPTS_TYPE_HASH_COPY;
10408 kern_type = KERN_TYPE_PBKDF2_SHA256;
10409 dgst_size = DGST_SIZE_4_32;
10410 parse_func = pbkdf2_sha256_parse_hash;
10411 sort_by_digest = sort_by_digest_4_32;
10412 opti_type = OPTI_TYPE_ZERO_BYTE
10413 | OPTI_TYPE_SLOW_HASH_SIMD;
10414 dgst_pos0 = 0;
10415 dgst_pos1 = 1;
10416 dgst_pos2 = 2;
10417 dgst_pos3 = 3;
10418 break;
10419
10420 case 11000: hash_type = HASH_TYPE_MD5;
10421 salt_type = SALT_TYPE_INTERN;
10422 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10423 opts_type = OPTS_TYPE_PT_GENERATE_LE
10424 | OPTS_TYPE_PT_ADD80;
10425 kern_type = KERN_TYPE_PRESTASHOP;
10426 dgst_size = DGST_SIZE_4_4;
10427 parse_func = prestashop_parse_hash;
10428 sort_by_digest = sort_by_digest_4_4;
10429 opti_type = OPTI_TYPE_ZERO_BYTE
10430 | OPTI_TYPE_PRECOMPUTE_INIT
10431 | OPTI_TYPE_NOT_ITERATED
10432 | OPTI_TYPE_PREPENDED_SALT;
10433 dgst_pos0 = 0;
10434 dgst_pos1 = 3;
10435 dgst_pos2 = 2;
10436 dgst_pos3 = 1;
10437 break;
10438
10439 case 11100: hash_type = HASH_TYPE_MD5;
10440 salt_type = SALT_TYPE_EMBEDDED;
10441 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10442 opts_type = OPTS_TYPE_PT_GENERATE_LE
10443 | OPTS_TYPE_ST_ADD80;
10444 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10445 dgst_size = DGST_SIZE_4_4;
10446 parse_func = postgresql_auth_parse_hash;
10447 sort_by_digest = sort_by_digest_4_4;
10448 opti_type = OPTI_TYPE_ZERO_BYTE
10449 | OPTI_TYPE_PRECOMPUTE_INIT
10450 | OPTI_TYPE_PRECOMPUTE_MERKLE
10451 | OPTI_TYPE_EARLY_SKIP;
10452 dgst_pos0 = 0;
10453 dgst_pos1 = 3;
10454 dgst_pos2 = 2;
10455 dgst_pos3 = 1;
10456 break;
10457
10458 case 11200: hash_type = HASH_TYPE_SHA1;
10459 salt_type = SALT_TYPE_EMBEDDED;
10460 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10461 opts_type = OPTS_TYPE_PT_GENERATE_BE
10462 | OPTS_TYPE_PT_ADD80
10463 | OPTS_TYPE_ST_HEX;
10464 kern_type = KERN_TYPE_MYSQL_AUTH;
10465 dgst_size = DGST_SIZE_4_5;
10466 parse_func = mysql_auth_parse_hash;
10467 sort_by_digest = sort_by_digest_4_5;
10468 opti_type = OPTI_TYPE_ZERO_BYTE
10469 | OPTI_TYPE_EARLY_SKIP;
10470 dgst_pos0 = 3;
10471 dgst_pos1 = 4;
10472 dgst_pos2 = 2;
10473 dgst_pos3 = 1;
10474 break;
10475
10476 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10477 salt_type = SALT_TYPE_EMBEDDED;
10478 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10479 opts_type = OPTS_TYPE_PT_GENERATE_LE
10480 | OPTS_TYPE_ST_HEX
10481 | OPTS_TYPE_ST_ADD80;
10482 kern_type = KERN_TYPE_BITCOIN_WALLET;
10483 dgst_size = DGST_SIZE_4_4;
10484 parse_func = bitcoin_wallet_parse_hash;
10485 sort_by_digest = sort_by_digest_4_4;
10486 opti_type = OPTI_TYPE_ZERO_BYTE;
10487 dgst_pos0 = 0;
10488 dgst_pos1 = 1;
10489 dgst_pos2 = 2;
10490 dgst_pos3 = 3;
10491 break;
10492
10493 case 11400: hash_type = HASH_TYPE_MD5;
10494 salt_type = SALT_TYPE_EMBEDDED;
10495 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10496 opts_type = OPTS_TYPE_PT_GENERATE_LE
10497 | OPTS_TYPE_PT_ADD80
10498 | OPTS_TYPE_HASH_COPY;
10499 kern_type = KERN_TYPE_SIP_AUTH;
10500 dgst_size = DGST_SIZE_4_4;
10501 parse_func = sip_auth_parse_hash;
10502 sort_by_digest = sort_by_digest_4_4;
10503 opti_type = OPTI_TYPE_ZERO_BYTE;
10504 dgst_pos0 = 0;
10505 dgst_pos1 = 3;
10506 dgst_pos2 = 2;
10507 dgst_pos3 = 1;
10508 break;
10509
10510 case 11500: hash_type = HASH_TYPE_CRC32;
10511 salt_type = SALT_TYPE_INTERN;
10512 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10513 opts_type = OPTS_TYPE_PT_GENERATE_LE
10514 | OPTS_TYPE_ST_GENERATE_LE
10515 | OPTS_TYPE_ST_HEX;
10516 kern_type = KERN_TYPE_CRC32;
10517 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10518 parse_func = crc32_parse_hash;
10519 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10520 opti_type = OPTI_TYPE_ZERO_BYTE;
10521 dgst_pos0 = 0;
10522 dgst_pos1 = 1;
10523 dgst_pos2 = 2;
10524 dgst_pos3 = 3;
10525 break;
10526
10527 case 11600: hash_type = HASH_TYPE_AES;
10528 salt_type = SALT_TYPE_EMBEDDED;
10529 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10530 opts_type = OPTS_TYPE_PT_GENERATE_LE
10531 | OPTS_TYPE_PT_NEVERCRACK;
10532 kern_type = KERN_TYPE_SEVEN_ZIP;
10533 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10534 parse_func = seven_zip_parse_hash;
10535 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10536 opti_type = OPTI_TYPE_ZERO_BYTE;
10537 dgst_pos0 = 0;
10538 dgst_pos1 = 1;
10539 dgst_pos2 = 2;
10540 dgst_pos3 = 3;
10541 break;
10542
10543 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10544 salt_type = SALT_TYPE_NONE;
10545 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10546 opts_type = OPTS_TYPE_PT_GENERATE_LE
10547 | OPTS_TYPE_PT_ADD01;
10548 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10549 dgst_size = DGST_SIZE_4_8;
10550 parse_func = gost2012sbog_256_parse_hash;
10551 sort_by_digest = sort_by_digest_4_8;
10552 opti_type = OPTI_TYPE_ZERO_BYTE;
10553 dgst_pos0 = 0;
10554 dgst_pos1 = 1;
10555 dgst_pos2 = 2;
10556 dgst_pos3 = 3;
10557 break;
10558
10559 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10560 salt_type = SALT_TYPE_NONE;
10561 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10562 opts_type = OPTS_TYPE_PT_GENERATE_LE
10563 | OPTS_TYPE_PT_ADD01;
10564 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10565 dgst_size = DGST_SIZE_4_16;
10566 parse_func = gost2012sbog_512_parse_hash;
10567 sort_by_digest = sort_by_digest_4_16;
10568 opti_type = OPTI_TYPE_ZERO_BYTE;
10569 dgst_pos0 = 0;
10570 dgst_pos1 = 1;
10571 dgst_pos2 = 2;
10572 dgst_pos3 = 3;
10573 break;
10574
10575 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10576 salt_type = SALT_TYPE_EMBEDDED;
10577 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10578 opts_type = OPTS_TYPE_PT_GENERATE_LE
10579 | OPTS_TYPE_ST_BASE64
10580 | OPTS_TYPE_HASH_COPY;
10581 kern_type = KERN_TYPE_PBKDF2_MD5;
10582 dgst_size = DGST_SIZE_4_32;
10583 parse_func = pbkdf2_md5_parse_hash;
10584 sort_by_digest = sort_by_digest_4_32;
10585 opti_type = OPTI_TYPE_ZERO_BYTE
10586 | OPTI_TYPE_SLOW_HASH_SIMD;
10587 dgst_pos0 = 0;
10588 dgst_pos1 = 1;
10589 dgst_pos2 = 2;
10590 dgst_pos3 = 3;
10591 break;
10592
10593 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10594 salt_type = SALT_TYPE_EMBEDDED;
10595 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10596 opts_type = OPTS_TYPE_PT_GENERATE_LE
10597 | OPTS_TYPE_ST_BASE64
10598 | OPTS_TYPE_HASH_COPY;
10599 kern_type = KERN_TYPE_PBKDF2_SHA1;
10600 dgst_size = DGST_SIZE_4_32;
10601 parse_func = pbkdf2_sha1_parse_hash;
10602 sort_by_digest = sort_by_digest_4_32;
10603 opti_type = OPTI_TYPE_ZERO_BYTE
10604 | OPTI_TYPE_SLOW_HASH_SIMD;
10605 dgst_pos0 = 0;
10606 dgst_pos1 = 1;
10607 dgst_pos2 = 2;
10608 dgst_pos3 = 3;
10609 break;
10610
10611 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10612 salt_type = SALT_TYPE_EMBEDDED;
10613 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10614 opts_type = OPTS_TYPE_PT_GENERATE_LE
10615 | OPTS_TYPE_ST_BASE64
10616 | OPTS_TYPE_HASH_COPY;
10617 kern_type = KERN_TYPE_PBKDF2_SHA512;
10618 dgst_size = DGST_SIZE_8_16;
10619 parse_func = pbkdf2_sha512_parse_hash;
10620 sort_by_digest = sort_by_digest_8_16;
10621 opti_type = OPTI_TYPE_ZERO_BYTE
10622 | OPTI_TYPE_USES_BITS_64
10623 | OPTI_TYPE_SLOW_HASH_SIMD;
10624 dgst_pos0 = 0;
10625 dgst_pos1 = 1;
10626 dgst_pos2 = 2;
10627 dgst_pos3 = 3;
10628 break;
10629
10630 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10631 salt_type = SALT_TYPE_EMBEDDED;
10632 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10633 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10634 kern_type = KERN_TYPE_ECRYPTFS;
10635 dgst_size = DGST_SIZE_8_8;
10636 parse_func = ecryptfs_parse_hash;
10637 sort_by_digest = sort_by_digest_8_8;
10638 opti_type = OPTI_TYPE_ZERO_BYTE
10639 | OPTI_TYPE_USES_BITS_64;
10640 dgst_pos0 = 0;
10641 dgst_pos1 = 1;
10642 dgst_pos2 = 2;
10643 dgst_pos3 = 3;
10644 break;
10645
10646 case 12300: hash_type = HASH_TYPE_ORACLET;
10647 salt_type = SALT_TYPE_EMBEDDED;
10648 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10649 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10650 kern_type = KERN_TYPE_ORACLET;
10651 dgst_size = DGST_SIZE_8_16;
10652 parse_func = oraclet_parse_hash;
10653 sort_by_digest = sort_by_digest_8_16;
10654 opti_type = OPTI_TYPE_ZERO_BYTE
10655 | OPTI_TYPE_USES_BITS_64;
10656 dgst_pos0 = 0;
10657 dgst_pos1 = 1;
10658 dgst_pos2 = 2;
10659 dgst_pos3 = 3;
10660 break;
10661
10662 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10663 salt_type = SALT_TYPE_EMBEDDED;
10664 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10665 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10666 kern_type = KERN_TYPE_BSDICRYPT;
10667 dgst_size = DGST_SIZE_4_4;
10668 parse_func = bsdicrypt_parse_hash;
10669 sort_by_digest = sort_by_digest_4_4;
10670 opti_type = OPTI_TYPE_ZERO_BYTE
10671 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10672 dgst_pos0 = 0;
10673 dgst_pos1 = 1;
10674 dgst_pos2 = 2;
10675 dgst_pos3 = 3;
10676 break;
10677
10678 case 12500: hash_type = HASH_TYPE_RAR3HP;
10679 salt_type = SALT_TYPE_EMBEDDED;
10680 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10681 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10682 kern_type = KERN_TYPE_RAR3;
10683 dgst_size = DGST_SIZE_4_4;
10684 parse_func = rar3hp_parse_hash;
10685 sort_by_digest = sort_by_digest_4_4;
10686 opti_type = OPTI_TYPE_ZERO_BYTE;
10687 dgst_pos0 = 0;
10688 dgst_pos1 = 1;
10689 dgst_pos2 = 2;
10690 dgst_pos3 = 3;
10691 break;
10692
10693 case 12600: hash_type = HASH_TYPE_SHA256;
10694 salt_type = SALT_TYPE_INTERN;
10695 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10696 opts_type = OPTS_TYPE_PT_GENERATE_BE
10697 | OPTS_TYPE_PT_ADD80;
10698 kern_type = KERN_TYPE_CF10;
10699 dgst_size = DGST_SIZE_4_8;
10700 parse_func = cf10_parse_hash;
10701 sort_by_digest = sort_by_digest_4_8;
10702 opti_type = OPTI_TYPE_ZERO_BYTE
10703 | OPTI_TYPE_PRECOMPUTE_INIT
10704 | OPTI_TYPE_EARLY_SKIP
10705 | OPTI_TYPE_NOT_ITERATED;
10706 dgst_pos0 = 3;
10707 dgst_pos1 = 7;
10708 dgst_pos2 = 2;
10709 dgst_pos3 = 6;
10710 break;
10711
10712 case 12700: hash_type = HASH_TYPE_AES;
10713 salt_type = SALT_TYPE_EMBEDDED;
10714 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10715 opts_type = OPTS_TYPE_PT_GENERATE_LE
10716 | OPTS_TYPE_HASH_COPY;
10717 kern_type = KERN_TYPE_MYWALLET;
10718 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10719 parse_func = mywallet_parse_hash;
10720 sort_by_digest = sort_by_digest_4_5;
10721 opti_type = OPTI_TYPE_ZERO_BYTE;
10722 dgst_pos0 = 0;
10723 dgst_pos1 = 1;
10724 dgst_pos2 = 2;
10725 dgst_pos3 = 3;
10726 break;
10727
10728 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10729 salt_type = SALT_TYPE_EMBEDDED;
10730 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10731 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10732 kern_type = KERN_TYPE_MS_DRSR;
10733 dgst_size = DGST_SIZE_4_8;
10734 parse_func = ms_drsr_parse_hash;
10735 sort_by_digest = sort_by_digest_4_8;
10736 opti_type = OPTI_TYPE_ZERO_BYTE;
10737 dgst_pos0 = 0;
10738 dgst_pos1 = 1;
10739 dgst_pos2 = 2;
10740 dgst_pos3 = 3;
10741 break;
10742
10743 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10744 salt_type = SALT_TYPE_EMBEDDED;
10745 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10746 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10747 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10748 dgst_size = DGST_SIZE_4_8;
10749 parse_func = androidfde_samsung_parse_hash;
10750 sort_by_digest = sort_by_digest_4_8;
10751 opti_type = OPTI_TYPE_ZERO_BYTE;
10752 dgst_pos0 = 0;
10753 dgst_pos1 = 1;
10754 dgst_pos2 = 2;
10755 dgst_pos3 = 3;
10756 break;
10757
10758 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10759 salt_type = SALT_TYPE_EMBEDDED;
10760 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10761 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10762 kern_type = KERN_TYPE_RAR5;
10763 dgst_size = DGST_SIZE_4_4;
10764 parse_func = rar5_parse_hash;
10765 sort_by_digest = sort_by_digest_4_4;
10766 opti_type = OPTI_TYPE_ZERO_BYTE;
10767 dgst_pos0 = 0;
10768 dgst_pos1 = 1;
10769 dgst_pos2 = 2;
10770 dgst_pos3 = 3;
10771 break;
10772
10773 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10774 salt_type = SALT_TYPE_EMBEDDED;
10775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10776 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10777 kern_type = KERN_TYPE_KRB5TGS;
10778 dgst_size = DGST_SIZE_4_4;
10779 parse_func = krb5tgs_parse_hash;
10780 sort_by_digest = sort_by_digest_4_4;
10781 opti_type = OPTI_TYPE_ZERO_BYTE
10782 | OPTI_TYPE_NOT_ITERATED;
10783 dgst_pos0 = 0;
10784 dgst_pos1 = 1;
10785 dgst_pos2 = 2;
10786 dgst_pos3 = 3;
10787 break;
10788
10789 case 13200: hash_type = HASH_TYPE_AES;
10790 salt_type = SALT_TYPE_EMBEDDED;
10791 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10792 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10793 kern_type = KERN_TYPE_AXCRYPT;
10794 dgst_size = DGST_SIZE_4_4;
10795 parse_func = axcrypt_parse_hash;
10796 sort_by_digest = sort_by_digest_4_4;
10797 opti_type = OPTI_TYPE_ZERO_BYTE;
10798 dgst_pos0 = 0;
10799 dgst_pos1 = 1;
10800 dgst_pos2 = 2;
10801 dgst_pos3 = 3;
10802 break;
10803
10804 case 13300: hash_type = HASH_TYPE_SHA1;
10805 salt_type = SALT_TYPE_NONE;
10806 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10807 opts_type = OPTS_TYPE_PT_GENERATE_BE
10808 | OPTS_TYPE_PT_ADD80
10809 | OPTS_TYPE_PT_ADDBITS15;
10810 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10811 dgst_size = DGST_SIZE_4_5;
10812 parse_func = sha1axcrypt_parse_hash;
10813 sort_by_digest = sort_by_digest_4_5;
10814 opti_type = OPTI_TYPE_ZERO_BYTE
10815 | OPTI_TYPE_PRECOMPUTE_INIT
10816 | OPTI_TYPE_EARLY_SKIP
10817 | OPTI_TYPE_NOT_ITERATED
10818 | OPTI_TYPE_NOT_SALTED;
10819 dgst_pos0 = 0;
10820 dgst_pos1 = 4;
10821 dgst_pos2 = 3;
10822 dgst_pos3 = 2;
10823 break;
10824
10825 case 13400: hash_type = HASH_TYPE_AES;
10826 salt_type = SALT_TYPE_EMBEDDED;
10827 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10828 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10829 kern_type = KERN_TYPE_KEEPASS;
10830 dgst_size = DGST_SIZE_4_4;
10831 parse_func = keepass_parse_hash;
10832 sort_by_digest = sort_by_digest_4_4;
10833 opti_type = OPTI_TYPE_ZERO_BYTE;
10834 dgst_pos0 = 0;
10835 dgst_pos1 = 1;
10836 dgst_pos2 = 2;
10837 dgst_pos3 = 3;
10838 break;
10839
10840 case 13500: hash_type = HASH_TYPE_SHA1;
10841 salt_type = SALT_TYPE_EMBEDDED;
10842 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10843 opts_type = OPTS_TYPE_PT_GENERATE_BE
10844 | OPTS_TYPE_PT_UNICODE
10845 | OPTS_TYPE_PT_ADD80;
10846 kern_type = KERN_TYPE_PSTOKEN;
10847 dgst_size = DGST_SIZE_4_5;
10848 parse_func = pstoken_parse_hash;
10849 sort_by_digest = sort_by_digest_4_5;
10850 opti_type = OPTI_TYPE_ZERO_BYTE
10851 | OPTI_TYPE_PRECOMPUTE_INIT
10852 | OPTI_TYPE_EARLY_SKIP
10853 | OPTI_TYPE_NOT_ITERATED
10854 | OPTI_TYPE_PREPENDED_SALT
10855 | OPTI_TYPE_RAW_HASH;
10856 dgst_pos0 = 3;
10857 dgst_pos1 = 4;
10858 dgst_pos2 = 2;
10859 dgst_pos3 = 1;
10860 break;
10861
10862 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10863 salt_type = SALT_TYPE_EMBEDDED;
10864 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10865 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10866 kern_type = KERN_TYPE_ZIP2;
10867 dgst_size = DGST_SIZE_4_4;
10868 parse_func = zip2_parse_hash;
10869 sort_by_digest = sort_by_digest_4_4;
10870 opti_type = OPTI_TYPE_ZERO_BYTE;
10871 dgst_pos0 = 0;
10872 dgst_pos1 = 1;
10873 dgst_pos2 = 2;
10874 dgst_pos3 = 3;
10875 break;
10876
10877 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10878 salt_type = SALT_TYPE_EMBEDDED;
10879 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10880 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10881 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10882 dgst_size = DGST_SIZE_4_5;
10883 parse_func = veracrypt_parse_hash_655331;
10884 sort_by_digest = sort_by_digest_4_5;
10885 opti_type = OPTI_TYPE_ZERO_BYTE;
10886 dgst_pos0 = 0;
10887 dgst_pos1 = 1;
10888 dgst_pos2 = 2;
10889 dgst_pos3 = 3;
10890 break;
10891
10892 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10893 salt_type = SALT_TYPE_EMBEDDED;
10894 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10895 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10896 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10897 dgst_size = DGST_SIZE_4_5;
10898 parse_func = veracrypt_parse_hash_655331;
10899 sort_by_digest = sort_by_digest_4_5;
10900 opti_type = OPTI_TYPE_ZERO_BYTE;
10901 dgst_pos0 = 0;
10902 dgst_pos1 = 1;
10903 dgst_pos2 = 2;
10904 dgst_pos3 = 3;
10905 break;
10906
10907 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10908 salt_type = SALT_TYPE_EMBEDDED;
10909 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10910 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10911 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10912 dgst_size = DGST_SIZE_4_5;
10913 parse_func = veracrypt_parse_hash_655331;
10914 sort_by_digest = sort_by_digest_4_5;
10915 opti_type = OPTI_TYPE_ZERO_BYTE;
10916 dgst_pos0 = 0;
10917 dgst_pos1 = 1;
10918 dgst_pos2 = 2;
10919 dgst_pos3 = 3;
10920 break;
10921
10922 case 13721: hash_type = HASH_TYPE_SHA512;
10923 salt_type = SALT_TYPE_EMBEDDED;
10924 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10925 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10926 kern_type = KERN_TYPE_TCSHA512_XTS512;
10927 dgst_size = DGST_SIZE_8_8;
10928 parse_func = veracrypt_parse_hash_500000;
10929 sort_by_digest = sort_by_digest_8_8;
10930 opti_type = OPTI_TYPE_ZERO_BYTE
10931 | OPTI_TYPE_USES_BITS_64;
10932 dgst_pos0 = 0;
10933 dgst_pos1 = 1;
10934 dgst_pos2 = 2;
10935 dgst_pos3 = 3;
10936 break;
10937
10938 case 13722: hash_type = HASH_TYPE_SHA512;
10939 salt_type = SALT_TYPE_EMBEDDED;
10940 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10941 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10942 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10943 dgst_size = DGST_SIZE_8_8;
10944 parse_func = veracrypt_parse_hash_500000;
10945 sort_by_digest = sort_by_digest_8_8;
10946 opti_type = OPTI_TYPE_ZERO_BYTE
10947 | OPTI_TYPE_USES_BITS_64;
10948 dgst_pos0 = 0;
10949 dgst_pos1 = 1;
10950 dgst_pos2 = 2;
10951 dgst_pos3 = 3;
10952 break;
10953
10954 case 13723: hash_type = HASH_TYPE_SHA512;
10955 salt_type = SALT_TYPE_EMBEDDED;
10956 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10957 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10958 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10959 dgst_size = DGST_SIZE_8_8;
10960 parse_func = veracrypt_parse_hash_500000;
10961 sort_by_digest = sort_by_digest_8_8;
10962 opti_type = OPTI_TYPE_ZERO_BYTE
10963 | OPTI_TYPE_USES_BITS_64;
10964 dgst_pos0 = 0;
10965 dgst_pos1 = 1;
10966 dgst_pos2 = 2;
10967 dgst_pos3 = 3;
10968 break;
10969
10970 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10971 salt_type = SALT_TYPE_EMBEDDED;
10972 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10973 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10974 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10975 dgst_size = DGST_SIZE_4_8;
10976 parse_func = veracrypt_parse_hash_500000;
10977 sort_by_digest = sort_by_digest_4_8;
10978 opti_type = OPTI_TYPE_ZERO_BYTE;
10979 dgst_pos0 = 0;
10980 dgst_pos1 = 1;
10981 dgst_pos2 = 2;
10982 dgst_pos3 = 3;
10983 break;
10984
10985 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10986 salt_type = SALT_TYPE_EMBEDDED;
10987 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10988 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10989 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10990 dgst_size = DGST_SIZE_4_8;
10991 parse_func = veracrypt_parse_hash_500000;
10992 sort_by_digest = sort_by_digest_4_8;
10993 opti_type = OPTI_TYPE_ZERO_BYTE;
10994 dgst_pos0 = 0;
10995 dgst_pos1 = 1;
10996 dgst_pos2 = 2;
10997 dgst_pos3 = 3;
10998 break;
10999
11000 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
11001 salt_type = SALT_TYPE_EMBEDDED;
11002 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11003 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11004 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
11005 dgst_size = DGST_SIZE_4_8;
11006 parse_func = veracrypt_parse_hash_500000;
11007 sort_by_digest = sort_by_digest_4_8;
11008 opti_type = OPTI_TYPE_ZERO_BYTE;
11009 dgst_pos0 = 0;
11010 dgst_pos1 = 1;
11011 dgst_pos2 = 2;
11012 dgst_pos3 = 3;
11013 break;
11014
11015 case 13741: hash_type = HASH_TYPE_RIPEMD160;
11016 salt_type = SALT_TYPE_EMBEDDED;
11017 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11018 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11019 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
11020 dgst_size = DGST_SIZE_4_5;
11021 parse_func = veracrypt_parse_hash_327661;
11022 sort_by_digest = sort_by_digest_4_5;
11023 opti_type = OPTI_TYPE_ZERO_BYTE;
11024 dgst_pos0 = 0;
11025 dgst_pos1 = 1;
11026 dgst_pos2 = 2;
11027 dgst_pos3 = 3;
11028 break;
11029
11030 case 13742: hash_type = HASH_TYPE_RIPEMD160;
11031 salt_type = SALT_TYPE_EMBEDDED;
11032 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11033 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11034 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
11035 dgst_size = DGST_SIZE_4_5;
11036 parse_func = veracrypt_parse_hash_327661;
11037 sort_by_digest = sort_by_digest_4_5;
11038 opti_type = OPTI_TYPE_ZERO_BYTE;
11039 dgst_pos0 = 0;
11040 dgst_pos1 = 1;
11041 dgst_pos2 = 2;
11042 dgst_pos3 = 3;
11043 break;
11044
11045 case 13743: hash_type = HASH_TYPE_RIPEMD160;
11046 salt_type = SALT_TYPE_EMBEDDED;
11047 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11048 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11049 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11050 dgst_size = DGST_SIZE_4_5;
11051 parse_func = veracrypt_parse_hash_327661;
11052 sort_by_digest = sort_by_digest_4_5;
11053 opti_type = OPTI_TYPE_ZERO_BYTE;
11054 dgst_pos0 = 0;
11055 dgst_pos1 = 1;
11056 dgst_pos2 = 2;
11057 dgst_pos3 = 3;
11058 break;
11059
11060 case 13751: hash_type = HASH_TYPE_SHA256;
11061 salt_type = SALT_TYPE_EMBEDDED;
11062 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11063 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11064 kern_type = KERN_TYPE_VCSHA256_XTS512;
11065 dgst_size = DGST_SIZE_4_8;
11066 parse_func = veracrypt_parse_hash_500000;
11067 sort_by_digest = sort_by_digest_4_8;
11068 opti_type = OPTI_TYPE_ZERO_BYTE;
11069 dgst_pos0 = 0;
11070 dgst_pos1 = 1;
11071 dgst_pos2 = 2;
11072 dgst_pos3 = 3;
11073 break;
11074
11075 case 13752: hash_type = HASH_TYPE_SHA256;
11076 salt_type = SALT_TYPE_EMBEDDED;
11077 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11078 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11079 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11080 dgst_size = DGST_SIZE_4_8;
11081 parse_func = veracrypt_parse_hash_500000;
11082 sort_by_digest = sort_by_digest_4_8;
11083 opti_type = OPTI_TYPE_ZERO_BYTE;
11084 dgst_pos0 = 0;
11085 dgst_pos1 = 1;
11086 dgst_pos2 = 2;
11087 dgst_pos3 = 3;
11088 break;
11089
11090 case 13753: hash_type = HASH_TYPE_SHA256;
11091 salt_type = SALT_TYPE_EMBEDDED;
11092 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11093 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11094 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11095 dgst_size = DGST_SIZE_4_8;
11096 parse_func = veracrypt_parse_hash_500000;
11097 sort_by_digest = sort_by_digest_4_8;
11098 opti_type = OPTI_TYPE_ZERO_BYTE;
11099 dgst_pos0 = 0;
11100 dgst_pos1 = 1;
11101 dgst_pos2 = 2;
11102 dgst_pos3 = 3;
11103 break;
11104
11105 case 13761: hash_type = HASH_TYPE_SHA256;
11106 salt_type = SALT_TYPE_EMBEDDED;
11107 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11108 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11109 kern_type = KERN_TYPE_VCSHA256_XTS512;
11110 dgst_size = DGST_SIZE_4_8;
11111 parse_func = veracrypt_parse_hash_200000;
11112 sort_by_digest = sort_by_digest_4_8;
11113 opti_type = OPTI_TYPE_ZERO_BYTE;
11114 dgst_pos0 = 0;
11115 dgst_pos1 = 1;
11116 dgst_pos2 = 2;
11117 dgst_pos3 = 3;
11118 break;
11119
11120 case 13762: hash_type = HASH_TYPE_SHA256;
11121 salt_type = SALT_TYPE_EMBEDDED;
11122 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11123 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11124 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11125 dgst_size = DGST_SIZE_4_8;
11126 parse_func = veracrypt_parse_hash_200000;
11127 sort_by_digest = sort_by_digest_4_8;
11128 opti_type = OPTI_TYPE_ZERO_BYTE;
11129 dgst_pos0 = 0;
11130 dgst_pos1 = 1;
11131 dgst_pos2 = 2;
11132 dgst_pos3 = 3;
11133 break;
11134
11135 case 13763: hash_type = HASH_TYPE_SHA256;
11136 salt_type = SALT_TYPE_EMBEDDED;
11137 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11138 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11139 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11140 dgst_size = DGST_SIZE_4_8;
11141 parse_func = veracrypt_parse_hash_200000;
11142 sort_by_digest = sort_by_digest_4_8;
11143 opti_type = OPTI_TYPE_ZERO_BYTE;
11144 dgst_pos0 = 0;
11145 dgst_pos1 = 1;
11146 dgst_pos2 = 2;
11147 dgst_pos3 = 3;
11148 break;
11149
11150 case 13800: hash_type = HASH_TYPE_SHA256;
11151 salt_type = SALT_TYPE_EMBEDDED;
11152 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11153 opts_type = OPTS_TYPE_PT_GENERATE_BE
11154 | OPTS_TYPE_PT_UNICODE;
11155 kern_type = KERN_TYPE_WIN8PHONE;
11156 dgst_size = DGST_SIZE_4_8;
11157 parse_func = win8phone_parse_hash;
11158 sort_by_digest = sort_by_digest_4_8;
11159 opti_type = OPTI_TYPE_ZERO_BYTE
11160 | OPTI_TYPE_PRECOMPUTE_INIT
11161 | OPTI_TYPE_EARLY_SKIP
11162 | OPTI_TYPE_NOT_ITERATED
11163 | OPTI_TYPE_RAW_HASH;
11164 dgst_pos0 = 3;
11165 dgst_pos1 = 7;
11166 dgst_pos2 = 2;
11167 dgst_pos3 = 6;
11168 break;
11169
11170 default: usage_mini_print (PROGNAME); return (-1);
11171 }
11172
11173 /**
11174 * parser
11175 */
11176
11177 data.parse_func = parse_func;
11178
11179 /**
11180 * misc stuff
11181 */
11182
11183 if (hex_salt)
11184 {
11185 if (salt_type == SALT_TYPE_INTERN)
11186 {
11187 opts_type |= OPTS_TYPE_ST_HEX;
11188 }
11189 else
11190 {
11191 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11192
11193 return (-1);
11194 }
11195 }
11196
11197 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11198 | (salt_type == SALT_TYPE_EXTERN)
11199 | (salt_type == SALT_TYPE_EMBEDDED)
11200 | (salt_type == SALT_TYPE_VIRTUAL));
11201
11202 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
11203
11204 data.hash_type = hash_type;
11205 data.attack_mode = attack_mode;
11206 data.attack_kern = attack_kern;
11207 data.attack_exec = attack_exec;
11208 data.kern_type = kern_type;
11209 data.opts_type = opts_type;
11210 data.dgst_size = dgst_size;
11211 data.salt_type = salt_type;
11212 data.isSalted = isSalted;
11213 data.sort_by_digest = sort_by_digest;
11214 data.dgst_pos0 = dgst_pos0;
11215 data.dgst_pos1 = dgst_pos1;
11216 data.dgst_pos2 = dgst_pos2;
11217 data.dgst_pos3 = dgst_pos3;
11218
11219 esalt_size = 0;
11220
11221 switch (hash_mode)
11222 {
11223 case 2500: esalt_size = sizeof (wpa_t); break;
11224 case 5300: esalt_size = sizeof (ikepsk_t); break;
11225 case 5400: esalt_size = sizeof (ikepsk_t); break;
11226 case 5500: esalt_size = sizeof (netntlm_t); break;
11227 case 5600: esalt_size = sizeof (netntlm_t); break;
11228 case 6211: esalt_size = sizeof (tc_t); break;
11229 case 6212: esalt_size = sizeof (tc_t); break;
11230 case 6213: esalt_size = sizeof (tc_t); break;
11231 case 6221: esalt_size = sizeof (tc_t); break;
11232 case 6222: esalt_size = sizeof (tc_t); break;
11233 case 6223: esalt_size = sizeof (tc_t); break;
11234 case 6231: esalt_size = sizeof (tc_t); break;
11235 case 6232: esalt_size = sizeof (tc_t); break;
11236 case 6233: esalt_size = sizeof (tc_t); break;
11237 case 6241: esalt_size = sizeof (tc_t); break;
11238 case 6242: esalt_size = sizeof (tc_t); break;
11239 case 6243: esalt_size = sizeof (tc_t); break;
11240 case 6600: esalt_size = sizeof (agilekey_t); break;
11241 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11242 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
11243 case 7300: esalt_size = sizeof (rakp_t); break;
11244 case 7500: esalt_size = sizeof (krb5pa_t); break;
11245 case 8200: esalt_size = sizeof (cloudkey_t); break;
11246 case 8800: esalt_size = sizeof (androidfde_t); break;
11247 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
11248 case 9400: esalt_size = sizeof (office2007_t); break;
11249 case 9500: esalt_size = sizeof (office2010_t); break;
11250 case 9600: esalt_size = sizeof (office2013_t); break;
11251 case 9700: esalt_size = sizeof (oldoffice01_t); break;
11252 case 9710: esalt_size = sizeof (oldoffice01_t); break;
11253 case 9720: esalt_size = sizeof (oldoffice01_t); break;
11254 case 9800: esalt_size = sizeof (oldoffice34_t); break;
11255 case 9810: esalt_size = sizeof (oldoffice34_t); break;
11256 case 9820: esalt_size = sizeof (oldoffice34_t); break;
11257 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
11258 case 10200: esalt_size = sizeof (cram_md5_t); break;
11259 case 10400: esalt_size = sizeof (pdf_t); break;
11260 case 10410: esalt_size = sizeof (pdf_t); break;
11261 case 10420: esalt_size = sizeof (pdf_t); break;
11262 case 10500: esalt_size = sizeof (pdf_t); break;
11263 case 10600: esalt_size = sizeof (pdf_t); break;
11264 case 10700: esalt_size = sizeof (pdf_t); break;
11265 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
11266 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
11267 case 11400: esalt_size = sizeof (sip_t); break;
11268 case 11600: esalt_size = sizeof (seven_zip_t); break;
11269 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
11270 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
11271 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11272 case 13000: esalt_size = sizeof (rar5_t); break;
11273 case 13100: esalt_size = sizeof (krb5tgs_t); break;
11274 case 13400: esalt_size = sizeof (keepass_t); break;
11275 case 13500: esalt_size = sizeof (pstoken_t); break;
11276 case 13600: esalt_size = sizeof (zip2_t); break;
11277 case 13711: esalt_size = sizeof (tc_t); break;
11278 case 13712: esalt_size = sizeof (tc_t); break;
11279 case 13713: esalt_size = sizeof (tc_t); break;
11280 case 13721: esalt_size = sizeof (tc_t); break;
11281 case 13722: esalt_size = sizeof (tc_t); break;
11282 case 13723: esalt_size = sizeof (tc_t); break;
11283 case 13731: esalt_size = sizeof (tc_t); break;
11284 case 13732: esalt_size = sizeof (tc_t); break;
11285 case 13733: esalt_size = sizeof (tc_t); break;
11286 case 13741: esalt_size = sizeof (tc_t); break;
11287 case 13742: esalt_size = sizeof (tc_t); break;
11288 case 13743: esalt_size = sizeof (tc_t); break;
11289 case 13751: esalt_size = sizeof (tc_t); break;
11290 case 13752: esalt_size = sizeof (tc_t); break;
11291 case 13753: esalt_size = sizeof (tc_t); break;
11292 case 13761: esalt_size = sizeof (tc_t); break;
11293 case 13762: esalt_size = sizeof (tc_t); break;
11294 case 13763: esalt_size = sizeof (tc_t); break;
11295 case 13800: esalt_size = sizeof (win8phone_t); break;
11296 }
11297
11298 data.esalt_size = esalt_size;
11299
11300 /**
11301 * choose dictionary parser
11302 */
11303
11304 if (hash_type == HASH_TYPE_LM)
11305 {
11306 get_next_word_func = get_next_word_lm;
11307 }
11308 else if (opts_type & OPTS_TYPE_PT_UPPER)
11309 {
11310 get_next_word_func = get_next_word_uc;
11311 }
11312 else
11313 {
11314 get_next_word_func = get_next_word_std;
11315 }
11316
11317 /**
11318 * dictstat
11319 */
11320
11321 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11322
11323 #ifdef _POSIX
11324 size_t dictstat_nmemb = 0;
11325 #endif
11326
11327 #ifdef _WIN
11328 uint dictstat_nmemb = 0;
11329 #endif
11330
11331 char dictstat[256] = { 0 };
11332
11333 FILE *dictstat_fp = NULL;
11334
11335 if (keyspace == 0)
11336 {
11337 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11338
11339 dictstat_fp = fopen (dictstat, "rb");
11340
11341 if (dictstat_fp)
11342 {
11343 #ifdef _POSIX
11344 struct stat tmpstat;
11345
11346 fstat (fileno (dictstat_fp), &tmpstat);
11347 #endif
11348
11349 #ifdef _WIN
11350 struct stat64 tmpstat;
11351
11352 _fstat64 (fileno (dictstat_fp), &tmpstat);
11353 #endif
11354
11355 if (tmpstat.st_mtime < COMPTIME)
11356 {
11357 /* with v0.15 the format changed so we have to ensure user is using a good version
11358 since there is no version-header in the dictstat file */
11359
11360 fclose (dictstat_fp);
11361
11362 unlink (dictstat);
11363 }
11364 else
11365 {
11366 while (!feof (dictstat_fp))
11367 {
11368 dictstat_t d;
11369
11370 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11371
11372 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11373
11374 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11375 {
11376 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11377
11378 return -1;
11379 }
11380 }
11381
11382 fclose (dictstat_fp);
11383 }
11384 }
11385 }
11386
11387 /**
11388 * potfile
11389 */
11390
11391 char potfile[256] = { 0 };
11392
11393 if (potfile_path == NULL)
11394 {
11395 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11396 }
11397 else
11398 {
11399 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11400 }
11401
11402 data.pot_fp = NULL;
11403
11404 FILE *out_fp = NULL;
11405 FILE *pot_fp = NULL;
11406
11407 if (show == 1 || left == 1)
11408 {
11409 pot_fp = fopen (potfile, "rb");
11410
11411 if (pot_fp == NULL)
11412 {
11413 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11414
11415 return (-1);
11416 }
11417
11418 if (outfile != NULL)
11419 {
11420 if ((out_fp = fopen (outfile, "ab")) == NULL)
11421 {
11422 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11423
11424 fclose (pot_fp);
11425
11426 return (-1);
11427 }
11428 }
11429 else
11430 {
11431 out_fp = stdout;
11432 }
11433 }
11434 else
11435 {
11436 if (potfile_disable == 0)
11437 {
11438 pot_fp = fopen (potfile, "ab");
11439
11440 if (pot_fp == NULL)
11441 {
11442 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11443
11444 return (-1);
11445 }
11446
11447 data.pot_fp = pot_fp;
11448 }
11449 }
11450
11451 pot_t *pot = NULL;
11452
11453 uint pot_cnt = 0;
11454 uint pot_avail = 0;
11455
11456 if (show == 1 || left == 1)
11457 {
11458 SUPPRESS_OUTPUT = 1;
11459
11460 pot_avail = count_lines (pot_fp);
11461
11462 rewind (pot_fp);
11463
11464 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11465
11466 uint pot_hashes_avail = 0;
11467
11468 uint line_num = 0;
11469
11470 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11471
11472 while (!feof (pot_fp))
11473 {
11474 line_num++;
11475
11476 int line_len = fgetl (pot_fp, line_buf);
11477
11478 if (line_len == 0) continue;
11479
11480 char *plain_buf = line_buf + line_len;
11481
11482 pot_t *pot_ptr = &pot[pot_cnt];
11483
11484 hash_t *hashes_buf = &pot_ptr->hash;
11485
11486 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11487 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11488
11489 if (pot_cnt == pot_hashes_avail)
11490 {
11491 uint pos = 0;
11492
11493 for (pos = 0; pos < INCR_POT; pos++)
11494 {
11495 if ((pot_cnt + pos) >= pot_avail) break;
11496
11497 pot_t *tmp_pot = &pot[pot_cnt + pos];
11498
11499 hash_t *tmp_hash = &tmp_pot->hash;
11500
11501 tmp_hash->digest = mymalloc (dgst_size);
11502
11503 if (isSalted)
11504 {
11505 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11506 }
11507
11508 if (esalt_size)
11509 {
11510 tmp_hash->esalt = mymalloc (esalt_size);
11511 }
11512
11513 pot_hashes_avail++;
11514 }
11515 }
11516
11517 int plain_len = 0;
11518
11519 int parser_status;
11520
11521 int iter = MAX_CUT_TRIES;
11522
11523 do
11524 {
11525 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11526 {
11527 if (line_buf[i] == ':')
11528 {
11529 line_len--;
11530
11531 break;
11532 }
11533 }
11534
11535 if (data.hash_mode != 2500)
11536 {
11537 parser_status = parse_func (line_buf, line_len, hashes_buf);
11538 }
11539 else
11540 {
11541 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11542
11543 if (line_len > max_salt_size)
11544 {
11545 parser_status = PARSER_GLOBAL_LENGTH;
11546 }
11547 else
11548 {
11549 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11550
11551 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11552
11553 hashes_buf->salt->salt_len = line_len;
11554
11555 parser_status = PARSER_OK;
11556 }
11557 }
11558
11559 // if NOT parsed without error, we add the ":" to the plain
11560
11561 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11562 {
11563 plain_len++;
11564 plain_buf--;
11565 }
11566
11567 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11568
11569 if (parser_status < PARSER_GLOBAL_ZERO)
11570 {
11571 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11572
11573 continue;
11574 }
11575
11576 if (plain_len >= 255) continue;
11577
11578 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11579
11580 pot_ptr->plain_len = plain_len;
11581
11582 pot_cnt++;
11583 }
11584
11585 myfree (line_buf);
11586
11587 fclose (pot_fp);
11588
11589 SUPPRESS_OUTPUT = 0;
11590
11591 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11592 }
11593
11594 /**
11595 * word len
11596 */
11597
11598 uint pw_min = PW_MIN;
11599 uint pw_max = PW_MAX;
11600
11601 switch (hash_mode)
11602 {
11603 case 125: if (pw_max > 32) pw_max = 32;
11604 break;
11605 case 400: if (pw_max > 40) pw_max = 40;
11606 break;
11607 case 500: if (pw_max > 16) pw_max = 16;
11608 break;
11609 case 1500: if (pw_max > 8) pw_max = 8;
11610 break;
11611 case 1600: if (pw_max > 16) pw_max = 16;
11612 break;
11613 case 1800: if (pw_max > 16) pw_max = 16;
11614 break;
11615 case 2100: if (pw_max > 16) pw_max = 16;
11616 break;
11617 case 2500: if (pw_min < 8) pw_min = 8;
11618 break;
11619 case 3000: if (pw_max > 7) pw_max = 7;
11620 break;
11621 case 5200: if (pw_max > 24) pw_max = 24;
11622 break;
11623 case 5800: if (pw_max > 16) pw_max = 16;
11624 break;
11625 case 6300: if (pw_max > 16) pw_max = 16;
11626 break;
11627 case 7400: if (pw_max > 16) pw_max = 16;
11628 break;
11629 case 7700: if (pw_max > 8) pw_max = 8;
11630 break;
11631 case 7900: if (pw_max > 48) pw_max = 48;
11632 break;
11633 case 8500: if (pw_max > 8) pw_max = 8;
11634 break;
11635 case 8600: if (pw_max > 16) pw_max = 16;
11636 break;
11637 case 9710: pw_min = 5;
11638 pw_max = 5;
11639 break;
11640 case 9810: pw_min = 5;
11641 pw_max = 5;
11642 break;
11643 case 10410: pw_min = 5;
11644 pw_max = 5;
11645 break;
11646 case 10300: if (pw_max < 3) pw_min = 3;
11647 if (pw_max > 40) pw_max = 40;
11648 break;
11649 case 10500: if (pw_max < 3) pw_min = 3;
11650 if (pw_max > 40) pw_max = 40;
11651 break;
11652 case 10700: if (pw_max > 16) pw_max = 16;
11653 break;
11654 case 11300: if (pw_max > 40) pw_max = 40;
11655 break;
11656 case 11600: if (pw_max > 32) pw_max = 32;
11657 break;
11658 case 12500: if (pw_max > 20) pw_max = 20;
11659 break;
11660 case 12800: if (pw_max > 24) pw_max = 24;
11661 break;
11662 }
11663
11664 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11665 {
11666 switch (attack_kern)
11667 {
11668 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11669 break;
11670 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11671 break;
11672 }
11673 }
11674
11675 /**
11676 * charsets : keep them together for more easy maintainnce
11677 */
11678
11679 cs_t mp_sys[6] = { { { 0 }, 0 } };
11680 cs_t mp_usr[4] = { { { 0 }, 0 } };
11681
11682 mp_setup_sys (mp_sys);
11683
11684 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11685 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11686 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11687 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11688
11689 /**
11690 * load hashes, part I: find input mode, count hashes
11691 */
11692
11693 uint hashlist_mode = 0;
11694 uint hashlist_format = HLFMT_HASHCAT;
11695
11696 uint hashes_avail = 0;
11697
11698 if ((benchmark == 0) && (stdout_flag == 0))
11699 {
11700 struct stat f;
11701
11702 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11703
11704 if ((hash_mode == 2500) ||
11705 (hash_mode == 5200) ||
11706 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11707 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11708 (hash_mode == 9000))
11709 {
11710 hashlist_mode = HL_MODE_ARG;
11711
11712 char *hashfile = myargv[optind];
11713
11714 data.hashfile = hashfile;
11715
11716 logfile_top_var_string ("target", hashfile);
11717 }
11718
11719 if (hashlist_mode == HL_MODE_ARG)
11720 {
11721 if (hash_mode == 2500)
11722 {
11723 struct stat st;
11724
11725 if (stat (data.hashfile, &st) == -1)
11726 {
11727 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11728
11729 return (-1);
11730 }
11731
11732 hashes_avail = st.st_size / sizeof (hccap_t);
11733 }
11734 else
11735 {
11736 hashes_avail = 1;
11737 }
11738 }
11739 else if (hashlist_mode == HL_MODE_FILE)
11740 {
11741 char *hashfile = myargv[optind];
11742
11743 data.hashfile = hashfile;
11744
11745 logfile_top_var_string ("target", hashfile);
11746
11747 FILE *fp = NULL;
11748
11749 if ((fp = fopen (hashfile, "rb")) == NULL)
11750 {
11751 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11752
11753 return (-1);
11754 }
11755
11756 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11757
11758 hashes_avail = count_lines (fp);
11759
11760 rewind (fp);
11761
11762 if (hashes_avail == 0)
11763 {
11764 log_error ("ERROR: hashfile is empty or corrupt");
11765
11766 fclose (fp);
11767
11768 return (-1);
11769 }
11770
11771 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11772
11773 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11774 {
11775 log_error ("ERROR: remove not supported in native hashfile-format mode");
11776
11777 fclose (fp);
11778
11779 return (-1);
11780 }
11781
11782 fclose (fp);
11783 }
11784 }
11785 else
11786 {
11787 hashlist_mode = HL_MODE_ARG;
11788
11789 hashes_avail = 1;
11790 }
11791
11792 if (hash_mode == 3000) hashes_avail *= 2;
11793
11794 data.hashlist_mode = hashlist_mode;
11795 data.hashlist_format = hashlist_format;
11796
11797 logfile_top_uint (hashlist_mode);
11798 logfile_top_uint (hashlist_format);
11799
11800 /**
11801 * load hashes, part II: allocate required memory, set pointers
11802 */
11803
11804 hash_t *hashes_buf = NULL;
11805 void *digests_buf = NULL;
11806 salt_t *salts_buf = NULL;
11807 void *esalts_buf = NULL;
11808
11809 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11810
11811 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11812
11813 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11814 {
11815 u32 hash_pos;
11816
11817 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11818 {
11819 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11820
11821 hashes_buf[hash_pos].hash_info = hash_info;
11822
11823 if (username && (remove || show || left))
11824 {
11825 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11826 }
11827
11828 if (benchmark)
11829 {
11830 hash_info->orighash = (char *) mymalloc (256);
11831 }
11832 }
11833 }
11834
11835 if (isSalted)
11836 {
11837 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11838
11839 if (esalt_size)
11840 {
11841 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11842 }
11843 }
11844 else
11845 {
11846 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11847 }
11848
11849 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11850 {
11851 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11852
11853 if (isSalted)
11854 {
11855 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11856
11857 if (esalt_size)
11858 {
11859 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11860 }
11861 }
11862 else
11863 {
11864 hashes_buf[hash_pos].salt = &salts_buf[0];
11865 }
11866 }
11867
11868 /**
11869 * load hashes, part III: parse hashes or generate them if benchmark
11870 */
11871
11872 uint hashes_cnt = 0;
11873
11874 if (benchmark == 0)
11875 {
11876 if (keyspace == 1)
11877 {
11878 // useless to read hash file for keyspace, cheat a little bit w/ optind
11879 }
11880 else if (stdout_flag == 1)
11881 {
11882 // useless to read hash file for stdout, cheat a little bit w/ optind
11883 }
11884 else if (hashes_avail == 0)
11885 {
11886 }
11887 else if (hashlist_mode == HL_MODE_ARG)
11888 {
11889 char *input_buf = myargv[optind];
11890
11891 uint input_len = strlen (input_buf);
11892
11893 logfile_top_var_string ("target", input_buf);
11894
11895 char *hash_buf = NULL;
11896 int hash_len = 0;
11897
11898 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11899
11900 bool hash_fmt_error = 0;
11901
11902 if (hash_len < 1) hash_fmt_error = 1;
11903 if (hash_buf == NULL) hash_fmt_error = 1;
11904
11905 if (hash_fmt_error)
11906 {
11907 log_info ("WARNING: Failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11908 }
11909 else
11910 {
11911 if (opts_type & OPTS_TYPE_HASH_COPY)
11912 {
11913 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11914
11915 hash_info_tmp->orighash = mystrdup (hash_buf);
11916 }
11917
11918 if (isSalted)
11919 {
11920 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11921 }
11922
11923 int parser_status = PARSER_OK;
11924
11925 if (hash_mode == 2500)
11926 {
11927 if (hash_len == 0)
11928 {
11929 log_error ("ERROR: hccap file not specified");
11930
11931 return (-1);
11932 }
11933
11934 hashlist_mode = HL_MODE_FILE;
11935
11936 data.hashlist_mode = hashlist_mode;
11937
11938 FILE *fp = fopen (hash_buf, "rb");
11939
11940 if (fp == NULL)
11941 {
11942 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11943
11944 return (-1);
11945 }
11946
11947 if (hashes_avail < 1)
11948 {
11949 log_error ("ERROR: hccap file is empty or corrupt");
11950
11951 fclose (fp);
11952
11953 return (-1);
11954 }
11955
11956 uint hccap_size = sizeof (hccap_t);
11957
11958 char *in = (char *) mymalloc (hccap_size);
11959
11960 while (!feof (fp))
11961 {
11962 int n = fread (in, hccap_size, 1, fp);
11963
11964 if (n != 1)
11965 {
11966 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11967
11968 break;
11969 }
11970
11971 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11972
11973 if (parser_status != PARSER_OK)
11974 {
11975 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11976
11977 continue;
11978 }
11979
11980 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11981
11982 if ((show == 1) || (left == 1))
11983 {
11984 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11985
11986 char *salt_ptr = (char *) tmp_salt->salt_buf;
11987
11988 int cur_pos = tmp_salt->salt_len;
11989 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11990
11991 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11992
11993 // do the appending task
11994
11995 snprintf (salt_ptr + cur_pos,
11996 rem_len,
11997 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11998 wpa->orig_mac1[0],
11999 wpa->orig_mac1[1],
12000 wpa->orig_mac1[2],
12001 wpa->orig_mac1[3],
12002 wpa->orig_mac1[4],
12003 wpa->orig_mac1[5],
12004 wpa->orig_mac2[0],
12005 wpa->orig_mac2[1],
12006 wpa->orig_mac2[2],
12007 wpa->orig_mac2[3],
12008 wpa->orig_mac2[4],
12009 wpa->orig_mac2[5]);
12010
12011 // memset () the remaining part of the salt
12012
12013 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
12014 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12015
12016 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
12017
12018 tmp_salt->salt_len += 1 + 12 + 1 + 12;
12019 }
12020
12021 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);
12022 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);
12023
12024 hashes_cnt++;
12025 }
12026
12027 fclose (fp);
12028
12029 myfree (in);
12030 }
12031 else if (hash_mode == 3000)
12032 {
12033 if (hash_len == 32)
12034 {
12035 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12036
12037 hash_t *lm_hash_left = NULL;
12038
12039 if (parser_status == PARSER_OK)
12040 {
12041 lm_hash_left = &hashes_buf[hashes_cnt];
12042
12043 hashes_cnt++;
12044 }
12045 else
12046 {
12047 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12048 }
12049
12050 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12051
12052 hash_t *lm_hash_right = NULL;
12053
12054 if (parser_status == PARSER_OK)
12055 {
12056 lm_hash_right = &hashes_buf[hashes_cnt];
12057
12058 hashes_cnt++;
12059 }
12060 else
12061 {
12062 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12063 }
12064
12065 // show / left
12066
12067 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12068 {
12069 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);
12070 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);
12071 }
12072 }
12073 else
12074 {
12075 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12076
12077 if (parser_status == PARSER_OK)
12078 {
12079 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12080 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12081 }
12082
12083 if (parser_status == PARSER_OK)
12084 {
12085 hashes_cnt++;
12086 }
12087 else
12088 {
12089 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12090 }
12091 }
12092 }
12093 else
12094 {
12095 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12096
12097 if (parser_status == PARSER_OK)
12098 {
12099 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12100 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12101 }
12102
12103 if (parser_status == PARSER_OK)
12104 {
12105 hashes_cnt++;
12106 }
12107 else
12108 {
12109 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12110 }
12111 }
12112 }
12113 }
12114 else if (hashlist_mode == HL_MODE_FILE)
12115 {
12116 char *hashfile = data.hashfile;
12117
12118 FILE *fp;
12119
12120 if ((fp = fopen (hashfile, "rb")) == NULL)
12121 {
12122 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12123
12124 return (-1);
12125 }
12126
12127 uint line_num = 0;
12128
12129 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12130
12131 while (!feof (fp))
12132 {
12133 line_num++;
12134
12135 int line_len = fgetl (fp, line_buf);
12136
12137 if (line_len == 0) continue;
12138
12139 char *hash_buf = NULL;
12140 int hash_len = 0;
12141
12142 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12143
12144 bool hash_fmt_error = 0;
12145
12146 if (hash_len < 1) hash_fmt_error = 1;
12147 if (hash_buf == NULL) hash_fmt_error = 1;
12148
12149 if (hash_fmt_error)
12150 {
12151 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12152
12153 continue;
12154 }
12155
12156 if (username)
12157 {
12158 char *user_buf = NULL;
12159 int user_len = 0;
12160
12161 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12162
12163 if (remove || show)
12164 {
12165 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12166
12167 *user = (user_t *) mymalloc (sizeof (user_t));
12168
12169 user_t *user_ptr = *user;
12170
12171 if (user_buf != NULL)
12172 {
12173 user_ptr->user_name = mystrdup (user_buf);
12174 }
12175 else
12176 {
12177 user_ptr->user_name = mystrdup ("");
12178 }
12179
12180 user_ptr->user_len = user_len;
12181 }
12182 }
12183
12184 if (opts_type & OPTS_TYPE_HASH_COPY)
12185 {
12186 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12187
12188 hash_info_tmp->orighash = mystrdup (hash_buf);
12189 }
12190
12191 if (isSalted)
12192 {
12193 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12194 }
12195
12196 if (hash_mode == 3000)
12197 {
12198 if (hash_len == 32)
12199 {
12200 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12201
12202 if (parser_status < PARSER_GLOBAL_ZERO)
12203 {
12204 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12205
12206 continue;
12207 }
12208
12209 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12210
12211 hashes_cnt++;
12212
12213 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12214
12215 if (parser_status < PARSER_GLOBAL_ZERO)
12216 {
12217 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12218
12219 continue;
12220 }
12221
12222 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12223
12224 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);
12225
12226 hashes_cnt++;
12227
12228 // show / left
12229
12230 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);
12231 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);
12232 }
12233 else
12234 {
12235 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12236
12237 if (parser_status < PARSER_GLOBAL_ZERO)
12238 {
12239 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12240
12241 continue;
12242 }
12243
12244 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);
12245
12246 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12247 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12248
12249 hashes_cnt++;
12250 }
12251 }
12252 else
12253 {
12254 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12255
12256 if (parser_status < PARSER_GLOBAL_ZERO)
12257 {
12258 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12259
12260 continue;
12261 }
12262
12263 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);
12264
12265 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12266 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12267
12268 hashes_cnt++;
12269 }
12270 }
12271
12272 myfree (line_buf);
12273
12274 fclose (fp);
12275
12276 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12277
12278 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12279 }
12280 }
12281 else
12282 {
12283 if (isSalted)
12284 {
12285 hashes_buf[0].salt->salt_len = 8;
12286
12287 // special salt handling
12288
12289 switch (hash_mode)
12290 {
12291 case 1500: hashes_buf[0].salt->salt_len = 2;
12292 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12293 break;
12294 case 1731: hashes_buf[0].salt->salt_len = 4;
12295 break;
12296 case 2410: hashes_buf[0].salt->salt_len = 4;
12297 break;
12298 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12299 break;
12300 case 3100: hashes_buf[0].salt->salt_len = 1;
12301 break;
12302 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
12303 break;
12304 case 5800: hashes_buf[0].salt->salt_len = 16;
12305 break;
12306 case 6800: hashes_buf[0].salt->salt_len = 32;
12307 break;
12308 case 8400: hashes_buf[0].salt->salt_len = 40;
12309 break;
12310 case 8800: hashes_buf[0].salt->salt_len = 16;
12311 break;
12312 case 8900: hashes_buf[0].salt->salt_len = 16;
12313 hashes_buf[0].salt->scrypt_N = 1024;
12314 hashes_buf[0].salt->scrypt_r = 1;
12315 hashes_buf[0].salt->scrypt_p = 1;
12316 break;
12317 case 9100: hashes_buf[0].salt->salt_len = 16;
12318 break;
12319 case 9300: hashes_buf[0].salt->salt_len = 14;
12320 hashes_buf[0].salt->scrypt_N = 16384;
12321 hashes_buf[0].salt->scrypt_r = 1;
12322 hashes_buf[0].salt->scrypt_p = 1;
12323 break;
12324 case 9400: hashes_buf[0].salt->salt_len = 16;
12325 break;
12326 case 9500: hashes_buf[0].salt->salt_len = 16;
12327 break;
12328 case 9600: hashes_buf[0].salt->salt_len = 16;
12329 break;
12330 case 9700: hashes_buf[0].salt->salt_len = 16;
12331 break;
12332 case 9710: hashes_buf[0].salt->salt_len = 16;
12333 break;
12334 case 9720: hashes_buf[0].salt->salt_len = 16;
12335 break;
12336 case 9800: hashes_buf[0].salt->salt_len = 16;
12337 break;
12338 case 9810: hashes_buf[0].salt->salt_len = 16;
12339 break;
12340 case 9820: hashes_buf[0].salt->salt_len = 16;
12341 break;
12342 case 10300: hashes_buf[0].salt->salt_len = 12;
12343 break;
12344 case 11500: hashes_buf[0].salt->salt_len = 4;
12345 break;
12346 case 11600: hashes_buf[0].salt->salt_len = 4;
12347 break;
12348 case 12400: hashes_buf[0].salt->salt_len = 4;
12349 break;
12350 case 12500: hashes_buf[0].salt->salt_len = 8;
12351 break;
12352 case 12600: hashes_buf[0].salt->salt_len = 64;
12353 break;
12354 }
12355
12356 // special esalt handling
12357
12358 switch (hash_mode)
12359 {
12360 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12361 break;
12362 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12363 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12364 break;
12365 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12366 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12367 break;
12368 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12369 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12370 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12371 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12372 break;
12373 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12374 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12375 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12376 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12377 break;
12378 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12379 break;
12380 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12381 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12382 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12383 break;
12384 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12385 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12386 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12387 break;
12388 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12389 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12390 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12391 break;
12392 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12393 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12394 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12395 break;
12396 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12397 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12398 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12399 break;
12400 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12401 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12402 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12403 break;
12404 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12405 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12406 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12407 break;
12408 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12409 break;
12410 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12411 break;
12412 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12413 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12414 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12415 break;
12416 }
12417 }
12418
12419 // set hashfile
12420
12421 switch (hash_mode)
12422 {
12423 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12424 break;
12425 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12426 break;
12427 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12428 break;
12429 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12430 break;
12431 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12432 break;
12433 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12434 break;
12435 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12436 break;
12437 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12438 break;
12439 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12440 break;
12441 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12442 break;
12443 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12444 break;
12445 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12446 break;
12447 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12448 break;
12449 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12450 break;
12451 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12452 break;
12453 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12454 break;
12455 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12456 break;
12457 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12458 break;
12459 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12460 break;
12461 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12462 break;
12463 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12464 break;
12465 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12466 break;
12467 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12468 break;
12469 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12470 break;
12471 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12472 break;
12473 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12474 break;
12475 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12476 break;
12477 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12478 break;
12479 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12480 break;
12481 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12482 break;
12483 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12484 break;
12485 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12486 break;
12487 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12488 break;
12489 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12490 break;
12491 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12492 break;
12493 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12494 break;
12495 }
12496
12497 // set default iterations
12498
12499 switch (hash_mode)
12500 {
12501 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12502 break;
12503 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12504 break;
12505 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12506 break;
12507 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12508 break;
12509 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12510 break;
12511 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12512 break;
12513 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12514 break;
12515 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12516 break;
12517 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12518 break;
12519 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12520 break;
12521 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12522 break;
12523 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12524 break;
12525 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12526 break;
12527 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12528 break;
12529 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12530 break;
12531 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12532 break;
12533 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12534 break;
12535 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12536 break;
12537 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12538 break;
12539 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12540 break;
12541 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12542 break;
12543 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12544 break;
12545 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12546 break;
12547 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12548 break;
12549 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12550 break;
12551 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12552 break;
12553 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12554 break;
12555 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12556 break;
12557 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12558 break;
12559 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12560 break;
12561 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12562 break;
12563 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12564 break;
12565 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12566 break;
12567 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12568 break;
12569 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12570 break;
12571 case 8900: hashes_buf[0].salt->salt_iter = 1;
12572 break;
12573 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12574 break;
12575 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12576 break;
12577 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12578 break;
12579 case 9300: hashes_buf[0].salt->salt_iter = 1;
12580 break;
12581 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12582 break;
12583 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12584 break;
12585 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12586 break;
12587 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12588 break;
12589 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12590 break;
12591 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12592 break;
12593 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12594 break;
12595 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12596 break;
12597 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12598 break;
12599 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12600 break;
12601 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12602 break;
12603 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12604 break;
12605 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12606 break;
12607 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12608 break;
12609 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12610 break;
12611 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12612 break;
12613 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12614 break;
12615 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12616 break;
12617 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12618 break;
12619 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12620 break;
12621 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12622 break;
12623 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12624 break;
12625 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12626 break;
12627 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12628 break;
12629 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12630 break;
12631 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12632 break;
12633 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12634 break;
12635 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12636 break;
12637 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12638 break;
12639 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12640 break;
12641 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12642 break;
12643 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12644 break;
12645 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12646 break;
12647 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12648 break;
12649 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12650 break;
12651 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12652 break;
12653 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12654 break;
12655 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12656 break;
12657 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12658 break;
12659 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12660 break;
12661 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12662 break;
12663 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12664 break;
12665 }
12666
12667 hashes_cnt = 1;
12668 }
12669
12670 if (show == 1 || left == 1)
12671 {
12672 for (uint i = 0; i < pot_cnt; i++)
12673 {
12674 pot_t *pot_ptr = &pot[i];
12675
12676 hash_t *hashes_buf = &pot_ptr->hash;
12677
12678 local_free (hashes_buf->digest);
12679
12680 if (isSalted)
12681 {
12682 local_free (hashes_buf->salt);
12683 }
12684 }
12685
12686 local_free (pot);
12687
12688 if (data.quiet == 0) log_info_nn ("");
12689
12690 return (0);
12691 }
12692
12693 if ((keyspace == 0) && (stdout_flag == 0))
12694 {
12695 if (hashes_cnt == 0)
12696 {
12697 log_error ("ERROR: No hashes loaded");
12698
12699 return (-1);
12700 }
12701 }
12702
12703 /**
12704 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12705 */
12706
12707 if (data.outfile != NULL)
12708 {
12709 if (data.hashfile != NULL)
12710 {
12711 #ifdef _POSIX
12712 struct stat tmpstat_outfile;
12713 struct stat tmpstat_hashfile;
12714 #endif
12715
12716 #ifdef _WIN
12717 struct stat64 tmpstat_outfile;
12718 struct stat64 tmpstat_hashfile;
12719 #endif
12720
12721 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12722
12723 if (tmp_outfile_fp)
12724 {
12725 #ifdef _POSIX
12726 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12727 #endif
12728
12729 #ifdef _WIN
12730 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12731 #endif
12732
12733 fclose (tmp_outfile_fp);
12734 }
12735
12736 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12737
12738 if (tmp_hashfile_fp)
12739 {
12740 #ifdef _POSIX
12741 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12742 #endif
12743
12744 #ifdef _WIN
12745 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12746 #endif
12747
12748 fclose (tmp_hashfile_fp);
12749 }
12750
12751 if (tmp_outfile_fp && tmp_outfile_fp)
12752 {
12753 tmpstat_outfile.st_mode = 0;
12754 tmpstat_outfile.st_nlink = 0;
12755 tmpstat_outfile.st_uid = 0;
12756 tmpstat_outfile.st_gid = 0;
12757 tmpstat_outfile.st_rdev = 0;
12758 tmpstat_outfile.st_atime = 0;
12759
12760 tmpstat_hashfile.st_mode = 0;
12761 tmpstat_hashfile.st_nlink = 0;
12762 tmpstat_hashfile.st_uid = 0;
12763 tmpstat_hashfile.st_gid = 0;
12764 tmpstat_hashfile.st_rdev = 0;
12765 tmpstat_hashfile.st_atime = 0;
12766
12767 #ifdef _POSIX
12768 tmpstat_outfile.st_blksize = 0;
12769 tmpstat_outfile.st_blocks = 0;
12770
12771 tmpstat_hashfile.st_blksize = 0;
12772 tmpstat_hashfile.st_blocks = 0;
12773 #endif
12774
12775 #ifdef _POSIX
12776 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12777 {
12778 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12779
12780 return (-1);
12781 }
12782 #endif
12783
12784 #ifdef _WIN
12785 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12786 {
12787 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12788
12789 return (-1);
12790 }
12791 #endif
12792 }
12793 }
12794 }
12795
12796 /**
12797 * Remove duplicates
12798 */
12799
12800 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12801
12802 if (isSalted)
12803 {
12804 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12805 }
12806 else
12807 {
12808 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12809 }
12810
12811 uint hashes_cnt_orig = hashes_cnt;
12812
12813 hashes_cnt = 1;
12814
12815 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12816 {
12817 if (isSalted)
12818 {
12819 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12820 {
12821 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12822 }
12823 }
12824 else
12825 {
12826 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12827 }
12828
12829 if (hashes_pos > hashes_cnt)
12830 {
12831 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12832 }
12833
12834 hashes_cnt++;
12835 }
12836
12837 /**
12838 * Potfile removes
12839 */
12840
12841 uint potfile_remove_cracks = 0;
12842
12843 if (potfile_disable == 0)
12844 {
12845 hash_t hash_buf;
12846
12847 hash_buf.digest = mymalloc (dgst_size);
12848 hash_buf.salt = NULL;
12849 hash_buf.esalt = NULL;
12850 hash_buf.hash_info = NULL;
12851 hash_buf.cracked = 0;
12852
12853 if (isSalted)
12854 {
12855 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12856 }
12857
12858 if (esalt_size)
12859 {
12860 hash_buf.esalt = mymalloc (esalt_size);
12861 }
12862
12863 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12864
12865 // no solution for these special hash types (for instane because they use hashfile in output etc)
12866 if ((hash_mode != 5200) &&
12867 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12868 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12869 (hash_mode != 9000))
12870 {
12871 FILE *fp = fopen (potfile, "rb");
12872
12873 if (fp != NULL)
12874 {
12875 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12876
12877 // to be safe work with a copy (because of line_len loop, i etc)
12878 // moved up here because it's easier to handle continue case
12879 // it's just 64kb
12880
12881 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12882
12883 while (!feof (fp))
12884 {
12885 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12886
12887 if (ptr == NULL) break;
12888
12889 int line_len = strlen (line_buf);
12890
12891 if (line_len == 0) continue;
12892
12893 int iter = MAX_CUT_TRIES;
12894
12895 for (int i = line_len - 1; i && iter; i--, line_len--)
12896 {
12897 if (line_buf[i] != ':') continue;
12898
12899 if (isSalted)
12900 {
12901 memset (hash_buf.salt, 0, sizeof (salt_t));
12902 }
12903
12904 hash_t *found = NULL;
12905
12906 if (hash_mode == 6800)
12907 {
12908 if (i < 64) // 64 = 16 * uint in salt_buf[]
12909 {
12910 // manipulate salt_buf
12911 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12912
12913 hash_buf.salt->salt_len = i;
12914
12915 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12916 }
12917 }
12918 else if (hash_mode == 2500)
12919 {
12920 if (i < 64) // 64 = 16 * uint in salt_buf[]
12921 {
12922 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12923 // manipulate salt_buf
12924
12925 memcpy (line_buf_cpy, line_buf, i);
12926
12927 char *mac2_pos = strrchr (line_buf_cpy, ':');
12928
12929 if (mac2_pos == NULL) continue;
12930
12931 mac2_pos[0] = 0;
12932 mac2_pos++;
12933
12934 if (strlen (mac2_pos) != 12) continue;
12935
12936 char *mac1_pos = strrchr (line_buf_cpy, ':');
12937
12938 if (mac1_pos == NULL) continue;
12939
12940 mac1_pos[0] = 0;
12941 mac1_pos++;
12942
12943 if (strlen (mac1_pos) != 12) continue;
12944
12945 uint essid_length = mac1_pos - line_buf_cpy - 1;
12946
12947 // here we need the ESSID
12948 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12949
12950 hash_buf.salt->salt_len = essid_length;
12951
12952 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12953
12954 if (found)
12955 {
12956 wpa_t *wpa = (wpa_t *) found->esalt;
12957
12958 // compare hex string(s) vs binary MAC address(es)
12959
12960 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12961 {
12962 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12963 {
12964 found = NULL;
12965
12966 break;
12967 }
12968 }
12969
12970 // early skip ;)
12971 if (!found) continue;
12972
12973 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12974 {
12975 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12976 {
12977 found = NULL;
12978
12979 break;
12980 }
12981 }
12982 }
12983 }
12984 }
12985 else
12986 {
12987 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12988
12989 if (parser_status == PARSER_OK)
12990 {
12991 if (isSalted)
12992 {
12993 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12994 }
12995 else
12996 {
12997 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12998 }
12999 }
13000 }
13001
13002 if (found == NULL) continue;
13003
13004 if (!found->cracked) potfile_remove_cracks++;
13005
13006 found->cracked = 1;
13007
13008 if (found) break;
13009
13010 iter--;
13011 }
13012 }
13013
13014 myfree (line_buf_cpy);
13015
13016 myfree (line_buf);
13017
13018 fclose (fp);
13019 }
13020 }
13021
13022 if (esalt_size)
13023 {
13024 local_free (hash_buf.esalt);
13025 }
13026
13027 if (isSalted)
13028 {
13029 local_free (hash_buf.salt);
13030 }
13031
13032 local_free (hash_buf.digest);
13033 }
13034
13035 /**
13036 * Now generate all the buffers required for later
13037 */
13038
13039 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
13040
13041 salt_t *salts_buf_new = NULL;
13042 void *esalts_buf_new = NULL;
13043
13044 if (isSalted)
13045 {
13046 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
13047
13048 if (esalt_size)
13049 {
13050 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
13051 }
13052 }
13053 else
13054 {
13055 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13056 }
13057
13058 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13059
13060 uint digests_cnt = hashes_cnt;
13061 uint digests_done = 0;
13062
13063 size_t size_digests = digests_cnt * dgst_size;
13064 size_t size_shown = digests_cnt * sizeof (uint);
13065
13066 uint *digests_shown = (uint *) mymalloc (size_shown);
13067 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13068
13069 uint salts_cnt = 0;
13070 uint salts_done = 0;
13071
13072 hashinfo_t **hash_info = NULL;
13073
13074 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13075 {
13076 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13077
13078 if (username && (remove || show))
13079 {
13080 uint user_pos;
13081
13082 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13083 {
13084 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13085
13086 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13087 }
13088 }
13089 }
13090
13091 uint *salts_shown = (uint *) mymalloc (size_shown);
13092
13093 salt_t *salt_buf;
13094
13095 {
13096 // copied from inner loop
13097
13098 salt_buf = &salts_buf_new[salts_cnt];
13099
13100 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13101
13102 if (esalt_size)
13103 {
13104 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13105 }
13106
13107 salt_buf->digests_cnt = 0;
13108 salt_buf->digests_done = 0;
13109 salt_buf->digests_offset = 0;
13110
13111 salts_cnt++;
13112 }
13113
13114 if (hashes_buf[0].cracked == 1)
13115 {
13116 digests_shown[0] = 1;
13117
13118 digests_done++;
13119
13120 salt_buf->digests_done++;
13121 }
13122
13123 salt_buf->digests_cnt++;
13124
13125 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13126
13127 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13128 {
13129 hash_info[0] = hashes_buf[0].hash_info;
13130 }
13131
13132 // copy from inner loop
13133
13134 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13135 {
13136 if (isSalted)
13137 {
13138 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13139 {
13140 salt_buf = &salts_buf_new[salts_cnt];
13141
13142 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13143
13144 if (esalt_size)
13145 {
13146 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13147 }
13148
13149 salt_buf->digests_cnt = 0;
13150 salt_buf->digests_done = 0;
13151 salt_buf->digests_offset = hashes_pos;
13152
13153 salts_cnt++;
13154 }
13155 }
13156
13157 if (hashes_buf[hashes_pos].cracked == 1)
13158 {
13159 digests_shown[hashes_pos] = 1;
13160
13161 digests_done++;
13162
13163 salt_buf->digests_done++;
13164 }
13165
13166 salt_buf->digests_cnt++;
13167
13168 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13169
13170 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13171 {
13172 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13173 }
13174 }
13175
13176 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13177 {
13178 salt_t *salt_buf = &salts_buf_new[salt_pos];
13179
13180 if (salt_buf->digests_done == salt_buf->digests_cnt)
13181 {
13182 salts_shown[salt_pos] = 1;
13183
13184 salts_done++;
13185 }
13186
13187 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13188 }
13189
13190 local_free (digests_buf);
13191 local_free (salts_buf);
13192 local_free (esalts_buf);
13193
13194 digests_buf = digests_buf_new;
13195 salts_buf = salts_buf_new;
13196 esalts_buf = esalts_buf_new;
13197
13198 local_free (hashes_buf);
13199
13200 /**
13201 * special modification not set from parser
13202 */
13203
13204 switch (hash_mode)
13205 {
13206 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13207 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13208 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13209 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13210 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13211 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13212 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13213 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13214 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13215 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13216 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13217 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13218 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13219 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13220 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13221 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13222 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13223 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13224 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13225 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13226 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13227 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13228 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13229 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13230 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13231 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13232 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13233 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13234 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13235 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13236 }
13237
13238 if (truecrypt_keyfiles)
13239 {
13240 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13241
13242 char *keyfiles = strdup (truecrypt_keyfiles);
13243
13244 char *keyfile = strtok (keyfiles, ",");
13245
13246 do
13247 {
13248 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13249
13250 } while ((keyfile = strtok (NULL, ",")) != NULL);
13251
13252 free (keyfiles);
13253 }
13254
13255 if (veracrypt_keyfiles)
13256 {
13257 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13258
13259 char *keyfiles = strdup (veracrypt_keyfiles);
13260
13261 char *keyfile = strtok (keyfiles, ",");
13262
13263 do
13264 {
13265 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13266
13267 } while ((keyfile = strtok (NULL, ",")) != NULL);
13268
13269 free (keyfiles);
13270 }
13271
13272 data.digests_cnt = digests_cnt;
13273 data.digests_done = digests_done;
13274 data.digests_buf = digests_buf;
13275 data.digests_shown = digests_shown;
13276 data.digests_shown_tmp = digests_shown_tmp;
13277
13278 data.salts_cnt = salts_cnt;
13279 data.salts_done = salts_done;
13280 data.salts_buf = salts_buf;
13281 data.salts_shown = salts_shown;
13282
13283 data.esalts_buf = esalts_buf;
13284 data.hash_info = hash_info;
13285
13286 /**
13287 * Automatic Optimizers
13288 */
13289
13290 if (salts_cnt == 1)
13291 opti_type |= OPTI_TYPE_SINGLE_SALT;
13292
13293 if (digests_cnt == 1)
13294 opti_type |= OPTI_TYPE_SINGLE_HASH;
13295
13296 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13297 opti_type |= OPTI_TYPE_NOT_ITERATED;
13298
13299 if (attack_mode == ATTACK_MODE_BF)
13300 opti_type |= OPTI_TYPE_BRUTE_FORCE;
13301
13302 data.opti_type = opti_type;
13303
13304 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13305 {
13306 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13307 {
13308 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13309 {
13310 if (opts_type & OPTS_TYPE_ST_ADD80)
13311 {
13312 opts_type &= ~OPTS_TYPE_ST_ADD80;
13313 opts_type |= OPTS_TYPE_PT_ADD80;
13314 }
13315
13316 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13317 {
13318 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13319 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13320 }
13321
13322 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13323 {
13324 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13325 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13326 }
13327 }
13328 }
13329 }
13330
13331 /**
13332 * Some algorithm, like descrypt, can benefit from JIT compilation
13333 */
13334
13335 int force_jit_compilation = -1;
13336
13337 if (hash_mode == 8900)
13338 {
13339 force_jit_compilation = 8900;
13340 }
13341 else if (hash_mode == 9300)
13342 {
13343 force_jit_compilation = 8900;
13344 }
13345 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13346 {
13347 force_jit_compilation = 1500;
13348 }
13349
13350 /**
13351 * generate bitmap tables
13352 */
13353
13354 const uint bitmap_shift1 = 5;
13355 const uint bitmap_shift2 = 13;
13356
13357 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13358
13359 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13360 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13361 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13362 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13363 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13364 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13365 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13366 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13367
13368 uint bitmap_bits;
13369 uint bitmap_nums;
13370 uint bitmap_mask;
13371 uint bitmap_size;
13372
13373 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13374 {
13375 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13376
13377 bitmap_nums = 1 << bitmap_bits;
13378
13379 bitmap_mask = bitmap_nums - 1;
13380
13381 bitmap_size = bitmap_nums * sizeof (uint);
13382
13383 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13384
13385 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;
13386 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;
13387
13388 break;
13389 }
13390
13391 bitmap_nums = 1 << bitmap_bits;
13392
13393 bitmap_mask = bitmap_nums - 1;
13394
13395 bitmap_size = bitmap_nums * sizeof (uint);
13396
13397 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);
13398 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);
13399
13400 /**
13401 * prepare quick rule
13402 */
13403
13404 data.rule_buf_l = rule_buf_l;
13405 data.rule_buf_r = rule_buf_r;
13406
13407 int rule_len_l = (int) strlen (rule_buf_l);
13408 int rule_len_r = (int) strlen (rule_buf_r);
13409
13410 data.rule_len_l = rule_len_l;
13411 data.rule_len_r = rule_len_r;
13412
13413 /**
13414 * load rules
13415 */
13416
13417 uint *all_kernel_rules_cnt = NULL;
13418
13419 kernel_rule_t **all_kernel_rules_buf = NULL;
13420
13421 if (rp_files_cnt)
13422 {
13423 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13424
13425 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13426 }
13427
13428 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13429
13430 int rule_len = 0;
13431
13432 for (uint i = 0; i < rp_files_cnt; i++)
13433 {
13434 uint kernel_rules_avail = 0;
13435
13436 uint kernel_rules_cnt = 0;
13437
13438 kernel_rule_t *kernel_rules_buf = NULL;
13439
13440 char *rp_file = rp_files[i];
13441
13442 char in[BLOCK_SIZE] = { 0 };
13443 char out[BLOCK_SIZE] = { 0 };
13444
13445 FILE *fp = NULL;
13446
13447 uint rule_line = 0;
13448
13449 if ((fp = fopen (rp_file, "rb")) == NULL)
13450 {
13451 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13452
13453 return (-1);
13454 }
13455
13456 while (!feof (fp))
13457 {
13458 memset (rule_buf, 0, HCBUFSIZ);
13459
13460 rule_len = fgetl (fp, rule_buf);
13461
13462 rule_line++;
13463
13464 if (rule_len == 0) continue;
13465
13466 if (rule_buf[0] == '#') continue;
13467
13468 if (kernel_rules_avail == kernel_rules_cnt)
13469 {
13470 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13471
13472 kernel_rules_avail += INCR_RULES;
13473 }
13474
13475 memset (in, 0, BLOCK_SIZE);
13476 memset (out, 0, BLOCK_SIZE);
13477
13478 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13479
13480 if (result == -1)
13481 {
13482 log_info ("WARNING: Skipping invalid or unsupported rule in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13483
13484 continue;
13485 }
13486
13487 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13488 {
13489 log_info ("WARNING: Cannot convert rule for use on device in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13490
13491 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13492
13493 continue;
13494 }
13495
13496 /* its so slow
13497 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13498 {
13499 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13500
13501 continue;
13502 }
13503 */
13504
13505 kernel_rules_cnt++;
13506 }
13507
13508 fclose (fp);
13509
13510 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13511
13512 all_kernel_rules_buf[i] = kernel_rules_buf;
13513 }
13514
13515 /**
13516 * merge rules or automatic rule generator
13517 */
13518
13519 uint kernel_rules_cnt = 0;
13520
13521 kernel_rule_t *kernel_rules_buf = NULL;
13522
13523 if (attack_mode == ATTACK_MODE_STRAIGHT)
13524 {
13525 if (rp_files_cnt)
13526 {
13527 kernel_rules_cnt = 1;
13528
13529 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13530
13531 repeats[0] = kernel_rules_cnt;
13532
13533 for (uint i = 0; i < rp_files_cnt; i++)
13534 {
13535 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13536
13537 repeats[i + 1] = kernel_rules_cnt;
13538 }
13539
13540 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13541
13542 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13543
13544 for (uint i = 0; i < kernel_rules_cnt; i++)
13545 {
13546 uint out_pos = 0;
13547
13548 kernel_rule_t *out = &kernel_rules_buf[i];
13549
13550 for (uint j = 0; j < rp_files_cnt; j++)
13551 {
13552 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13553 uint in_pos;
13554
13555 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13556
13557 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13558 {
13559 if (out_pos == RULES_MAX - 1)
13560 {
13561 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13562
13563 break;
13564 }
13565
13566 out->cmds[out_pos] = in->cmds[in_pos];
13567 }
13568 }
13569 }
13570
13571 local_free (repeats);
13572 }
13573 else if (rp_gen)
13574 {
13575 uint kernel_rules_avail = 0;
13576
13577 while (kernel_rules_cnt < rp_gen)
13578 {
13579 if (kernel_rules_avail == kernel_rules_cnt)
13580 {
13581 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13582
13583 kernel_rules_avail += INCR_RULES;
13584 }
13585
13586 memset (rule_buf, 0, HCBUFSIZ);
13587
13588 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13589
13590 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13591
13592 kernel_rules_cnt++;
13593 }
13594 }
13595 }
13596
13597 myfree (rule_buf);
13598
13599 /**
13600 * generate NOP rules
13601 */
13602
13603 if (kernel_rules_cnt == 0)
13604 {
13605 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13606
13607 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13608
13609 kernel_rules_cnt++;
13610 }
13611
13612 data.kernel_rules_cnt = kernel_rules_cnt;
13613 data.kernel_rules_buf = kernel_rules_buf;
13614
13615 /**
13616 * OpenCL platforms: detect
13617 */
13618
13619 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13620 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13621
13622 cl_uint platforms_cnt = 0;
13623 cl_uint platform_devices_cnt = 0;
13624
13625 if (keyspace == 0)
13626 {
13627 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13628
13629 if (platforms_cnt == 0)
13630 {
13631 log_info ("");
13632 log_info ("ATTENTION! No OpenCL compatible platform found");
13633 log_info ("");
13634 log_info ("You're probably missing the OpenCL runtime installation");
13635 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13636 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13637 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13638 log_info ("");
13639
13640 return (-1);
13641 }
13642
13643 if (opencl_platforms_filter != (uint) -1)
13644 {
13645 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13646
13647 if (opencl_platforms_filter > platform_cnt_mask)
13648 {
13649 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13650
13651 return (-1);
13652 }
13653 }
13654 }
13655
13656 if (opencl_device_types == NULL)
13657 {
13658 /**
13659 * OpenCL device types:
13660 * 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.
13661 */
13662
13663 cl_device_type device_types_all = 0;
13664
13665 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13666 {
13667 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13668
13669 cl_platform_id platform = platforms[platform_id];
13670
13671 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13672
13673 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13674 {
13675 cl_device_id device = platform_devices[platform_devices_id];
13676
13677 cl_device_type device_type;
13678
13679 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13680
13681 device_types_all |= device_type;
13682 }
13683 }
13684
13685 // In such a case, automatically enable CPU device type support, since it's disabled by default.
13686
13687 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13688 {
13689 device_types_filter |= CL_DEVICE_TYPE_CPU;
13690 }
13691
13692 // In another case, when the user uses --stdout, using CPU devices is much faster to setup
13693 // If we have a CPU device, force it to be used
13694
13695 if (stdout_flag == 1)
13696 {
13697 if (device_types_all & CL_DEVICE_TYPE_CPU)
13698 {
13699 device_types_filter = CL_DEVICE_TYPE_CPU;
13700 }
13701 }
13702 }
13703
13704 /**
13705 * OpenCL devices: simply push all devices from all platforms into the same device array
13706 */
13707
13708 int need_adl = 0;
13709 int need_nvapi = 0;
13710 int need_nvml = 0;
13711 int need_xnvctrl = 0;
13712
13713 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13714
13715 data.devices_param = devices_param;
13716
13717 uint devices_cnt = 0;
13718
13719 uint devices_active = 0;
13720
13721 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13722 {
13723 cl_platform_id platform = platforms[platform_id];
13724
13725 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13726
13727 char platform_vendor[INFOSZ] = { 0 };
13728
13729 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13730
13731 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13732 // this causes trouble with vendor id based macros
13733 // we'll assign generic to those without special optimization available
13734
13735 cl_uint platform_vendor_id = 0;
13736
13737 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13738 {
13739 platform_vendor_id = VENDOR_ID_AMD;
13740 }
13741 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13742 {
13743 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13744 }
13745 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13746 {
13747 platform_vendor_id = VENDOR_ID_APPLE;
13748 }
13749 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13750 {
13751 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13752 }
13753 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13754 {
13755 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13756 }
13757 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13758 {
13759 platform_vendor_id = VENDOR_ID_MESA;
13760 }
13761 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13762 {
13763 platform_vendor_id = VENDOR_ID_NV;
13764 }
13765 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13766 {
13767 platform_vendor_id = VENDOR_ID_POCL;
13768 }
13769 else
13770 {
13771 platform_vendor_id = VENDOR_ID_GENERIC;
13772 }
13773
13774 const uint platform_skipped = ((opencl_platforms_filter & (1 << platform_id)) == 0);
13775
13776 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13777 {
13778 if (machine_readable == 0)
13779 {
13780 if (platform_skipped == 0)
13781 {
13782 const int len = log_info ("OpenCL Platform #%u: %s", platform_id + 1, platform_vendor);
13783
13784 char line[256] = { 0 };
13785
13786 for (int i = 0; i < len; i++) line[i] = '=';
13787
13788 log_info (line);
13789 }
13790 else
13791 {
13792 log_info ("OpenCL Platform #%u: %s, skipped", platform_id + 1, platform_vendor);
13793 log_info ("");
13794 }
13795 }
13796 }
13797
13798 if (platform_skipped == 1) continue;
13799
13800 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13801 {
13802 size_t param_value_size = 0;
13803
13804 const uint device_id = devices_cnt;
13805
13806 hc_device_param_t *device_param = &data.devices_param[device_id];
13807
13808 device_param->platform_vendor_id = platform_vendor_id;
13809
13810 device_param->device = platform_devices[platform_devices_id];
13811
13812 device_param->device_id = device_id;
13813
13814 device_param->platform_devices_id = platform_devices_id;
13815
13816 // device_type
13817
13818 cl_device_type device_type;
13819
13820 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13821
13822 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13823
13824 device_param->device_type = device_type;
13825
13826 // device_name
13827
13828 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13829
13830 char *device_name = (char *) mymalloc (param_value_size);
13831
13832 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13833
13834 device_param->device_name = device_name;
13835
13836 // device_vendor
13837
13838 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13839
13840 char *device_vendor = (char *) mymalloc (param_value_size);
13841
13842 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13843
13844 device_param->device_vendor = device_vendor;
13845
13846 cl_uint device_vendor_id = 0;
13847
13848 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13849 {
13850 device_vendor_id = VENDOR_ID_AMD;
13851 }
13852 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13853 {
13854 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13855 }
13856 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13857 {
13858 device_vendor_id = VENDOR_ID_APPLE;
13859 }
13860 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13861 {
13862 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13863 }
13864 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13865 {
13866 device_vendor_id = VENDOR_ID_INTEL_SDK;
13867 }
13868 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13869 {
13870 device_vendor_id = VENDOR_ID_MESA;
13871 }
13872 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13873 {
13874 device_vendor_id = VENDOR_ID_NV;
13875 }
13876 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13877 {
13878 device_vendor_id = VENDOR_ID_POCL;
13879 }
13880 else
13881 {
13882 device_vendor_id = VENDOR_ID_GENERIC;
13883 }
13884
13885 device_param->device_vendor_id = device_vendor_id;
13886
13887 // tuning db
13888
13889 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13890
13891 // device_version
13892
13893 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13894
13895 char *device_version = (char *) mymalloc (param_value_size);
13896
13897 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13898
13899 device_param->device_version = device_version;
13900
13901 // device_opencl_version
13902
13903 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13904
13905 char *device_opencl_version = (char *) mymalloc (param_value_size);
13906
13907 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13908
13909 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13910
13911 myfree (device_opencl_version);
13912
13913 // vector_width
13914
13915 cl_uint vector_width;
13916
13917 if (opencl_vector_width_chgd == 0)
13918 {
13919 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13920 {
13921 if (opti_type & OPTI_TYPE_USES_BITS_64)
13922 {
13923 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13924 }
13925 else
13926 {
13927 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13928 }
13929 }
13930 else
13931 {
13932 vector_width = (cl_uint) tuningdb_entry->vector_width;
13933 }
13934 }
13935 else
13936 {
13937 vector_width = opencl_vector_width;
13938 }
13939
13940 if (vector_width > 16) vector_width = 16;
13941
13942 device_param->vector_width = vector_width;
13943
13944 // max_compute_units
13945
13946 cl_uint device_processors;
13947
13948 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13949
13950 device_param->device_processors = device_processors;
13951
13952 // device_maxmem_alloc
13953 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13954
13955 cl_ulong device_maxmem_alloc;
13956
13957 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13958
13959 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13960
13961 // device_global_mem
13962
13963 cl_ulong device_global_mem;
13964
13965 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13966
13967 device_param->device_global_mem = device_global_mem;
13968
13969 // max_work_group_size
13970
13971 size_t device_maxworkgroup_size;
13972
13973 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13974
13975 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13976
13977 // max_clock_frequency
13978
13979 cl_uint device_maxclock_frequency;
13980
13981 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13982
13983 device_param->device_maxclock_frequency = device_maxclock_frequency;
13984
13985 // device_endian_little
13986
13987 cl_bool device_endian_little;
13988
13989 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13990
13991 if (device_endian_little == CL_FALSE)
13992 {
13993 log_info ("- Device #%u: WARNING: Not a little endian device", device_id + 1);
13994
13995 device_param->skipped = 1;
13996 }
13997
13998 // device_available
13999
14000 cl_bool device_available;
14001
14002 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
14003
14004 if (device_available == CL_FALSE)
14005 {
14006 log_info ("- Device #%u: WARNING: Device not available", device_id + 1);
14007
14008 device_param->skipped = 1;
14009 }
14010
14011 // device_compiler_available
14012
14013 cl_bool device_compiler_available;
14014
14015 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
14016
14017 if (device_compiler_available == CL_FALSE)
14018 {
14019 log_info ("- Device #%u: WARNING: No compiler available for device", device_id + 1);
14020
14021 device_param->skipped = 1;
14022 }
14023
14024 // device_execution_capabilities
14025
14026 cl_device_exec_capabilities device_execution_capabilities;
14027
14028 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
14029
14030 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
14031 {
14032 log_info ("- Device #%u: WARNING: Device does not support executing kernels", device_id + 1);
14033
14034 device_param->skipped = 1;
14035 }
14036
14037 // device_extensions
14038
14039 size_t device_extensions_size;
14040
14041 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
14042
14043 char *device_extensions = mymalloc (device_extensions_size + 1);
14044
14045 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
14046
14047 if (strstr (device_extensions, "base_atomics") == 0)
14048 {
14049 log_info ("- Device #%u: WARNING: Device does not support base atomics", device_id + 1);
14050
14051 device_param->skipped = 1;
14052 }
14053
14054 if (strstr (device_extensions, "byte_addressable_store") == 0)
14055 {
14056 log_info ("- Device #%u: WARNING: Device does not support byte addressable store", device_id + 1);
14057
14058 device_param->skipped = 1;
14059 }
14060
14061 myfree (device_extensions);
14062
14063 // device_local_mem_size
14064
14065 cl_ulong device_local_mem_size;
14066
14067 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
14068
14069 if (device_local_mem_size < 32768)
14070 {
14071 log_info ("- Device #%u: WARNING: Device local mem size is too small", device_id + 1);
14072
14073 device_param->skipped = 1;
14074 }
14075
14076 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
14077 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
14078 // This results in both utilizing it for 50%
14079 // However, Intel has much better SIMD control over their own hardware
14080 // It makes sense to give them full control over their own hardware
14081
14082 if (device_type & CL_DEVICE_TYPE_CPU)
14083 {
14084 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14085 {
14086 if (data.force == 0)
14087 {
14088 if (algorithm_pos == 0)
14089 {
14090 log_info ("- Device #%u: WARNING: Not a native Intel OpenCL runtime, expect massive speed loss", device_id + 1);
14091 log_info (" You can use --force to override this but do not post error reports if you do so");
14092 }
14093
14094 device_param->skipped = 1;
14095 }
14096 }
14097 }
14098
14099 // skipped
14100
14101 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14102 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14103
14104 // driver_version
14105
14106 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14107
14108 char *driver_version = (char *) mymalloc (param_value_size);
14109
14110 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14111
14112 device_param->driver_version = driver_version;
14113
14114 // device_name_chksum
14115
14116 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14117
14118 #if __x86_64__
14119 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);
14120 #else
14121 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);
14122 #endif
14123
14124 uint device_name_digest[4] = { 0 };
14125
14126 md5_64 ((uint *) device_name_chksum, device_name_digest);
14127
14128 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14129
14130 device_param->device_name_chksum = device_name_chksum;
14131
14132 // device_processor_cores
14133
14134 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14135 {
14136 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14137 {
14138 need_adl = 1;
14139 }
14140
14141 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14142 {
14143 need_nvml = 1;
14144
14145 #ifdef LINUX
14146 need_xnvctrl = 1;
14147 #endif
14148
14149 #ifdef WIN
14150 need_nvapi = 1;
14151 #endif
14152 }
14153 }
14154
14155 // device_processor_cores
14156
14157 if (device_type & CL_DEVICE_TYPE_CPU)
14158 {
14159 cl_uint device_processor_cores = 1;
14160
14161 device_param->device_processor_cores = device_processor_cores;
14162 }
14163
14164 if (device_type & CL_DEVICE_TYPE_GPU)
14165 {
14166 if (device_vendor_id == VENDOR_ID_AMD)
14167 {
14168 cl_uint device_processor_cores = 0;
14169
14170 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
14171
14172 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
14173
14174 device_param->device_processor_cores = device_processor_cores;
14175 }
14176 else if (device_vendor_id == VENDOR_ID_NV)
14177 {
14178 cl_uint kernel_exec_timeout = 0;
14179
14180 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14181
14182 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14183
14184 device_param->kernel_exec_timeout = kernel_exec_timeout;
14185
14186 cl_uint device_processor_cores = 0;
14187
14188 #define CL_DEVICE_WARP_SIZE_NV 0x4003
14189
14190 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
14191
14192 device_param->device_processor_cores = device_processor_cores;
14193
14194 cl_uint sm_minor = 0;
14195 cl_uint sm_major = 0;
14196
14197 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14198 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14199
14200 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14201 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14202
14203 device_param->sm_minor = sm_minor;
14204 device_param->sm_major = sm_major;
14205
14206 // CPU burning loop damper
14207 // Value is given as number between 0-100
14208 // By default 100%
14209
14210 device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14211
14212 if (nvidia_spin_damp_chgd == 0)
14213 {
14214 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14215 {
14216 /**
14217 * the workaround is not a friend of rule based attacks
14218 * the words from the wordlist combined with fast and slow rules cause
14219 * fluctuations which cause inaccurate wait time estimations
14220 * using a reduced damping percentage almost compensates this
14221 */
14222
14223 device_param->nvidia_spin_damp = 64;
14224 }
14225 }
14226
14227 device_param->nvidia_spin_damp /= 100;
14228 }
14229 else
14230 {
14231 cl_uint device_processor_cores = 1;
14232
14233 device_param->device_processor_cores = device_processor_cores;
14234 }
14235 }
14236
14237 // display results
14238
14239 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14240 {
14241 if (machine_readable == 0)
14242 {
14243 if (device_param->skipped == 0)
14244 {
14245 log_info ("- Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14246 device_id + 1,
14247 device_name,
14248 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14249 (unsigned int) (device_global_mem / 1024 / 1024),
14250 (unsigned int) device_processors);
14251 }
14252 else
14253 {
14254 log_info ("- Device #%u: %s, skipped",
14255 device_id + 1,
14256 device_name);
14257 }
14258 }
14259 }
14260
14261 // common driver check
14262
14263 if (device_param->skipped == 0)
14264 {
14265 if (device_type & CL_DEVICE_TYPE_GPU)
14266 {
14267 if (platform_vendor_id == VENDOR_ID_AMD)
14268 {
14269 int catalyst_check = (force == 1) ? 0 : 1;
14270
14271 int catalyst_warn = 0;
14272
14273 int catalyst_broken = 0;
14274
14275 if (catalyst_check == 1)
14276 {
14277 catalyst_warn = 1;
14278
14279 // v14.9 and higher
14280 if (atoi (device_param->driver_version) >= 1573)
14281 {
14282 catalyst_warn = 0;
14283 }
14284
14285 catalyst_check = 0;
14286 }
14287
14288 if (catalyst_broken == 1)
14289 {
14290 log_info ("");
14291 log_info ("ATTENTION! The Catalyst driver installed on your system is known to be broken!");
14292 log_info ("It passes over cracked hashes and will not report them as cracked");
14293 log_info ("You are STRONGLY encouraged not to use it");
14294 log_info ("You can use --force to override this but do not post error reports if you do so");
14295 log_info ("");
14296
14297 return (-1);
14298 }
14299
14300 if (catalyst_warn == 1)
14301 {
14302 log_info ("");
14303 log_info ("ATTENTION! Unsupported or incorrectly installed Catalyst driver detected!");
14304 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver");
14305 log_info ("See hashcat's homepage for official supported catalyst drivers");
14306 #ifdef _WIN
14307 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14308 #endif
14309 log_info ("You can use --force to override this but do not post error reports if you do so");
14310 log_info ("");
14311
14312 return (-1);
14313 }
14314 }
14315 else if (platform_vendor_id == VENDOR_ID_NV)
14316 {
14317 if (device_param->kernel_exec_timeout != 0)
14318 {
14319 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);
14320 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14321 }
14322 }
14323 }
14324
14325 /* turns out pocl still creates segfaults (because of llvm)
14326 if (device_type & CL_DEVICE_TYPE_CPU)
14327 {
14328 if (platform_vendor_id == VENDOR_ID_AMD)
14329 {
14330 if (force == 0)
14331 {
14332 log_info ("");
14333 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14334 log_info ("You are STRONGLY encouraged not to use it");
14335 log_info ("You can use --force to override this but do not post error reports if you do so");
14336 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14337 log_info ("");
14338
14339 return (-1);
14340 }
14341 }
14342 }
14343 */
14344
14345 /**
14346 * kernel accel and loops tuning db adjustment
14347 */
14348
14349 device_param->kernel_accel_min = 1;
14350 device_param->kernel_accel_max = 1024;
14351
14352 device_param->kernel_loops_min = 1;
14353 device_param->kernel_loops_max = 1024;
14354
14355 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14356
14357 if (tuningdb_entry)
14358 {
14359 u32 _kernel_accel = tuningdb_entry->kernel_accel;
14360 u32 _kernel_loops = tuningdb_entry->kernel_loops;
14361
14362 if (_kernel_accel)
14363 {
14364 device_param->kernel_accel_min = _kernel_accel;
14365 device_param->kernel_accel_max = _kernel_accel;
14366 }
14367
14368 if (_kernel_loops)
14369 {
14370 if (workload_profile == 1)
14371 {
14372 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14373 }
14374 else if (workload_profile == 2)
14375 {
14376 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14377 }
14378
14379 device_param->kernel_loops_min = _kernel_loops;
14380 device_param->kernel_loops_max = _kernel_loops;
14381 }
14382 }
14383
14384 // commandline parameters overwrite tuningdb entries
14385
14386 if (kernel_accel)
14387 {
14388 device_param->kernel_accel_min = kernel_accel;
14389 device_param->kernel_accel_max = kernel_accel;
14390 }
14391
14392 if (kernel_loops)
14393 {
14394 device_param->kernel_loops_min = kernel_loops;
14395 device_param->kernel_loops_max = kernel_loops;
14396 }
14397
14398 /**
14399 * activate device
14400 */
14401
14402 devices_active++;
14403 }
14404
14405 // next please
14406
14407 devices_cnt++;
14408 }
14409
14410 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14411 {
14412 if (machine_readable == 0)
14413 {
14414 log_info ("");
14415 }
14416 }
14417 }
14418
14419 if (keyspace == 0 && devices_active == 0)
14420 {
14421 log_error ("ERROR: No devices found/left");
14422
14423 return (-1);
14424 }
14425
14426 // 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)
14427
14428 if (devices_filter != (uint) -1)
14429 {
14430 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14431
14432 if (devices_filter > devices_cnt_mask)
14433 {
14434 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14435
14436 return (-1);
14437 }
14438 }
14439
14440 data.devices_cnt = devices_cnt;
14441
14442 data.devices_active = devices_active;
14443
14444 /**
14445 * HM devices: init
14446 */
14447
14448 #ifdef HAVE_HWMON
14449 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14450 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14451 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14452 hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX] = { { 0 } };
14453
14454 if (gpu_temp_disable == 0)
14455 {
14456 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14457 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14458 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14459 XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));
14460
14461 data.hm_adl = NULL;
14462 data.hm_nvapi = NULL;
14463 data.hm_nvml = NULL;
14464 data.hm_xnvctrl = NULL;
14465
14466 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14467 {
14468 data.hm_nvml = nvml;
14469 }
14470
14471 if (data.hm_nvml)
14472 {
14473 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14474 {
14475 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14476
14477 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14478
14479 int tmp_out = 0;
14480
14481 for (int i = 0; i < tmp_in; i++)
14482 {
14483 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14484 }
14485
14486 for (int i = 0; i < tmp_out; i++)
14487 {
14488 unsigned int speed;
14489
14490 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14491
14492 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14493
14494 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14495 }
14496 }
14497 }
14498
14499 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14500 {
14501 data.hm_nvapi = nvapi;
14502 }
14503
14504 if (data.hm_nvapi)
14505 {
14506 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14507 {
14508 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14509
14510 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14511
14512 int tmp_out = 0;
14513
14514 for (int i = 0; i < tmp_in; i++)
14515 {
14516 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14517 }
14518 }
14519 }
14520
14521 if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0))
14522 {
14523 data.hm_xnvctrl = xnvctrl;
14524 }
14525
14526 if (data.hm_xnvctrl)
14527 {
14528 if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
14529 {
14530 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14531 {
14532 hc_device_param_t *device_param = &data.devices_param[device_id];
14533
14534 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14535
14536 hm_adapters_xnvctrl[device_id].xnvctrl = device_id;
14537
14538 int speed = 0;
14539
14540 if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
14541 }
14542 }
14543 }
14544
14545 if ((need_adl == 1) && (adl_init (adl) == 0))
14546 {
14547 data.hm_adl = adl;
14548 }
14549
14550 if (data.hm_adl)
14551 {
14552 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14553 {
14554 // total number of adapters
14555
14556 int hm_adapters_num;
14557
14558 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14559
14560 // adapter info
14561
14562 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14563
14564 if (lpAdapterInfo == NULL) return (-1);
14565
14566 // get a list (of ids of) valid/usable adapters
14567
14568 int num_adl_adapters = 0;
14569
14570 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14571
14572 if (num_adl_adapters > 0)
14573 {
14574 hc_thread_mutex_lock (mux_adl);
14575
14576 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14577
14578 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14579
14580 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14581 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14582
14583 hc_thread_mutex_unlock (mux_adl);
14584 }
14585
14586 myfree (valid_adl_device_list);
14587 myfree (lpAdapterInfo);
14588 }
14589 }
14590
14591 if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14592 {
14593 gpu_temp_disable = 1;
14594 }
14595 }
14596
14597 /**
14598 * OpenCL devices: allocate buffer for device specific information
14599 */
14600
14601 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14602 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14603
14604 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14605
14606 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14607
14608 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14609
14610 /**
14611 * User-defined GPU temp handling
14612 */
14613
14614 if (gpu_temp_disable == 1)
14615 {
14616 gpu_temp_abort = 0;
14617 gpu_temp_retain = 0;
14618 }
14619
14620 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14621 {
14622 if (gpu_temp_abort < gpu_temp_retain)
14623 {
14624 log_error ("ERROR: Invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14625
14626 return (-1);
14627 }
14628 }
14629
14630 data.gpu_temp_disable = gpu_temp_disable;
14631 data.gpu_temp_abort = gpu_temp_abort;
14632 data.gpu_temp_retain = gpu_temp_retain;
14633 #endif
14634
14635 /**
14636 * enable custom signal handler(s)
14637 */
14638
14639 if (benchmark == 0)
14640 {
14641 hc_signal (sigHandler_default);
14642 }
14643 else
14644 {
14645 hc_signal (sigHandler_benchmark);
14646 }
14647
14648 /**
14649 * inform the user
14650 */
14651
14652 if (data.quiet == 0)
14653 {
14654 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14655
14656 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);
14657
14658 if (attack_mode == ATTACK_MODE_STRAIGHT)
14659 {
14660 log_info ("Rules: %u", kernel_rules_cnt);
14661 }
14662
14663 if (opti_type)
14664 {
14665 log_info ("Applicable Optimizers:");
14666
14667 for (uint i = 0; i < 32; i++)
14668 {
14669 const uint opti_bit = 1u << i;
14670
14671 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14672 }
14673 }
14674
14675 /**
14676 * Watchdog and Temperature balance
14677 */
14678
14679 #ifdef HAVE_HWMON
14680 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14681 {
14682 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14683 }
14684
14685 if (gpu_temp_abort == 0)
14686 {
14687 log_info ("Watchdog: Temperature abort trigger disabled");
14688 }
14689 else
14690 {
14691 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14692 }
14693
14694 if (gpu_temp_retain == 0)
14695 {
14696 log_info ("Watchdog: Temperature retain trigger disabled");
14697 }
14698 else
14699 {
14700 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14701 }
14702
14703 if (data.quiet == 0) log_info ("");
14704 #endif
14705 }
14706
14707 #ifdef HAVE_HWMON
14708
14709 /**
14710 * HM devices: copy
14711 */
14712
14713 if (gpu_temp_disable == 0)
14714 {
14715 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14716 {
14717 hc_device_param_t *device_param = &data.devices_param[device_id];
14718
14719 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14720
14721 if (device_param->skipped) continue;
14722
14723 const uint platform_devices_id = device_param->platform_devices_id;
14724
14725 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14726 {
14727 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14728 data.hm_device[device_id].nvapi = 0;
14729 data.hm_device[device_id].nvml = 0;
14730 data.hm_device[device_id].xnvctrl = 0;
14731 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14732 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14733 data.hm_device[device_id].fan_set_supported = 0;
14734 }
14735
14736 if (device_param->device_vendor_id == VENDOR_ID_NV)
14737 {
14738 data.hm_device[device_id].adl = 0;
14739 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14740 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14741 data.hm_device[device_id].xnvctrl = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
14742 data.hm_device[device_id].od_version = 0;
14743 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14744 data.hm_device[device_id].fan_set_supported = 0;
14745 }
14746 }
14747 }
14748
14749 /**
14750 * powertune on user request
14751 */
14752
14753 if (powertune_enable == 1)
14754 {
14755 hc_thread_mutex_lock (mux_adl);
14756
14757 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14758 {
14759 hc_device_param_t *device_param = &data.devices_param[device_id];
14760
14761 if (device_param->skipped) continue;
14762
14763 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14764 {
14765 /**
14766 * Temporary fix:
14767 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14768 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14769 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14770 * Driver / ADL bug?
14771 */
14772
14773 if (data.hm_device[device_id].od_version == 6)
14774 {
14775 int ADL_rc;
14776
14777 // check powertune capabilities first, if not available then skip device
14778
14779 int powertune_supported = 0;
14780
14781 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14782 {
14783 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14784
14785 return (-1);
14786 }
14787
14788 // first backup current value, we will restore it later
14789
14790 if (powertune_supported != 0)
14791 {
14792 // powercontrol settings
14793
14794 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14795
14796 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14797 {
14798 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14799 }
14800
14801 if (ADL_rc != ADL_OK)
14802 {
14803 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14804
14805 return (-1);
14806 }
14807
14808 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14809 {
14810 log_error ("ERROR: Failed to set new ADL PowerControl values");
14811
14812 return (-1);
14813 }
14814
14815 // clocks
14816
14817 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14818
14819 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14820
14821 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)
14822 {
14823 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14824
14825 return (-1);
14826 }
14827
14828 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14829
14830 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14831
14832 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14833 {
14834 log_error ("ERROR: Failed to get ADL device capabilities");
14835
14836 return (-1);
14837 }
14838
14839 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14840 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14841
14842 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14843 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14844
14845 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14846 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14847
14848 // warning if profile has too low max values
14849
14850 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14851 {
14852 log_info ("WARN: The custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14853 }
14854
14855 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14856 {
14857 log_info ("WARN: The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14858 }
14859
14860 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14861
14862 performance_state->iNumberOfPerformanceLevels = 2;
14863
14864 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14865 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14866 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14867 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14868
14869 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)
14870 {
14871 log_info ("ERROR: Failed to set ADL performance state");
14872
14873 return (-1);
14874 }
14875
14876 local_free (performance_state);
14877 }
14878
14879 // set powertune value only
14880
14881 if (powertune_supported != 0)
14882 {
14883 // powertune set
14884 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14885
14886 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14887 {
14888 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14889
14890 return (-1);
14891 }
14892
14893 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14894 {
14895 log_error ("ERROR: Failed to set new ADL PowerControl values");
14896
14897 return (-1);
14898 }
14899 }
14900 }
14901 }
14902
14903 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14904 {
14905 // first backup current value, we will restore it later
14906
14907 unsigned int limit;
14908
14909 int powertune_supported = 0;
14910
14911 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14912 {
14913 powertune_supported = 1;
14914 }
14915
14916 // if backup worked, activate the maximum allowed
14917
14918 if (powertune_supported != 0)
14919 {
14920 unsigned int minLimit;
14921 unsigned int maxLimit;
14922
14923 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14924 {
14925 if (maxLimit > 0)
14926 {
14927 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14928 {
14929 // now we can be sure we need to reset later
14930
14931 nvml_power_limit[device_id] = limit;
14932 }
14933 }
14934 }
14935 }
14936 }
14937 }
14938
14939 hc_thread_mutex_unlock (mux_adl);
14940 }
14941
14942 #endif // HAVE_HWMON
14943
14944 #ifdef DEBUG
14945 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14946 #endif
14947
14948 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14949
14950 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14951 {
14952 /**
14953 * host buffer
14954 */
14955
14956 hc_device_param_t *device_param = &data.devices_param[device_id];
14957
14958 if (device_param->skipped) continue;
14959
14960 /**
14961 * device properties
14962 */
14963
14964 const char *device_name_chksum = device_param->device_name_chksum;
14965 const u32 device_processors = device_param->device_processors;
14966 const u32 device_processor_cores = device_param->device_processor_cores;
14967
14968 /**
14969 * create context for each device
14970 */
14971
14972 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14973
14974 /**
14975 * create command-queue
14976 */
14977
14978 // not supported with NV
14979 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14980
14981 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14982
14983 /**
14984 * kernel threads: some algorithms need a fixed kernel-threads count
14985 * because of shared memory usage or bitslice
14986 * there needs to be some upper limit, otherwise there's too much overhead
14987 */
14988
14989 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14990
14991 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14992 {
14993 kernel_threads = KERNEL_THREADS_MAX_CPU;
14994 }
14995
14996 if (hash_mode == 1500) kernel_threads = 64; // DES
14997 if (hash_mode == 3000) kernel_threads = 64; // DES
14998 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14999 if (hash_mode == 7500) kernel_threads = 64; // RC4
15000 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
15001 if (hash_mode == 9700) kernel_threads = 64; // RC4
15002 if (hash_mode == 9710) kernel_threads = 64; // RC4
15003 if (hash_mode == 9800) kernel_threads = 64; // RC4
15004 if (hash_mode == 9810) kernel_threads = 64; // RC4
15005 if (hash_mode == 10400) kernel_threads = 64; // RC4
15006 if (hash_mode == 10410) kernel_threads = 64; // RC4
15007 if (hash_mode == 10500) kernel_threads = 64; // RC4
15008 if (hash_mode == 13100) kernel_threads = 64; // RC4
15009
15010 device_param->kernel_threads = kernel_threads;
15011
15012 device_param->hardware_power = device_processors * kernel_threads;
15013
15014 /**
15015 * create input buffers on device : calculate size of fixed memory buffers
15016 */
15017
15018 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
15019 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
15020
15021 device_param->size_root_css = size_root_css;
15022 device_param->size_markov_css = size_markov_css;
15023
15024 size_t size_results = sizeof (uint);
15025
15026 device_param->size_results = size_results;
15027
15028 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
15029 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
15030
15031 size_t size_plains = digests_cnt * sizeof (plain_t);
15032 size_t size_salts = salts_cnt * sizeof (salt_t);
15033 size_t size_esalts = salts_cnt * esalt_size;
15034
15035 device_param->size_plains = size_plains;
15036 device_param->size_digests = size_digests;
15037 device_param->size_shown = size_shown;
15038 device_param->size_salts = size_salts;
15039
15040 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
15041 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
15042 size_t size_tm = 32 * sizeof (bs_word_t);
15043
15044 // scryptV stuff
15045
15046 size_t size_scryptV = 1;
15047
15048 if ((hash_mode == 8900) || (hash_mode == 9300))
15049 {
15050 uint tmto_start = 0;
15051 uint tmto_stop = 10;
15052
15053 if (scrypt_tmto)
15054 {
15055 tmto_start = scrypt_tmto;
15056 }
15057 else
15058 {
15059 // in case the user did not specify the tmto manually
15060 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
15061 // but set the lower end only in case the user has a device with too less memory
15062
15063 if (hash_mode == 8900)
15064 {
15065 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15066 {
15067 tmto_start = 1;
15068 }
15069 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15070 {
15071 tmto_start = 2;
15072 }
15073 }
15074 else if (hash_mode == 9300)
15075 {
15076 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15077 {
15078 tmto_start = 2;
15079 }
15080 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15081 {
15082 tmto_start = 2;
15083 }
15084 }
15085 }
15086
15087 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
15088 {
15089 // TODO: in theory the following calculation needs to be done per salt, not global
15090 // we assume all hashes have the same scrypt settings
15091
15092 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
15093
15094 size_scryptV /= 1 << tmto;
15095
15096 size_scryptV *= device_processors * device_processor_cores;
15097
15098 if (size_scryptV > device_param->device_maxmem_alloc)
15099 {
15100 if (quiet == 0) log_info ("WARNING: Not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15101
15102 continue;
15103 }
15104
15105 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
15106 {
15107 data.salts_buf[salts_pos].scrypt_tmto = tmto;
15108 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
15109 }
15110
15111 break;
15112 }
15113
15114 if (data.salts_buf[0].scrypt_phy == 0)
15115 {
15116 log_error ("ERROR: Can't allocate enough device memory");
15117
15118 return -1;
15119 }
15120
15121 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
15122 }
15123
15124 /**
15125 * some algorithms need a fixed kernel-loops count
15126 */
15127
15128 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15129 {
15130 const u32 kernel_loops_fixed = 1024;
15131
15132 device_param->kernel_loops_min = kernel_loops_fixed;
15133 device_param->kernel_loops_max = kernel_loops_fixed;
15134 }
15135
15136 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15137 {
15138 const u32 kernel_loops_fixed = 1024;
15139
15140 device_param->kernel_loops_min = kernel_loops_fixed;
15141 device_param->kernel_loops_max = kernel_loops_fixed;
15142 }
15143
15144 if (hash_mode == 8900)
15145 {
15146 const u32 kernel_loops_fixed = 1;
15147
15148 device_param->kernel_loops_min = kernel_loops_fixed;
15149 device_param->kernel_loops_max = kernel_loops_fixed;
15150 }
15151
15152 if (hash_mode == 9300)
15153 {
15154 const u32 kernel_loops_fixed = 1;
15155
15156 device_param->kernel_loops_min = kernel_loops_fixed;
15157 device_param->kernel_loops_max = kernel_loops_fixed;
15158 }
15159
15160 if (hash_mode == 12500)
15161 {
15162 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15163
15164 device_param->kernel_loops_min = kernel_loops_fixed;
15165 device_param->kernel_loops_max = kernel_loops_fixed;
15166 }
15167
15168 /**
15169 * some algorithms have a maximum kernel-loops count
15170 */
15171
15172 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15173 {
15174 u32 innerloop_cnt = 0;
15175
15176 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15177 {
15178 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15179 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15180 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15181 }
15182 else
15183 {
15184 innerloop_cnt = data.salts_buf[0].salt_iter;
15185 }
15186
15187 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15188 (innerloop_cnt <= device_param->kernel_loops_max))
15189 {
15190 device_param->kernel_loops_max = innerloop_cnt;
15191 }
15192 }
15193
15194 u32 kernel_accel_min = device_param->kernel_accel_min;
15195 u32 kernel_accel_max = device_param->kernel_accel_max;
15196
15197 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15198
15199 size_t size_pws = 4;
15200 size_t size_tmps = 4;
15201 size_t size_hooks = 4;
15202
15203 while (kernel_accel_max >= kernel_accel_min)
15204 {
15205 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15206
15207 // size_pws
15208
15209 size_pws = kernel_power_max * sizeof (pw_t);
15210
15211 // size_tmps
15212
15213 switch (hash_mode)
15214 {
15215 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15216 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15217 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15218 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15219 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15220 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15221 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15222 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15223 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15224 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15225 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15226 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15227 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15228 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15229 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15230 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15231 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15232 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15233 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15234 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15235 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15236 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15237 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15238 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
15239 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
15240 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
15241 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
15242 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
15243 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15244 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15245 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
15246 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
15247 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15248 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
15249 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15250 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
15251 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
15252 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15253 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15254 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
15255 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
15256 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
15257 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15258 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
15259 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
15260 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
15261 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
15262 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15263 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
15264 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
15265 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
15266 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15267 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15268 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
15269 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
15270 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
15271 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
15272 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
15273 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15274 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15275 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15276 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
15277 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
15278 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15279 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15280 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15281 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15282 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15283 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15284 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15285 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15286 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15287 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15288 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15289 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15290 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15291 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15292 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15293 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15294 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15295 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15296 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15297 };
15298
15299 // size_hooks
15300
15301 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15302 {
15303 switch (hash_mode)
15304 {
15305 }
15306 }
15307
15308 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15309 // if not, decrease amplifier and try again
15310
15311 int memory_limit_hit = 0;
15312
15313 if (size_pws > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15314 if (size_tmps > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15315 if (size_hooks > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15316
15317 const u64 size_total
15318 = bitmap_size
15319 + bitmap_size
15320 + bitmap_size
15321 + bitmap_size
15322 + bitmap_size
15323 + bitmap_size
15324 + bitmap_size
15325 + bitmap_size
15326 + size_bfs
15327 + size_combs
15328 + size_digests
15329 + size_esalts
15330 + size_hooks
15331 + size_markov_css
15332 + size_plains
15333 + size_pws
15334 + size_pws // not a bug
15335 + size_results
15336 + size_root_css
15337 + size_rules
15338 + size_rules_c
15339 + size_salts
15340 + size_scryptV
15341 + size_shown
15342 + size_tm
15343 + size_tmps;
15344
15345 if (size_total > device_param->device_global_mem) memory_limit_hit = 1;
15346
15347 if (memory_limit_hit == 1)
15348 {
15349 kernel_accel_max--;
15350
15351 continue;
15352 }
15353
15354 break;
15355 }
15356
15357 if (kernel_accel_max < kernel_accel_min)
15358 {
15359 log_error ("- Device #%u: Device does not provide enough allocatable device-memory to handle this attack", device_id + 1);
15360
15361 return -1;
15362 }
15363
15364 device_param->kernel_accel_min = kernel_accel_min;
15365 device_param->kernel_accel_max = kernel_accel_max;
15366
15367 /*
15368 if (kernel_accel_max < kernel_accel)
15369 {
15370 if (quiet == 0) log_info ("- Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
15371
15372 device_param->kernel_accel = kernel_accel_max;
15373 }
15374 */
15375
15376 device_param->size_bfs = size_bfs;
15377 device_param->size_combs = size_combs;
15378 device_param->size_rules = size_rules;
15379 device_param->size_rules_c = size_rules_c;
15380 device_param->size_pws = size_pws;
15381 device_param->size_tmps = size_tmps;
15382 device_param->size_hooks = size_hooks;
15383
15384 /**
15385 * default building options
15386 */
15387
15388 char cpath[1024] = { 0 };
15389
15390 char build_opts[1024] = { 0 };
15391
15392 #if _WIN
15393
15394 snprintf (cpath, sizeof (cpath) - 1, "%s\\OpenCL\\", shared_dir);
15395
15396 char *cpath_real = mymalloc (MAX_PATH);
15397
15398 if (GetFullPathName (cpath, MAX_PATH, cpath_real, NULL) == 0)
15399 {
15400 log_error ("ERROR: %s: %s", cpath, "GetFullPathName()");
15401
15402 return -1;
15403 }
15404
15405 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\"", cpath_real);
15406
15407 myfree (cpath_real);
15408
15409 #else
15410
15411 snprintf (cpath, sizeof (cpath) - 1, "%s/OpenCL/", shared_dir);
15412
15413 char *cpath_real = mymalloc (PATH_MAX);
15414
15415 if (realpath (cpath, cpath_real) == NULL)
15416 {
15417 log_error ("ERROR: %s: %s", cpath, strerror (errno));
15418
15419 return -1;
15420 }
15421
15422 char cpath_escaped[1024] = { 0 };
15423
15424 naive_escape (cpath_real, cpath_escaped, sizeof (cpath_escaped));
15425
15426 myfree (cpath_real);
15427
15428 snprintf (build_opts, sizeof (build_opts) - 1, "-I %s", cpath_escaped);
15429
15430 #endif
15431
15432 // we don't have sm_* on vendors not NV but it doesn't matter
15433
15434 char build_opts_new[1024] = { 0 };
15435
15436 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -D VENDOR_ID=%u -D CUDA_ARCH=%d -D VECT_SIZE=%u -D DEVICE_TYPE=%u -D KERN_TYPE=%u -D _unroll -cl-std=CL1.1", build_opts, device_param->device_vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type);
15437
15438 strncpy (build_opts, build_opts_new, sizeof (build_opts));
15439
15440 #ifdef DEBUG
15441 log_info ("- Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15442 #endif
15443
15444 /**
15445 * main kernel
15446 */
15447
15448 {
15449 /**
15450 * kernel source filename
15451 */
15452
15453 char source_file[256] = { 0 };
15454
15455 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15456
15457 struct stat sst;
15458
15459 if (stat (source_file, &sst) == -1)
15460 {
15461 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15462
15463 return -1;
15464 }
15465
15466 /**
15467 * kernel cached filename
15468 */
15469
15470 char cached_file[256] = { 0 };
15471
15472 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15473
15474 int cached = 1;
15475
15476 struct stat cst;
15477
15478 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15479 {
15480 cached = 0;
15481 }
15482
15483 /**
15484 * kernel compile or load
15485 */
15486
15487 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15488
15489 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15490
15491 if (force_jit_compilation == -1)
15492 {
15493 if (cached == 0)
15494 {
15495 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));
15496
15497 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15498
15499 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15500
15501 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15502
15503 #ifdef DEBUG
15504 size_t build_log_size = 0;
15505
15506 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15507
15508 if (build_log_size > 1)
15509 {
15510 char *build_log = (char *) malloc (build_log_size + 1);
15511
15512 memset (build_log, 0, build_log_size + 1);
15513
15514 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15515
15516 puts (build_log);
15517
15518 free (build_log);
15519 }
15520 #endif
15521
15522 if (rc != 0)
15523 {
15524 device_param->skipped = true;
15525
15526 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15527
15528 continue;
15529 }
15530
15531 size_t binary_size;
15532
15533 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15534
15535 u8 *binary = (u8 *) mymalloc (binary_size);
15536
15537 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15538
15539 writeProgramBin (cached_file, binary, binary_size);
15540
15541 local_free (binary);
15542 }
15543 else
15544 {
15545 #ifdef DEBUG
15546 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15547 #endif
15548
15549 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15550
15551 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15552
15553 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15554 }
15555 }
15556 else
15557 {
15558 #ifdef DEBUG
15559 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15560 #endif
15561
15562 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15563
15564 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15565
15566 char build_opts_update[1024] = { 0 };
15567
15568 if (force_jit_compilation == 1500)
15569 {
15570 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15571 }
15572 else if (force_jit_compilation == 8900)
15573 {
15574 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);
15575 }
15576 else
15577 {
15578 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15579 }
15580
15581 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15582
15583 #ifdef DEBUG
15584 size_t build_log_size = 0;
15585
15586 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15587
15588 if (build_log_size > 1)
15589 {
15590 char *build_log = (char *) malloc (build_log_size + 1);
15591
15592 memset (build_log, 0, build_log_size + 1);
15593
15594 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15595
15596 puts (build_log);
15597
15598 free (build_log);
15599 }
15600 #endif
15601
15602 if (rc != 0)
15603 {
15604 device_param->skipped = true;
15605
15606 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15607 }
15608 }
15609
15610 local_free (kernel_lengths);
15611 local_free (kernel_sources[0]);
15612 local_free (kernel_sources);
15613 }
15614
15615 /**
15616 * word generator kernel
15617 */
15618
15619 if (attack_mode != ATTACK_MODE_STRAIGHT)
15620 {
15621 /**
15622 * kernel mp source filename
15623 */
15624
15625 char source_file[256] = { 0 };
15626
15627 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15628
15629 struct stat sst;
15630
15631 if (stat (source_file, &sst) == -1)
15632 {
15633 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15634
15635 return -1;
15636 }
15637
15638 /**
15639 * kernel mp cached filename
15640 */
15641
15642 char cached_file[256] = { 0 };
15643
15644 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15645
15646 int cached = 1;
15647
15648 struct stat cst;
15649
15650 if (stat (cached_file, &cst) == -1)
15651 {
15652 cached = 0;
15653 }
15654
15655 /**
15656 * kernel compile or load
15657 */
15658
15659 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15660
15661 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15662
15663 if (cached == 0)
15664 {
15665 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));
15666 if (quiet == 0) log_info ("");
15667
15668 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15669
15670 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15671
15672 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15673
15674 if (rc != 0)
15675 {
15676 device_param->skipped = true;
15677
15678 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15679
15680 continue;
15681 }
15682
15683 size_t binary_size;
15684
15685 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15686
15687 u8 *binary = (u8 *) mymalloc (binary_size);
15688
15689 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15690
15691 writeProgramBin (cached_file, binary, binary_size);
15692
15693 local_free (binary);
15694 }
15695 else
15696 {
15697 #ifdef DEBUG
15698 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15699 #endif
15700
15701 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15702
15703 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15704
15705 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15706 }
15707
15708 local_free (kernel_lengths);
15709 local_free (kernel_sources[0]);
15710 local_free (kernel_sources);
15711 }
15712
15713 /**
15714 * amplifier kernel
15715 */
15716
15717 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15718 {
15719
15720 }
15721 else
15722 {
15723 /**
15724 * kernel amp source filename
15725 */
15726
15727 char source_file[256] = { 0 };
15728
15729 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15730
15731 struct stat sst;
15732
15733 if (stat (source_file, &sst) == -1)
15734 {
15735 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15736
15737 return -1;
15738 }
15739
15740 /**
15741 * kernel amp cached filename
15742 */
15743
15744 char cached_file[256] = { 0 };
15745
15746 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15747
15748 int cached = 1;
15749
15750 struct stat cst;
15751
15752 if (stat (cached_file, &cst) == -1)
15753 {
15754 cached = 0;
15755 }
15756
15757 /**
15758 * kernel compile or load
15759 */
15760
15761 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15762
15763 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15764
15765 if (cached == 0)
15766 {
15767 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));
15768 if (quiet == 0) log_info ("");
15769
15770 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15771
15772 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15773
15774 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15775
15776 if (rc != 0)
15777 {
15778 device_param->skipped = true;
15779
15780 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15781
15782 continue;
15783 }
15784
15785 size_t binary_size;
15786
15787 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15788
15789 u8 *binary = (u8 *) mymalloc (binary_size);
15790
15791 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15792
15793 writeProgramBin (cached_file, binary, binary_size);
15794
15795 local_free (binary);
15796 }
15797 else
15798 {
15799 #ifdef DEBUG
15800 if (quiet == 0) log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15801 #endif
15802
15803 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15804
15805 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15806
15807 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15808 }
15809
15810 local_free (kernel_lengths);
15811 local_free (kernel_sources[0]);
15812 local_free (kernel_sources);
15813 }
15814
15815 // some algorithm collide too fast, make that impossible
15816
15817 if (benchmark == 1)
15818 {
15819 ((uint *) digests_buf)[0] = -1;
15820 ((uint *) digests_buf)[1] = -1;
15821 ((uint *) digests_buf)[2] = -1;
15822 ((uint *) digests_buf)[3] = -1;
15823 }
15824
15825 /**
15826 * global buffers
15827 */
15828
15829 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15830 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15831 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15832 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15833 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15834 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15835 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15836 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15837 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15838 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15839 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15840 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15841 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15842 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15843 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15844 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15845 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15846 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15847
15848 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);
15849 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);
15850 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);
15851 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);
15852 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);
15853 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);
15854 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);
15855 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);
15856 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15857 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15858 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15859
15860 /**
15861 * special buffers
15862 */
15863
15864 if (attack_kern == ATTACK_KERN_STRAIGHT)
15865 {
15866 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15867 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15868
15869 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15870 }
15871 else if (attack_kern == ATTACK_KERN_COMBI)
15872 {
15873 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15874 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15875 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15876 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15877 }
15878 else if (attack_kern == ATTACK_KERN_BF)
15879 {
15880 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15881 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15882 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15883 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15884 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15885 }
15886
15887 if (size_esalts)
15888 {
15889 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15890
15891 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15892 }
15893
15894 /**
15895 * main host data
15896 */
15897
15898 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15899
15900 device_param->pws_buf = pws_buf;
15901
15902 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15903
15904 device_param->combs_buf = combs_buf;
15905
15906 void *hooks_buf = mymalloc (size_hooks);
15907
15908 device_param->hooks_buf = hooks_buf;
15909
15910 /**
15911 * kernel args
15912 */
15913
15914 device_param->kernel_params_buf32[21] = bitmap_mask;
15915 device_param->kernel_params_buf32[22] = bitmap_shift1;
15916 device_param->kernel_params_buf32[23] = bitmap_shift2;
15917 device_param->kernel_params_buf32[24] = 0; // salt_pos
15918 device_param->kernel_params_buf32[25] = 0; // loop_pos
15919 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15920 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15921 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15922 device_param->kernel_params_buf32[29] = 0; // digests_offset
15923 device_param->kernel_params_buf32[30] = 0; // combs_mode
15924 device_param->kernel_params_buf32[31] = 0; // gid_max
15925
15926 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15927 ? &device_param->d_pws_buf
15928 : &device_param->d_pws_amp_buf;
15929 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15930 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15931 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15932 device_param->kernel_params[ 4] = &device_param->d_tmps;
15933 device_param->kernel_params[ 5] = &device_param->d_hooks;
15934 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15935 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15936 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15937 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15938 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15939 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15940 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15941 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15942 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15943 device_param->kernel_params[15] = &device_param->d_digests_buf;
15944 device_param->kernel_params[16] = &device_param->d_digests_shown;
15945 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15946 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15947 device_param->kernel_params[19] = &device_param->d_result;
15948 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15949 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15950 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15951 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15952 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15953 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15954 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15955 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15956 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15957 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15958 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15959 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15960
15961 device_param->kernel_params_mp_buf64[3] = 0;
15962 device_param->kernel_params_mp_buf32[4] = 0;
15963 device_param->kernel_params_mp_buf32[5] = 0;
15964 device_param->kernel_params_mp_buf32[6] = 0;
15965 device_param->kernel_params_mp_buf32[7] = 0;
15966 device_param->kernel_params_mp_buf32[8] = 0;
15967
15968 device_param->kernel_params_mp[0] = NULL;
15969 device_param->kernel_params_mp[1] = NULL;
15970 device_param->kernel_params_mp[2] = NULL;
15971 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15972 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15973 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15974 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15975 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15976 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15977
15978 device_param->kernel_params_mp_l_buf64[3] = 0;
15979 device_param->kernel_params_mp_l_buf32[4] = 0;
15980 device_param->kernel_params_mp_l_buf32[5] = 0;
15981 device_param->kernel_params_mp_l_buf32[6] = 0;
15982 device_param->kernel_params_mp_l_buf32[7] = 0;
15983 device_param->kernel_params_mp_l_buf32[8] = 0;
15984 device_param->kernel_params_mp_l_buf32[9] = 0;
15985
15986 device_param->kernel_params_mp_l[0] = NULL;
15987 device_param->kernel_params_mp_l[1] = NULL;
15988 device_param->kernel_params_mp_l[2] = NULL;
15989 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15990 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15991 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15992 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15993 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15994 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15995 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15996
15997 device_param->kernel_params_mp_r_buf64[3] = 0;
15998 device_param->kernel_params_mp_r_buf32[4] = 0;
15999 device_param->kernel_params_mp_r_buf32[5] = 0;
16000 device_param->kernel_params_mp_r_buf32[6] = 0;
16001 device_param->kernel_params_mp_r_buf32[7] = 0;
16002 device_param->kernel_params_mp_r_buf32[8] = 0;
16003
16004 device_param->kernel_params_mp_r[0] = NULL;
16005 device_param->kernel_params_mp_r[1] = NULL;
16006 device_param->kernel_params_mp_r[2] = NULL;
16007 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
16008 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
16009 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
16010 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
16011 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
16012 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
16013
16014 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
16015 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
16016
16017 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
16018 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
16019 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
16020 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
16021 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
16022 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
16023 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
16024
16025 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
16026 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
16027
16028 device_param->kernel_params_memset_buf32[1] = 0; // value
16029 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
16030
16031 device_param->kernel_params_memset[0] = NULL;
16032 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
16033 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
16034
16035 /**
16036 * kernel name
16037 */
16038
16039 size_t kernel_wgs_tmp;
16040
16041 char kernel_name[64] = { 0 };
16042
16043 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16044 {
16045 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16046 {
16047 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
16048
16049 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16050
16051 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
16052
16053 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16054
16055 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
16056
16057 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16058 }
16059 else
16060 {
16061 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
16062
16063 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16064
16065 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
16066
16067 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16068
16069 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
16070
16071 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16072 }
16073
16074 if (data.attack_mode == ATTACK_MODE_BF)
16075 {
16076 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16077 {
16078 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
16079
16080 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16081
16082 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);
16083 }
16084 }
16085 }
16086 else
16087 {
16088 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
16089
16090 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16091
16092 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
16093
16094 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16095
16096 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
16097
16098 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16099
16100 if (opts_type & OPTS_TYPE_HOOK12)
16101 {
16102 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
16103
16104 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16105
16106 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);
16107 }
16108
16109 if (opts_type & OPTS_TYPE_HOOK23)
16110 {
16111 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
16112
16113 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16114
16115 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);
16116 }
16117 }
16118
16119 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);
16120 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);
16121 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);
16122
16123 for (uint i = 0; i <= 20; i++)
16124 {
16125 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
16126 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
16127 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
16128
16129 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
16130 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
16131 }
16132
16133 for (uint i = 21; i <= 31; i++)
16134 {
16135 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
16136 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
16137 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
16138
16139 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
16140 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
16141 }
16142
16143 // GPU memset
16144
16145 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
16146
16147 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);
16148
16149 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
16150 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
16151 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
16152
16153 // MP start
16154
16155 if (attack_mode == ATTACK_MODE_BF)
16156 {
16157 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
16158 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
16159
16160 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);
16161 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);
16162
16163 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16164 {
16165 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
16166 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
16167 }
16168 }
16169 else if (attack_mode == ATTACK_MODE_HYBRID1)
16170 {
16171 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16172
16173 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);
16174 }
16175 else if (attack_mode == ATTACK_MODE_HYBRID2)
16176 {
16177 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16178
16179 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);
16180 }
16181
16182 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16183 {
16184 // nothing to do
16185 }
16186 else
16187 {
16188 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
16189
16190 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);
16191 }
16192
16193 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16194 {
16195 // nothing to do
16196 }
16197 else
16198 {
16199 for (uint i = 0; i < 5; i++)
16200 {
16201 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
16202 }
16203
16204 for (uint i = 5; i < 7; i++)
16205 {
16206 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
16207 }
16208 }
16209
16210 // maybe this has been updated by clGetKernelWorkGroupInfo()
16211 // value can only be decreased, so we don't need to reallocate buffers
16212
16213 device_param->kernel_threads = kernel_threads;
16214
16215 // zero some data buffers
16216
16217 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
16218 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
16219 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
16220 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
16221 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
16222 run_kernel_bzero (device_param, device_param->d_result, size_results);
16223
16224 /**
16225 * special buffers
16226 */
16227
16228 if (attack_kern == ATTACK_KERN_STRAIGHT)
16229 {
16230 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
16231 }
16232 else if (attack_kern == ATTACK_KERN_COMBI)
16233 {
16234 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
16235 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
16236 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16237 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16238 }
16239 else if (attack_kern == ATTACK_KERN_BF)
16240 {
16241 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
16242 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
16243 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
16244 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16245 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16246 }
16247
16248 #if defined(HAVE_HWMON)
16249
16250 /**
16251 * Store initial fanspeed if gpu_temp_retain is enabled
16252 */
16253
16254 if (gpu_temp_disable == 0)
16255 {
16256 if (gpu_temp_retain != 0)
16257 {
16258 hc_thread_mutex_lock (mux_adl);
16259
16260 if (data.hm_device[device_id].fan_get_supported == 1)
16261 {
16262 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
16263 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
16264
16265 temp_retain_fanspeed_value[device_id] = fanspeed;
16266 temp_retain_fanpolicy_value[device_id] = fanpolicy;
16267
16268 // we also set it to tell the OS we take control over the fan and it's automatic controller
16269 // if it was set to automatic. we do not control user-defined fanspeeds.
16270
16271 if (fanpolicy == 1)
16272 {
16273 data.hm_device[device_id].fan_set_supported = 1;
16274
16275 int rc = -1;
16276
16277 if (device_param->device_vendor_id == VENDOR_ID_AMD)
16278 {
16279 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
16280 }
16281 else if (device_param->device_vendor_id == VENDOR_ID_NV)
16282 {
16283 #ifdef LINUX
16284 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE);
16285 #endif
16286
16287 #ifdef WIN
16288 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
16289 #endif
16290 }
16291
16292 if (rc == 0)
16293 {
16294 data.hm_device[device_id].fan_set_supported = 1;
16295 }
16296 else
16297 {
16298 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
16299
16300 data.hm_device[device_id].fan_set_supported = 0;
16301 }
16302 }
16303 else
16304 {
16305 data.hm_device[device_id].fan_set_supported = 0;
16306 }
16307 }
16308
16309 hc_thread_mutex_unlock (mux_adl);
16310 }
16311 }
16312
16313 #endif // HAVE_HWMON
16314 }
16315
16316 if (data.quiet == 0) log_info_nn ("");
16317
16318 /**
16319 * In benchmark-mode, inform user which algorithm is checked
16320 */
16321
16322 if (benchmark == 1)
16323 {
16324 if (machine_readable == 0)
16325 {
16326 quiet = 0;
16327
16328 data.quiet = quiet;
16329
16330 char *hash_type = strhashtype (data.hash_mode); // not a bug
16331
16332 log_info ("Hashtype: %s", hash_type);
16333 log_info ("");
16334 }
16335 }
16336
16337 /**
16338 * keep track of the progress
16339 */
16340
16341 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16342 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16343 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16344
16345 /**
16346 * open filehandles
16347 */
16348
16349 #if _WIN
16350 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
16351 {
16352 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
16353
16354 return (-1);
16355 }
16356
16357 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
16358 {
16359 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
16360
16361 return (-1);
16362 }
16363
16364 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
16365 {
16366 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
16367
16368 return (-1);
16369 }
16370 #endif
16371
16372 /**
16373 * dictionary pad
16374 */
16375
16376 segment_size *= (1024 * 1024);
16377
16378 data.segment_size = segment_size;
16379
16380 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
16381
16382 wl_data->buf = (char *) mymalloc (segment_size);
16383 wl_data->avail = segment_size;
16384 wl_data->incr = segment_size;
16385 wl_data->cnt = 0;
16386 wl_data->pos = 0;
16387
16388 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
16389
16390 data.wordlist_mode = wordlist_mode;
16391
16392 cs_t *css_buf = NULL;
16393 uint css_cnt = 0;
16394 uint dictcnt = 0;
16395 uint maskcnt = 1;
16396 char **masks = NULL;
16397 char **dictfiles = NULL;
16398
16399 uint mask_from_file = 0;
16400
16401 if (attack_mode == ATTACK_MODE_STRAIGHT)
16402 {
16403 if (wordlist_mode == WL_MODE_FILE)
16404 {
16405 int wls_left = myargc - (optind + 1);
16406
16407 for (int i = 0; i < wls_left; i++)
16408 {
16409 char *l0_filename = myargv[optind + 1 + i];
16410
16411 struct stat l0_stat;
16412
16413 if (stat (l0_filename, &l0_stat) == -1)
16414 {
16415 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
16416
16417 return (-1);
16418 }
16419
16420 uint is_dir = S_ISDIR (l0_stat.st_mode);
16421
16422 if (is_dir == 0)
16423 {
16424 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16425
16426 dictcnt++;
16427
16428 dictfiles[dictcnt - 1] = l0_filename;
16429 }
16430 else
16431 {
16432 // do not allow --keyspace w/ a directory
16433
16434 if (keyspace == 1)
16435 {
16436 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16437
16438 return (-1);
16439 }
16440
16441 char **dictionary_files = NULL;
16442
16443 dictionary_files = scan_directory (l0_filename);
16444
16445 if (dictionary_files != NULL)
16446 {
16447 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16448
16449 for (int d = 0; dictionary_files[d] != NULL; d++)
16450 {
16451 char *l1_filename = dictionary_files[d];
16452
16453 struct stat l1_stat;
16454
16455 if (stat (l1_filename, &l1_stat) == -1)
16456 {
16457 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16458
16459 return (-1);
16460 }
16461
16462 if (S_ISREG (l1_stat.st_mode))
16463 {
16464 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16465
16466 dictcnt++;
16467
16468 dictfiles[dictcnt - 1] = strdup (l1_filename);
16469 }
16470 }
16471 }
16472
16473 local_free (dictionary_files);
16474 }
16475 }
16476
16477 if (dictcnt < 1)
16478 {
16479 log_error ("ERROR: No usable dictionary file found.");
16480
16481 return (-1);
16482 }
16483 }
16484 else if (wordlist_mode == WL_MODE_STDIN)
16485 {
16486 dictcnt = 1;
16487 }
16488 }
16489 else if (attack_mode == ATTACK_MODE_COMBI)
16490 {
16491 // display
16492
16493 char *dictfile1 = myargv[optind + 1 + 0];
16494 char *dictfile2 = myargv[optind + 1 + 1];
16495
16496 // find the bigger dictionary and use as base
16497
16498 FILE *fp1 = NULL;
16499 FILE *fp2 = NULL;
16500
16501 struct stat tmp_stat;
16502
16503 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16504 {
16505 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16506
16507 return (-1);
16508 }
16509
16510 if (stat (dictfile1, &tmp_stat) == -1)
16511 {
16512 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16513
16514 fclose (fp1);
16515
16516 return (-1);
16517 }
16518
16519 if (S_ISDIR (tmp_stat.st_mode))
16520 {
16521 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16522
16523 fclose (fp1);
16524
16525 return (-1);
16526 }
16527
16528 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16529 {
16530 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16531
16532 fclose (fp1);
16533
16534 return (-1);
16535 }
16536
16537 if (stat (dictfile2, &tmp_stat) == -1)
16538 {
16539 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16540
16541 fclose (fp1);
16542 fclose (fp2);
16543
16544 return (-1);
16545 }
16546
16547 if (S_ISDIR (tmp_stat.st_mode))
16548 {
16549 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16550
16551 fclose (fp1);
16552 fclose (fp2);
16553
16554 return (-1);
16555 }
16556
16557 data.combs_cnt = 1;
16558
16559 data.quiet = 1;
16560
16561 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16562
16563 data.quiet = quiet;
16564
16565 if (words1_cnt == 0)
16566 {
16567 log_error ("ERROR: %s: empty file", dictfile1);
16568
16569 fclose (fp1);
16570 fclose (fp2);
16571
16572 return (-1);
16573 }
16574
16575 data.combs_cnt = 1;
16576
16577 data.quiet = 1;
16578
16579 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16580
16581 data.quiet = quiet;
16582
16583 if (words2_cnt == 0)
16584 {
16585 log_error ("ERROR: %s: empty file", dictfile2);
16586
16587 fclose (fp1);
16588 fclose (fp2);
16589
16590 return (-1);
16591 }
16592
16593 fclose (fp1);
16594 fclose (fp2);
16595
16596 data.dictfile = dictfile1;
16597 data.dictfile2 = dictfile2;
16598
16599 if (words1_cnt >= words2_cnt)
16600 {
16601 data.combs_cnt = words2_cnt;
16602 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16603
16604 dictfiles = &data.dictfile;
16605
16606 dictcnt = 1;
16607 }
16608 else
16609 {
16610 data.combs_cnt = words1_cnt;
16611 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16612
16613 dictfiles = &data.dictfile2;
16614
16615 dictcnt = 1;
16616
16617 // we also have to switch wordlist related rules!
16618
16619 char *tmpc = data.rule_buf_l;
16620
16621 data.rule_buf_l = data.rule_buf_r;
16622 data.rule_buf_r = tmpc;
16623
16624 int tmpi = data.rule_len_l;
16625
16626 data.rule_len_l = data.rule_len_r;
16627 data.rule_len_r = tmpi;
16628 }
16629 }
16630 else if (attack_mode == ATTACK_MODE_BF)
16631 {
16632 char *mask = NULL;
16633
16634 maskcnt = 0;
16635
16636 if (benchmark == 0)
16637 {
16638 mask = myargv[optind + 1];
16639
16640 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16641
16642 if ((optind + 2) <= myargc)
16643 {
16644 struct stat file_stat;
16645
16646 if (stat (mask, &file_stat) == -1)
16647 {
16648 maskcnt = 1;
16649
16650 masks[maskcnt - 1] = mystrdup (mask);
16651 }
16652 else
16653 {
16654 int wls_left = myargc - (optind + 1);
16655
16656 uint masks_avail = INCR_MASKS;
16657
16658 for (int i = 0; i < wls_left; i++)
16659 {
16660 if (i != 0)
16661 {
16662 mask = myargv[optind + 1 + i];
16663
16664 if (stat (mask, &file_stat) == -1)
16665 {
16666 log_error ("ERROR: %s: %s", mask, strerror (errno));
16667
16668 return (-1);
16669 }
16670 }
16671
16672 uint is_file = S_ISREG (file_stat.st_mode);
16673
16674 if (is_file == 1)
16675 {
16676 FILE *mask_fp;
16677
16678 if ((mask_fp = fopen (mask, "r")) == NULL)
16679 {
16680 log_error ("ERROR: %s: %s", mask, strerror (errno));
16681
16682 return (-1);
16683 }
16684
16685 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16686
16687 while (!feof (mask_fp))
16688 {
16689 memset (line_buf, 0, HCBUFSIZ);
16690
16691 int line_len = fgetl (mask_fp, line_buf);
16692
16693 if (line_len == 0) continue;
16694
16695 if (line_buf[0] == '#') continue;
16696
16697 if (masks_avail == maskcnt)
16698 {
16699 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16700
16701 masks_avail += INCR_MASKS;
16702 }
16703
16704 masks[maskcnt] = mystrdup (line_buf);
16705
16706 maskcnt++;
16707 }
16708
16709 myfree (line_buf);
16710
16711 fclose (mask_fp);
16712 }
16713 else
16714 {
16715 log_error ("ERROR: %s: unsupported file-type", mask);
16716
16717 return (-1);
16718 }
16719 }
16720
16721 mask_from_file = 1;
16722 }
16723 }
16724 else
16725 {
16726 custom_charset_1 = (char *) "?l?d?u";
16727 custom_charset_2 = (char *) "?l?d";
16728 custom_charset_3 = (char *) "?l?d*!$@_";
16729
16730 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16731 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16732 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16733
16734 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16735
16736 wordlist_mode = WL_MODE_MASK;
16737
16738 data.wordlist_mode = wordlist_mode;
16739
16740 increment = 1;
16741
16742 maskcnt = 1;
16743 }
16744 }
16745 else
16746 {
16747 /**
16748 * generate full masks and charsets
16749 */
16750
16751 masks = (char **) mymalloc (sizeof (char *));
16752
16753 switch (hash_mode)
16754 {
16755 case 1731: pw_min = 5;
16756 pw_max = 5;
16757 mask = mystrdup ("?b?b?b?b?b");
16758 break;
16759 case 12500: pw_min = 5;
16760 pw_max = 5;
16761 mask = mystrdup ("?b?b?b?b?b");
16762 break;
16763 default: pw_min = 7;
16764 pw_max = 7;
16765 mask = mystrdup ("?b?b?b?b?b?b?b");
16766 break;
16767 }
16768
16769 maskcnt = 1;
16770
16771 masks[maskcnt - 1] = mystrdup (mask);
16772
16773 wordlist_mode = WL_MODE_MASK;
16774
16775 data.wordlist_mode = wordlist_mode;
16776
16777 increment = 1;
16778 }
16779
16780 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16781
16782 if (increment)
16783 {
16784 if (increment_min > pw_min) pw_min = increment_min;
16785
16786 if (increment_max < pw_max) pw_max = increment_max;
16787 }
16788 }
16789 else if (attack_mode == ATTACK_MODE_HYBRID1)
16790 {
16791 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16792
16793 // display
16794
16795 char *mask = myargv[myargc - 1];
16796
16797 maskcnt = 0;
16798
16799 masks = (char **) mymalloc (1 * sizeof (char *));
16800
16801 // mod
16802
16803 struct stat file_stat;
16804
16805 if (stat (mask, &file_stat) == -1)
16806 {
16807 maskcnt = 1;
16808
16809 masks[maskcnt - 1] = mystrdup (mask);
16810 }
16811 else
16812 {
16813 uint is_file = S_ISREG (file_stat.st_mode);
16814
16815 if (is_file == 1)
16816 {
16817 FILE *mask_fp;
16818
16819 if ((mask_fp = fopen (mask, "r")) == NULL)
16820 {
16821 log_error ("ERROR: %s: %s", mask, strerror (errno));
16822
16823 return (-1);
16824 }
16825
16826 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16827
16828 uint masks_avail = 1;
16829
16830 while (!feof (mask_fp))
16831 {
16832 memset (line_buf, 0, HCBUFSIZ);
16833
16834 int line_len = fgetl (mask_fp, line_buf);
16835
16836 if (line_len == 0) continue;
16837
16838 if (line_buf[0] == '#') continue;
16839
16840 if (masks_avail == maskcnt)
16841 {
16842 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16843
16844 masks_avail += INCR_MASKS;
16845 }
16846
16847 masks[maskcnt] = mystrdup (line_buf);
16848
16849 maskcnt++;
16850 }
16851
16852 myfree (line_buf);
16853
16854 fclose (mask_fp);
16855
16856 mask_from_file = 1;
16857 }
16858 else
16859 {
16860 maskcnt = 1;
16861
16862 masks[maskcnt - 1] = mystrdup (mask);
16863 }
16864 }
16865
16866 // base
16867
16868 int wls_left = myargc - (optind + 2);
16869
16870 for (int i = 0; i < wls_left; i++)
16871 {
16872 char *filename = myargv[optind + 1 + i];
16873
16874 struct stat file_stat;
16875
16876 if (stat (filename, &file_stat) == -1)
16877 {
16878 log_error ("ERROR: %s: %s", filename, strerror (errno));
16879
16880 return (-1);
16881 }
16882
16883 uint is_dir = S_ISDIR (file_stat.st_mode);
16884
16885 if (is_dir == 0)
16886 {
16887 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16888
16889 dictcnt++;
16890
16891 dictfiles[dictcnt - 1] = filename;
16892 }
16893 else
16894 {
16895 // do not allow --keyspace w/ a directory
16896
16897 if (keyspace == 1)
16898 {
16899 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16900
16901 return (-1);
16902 }
16903
16904 char **dictionary_files = NULL;
16905
16906 dictionary_files = scan_directory (filename);
16907
16908 if (dictionary_files != NULL)
16909 {
16910 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16911
16912 for (int d = 0; dictionary_files[d] != NULL; d++)
16913 {
16914 char *l1_filename = dictionary_files[d];
16915
16916 struct stat l1_stat;
16917
16918 if (stat (l1_filename, &l1_stat) == -1)
16919 {
16920 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16921
16922 return (-1);
16923 }
16924
16925 if (S_ISREG (l1_stat.st_mode))
16926 {
16927 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16928
16929 dictcnt++;
16930
16931 dictfiles[dictcnt - 1] = strdup (l1_filename);
16932 }
16933 }
16934 }
16935
16936 local_free (dictionary_files);
16937 }
16938 }
16939
16940 if (dictcnt < 1)
16941 {
16942 log_error ("ERROR: No usable dictionary file found.");
16943
16944 return (-1);
16945 }
16946
16947 if (increment)
16948 {
16949 maskcnt = 0;
16950
16951 uint mask_min = increment_min; // we can't reject smaller masks here
16952 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16953
16954 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16955 {
16956 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16957
16958 if (cur_mask == NULL) break;
16959
16960 masks[maskcnt] = cur_mask;
16961
16962 maskcnt++;
16963
16964 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16965 }
16966 }
16967 }
16968 else if (attack_mode == ATTACK_MODE_HYBRID2)
16969 {
16970 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16971
16972 // display
16973
16974 char *mask = myargv[optind + 1 + 0];
16975
16976 maskcnt = 0;
16977
16978 masks = (char **) mymalloc (1 * sizeof (char *));
16979
16980 // mod
16981
16982 struct stat file_stat;
16983
16984 if (stat (mask, &file_stat) == -1)
16985 {
16986 maskcnt = 1;
16987
16988 masks[maskcnt - 1] = mystrdup (mask);
16989 }
16990 else
16991 {
16992 uint is_file = S_ISREG (file_stat.st_mode);
16993
16994 if (is_file == 1)
16995 {
16996 FILE *mask_fp;
16997
16998 if ((mask_fp = fopen (mask, "r")) == NULL)
16999 {
17000 log_error ("ERROR: %s: %s", mask, strerror (errno));
17001
17002 return (-1);
17003 }
17004
17005 char *line_buf = (char *) mymalloc (HCBUFSIZ);
17006
17007 uint masks_avail = 1;
17008
17009 while (!feof (mask_fp))
17010 {
17011 memset (line_buf, 0, HCBUFSIZ);
17012
17013 int line_len = fgetl (mask_fp, line_buf);
17014
17015 if (line_len == 0) continue;
17016
17017 if (line_buf[0] == '#') continue;
17018
17019 if (masks_avail == maskcnt)
17020 {
17021 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
17022
17023 masks_avail += INCR_MASKS;
17024 }
17025
17026 masks[maskcnt] = mystrdup (line_buf);
17027
17028 maskcnt++;
17029 }
17030
17031 myfree (line_buf);
17032
17033 fclose (mask_fp);
17034
17035 mask_from_file = 1;
17036 }
17037 else
17038 {
17039 maskcnt = 1;
17040
17041 masks[maskcnt - 1] = mystrdup (mask);
17042 }
17043 }
17044
17045 // base
17046
17047 int wls_left = myargc - (optind + 2);
17048
17049 for (int i = 0; i < wls_left; i++)
17050 {
17051 char *filename = myargv[optind + 2 + i];
17052
17053 struct stat file_stat;
17054
17055 if (stat (filename, &file_stat) == -1)
17056 {
17057 log_error ("ERROR: %s: %s", filename, strerror (errno));
17058
17059 return (-1);
17060 }
17061
17062 uint is_dir = S_ISDIR (file_stat.st_mode);
17063
17064 if (is_dir == 0)
17065 {
17066 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17067
17068 dictcnt++;
17069
17070 dictfiles[dictcnt - 1] = filename;
17071 }
17072 else
17073 {
17074 // do not allow --keyspace w/ a directory
17075
17076 if (keyspace == 1)
17077 {
17078 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17079
17080 return (-1);
17081 }
17082
17083 char **dictionary_files = NULL;
17084
17085 dictionary_files = scan_directory (filename);
17086
17087 if (dictionary_files != NULL)
17088 {
17089 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17090
17091 for (int d = 0; dictionary_files[d] != NULL; d++)
17092 {
17093 char *l1_filename = dictionary_files[d];
17094
17095 struct stat l1_stat;
17096
17097 if (stat (l1_filename, &l1_stat) == -1)
17098 {
17099 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17100
17101 return (-1);
17102 }
17103
17104 if (S_ISREG (l1_stat.st_mode))
17105 {
17106 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17107
17108 dictcnt++;
17109
17110 dictfiles[dictcnt - 1] = strdup (l1_filename);
17111 }
17112 }
17113 }
17114
17115 local_free (dictionary_files);
17116 }
17117 }
17118
17119 if (dictcnt < 1)
17120 {
17121 log_error ("ERROR: No usable dictionary file found.");
17122
17123 return (-1);
17124 }
17125
17126 if (increment)
17127 {
17128 maskcnt = 0;
17129
17130 uint mask_min = increment_min; // we can't reject smaller masks here
17131 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17132
17133 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17134 {
17135 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17136
17137 if (cur_mask == NULL) break;
17138
17139 masks[maskcnt] = cur_mask;
17140
17141 maskcnt++;
17142
17143 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17144 }
17145 }
17146 }
17147
17148 data.pw_min = pw_min;
17149 data.pw_max = pw_max;
17150
17151 /**
17152 * weak hash check
17153 */
17154
17155 if (weak_hash_threshold >= salts_cnt)
17156 {
17157 hc_device_param_t *device_param = NULL;
17158
17159 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17160 {
17161 device_param = &data.devices_param[device_id];
17162
17163 if (device_param->skipped) continue;
17164
17165 break;
17166 }
17167
17168 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
17169
17170 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
17171 {
17172 weak_hash_check (device_param, salt_pos);
17173 }
17174
17175 // Display hack, guarantee that there is at least one \r before real start
17176
17177 //if (data.quiet == 0) log_info ("");
17178 }
17179
17180 /**
17181 * status and monitor threads
17182 */
17183
17184 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
17185
17186 uint i_threads_cnt = 0;
17187
17188 hc_thread_t *i_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17189
17190 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17191 {
17192 if (stdout_flag == 0)
17193 {
17194 hc_thread_create (i_threads[i_threads_cnt], thread_keypress, &benchmark);
17195
17196 i_threads_cnt++;
17197 }
17198 }
17199
17200 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
17201
17202 uint ni_threads_cnt = 0;
17203
17204 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17205
17206 if (stdout_flag == 0)
17207 {
17208 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
17209
17210 ni_threads_cnt++;
17211 }
17212
17213 /**
17214 * Outfile remove
17215 */
17216
17217 if (keyspace == 0)
17218 {
17219 if (outfile_check_timer != 0)
17220 {
17221 if (data.outfile_check_directory != NULL)
17222 {
17223 if ((hash_mode != 5200) &&
17224 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
17225 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
17226 (hash_mode != 9000))
17227 {
17228 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
17229
17230 ni_threads_cnt++;
17231 }
17232 else
17233 {
17234 outfile_check_timer = 0;
17235 }
17236 }
17237 else
17238 {
17239 outfile_check_timer = 0;
17240 }
17241 }
17242 }
17243
17244 /**
17245 * Inform the user if we got some hashes remove because of the pot file remove feature
17246 */
17247
17248 if (data.quiet == 0)
17249 {
17250 if (potfile_remove_cracks > 0)
17251 {
17252 if (potfile_remove_cracks == 1) log_info ("INFO: Removed 1 hash found in pot file\n");
17253 else log_info ("INFO: Removed %u hashes found in pot file\n", potfile_remove_cracks);
17254 }
17255 }
17256
17257 data.outfile_check_timer = outfile_check_timer;
17258
17259 /**
17260 * main loop
17261 */
17262
17263 char **induction_dictionaries = NULL;
17264
17265 int induction_dictionaries_cnt = 0;
17266
17267 hcstat_table_t *root_table_buf = NULL;
17268 hcstat_table_t *markov_table_buf = NULL;
17269
17270 uint initial_restore_done = 0;
17271
17272 data.maskcnt = maskcnt;
17273
17274 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
17275 {
17276 if (data.devices_status == STATUS_CRACKED) break;
17277
17278 data.devices_status = STATUS_INIT;
17279
17280 if (maskpos > rd->maskpos)
17281 {
17282 rd->dictpos = 0;
17283 }
17284
17285 rd->maskpos = maskpos;
17286 data.maskpos = maskpos;
17287
17288 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
17289 {
17290 char *mask = masks[maskpos];
17291
17292 if (mask_from_file == 1)
17293 {
17294 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
17295
17296 char *str_ptr;
17297 uint str_pos;
17298
17299 uint mask_offset = 0;
17300
17301 uint separator_cnt;
17302
17303 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
17304 {
17305 str_ptr = strstr (mask + mask_offset, ",");
17306
17307 if (str_ptr == NULL) break;
17308
17309 str_pos = str_ptr - mask;
17310
17311 // escaped separator, i.e. "\,"
17312
17313 if (str_pos > 0)
17314 {
17315 if (mask[str_pos - 1] == '\\')
17316 {
17317 separator_cnt --;
17318
17319 mask_offset = str_pos + 1;
17320
17321 continue;
17322 }
17323 }
17324
17325 // reset the offset
17326
17327 mask_offset = 0;
17328
17329 mask[str_pos] = '\0';
17330
17331 switch (separator_cnt)
17332 {
17333 case 0:
17334 mp_reset_usr (mp_usr, 0);
17335
17336 custom_charset_1 = mask;
17337 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17338 break;
17339
17340 case 1:
17341 mp_reset_usr (mp_usr, 1);
17342
17343 custom_charset_2 = mask;
17344 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17345 break;
17346
17347 case 2:
17348 mp_reset_usr (mp_usr, 2);
17349
17350 custom_charset_3 = mask;
17351 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17352 break;
17353
17354 case 3:
17355 mp_reset_usr (mp_usr, 3);
17356
17357 custom_charset_4 = mask;
17358 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
17359 break;
17360 }
17361
17362 mask = mask + str_pos + 1;
17363 }
17364 }
17365
17366 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17367 {
17368 if (maskpos > 0)
17369 {
17370 local_free (css_buf);
17371 local_free (data.root_css_buf);
17372 local_free (data.markov_css_buf);
17373
17374 local_free (masks[maskpos - 1]);
17375 }
17376
17377 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17378
17379 data.mask = mask;
17380 data.css_cnt = css_cnt;
17381 data.css_buf = css_buf;
17382
17383 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17384
17385 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17386
17387 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17388 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17389
17390 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17391
17392 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17393
17394 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17395 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17396
17397 data.root_css_buf = root_css_buf;
17398 data.markov_css_buf = markov_css_buf;
17399
17400 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17401
17402 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17403
17404 local_free (root_table_buf);
17405 local_free (markov_table_buf);
17406
17407 // args
17408
17409 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17410 {
17411 hc_device_param_t *device_param = &data.devices_param[device_id];
17412
17413 if (device_param->skipped) continue;
17414
17415 device_param->kernel_params_mp[0] = &device_param->d_combs;
17416 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
17417 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
17418
17419 device_param->kernel_params_mp_buf64[3] = 0;
17420 device_param->kernel_params_mp_buf32[4] = css_cnt;
17421 device_param->kernel_params_mp_buf32[5] = 0;
17422 device_param->kernel_params_mp_buf32[6] = 0;
17423 device_param->kernel_params_mp_buf32[7] = 0;
17424
17425 if (attack_mode == ATTACK_MODE_HYBRID1)
17426 {
17427 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
17428 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
17429 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
17430 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
17431 }
17432 else if (attack_mode == ATTACK_MODE_HYBRID2)
17433 {
17434 device_param->kernel_params_mp_buf32[5] = 0;
17435 device_param->kernel_params_mp_buf32[6] = 0;
17436 device_param->kernel_params_mp_buf32[7] = 0;
17437 }
17438
17439 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]);
17440 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]);
17441 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]);
17442
17443 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);
17444 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);
17445 }
17446 }
17447 else if (attack_mode == ATTACK_MODE_BF)
17448 {
17449 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
17450
17451 if (increment)
17452 {
17453 for (uint i = 0; i < dictcnt; i++)
17454 {
17455 local_free (dictfiles[i]);
17456 }
17457
17458 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17459 {
17460 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17461
17462 if (l1_filename == NULL) break;
17463
17464 dictcnt++;
17465
17466 dictfiles[dictcnt - 1] = l1_filename;
17467 }
17468 }
17469 else
17470 {
17471 dictcnt++;
17472
17473 dictfiles[dictcnt - 1] = mask;
17474 }
17475
17476 if (dictcnt == 0)
17477 {
17478 log_error ("ERROR: Mask is too small");
17479
17480 return (-1);
17481 }
17482 }
17483 }
17484
17485 free (induction_dictionaries);
17486
17487 // induction_dictionaries_cnt = 0; // implied
17488
17489 if (attack_mode != ATTACK_MODE_BF)
17490 {
17491 if (keyspace == 0)
17492 {
17493 induction_dictionaries = scan_directory (induction_directory);
17494
17495 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17496 }
17497 }
17498
17499 if (induction_dictionaries_cnt)
17500 {
17501 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17502 }
17503
17504 /**
17505 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17506 */
17507 if (keyspace == 1)
17508 {
17509 if ((maskcnt > 1) || (dictcnt > 1))
17510 {
17511 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17512
17513 return (-1);
17514 }
17515 }
17516
17517 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17518 {
17519 char *subid = logfile_generate_subid ();
17520
17521 data.subid = subid;
17522
17523 logfile_sub_msg ("START");
17524
17525 data.devices_status = STATUS_INIT;
17526
17527 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17528 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17529 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17530
17531 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17532
17533 data.cpt_pos = 0;
17534
17535 data.cpt_start = time (NULL);
17536
17537 data.cpt_total = 0;
17538
17539 if (data.restore == 0)
17540 {
17541 rd->words_cur = skip;
17542
17543 skip = 0;
17544
17545 data.skip = 0;
17546 }
17547
17548 data.ms_paused = 0;
17549
17550 data.kernel_power_final = 0;
17551
17552 data.words_cur = rd->words_cur;
17553
17554 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17555 {
17556 hc_device_param_t *device_param = &data.devices_param[device_id];
17557
17558 if (device_param->skipped) continue;
17559
17560 device_param->speed_pos = 0;
17561
17562 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17563 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17564
17565 device_param->exec_pos = 0;
17566
17567 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17568
17569 device_param->outerloop_pos = 0;
17570 device_param->outerloop_left = 0;
17571 device_param->innerloop_pos = 0;
17572 device_param->innerloop_left = 0;
17573
17574 // some more resets:
17575
17576 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17577
17578 device_param->pws_cnt = 0;
17579
17580 device_param->words_off = 0;
17581 device_param->words_done = 0;
17582 }
17583
17584 // figure out some workload
17585
17586 if (attack_mode == ATTACK_MODE_STRAIGHT)
17587 {
17588 if (data.wordlist_mode == WL_MODE_FILE)
17589 {
17590 char *dictfile = NULL;
17591
17592 if (induction_dictionaries_cnt)
17593 {
17594 dictfile = induction_dictionaries[0];
17595 }
17596 else
17597 {
17598 dictfile = dictfiles[dictpos];
17599 }
17600
17601 data.dictfile = dictfile;
17602
17603 logfile_sub_string (dictfile);
17604
17605 for (uint i = 0; i < rp_files_cnt; i++)
17606 {
17607 logfile_sub_var_string ("rulefile", rp_files[i]);
17608 }
17609
17610 FILE *fd2 = fopen (dictfile, "rb");
17611
17612 if (fd2 == NULL)
17613 {
17614 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17615
17616 return (-1);
17617 }
17618
17619 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17620
17621 fclose (fd2);
17622
17623 if (data.words_cnt == 0)
17624 {
17625 if (data.devices_status == STATUS_CRACKED) break;
17626 if (data.devices_status == STATUS_ABORTED) break;
17627
17628 dictpos++;
17629
17630 continue;
17631 }
17632 }
17633 }
17634 else if (attack_mode == ATTACK_MODE_COMBI)
17635 {
17636 char *dictfile = data.dictfile;
17637 char *dictfile2 = data.dictfile2;
17638
17639 logfile_sub_string (dictfile);
17640 logfile_sub_string (dictfile2);
17641
17642 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17643 {
17644 FILE *fd2 = fopen (dictfile, "rb");
17645
17646 if (fd2 == NULL)
17647 {
17648 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17649
17650 return (-1);
17651 }
17652
17653 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17654
17655 fclose (fd2);
17656 }
17657 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17658 {
17659 FILE *fd2 = fopen (dictfile2, "rb");
17660
17661 if (fd2 == NULL)
17662 {
17663 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17664
17665 return (-1);
17666 }
17667
17668 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17669
17670 fclose (fd2);
17671 }
17672
17673 if (data.words_cnt == 0)
17674 {
17675 if (data.devices_status == STATUS_CRACKED) break;
17676 if (data.devices_status == STATUS_ABORTED) break;
17677
17678 dictpos++;
17679
17680 continue;
17681 }
17682 }
17683 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17684 {
17685 char *dictfile = NULL;
17686
17687 if (induction_dictionaries_cnt)
17688 {
17689 dictfile = induction_dictionaries[0];
17690 }
17691 else
17692 {
17693 dictfile = dictfiles[dictpos];
17694 }
17695
17696 data.dictfile = dictfile;
17697
17698 char *mask = data.mask;
17699
17700 logfile_sub_string (dictfile);
17701 logfile_sub_string (mask);
17702
17703 FILE *fd2 = fopen (dictfile, "rb");
17704
17705 if (fd2 == NULL)
17706 {
17707 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17708
17709 return (-1);
17710 }
17711
17712 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17713
17714 fclose (fd2);
17715
17716 if (data.words_cnt == 0)
17717 {
17718 if (data.devices_status == STATUS_CRACKED) break;
17719 if (data.devices_status == STATUS_ABORTED) break;
17720
17721 dictpos++;
17722
17723 continue;
17724 }
17725 }
17726 else if (attack_mode == ATTACK_MODE_BF)
17727 {
17728 local_free (css_buf);
17729 local_free (data.root_css_buf);
17730 local_free (data.markov_css_buf);
17731
17732 char *mask = dictfiles[dictpos];
17733
17734 logfile_sub_string (mask);
17735
17736 // base
17737
17738 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17739
17740 if (opts_type & OPTS_TYPE_PT_UNICODE)
17741 {
17742 uint css_cnt_unicode = css_cnt * 2;
17743
17744 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17745
17746 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17747 {
17748 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17749
17750 css_buf_unicode[j + 1].cs_buf[0] = 0;
17751 css_buf_unicode[j + 1].cs_len = 1;
17752 }
17753
17754 free (css_buf);
17755
17756 css_buf = css_buf_unicode;
17757 css_cnt = css_cnt_unicode;
17758 }
17759
17760 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17761
17762 uint mask_min = pw_min;
17763 uint mask_max = pw_max;
17764
17765 if (opts_type & OPTS_TYPE_PT_UNICODE)
17766 {
17767 mask_min *= 2;
17768 mask_max *= 2;
17769 }
17770
17771 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17772 {
17773 if (css_cnt < mask_min)
17774 {
17775 log_info ("WARNING: Skipping mask '%s' because it is smaller than the minimum password length", mask);
17776 }
17777
17778 if (css_cnt > mask_max)
17779 {
17780 log_info ("WARNING: Skipping mask '%s' because it is larger than the maximum password length", mask);
17781 }
17782
17783 // skip to next mask
17784
17785 dictpos++;
17786
17787 rd->dictpos = dictpos;
17788
17789 logfile_sub_msg ("STOP");
17790
17791 continue;
17792 }
17793
17794 uint save_css_cnt = css_cnt;
17795
17796 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17797 {
17798 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17799 {
17800 uint salt_len = (uint) data.salts_buf[0].salt_len;
17801 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17802
17803 uint css_cnt_salt = css_cnt + salt_len;
17804
17805 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17806
17807 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17808
17809 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17810 {
17811 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17812 css_buf_salt[j].cs_len = 1;
17813 }
17814
17815 free (css_buf);
17816
17817 css_buf = css_buf_salt;
17818 css_cnt = css_cnt_salt;
17819 }
17820 }
17821
17822 data.mask = mask;
17823 data.css_cnt = css_cnt;
17824 data.css_buf = css_buf;
17825
17826 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17827
17828 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17829
17830 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17831
17832 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17833 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17834
17835 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17836
17837 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17838
17839 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17840 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17841
17842 data.root_css_buf = root_css_buf;
17843 data.markov_css_buf = markov_css_buf;
17844
17845 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17846
17847 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17848
17849 local_free (root_table_buf);
17850 local_free (markov_table_buf);
17851
17852 // copy + args
17853
17854 uint css_cnt_l = css_cnt;
17855 uint css_cnt_r;
17856
17857 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17858 {
17859 if (save_css_cnt < 6)
17860 {
17861 css_cnt_r = 1;
17862 }
17863 else if (save_css_cnt == 6)
17864 {
17865 css_cnt_r = 2;
17866 }
17867 else
17868 {
17869 if (opts_type & OPTS_TYPE_PT_UNICODE)
17870 {
17871 if (save_css_cnt == 8 || save_css_cnt == 10)
17872 {
17873 css_cnt_r = 2;
17874 }
17875 else
17876 {
17877 css_cnt_r = 4;
17878 }
17879 }
17880 else
17881 {
17882 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17883 {
17884 css_cnt_r = 3;
17885 }
17886 else
17887 {
17888 css_cnt_r = 4;
17889 }
17890 }
17891 }
17892 }
17893 else
17894 {
17895 css_cnt_r = 1;
17896
17897 /* unfinished code?
17898 int sum = css_buf[css_cnt_r - 1].cs_len;
17899
17900 for (uint i = 1; i < 4 && i < css_cnt; i++)
17901 {
17902 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17903
17904 css_cnt_r++;
17905
17906 sum *= css_buf[css_cnt_r - 1].cs_len;
17907 }
17908 */
17909 }
17910
17911 css_cnt_l -= css_cnt_r;
17912
17913 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17914
17915 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17916 {
17917 hc_device_param_t *device_param = &data.devices_param[device_id];
17918
17919 if (device_param->skipped) continue;
17920
17921 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17922 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17923 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17924
17925 device_param->kernel_params_mp_l_buf64[3] = 0;
17926 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17927 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17928 device_param->kernel_params_mp_l_buf32[6] = 0;
17929 device_param->kernel_params_mp_l_buf32[7] = 0;
17930 device_param->kernel_params_mp_l_buf32[8] = 0;
17931
17932 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17933 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17934 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17935 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17936
17937 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17938 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17939 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17940
17941 device_param->kernel_params_mp_r_buf64[3] = 0;
17942 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17943 device_param->kernel_params_mp_r_buf32[5] = 0;
17944 device_param->kernel_params_mp_r_buf32[6] = 0;
17945 device_param->kernel_params_mp_r_buf32[7] = 0;
17946
17947 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]);
17948 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]);
17949 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]);
17950
17951 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]);
17952 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]);
17953 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]);
17954
17955 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);
17956 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);
17957 }
17958 }
17959
17960 u64 words_base = data.words_cnt;
17961
17962 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17963 {
17964 if (data.kernel_rules_cnt)
17965 {
17966 words_base /= data.kernel_rules_cnt;
17967 }
17968 }
17969 else if (data.attack_kern == ATTACK_KERN_COMBI)
17970 {
17971 if (data.combs_cnt)
17972 {
17973 words_base /= data.combs_cnt;
17974 }
17975 }
17976 else if (data.attack_kern == ATTACK_KERN_BF)
17977 {
17978 if (data.bfs_cnt)
17979 {
17980 words_base /= data.bfs_cnt;
17981 }
17982 }
17983
17984 data.words_base = words_base;
17985
17986 if (keyspace == 1)
17987 {
17988 log_info ("%llu", (unsigned long long int) words_base);
17989
17990 return (0);
17991 }
17992
17993 if (data.words_cur > data.words_base)
17994 {
17995 log_error ("ERROR: Restore value greater keyspace");
17996
17997 return (-1);
17998 }
17999
18000 if (data.words_cur)
18001 {
18002 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18003 {
18004 for (uint i = 0; i < data.salts_cnt; i++)
18005 {
18006 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
18007 }
18008 }
18009 else if (data.attack_kern == ATTACK_KERN_COMBI)
18010 {
18011 for (uint i = 0; i < data.salts_cnt; i++)
18012 {
18013 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
18014 }
18015 }
18016 else if (data.attack_kern == ATTACK_KERN_BF)
18017 {
18018 for (uint i = 0; i < data.salts_cnt; i++)
18019 {
18020 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
18021 }
18022 }
18023 }
18024
18025 /*
18026 * Update loopback file
18027 */
18028
18029 if (loopback == 1)
18030 {
18031 time_t now;
18032
18033 time (&now);
18034
18035 uint random_num = get_random_num (0, 9999);
18036
18037 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
18038
18039 data.loopback_file = loopback_file;
18040 }
18041
18042 /*
18043 * Update dictionary statistic
18044 */
18045
18046 if (keyspace == 0)
18047 {
18048 dictstat_fp = fopen (dictstat, "wb");
18049
18050 if (dictstat_fp)
18051 {
18052 lock_file (dictstat_fp);
18053
18054 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
18055
18056 fclose (dictstat_fp);
18057 }
18058 }
18059
18060 /**
18061 * create autotune threads
18062 */
18063
18064 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
18065
18066 data.devices_status = STATUS_AUTOTUNE;
18067
18068 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18069 {
18070 hc_device_param_t *device_param = &devices_param[device_id];
18071
18072 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
18073 }
18074
18075 hc_thread_wait (data.devices_cnt, c_threads);
18076
18077 /*
18078 * Inform user about possible slow speeds
18079 */
18080
18081 uint hardware_power_all = 0;
18082
18083 uint kernel_power_all = 0;
18084
18085 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18086 {
18087 hc_device_param_t *device_param = &devices_param[device_id];
18088
18089 hardware_power_all += device_param->hardware_power;
18090
18091 kernel_power_all += device_param->kernel_power;
18092 }
18093
18094 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
18095
18096 data.kernel_power_all = kernel_power_all;
18097
18098 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18099 {
18100 if (data.words_base < kernel_power_all)
18101 {
18102 if (quiet == 0)
18103 {
18104 clear_prompt ();
18105
18106 log_info ("ATTENTION!");
18107 log_info (" The wordlist or mask you are using is too small.");
18108 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
18109 log_info (" The cracking speed will drop.");
18110 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
18111 log_info ("");
18112 }
18113 }
18114 }
18115
18116 /**
18117 * create cracker threads
18118 */
18119
18120 data.devices_status = STATUS_RUNNING;
18121
18122 if (initial_restore_done == 0)
18123 {
18124 if (data.restore_disable == 0) cycle_restore ();
18125
18126 initial_restore_done = 1;
18127 }
18128
18129 hc_timer_set (&data.timer_running);
18130
18131 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18132 {
18133 if ((quiet == 0) && (status == 0) && (benchmark == 0))
18134 {
18135 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
18136 if (quiet == 0) fflush (stdout);
18137 }
18138 }
18139 else if (wordlist_mode == WL_MODE_STDIN)
18140 {
18141 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
18142 if (data.quiet == 0) log_info ("");
18143 }
18144
18145 time_t runtime_start;
18146
18147 time (&runtime_start);
18148
18149 data.runtime_start = runtime_start;
18150
18151 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18152 {
18153 hc_device_param_t *device_param = &devices_param[device_id];
18154
18155 if (wordlist_mode == WL_MODE_STDIN)
18156 {
18157 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
18158 }
18159 else
18160 {
18161 hc_thread_create (c_threads[device_id], thread_calc, device_param);
18162 }
18163 }
18164
18165 hc_thread_wait (data.devices_cnt, c_threads);
18166
18167 local_free (c_threads);
18168
18169 data.restore = 0;
18170
18171 // finalize task
18172
18173 logfile_sub_var_uint ("status-after-work", data.devices_status);
18174
18175 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18176
18177 if (data.devices_status == STATUS_CRACKED) break;
18178 if (data.devices_status == STATUS_ABORTED) break;
18179
18180 if (data.devices_status == STATUS_BYPASS)
18181 {
18182 data.devices_status = STATUS_RUNNING;
18183 }
18184
18185 if (induction_dictionaries_cnt)
18186 {
18187 unlink (induction_dictionaries[0]);
18188 }
18189
18190 free (induction_dictionaries);
18191
18192 if (attack_mode != ATTACK_MODE_BF)
18193 {
18194 induction_dictionaries = scan_directory (induction_directory);
18195
18196 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18197 }
18198
18199 if (benchmark == 0)
18200 {
18201 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
18202 {
18203 if (quiet == 0) clear_prompt ();
18204
18205 if (quiet == 0) log_info ("");
18206
18207 if (status == 1)
18208 {
18209 status_display ();
18210 }
18211 else
18212 {
18213 if (quiet == 0) status_display ();
18214 }
18215
18216 if (quiet == 0) log_info ("");
18217 }
18218 }
18219
18220 if (attack_mode == ATTACK_MODE_BF)
18221 {
18222 dictpos++;
18223
18224 rd->dictpos = dictpos;
18225 }
18226 else
18227 {
18228 if (induction_dictionaries_cnt)
18229 {
18230 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18231 }
18232 else
18233 {
18234 dictpos++;
18235
18236 rd->dictpos = dictpos;
18237 }
18238 }
18239
18240 time_t runtime_stop;
18241
18242 time (&runtime_stop);
18243
18244 data.runtime_stop = runtime_stop;
18245
18246 logfile_sub_uint (runtime_start);
18247 logfile_sub_uint (runtime_stop);
18248
18249 logfile_sub_msg ("STOP");
18250
18251 global_free (subid);
18252 }
18253
18254 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18255
18256 if (data.devices_status == STATUS_CRACKED) break;
18257 if (data.devices_status == STATUS_ABORTED) break;
18258 if (data.devices_status == STATUS_QUIT) break;
18259
18260 if (data.devices_status == STATUS_BYPASS)
18261 {
18262 data.devices_status = STATUS_RUNNING;
18263 }
18264 }
18265
18266 // 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
18267
18268 if (attack_mode == ATTACK_MODE_STRAIGHT)
18269 {
18270 if (data.wordlist_mode == WL_MODE_FILE)
18271 {
18272 if (data.dictfile == NULL)
18273 {
18274 if (dictfiles != NULL)
18275 {
18276 data.dictfile = dictfiles[0];
18277
18278 hc_timer_set (&data.timer_running);
18279 }
18280 }
18281 }
18282 }
18283 // NOTE: combi is okay because it is already set beforehand
18284 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
18285 {
18286 if (data.dictfile == NULL)
18287 {
18288 if (dictfiles != NULL)
18289 {
18290 hc_timer_set (&data.timer_running);
18291
18292 data.dictfile = dictfiles[0];
18293 }
18294 }
18295 }
18296 else if (attack_mode == ATTACK_MODE_BF)
18297 {
18298 if (data.mask == NULL)
18299 {
18300 hc_timer_set (&data.timer_running);
18301
18302 data.mask = masks[0];
18303 }
18304 }
18305
18306 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18307 {
18308 data.devices_status = STATUS_EXHAUSTED;
18309 }
18310
18311 // if cracked / aborted remove last induction dictionary
18312
18313 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
18314 {
18315 struct stat induct_stat;
18316
18317 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
18318 {
18319 unlink (induction_dictionaries[file_pos]);
18320 }
18321 }
18322
18323 // wait for non-interactive threads
18324
18325 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
18326 {
18327 hc_thread_wait (1, &ni_threads[thread_idx]);
18328 }
18329
18330 local_free (ni_threads);
18331
18332 // wait for interactive threads
18333
18334 for (uint thread_idx = 0; thread_idx < i_threads_cnt; thread_idx++)
18335 {
18336 hc_thread_wait (1, &i_threads[thread_idx]);
18337 }
18338
18339 local_free (i_threads);
18340
18341 // we dont need restore file anymore
18342 if (data.restore_disable == 0)
18343 {
18344 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
18345 {
18346 unlink (eff_restore_file);
18347 unlink (new_restore_file);
18348 }
18349 else
18350 {
18351 cycle_restore ();
18352 }
18353 }
18354
18355 // finally save left hashes
18356
18357 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
18358 {
18359 save_hash ();
18360 }
18361
18362 /**
18363 * Clean up
18364 */
18365
18366 if (benchmark == 1)
18367 {
18368 status_benchmark ();
18369
18370 if (machine_readable == 0)
18371 {
18372 log_info ("");
18373 }
18374 }
18375 else
18376 {
18377 if (quiet == 0) clear_prompt ();
18378
18379 if (quiet == 0) log_info ("");
18380
18381 if (status == 1)
18382 {
18383 status_display ();
18384 }
18385 else
18386 {
18387 if (quiet == 0) status_display ();
18388 }
18389
18390 if (quiet == 0) log_info ("");
18391 }
18392
18393 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18394 {
18395 hc_device_param_t *device_param = &data.devices_param[device_id];
18396
18397 if (device_param->skipped) continue;
18398
18399 local_free (device_param->combs_buf);
18400
18401 local_free (device_param->hooks_buf);
18402
18403 local_free (device_param->device_name);
18404
18405 local_free (device_param->device_name_chksum);
18406
18407 local_free (device_param->device_version);
18408
18409 local_free (device_param->driver_version);
18410
18411 if (device_param->pws_buf) myfree (device_param->pws_buf);
18412 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
18413 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
18414 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
18415 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
18416 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
18417 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
18418 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
18419 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
18420 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
18421 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
18422 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
18423 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
18424 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
18425 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
18426 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
18427 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
18428 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
18429 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
18430 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
18431 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
18432 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
18433 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
18434 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
18435 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
18436 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
18437 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
18438 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
18439 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
18440
18441 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
18442 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
18443 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
18444 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
18445 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
18446 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
18447 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
18448 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
18449 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
18450 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
18451 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
18452
18453 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
18454 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
18455 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
18456
18457 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
18458 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
18459 }
18460
18461 // reset default fan speed
18462
18463 #ifdef HAVE_HWMON
18464 if (gpu_temp_disable == 0)
18465 {
18466 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
18467 {
18468 hc_thread_mutex_lock (mux_adl);
18469
18470 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18471 {
18472 hc_device_param_t *device_param = &data.devices_param[device_id];
18473
18474 if (device_param->skipped) continue;
18475
18476 if (data.hm_device[device_id].fan_set_supported == 1)
18477 {
18478 int fanspeed = temp_retain_fanspeed_value[device_id];
18479 int fanpolicy = temp_retain_fanpolicy_value[device_id];
18480
18481 if (fanpolicy == 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, fanspeed, 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, fanspeed, fanpolicy);
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
18505 hc_thread_mutex_unlock (mux_adl);
18506 }
18507 }
18508
18509 // reset power tuning
18510
18511 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
18512 {
18513 hc_thread_mutex_lock (mux_adl);
18514
18515 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18516 {
18517 hc_device_param_t *device_param = &data.devices_param[device_id];
18518
18519 if (device_param->skipped) continue;
18520
18521 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18522 {
18523 if (data.hm_device[device_id].od_version == 6)
18524 {
18525 // check powertune capabilities first, if not available then skip device
18526
18527 int powertune_supported = 0;
18528
18529 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18530 {
18531 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18532
18533 return (-1);
18534 }
18535
18536 if (powertune_supported != 0)
18537 {
18538 // powercontrol settings
18539
18540 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18541 {
18542 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18543
18544 return (-1);
18545 }
18546
18547 // clocks
18548
18549 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18550
18551 performance_state->iNumberOfPerformanceLevels = 2;
18552
18553 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18554 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18555 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18556 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18557
18558 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18559 {
18560 log_info ("ERROR: Failed to restore ADL performance state");
18561
18562 return (-1);
18563 }
18564
18565 local_free (performance_state);
18566 }
18567 }
18568 }
18569
18570 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18571 {
18572 unsigned int limit = nvml_power_limit[device_id];
18573
18574 if (limit > 0)
18575 {
18576 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18577 }
18578 }
18579 }
18580
18581 hc_thread_mutex_unlock (mux_adl);
18582 }
18583
18584 if (gpu_temp_disable == 0)
18585 {
18586 if (data.hm_nvml)
18587 {
18588 hm_NVML_nvmlShutdown (data.hm_nvml);
18589
18590 nvml_close (data.hm_nvml);
18591
18592 data.hm_nvml = NULL;
18593 }
18594
18595 if (data.hm_nvapi)
18596 {
18597 hm_NvAPI_Unload (data.hm_nvapi);
18598
18599 nvapi_close (data.hm_nvapi);
18600
18601 data.hm_nvapi = NULL;
18602 }
18603
18604 if (data.hm_xnvctrl)
18605 {
18606 hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);
18607
18608 xnvctrl_close (data.hm_xnvctrl);
18609
18610 data.hm_xnvctrl = NULL;
18611 }
18612
18613 if (data.hm_adl)
18614 {
18615 hm_ADL_Main_Control_Destroy (data.hm_adl);
18616
18617 adl_close (data.hm_adl);
18618
18619 data.hm_adl = NULL;
18620 }
18621 }
18622 #endif // HAVE_HWMON
18623
18624 // free memory
18625
18626 local_free (masks);
18627
18628 local_free (dictstat_base);
18629
18630 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18631 {
18632 pot_t *pot_ptr = &pot[pot_pos];
18633
18634 hash_t *hash = &pot_ptr->hash;
18635
18636 local_free (hash->digest);
18637
18638 if (isSalted)
18639 {
18640 local_free (hash->salt);
18641 }
18642 }
18643
18644 local_free (pot);
18645
18646 local_free (all_kernel_rules_cnt);
18647 local_free (all_kernel_rules_buf);
18648
18649 local_free (wl_data->buf);
18650 local_free (wl_data);
18651
18652 local_free (bitmap_s1_a);
18653 local_free (bitmap_s1_b);
18654 local_free (bitmap_s1_c);
18655 local_free (bitmap_s1_d);
18656 local_free (bitmap_s2_a);
18657 local_free (bitmap_s2_b);
18658 local_free (bitmap_s2_c);
18659 local_free (bitmap_s2_d);
18660
18661 #ifdef HAVE_HWMON
18662 local_free (temp_retain_fanspeed_value);
18663 local_free (od_clock_mem_status);
18664 local_free (od_power_control_status);
18665 local_free (nvml_power_limit);
18666 #endif
18667
18668 global_free (devices_param);
18669
18670 global_free (kernel_rules_buf);
18671
18672 global_free (root_css_buf);
18673 global_free (markov_css_buf);
18674
18675 global_free (digests_buf);
18676 global_free (digests_shown);
18677 global_free (digests_shown_tmp);
18678
18679 global_free (salts_buf);
18680 global_free (salts_shown);
18681
18682 global_free (esalts_buf);
18683
18684 global_free (words_progress_done);
18685 global_free (words_progress_rejected);
18686 global_free (words_progress_restored);
18687
18688 if (pot_fp) fclose (pot_fp);
18689
18690 if (data.devices_status == STATUS_QUIT) break;
18691 }
18692
18693 // destroy others mutex
18694
18695 hc_thread_mutex_delete (mux_dispatcher);
18696 hc_thread_mutex_delete (mux_counter);
18697 hc_thread_mutex_delete (mux_display);
18698 hc_thread_mutex_delete (mux_adl);
18699
18700 // free memory
18701
18702 local_free (eff_restore_file);
18703 local_free (new_restore_file);
18704
18705 local_free (rd);
18706
18707 // tuning db
18708
18709 tuning_db_destroy (tuning_db);
18710
18711 // loopback
18712
18713 local_free (loopback_file);
18714
18715 if (loopback == 1) unlink (loopback_file);
18716
18717 // induction directory
18718
18719 if (induction_dir == NULL)
18720 {
18721 if (attack_mode != ATTACK_MODE_BF)
18722 {
18723 if (rmdir (induction_directory) == -1)
18724 {
18725 if (errno == ENOENT)
18726 {
18727 // good, we can ignore
18728 }
18729 else if (errno == ENOTEMPTY)
18730 {
18731 // good, we can ignore
18732 }
18733 else
18734 {
18735 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18736
18737 return (-1);
18738 }
18739 }
18740
18741 local_free (induction_directory);
18742 }
18743 }
18744
18745 // outfile-check directory
18746
18747 if (outfile_check_dir == NULL)
18748 {
18749 if (rmdir (outfile_check_directory) == -1)
18750 {
18751 if (errno == ENOENT)
18752 {
18753 // good, we can ignore
18754 }
18755 else if (errno == ENOTEMPTY)
18756 {
18757 // good, we can ignore
18758 }
18759 else
18760 {
18761 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18762
18763 return (-1);
18764 }
18765 }
18766
18767 local_free (outfile_check_directory);
18768 }
18769
18770 time_t proc_stop;
18771
18772 time (&proc_stop);
18773
18774 logfile_top_uint (proc_start);
18775 logfile_top_uint (proc_stop);
18776
18777 logfile_top_msg ("STOP");
18778
18779 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18780 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18781
18782 if (data.ocl) ocl_close (data.ocl);
18783
18784 if (data.devices_status == STATUS_ABORTED) return 2;
18785 if (data.devices_status == STATUS_QUIT) return 2;
18786 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18787 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18788 if (data.devices_status == STATUS_CRACKED) return 0;
18789
18790 return -1;
18791 }
Hashcat additions to support pwdhash