projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Added support for XNVCTRL on Linux to add support for --gpu-temp-retain for NVidia GPU
[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 0
82 #define WORKLOAD_PROFILE 2
83 #define KERNEL_ACCEL 0
84 #define KERNEL_LOOPS 0
85 #define KERNEL_RULES 1024
86 #define KERNEL_COMBS 1024
87 #define KERNEL_BFS 1024
88 #define KERNEL_THREADS_MAX 256
89 #define KERNEL_THREADS_MAX_CPU 16
90 #define POWERTUNE_ENABLE 0
91 #define LOGFILE_DISABLE 0
92 #define SCRYPT_TMTO 0
93 #define OPENCL_VECTOR_WIDTH 0
94
95 #define WL_MODE_STDIN 1
96 #define WL_MODE_FILE 2
97 #define WL_MODE_MASK 3
98
99 #define HL_MODE_FILE 4
100 #define HL_MODE_ARG 5
101
102 #define HLFMTS_CNT 11
103 #define HLFMT_HASHCAT 0
104 #define HLFMT_PWDUMP 1
105 #define HLFMT_PASSWD 2
106 #define HLFMT_SHADOW 3
107 #define HLFMT_DCC 4
108 #define HLFMT_DCC2 5
109 #define HLFMT_NETNTLM1 7
110 #define HLFMT_NETNTLM2 8
111 #define HLFMT_NSLDAP 9
112 #define HLFMT_NSLDAPS 10
113
114 #define HLFMT_TEXT_HASHCAT "native hashcat"
115 #define HLFMT_TEXT_PWDUMP "pwdump"
116 #define HLFMT_TEXT_PASSWD "passwd"
117 #define HLFMT_TEXT_SHADOW "shadow"
118 #define HLFMT_TEXT_DCC "DCC"
119 #define HLFMT_TEXT_DCC2 "DCC 2"
120 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
121 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
122 #define HLFMT_TEXT_NSLDAP "nsldap"
123 #define HLFMT_TEXT_NSLDAPS "nsldaps"
124
125 #define ATTACK_MODE_STRAIGHT 0
126 #define ATTACK_MODE_COMBI 1
127 #define ATTACK_MODE_TOGGLE 2
128 #define ATTACK_MODE_BF 3
129 #define ATTACK_MODE_PERM 4
130 #define ATTACK_MODE_TABLE 5
131 #define ATTACK_MODE_HYBRID1 6
132 #define ATTACK_MODE_HYBRID2 7
133 #define ATTACK_MODE_NONE 100
134
135 #define ATTACK_KERN_STRAIGHT 0
136 #define ATTACK_KERN_COMBI 1
137 #define ATTACK_KERN_BF 3
138 #define ATTACK_KERN_NONE 100
139
140 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
141 #define ATTACK_EXEC_INSIDE_KERNEL 11
142
143 #define COMBINATOR_MODE_BASE_LEFT 10001
144 #define COMBINATOR_MODE_BASE_RIGHT 10002
145
146 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
147 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
148
149 #define MAX_CUT_TRIES 4
150
151 #define MAX_DICTSTAT 10000
152
153 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
154
155 #define NVIDIA_100PERCENTCPU_WORKAROUND 100
156
157 #define global_free(attr) \
158 { \
159 myfree ((void *) data.attr); \
160 \
161 data.attr = NULL; \
162 }
163
164 #define local_free(attr) \
165 { \
166 myfree ((void *) attr); \
167 \
168 attr = NULL; \
169 }
170
171 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
172 #define HC_API_CALL __stdcall
173 #else
174 #define HC_API_CALL
175 #endif
176
177 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
178 {
179 900,
180 0,
181 5100,
182 100,
183 1400,
184 10800,
185 1700,
186 5000,
187 10100,
188 6000,
189 6100,
190 6900,
191 11700,
192 11800,
193 400,
194 8900,
195 11900,
196 12000,
197 10900,
198 12100,
199 23,
200 2500,
201 5300,
202 5400,
203 5500,
204 5600,
205 7300,
206 7500,
207 13100,
208 8300,
209 11100,
210 11200,
211 11400,
212 121,
213 2611,
214 2711,
215 2811,
216 8400,
217 11,
218 2612,
219 7900,
220 21,
221 11000,
222 124,
223 10000,
224 3711,
225 7600,
226 12,
227 131,
228 132,
229 1731,
230 200,
231 300,
232 3100,
233 112,
234 12300,
235 8000,
236 141,
237 1441,
238 1600,
239 12600,
240 1421,
241 101,
242 111,
243 1711,
244 3000,
245 1000,
246 1100,
247 2100,
248 12800,
249 1500,
250 12400,
251 500,
252 3200,
253 7400,
254 1800,
255 122,
256 1722,
257 7100,
258 6300,
259 6700,
260 6400,
261 6500,
262 2400,
263 2410,
264 5700,
265 9200,
266 9300,
267 22,
268 501,
269 5800,
270 8100,
271 8500,
272 7200,
273 9900,
274 7700,
275 7800,
276 10300,
277 8600,
278 8700,
279 9100,
280 133,
281 13500,
282 11600,
283 13600,
284 12500,
285 13000,
286 13200,
287 13300,
288 6211,
289 6221,
290 6231,
291 6241,
292 13711,
293 13721,
294 13731,
295 13741,
296 13751,
297 13761,
298 8800,
299 12900,
300 12200,
301 9700,
302 9710,
303 9800,
304 9810,
305 9400,
306 9500,
307 9600,
308 10400,
309 10410,
310 10500,
311 10600,
312 10700,
313 9000,
314 5200,
315 6800,
316 6600,
317 8200,
318 11300,
319 12700,
320 13400,
321 125
322 };
323
324 /**
325 * types
326 */
327
328 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
329
330 /**
331 * globals
332 */
333
334 static unsigned int full01 = 0x01010101;
335 static unsigned int full80 = 0x80808080;
336
337 int SUPPRESS_OUTPUT = 0;
338
339 hc_thread_mutex_t mux_adl;
340 hc_thread_mutex_t mux_counter;
341 hc_thread_mutex_t mux_dispatcher;
342 hc_thread_mutex_t mux_display;
343
344 hc_global_data_t data;
345
346 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
347
348 const char *USAGE_MINI[] =
349 {
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "Try --help for more help.",
353 NULL
354 };
355
356 const char *USAGE_BIG[] =
357 {
358 "%s, advanced password recovery",
359 "",
360 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
361 "",
362 "- [ Options ] -",
363 "",
364 " Options Short / Long | Type | Description | Example",
365 "===============================|======|======================================================|=======================",
366 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
367 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
368 " -V, --version | | Print version |",
369 " -h, --help | | Print help |",
370 " --quiet | | Suppress output |",
371 " --hex-charset | | Assume charset is given in hex |",
372 " --hex-salt | | Assume salt is given in hex |",
373 " --hex-wordlist | | Assume words in wordlist is given in hex |",
374 " --force | | Ignore warnings |",
375 " --status | | Enable automatic update of the status-screen |",
376 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
377 " --machine-readable | | Display the status view in a machine readable format |",
378 " --loopback | | Add new plains to induct directory |",
379 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
380 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
381 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
382 " --markov-classic | | Enables classic markov-chains, no per-position |",
383 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
384 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
385 " --session | Str | Define specific session name | --session=mysession",
386 " --restore | | Restore session from --session |",
387 " --restore-disable | | Do not write restore file |",
388 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
389 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
390 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
391 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
392 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
393 " --stdout | | Do not crack a hash, instead print candidates only |",
394 " --show | | Show cracked passwords only |",
395 " --left | | Show un-cracked passwords only |",
396 " --username | | Enable ignoring of usernames in hashfile |",
397 " --remove | | Enable remove of hash once it is cracked |",
398 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
399 " --potfile-disable | | Do not write potfile |",
400 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
401 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
402 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
403 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
404 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
405 " --logfile-disable | | Disable the logfile |",
406 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
407 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
408 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
409 " -b, --benchmark | | Run benchmark |",
410 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
411 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
412 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
413 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
414 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
415 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
416 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=1",
417 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
418 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
419 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
420 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
421 " --nvidia-spin-damp | Num | Workaround NVidias CPU burning loop bug, in percent | --nvidia-spin-damp=50",
422 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
423 #ifdef HAVE_HWMON
424 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
425 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
426 " --powertune-enable | | Enable power tuning, restores settings when finished |",
427 #endif
428 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
429 " -s, --skip | Num | Skip X words from the start | -s 1000000",
430 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
431 " --keyspace | | Show keyspace base:mod values and quit |",
432 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
433 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
434 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
435 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
436 " --generate-rules-func-min | Num | Force min X funcs per rule |",
437 " --generate-rules-func-max | Num | Force max X funcs per rule |",
438 " --generate-rules-seed | Num | Force RNG seed set to X |",
439 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
440 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
441 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
442 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
443 " -i, --increment | | Enable mask increment mode |",
444 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
445 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
446 "",
447 "- [ Hash modes ] -",
448 "",
449 " # | Name | Category",
450 " ======+==================================================+======================================",
451 " 900 | MD4 | Raw Hash",
452 " 0 | MD5 | Raw Hash",
453 " 5100 | Half MD5 | Raw Hash",
454 " 100 | SHA1 | Raw Hash",
455 " 10800 | SHA-384 | Raw Hash",
456 " 1400 | SHA-256 | Raw Hash",
457 " 1700 | SHA-512 | Raw Hash",
458 " 5000 | SHA-3(Keccak) | Raw Hash",
459 " 10100 | SipHash | Raw Hash",
460 " 6000 | RipeMD160 | Raw Hash",
461 " 6100 | Whirlpool | Raw Hash",
462 " 6900 | GOST R 34.11-94 | Raw Hash",
463 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
464 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
465 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
466 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
467 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
468 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
469 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
470 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
471 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
472 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
473 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
474 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
475 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
476 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
477 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
478 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
479 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
480 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
481 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
482 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
483 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
484 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
485 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
486 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
487 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
488 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
489 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
490 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
491 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
492 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
493 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
494 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
495 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
496 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
497 " 400 | phpass | Generic KDF",
498 " 8900 | scrypt | Generic KDF",
499 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
500 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
501 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
502 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
503 " 23 | Skype | Network protocols",
504 " 2500 | WPA/WPA2 | Network protocols",
505 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
506 " 5300 | IKE-PSK MD5 | Network protocols",
507 " 5400 | IKE-PSK SHA1 | Network protocols",
508 " 5500 | NetNTLMv1 | Network protocols",
509 " 5500 | NetNTLMv1 + ESS | Network protocols",
510 " 5600 | NetNTLMv2 | Network protocols",
511 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
512 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
513 " 8300 | DNSSEC (NSEC3) | Network protocols",
514 " 10200 | Cram MD5 | Network protocols",
515 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
516 " 11200 | MySQL CRAM (SHA1) | Network protocols",
517 " 11400 | SIP digest authentication (MD5) | Network protocols",
518 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
519 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
520 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
521 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
522 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
523 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
524 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
525 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
526 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
527 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
528 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
529 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
530 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
531 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
532 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
533 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
534 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
535 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
536 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
537 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
538 " 12 | PostgreSQL | Database Server",
539 " 131 | MSSQL(2000) | Database Server",
540 " 132 | MSSQL(2005) | Database Server",
541 " 1731 | MSSQL(2012) | Database Server",
542 " 1731 | MSSQL(2014) | Database Server",
543 " 200 | MySQL323 | Database Server",
544 " 300 | MySQL4.1/MySQL5 | Database Server",
545 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
546 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
547 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
548 " 8000 | Sybase ASE | Database Server",
549 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
550 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
551 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
552 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
553 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
554 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
555 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
556 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
557 " 11500 | CRC32 | Checksums",
558 " 3000 | LM | Operating-Systems",
559 " 1000 | NTLM | Operating-Systems",
560 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
561 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
562 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
563 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
564 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
565 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
566 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
567 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
568 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
569 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
570 " 1722 | OSX v10.7 | Operating-Systems",
571 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
572 " 6300 | AIX {smd5} | Operating-Systems",
573 " 6700 | AIX {ssha1} | Operating-Systems",
574 " 6400 | AIX {ssha256} | Operating-Systems",
575 " 6500 | AIX {ssha512} | Operating-Systems",
576 " 2400 | Cisco-PIX | Operating-Systems",
577 " 2410 | Cisco-ASA | Operating-Systems",
578 " 500 | Cisco-IOS $1$ | Operating-Systems",
579 " 5700 | Cisco-IOS $4$ | Operating-Systems",
580 " 9200 | Cisco-IOS $8$ | Operating-Systems",
581 " 9300 | Cisco-IOS $9$ | Operating-Systems",
582 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
583 " 501 | Juniper IVE | Operating-Systems",
584 " 5800 | Android PIN | Operating-Systems",
585 " 13800 | Windows 8+ phone PIN/Password | Operating-Systems",
586 " 8100 | Citrix Netscaler | Operating-Systems",
587 " 8500 | RACF | Operating-Systems",
588 " 7200 | GRUB 2 | Operating-Systems",
589 " 9900 | Radmin2 | Operating-Systems",
590 " 125 | ArubaOS | Operating-Systems",
591 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
592 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
593 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
594 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
595 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
596 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
597 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
598 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
599 " 11600 | 7-Zip | Archives",
600 " 12500 | RAR3-hp | Archives",
601 " 13000 | RAR5 | Archives",
602 " 13200 | AxCrypt | Archives",
603 " 13300 | AxCrypt in memory SHA1 | Archives",
604 " 13600 | WinZip | Archives",
605 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
606 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
607 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
608 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
609 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
610 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
611 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
612 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
613 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
614 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
615 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
616 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
617 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
618 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
619 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
620 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
621 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
622 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
623 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
624 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
625 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
626 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
627 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
628 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
629 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
630 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
631 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
632 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
633 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
634 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
635 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
636 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
637 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
638 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
639 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
640 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
641 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
642 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
643 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
644 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
645 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
646 " 9400 | MS Office 2007 | Documents",
647 " 9500 | MS Office 2010 | Documents",
648 " 9600 | MS Office 2013 | Documents",
649 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
650 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
651 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
652 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
653 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
654 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
655 " 9000 | Password Safe v2 | Password Managers",
656 " 5200 | Password Safe v3 | Password Managers",
657 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
658 " 6600 | 1Password, agilekeychain | Password Managers",
659 " 8200 | 1Password, cloudkeychain | Password Managers",
660 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
661 " 12700 | Blockchain, My Wallet | Password Managers",
662 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
663 "",
664 "- [ Outfile Formats ] -",
665 "",
666 " # | Format",
667 " ===+========",
668 " 1 | hash[:salt]",
669 " 2 | plain",
670 " 3 | hash[:salt]:plain",
671 " 4 | hex_plain",
672 " 5 | hash[:salt]:hex_plain",
673 " 6 | plain:hex_plain",
674 " 7 | hash[:salt]:plain:hex_plain",
675 " 8 | crackpos",
676 " 9 | hash[:salt]:crack_pos",
677 " 10 | plain:crack_pos",
678 " 11 | hash[:salt]:plain:crack_pos",
679 " 12 | hex_plain:crack_pos",
680 " 13 | hash[:salt]:hex_plain:crack_pos",
681 " 14 | plain:hex_plain:crack_pos",
682 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
683 "",
684 "- [ Rule Debugging Modes ] -",
685 "",
686 " # | Format",
687 " ===+========",
688 " 1 | Finding-Rule",
689 " 2 | Original-Word",
690 " 3 | Original-Word:Finding-Rule",
691 " 4 | Original-Word:Finding-Rule:Processed-Word",
692 "",
693 "- [ Attack Modes ] -",
694 "",
695 " # | Mode",
696 " ===+======",
697 " 0 | Straight",
698 " 1 | Combination",
699 " 3 | Brute-force",
700 " 6 | Hybrid Wordlist + Mask",
701 " 7 | Hybrid Mask + Wordlist",
702 "",
703 "- [ Built-in Charsets ] -",
704 "",
705 " ? | Charset",
706 " ===+=========",
707 " l | abcdefghijklmnopqrstuvwxyz",
708 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
709 " d | 0123456789",
710 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
711 " a | ?l?u?d?s",
712 " b | 0x00 - 0xff",
713 "",
714 "- [ OpenCL Device Types ] -",
715 "",
716 " # | Device Type",
717 " ===+=============",
718 " 1 | CPU",
719 " 2 | GPU",
720 " 3 | FPGA, DSP, Co-Processor",
721 "",
722 "- [ Workload Profiles ] -",
723 "",
724 " # | Performance | Runtime | Power Consumption | Desktop Impact",
725 " ===+=============+=========+===================+=================",
726 " 1 | Low | 2 ms | Low | Minimal",
727 " 2 | Default | 12 ms | Economic | Noticeable",
728 " 3 | High | 96 ms | High | Unresponsive",
729 " 4 | Nightmare | 480 ms | Insane | Headless",
730 "",
731 "If you have no idea what just happened then visit the following pages:",
732 "",
733 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
734 "* https://hashcat.net/wiki/#frequently_asked_questions",
735 "",
736 NULL
737 };
738
739 /**
740 * hashcat specific functions
741 */
742
743 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
744 {
745 int exec_pos = (int) device_param->exec_pos - last_num_entries;
746
747 if (exec_pos < 0) exec_pos += EXEC_CACHE;
748
749 double exec_ms_sum = 0;
750
751 int exec_ms_cnt = 0;
752
753 for (int i = 0; i < last_num_entries; i++)
754 {
755 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
756
757 if (exec_ms)
758 {
759 exec_ms_sum += exec_ms;
760
761 exec_ms_cnt++;
762 }
763 }
764
765 if (exec_ms_cnt == 0) return 0;
766
767 return exec_ms_sum / exec_ms_cnt;
768 }
769
770 void status_display_machine_readable ()
771 {
772 FILE *out = stdout;
773
774 fprintf (out, "STATUS\t%u\t", data.devices_status);
775
776 /**
777 * speed new
778 */
779
780 fprintf (out, "SPEED\t");
781
782 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
783 {
784 hc_device_param_t *device_param = &data.devices_param[device_id];
785
786 if (device_param->skipped) continue;
787
788 u64 speed_cnt = 0;
789 double speed_ms = 0;
790
791 for (int i = 0; i < SPEED_CACHE; i++)
792 {
793 speed_cnt += device_param->speed_cnt[i];
794 speed_ms += device_param->speed_ms[i];
795 }
796
797 speed_cnt /= SPEED_CACHE;
798 speed_ms /= SPEED_CACHE;
799
800 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
801 }
802
803 /**
804 * exec time
805 */
806
807 fprintf (out, "EXEC_RUNTIME\t");
808
809 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
810 {
811 hc_device_param_t *device_param = &data.devices_param[device_id];
812
813 if (device_param->skipped) continue;
814
815 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
816
817 fprintf (out, "%f\t", exec_ms_avg);
818 }
819
820 /**
821 * words_cur
822 */
823
824 u64 words_cur = get_lowest_words_done ();
825
826 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
827
828 /**
829 * counter
830 */
831
832 u64 progress_total = data.words_cnt * data.salts_cnt;
833
834 u64 all_done = 0;
835 u64 all_rejected = 0;
836 u64 all_restored = 0;
837
838 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
839 {
840 all_done += data.words_progress_done[salt_pos];
841 all_rejected += data.words_progress_rejected[salt_pos];
842 all_restored += data.words_progress_restored[salt_pos];
843 }
844
845 u64 progress_cur = all_restored + all_done + all_rejected;
846 u64 progress_end = progress_total;
847
848 u64 progress_skip = 0;
849
850 if (data.skip)
851 {
852 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
853
854 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
855 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
856 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
857 }
858
859 if (data.limit)
860 {
861 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
862
863 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
864 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
865 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
866 }
867
868 u64 progress_cur_relative_skip = progress_cur - progress_skip;
869 u64 progress_end_relative_skip = progress_end - progress_skip;
870
871 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
872
873 /**
874 * cracks
875 */
876
877 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
878 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
879
880 /**
881 * temperature
882 */
883
884 #ifdef HAVE_HWMON
885 if (data.gpu_temp_disable == 0)
886 {
887 fprintf (out, "TEMP\t");
888
889 hc_thread_mutex_lock (mux_adl);
890
891 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
892 {
893 hc_device_param_t *device_param = &data.devices_param[device_id];
894
895 if (device_param->skipped) continue;
896
897 int temp = hm_get_temperature_with_device_id (device_id);
898
899 fprintf (out, "%d\t", temp);
900 }
901
902 hc_thread_mutex_unlock (mux_adl);
903 }
904 #endif // HAVE_HWMON
905
906 /**
907 * flush
908 */
909
910 #ifdef _WIN
911 fputc ('\r', out);
912 fputc ('\n', out);
913 #endif
914
915 #ifdef _POSIX
916 fputc ('\n', out);
917 #endif
918
919 fflush (out);
920 }
921
922 void status_display ()
923 {
924 if (data.devices_status == STATUS_INIT) return;
925 if (data.devices_status == STATUS_STARTING) return;
926 if (data.devices_status == STATUS_BYPASS) return;
927
928 if (data.machine_readable == 1)
929 {
930 status_display_machine_readable ();
931
932 return;
933 }
934
935 char tmp_buf[1000] = { 0 };
936
937 uint tmp_len = 0;
938
939 log_info ("Session.Name...: %s", data.session);
940
941 char *status_type = strstatus (data.devices_status);
942
943 uint hash_mode = data.hash_mode;
944
945 char *hash_type = strhashtype (hash_mode); // not a bug
946
947 log_info ("Status.........: %s", status_type);
948
949 /**
950 * show rules
951 */
952
953 if (data.rp_files_cnt)
954 {
955 uint i;
956
957 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
958 {
959 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
960 }
961
962 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
963
964 log_info ("Rules.Type.....: %s", tmp_buf);
965
966 tmp_len = 0;
967 }
968
969 if (data.rp_gen)
970 {
971 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
972
973 if (data.rp_gen_seed)
974 {
975 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
976 }
977 }
978
979 /**
980 * show input
981 */
982
983 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
984 {
985 if (data.wordlist_mode == WL_MODE_FILE)
986 {
987 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
988 }
989 else if (data.wordlist_mode == WL_MODE_STDIN)
990 {
991 log_info ("Input.Mode.....: Pipe");
992 }
993 }
994 else if (data.attack_mode == ATTACK_MODE_COMBI)
995 {
996 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
997 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
998 }
999 else if (data.attack_mode == ATTACK_MODE_BF)
1000 {
1001 char *mask = data.mask;
1002
1003 if (mask != NULL)
1004 {
1005 uint mask_len = data.css_cnt;
1006
1007 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1008
1009 if (mask_len > 0)
1010 {
1011 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1012 {
1013 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1014 {
1015 mask_len -= data.salts_buf[0].salt_len;
1016 }
1017 }
1018
1019 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1020
1021 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1022 }
1023
1024 if (data.maskcnt > 1)
1025 {
1026 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1027
1028 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1029 }
1030
1031 log_info ("Input.Mode.....: %s", tmp_buf);
1032 }
1033
1034 tmp_len = 0;
1035 }
1036 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1037 {
1038 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1039 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1040 }
1041 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1042 {
1043 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1044 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1045 }
1046
1047 if (data.digests_cnt == 1)
1048 {
1049 if (data.hash_mode == 2500)
1050 {
1051 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1052
1053 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1054 (char *) data.salts_buf[0].salt_buf,
1055 wpa->orig_mac1[0],
1056 wpa->orig_mac1[1],
1057 wpa->orig_mac1[2],
1058 wpa->orig_mac1[3],
1059 wpa->orig_mac1[4],
1060 wpa->orig_mac1[5],
1061 wpa->orig_mac2[0],
1062 wpa->orig_mac2[1],
1063 wpa->orig_mac2[2],
1064 wpa->orig_mac2[3],
1065 wpa->orig_mac2[4],
1066 wpa->orig_mac2[5]);
1067 }
1068 else if (data.hash_mode == 5200)
1069 {
1070 log_info ("Hash.Target....: File (%s)", data.hashfile);
1071 }
1072 else if (data.hash_mode == 9000)
1073 {
1074 log_info ("Hash.Target....: File (%s)", data.hashfile);
1075 }
1076 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1077 {
1078 log_info ("Hash.Target....: File (%s)", data.hashfile);
1079 }
1080 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1081 {
1082 log_info ("Hash.Target....: File (%s)", data.hashfile);
1083 }
1084 else
1085 {
1086 char out_buf[HCBUFSIZ] = { 0 };
1087
1088 ascii_digest (out_buf, 0, 0);
1089
1090 // limit length
1091 if (strlen (out_buf) > 40)
1092 {
1093 out_buf[41] = '.';
1094 out_buf[42] = '.';
1095 out_buf[43] = '.';
1096 out_buf[44] = 0;
1097 }
1098
1099 log_info ("Hash.Target....: %s", out_buf);
1100 }
1101 }
1102 else
1103 {
1104 if (data.hash_mode == 3000)
1105 {
1106 char out_buf1[32] = { 0 };
1107 char out_buf2[32] = { 0 };
1108
1109 ascii_digest (out_buf1, 0, 0);
1110 ascii_digest (out_buf2, 0, 1);
1111
1112 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1113 }
1114 else
1115 {
1116 log_info ("Hash.Target....: File (%s)", data.hashfile);
1117 }
1118 }
1119
1120 log_info ("Hash.Type......: %s", hash_type);
1121
1122 /**
1123 * speed new
1124 */
1125
1126 u64 speed_cnt[DEVICES_MAX] = { 0 };
1127 double speed_ms[DEVICES_MAX] = { 0 };
1128
1129 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1130 {
1131 hc_device_param_t *device_param = &data.devices_param[device_id];
1132
1133 if (device_param->skipped) continue;
1134
1135 speed_cnt[device_id] = 0;
1136 speed_ms[device_id] = 0;
1137
1138 for (int i = 0; i < SPEED_CACHE; i++)
1139 {
1140 speed_cnt[device_id] += device_param->speed_cnt[i];
1141 speed_ms[device_id] += device_param->speed_ms[i];
1142 }
1143
1144 speed_cnt[device_id] /= SPEED_CACHE;
1145 speed_ms[device_id] /= SPEED_CACHE;
1146 }
1147
1148 double hashes_all_ms = 0;
1149
1150 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1151
1152 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1153 {
1154 hc_device_param_t *device_param = &data.devices_param[device_id];
1155
1156 if (device_param->skipped) continue;
1157
1158 hashes_dev_ms[device_id] = 0;
1159
1160 if (speed_ms[device_id])
1161 {
1162 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1163
1164 hashes_all_ms += hashes_dev_ms[device_id];
1165 }
1166 }
1167
1168 /**
1169 * exec time
1170 */
1171
1172 double exec_all_ms[DEVICES_MAX] = { 0 };
1173
1174 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1175 {
1176 hc_device_param_t *device_param = &data.devices_param[device_id];
1177
1178 if (device_param->skipped) continue;
1179
1180 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1181
1182 exec_all_ms[device_id] = exec_ms_avg;
1183 }
1184
1185 /**
1186 * timers
1187 */
1188
1189 double ms_running = 0;
1190
1191 hc_timer_get (data.timer_running, ms_running);
1192
1193 double ms_paused = data.ms_paused;
1194
1195 if (data.devices_status == STATUS_PAUSED)
1196 {
1197 double ms_paused_tmp = 0;
1198
1199 hc_timer_get (data.timer_paused, ms_paused_tmp);
1200
1201 ms_paused += ms_paused_tmp;
1202 }
1203
1204 #ifdef WIN
1205
1206 __time64_t sec_run = ms_running / 1000;
1207
1208 #else
1209
1210 time_t sec_run = ms_running / 1000;
1211
1212 #endif
1213
1214 if (sec_run)
1215 {
1216 char display_run[32] = { 0 };
1217
1218 struct tm tm_run;
1219
1220 struct tm *tmp = NULL;
1221
1222 #ifdef WIN
1223
1224 tmp = _gmtime64 (&sec_run);
1225
1226 #else
1227
1228 tmp = gmtime (&sec_run);
1229
1230 #endif
1231
1232 if (tmp != NULL)
1233 {
1234 memset (&tm_run, 0, sizeof (tm_run));
1235
1236 memcpy (&tm_run, tmp, sizeof (tm_run));
1237
1238 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1239
1240 char *start = ctime (&data.proc_start);
1241
1242 size_t start_len = strlen (start);
1243
1244 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1245 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1246
1247 log_info ("Time.Started...: %s (%s)", start, display_run);
1248 }
1249 }
1250 else
1251 {
1252 log_info ("Time.Started...: 0 secs");
1253 }
1254
1255 /**
1256 * counters
1257 */
1258
1259 u64 progress_total = data.words_cnt * data.salts_cnt;
1260
1261 u64 all_done = 0;
1262 u64 all_rejected = 0;
1263 u64 all_restored = 0;
1264
1265 u64 progress_noneed = 0;
1266
1267 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1268 {
1269 all_done += data.words_progress_done[salt_pos];
1270 all_rejected += data.words_progress_rejected[salt_pos];
1271 all_restored += data.words_progress_restored[salt_pos];
1272
1273 // Important for ETA only
1274
1275 if (data.salts_shown[salt_pos] == 1)
1276 {
1277 const u64 all = data.words_progress_done[salt_pos]
1278 + data.words_progress_rejected[salt_pos]
1279 + data.words_progress_restored[salt_pos];
1280
1281 const u64 left = data.words_cnt - all;
1282
1283 progress_noneed += left;
1284 }
1285 }
1286
1287 u64 progress_cur = all_restored + all_done + all_rejected;
1288 u64 progress_end = progress_total;
1289
1290 u64 progress_skip = 0;
1291
1292 if (data.skip)
1293 {
1294 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1295
1296 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1297 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1298 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1299 }
1300
1301 if (data.limit)
1302 {
1303 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1304
1305 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1306 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1307 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1308 }
1309
1310 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1311 u64 progress_end_relative_skip = progress_end - progress_skip;
1312
1313 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1314 {
1315 if (data.devices_status != STATUS_CRACKED)
1316 {
1317 #ifdef WIN
1318 __time64_t sec_etc = 0;
1319 #else
1320 time_t sec_etc = 0;
1321 #endif
1322
1323 if (hashes_all_ms)
1324 {
1325 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1326
1327 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1328
1329 sec_etc = ms_left / 1000;
1330 }
1331
1332 if (sec_etc == 0)
1333 {
1334 //log_info ("Time.Estimated.: 0 secs");
1335 }
1336 else if ((u64) sec_etc > ETC_MAX)
1337 {
1338 log_info ("Time.Estimated.: > 10 Years");
1339 }
1340 else
1341 {
1342 char display_etc[32] = { 0 };
1343
1344 struct tm tm_etc;
1345
1346 struct tm *tmp = NULL;
1347
1348 #ifdef WIN
1349
1350 tmp = _gmtime64 (&sec_etc);
1351
1352 #else
1353
1354 tmp = gmtime (&sec_etc);
1355
1356 #endif
1357
1358 if (tmp != NULL)
1359 {
1360 memset (&tm_etc, 0, sizeof (tm_etc));
1361
1362 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1363
1364 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1365
1366 time_t now;
1367
1368 time (&now);
1369
1370 now += sec_etc;
1371
1372 char *etc = ctime (&now);
1373
1374 size_t etc_len = strlen (etc);
1375
1376 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1377 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1378
1379 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1380 }
1381 }
1382 }
1383 }
1384
1385 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1386 {
1387 hc_device_param_t *device_param = &data.devices_param[device_id];
1388
1389 if (device_param->skipped) continue;
1390
1391 char display_dev_cur[16] = { 0 };
1392
1393 strncpy (display_dev_cur, "0.00", 4);
1394
1395 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1396
1397 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1398 }
1399
1400 char display_all_cur[16] = { 0 };
1401
1402 strncpy (display_all_cur, "0.00", 4);
1403
1404 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1405
1406 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1407
1408 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1409 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1410
1411 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1412
1413 // crack-per-time
1414
1415 if (data.digests_cnt > 100)
1416 {
1417 time_t now = time (NULL);
1418
1419 int cpt_cur_min = 0;
1420 int cpt_cur_hour = 0;
1421 int cpt_cur_day = 0;
1422
1423 for (int i = 0; i < CPT_BUF; i++)
1424 {
1425 const uint cracked = data.cpt_buf[i].cracked;
1426 const time_t timestamp = data.cpt_buf[i].timestamp;
1427
1428 if ((timestamp + 60) > now)
1429 {
1430 cpt_cur_min += cracked;
1431 }
1432
1433 if ((timestamp + 3600) > now)
1434 {
1435 cpt_cur_hour += cracked;
1436 }
1437
1438 if ((timestamp + 86400) > now)
1439 {
1440 cpt_cur_day += cracked;
1441 }
1442 }
1443
1444 double ms_real = ms_running - ms_paused;
1445
1446 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1447 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1448 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1449
1450 if ((data.cpt_start + 86400) < now)
1451 {
1452 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1453 cpt_cur_min,
1454 cpt_cur_hour,
1455 cpt_cur_day,
1456 cpt_avg_min,
1457 cpt_avg_hour,
1458 cpt_avg_day);
1459 }
1460 else if ((data.cpt_start + 3600) < now)
1461 {
1462 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1463 cpt_cur_min,
1464 cpt_cur_hour,
1465 cpt_avg_min,
1466 cpt_avg_hour,
1467 cpt_avg_day);
1468 }
1469 else if ((data.cpt_start + 60) < now)
1470 {
1471 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1472 cpt_cur_min,
1473 cpt_avg_min,
1474 cpt_avg_hour,
1475 cpt_avg_day);
1476 }
1477 else
1478 {
1479 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1480 cpt_avg_min,
1481 cpt_avg_hour,
1482 cpt_avg_day);
1483 }
1484 }
1485
1486 // Restore point
1487
1488 u64 restore_point = get_lowest_words_done ();
1489
1490 u64 restore_total = data.words_base;
1491
1492 float percent_restore = 0;
1493
1494 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1495
1496 if (progress_end_relative_skip)
1497 {
1498 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1499 {
1500 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1501 float percent_rejected = 0.0;
1502
1503 if (progress_cur)
1504 {
1505 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1506 }
1507
1508 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1509 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1510
1511 if (data.restore_disable == 0)
1512 {
1513 if (percent_finished != 1)
1514 {
1515 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1516 }
1517 }
1518 }
1519 }
1520 else
1521 {
1522 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1523 {
1524 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1525 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1526
1527 if (data.restore_disable == 0)
1528 {
1529 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1530 }
1531 }
1532 else
1533 {
1534 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1535 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1536
1537 // --restore not allowed if stdin is used -- really? why?
1538
1539 //if (data.restore_disable == 0)
1540 //{
1541 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1542 //}
1543 }
1544 }
1545
1546 #ifdef HAVE_HWMON
1547
1548 if (data.devices_status == STATUS_EXHAUSTED) return;
1549 if (data.devices_status == STATUS_CRACKED) return;
1550 if (data.devices_status == STATUS_ABORTED) return;
1551 if (data.devices_status == STATUS_QUIT) return;
1552
1553 if (data.gpu_temp_disable == 0)
1554 {
1555 hc_thread_mutex_lock (mux_adl);
1556
1557 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1558 {
1559 hc_device_param_t *device_param = &data.devices_param[device_id];
1560
1561 if (device_param->skipped) continue;
1562
1563 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1564 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1565 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1566 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1567 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1568 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1569 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1570
1571 char output_buf[256] = { 0 };
1572
1573 int output_len = 0;
1574
1575 if (num_temperature >= 0)
1576 {
1577 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1578
1579 output_len = strlen (output_buf);
1580 }
1581
1582 if (num_fanspeed >= 0)
1583 {
1584 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1585
1586 output_len = strlen (output_buf);
1587 }
1588
1589 if (num_utilization >= 0)
1590 {
1591 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1592
1593 output_len = strlen (output_buf);
1594 }
1595
1596 if (num_corespeed >= 0)
1597 {
1598 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1599
1600 output_len = strlen (output_buf);
1601 }
1602
1603 if (num_memoryspeed >= 0)
1604 {
1605 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1606
1607 output_len = strlen (output_buf);
1608 }
1609
1610 if (num_buslanes >= 0)
1611 {
1612 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1613
1614 output_len = strlen (output_buf);
1615 }
1616
1617 if (num_throttle == 1)
1618 {
1619 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1620
1621 output_len = strlen (output_buf);
1622 }
1623
1624 if (output_len == 0)
1625 {
1626 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1627
1628 output_len = strlen (output_buf);
1629 }
1630
1631 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1632 }
1633
1634 hc_thread_mutex_unlock (mux_adl);
1635 }
1636
1637 #endif // HAVE_HWMON
1638 }
1639
1640 static void status_benchmark_automate ()
1641 {
1642 u64 speed_cnt[DEVICES_MAX] = { 0 };
1643 double speed_ms[DEVICES_MAX] = { 0 };
1644
1645 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1646 {
1647 hc_device_param_t *device_param = &data.devices_param[device_id];
1648
1649 if (device_param->skipped) continue;
1650
1651 speed_cnt[device_id] = device_param->speed_cnt[0];
1652 speed_ms[device_id] = device_param->speed_ms[0];
1653 }
1654
1655 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1656
1657 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1658 {
1659 hc_device_param_t *device_param = &data.devices_param[device_id];
1660
1661 if (device_param->skipped) continue;
1662
1663 hashes_dev_ms[device_id] = 0;
1664
1665 if (speed_ms[device_id])
1666 {
1667 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1668 }
1669 }
1670
1671 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1672 {
1673 hc_device_param_t *device_param = &data.devices_param[device_id];
1674
1675 if (device_param->skipped) continue;
1676
1677 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1678 }
1679 }
1680
1681 static void status_benchmark ()
1682 {
1683 if (data.devices_status == STATUS_INIT) return;
1684 if (data.devices_status == STATUS_STARTING) return;
1685 if (data.devices_status == STATUS_BYPASS) return;
1686
1687 if (data.machine_readable == 1)
1688 {
1689 status_benchmark_automate ();
1690
1691 return;
1692 }
1693
1694 u64 speed_cnt[DEVICES_MAX] = { 0 };
1695 double speed_ms[DEVICES_MAX] = { 0 };
1696
1697 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1698 {
1699 hc_device_param_t *device_param = &data.devices_param[device_id];
1700
1701 if (device_param->skipped) continue;
1702
1703 speed_cnt[device_id] = device_param->speed_cnt[0];
1704 speed_ms[device_id] = device_param->speed_ms[0];
1705 }
1706
1707 double hashes_all_ms = 0;
1708
1709 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1710
1711 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1712 {
1713 hc_device_param_t *device_param = &data.devices_param[device_id];
1714
1715 if (device_param->skipped) continue;
1716
1717 hashes_dev_ms[device_id] = 0;
1718
1719 if (speed_ms[device_id])
1720 {
1721 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1722
1723 hashes_all_ms += hashes_dev_ms[device_id];
1724 }
1725 }
1726
1727 /**
1728 * exec time
1729 */
1730
1731 double exec_all_ms[DEVICES_MAX] = { 0 };
1732
1733 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1734 {
1735 hc_device_param_t *device_param = &data.devices_param[device_id];
1736
1737 if (device_param->skipped) continue;
1738
1739 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1740
1741 exec_all_ms[device_id] = exec_ms_avg;
1742 }
1743
1744 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1745 {
1746 hc_device_param_t *device_param = &data.devices_param[device_id];
1747
1748 if (device_param->skipped) continue;
1749
1750 char display_dev_cur[16] = { 0 };
1751
1752 strncpy (display_dev_cur, "0.00", 4);
1753
1754 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1755
1756 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1757 }
1758
1759 char display_all_cur[16] = { 0 };
1760
1761 strncpy (display_all_cur, "0.00", 4);
1762
1763 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1764
1765 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1766 }
1767
1768 /**
1769 * hashcat -only- functions
1770 */
1771
1772 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1773 {
1774 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1775 {
1776 if (attack_kern == ATTACK_KERN_STRAIGHT)
1777 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1778 else if (attack_kern == ATTACK_KERN_COMBI)
1779 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1780 else if (attack_kern == ATTACK_KERN_BF)
1781 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1782 }
1783 else
1784 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1785 }
1786
1787 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1788 {
1789 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1790 {
1791 if (attack_kern == ATTACK_KERN_STRAIGHT)
1792 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1793 else if (attack_kern == ATTACK_KERN_COMBI)
1794 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1795 else if (attack_kern == ATTACK_KERN_BF)
1796 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1797 }
1798 else
1799 {
1800 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1801 }
1802 }
1803
1804 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1805 {
1806 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1807 {
1808 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1809 }
1810 else
1811 {
1812 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1813 }
1814 }
1815
1816 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1817 {
1818 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1819 {
1820 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1821 }
1822 else
1823 {
1824 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1825 }
1826 }
1827
1828 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1829 {
1830 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1831 }
1832
1833 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1834 {
1835 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1836 }
1837
1838 static uint convert_from_hex (char *line_buf, const uint line_len)
1839 {
1840 if (line_len & 1) return (line_len); // not in hex
1841
1842 if (data.hex_wordlist == 1)
1843 {
1844 uint i;
1845 uint j;
1846
1847 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1848 {
1849 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1850 }
1851
1852 memset (line_buf + i, 0, line_len - i);
1853
1854 return (i);
1855 }
1856 else if (line_len >= 6) // $HEX[] = 6
1857 {
1858 if (line_buf[0] != '$') return (line_len);
1859 if (line_buf[1] != 'H') return (line_len);
1860 if (line_buf[2] != 'E') return (line_len);
1861 if (line_buf[3] != 'X') return (line_len);
1862 if (line_buf[4] != '[') return (line_len);
1863 if (line_buf[line_len - 1] != ']') return (line_len);
1864
1865 uint i;
1866 uint j;
1867
1868 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1869 {
1870 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1871 }
1872
1873 memset (line_buf + i, 0, line_len - i);
1874
1875 return (i);
1876 }
1877
1878 return (line_len);
1879 }
1880
1881 static void clear_prompt ()
1882 {
1883 fputc ('\r', stdout);
1884
1885 for (size_t i = 0; i < strlen (PROMPT); i++)
1886 {
1887 fputc (' ', stdout);
1888 }
1889
1890 fputc ('\r', stdout);
1891
1892 fflush (stdout);
1893 }
1894
1895 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1896 {
1897 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);
1898 }
1899
1900 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1901 {
1902 char *outfile = data.outfile;
1903 uint quiet = data.quiet;
1904 FILE *pot_fp = data.pot_fp;
1905 uint loopback = data.loopback;
1906 uint debug_mode = data.debug_mode;
1907 char *debug_file = data.debug_file;
1908
1909 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1910 int debug_rule_len = 0; // -1 error
1911 uint debug_plain_len = 0;
1912
1913 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1914
1915 // hash
1916
1917 char out_buf[HCBUFSIZ] = { 0 };
1918
1919 const u32 salt_pos = plain->salt_pos;
1920 const u32 digest_pos = plain->digest_pos; // relative
1921 const u32 gidvid = plain->gidvid;
1922 const u32 il_pos = plain->il_pos;
1923
1924 ascii_digest (out_buf, salt_pos, digest_pos);
1925
1926 // plain
1927
1928 u64 crackpos = device_param->words_off;
1929
1930 uint plain_buf[16] = { 0 };
1931
1932 u8 *plain_ptr = (u8 *) plain_buf;
1933
1934 unsigned int plain_len = 0;
1935
1936 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1937 {
1938 pw_t pw;
1939
1940 gidd_to_pw_t (device_param, gidvid, &pw);
1941
1942 for (int i = 0; i < 16; i++)
1943 {
1944 plain_buf[i] = pw.i[i];
1945 }
1946
1947 plain_len = pw.pw_len;
1948
1949 const uint off = device_param->innerloop_pos + il_pos;
1950
1951 if (debug_mode > 0)
1952 {
1953 debug_rule_len = 0;
1954
1955 // save rule
1956 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1957 {
1958 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1959
1960 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1961 }
1962
1963 // save plain
1964 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1965 {
1966 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1967
1968 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1969
1970 debug_plain_len = plain_len;
1971 }
1972 }
1973
1974 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1975
1976 crackpos += gidvid;
1977 crackpos *= data.kernel_rules_cnt;
1978 crackpos += device_param->innerloop_pos + il_pos;
1979
1980 if (plain_len > data.pw_max) plain_len = data.pw_max;
1981 }
1982 else if (data.attack_mode == ATTACK_MODE_COMBI)
1983 {
1984 pw_t pw;
1985
1986 gidd_to_pw_t (device_param, gidvid, &pw);
1987
1988 for (int i = 0; i < 16; i++)
1989 {
1990 plain_buf[i] = pw.i[i];
1991 }
1992
1993 plain_len = pw.pw_len;
1994
1995 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1996 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1997
1998 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1999 {
2000 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2001 }
2002 else
2003 {
2004 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2005
2006 memcpy (plain_ptr, comb_buf, comb_len);
2007 }
2008
2009 plain_len += comb_len;
2010
2011 crackpos += gidvid;
2012 crackpos *= data.combs_cnt;
2013 crackpos += device_param->innerloop_pos + il_pos;
2014
2015 if (data.pw_max != PW_DICTMAX1)
2016 {
2017 if (plain_len > data.pw_max) plain_len = data.pw_max;
2018 }
2019 }
2020 else if (data.attack_mode == ATTACK_MODE_BF)
2021 {
2022 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2023 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2024
2025 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2026 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2027
2028 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2029 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2030
2031 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2032 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2033
2034 plain_len = data.css_cnt;
2035
2036 crackpos += gidvid;
2037 crackpos *= data.bfs_cnt;
2038 crackpos += device_param->innerloop_pos + il_pos;
2039 }
2040 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2041 {
2042 pw_t pw;
2043
2044 gidd_to_pw_t (device_param, gidvid, &pw);
2045
2046 for (int i = 0; i < 16; i++)
2047 {
2048 plain_buf[i] = pw.i[i];
2049 }
2050
2051 plain_len = pw.pw_len;
2052
2053 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2054
2055 uint start = 0;
2056 uint stop = device_param->kernel_params_mp_buf32[4];
2057
2058 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2059
2060 plain_len += start + stop;
2061
2062 crackpos += gidvid;
2063 crackpos *= data.combs_cnt;
2064 crackpos += device_param->innerloop_pos + il_pos;
2065
2066 if (data.pw_max != PW_DICTMAX1)
2067 {
2068 if (plain_len > data.pw_max) plain_len = data.pw_max;
2069 }
2070 }
2071 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2072 {
2073 pw_t pw;
2074
2075 gidd_to_pw_t (device_param, gidvid, &pw);
2076
2077 for (int i = 0; i < 16; i++)
2078 {
2079 plain_buf[i] = pw.i[i];
2080 }
2081
2082 plain_len = pw.pw_len;
2083
2084 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2085
2086 uint start = 0;
2087 uint stop = device_param->kernel_params_mp_buf32[4];
2088
2089 memmove (plain_ptr + stop, plain_ptr, plain_len);
2090
2091 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2092
2093 plain_len += start + stop;
2094
2095 crackpos += gidvid;
2096 crackpos *= data.combs_cnt;
2097 crackpos += device_param->innerloop_pos + il_pos;
2098
2099 if (data.pw_max != PW_DICTMAX1)
2100 {
2101 if (plain_len > data.pw_max) plain_len = data.pw_max;
2102 }
2103 }
2104
2105 if (data.attack_mode == ATTACK_MODE_BF)
2106 {
2107 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2108 {
2109 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2110 {
2111 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2112 {
2113 plain_len = plain_len - data.salts_buf[0].salt_len;
2114 }
2115 }
2116
2117 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2118 {
2119 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2120 {
2121 plain_ptr[j] = plain_ptr[i];
2122 }
2123
2124 plain_len = plain_len / 2;
2125 }
2126 }
2127 }
2128
2129 // if enabled, update also the potfile
2130
2131 if (pot_fp)
2132 {
2133 lock_file (pot_fp);
2134
2135 fprintf (pot_fp, "%s:", out_buf);
2136
2137 format_plain (pot_fp, plain_ptr, plain_len, 1);
2138
2139 fputc ('\n', pot_fp);
2140
2141 fflush (pot_fp);
2142
2143 unlock_file (pot_fp);
2144 }
2145
2146 // outfile
2147
2148 FILE *out_fp = NULL;
2149
2150 if (outfile != NULL)
2151 {
2152 if ((out_fp = fopen (outfile, "ab")) == NULL)
2153 {
2154 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2155
2156 out_fp = stdout;
2157 }
2158
2159 lock_file (out_fp);
2160 }
2161 else
2162 {
2163 out_fp = stdout;
2164
2165 if (quiet == 0) clear_prompt ();
2166 }
2167
2168 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2169
2170 if (outfile != NULL)
2171 {
2172 if (out_fp != stdout)
2173 {
2174 fclose (out_fp);
2175 }
2176 }
2177 else
2178 {
2179 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2180 {
2181 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2182 {
2183 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2184 if (quiet == 0) fflush (stdout);
2185 }
2186 }
2187 }
2188
2189 // loopback
2190
2191 if (loopback)
2192 {
2193 char *loopback_file = data.loopback_file;
2194
2195 FILE *fb_fp = NULL;
2196
2197 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2198 {
2199 lock_file (fb_fp);
2200
2201 format_plain (fb_fp, plain_ptr, plain_len, 1);
2202
2203 fputc ('\n', fb_fp);
2204
2205 fclose (fb_fp);
2206 }
2207 }
2208
2209 // (rule) debug mode
2210
2211 // the next check implies that:
2212 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2213 // - debug_mode > 0
2214
2215 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2216 {
2217 if (debug_rule_len < 0) debug_rule_len = 0;
2218
2219 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2220
2221 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2222
2223 if ((quiet == 0) && (debug_file == NULL))
2224 {
2225 fprintf (stdout, "%s", PROMPT);
2226
2227 fflush (stdout);
2228 }
2229 }
2230 }
2231
2232 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2233 {
2234 salt_t *salt_buf = &data.salts_buf[salt_pos];
2235
2236 u32 num_cracked;
2237
2238 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2239
2240 if (num_cracked)
2241 {
2242 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2243
2244 log_info_nn ("");
2245
2246 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2247
2248 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);
2249
2250 uint cpt_cracked = 0;
2251
2252 for (uint i = 0; i < num_cracked; i++)
2253 {
2254 const uint hash_pos = cracked[i].hash_pos;
2255
2256 if (data.digests_shown[hash_pos] == 1) continue;
2257
2258 hc_thread_mutex_lock (mux_display);
2259
2260 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2261 {
2262 data.digests_shown[hash_pos] = 1;
2263
2264 data.digests_done++;
2265
2266 cpt_cracked++;
2267
2268 salt_buf->digests_done++;
2269
2270 if (salt_buf->digests_done == salt_buf->digests_cnt)
2271 {
2272 data.salts_shown[salt_pos] = 1;
2273
2274 data.salts_done++;
2275 }
2276 }
2277
2278 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2279
2280 hc_thread_mutex_unlock (mux_display);
2281
2282 check_hash (device_param, &cracked[i]);
2283 }
2284
2285 myfree (cracked);
2286
2287 if (cpt_cracked > 0)
2288 {
2289 hc_thread_mutex_lock (mux_display);
2290
2291 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2292 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2293
2294 data.cpt_pos++;
2295
2296 data.cpt_total += cpt_cracked;
2297
2298 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2299
2300 hc_thread_mutex_unlock (mux_display);
2301 }
2302
2303 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2304 {
2305 // we need to reset cracked state on the device
2306 // otherwise host thinks again and again the hash was cracked
2307 // and returns invalid password each time
2308
2309 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2310
2311 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);
2312 }
2313
2314 num_cracked = 0;
2315
2316 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2317 }
2318 }
2319
2320 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2321 {
2322 char out_buf[HCBUFSIZ] = { 0 };
2323
2324 uint plain_buf[16] = { 0 };
2325
2326 u8 *plain_ptr = (u8 *) plain_buf;
2327
2328 uint plain_len = 0;
2329
2330 const uint il_cnt = device_param->kernel_params_buf32[27]; // ugly, i know
2331
2332 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2333 {
2334 pw_t pw;
2335
2336 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2337 {
2338 gidd_to_pw_t (device_param, gidvid, &pw);
2339
2340 const uint pos = device_param->innerloop_pos;
2341
2342 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2343 {
2344 for (int i = 0; i < 8; i++)
2345 {
2346 plain_buf[i] = pw.i[i];
2347 }
2348
2349 plain_len = pw.pw_len;
2350
2351 plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2352
2353 if (plain_len > data.pw_max) plain_len = data.pw_max;
2354
2355 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2356 }
2357 }
2358 }
2359 else if (data.attack_mode == ATTACK_MODE_COMBI)
2360 {
2361 pw_t pw;
2362
2363 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2364 {
2365 gidd_to_pw_t (device_param, gidvid, &pw);
2366
2367 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2368 {
2369 for (int i = 0; i < 8; i++)
2370 {
2371 plain_buf[i] = pw.i[i];
2372 }
2373
2374 plain_len = pw.pw_len;
2375
2376 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2377 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2378
2379 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2380 {
2381 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2382 }
2383 else
2384 {
2385 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2386
2387 memcpy (plain_ptr, comb_buf, comb_len);
2388 }
2389
2390 plain_len += comb_len;
2391
2392 if (data.pw_max != PW_DICTMAX1)
2393 {
2394 if (plain_len > data.pw_max) plain_len = data.pw_max;
2395 }
2396
2397 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2398 }
2399 }
2400 }
2401 else if (data.attack_mode == ATTACK_MODE_BF)
2402 {
2403 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2404 {
2405 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2406 {
2407 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2408 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2409
2410 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2411 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2412
2413 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2414 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2415
2416 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2417 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2418
2419 plain_len = data.css_cnt;
2420
2421 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2422 }
2423 }
2424 }
2425 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2426 {
2427 pw_t pw;
2428
2429 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2430 {
2431 gidd_to_pw_t (device_param, gidvid, &pw);
2432
2433 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2434 {
2435 for (int i = 0; i < 8; i++)
2436 {
2437 plain_buf[i] = pw.i[i];
2438 }
2439
2440 plain_len = pw.pw_len;
2441
2442 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2443
2444 uint start = 0;
2445 uint stop = device_param->kernel_params_mp_buf32[4];
2446
2447 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2448
2449 plain_len += start + stop;
2450
2451 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2452 }
2453 }
2454 }
2455 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2456 {
2457 pw_t pw;
2458
2459 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2460 {
2461 gidd_to_pw_t (device_param, gidvid, &pw);
2462
2463 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2464 {
2465 for (int i = 0; i < 8; i++)
2466 {
2467 plain_buf[i] = pw.i[i];
2468 }
2469
2470 plain_len = pw.pw_len;
2471
2472 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2473
2474 uint start = 0;
2475 uint stop = device_param->kernel_params_mp_buf32[4];
2476
2477 memmove (plain_ptr + stop, plain_ptr, plain_len);
2478
2479 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2480
2481 plain_len += start + stop;
2482
2483 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2484 }
2485 }
2486 }
2487 }
2488
2489 static void save_hash ()
2490 {
2491 char *hashfile = data.hashfile;
2492
2493 char new_hashfile[256] = { 0 };
2494 char old_hashfile[256] = { 0 };
2495
2496 snprintf (new_hashfile, 255, "%s.new", hashfile);
2497 snprintf (old_hashfile, 255, "%s.old", hashfile);
2498
2499 unlink (new_hashfile);
2500
2501 char separator = data.separator;
2502
2503 FILE *fp = fopen (new_hashfile, "wb");
2504
2505 if (fp == NULL)
2506 {
2507 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2508
2509 exit (-1);
2510 }
2511
2512 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2513 {
2514 if (data.salts_shown[salt_pos] == 1) continue;
2515
2516 salt_t *salt_buf = &data.salts_buf[salt_pos];
2517
2518 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2519 {
2520 uint idx = salt_buf->digests_offset + digest_pos;
2521
2522 if (data.digests_shown[idx] == 1) continue;
2523
2524 if (data.hash_mode != 2500)
2525 {
2526 if (data.username == 1)
2527 {
2528 user_t *user = data.hash_info[idx]->user;
2529
2530 uint i;
2531
2532 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2533
2534 fputc (separator, fp);
2535 }
2536
2537 char out_buf[HCBUFSIZ]; // scratch buffer
2538
2539 out_buf[0] = 0;
2540
2541 ascii_digest (out_buf, salt_pos, digest_pos);
2542
2543 fputs (out_buf, fp);
2544
2545 fputc ('\n', fp);
2546 }
2547 else
2548 {
2549 hccap_t hccap;
2550
2551 to_hccap_t (&hccap, salt_pos, digest_pos);
2552
2553 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2554 }
2555 }
2556 }
2557
2558 fflush (fp);
2559
2560 fclose (fp);
2561
2562 unlink (old_hashfile);
2563
2564 if (rename (hashfile, old_hashfile) != 0)
2565 {
2566 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2567
2568 exit (-1);
2569 }
2570
2571 unlink (hashfile);
2572
2573 if (rename (new_hashfile, hashfile) != 0)
2574 {
2575 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2576
2577 exit (-1);
2578 }
2579
2580 unlink (old_hashfile);
2581 }
2582
2583 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2584 {
2585 uint num_elements = num;
2586
2587 device_param->kernel_params_buf32[30] = data.combs_mode;
2588 device_param->kernel_params_buf32[31] = num;
2589
2590 uint kernel_threads = device_param->kernel_threads;
2591
2592 while (num_elements % kernel_threads) num_elements++;
2593
2594 cl_kernel kernel = NULL;
2595
2596 switch (kern_run)
2597 {
2598 case KERN_RUN_1: kernel = device_param->kernel1; break;
2599 case KERN_RUN_12: kernel = device_param->kernel12; break;
2600 case KERN_RUN_2: kernel = device_param->kernel2; break;
2601 case KERN_RUN_23: kernel = device_param->kernel23; break;
2602 case KERN_RUN_3: kernel = device_param->kernel3; break;
2603 }
2604
2605 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2606 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2607 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2608 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2609 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2610 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2611 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2612 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2613 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2614 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2615 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2616
2617 cl_event event;
2618
2619 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2620 {
2621 const size_t global_work_size[3] = { num_elements, 32, 1 };
2622 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2623
2624 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2625 }
2626 else
2627 {
2628 if (kern_run == KERN_RUN_2)
2629 {
2630 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2631 {
2632 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2633 }
2634 }
2635
2636 while (num_elements % kernel_threads) num_elements++;
2637
2638 const size_t global_work_size[3] = { num_elements, 1, 1 };
2639 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2640
2641 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2642 }
2643
2644 hc_clFlush (data.ocl, device_param->command_queue);
2645
2646 if (device_param->nvidia_spin_damp)
2647 {
2648 if (data.devices_status == STATUS_RUNNING)
2649 {
2650 if (iteration < EXPECTED_ITERATIONS)
2651 {
2652 switch (kern_run)
2653 {
2654 case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration] * device_param->nvidia_spin_damp); break;
2655 case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration] * device_param->nvidia_spin_damp); break;
2656 case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration] * device_param->nvidia_spin_damp); break;
2657 }
2658 }
2659 }
2660 }
2661
2662 hc_clWaitForEvents (data.ocl, 1, &event);
2663
2664 cl_ulong time_start;
2665 cl_ulong time_end;
2666
2667 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2668 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2669
2670 const double exec_us = (double) (time_end - time_start) / 1000;
2671
2672 if (data.devices_status == STATUS_RUNNING)
2673 {
2674 if (iteration < EXPECTED_ITERATIONS)
2675 {
2676 switch (kern_run)
2677 {
2678 case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2679 case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2680 case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2681 }
2682 }
2683 }
2684
2685 if (event_update)
2686 {
2687 uint exec_pos = device_param->exec_pos;
2688
2689 device_param->exec_ms[exec_pos] = exec_us / 1000;
2690
2691 exec_pos++;
2692
2693 if (exec_pos == EXEC_CACHE)
2694 {
2695 exec_pos = 0;
2696 }
2697
2698 device_param->exec_pos = exec_pos;
2699 }
2700
2701 hc_clReleaseEvent (data.ocl, event);
2702
2703 hc_clFinish (data.ocl, device_param->command_queue);
2704 }
2705
2706 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2707 {
2708 uint num_elements = num;
2709
2710 switch (kern_run)
2711 {
2712 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2713 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2714 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2715 }
2716
2717 // causes problems with special threads like in bcrypt
2718 // const uint kernel_threads = device_param->kernel_threads;
2719
2720 uint kernel_threads = device_param->kernel_threads;
2721
2722 while (num_elements % kernel_threads) num_elements++;
2723
2724 cl_kernel kernel = NULL;
2725
2726 switch (kern_run)
2727 {
2728 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2729 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2730 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2731 }
2732
2733 switch (kern_run)
2734 {
2735 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2736 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2737 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2738 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2739 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2740 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2741 break;
2742 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2743 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2744 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2745 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2746 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2747 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2748 break;
2749 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2750 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2751 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2752 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2753 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2754 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2755 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2756 break;
2757 }
2758
2759 const size_t global_work_size[3] = { num_elements, 1, 1 };
2760 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2761
2762 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2763
2764 hc_clFlush (data.ocl, device_param->command_queue);
2765
2766 hc_clFinish (data.ocl, device_param->command_queue);
2767 }
2768
2769 static void run_kernel_tm (hc_device_param_t *device_param)
2770 {
2771 const uint num_elements = 1024; // fixed
2772
2773 uint kernel_threads = 32;
2774
2775 cl_kernel kernel = device_param->kernel_tm;
2776
2777 const size_t global_work_size[3] = { num_elements, 1, 1 };
2778 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2779
2780 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2781
2782 hc_clFlush (data.ocl, device_param->command_queue);
2783
2784 hc_clFinish (data.ocl, device_param->command_queue);
2785 }
2786
2787 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2788 {
2789 uint num_elements = num;
2790
2791 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2792 device_param->kernel_params_amp_buf32[6] = num_elements;
2793
2794 // causes problems with special threads like in bcrypt
2795 // const uint kernel_threads = device_param->kernel_threads;
2796
2797 uint kernel_threads = device_param->kernel_threads;
2798
2799 while (num_elements % kernel_threads) num_elements++;
2800
2801 cl_kernel kernel = device_param->kernel_amp;
2802
2803 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2804 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2805
2806 const size_t global_work_size[3] = { num_elements, 1, 1 };
2807 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2808
2809 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2810
2811 hc_clFlush (data.ocl, device_param->command_queue);
2812
2813 hc_clFinish (data.ocl, device_param->command_queue);
2814 }
2815
2816 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2817 {
2818 const u32 num16d = num / 16;
2819 const u32 num16m = num % 16;
2820
2821 if (num16d)
2822 {
2823 device_param->kernel_params_memset_buf32[1] = value;
2824 device_param->kernel_params_memset_buf32[2] = num16d;
2825
2826 uint kernel_threads = device_param->kernel_threads;
2827
2828 uint num_elements = num16d;
2829
2830 while (num_elements % kernel_threads) num_elements++;
2831
2832 cl_kernel kernel = device_param->kernel_memset;
2833
2834 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2835 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2836 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2837
2838 const size_t global_work_size[3] = { num_elements, 1, 1 };
2839 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2840
2841 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2842
2843 hc_clFlush (data.ocl, device_param->command_queue);
2844
2845 hc_clFinish (data.ocl, device_param->command_queue);
2846 }
2847
2848 if (num16m)
2849 {
2850 u32 tmp[4];
2851
2852 tmp[0] = value;
2853 tmp[1] = value;
2854 tmp[2] = value;
2855 tmp[3] = value;
2856
2857 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2858 }
2859 }
2860
2861 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2862 {
2863 run_kernel_memset (device_param, buf, 0, size);
2864
2865 /*
2866 int rc = -1;
2867
2868 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2869 {
2870 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2871
2872 const cl_uchar zero = 0;
2873
2874 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2875 }
2876
2877 if (rc != 0)
2878 {
2879 // NOTE: clEnqueueFillBuffer () always fails with -59
2880 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2881 // How's that possible, OpenCL 1.2 support is advertised??
2882 // We need to workaround...
2883
2884 #define FILLSZ 0x100000
2885
2886 char *tmp = (char *) mymalloc (FILLSZ);
2887
2888 for (size_t i = 0; i < size; i += FILLSZ)
2889 {
2890 const size_t left = size - i;
2891
2892 const size_t fillsz = MIN (FILLSZ, left);
2893
2894 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2895 }
2896
2897 myfree (tmp);
2898 }
2899 */
2900 }
2901
2902 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)
2903 {
2904 if (data.hash_mode == 2000)
2905 {
2906 process_stdout (device_param, pws_cnt);
2907
2908 return;
2909 }
2910
2911 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2912 {
2913 if (attack_mode == ATTACK_MODE_BF)
2914 {
2915 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2916 {
2917 const uint size_tm = 32 * sizeof (bs_word_t);
2918
2919 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2920
2921 run_kernel_tm (device_param);
2922
2923 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);
2924 }
2925 }
2926
2927 if (highest_pw_len < 16)
2928 {
2929 run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
2930 }
2931 else if (highest_pw_len < 32)
2932 {
2933 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
2934 }
2935 else
2936 {
2937 run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
2938 }
2939 }
2940 else
2941 {
2942 run_kernel_amp (device_param, pws_cnt);
2943
2944 run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
2945
2946 if (opts_type & OPTS_TYPE_HOOK12)
2947 {
2948 run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
2949
2950 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);
2951
2952 // do something with data
2953
2954 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);
2955 }
2956
2957 uint iter = salt_buf->salt_iter;
2958
2959 uint loop_step = device_param->kernel_loops;
2960
2961 for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
2962 {
2963 uint loop_left = iter - loop_pos;
2964
2965 loop_left = MIN (loop_left, loop_step);
2966
2967 device_param->kernel_params_buf32[25] = loop_pos;
2968 device_param->kernel_params_buf32[26] = loop_left;
2969
2970 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
2971
2972 if (data.devices_status == STATUS_CRACKED) break;
2973 if (data.devices_status == STATUS_ABORTED) break;
2974 if (data.devices_status == STATUS_QUIT) break;
2975
2976 /**
2977 * speed
2978 */
2979
2980 const float iter_part = (float) (loop_pos + loop_left) / iter;
2981
2982 const u64 perf_sum_all = pws_cnt * iter_part;
2983
2984 double speed_ms;
2985
2986 hc_timer_get (device_param->timer_speed, speed_ms);
2987
2988 const u32 speed_pos = device_param->speed_pos;
2989
2990 device_param->speed_cnt[speed_pos] = perf_sum_all;
2991
2992 device_param->speed_ms[speed_pos] = speed_ms;
2993
2994 if (data.benchmark == 1)
2995 {
2996 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2997 }
2998 }
2999
3000 if (opts_type & OPTS_TYPE_HOOK23)
3001 {
3002 run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
3003
3004 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);
3005
3006 // do something with data
3007
3008 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);
3009 }
3010
3011 run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3012 }
3013 }
3014
3015 static int run_rule_engine (const int rule_len, const char *rule_buf)
3016 {
3017 if (rule_len == 0)
3018 {
3019 return 0;
3020 }
3021 else if (rule_len == 1)
3022 {
3023 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3024 }
3025
3026 return 1;
3027 }
3028
3029 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3030 {
3031 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3032 {
3033 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);
3034 }
3035 else if (data.attack_kern == ATTACK_KERN_COMBI)
3036 {
3037 if (data.attack_mode == ATTACK_MODE_COMBI)
3038 {
3039 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3040 {
3041 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3042 {
3043 for (u32 i = 0; i < pws_cnt; i++)
3044 {
3045 const u32 pw_len = device_param->pws_buf[i].pw_len;
3046
3047 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3048
3049 ptr[pw_len] = 0x01;
3050 }
3051 }
3052 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3053 {
3054 for (u32 i = 0; i < pws_cnt; i++)
3055 {
3056 const u32 pw_len = device_param->pws_buf[i].pw_len;
3057
3058 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3059
3060 ptr[pw_len] = 0x80;
3061 }
3062 }
3063 }
3064 }
3065 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3066 {
3067 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3068 {
3069 for (u32 i = 0; i < pws_cnt; i++)
3070 {
3071 const u32 pw_len = device_param->pws_buf[i].pw_len;
3072
3073 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3074
3075 ptr[pw_len] = 0x01;
3076 }
3077 }
3078 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3079 {
3080 for (u32 i = 0; i < pws_cnt; i++)
3081 {
3082 const u32 pw_len = device_param->pws_buf[i].pw_len;
3083
3084 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3085
3086 ptr[pw_len] = 0x80;
3087 }
3088 }
3089 }
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_BF)
3094 {
3095 const u64 off = device_param->words_off;
3096
3097 device_param->kernel_params_mp_l_buf64[3] = off;
3098
3099 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3100 }
3101 }
3102
3103 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3104 {
3105 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3106
3107 device_param->kernel_params_buf32[25] = 0;
3108 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
3109 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3110
3111 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3112 {
3113 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3114 }
3115 else
3116 {
3117 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3118 }
3119
3120 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3121
3122 return exec_ms_prev;
3123 }
3124
3125 static void autotune (hc_device_param_t *device_param)
3126 {
3127 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3128
3129 const u32 kernel_accel_min = device_param->kernel_accel_min;
3130 const u32 kernel_accel_max = device_param->kernel_accel_max;
3131
3132 const u32 kernel_loops_min = device_param->kernel_loops_min;
3133 const u32 kernel_loops_max = device_param->kernel_loops_max;
3134
3135 u32 kernel_accel = kernel_accel_min;
3136 u32 kernel_loops = kernel_loops_min;
3137
3138 // in this case the user specified a fixed -u and -n on the commandline
3139 // no way to tune anything
3140 // but we need to run a few caching rounds
3141
3142 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3143 {
3144 if (data.hash_mode != 2000)
3145 {
3146 try_run (device_param, kernel_accel, kernel_loops);
3147 try_run (device_param, kernel_accel, kernel_loops);
3148 try_run (device_param, kernel_accel, kernel_loops);
3149 try_run (device_param, kernel_accel, kernel_loops);
3150 }
3151
3152 device_param->kernel_accel = kernel_accel;
3153 device_param->kernel_loops = kernel_loops;
3154
3155 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3156
3157 device_param->kernel_power = kernel_power;
3158
3159 return;
3160 }
3161
3162 // from here it's clear we are allowed to autotune
3163 // so let's init some fake words
3164
3165 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3166
3167 if (data.attack_kern == ATTACK_KERN_BF)
3168 {
3169 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3170 }
3171 else
3172 {
3173 for (u32 i = 0; i < kernel_power_max; i++)
3174 {
3175 device_param->pws_buf[i].i[0] = i;
3176 device_param->pws_buf[i].i[1] = 0x01234567;
3177 device_param->pws_buf[i].pw_len = 7 + (i & 7);
3178 }
3179
3180 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);
3181 }
3182
3183 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3184 {
3185 if (data.kernel_rules_cnt > 1)
3186 {
3187 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);
3188 }
3189 }
3190 else
3191 {
3192 run_kernel_amp (device_param, kernel_power_max);
3193 }
3194
3195 #define VERIFIER_CNT 1
3196
3197 // first find out highest kernel-loops that stays below target_ms
3198
3199 if (kernel_loops_min < kernel_loops_max)
3200 {
3201 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3202 {
3203 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3204
3205 for (int i = 0; i < VERIFIER_CNT; i++)
3206 {
3207 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3208
3209 exec_ms = MIN (exec_ms, exec_ms_v);
3210 }
3211
3212 if (exec_ms < target_ms) break;
3213 }
3214 }
3215
3216 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3217
3218 #define STEPS_CNT 10
3219
3220 if (kernel_accel_min < kernel_accel_max)
3221 {
3222 for (int i = 0; i < STEPS_CNT; i++)
3223 {
3224 const u32 kernel_accel_try = 1 << i;
3225
3226 if (kernel_accel_try < kernel_accel_min) continue;
3227 if (kernel_accel_try > kernel_accel_max) break;
3228
3229 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3230
3231 for (int i = 0; i < VERIFIER_CNT; i++)
3232 {
3233 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3234
3235 exec_ms = MIN (exec_ms, exec_ms_v);
3236 }
3237
3238 if (exec_ms > target_ms) break;
3239
3240 kernel_accel = kernel_accel_try;
3241 }
3242 }
3243
3244 // at this point we want to know the actual runtime for the following reason:
3245 // we need a reference for the balancing loop following up, and this
3246 // the balancing loop can have an effect that the creates a new opportunity, for example:
3247 // if the target is 95 ms and the current runtime is 48ms the above loop
3248 // stopped the execution because the previous exec_ms was > 95ms
3249 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3250 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3251
3252 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3253
3254 for (int i = 0; i < VERIFIER_CNT; i++)
3255 {
3256 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3257
3258 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3259 }
3260
3261 u32 diff = kernel_loops - kernel_accel;
3262
3263 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3264 {
3265 u32 kernel_accel_orig = kernel_accel;
3266 u32 kernel_loops_orig = kernel_loops;
3267
3268 for (u32 f = 1; f < 1024; f++)
3269 {
3270 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3271 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3272
3273 if (kernel_accel_try > kernel_accel_max) break;
3274 if (kernel_loops_try < kernel_loops_min) break;
3275
3276 u32 diff_new = kernel_loops_try - kernel_accel_try;
3277
3278 if (diff_new > diff) break;
3279
3280 diff_new = diff;
3281
3282 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3283
3284 for (int i = 0; i < VERIFIER_CNT; i++)
3285 {
3286 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3287
3288 exec_ms = MIN (exec_ms, exec_ms_v);
3289 }
3290
3291 if (exec_ms < exec_ms_pre_final)
3292 {
3293 exec_ms_pre_final = exec_ms;
3294
3295 kernel_accel = kernel_accel_try;
3296 kernel_loops = kernel_loops_try;
3297 }
3298 }
3299 }
3300
3301 const double exec_left = target_ms / exec_ms_pre_final;
3302
3303 const double accel_left = kernel_accel_max / kernel_accel;
3304
3305 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3306
3307 if (exec_accel_min >= 1.0)
3308 {
3309 // this is safe to not overflow kernel_accel_max because of accel_left
3310
3311 kernel_accel = (double) kernel_accel * exec_accel_min;
3312 }
3313
3314 // reset them fake words
3315
3316 /*
3317 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3318
3319 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);
3320 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);
3321 */
3322
3323 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3324
3325 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3326 {
3327 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3328 }
3329
3330 // reset timer
3331
3332 device_param->exec_pos = 0;
3333
3334 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3335
3336 memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3337 memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3338 memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3339
3340 // store
3341
3342 device_param->kernel_accel = kernel_accel;
3343 device_param->kernel_loops = kernel_loops;
3344
3345 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3346
3347 device_param->kernel_power = kernel_power;
3348
3349 #ifdef DEBUG
3350
3351 if (data.quiet == 0)
3352 {
3353 clear_prompt ();
3354
3355 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3356 "Device #%u: autotuned kernel-loops to %u\n",
3357 device_param->device_id + 1, kernel_accel,
3358 device_param->device_id + 1, kernel_loops);
3359
3360 fprintf (stdout, "%s", PROMPT);
3361
3362 fflush (stdout);
3363 }
3364
3365 #endif
3366 }
3367
3368 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3369 {
3370 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3371
3372 // init speed timer
3373
3374 uint speed_pos = device_param->speed_pos;
3375
3376 #ifdef _POSIX
3377 if (device_param->timer_speed.tv_sec == 0)
3378 {
3379 hc_timer_set (&device_param->timer_speed);
3380 }
3381 #endif
3382
3383 #ifdef _WIN
3384 if (device_param->timer_speed.QuadPart == 0)
3385 {
3386 hc_timer_set (&device_param->timer_speed);
3387 }
3388 #endif
3389
3390 // find higest password length, this is for optimization stuff
3391
3392 uint highest_pw_len = 0;
3393
3394 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3395 {
3396 }
3397 else if (data.attack_kern == ATTACK_KERN_COMBI)
3398 {
3399 }
3400 else if (data.attack_kern == ATTACK_KERN_BF)
3401 {
3402 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3403 + device_param->kernel_params_mp_l_buf32[5];
3404 }
3405
3406 // iteration type
3407
3408 uint innerloop_step = 0;
3409 uint innerloop_cnt = 0;
3410
3411 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3412 else innerloop_step = 1;
3413
3414 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3415 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3416 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3417
3418 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3419
3420 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3421 {
3422 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3423
3424 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3425
3426 if (data.devices_status == STATUS_CRACKED) break;
3427 if (data.devices_status == STATUS_ABORTED) break;
3428 if (data.devices_status == STATUS_QUIT) break;
3429 if (data.devices_status == STATUS_BYPASS) break;
3430
3431 salt_t *salt_buf = &data.salts_buf[salt_pos];
3432
3433 device_param->kernel_params_buf32[24] = salt_pos;
3434 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3435 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3436
3437 FILE *combs_fp = device_param->combs_fp;
3438
3439 if (data.attack_mode == ATTACK_MODE_COMBI)
3440 {
3441 rewind (combs_fp);
3442 }
3443
3444 // innerloops
3445
3446 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3447 {
3448 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3449
3450 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3451
3452 if (data.devices_status == STATUS_CRACKED) break;
3453 if (data.devices_status == STATUS_ABORTED) break;
3454 if (data.devices_status == STATUS_QUIT) break;
3455 if (data.devices_status == STATUS_BYPASS) break;
3456
3457 uint fast_iteration = 0;
3458
3459 uint innerloop_left = innerloop_cnt - innerloop_pos;
3460
3461 if (innerloop_left > innerloop_step)
3462 {
3463 innerloop_left = innerloop_step;
3464
3465 fast_iteration = 1;
3466 }
3467
3468 device_param->innerloop_pos = innerloop_pos;
3469 device_param->innerloop_left = innerloop_left;
3470
3471 device_param->kernel_params_buf32[27] = innerloop_left;
3472
3473 // i think we can get rid of this
3474 if (innerloop_left == 0)
3475 {
3476 puts ("bug, how should this happen????\n");
3477
3478 continue;
3479 }
3480
3481 if (data.salts_shown[salt_pos] == 1)
3482 {
3483 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3484
3485 continue;
3486 }
3487
3488 // initialize amplifiers
3489
3490 if (data.attack_mode == ATTACK_MODE_COMBI)
3491 {
3492 uint i = 0;
3493
3494 while (i < innerloop_left)
3495 {
3496 if (feof (combs_fp)) break;
3497
3498 int line_len = fgetl (combs_fp, line_buf);
3499
3500 if (line_len >= PW_MAX1) continue;
3501
3502 line_len = convert_from_hex (line_buf, line_len);
3503
3504 char *line_buf_new = line_buf;
3505
3506 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3507 {
3508 char rule_buf_out[BLOCK_SIZE] = { 0 };
3509
3510 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3511
3512 if (rule_len_out < 0)
3513 {
3514 data.words_progress_rejected[salt_pos] += pws_cnt;
3515
3516 continue;
3517 }
3518
3519 line_len = rule_len_out;
3520
3521 line_buf_new = rule_buf_out;
3522 }
3523
3524 line_len = MIN (line_len, PW_DICTMAX);
3525
3526 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3527
3528 memcpy (ptr, line_buf_new, line_len);
3529
3530 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3531
3532 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3533 {
3534 uppercase (ptr, line_len);
3535 }
3536
3537 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3538 {
3539 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3540 {
3541 ptr[line_len] = 0x80;
3542 }
3543
3544 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3545 {
3546 ptr[line_len] = 0x01;
3547 }
3548 }
3549
3550 device_param->combs_buf[i].pw_len = line_len;
3551
3552 i++;
3553 }
3554
3555 for (uint j = i; j < innerloop_left; j++)
3556 {
3557 device_param->combs_buf[j].i[0] = 0;
3558 device_param->combs_buf[j].i[1] = 0;
3559 device_param->combs_buf[j].i[2] = 0;
3560 device_param->combs_buf[j].i[3] = 0;
3561 device_param->combs_buf[j].i[4] = 0;
3562 device_param->combs_buf[j].i[5] = 0;
3563 device_param->combs_buf[j].i[6] = 0;
3564 device_param->combs_buf[j].i[7] = 0;
3565
3566 device_param->combs_buf[j].pw_len = 0;
3567 }
3568
3569 innerloop_left = i;
3570 }
3571 else if (data.attack_mode == ATTACK_MODE_BF)
3572 {
3573 u64 off = innerloop_pos;
3574
3575 device_param->kernel_params_mp_r_buf64[3] = off;
3576
3577 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3578 }
3579 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3580 {
3581 u64 off = innerloop_pos;
3582
3583 device_param->kernel_params_mp_buf64[3] = off;
3584
3585 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3586 }
3587 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3588 {
3589 u64 off = innerloop_pos;
3590
3591 device_param->kernel_params_mp_buf64[3] = off;
3592
3593 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3594 }
3595
3596 // copy amplifiers
3597
3598 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3599 {
3600 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);
3601 }
3602 else if (data.attack_mode == ATTACK_MODE_COMBI)
3603 {
3604 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);
3605 }
3606 else if (data.attack_mode == ATTACK_MODE_BF)
3607 {
3608 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);
3609 }
3610 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3611 {
3612 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);
3613 }
3614 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3615 {
3616 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);
3617 }
3618
3619 if (data.benchmark == 1)
3620 {
3621 hc_timer_set (&device_param->timer_speed);
3622 }
3623
3624 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
3625
3626 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3627
3628 if (data.devices_status == STATUS_CRACKED) break;
3629 if (data.devices_status == STATUS_ABORTED) break;
3630 if (data.devices_status == STATUS_QUIT) break;
3631
3632 /**
3633 * result
3634 */
3635
3636 if (data.benchmark == 0)
3637 {
3638 check_cracked (device_param, salt_pos);
3639 }
3640
3641 /**
3642 * progress
3643 */
3644
3645 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3646
3647 hc_thread_mutex_lock (mux_counter);
3648
3649 data.words_progress_done[salt_pos] += perf_sum_all;
3650
3651 hc_thread_mutex_unlock (mux_counter);
3652
3653 /**
3654 * speed
3655 */
3656
3657 double speed_ms;
3658
3659 hc_timer_get (device_param->timer_speed, speed_ms);
3660
3661 hc_timer_set (&device_param->timer_speed);
3662
3663 // current speed
3664
3665 //hc_thread_mutex_lock (mux_display);
3666
3667 device_param->speed_cnt[speed_pos] = perf_sum_all;
3668
3669 device_param->speed_ms[speed_pos] = speed_ms;
3670
3671 //hc_thread_mutex_unlock (mux_display);
3672
3673 speed_pos++;
3674
3675 if (speed_pos == SPEED_CACHE)
3676 {
3677 speed_pos = 0;
3678 }
3679
3680 /**
3681 * benchmark
3682 */
3683
3684 if (data.benchmark == 1) break;
3685 }
3686 }
3687
3688 device_param->speed_pos = speed_pos;
3689
3690 myfree (line_buf);
3691 }
3692
3693 static void load_segment (wl_data_t *wl_data, FILE *fd)
3694 {
3695 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3696
3697 wl_data->pos = 0;
3698
3699 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3700
3701 wl_data->buf[wl_data->cnt] = 0;
3702
3703 if (wl_data->cnt == 0) return;
3704
3705 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3706
3707 while (!feof (fd))
3708 {
3709 if (wl_data->cnt == wl_data->avail)
3710 {
3711 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3712
3713 wl_data->avail += wl_data->incr;
3714 }
3715
3716 const int c = fgetc (fd);
3717
3718 if (c == EOF) break;
3719
3720 wl_data->buf[wl_data->cnt] = (char) c;
3721
3722 wl_data->cnt++;
3723
3724 if (c == '\n') break;
3725 }
3726
3727 // ensure stream ends with a newline
3728
3729 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3730 {
3731 wl_data->cnt++;
3732
3733 wl_data->buf[wl_data->cnt - 1] = '\n';
3734 }
3735
3736 return;
3737 }
3738
3739 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3740 {
3741 char *ptr = buf;
3742
3743 for (u32 i = 0; i < sz; i++, ptr++)
3744 {
3745 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3746
3747 if (i == 7)
3748 {
3749 *off = i;
3750 *len = i;
3751
3752 return;
3753 }
3754
3755 if (*ptr != '\n') continue;
3756
3757 *off = i + 1;
3758
3759 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3760
3761 *len = i;
3762
3763 return;
3764 }
3765
3766 *off = sz;
3767 *len = sz;
3768 }
3769
3770 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3771 {
3772 char *ptr = buf;
3773
3774 for (u32 i = 0; i < sz; i++, ptr++)
3775 {
3776 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3777
3778 if (*ptr != '\n') continue;
3779
3780 *off = i + 1;
3781
3782 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3783
3784 *len = i;
3785
3786 return;
3787 }
3788
3789 *off = sz;
3790 *len = sz;
3791 }
3792
3793 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3794 {
3795 char *ptr = buf;
3796
3797 for (u32 i = 0; i < sz; i++, ptr++)
3798 {
3799 if (*ptr != '\n') continue;
3800
3801 *off = i + 1;
3802
3803 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3804
3805 *len = i;
3806
3807 return;
3808 }
3809
3810 *off = sz;
3811 *len = sz;
3812 }
3813
3814 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3815 {
3816 while (wl_data->pos < wl_data->cnt)
3817 {
3818 uint off;
3819 uint len;
3820
3821 char *ptr = wl_data->buf + wl_data->pos;
3822
3823 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3824
3825 wl_data->pos += off;
3826
3827 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3828 {
3829 char rule_buf_out[BLOCK_SIZE] = { 0 };
3830
3831 int rule_len_out = -1;
3832
3833 if (len < BLOCK_SIZE)
3834 {
3835 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3836 }
3837
3838 if (rule_len_out < 0)
3839 {
3840 continue;
3841 }
3842
3843 if (rule_len_out > PW_MAX)
3844 {
3845 continue;
3846 }
3847 }
3848 else
3849 {
3850 if (len > PW_MAX)
3851 {
3852 continue;
3853 }
3854 }
3855
3856 *out_buf = ptr;
3857 *out_len = len;
3858
3859 return;
3860 }
3861
3862 if (feof (fd))
3863 {
3864 fprintf (stderr, "BUG feof()!!\n");
3865
3866 return;
3867 }
3868
3869 load_segment (wl_data, fd);
3870
3871 get_next_word (wl_data, fd, out_buf, out_len);
3872 }
3873
3874 #ifdef _POSIX
3875 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3876 #endif
3877
3878 #ifdef _WIN
3879 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3880 #endif
3881 {
3882 hc_signal (NULL);
3883
3884 dictstat_t d;
3885
3886 d.cnt = 0;
3887
3888 #ifdef _POSIX
3889 fstat (fileno (fd), &d.stat);
3890 #endif
3891
3892 #ifdef _WIN
3893 _fstat64 (fileno (fd), &d.stat);
3894 #endif
3895
3896 d.stat.st_mode = 0;
3897 d.stat.st_nlink = 0;
3898 d.stat.st_uid = 0;
3899 d.stat.st_gid = 0;
3900 d.stat.st_rdev = 0;
3901 d.stat.st_atime = 0;
3902
3903 #ifdef _POSIX
3904 d.stat.st_blksize = 0;
3905 d.stat.st_blocks = 0;
3906 #endif
3907
3908 if (d.stat.st_size == 0) return 0;
3909
3910 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3911
3912 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3913 {
3914 if (d_cache)
3915 {
3916 u64 cnt = d_cache->cnt;
3917
3918 u64 keyspace = cnt;
3919
3920 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3921 {
3922 keyspace *= data.kernel_rules_cnt;
3923 }
3924 else if (data.attack_kern == ATTACK_KERN_COMBI)
3925 {
3926 keyspace *= data.combs_cnt;
3927 }
3928
3929 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);
3930 if (data.quiet == 0) log_info ("");
3931
3932 hc_signal (sigHandler_default);
3933
3934 return (keyspace);
3935 }
3936 }
3937
3938 time_t now = 0;
3939 time_t prev = 0;
3940
3941 u64 comp = 0;
3942 u64 cnt = 0;
3943 u64 cnt2 = 0;
3944
3945 while (!feof (fd))
3946 {
3947 load_segment (wl_data, fd);
3948
3949 comp += wl_data->cnt;
3950
3951 u32 i = 0;
3952
3953 while (i < wl_data->cnt)
3954 {
3955 u32 len;
3956 u32 off;
3957
3958 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3959
3960 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3961 {
3962 char rule_buf_out[BLOCK_SIZE] = { 0 };
3963
3964 int rule_len_out = -1;
3965
3966 if (len < BLOCK_SIZE)
3967 {
3968 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3969 }
3970
3971 if (rule_len_out < 0)
3972 {
3973 len = PW_MAX1;
3974 }
3975 else
3976 {
3977 len = rule_len_out;
3978 }
3979 }
3980
3981 if (len < PW_MAX1)
3982 {
3983 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3984 {
3985 cnt += data.kernel_rules_cnt;
3986 }
3987 else if (data.attack_kern == ATTACK_KERN_COMBI)
3988 {
3989 cnt += data.combs_cnt;
3990 }
3991
3992 d.cnt++;
3993 }
3994
3995 i += off;
3996
3997 cnt2++;
3998 }
3999
4000 time (&now);
4001
4002 if ((now - prev) == 0) continue;
4003
4004 float percent = (float) comp / (float) d.stat.st_size;
4005
4006 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);
4007
4008 time (&prev);
4009 }
4010
4011 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);
4012 if (data.quiet == 0) log_info ("");
4013
4014 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4015
4016 hc_signal (sigHandler_default);
4017
4018 return (cnt);
4019 }
4020
4021 static void *thread_monitor (void *p)
4022 {
4023 uint runtime_check = 0;
4024 uint remove_check = 0;
4025 uint status_check = 0;
4026 uint restore_check = 0;
4027
4028 uint restore_left = data.restore_timer;
4029 uint remove_left = data.remove_timer;
4030 uint status_left = data.status_timer;
4031
4032 #ifdef HAVE_HWMON
4033 uint hwmon_check = 0;
4034
4035 int slowdown_warnings = 0;
4036
4037 // these variables are mainly used for fan control
4038
4039 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4040
4041 // temperature controller "loopback" values
4042
4043 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4044 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4045
4046 int temp_threshold = 1; // degrees celcius
4047
4048 int fan_speed_min = 15; // in percentage
4049 int fan_speed_max = 100;
4050
4051 time_t last_temp_check_time;
4052 #endif // HAVE_HWMON
4053
4054 uint sleep_time = 1;
4055
4056 if (data.runtime)
4057 {
4058 runtime_check = 1;
4059 }
4060
4061 if (data.restore_timer)
4062 {
4063 restore_check = 1;
4064 }
4065
4066 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4067 {
4068 remove_check = 1;
4069 }
4070
4071 if (data.status == 1)
4072 {
4073 status_check = 1;
4074 }
4075
4076 #ifdef HAVE_HWMON
4077 if (data.gpu_temp_disable == 0)
4078 {
4079 time (&last_temp_check_time);
4080
4081 hwmon_check = 1;
4082 }
4083 #endif
4084
4085 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4086 {
4087 #ifdef HAVE_HWMON
4088 if (hwmon_check == 0)
4089 #endif
4090 return (p);
4091 }
4092
4093 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4094 {
4095 hc_sleep (sleep_time);
4096
4097 if (data.devices_status != STATUS_RUNNING) continue;
4098
4099 #ifdef HAVE_HWMON
4100
4101 if (hwmon_check == 1)
4102 {
4103 hc_thread_mutex_lock (mux_adl);
4104
4105 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4106 {
4107 hc_device_param_t *device_param = &data.devices_param[device_id];
4108
4109 if (device_param->skipped) continue;
4110
4111 if (device_param->device_vendor_id == VENDOR_ID_NV)
4112 {
4113 if (data.hm_nvapi)
4114 {
4115 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
4116 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
4117
4118 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4119 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4120
4121 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4122
4123 perfPolicies_status.info_value = perfPolicies_info.info_value;
4124
4125 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4126
4127 if (perfPolicies_status.throttle & 2)
4128 {
4129 if (slowdown_warnings < 3)
4130 {
4131 if (data.quiet == 0) clear_prompt ();
4132
4133 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4134
4135 if (slowdown_warnings == 2)
4136 {
4137 log_info ("");
4138 }
4139
4140 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4141 if (data.quiet == 0) fflush (stdout);
4142
4143 slowdown_warnings++;
4144 }
4145 }
4146 else
4147 {
4148 slowdown_warnings = 0;
4149 }
4150 }
4151 }
4152 }
4153
4154 hc_thread_mutex_unlock (mux_adl);
4155 }
4156
4157 if (hwmon_check == 1)
4158 {
4159 hc_thread_mutex_lock (mux_adl);
4160
4161 time_t temp_check_time;
4162
4163 time (&temp_check_time);
4164
4165 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4166
4167 if (Ta == 0) Ta = 1;
4168
4169 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4170 {
4171 hc_device_param_t *device_param = &data.devices_param[device_id];
4172
4173 if (device_param->skipped) continue;
4174
4175 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4176
4177 const int temperature = hm_get_temperature_with_device_id (device_id);
4178
4179 if (temperature > (int) data.gpu_temp_abort)
4180 {
4181 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4182
4183 if (data.devices_status != STATUS_QUIT) myabort ();
4184
4185 break;
4186 }
4187
4188 const int gpu_temp_retain = data.gpu_temp_retain;
4189
4190 if (gpu_temp_retain)
4191 {
4192 if (data.hm_device[device_id].fan_set_supported == 1)
4193 {
4194 int temp_cur = temperature;
4195
4196 int temp_diff_new = gpu_temp_retain - temp_cur;
4197
4198 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4199
4200 // calculate Ta value (time difference in seconds between the last check and this check)
4201
4202 last_temp_check_time = temp_check_time;
4203
4204 float Kp = 1.8;
4205 float Ki = 0.005;
4206 float Kd = 6;
4207
4208 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4209
4210 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);
4211
4212 if (abs (fan_diff_required) >= temp_threshold)
4213 {
4214 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4215
4216 int fan_speed_level = fan_speed_cur;
4217
4218 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4219
4220 int fan_speed_new = fan_speed_level - fan_diff_required;
4221
4222 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4223 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4224
4225 if (fan_speed_new != fan_speed_cur)
4226 {
4227 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4228 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4229
4230 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4231 {
4232 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4233 {
4234 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4235 }
4236 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4237 {
4238 #ifdef _POSIX
4239 hm_set_fanspeed_with_device_id_xnvctrl (device_id, fan_speed_new);
4240 #endif
4241 }
4242
4243 fan_speed_chgd[device_id] = 1;
4244 }
4245
4246 temp_diff_old[device_id] = temp_diff_new;
4247 }
4248 }
4249 }
4250 }
4251 }
4252
4253 hc_thread_mutex_unlock (mux_adl);
4254 }
4255 #endif // HAVE_HWMON
4256
4257 if (restore_check == 1)
4258 {
4259 restore_left--;
4260
4261 if (restore_left == 0)
4262 {
4263 if (data.restore_disable == 0) cycle_restore ();
4264
4265 restore_left = data.restore_timer;
4266 }
4267 }
4268
4269 if ((runtime_check == 1) && (data.runtime_start > 0))
4270 {
4271 time_t runtime_cur;
4272
4273 time (&runtime_cur);
4274
4275 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4276
4277 if (runtime_left <= 0)
4278 {
4279 if (data.benchmark == 0)
4280 {
4281 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4282 }
4283
4284 if (data.devices_status != STATUS_QUIT) myabort ();
4285 }
4286 }
4287
4288 if (remove_check == 1)
4289 {
4290 remove_left--;
4291
4292 if (remove_left == 0)
4293 {
4294 if (data.digests_saved != data.digests_done)
4295 {
4296 data.digests_saved = data.digests_done;
4297
4298 save_hash ();
4299 }
4300
4301 remove_left = data.remove_timer;
4302 }
4303 }
4304
4305 if (status_check == 1)
4306 {
4307 status_left--;
4308
4309 if (status_left == 0)
4310 {
4311 //hc_thread_mutex_lock (mux_display);
4312
4313 if (data.quiet == 0) clear_prompt ();
4314
4315 if (data.quiet == 0) log_info ("");
4316
4317 status_display ();
4318
4319 if (data.quiet == 0) log_info ("");
4320
4321 //hc_thread_mutex_unlock (mux_display);
4322
4323 status_left = data.status_timer;
4324 }
4325 }
4326 }
4327
4328 #ifdef HAVE_HWMON
4329 myfree (fan_speed_chgd);
4330
4331 myfree (temp_diff_old);
4332 myfree (temp_diff_sum);
4333 #endif
4334
4335 p = NULL;
4336
4337 return (p);
4338 }
4339
4340 static void *thread_outfile_remove (void *p)
4341 {
4342 // some hash-dependent constants
4343 char *outfile_dir = data.outfile_check_directory;
4344 uint dgst_size = data.dgst_size;
4345 uint isSalted = data.isSalted;
4346 uint esalt_size = data.esalt_size;
4347 uint hash_mode = data.hash_mode;
4348
4349 uint outfile_check_timer = data.outfile_check_timer;
4350
4351 char separator = data.separator;
4352
4353 // some hash-dependent functions
4354 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4355 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4356
4357 // buffers
4358 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4359
4360 hash_buf.digest = mymalloc (dgst_size);
4361
4362 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4363
4364 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4365
4366 uint digest_buf[64] = { 0 };
4367
4368 outfile_data_t *out_info = NULL;
4369
4370 char **out_files = NULL;
4371
4372 time_t folder_mtime = 0;
4373
4374 int out_cnt = 0;
4375
4376 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4377
4378 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4379 {
4380 hc_sleep (1);
4381
4382 if (data.devices_status != STATUS_RUNNING) continue;
4383
4384 check_left--;
4385
4386 if (check_left == 0)
4387 {
4388 struct stat outfile_check_stat;
4389
4390 if (stat (outfile_dir, &outfile_check_stat) == 0)
4391 {
4392 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4393
4394 if (is_dir == 1)
4395 {
4396 if (outfile_check_stat.st_mtime > folder_mtime)
4397 {
4398 char **out_files_new = scan_directory (outfile_dir);
4399
4400 int out_cnt_new = count_dictionaries (out_files_new);
4401
4402 outfile_data_t *out_info_new = NULL;
4403
4404 if (out_cnt_new > 0)
4405 {
4406 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4407
4408 for (int i = 0; i < out_cnt_new; i++)
4409 {
4410 out_info_new[i].file_name = out_files_new[i];
4411
4412 // check if there are files that we have seen/checked before (and not changed)
4413
4414 for (int j = 0; j < out_cnt; j++)
4415 {
4416 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4417 {
4418 struct stat outfile_stat;
4419
4420 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4421 {
4422 if (outfile_stat.st_ctime == out_info[j].ctime)
4423 {
4424 out_info_new[i].ctime = out_info[j].ctime;
4425 out_info_new[i].seek = out_info[j].seek;
4426 }
4427 }
4428 }
4429 }
4430 }
4431 }
4432
4433 local_free (out_info);
4434 local_free (out_files);
4435
4436 out_files = out_files_new;
4437 out_cnt = out_cnt_new;
4438 out_info = out_info_new;
4439
4440 folder_mtime = outfile_check_stat.st_mtime;
4441 }
4442
4443 for (int j = 0; j < out_cnt; j++)
4444 {
4445 FILE *fp = fopen (out_info[j].file_name, "rb");
4446
4447 if (fp != NULL)
4448 {
4449 //hc_thread_mutex_lock (mux_display);
4450
4451 #ifdef _POSIX
4452 struct stat outfile_stat;
4453
4454 fstat (fileno (fp), &outfile_stat);
4455 #endif
4456
4457 #ifdef _WIN
4458 struct stat64 outfile_stat;
4459
4460 _fstat64 (fileno (fp), &outfile_stat);
4461 #endif
4462
4463 if (outfile_stat.st_ctime > out_info[j].ctime)
4464 {
4465 out_info[j].ctime = outfile_stat.st_ctime;
4466 out_info[j].seek = 0;
4467 }
4468
4469 fseek (fp, out_info[j].seek, SEEK_SET);
4470
4471 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4472
4473 while (!feof (fp))
4474 {
4475 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4476
4477 if (ptr == NULL) break;
4478
4479 int line_len = strlen (line_buf);
4480
4481 if (line_len <= 0) continue;
4482
4483 int iter = MAX_CUT_TRIES;
4484
4485 for (uint i = line_len - 1; i && iter; i--, line_len--)
4486 {
4487 if (line_buf[i] != separator) continue;
4488
4489 int parser_status = PARSER_OK;
4490
4491 if ((hash_mode != 2500) && (hash_mode != 6800))
4492 {
4493 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4494 }
4495
4496 uint found = 0;
4497
4498 if (parser_status == PARSER_OK)
4499 {
4500 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4501 {
4502 if (data.salts_shown[salt_pos] == 1) continue;
4503
4504 salt_t *salt_buf = &data.salts_buf[salt_pos];
4505
4506 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4507 {
4508 uint idx = salt_buf->digests_offset + digest_pos;
4509
4510 if (data.digests_shown[idx] == 1) continue;
4511
4512 uint cracked = 0;
4513
4514 if (hash_mode == 6800)
4515 {
4516 if (i == salt_buf->salt_len)
4517 {
4518 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4519 }
4520 }
4521 else if (hash_mode == 2500)
4522 {
4523 // BSSID : MAC1 : MAC2 (:plain)
4524 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4525 {
4526 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4527
4528 if (!cracked) continue;
4529
4530 // now compare MAC1 and MAC2 too, since we have this additional info
4531 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4532 char *mac2_pos = mac1_pos + 12 + 1;
4533
4534 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4535 wpa_t *wpa = &wpas[salt_pos];
4536
4537 // compare hex string(s) vs binary MAC address(es)
4538
4539 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4540 {
4541 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4542 {
4543 cracked = 0;
4544
4545 break;
4546 }
4547 }
4548
4549 // early skip ;)
4550 if (!cracked) continue;
4551
4552 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4553 {
4554 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4555 {
4556 cracked = 0;
4557
4558 break;
4559 }
4560 }
4561 }
4562 }
4563 else
4564 {
4565 char *digests_buf_ptr = (char *) data.digests_buf;
4566
4567 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4568
4569 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4570 }
4571
4572 if (cracked == 1)
4573 {
4574 found = 1;
4575
4576 data.digests_shown[idx] = 1;
4577
4578 data.digests_done++;
4579
4580 salt_buf->digests_done++;
4581
4582 if (salt_buf->digests_done == salt_buf->digests_cnt)
4583 {
4584 data.salts_shown[salt_pos] = 1;
4585
4586 data.salts_done++;
4587
4588 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4589 }
4590 }
4591 }
4592
4593 if (data.devices_status == STATUS_CRACKED) break;
4594 }
4595 }
4596
4597 if (found) break;
4598
4599 if (data.devices_status == STATUS_CRACKED) break;
4600
4601 iter--;
4602 }
4603
4604 if (data.devices_status == STATUS_CRACKED) break;
4605 }
4606
4607 myfree (line_buf);
4608
4609 out_info[j].seek = ftell (fp);
4610
4611 //hc_thread_mutex_unlock (mux_display);
4612
4613 fclose (fp);
4614 }
4615 }
4616 }
4617 }
4618
4619 check_left = outfile_check_timer;
4620 }
4621 }
4622
4623 if (esalt_size) local_free (hash_buf.esalt);
4624
4625 if (isSalted) local_free (hash_buf.salt);
4626
4627 local_free (hash_buf.digest);
4628
4629 local_free (out_info);
4630
4631 local_free (out_files);
4632
4633 p = NULL;
4634
4635 return (p);
4636 }
4637
4638 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4639 {
4640 //if (device_param->pws_cnt < device_param->kernel_power)
4641 //{
4642 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4643
4644 u8 *ptr = (u8 *) pw->i;
4645
4646 memcpy (ptr, pw_buf, pw_len);
4647
4648 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4649
4650 pw->pw_len = pw_len;
4651
4652 device_param->pws_cnt++;
4653 //}
4654 //else
4655 //{
4656 // fprintf (stderr, "BUG pw_add()!!\n");
4657 //
4658 // return;
4659 //}
4660 }
4661
4662 static void set_kernel_power_final (const u64 kernel_power_final)
4663 {
4664 if (data.quiet == 0)
4665 {
4666 clear_prompt ();
4667
4668 //log_info ("");
4669
4670 log_info ("INFO: approaching final keyspace, workload adjusted");
4671 log_info ("");
4672
4673 fprintf (stdout, "%s", PROMPT);
4674
4675 fflush (stdout);
4676 }
4677
4678 data.kernel_power_final = kernel_power_final;
4679 }
4680
4681 static u32 get_power (hc_device_param_t *device_param)
4682 {
4683 const u64 kernel_power_final = data.kernel_power_final;
4684
4685 if (kernel_power_final)
4686 {
4687 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4688
4689 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4690
4691 // work should be at least the hardware power available without any accelerator
4692
4693 const u64 work = MAX (words_left_device, device_param->hardware_power);
4694
4695 return work;
4696 }
4697
4698 return device_param->kernel_power;
4699 }
4700
4701 static uint get_work (hc_device_param_t *device_param, const u64 max)
4702 {
4703 hc_thread_mutex_lock (mux_dispatcher);
4704
4705 const u64 words_cur = data.words_cur;
4706 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4707
4708 device_param->words_off = words_cur;
4709
4710 const u64 kernel_power_all = data.kernel_power_all;
4711
4712 const u64 words_left = words_base - words_cur;
4713
4714 if (words_left < kernel_power_all)
4715 {
4716 if (data.kernel_power_final == 0)
4717 {
4718 set_kernel_power_final (words_left);
4719 }
4720 }
4721
4722 const u32 kernel_power = get_power (device_param);
4723
4724 uint work = MIN (words_left, kernel_power);
4725
4726 work = MIN (work, max);
4727
4728 data.words_cur += work;
4729
4730 hc_thread_mutex_unlock (mux_dispatcher);
4731
4732 return work;
4733 }
4734
4735 static void *thread_autotune (void *p)
4736 {
4737 hc_device_param_t *device_param = (hc_device_param_t *) p;
4738
4739 if (device_param->skipped) return NULL;
4740
4741 autotune (device_param);
4742
4743 return NULL;
4744 }
4745
4746 static void *thread_calc_stdin (void *p)
4747 {
4748 hc_device_param_t *device_param = (hc_device_param_t *) p;
4749
4750 if (device_param->skipped) return NULL;
4751
4752 char *buf = (char *) mymalloc (HCBUFSIZ);
4753
4754 const uint attack_kern = data.attack_kern;
4755
4756 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4757 {
4758 hc_thread_mutex_lock (mux_dispatcher);
4759
4760 if (feof (stdin) != 0)
4761 {
4762 hc_thread_mutex_unlock (mux_dispatcher);
4763
4764 break;
4765 }
4766
4767 uint words_cur = 0;
4768
4769 while (words_cur < device_param->kernel_power)
4770 {
4771 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4772
4773 if (line_buf == NULL) break;
4774
4775 uint line_len = in_superchop (line_buf);
4776
4777 line_len = convert_from_hex (line_buf, line_len);
4778
4779 // post-process rule engine
4780
4781 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4782 {
4783 char rule_buf_out[BLOCK_SIZE] = { 0 };
4784
4785 int rule_len_out = -1;
4786
4787 if (line_len < BLOCK_SIZE)
4788 {
4789 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4790 }
4791
4792 if (rule_len_out < 0) continue;
4793
4794 line_buf = rule_buf_out;
4795 line_len = rule_len_out;
4796 }
4797
4798 if (line_len > PW_MAX)
4799 {
4800 continue;
4801 }
4802
4803 // hmm that's always the case, or?
4804
4805 if (attack_kern == ATTACK_KERN_STRAIGHT)
4806 {
4807 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4808 {
4809 hc_thread_mutex_lock (mux_counter);
4810
4811 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4812 {
4813 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4814 }
4815
4816 hc_thread_mutex_unlock (mux_counter);
4817
4818 continue;
4819 }
4820 }
4821
4822 pw_add (device_param, (u8 *) line_buf, line_len);
4823
4824 words_cur++;
4825
4826 if (data.devices_status == STATUS_CRACKED) break;
4827 if (data.devices_status == STATUS_ABORTED) break;
4828 if (data.devices_status == STATUS_QUIT) break;
4829 if (data.devices_status == STATUS_BYPASS) break;
4830 }
4831
4832 hc_thread_mutex_unlock (mux_dispatcher);
4833
4834 if (data.devices_status == STATUS_CRACKED) break;
4835 if (data.devices_status == STATUS_ABORTED) break;
4836 if (data.devices_status == STATUS_QUIT) break;
4837 if (data.devices_status == STATUS_BYPASS) break;
4838
4839 // flush
4840
4841 const uint pws_cnt = device_param->pws_cnt;
4842
4843 if (pws_cnt)
4844 {
4845 run_copy (device_param, pws_cnt);
4846
4847 run_cracker (device_param, pws_cnt);
4848
4849 device_param->pws_cnt = 0;
4850
4851 /*
4852 still required?
4853 if (attack_kern == ATTACK_KERN_STRAIGHT)
4854 {
4855 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4856 }
4857 else if (attack_kern == ATTACK_KERN_COMBI)
4858 {
4859 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4860 }
4861 */
4862 }
4863 }
4864
4865 device_param->kernel_accel = 0;
4866 device_param->kernel_loops = 0;
4867
4868 myfree (buf);
4869
4870 return NULL;
4871 }
4872
4873 static void *thread_calc (void *p)
4874 {
4875 hc_device_param_t *device_param = (hc_device_param_t *) p;
4876
4877 if (device_param->skipped) return NULL;
4878
4879 const uint attack_mode = data.attack_mode;
4880 const uint attack_kern = data.attack_kern;
4881
4882 if (attack_mode == ATTACK_MODE_BF)
4883 {
4884 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4885 {
4886 const uint work = get_work (device_param, -1);
4887
4888 if (work == 0) break;
4889
4890 const u64 words_off = device_param->words_off;
4891 const u64 words_fin = words_off + work;
4892
4893 const uint pws_cnt = work;
4894
4895 device_param->pws_cnt = pws_cnt;
4896
4897 if (pws_cnt)
4898 {
4899 run_copy (device_param, pws_cnt);
4900
4901 run_cracker (device_param, pws_cnt);
4902
4903 device_param->pws_cnt = 0;
4904
4905 /*
4906 still required?
4907 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4908 */
4909 }
4910
4911 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4912
4913 if (data.devices_status == STATUS_CRACKED) break;
4914 if (data.devices_status == STATUS_ABORTED) break;
4915 if (data.devices_status == STATUS_QUIT) break;
4916 if (data.devices_status == STATUS_BYPASS) break;
4917
4918 if (data.benchmark == 1) break;
4919
4920 device_param->words_done = words_fin;
4921 }
4922 }
4923 else
4924 {
4925 const uint segment_size = data.segment_size;
4926
4927 char *dictfile = data.dictfile;
4928
4929 if (attack_mode == ATTACK_MODE_COMBI)
4930 {
4931 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4932 {
4933 dictfile = data.dictfile2;
4934 }
4935 }
4936
4937 FILE *fd = fopen (dictfile, "rb");
4938
4939 if (fd == NULL)
4940 {
4941 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4942
4943 return NULL;
4944 }
4945
4946 if (attack_mode == ATTACK_MODE_COMBI)
4947 {
4948 const uint combs_mode = data.combs_mode;
4949
4950 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4951 {
4952 const char *dictfilec = data.dictfile2;
4953
4954 FILE *combs_fp = fopen (dictfilec, "rb");
4955
4956 if (combs_fp == NULL)
4957 {
4958 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4959
4960 fclose (fd);
4961
4962 return NULL;
4963 }
4964
4965 device_param->combs_fp = combs_fp;
4966 }
4967 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4968 {
4969 const char *dictfilec = data.dictfile;
4970
4971 FILE *combs_fp = fopen (dictfilec, "rb");
4972
4973 if (combs_fp == NULL)
4974 {
4975 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4976
4977 fclose (fd);
4978
4979 return NULL;
4980 }
4981
4982 device_param->combs_fp = combs_fp;
4983 }
4984 }
4985
4986 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4987
4988 wl_data->buf = (char *) mymalloc (segment_size);
4989 wl_data->avail = segment_size;
4990 wl_data->incr = segment_size;
4991 wl_data->cnt = 0;
4992 wl_data->pos = 0;
4993
4994 u64 words_cur = 0;
4995
4996 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4997 {
4998 u64 words_off = 0;
4999 u64 words_fin = 0;
5000
5001 u64 max = -1;
5002
5003 while (max)
5004 {
5005 const uint work = get_work (device_param, max);
5006
5007 if (work == 0) break;
5008
5009 max = 0;
5010
5011 words_off = device_param->words_off;
5012 words_fin = words_off + work;
5013
5014 char *line_buf;
5015 uint line_len;
5016
5017 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5018
5019 for ( ; words_cur < words_fin; words_cur++)
5020 {
5021 get_next_word (wl_data, fd, &line_buf, &line_len);
5022
5023 line_len = convert_from_hex (line_buf, line_len);
5024
5025 // post-process rule engine
5026
5027 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5028 {
5029 char rule_buf_out[BLOCK_SIZE] = { 0 };
5030
5031 int rule_len_out = -1;
5032
5033 if (line_len < BLOCK_SIZE)
5034 {
5035 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5036 }
5037
5038 if (rule_len_out < 0) continue;
5039
5040 line_buf = rule_buf_out;
5041 line_len = rule_len_out;
5042 }
5043
5044 if (attack_kern == ATTACK_KERN_STRAIGHT)
5045 {
5046 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5047 {
5048 max++;
5049
5050 hc_thread_mutex_lock (mux_counter);
5051
5052 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5053 {
5054 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5055 }
5056
5057 hc_thread_mutex_unlock (mux_counter);
5058
5059 continue;
5060 }
5061 }
5062 else if (attack_kern == ATTACK_KERN_COMBI)
5063 {
5064 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5065 // since we still need to combine the plains
5066
5067 if (line_len > data.pw_max)
5068 {
5069 max++;
5070
5071 hc_thread_mutex_lock (mux_counter);
5072
5073 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5074 {
5075 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5076 }
5077
5078 hc_thread_mutex_unlock (mux_counter);
5079
5080 continue;
5081 }
5082 }
5083
5084 pw_add (device_param, (u8 *) line_buf, line_len);
5085
5086 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5087
5088 if (data.devices_status == STATUS_CRACKED) break;
5089 if (data.devices_status == STATUS_ABORTED) break;
5090 if (data.devices_status == STATUS_QUIT) break;
5091 if (data.devices_status == STATUS_BYPASS) break;
5092 }
5093
5094 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5095
5096 if (data.devices_status == STATUS_CRACKED) break;
5097 if (data.devices_status == STATUS_ABORTED) break;
5098 if (data.devices_status == STATUS_QUIT) break;
5099 if (data.devices_status == STATUS_BYPASS) break;
5100 }
5101
5102 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5103
5104 if (data.devices_status == STATUS_CRACKED) break;
5105 if (data.devices_status == STATUS_ABORTED) break;
5106 if (data.devices_status == STATUS_QUIT) break;
5107 if (data.devices_status == STATUS_BYPASS) break;
5108
5109 //
5110 // flush
5111 //
5112
5113 const uint pws_cnt = device_param->pws_cnt;
5114
5115 if (pws_cnt)
5116 {
5117 run_copy (device_param, pws_cnt);
5118
5119 run_cracker (device_param, pws_cnt);
5120
5121 device_param->pws_cnt = 0;
5122
5123 /*
5124 still required?
5125 if (attack_kern == ATTACK_KERN_STRAIGHT)
5126 {
5127 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5128 }
5129 else if (attack_kern == ATTACK_KERN_COMBI)
5130 {
5131 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5132 }
5133 */
5134 }
5135
5136 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5137
5138 if (data.devices_status == STATUS_CRACKED) break;
5139 if (data.devices_status == STATUS_ABORTED) break;
5140 if (data.devices_status == STATUS_QUIT) break;
5141 if (data.devices_status == STATUS_BYPASS) break;
5142
5143 if (words_fin == 0) break;
5144
5145 device_param->words_done = words_fin;
5146 }
5147
5148 if (attack_mode == ATTACK_MODE_COMBI)
5149 {
5150 fclose (device_param->combs_fp);
5151 }
5152
5153 free (wl_data->buf);
5154 free (wl_data);
5155
5156 fclose (fd);
5157 }
5158
5159 device_param->kernel_accel = 0;
5160 device_param->kernel_loops = 0;
5161
5162 return NULL;
5163 }
5164
5165 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5166 {
5167 if (!device_param)
5168 {
5169 log_error ("ERROR: %s : Invalid argument", __func__);
5170
5171 exit (-1);
5172 }
5173
5174 salt_t *salt_buf = &data.salts_buf[salt_pos];
5175
5176 device_param->kernel_params_buf32[24] = salt_pos;
5177 device_param->kernel_params_buf32[27] = 1;
5178 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
5179 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
5180 device_param->kernel_params_buf32[30] = 0;
5181 device_param->kernel_params_buf32[31] = 1;
5182
5183 char *dictfile_old = data.dictfile;
5184
5185 const char *weak_hash_check = "weak-hash-check";
5186
5187 data.dictfile = (char *) weak_hash_check;
5188
5189 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5190
5191 data.kernel_rules_buf[0].cmds[0] = 0;
5192
5193 /**
5194 * run the kernel
5195 */
5196
5197 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5198 {
5199 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5200 }
5201 else
5202 {
5203 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5204
5205 uint loop_step = 16;
5206
5207 const uint iter = salt_buf->salt_iter;
5208
5209 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5210 {
5211 uint loop_left = iter - loop_pos;
5212
5213 loop_left = MIN (loop_left, loop_step);
5214
5215 device_param->kernel_params_buf32[25] = loop_pos;
5216 device_param->kernel_params_buf32[26] = loop_left;
5217
5218 run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5219 }
5220
5221 run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5222 }
5223
5224 /**
5225 * result
5226 */
5227
5228 check_cracked (device_param, salt_pos);
5229
5230 /**
5231 * cleanup
5232 */
5233
5234 device_param->kernel_params_buf32[24] = 0;
5235 device_param->kernel_params_buf32[25] = 0;
5236 device_param->kernel_params_buf32[26] = 0;
5237 device_param->kernel_params_buf32[27] = 0;
5238 device_param->kernel_params_buf32[28] = 0;
5239 device_param->kernel_params_buf32[29] = 0;
5240 device_param->kernel_params_buf32[30] = 0;
5241 device_param->kernel_params_buf32[31] = 0;
5242
5243 data.dictfile = dictfile_old;
5244
5245 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5246 }
5247
5248 // hlfmt hashcat
5249
5250 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5251 {
5252 if (data.username == 0)
5253 {
5254 *hashbuf_pos = line_buf;
5255 *hashbuf_len = line_len;
5256 }
5257 else
5258 {
5259 char *pos = line_buf;
5260 int len = line_len;
5261
5262 for (int i = 0; i < line_len; i++, pos++, len--)
5263 {
5264 if (line_buf[i] == data.separator)
5265 {
5266 pos++;
5267
5268 len--;
5269
5270 break;
5271 }
5272 }
5273
5274 *hashbuf_pos = pos;
5275 *hashbuf_len = len;
5276 }
5277 }
5278
5279 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5280 {
5281 char *pos = NULL;
5282 int len = 0;
5283
5284 int sep_cnt = 0;
5285
5286 for (int i = 0; i < line_len; i++)
5287 {
5288 if (line_buf[i] == data.separator)
5289 {
5290 sep_cnt++;
5291
5292 continue;
5293 }
5294
5295 if (sep_cnt == 0)
5296 {
5297 if (pos == NULL) pos = line_buf + i;
5298
5299 len++;
5300 }
5301 }
5302
5303 *userbuf_pos = pos;
5304 *userbuf_len = len;
5305 }
5306
5307 // hlfmt pwdump
5308
5309 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5310 {
5311 int sep_cnt = 0;
5312
5313 int sep2_len = 0;
5314 int sep3_len = 0;
5315
5316 for (int i = 0; i < line_len; i++)
5317 {
5318 if (line_buf[i] == ':')
5319 {
5320 sep_cnt++;
5321
5322 continue;
5323 }
5324
5325 if (sep_cnt == 2) sep2_len++;
5326 if (sep_cnt == 3) sep3_len++;
5327 }
5328
5329 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5330
5331 return 0;
5332 }
5333
5334 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5335 {
5336 char *pos = NULL;
5337 int len = 0;
5338
5339 int sep_cnt = 0;
5340
5341 for (int i = 0; i < line_len; i++)
5342 {
5343 if (line_buf[i] == ':')
5344 {
5345 sep_cnt++;
5346
5347 continue;
5348 }
5349
5350 if (data.hash_mode == 1000)
5351 {
5352 if (sep_cnt == 3)
5353 {
5354 if (pos == NULL) pos = line_buf + i;
5355
5356 len++;
5357 }
5358 }
5359 else if (data.hash_mode == 3000)
5360 {
5361 if (sep_cnt == 2)
5362 {
5363 if (pos == NULL) pos = line_buf + i;
5364
5365 len++;
5366 }
5367 }
5368 }
5369
5370 *hashbuf_pos = pos;
5371 *hashbuf_len = len;
5372 }
5373
5374 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5375 {
5376 char *pos = NULL;
5377 int len = 0;
5378
5379 int sep_cnt = 0;
5380
5381 for (int i = 0; i < line_len; i++)
5382 {
5383 if (line_buf[i] == ':')
5384 {
5385 sep_cnt++;
5386
5387 continue;
5388 }
5389
5390 if (sep_cnt == 0)
5391 {
5392 if (pos == NULL) pos = line_buf + i;
5393
5394 len++;
5395 }
5396 }
5397
5398 *userbuf_pos = pos;
5399 *userbuf_len = len;
5400 }
5401
5402 // hlfmt passwd
5403
5404 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5405 {
5406 int sep_cnt = 0;
5407
5408 char sep5_first = 0;
5409 char sep6_first = 0;
5410
5411 for (int i = 0; i < line_len; i++)
5412 {
5413 if (line_buf[i] == ':')
5414 {
5415 sep_cnt++;
5416
5417 continue;
5418 }
5419
5420 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5421 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5422 }
5423
5424 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5425
5426 return 0;
5427 }
5428
5429 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5430 {
5431 char *pos = NULL;
5432 int len = 0;
5433
5434 int sep_cnt = 0;
5435
5436 for (int i = 0; i < line_len; i++)
5437 {
5438 if (line_buf[i] == ':')
5439 {
5440 sep_cnt++;
5441
5442 continue;
5443 }
5444
5445 if (sep_cnt == 1)
5446 {
5447 if (pos == NULL) pos = line_buf + i;
5448
5449 len++;
5450 }
5451 }
5452
5453 *hashbuf_pos = pos;
5454 *hashbuf_len = len;
5455 }
5456
5457 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5458 {
5459 char *pos = NULL;
5460 int len = 0;
5461
5462 int sep_cnt = 0;
5463
5464 for (int i = 0; i < line_len; i++)
5465 {
5466 if (line_buf[i] == ':')
5467 {
5468 sep_cnt++;
5469
5470 continue;
5471 }
5472
5473 if (sep_cnt == 0)
5474 {
5475 if (pos == NULL) pos = line_buf + i;
5476
5477 len++;
5478 }
5479 }
5480
5481 *userbuf_pos = pos;
5482 *userbuf_len = len;
5483 }
5484
5485 // hlfmt shadow
5486
5487 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5488 {
5489 int sep_cnt = 0;
5490
5491 for (int i = 0; i < line_len; i++)
5492 {
5493 if (line_buf[i] == ':') sep_cnt++;
5494 }
5495
5496 if (sep_cnt == 8) return 1;
5497
5498 return 0;
5499 }
5500
5501 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5502 {
5503 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5504 }
5505
5506 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5507 {
5508 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5509 }
5510
5511 // hlfmt main
5512
5513 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5514 {
5515 switch (hashfile_format)
5516 {
5517 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5518 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5519 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5520 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5521 }
5522 }
5523
5524 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5525 {
5526 switch (hashfile_format)
5527 {
5528 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5529 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5530 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5531 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5532 }
5533 }
5534
5535 char *strhlfmt (const uint hashfile_format)
5536 {
5537 switch (hashfile_format)
5538 {
5539 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5540 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5541 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5542 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5543 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5544 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5545 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5546 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5547 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5548 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5549 }
5550
5551 return ((char *) "Unknown");
5552 }
5553
5554 static uint hlfmt_detect (FILE *fp, uint max_check)
5555 {
5556 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5557
5558 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5559 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5560
5561 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5562
5563 uint num_check = 0;
5564
5565 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5566
5567 while (!feof (fp))
5568 {
5569 int line_len = fgetl (fp, line_buf);
5570
5571 if (line_len == 0) continue;
5572
5573 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5574 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5575 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5576
5577 if (num_check == max_check) break;
5578
5579 num_check++;
5580 }
5581
5582 myfree (line_buf);
5583
5584 uint hashlist_format = HLFMT_HASHCAT;
5585
5586 for (int i = 1; i < HLFMTS_CNT; i++)
5587 {
5588 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5589
5590 hashlist_format = i;
5591 }
5592
5593 free (formats_cnt);
5594
5595 return hashlist_format;
5596 }
5597
5598 /**
5599 * some further helper function
5600 */
5601
5602 // wrapper around mymalloc for ADL
5603
5604 #if defined(HAVE_HWMON)
5605 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5606 {
5607 return mymalloc (iSize);
5608 }
5609 #endif
5610
5611 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)
5612 {
5613 u64 collisions = 0;
5614
5615 const uint dgst_pos0 = data.dgst_pos0;
5616 const uint dgst_pos1 = data.dgst_pos1;
5617 const uint dgst_pos2 = data.dgst_pos2;
5618 const uint dgst_pos3 = data.dgst_pos3;
5619
5620 memset (bitmap_a, 0, bitmap_size);
5621 memset (bitmap_b, 0, bitmap_size);
5622 memset (bitmap_c, 0, bitmap_size);
5623 memset (bitmap_d, 0, bitmap_size);
5624
5625 for (uint i = 0; i < digests_cnt; i++)
5626 {
5627 uint *digest_ptr = (uint *) digests_buf_ptr;
5628
5629 digests_buf_ptr += dgst_size;
5630
5631 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5632 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5633 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5634 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5635
5636 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5637 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5638 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5639 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5640
5641 if (bitmap_a[idx0] & val0) collisions++;
5642 if (bitmap_b[idx1] & val1) collisions++;
5643 if (bitmap_c[idx2] & val2) collisions++;
5644 if (bitmap_d[idx3] & val3) collisions++;
5645
5646 bitmap_a[idx0] |= val0;
5647 bitmap_b[idx1] |= val1;
5648 bitmap_c[idx2] |= val2;
5649 bitmap_d[idx3] |= val3;
5650
5651 if (collisions >= collisions_max) return 0x7fffffff;
5652 }
5653
5654 return collisions;
5655 }
5656
5657 /**
5658 * main
5659 */
5660
5661 #ifdef WIN
5662 void SetConsoleWindowSize (const int x)
5663 {
5664 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5665
5666 if (h == INVALID_HANDLE_VALUE) return;
5667
5668 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5669
5670 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5671
5672 SMALL_RECT *sr = &bufferInfo.srWindow;
5673
5674 sr->Right = MAX (sr->Right, x - 1);
5675
5676 COORD co;
5677
5678 co.X = sr->Right + 1;
5679 co.Y = 9999;
5680
5681 if (!SetConsoleScreenBufferSize (h, co)) return;
5682
5683 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5684 }
5685 #endif
5686
5687 int main (int argc, char **argv)
5688 {
5689 #ifdef WIN
5690 SetConsoleWindowSize (132);
5691 #endif
5692
5693 /**
5694 * To help users a bit
5695 */
5696
5697 char *compute = getenv ("COMPUTE");
5698
5699 if (compute)
5700 {
5701 static char display[100];
5702
5703 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5704
5705 putenv (display);
5706 }
5707 else
5708 {
5709 if (getenv ("DISPLAY") == NULL)
5710 putenv ((char *) "DISPLAY=:0");
5711 }
5712
5713 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5714 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5715
5716 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5717 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5718
5719 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5720 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5721
5722 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5723 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5724
5725 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5726 putenv ((char *) "POCL_KERNEL_CACHE=0");
5727
5728 umask (077);
5729
5730 /**
5731 * Real init
5732 */
5733
5734 memset (&data, 0, sizeof (hc_global_data_t));
5735
5736 time_t proc_start;
5737
5738 time (&proc_start);
5739
5740 data.proc_start = proc_start;
5741
5742 int myargc = argc;
5743 char **myargv = argv;
5744
5745 hc_thread_mutex_init (mux_dispatcher);
5746 hc_thread_mutex_init (mux_counter);
5747 hc_thread_mutex_init (mux_display);
5748 hc_thread_mutex_init (mux_adl);
5749
5750 /**
5751 * commandline parameters
5752 */
5753
5754 uint usage = USAGE;
5755 uint version = VERSION;
5756 uint quiet = QUIET;
5757 uint benchmark = BENCHMARK;
5758 uint stdout_flag = STDOUT_FLAG;
5759 uint show = SHOW;
5760 uint left = LEFT;
5761 uint username = USERNAME;
5762 uint remove = REMOVE;
5763 uint remove_timer = REMOVE_TIMER;
5764 u64 skip = SKIP;
5765 u64 limit = LIMIT;
5766 uint keyspace = KEYSPACE;
5767 uint potfile_disable = POTFILE_DISABLE;
5768 char *potfile_path = NULL;
5769 uint debug_mode = DEBUG_MODE;
5770 char *debug_file = NULL;
5771 char *induction_dir = NULL;
5772 char *outfile_check_dir = NULL;
5773 uint force = FORCE;
5774 uint runtime = RUNTIME;
5775 uint hash_mode = HASH_MODE;
5776 uint attack_mode = ATTACK_MODE;
5777 uint markov_disable = MARKOV_DISABLE;
5778 uint markov_classic = MARKOV_CLASSIC;
5779 uint markov_threshold = MARKOV_THRESHOLD;
5780 char *markov_hcstat = NULL;
5781 char *outfile = NULL;
5782 uint outfile_format = OUTFILE_FORMAT;
5783 uint outfile_autohex = OUTFILE_AUTOHEX;
5784 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5785 uint restore = RESTORE;
5786 uint restore_timer = RESTORE_TIMER;
5787 uint restore_disable = RESTORE_DISABLE;
5788 uint status = STATUS;
5789 uint status_timer = STATUS_TIMER;
5790 uint machine_readable = MACHINE_READABLE;
5791 uint loopback = LOOPBACK;
5792 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5793 char *session = NULL;
5794 uint hex_charset = HEX_CHARSET;
5795 uint hex_salt = HEX_SALT;
5796 uint hex_wordlist = HEX_WORDLIST;
5797 uint rp_gen = RP_GEN;
5798 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5799 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5800 uint rp_gen_seed = RP_GEN_SEED;
5801 char *rule_buf_l = (char *) RULE_BUF_L;
5802 char *rule_buf_r = (char *) RULE_BUF_R;
5803 uint increment = INCREMENT;
5804 uint increment_min = INCREMENT_MIN;
5805 uint increment_max = INCREMENT_MAX;
5806 char *cpu_affinity = NULL;
5807 OCL_PTR *ocl = NULL;
5808 char *opencl_devices = NULL;
5809 char *opencl_platforms = NULL;
5810 char *opencl_device_types = NULL;
5811 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5812 char *truecrypt_keyfiles = NULL;
5813 char *veracrypt_keyfiles = NULL;
5814 uint veracrypt_pim = 0;
5815 uint workload_profile = WORKLOAD_PROFILE;
5816 uint kernel_accel = KERNEL_ACCEL;
5817 uint kernel_loops = KERNEL_LOOPS;
5818 uint nvidia_spin_damp = NVIDIA_SPIN_DAMP;
5819 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5820 #ifdef HAVE_HWMON
5821 uint gpu_temp_abort = GPU_TEMP_ABORT;
5822 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5823 uint powertune_enable = POWERTUNE_ENABLE;
5824 #endif
5825 uint logfile_disable = LOGFILE_DISABLE;
5826 uint segment_size = SEGMENT_SIZE;
5827 uint scrypt_tmto = SCRYPT_TMTO;
5828 char separator = SEPARATOR;
5829 uint bitmap_min = BITMAP_MIN;
5830 uint bitmap_max = BITMAP_MAX;
5831 char *custom_charset_1 = NULL;
5832 char *custom_charset_2 = NULL;
5833 char *custom_charset_3 = NULL;
5834 char *custom_charset_4 = NULL;
5835
5836 #define IDX_HELP 'h'
5837 #define IDX_VERSION 'V'
5838 #define IDX_VERSION_LOWER 'v'
5839 #define IDX_QUIET 0xff02
5840 #define IDX_SHOW 0xff03
5841 #define IDX_LEFT 0xff04
5842 #define IDX_REMOVE 0xff05
5843 #define IDX_REMOVE_TIMER 0xff37
5844 #define IDX_SKIP 's'
5845 #define IDX_LIMIT 'l'
5846 #define IDX_KEYSPACE 0xff35
5847 #define IDX_POTFILE_DISABLE 0xff06
5848 #define IDX_POTFILE_PATH 0xffe0
5849 #define IDX_DEBUG_MODE 0xff43
5850 #define IDX_DEBUG_FILE 0xff44
5851 #define IDX_INDUCTION_DIR 0xff46
5852 #define IDX_OUTFILE_CHECK_DIR 0xff47
5853 #define IDX_USERNAME 0xff07
5854 #define IDX_FORCE 0xff08
5855 #define IDX_RUNTIME 0xff09
5856 #define IDX_BENCHMARK 'b'
5857 #define IDX_STDOUT_FLAG 0xff77
5858 #define IDX_HASH_MODE 'm'
5859 #define IDX_ATTACK_MODE 'a'
5860 #define IDX_RP_FILE 'r'
5861 #define IDX_RP_GEN 'g'
5862 #define IDX_RP_GEN_FUNC_MIN 0xff10
5863 #define IDX_RP_GEN_FUNC_MAX 0xff11
5864 #define IDX_RP_GEN_SEED 0xff34
5865 #define IDX_RULE_BUF_L 'j'
5866 #define IDX_RULE_BUF_R 'k'
5867 #define IDX_INCREMENT 'i'
5868 #define IDX_INCREMENT_MIN 0xff12
5869 #define IDX_INCREMENT_MAX 0xff13
5870 #define IDX_OUTFILE 'o'
5871 #define IDX_OUTFILE_FORMAT 0xff14
5872 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5873 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5874 #define IDX_RESTORE 0xff15
5875 #define IDX_RESTORE_DISABLE 0xff27
5876 #define IDX_STATUS 0xff17
5877 #define IDX_STATUS_TIMER 0xff18
5878 #define IDX_MACHINE_READABLE 0xff50
5879 #define IDX_LOOPBACK 0xff38
5880 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5881 #define IDX_SESSION 0xff19
5882 #define IDX_HEX_CHARSET 0xff20
5883 #define IDX_HEX_SALT 0xff21
5884 #define IDX_HEX_WORDLIST 0xff40
5885 #define IDX_MARKOV_DISABLE 0xff22
5886 #define IDX_MARKOV_CLASSIC 0xff23
5887 #define IDX_MARKOV_THRESHOLD 't'
5888 #define IDX_MARKOV_HCSTAT 0xff24
5889 #define IDX_CPU_AFFINITY 0xff25
5890 #define IDX_OPENCL_DEVICES 'd'
5891 #define IDX_OPENCL_PLATFORMS 0xff72
5892 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5893 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5894 #define IDX_WORKLOAD_PROFILE 'w'
5895 #define IDX_KERNEL_ACCEL 'n'
5896 #define IDX_KERNEL_LOOPS 'u'
5897 #define IDX_NVIDIA_SPIN_DAMP 0xff79
5898 #define IDX_GPU_TEMP_DISABLE 0xff29
5899 #define IDX_GPU_TEMP_ABORT 0xff30
5900 #define IDX_GPU_TEMP_RETAIN 0xff31
5901 #define IDX_POWERTUNE_ENABLE 0xff41
5902 #define IDX_LOGFILE_DISABLE 0xff51
5903 #define IDX_TRUECRYPT_KEYFILES 0xff52
5904 #define IDX_VERACRYPT_KEYFILES 0xff53
5905 #define IDX_VERACRYPT_PIM 0xff54
5906 #define IDX_SCRYPT_TMTO 0xff61
5907 #define IDX_SEGMENT_SIZE 'c'
5908 #define IDX_SEPARATOR 'p'
5909 #define IDX_BITMAP_MIN 0xff70
5910 #define IDX_BITMAP_MAX 0xff71
5911 #define IDX_CUSTOM_CHARSET_1 '1'
5912 #define IDX_CUSTOM_CHARSET_2 '2'
5913 #define IDX_CUSTOM_CHARSET_3 '3'
5914 #define IDX_CUSTOM_CHARSET_4 '4'
5915
5916 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5917
5918 struct option long_options[] =
5919 {
5920 {"help", no_argument, 0, IDX_HELP},
5921 {"version", no_argument, 0, IDX_VERSION},
5922 {"quiet", no_argument, 0, IDX_QUIET},
5923 {"show", no_argument, 0, IDX_SHOW},
5924 {"left", no_argument, 0, IDX_LEFT},
5925 {"username", no_argument, 0, IDX_USERNAME},
5926 {"remove", no_argument, 0, IDX_REMOVE},
5927 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5928 {"skip", required_argument, 0, IDX_SKIP},
5929 {"limit", required_argument, 0, IDX_LIMIT},
5930 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5931 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5932 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5933 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5934 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5935 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5936 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5937 {"force", no_argument, 0, IDX_FORCE},
5938 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5939 {"stdout", no_argument, 0, IDX_STDOUT_FLAG},
5940 {"restore", no_argument, 0, IDX_RESTORE},
5941 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5942 {"status", no_argument, 0, IDX_STATUS},
5943 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5944 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5945 {"loopback", no_argument, 0, IDX_LOOPBACK},
5946 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5947 {"session", required_argument, 0, IDX_SESSION},
5948 {"runtime", required_argument, 0, IDX_RUNTIME},
5949 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5950 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5951 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5952 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5953 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5954 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5955 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5956 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5957 {"rules-file", required_argument, 0, IDX_RP_FILE},
5958 {"outfile", required_argument, 0, IDX_OUTFILE},
5959 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5960 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5961 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5962 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5963 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5964 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5965 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5966 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5967 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5968 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5969 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5970 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5971 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5972 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5973 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5974 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5975 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5976 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5977 {"nvidia-spin-damp", required_argument, 0, IDX_NVIDIA_SPIN_DAMP},
5978 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5979 #ifdef HAVE_HWMON
5980 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5981 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5982 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5983 #endif // HAVE_HWMON
5984 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5985 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5986 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5987 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5988 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5989 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5990 {"seperator", required_argument, 0, IDX_SEPARATOR},
5991 {"separator", required_argument, 0, IDX_SEPARATOR},
5992 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5993 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5994 {"increment", no_argument, 0, IDX_INCREMENT},
5995 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5996 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5997 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5998 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5999 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
6000 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
6001 {0, 0, 0, 0}
6002 };
6003
6004 uint rp_files_cnt = 0;
6005
6006 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6007
6008 int option_index = 0;
6009 int c = -1;
6010
6011 optind = 1;
6012 optopt = 0;
6013
6014 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6015 {
6016 switch (c)
6017 {
6018 case IDX_HELP: usage = 1; break;
6019 case IDX_VERSION:
6020 case IDX_VERSION_LOWER: version = 1; break;
6021 case IDX_RESTORE: restore = 1; break;
6022 case IDX_SESSION: session = optarg; break;
6023 case IDX_SHOW: show = 1; break;
6024 case IDX_LEFT: left = 1; break;
6025 case '?': return (-1);
6026 }
6027 }
6028
6029 if (optopt != 0)
6030 {
6031 log_error ("ERROR: Invalid argument specified");
6032
6033 return (-1);
6034 }
6035
6036 /**
6037 * exit functions
6038 */
6039
6040 if (version)
6041 {
6042 log_info ("%s", VERSION_TAG);
6043
6044 return (0);
6045 }
6046
6047 if (usage)
6048 {
6049 usage_big_print (PROGNAME);
6050
6051 return (0);
6052 }
6053
6054 /**
6055 * session needs to be set, always!
6056 */
6057
6058 if (session == NULL) session = (char *) PROGNAME;
6059
6060 /**
6061 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6062 */
6063
6064 char *exec_path = get_exec_path ();
6065
6066 #ifdef LINUX
6067
6068 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6069 char *resolved_exec_path = realpath (exec_path, NULL);
6070
6071 char *install_dir = get_install_dir (resolved_exec_path);
6072 char *profile_dir = NULL;
6073 char *session_dir = NULL;
6074 char *shared_dir = NULL;
6075
6076 if (strcmp (install_dir, resolved_install_folder) == 0)
6077 {
6078 struct passwd *pw = getpwuid (getuid ());
6079
6080 const char *homedir = pw->pw_dir;
6081
6082 profile_dir = get_profile_dir (homedir);
6083 session_dir = get_session_dir (profile_dir);
6084 shared_dir = strdup (SHARED_FOLDER);
6085
6086 mkdir (profile_dir, 0700);
6087 mkdir (session_dir, 0700);
6088 }
6089 else
6090 {
6091 profile_dir = install_dir;
6092 session_dir = install_dir;
6093 shared_dir = install_dir;
6094 }
6095
6096 myfree (resolved_install_folder);
6097 myfree (resolved_exec_path);
6098
6099 #else
6100
6101 char *install_dir = get_install_dir (exec_path);
6102 char *profile_dir = install_dir;
6103 char *session_dir = install_dir;
6104 char *shared_dir = install_dir;
6105
6106 #endif
6107
6108 data.install_dir = install_dir;
6109 data.profile_dir = profile_dir;
6110 data.session_dir = session_dir;
6111 data.shared_dir = shared_dir;
6112
6113 myfree (exec_path);
6114
6115 /**
6116 * kernel cache, we need to make sure folder exist
6117 */
6118
6119 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6120
6121 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6122
6123 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6124
6125 mkdir (kernels_folder, 0700);
6126
6127 myfree (kernels_folder);
6128
6129 /**
6130 * session
6131 */
6132
6133 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6134
6135 data.session = session;
6136
6137 char *eff_restore_file = (char *) mymalloc (session_size);
6138 char *new_restore_file = (char *) mymalloc (session_size);
6139
6140 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
6141 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6142
6143 data.eff_restore_file = eff_restore_file;
6144 data.new_restore_file = new_restore_file;
6145
6146 if (((show == 1) || (left == 1)) && (restore == 1))
6147 {
6148 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6149 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6150
6151 return (-1);
6152 }
6153
6154 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6155 if ((show == 1) || (left == 1))
6156 {
6157 restore_disable = 1;
6158
6159 restore = 0;
6160 }
6161
6162 data.restore_disable = restore_disable;
6163
6164 restore_data_t *rd = init_restore (argc, argv);
6165
6166 data.rd = rd;
6167
6168 /**
6169 * restore file
6170 */
6171
6172 if (restore == 1)
6173 {
6174 read_restore (eff_restore_file, rd);
6175
6176 if (rd->version_bin < RESTORE_MIN)
6177 {
6178 log_error ("ERROR: Incompatible restore-file version");
6179
6180 return (-1);
6181 }
6182
6183 myargc = rd->argc;
6184 myargv = rd->argv;
6185
6186 #ifdef _POSIX
6187 rd->pid = getpid ();
6188 #elif _WIN
6189 rd->pid = GetCurrentProcessId ();
6190 #endif
6191 }
6192
6193 uint hash_mode_chgd = 0;
6194 uint runtime_chgd = 0;
6195 uint kernel_loops_chgd = 0;
6196 uint kernel_accel_chgd = 0;
6197 uint nvidia_spin_damp_chgd = 0;
6198 uint attack_mode_chgd = 0;
6199 uint outfile_format_chgd = 0;
6200 uint rp_gen_seed_chgd = 0;
6201 uint remove_timer_chgd = 0;
6202 uint increment_min_chgd = 0;
6203 uint increment_max_chgd = 0;
6204 uint workload_profile_chgd = 0;
6205 uint opencl_vector_width_chgd = 0;
6206
6207 optind = 1;
6208 optopt = 0;
6209 option_index = 0;
6210
6211 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6212 {
6213 switch (c)
6214 {
6215 //case IDX_HELP: usage = 1; break;
6216 //case IDX_VERSION: version = 1; break;
6217 //case IDX_RESTORE: restore = 1; break;
6218 case IDX_QUIET: quiet = 1; break;
6219 //case IDX_SHOW: show = 1; break;
6220 case IDX_SHOW: break;
6221 //case IDX_LEFT: left = 1; break;
6222 case IDX_LEFT: break;
6223 case IDX_USERNAME: username = 1; break;
6224 case IDX_REMOVE: remove = 1; break;
6225 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6226 remove_timer_chgd = 1; break;
6227 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6228 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6229 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6230 case IDX_DEBUG_FILE: debug_file = optarg; break;
6231 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6232 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6233 case IDX_FORCE: force = 1; break;
6234 case IDX_SKIP: skip = atoll (optarg); break;
6235 case IDX_LIMIT: limit = atoll (optarg); break;
6236 case IDX_KEYSPACE: keyspace = 1; break;
6237 case IDX_BENCHMARK: benchmark = 1; break;
6238 case IDX_STDOUT_FLAG: stdout_flag = 1; break;
6239 case IDX_RESTORE: break;
6240 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6241 case IDX_STATUS: status = 1; break;
6242 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6243 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6244 case IDX_LOOPBACK: loopback = 1; break;
6245 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6246 //case IDX_SESSION: session = optarg; break;
6247 case IDX_SESSION: break;
6248 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6249 hash_mode_chgd = 1; break;
6250 case IDX_RUNTIME: runtime = atoi (optarg);
6251 runtime_chgd = 1; break;
6252 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6253 attack_mode_chgd = 1; break;
6254 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6255 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6256 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6257 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6258 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6259 rp_gen_seed_chgd = 1; break;
6260 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6261 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6262 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6263 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6264 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6265 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6266 case IDX_OUTFILE: outfile = optarg; break;
6267 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6268 outfile_format_chgd = 1; break;
6269 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6270 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6271 case IDX_HEX_CHARSET: hex_charset = 1; break;
6272 case IDX_HEX_SALT: hex_salt = 1; break;
6273 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6274 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6275 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6276 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6277 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6278 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6279 opencl_vector_width_chgd = 1; break;
6280 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6281 workload_profile_chgd = 1; break;
6282 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6283 kernel_accel_chgd = 1; break;
6284 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6285 kernel_loops_chgd = 1; break;
6286 case IDX_NVIDIA_SPIN_DAMP: nvidia_spin_damp = atoi (optarg);
6287 nvidia_spin_damp_chgd = 1; break;
6288 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6289 #ifdef HAVE_HWMON
6290 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6291 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6292 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6293 #endif // HAVE_HWMON
6294 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6295 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6296 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6297 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6298 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6299 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6300 case IDX_SEPARATOR: separator = optarg[0]; break;
6301 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6302 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6303 case IDX_INCREMENT: increment = 1; break;
6304 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6305 increment_min_chgd = 1; break;
6306 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6307 increment_max_chgd = 1; break;
6308 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6309 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6310 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6311 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6312
6313 default:
6314 log_error ("ERROR: Invalid argument specified");
6315 return (-1);
6316 }
6317 }
6318
6319 if (optopt != 0)
6320 {
6321 log_error ("ERROR: Invalid argument specified");
6322
6323 return (-1);
6324 }
6325
6326 /**
6327 * Inform user things getting started,
6328 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6329 * - we do not need to check algorithm_pos
6330 */
6331
6332 if (quiet == 0)
6333 {
6334 if (benchmark == 1)
6335 {
6336 if (machine_readable == 0)
6337 {
6338 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6339 log_info ("");
6340 log_info ("Note: Reported benchmark cracking speed = real cracking speed");
6341 log_info ("To verify, run hashcat like this: only_one_hash.txt -a 3 -w 3 ?b?b?b?b?b?b?b");
6342 log_info ("");
6343 }
6344 else
6345 {
6346 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6347 }
6348 }
6349 else if (restore == 1)
6350 {
6351 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6352 log_info ("");
6353 }
6354 else if (stdout_flag == 1)
6355 {
6356 // do nothing
6357 }
6358 else
6359 {
6360 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6361 log_info ("");
6362 }
6363 }
6364
6365 /**
6366 * sanity check
6367 */
6368
6369 if (attack_mode > 7)
6370 {
6371 log_error ("ERROR: Invalid attack-mode specified");
6372
6373 return (-1);
6374 }
6375
6376 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6377 {
6378 log_error ("ERROR: Invalid runtime specified");
6379
6380 return (-1);
6381 }
6382
6383 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6384 {
6385 log_error ("ERROR: Invalid hash-type specified");
6386
6387 return (-1);
6388 }
6389
6390 // renamed hash modes
6391
6392 if (hash_mode_chgd)
6393 {
6394 int n = -1;
6395
6396 switch (hash_mode)
6397 {
6398 case 123: n = 124;
6399 break;
6400 }
6401
6402 if (n >= 0)
6403 {
6404 log_error ("Old -m specified, use -m %d instead", n);
6405
6406 return (-1);
6407 }
6408 }
6409
6410 if (username == 1)
6411 {
6412 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6413 {
6414 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6415
6416 return (-1);
6417 }
6418 }
6419
6420 if (outfile_format > 16)
6421 {
6422 log_error ("ERROR: Invalid outfile-format specified");
6423
6424 return (-1);
6425 }
6426
6427 if (left == 1)
6428 {
6429 if (outfile_format_chgd == 1)
6430 {
6431 if (outfile_format > 1)
6432 {
6433 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6434
6435 return (-1);
6436 }
6437 }
6438 else
6439 {
6440 outfile_format = OUTFILE_FMT_HASH;
6441 }
6442 }
6443
6444 if (show == 1)
6445 {
6446 if (outfile_format_chgd == 1)
6447 {
6448 if ((outfile_format > 7) && (outfile_format < 16))
6449 {
6450 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6451
6452 return (-1);
6453 }
6454 }
6455 }
6456
6457 if (increment_min < INCREMENT_MIN)
6458 {
6459 log_error ("ERROR: Invalid increment-min specified");
6460
6461 return (-1);
6462 }
6463
6464 if (increment_max > INCREMENT_MAX)
6465 {
6466 log_error ("ERROR: Invalid increment-max specified");
6467
6468 return (-1);
6469 }
6470
6471 if (increment_min > increment_max)
6472 {
6473 log_error ("ERROR: Invalid increment-min specified");
6474
6475 return (-1);
6476 }
6477
6478 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6479 {
6480 log_error ("ERROR: increment is not allowed in attack-mode 0");
6481
6482 return (-1);
6483 }
6484
6485 if ((increment == 0) && (increment_min_chgd == 1))
6486 {
6487 log_error ("ERROR: increment-min is only supported together with increment switch");
6488
6489 return (-1);
6490 }
6491
6492 if ((increment == 0) && (increment_max_chgd == 1))
6493 {
6494 log_error ("ERROR: increment-max is only supported together with increment switch");
6495
6496 return (-1);
6497 }
6498
6499 if (rp_files_cnt && rp_gen)
6500 {
6501 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6502
6503 return (-1);
6504 }
6505
6506 if (rp_files_cnt || rp_gen)
6507 {
6508 if (attack_mode != ATTACK_MODE_STRAIGHT)
6509 {
6510 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6511
6512 return (-1);
6513 }
6514 }
6515
6516 if (rp_gen_func_min > rp_gen_func_max)
6517 {
6518 log_error ("ERROR: Invalid rp-gen-func-min specified");
6519
6520 return (-1);
6521 }
6522
6523 if (kernel_accel_chgd == 1)
6524 {
6525 if (force == 0)
6526 {
6527 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6528 log_info ("Please consider using the option -w instead");
6529 log_info ("You can use --force to override this but do not post error reports if you do so");
6530 log_info ("");
6531
6532 return (-1);
6533 }
6534
6535 if (kernel_accel < 1)
6536 {
6537 log_error ("ERROR: Invalid kernel-accel specified");
6538
6539 return (-1);
6540 }
6541
6542 if (kernel_accel > 1024)
6543 {
6544 log_error ("ERROR: Invalid kernel-accel specified");
6545
6546 return (-1);
6547 }
6548 }
6549
6550 if (kernel_loops_chgd == 1)
6551 {
6552 if (force == 0)
6553 {
6554 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6555 log_info ("Please consider using the option -w instead");
6556 log_info ("You can use --force to override this but do not post error reports if you do so");
6557 log_info ("");
6558
6559 return (-1);
6560 }
6561
6562 if (kernel_loops < 1)
6563 {
6564 log_error ("ERROR: Invalid kernel-loops specified");
6565
6566 return (-1);
6567 }
6568
6569 if (kernel_loops > 1024)
6570 {
6571 log_error ("ERROR: Invalid kernel-loops specified");
6572
6573 return (-1);
6574 }
6575 }
6576
6577 if ((workload_profile < 1) || (workload_profile > 4))
6578 {
6579 log_error ("ERROR: workload-profile %i not available", workload_profile);
6580
6581 return (-1);
6582 }
6583
6584 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6585 {
6586 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6587
6588 return (-1);
6589 }
6590
6591 if (show == 1 || left == 1)
6592 {
6593 attack_mode = ATTACK_MODE_NONE;
6594
6595 if (remove == 1)
6596 {
6597 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6598
6599 return (-1);
6600 }
6601
6602 if (potfile_disable == 1)
6603 {
6604 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6605
6606 return (-1);
6607 }
6608 }
6609
6610 uint attack_kern = ATTACK_KERN_NONE;
6611
6612 switch (attack_mode)
6613 {
6614 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6615 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6616 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6617 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6618 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6619 }
6620
6621 if (benchmark == 1)
6622 {
6623 if (myargv[optind] != 0)
6624 {
6625 log_error ("ERROR: Invalid argument for benchmark mode specified");
6626
6627 return (-1);
6628 }
6629
6630 if (attack_mode_chgd == 1)
6631 {
6632 if (attack_mode != ATTACK_MODE_BF)
6633 {
6634 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6635
6636 return (-1);
6637 }
6638 }
6639 }
6640 else
6641 {
6642 if (stdout_flag == 1) // no hash here
6643 {
6644 optind--;
6645 }
6646
6647 if (keyspace == 1)
6648 {
6649 int num_additional_params = 1;
6650
6651 if (attack_kern == ATTACK_KERN_COMBI)
6652 {
6653 num_additional_params = 2;
6654 }
6655
6656 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6657
6658 if (keyspace_wordlist_specified == 0) optind--;
6659 }
6660
6661 if (attack_kern == ATTACK_KERN_NONE)
6662 {
6663 if ((optind + 1) != myargc)
6664 {
6665 usage_mini_print (myargv[0]);
6666
6667 return (-1);
6668 }
6669 }
6670 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6671 {
6672 if ((optind + 1) > myargc)
6673 {
6674 usage_mini_print (myargv[0]);
6675
6676 return (-1);
6677 }
6678 }
6679 else if (attack_kern == ATTACK_KERN_COMBI)
6680 {
6681 if ((optind + 3) != myargc)
6682 {
6683 usage_mini_print (myargv[0]);
6684
6685 return (-1);
6686 }
6687 }
6688 else if (attack_kern == ATTACK_KERN_BF)
6689 {
6690 if ((optind + 1) > myargc)
6691 {
6692 usage_mini_print (myargv[0]);
6693
6694 return (-1);
6695 }
6696 }
6697 else
6698 {
6699 usage_mini_print (myargv[0]);
6700
6701 return (-1);
6702 }
6703 }
6704
6705 if (skip != 0 && limit != 0)
6706 {
6707 limit += skip;
6708 }
6709
6710 if (keyspace == 1)
6711 {
6712 if (show == 1)
6713 {
6714 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6715
6716 return (-1);
6717 }
6718 else if (left == 1)
6719 {
6720 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6721
6722 return (-1);
6723 }
6724
6725 potfile_disable = 1;
6726
6727 restore_disable = 1;
6728
6729 restore = 0;
6730
6731 weak_hash_threshold = 0;
6732
6733 quiet = 1;
6734 }
6735
6736 if (stdout_flag == 1)
6737 {
6738 status_timer = 0;
6739 restore_timer = 0;
6740 restore_disable = 1;
6741 restore = 0;
6742 potfile_disable = 1;
6743 weak_hash_threshold = 0;
6744 gpu_temp_disable = 1;
6745 hash_mode = 2000;
6746 quiet = 1;
6747 outfile_format = OUTFILE_FMT_PLAIN;
6748 kernel_accel = 1024;
6749 kernel_loops = 1024;
6750 force = 1;
6751 outfile_check_timer = 0;
6752 }
6753
6754 if (remove_timer_chgd == 1)
6755 {
6756 if (remove == 0)
6757 {
6758 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6759
6760 return (-1);
6761 }
6762
6763 if (remove_timer < 1)
6764 {
6765 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6766
6767 return (-1);
6768 }
6769 }
6770
6771 if (loopback == 1)
6772 {
6773 if (attack_mode == ATTACK_MODE_STRAIGHT)
6774 {
6775 if ((rp_files_cnt == 0) && (rp_gen == 0))
6776 {
6777 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6778
6779 return (-1);
6780 }
6781 }
6782 else
6783 {
6784 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6785
6786 return (-1);
6787 }
6788 }
6789
6790 if (debug_mode > 0)
6791 {
6792 if (attack_mode != ATTACK_MODE_STRAIGHT)
6793 {
6794 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6795
6796 return (-1);
6797 }
6798
6799 if ((rp_files_cnt == 0) && (rp_gen == 0))
6800 {
6801 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6802
6803 return (-1);
6804 }
6805 }
6806
6807 if (debug_mode > 4)
6808 {
6809 log_error ("ERROR: Invalid debug-mode specified");
6810
6811 return (-1);
6812 }
6813
6814 if (debug_file != NULL)
6815 {
6816 if (debug_mode < 1)
6817 {
6818 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6819
6820 return (-1);
6821 }
6822 }
6823
6824 if (induction_dir != NULL)
6825 {
6826 if (attack_mode == ATTACK_MODE_BF)
6827 {
6828 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6829
6830 return (-1);
6831 }
6832 }
6833
6834 if (attack_mode != ATTACK_MODE_STRAIGHT)
6835 {
6836 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6837 {
6838 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6839
6840 return (-1);
6841 }
6842
6843 weak_hash_threshold = 0;
6844 }
6845
6846 if (nvidia_spin_damp > 100)
6847 {
6848 log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)");
6849
6850 return (-1);
6851 }
6852
6853
6854 /**
6855 * induction directory
6856 */
6857
6858 char *induction_directory = NULL;
6859
6860 if (attack_mode != ATTACK_MODE_BF)
6861 {
6862 if (induction_dir == NULL)
6863 {
6864 induction_directory = (char *) mymalloc (session_size);
6865
6866 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6867
6868 // create induction folder if it does not already exist
6869
6870 if (keyspace == 0)
6871 {
6872 if (rmdir (induction_directory) == -1)
6873 {
6874 if (errno == ENOENT)
6875 {
6876 // good, we can ignore
6877 }
6878 else if (errno == ENOTEMPTY)
6879 {
6880 char *induction_directory_mv = (char *) mymalloc (session_size);
6881
6882 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6883
6884 if (rename (induction_directory, induction_directory_mv) != 0)
6885 {
6886 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6887
6888 return (-1);
6889 }
6890 }
6891 else
6892 {
6893 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6894
6895 return (-1);
6896 }
6897 }
6898
6899 if (mkdir (induction_directory, 0700) == -1)
6900 {
6901 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6902
6903 return (-1);
6904 }
6905 }
6906 }
6907 else
6908 {
6909 induction_directory = induction_dir;
6910 }
6911 }
6912
6913 data.induction_directory = induction_directory;
6914
6915 /**
6916 * loopback
6917 */
6918
6919 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6920
6921 char *loopback_file = (char *) mymalloc (loopback_size);
6922
6923 /**
6924 * tuning db
6925 */
6926
6927 char tuning_db_file[256] = { 0 };
6928
6929 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6930
6931 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6932
6933 /**
6934 * outfile-check directory
6935 */
6936
6937 char *outfile_check_directory = NULL;
6938
6939 if (outfile_check_dir == NULL)
6940 {
6941 outfile_check_directory = (char *) mymalloc (session_size);
6942
6943 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6944 }
6945 else
6946 {
6947 outfile_check_directory = outfile_check_dir;
6948 }
6949
6950 data.outfile_check_directory = outfile_check_directory;
6951
6952 if (keyspace == 0)
6953 {
6954 struct stat outfile_check_stat;
6955
6956 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6957 {
6958 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6959
6960 if (is_dir == 0)
6961 {
6962 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6963
6964 return (-1);
6965 }
6966 }
6967 else if (outfile_check_dir == NULL)
6968 {
6969 if (mkdir (outfile_check_directory, 0700) == -1)
6970 {
6971 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6972
6973 return (-1);
6974 }
6975 }
6976 }
6977
6978 /**
6979 * special other stuff
6980 */
6981
6982 if (hash_mode == 9710)
6983 {
6984 outfile_format = 5;
6985 outfile_format_chgd = 1;
6986 }
6987
6988 if (hash_mode == 9810)
6989 {
6990 outfile_format = 5;
6991 outfile_format_chgd = 1;
6992 }
6993
6994 if (hash_mode == 10410)
6995 {
6996 outfile_format = 5;
6997 outfile_format_chgd = 1;
6998 }
6999
7000 /**
7001 * store stuff
7002 */
7003
7004 data.hash_mode = hash_mode;
7005 data.restore = restore;
7006 data.restore_timer = restore_timer;
7007 data.restore_disable = restore_disable;
7008 data.status = status;
7009 data.status_timer = status_timer;
7010 data.machine_readable = machine_readable;
7011 data.loopback = loopback;
7012 data.runtime = runtime;
7013 data.remove = remove;
7014 data.remove_timer = remove_timer;
7015 data.debug_mode = debug_mode;
7016 data.debug_file = debug_file;
7017 data.username = username;
7018 data.quiet = quiet;
7019 data.outfile = outfile;
7020 data.outfile_format = outfile_format;
7021 data.outfile_autohex = outfile_autohex;
7022 data.hex_charset = hex_charset;
7023 data.hex_salt = hex_salt;
7024 data.hex_wordlist = hex_wordlist;
7025 data.separator = separator;
7026 data.rp_files = rp_files;
7027 data.rp_files_cnt = rp_files_cnt;
7028 data.rp_gen = rp_gen;
7029 data.rp_gen_seed = rp_gen_seed;
7030 data.force = force;
7031 data.benchmark = benchmark;
7032 data.skip = skip;
7033 data.limit = limit;
7034 #ifdef HAVE_HWMON
7035 data.powertune_enable = powertune_enable;
7036 #endif
7037 data.logfile_disable = logfile_disable;
7038 data.truecrypt_keyfiles = truecrypt_keyfiles;
7039 data.veracrypt_keyfiles = veracrypt_keyfiles;
7040 data.veracrypt_pim = veracrypt_pim;
7041 data.scrypt_tmto = scrypt_tmto;
7042 data.workload_profile = workload_profile;
7043
7044 /**
7045 * cpu affinity
7046 */
7047
7048 if (cpu_affinity)
7049 {
7050 set_cpu_affinity (cpu_affinity);
7051 }
7052
7053 if (rp_gen_seed_chgd == 0)
7054 {
7055 srand (proc_start);
7056 }
7057 else
7058 {
7059 srand (rp_gen_seed);
7060 }
7061
7062 /**
7063 * logfile init
7064 */
7065
7066 if (logfile_disable == 0)
7067 {
7068 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7069
7070 char *logfile = (char *) mymalloc (logfile_size);
7071
7072 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7073
7074 data.logfile = logfile;
7075
7076 char *topid = logfile_generate_topid ();
7077
7078 data.topid = topid;
7079 }
7080
7081 // logfile_append() checks for logfile_disable internally to make it easier from here
7082
7083 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7084 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7085 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7086 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7087 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7088 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7089 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7090 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7091 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7092 #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));
7093
7094 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7095 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7096 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7097 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7098 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7099 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7100 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7101 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7102
7103 logfile_top_msg ("START");
7104
7105 logfile_top_uint (attack_mode);
7106 logfile_top_uint (attack_kern);
7107 logfile_top_uint (benchmark);
7108 logfile_top_uint (stdout_flag);
7109 logfile_top_uint (bitmap_min);
7110 logfile_top_uint (bitmap_max);
7111 logfile_top_uint (debug_mode);
7112 logfile_top_uint (force);
7113 logfile_top_uint (kernel_accel);
7114 logfile_top_uint (kernel_loops);
7115 logfile_top_uint (nvidia_spin_damp);
7116 logfile_top_uint (gpu_temp_disable);
7117 #ifdef HAVE_HWMON
7118 logfile_top_uint (gpu_temp_abort);
7119 logfile_top_uint (gpu_temp_retain);
7120 #endif
7121 logfile_top_uint (hash_mode);
7122 logfile_top_uint (hex_charset);
7123 logfile_top_uint (hex_salt);
7124 logfile_top_uint (hex_wordlist);
7125 logfile_top_uint (increment);
7126 logfile_top_uint (increment_max);
7127 logfile_top_uint (increment_min);
7128 logfile_top_uint (keyspace);
7129 logfile_top_uint (left);
7130 logfile_top_uint (logfile_disable);
7131 logfile_top_uint (loopback);
7132 logfile_top_uint (markov_classic);
7133 logfile_top_uint (markov_disable);
7134 logfile_top_uint (markov_threshold);
7135 logfile_top_uint (outfile_autohex);
7136 logfile_top_uint (outfile_check_timer);
7137 logfile_top_uint (outfile_format);
7138 logfile_top_uint (potfile_disable);
7139 logfile_top_string (potfile_path);
7140 #if defined(HAVE_HWMON)
7141 logfile_top_uint (powertune_enable);
7142 #endif
7143 logfile_top_uint (scrypt_tmto);
7144 logfile_top_uint (quiet);
7145 logfile_top_uint (remove);
7146 logfile_top_uint (remove_timer);
7147 logfile_top_uint (restore);
7148 logfile_top_uint (restore_disable);
7149 logfile_top_uint (restore_timer);
7150 logfile_top_uint (rp_gen);
7151 logfile_top_uint (rp_gen_func_max);
7152 logfile_top_uint (rp_gen_func_min);
7153 logfile_top_uint (rp_gen_seed);
7154 logfile_top_uint (runtime);
7155 logfile_top_uint (segment_size);
7156 logfile_top_uint (show);
7157 logfile_top_uint (status);
7158 logfile_top_uint (machine_readable);
7159 logfile_top_uint (status_timer);
7160 logfile_top_uint (usage);
7161 logfile_top_uint (username);
7162 logfile_top_uint (version);
7163 logfile_top_uint (weak_hash_threshold);
7164 logfile_top_uint (workload_profile);
7165 logfile_top_uint64 (limit);
7166 logfile_top_uint64 (skip);
7167 logfile_top_char (separator);
7168 logfile_top_string (cpu_affinity);
7169 logfile_top_string (custom_charset_1);
7170 logfile_top_string (custom_charset_2);
7171 logfile_top_string (custom_charset_3);
7172 logfile_top_string (custom_charset_4);
7173 logfile_top_string (debug_file);
7174 logfile_top_string (opencl_devices);
7175 logfile_top_string (opencl_platforms);
7176 logfile_top_string (opencl_device_types);
7177 logfile_top_uint (opencl_vector_width);
7178 logfile_top_string (induction_dir);
7179 logfile_top_string (markov_hcstat);
7180 logfile_top_string (outfile);
7181 logfile_top_string (outfile_check_dir);
7182 logfile_top_string (rule_buf_l);
7183 logfile_top_string (rule_buf_r);
7184 logfile_top_string (session);
7185 logfile_top_string (truecrypt_keyfiles);
7186 logfile_top_string (veracrypt_keyfiles);
7187 logfile_top_uint (veracrypt_pim);
7188
7189 /**
7190 * Init OpenCL library loader
7191 */
7192
7193 if (keyspace == 0)
7194 {
7195 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7196
7197 ocl_init (ocl);
7198
7199 data.ocl = ocl;
7200 }
7201
7202 /**
7203 * OpenCL platform selection
7204 */
7205
7206 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7207
7208 /**
7209 * OpenCL device selection
7210 */
7211
7212 u32 devices_filter = setup_devices_filter (opencl_devices);
7213
7214 /**
7215 * OpenCL device type selection
7216 */
7217
7218 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7219
7220 /**
7221 * benchmark
7222 */
7223
7224 if (benchmark == 1)
7225 {
7226 /**
7227 * disable useless stuff for benchmark
7228 */
7229
7230 status_timer = 0;
7231 restore_timer = 0;
7232 restore_disable = 1;
7233 potfile_disable = 1;
7234 weak_hash_threshold = 0;
7235 nvidia_spin_damp = 0;
7236 gpu_temp_disable = 1;
7237 outfile_check_timer = 0;
7238
7239 #ifdef HAVE_HWMON
7240 if (powertune_enable == 1)
7241 {
7242 gpu_temp_disable = 0;
7243 }
7244 #endif
7245
7246 data.status_timer = status_timer;
7247 data.restore_timer = restore_timer;
7248 data.restore_disable = restore_disable;
7249 data.outfile_check_timer = outfile_check_timer;
7250
7251 /**
7252 * force attack mode to be bruteforce
7253 */
7254
7255 attack_mode = ATTACK_MODE_BF;
7256 attack_kern = ATTACK_KERN_BF;
7257
7258 if (workload_profile_chgd == 0)
7259 {
7260 workload_profile = 3;
7261
7262 data.workload_profile = workload_profile;
7263 }
7264 }
7265
7266 /**
7267 * config
7268 */
7269
7270 uint hash_type = 0;
7271 uint salt_type = 0;
7272 uint attack_exec = 0;
7273 uint opts_type = 0;
7274 uint kern_type = 0;
7275 uint dgst_size = 0;
7276 uint esalt_size = 0;
7277 uint opti_type = 0;
7278 uint dgst_pos0 = -1;
7279 uint dgst_pos1 = -1;
7280 uint dgst_pos2 = -1;
7281 uint dgst_pos3 = -1;
7282
7283 int (*parse_func) (char *, uint, hash_t *);
7284 int (*sort_by_digest) (const void *, const void *);
7285
7286 uint algorithm_pos = 0;
7287 uint algorithm_max = 1;
7288
7289 uint *algorithms = default_benchmark_algorithms;
7290
7291 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7292
7293 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7294 {
7295 /*
7296 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7297 * the following algos are skipped entirely
7298 */
7299
7300 if (algorithm_pos > 0)
7301 {
7302 local_free (rd);
7303
7304 rd = init_restore (argc, argv);
7305
7306 data.rd = rd;
7307 }
7308
7309 /**
7310 * update hash_mode in case of multihash benchmark
7311 */
7312
7313 if (benchmark == 1)
7314 {
7315 if (hash_mode_chgd == 0)
7316 {
7317 hash_mode = algorithms[algorithm_pos];
7318
7319 data.hash_mode = hash_mode;
7320 }
7321
7322 quiet = 1;
7323
7324 data.quiet = quiet;
7325 }
7326
7327 switch (hash_mode)
7328 {
7329 case 0: hash_type = HASH_TYPE_MD5;
7330 salt_type = SALT_TYPE_NONE;
7331 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7332 opts_type = OPTS_TYPE_PT_GENERATE_LE
7333 | OPTS_TYPE_PT_ADD80
7334 | OPTS_TYPE_PT_ADDBITS14;
7335 kern_type = KERN_TYPE_MD5;
7336 dgst_size = DGST_SIZE_4_4;
7337 parse_func = md5_parse_hash;
7338 sort_by_digest = sort_by_digest_4_4;
7339 opti_type = OPTI_TYPE_ZERO_BYTE
7340 | OPTI_TYPE_PRECOMPUTE_INIT
7341 | OPTI_TYPE_PRECOMPUTE_MERKLE
7342 | OPTI_TYPE_MEET_IN_MIDDLE
7343 | OPTI_TYPE_EARLY_SKIP
7344 | OPTI_TYPE_NOT_ITERATED
7345 | OPTI_TYPE_NOT_SALTED
7346 | OPTI_TYPE_RAW_HASH;
7347 dgst_pos0 = 0;
7348 dgst_pos1 = 3;
7349 dgst_pos2 = 2;
7350 dgst_pos3 = 1;
7351 break;
7352
7353 case 10: hash_type = HASH_TYPE_MD5;
7354 salt_type = SALT_TYPE_INTERN;
7355 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7356 opts_type = OPTS_TYPE_PT_GENERATE_LE
7357 | OPTS_TYPE_ST_ADD80
7358 | OPTS_TYPE_ST_ADDBITS14;
7359 kern_type = KERN_TYPE_MD5_PWSLT;
7360 dgst_size = DGST_SIZE_4_4;
7361 parse_func = md5s_parse_hash;
7362 sort_by_digest = sort_by_digest_4_4;
7363 opti_type = OPTI_TYPE_ZERO_BYTE
7364 | OPTI_TYPE_PRECOMPUTE_INIT
7365 | OPTI_TYPE_PRECOMPUTE_MERKLE
7366 | OPTI_TYPE_MEET_IN_MIDDLE
7367 | OPTI_TYPE_EARLY_SKIP
7368 | OPTI_TYPE_NOT_ITERATED
7369 | OPTI_TYPE_APPENDED_SALT
7370 | OPTI_TYPE_RAW_HASH;
7371 dgst_pos0 = 0;
7372 dgst_pos1 = 3;
7373 dgst_pos2 = 2;
7374 dgst_pos3 = 1;
7375 break;
7376
7377 case 11: hash_type = HASH_TYPE_MD5;
7378 salt_type = SALT_TYPE_INTERN;
7379 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7380 opts_type = OPTS_TYPE_PT_GENERATE_LE
7381 | OPTS_TYPE_ST_ADD80
7382 | OPTS_TYPE_ST_ADDBITS14;
7383 kern_type = KERN_TYPE_MD5_PWSLT;
7384 dgst_size = DGST_SIZE_4_4;
7385 parse_func = joomla_parse_hash;
7386 sort_by_digest = sort_by_digest_4_4;
7387 opti_type = OPTI_TYPE_ZERO_BYTE
7388 | OPTI_TYPE_PRECOMPUTE_INIT
7389 | OPTI_TYPE_PRECOMPUTE_MERKLE
7390 | OPTI_TYPE_MEET_IN_MIDDLE
7391 | OPTI_TYPE_EARLY_SKIP
7392 | OPTI_TYPE_NOT_ITERATED
7393 | OPTI_TYPE_APPENDED_SALT
7394 | OPTI_TYPE_RAW_HASH;
7395 dgst_pos0 = 0;
7396 dgst_pos1 = 3;
7397 dgst_pos2 = 2;
7398 dgst_pos3 = 1;
7399 break;
7400
7401 case 12: hash_type = HASH_TYPE_MD5;
7402 salt_type = SALT_TYPE_INTERN;
7403 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7404 opts_type = OPTS_TYPE_PT_GENERATE_LE
7405 | OPTS_TYPE_ST_ADD80
7406 | OPTS_TYPE_ST_ADDBITS14;
7407 kern_type = KERN_TYPE_MD5_PWSLT;
7408 dgst_size = DGST_SIZE_4_4;
7409 parse_func = postgresql_parse_hash;
7410 sort_by_digest = sort_by_digest_4_4;
7411 opti_type = OPTI_TYPE_ZERO_BYTE
7412 | OPTI_TYPE_PRECOMPUTE_INIT
7413 | OPTI_TYPE_PRECOMPUTE_MERKLE
7414 | OPTI_TYPE_MEET_IN_MIDDLE
7415 | OPTI_TYPE_EARLY_SKIP
7416 | OPTI_TYPE_NOT_ITERATED
7417 | OPTI_TYPE_APPENDED_SALT
7418 | OPTI_TYPE_RAW_HASH;
7419 dgst_pos0 = 0;
7420 dgst_pos1 = 3;
7421 dgst_pos2 = 2;
7422 dgst_pos3 = 1;
7423 break;
7424
7425 case 20: hash_type = HASH_TYPE_MD5;
7426 salt_type = SALT_TYPE_INTERN;
7427 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7428 opts_type = OPTS_TYPE_PT_GENERATE_LE
7429 | OPTS_TYPE_PT_ADD80
7430 | OPTS_TYPE_PT_ADDBITS14;
7431 kern_type = KERN_TYPE_MD5_SLTPW;
7432 dgst_size = DGST_SIZE_4_4;
7433 parse_func = md5s_parse_hash;
7434 sort_by_digest = sort_by_digest_4_4;
7435 opti_type = OPTI_TYPE_ZERO_BYTE
7436 | OPTI_TYPE_PRECOMPUTE_INIT
7437 | OPTI_TYPE_PRECOMPUTE_MERKLE
7438 | OPTI_TYPE_EARLY_SKIP
7439 | OPTI_TYPE_NOT_ITERATED
7440 | OPTI_TYPE_PREPENDED_SALT
7441 | OPTI_TYPE_RAW_HASH;
7442 dgst_pos0 = 0;
7443 dgst_pos1 = 3;
7444 dgst_pos2 = 2;
7445 dgst_pos3 = 1;
7446 break;
7447
7448 case 21: hash_type = HASH_TYPE_MD5;
7449 salt_type = SALT_TYPE_INTERN;
7450 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7451 opts_type = OPTS_TYPE_PT_GENERATE_LE
7452 | OPTS_TYPE_PT_ADD80
7453 | OPTS_TYPE_PT_ADDBITS14;
7454 kern_type = KERN_TYPE_MD5_SLTPW;
7455 dgst_size = DGST_SIZE_4_4;
7456 parse_func = osc_parse_hash;
7457 sort_by_digest = sort_by_digest_4_4;
7458 opti_type = OPTI_TYPE_ZERO_BYTE
7459 | OPTI_TYPE_PRECOMPUTE_INIT
7460 | OPTI_TYPE_PRECOMPUTE_MERKLE
7461 | OPTI_TYPE_EARLY_SKIP
7462 | OPTI_TYPE_NOT_ITERATED
7463 | OPTI_TYPE_PREPENDED_SALT
7464 | OPTI_TYPE_RAW_HASH;
7465 dgst_pos0 = 0;
7466 dgst_pos1 = 3;
7467 dgst_pos2 = 2;
7468 dgst_pos3 = 1;
7469 break;
7470
7471 case 22: hash_type = HASH_TYPE_MD5;
7472 salt_type = SALT_TYPE_EMBEDDED;
7473 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7474 opts_type = OPTS_TYPE_PT_GENERATE_LE
7475 | OPTS_TYPE_PT_ADD80
7476 | OPTS_TYPE_PT_ADDBITS14;
7477 kern_type = KERN_TYPE_MD5_SLTPW;
7478 dgst_size = DGST_SIZE_4_4;
7479 parse_func = netscreen_parse_hash;
7480 sort_by_digest = sort_by_digest_4_4;
7481 opti_type = OPTI_TYPE_ZERO_BYTE
7482 | OPTI_TYPE_PRECOMPUTE_INIT
7483 | OPTI_TYPE_PRECOMPUTE_MERKLE
7484 | OPTI_TYPE_EARLY_SKIP
7485 | OPTI_TYPE_NOT_ITERATED
7486 | OPTI_TYPE_PREPENDED_SALT
7487 | OPTI_TYPE_RAW_HASH;
7488 dgst_pos0 = 0;
7489 dgst_pos1 = 3;
7490 dgst_pos2 = 2;
7491 dgst_pos3 = 1;
7492 break;
7493
7494 case 23: hash_type = HASH_TYPE_MD5;
7495 salt_type = SALT_TYPE_EMBEDDED;
7496 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7497 opts_type = OPTS_TYPE_PT_GENERATE_LE
7498 | OPTS_TYPE_PT_ADD80
7499 | OPTS_TYPE_PT_ADDBITS14;
7500 kern_type = KERN_TYPE_MD5_SLTPW;
7501 dgst_size = DGST_SIZE_4_4;
7502 parse_func = skype_parse_hash;
7503 sort_by_digest = sort_by_digest_4_4;
7504 opti_type = OPTI_TYPE_ZERO_BYTE
7505 | OPTI_TYPE_PRECOMPUTE_INIT
7506 | OPTI_TYPE_PRECOMPUTE_MERKLE
7507 | OPTI_TYPE_EARLY_SKIP
7508 | OPTI_TYPE_NOT_ITERATED
7509 | OPTI_TYPE_PREPENDED_SALT
7510 | OPTI_TYPE_RAW_HASH;
7511 dgst_pos0 = 0;
7512 dgst_pos1 = 3;
7513 dgst_pos2 = 2;
7514 dgst_pos3 = 1;
7515 break;
7516
7517 case 30: hash_type = HASH_TYPE_MD5;
7518 salt_type = SALT_TYPE_INTERN;
7519 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7520 opts_type = OPTS_TYPE_PT_GENERATE_LE
7521 | OPTS_TYPE_PT_UNICODE
7522 | OPTS_TYPE_ST_ADD80
7523 | OPTS_TYPE_ST_ADDBITS14;
7524 kern_type = KERN_TYPE_MD5_PWUSLT;
7525 dgst_size = DGST_SIZE_4_4;
7526 parse_func = md5s_parse_hash;
7527 sort_by_digest = sort_by_digest_4_4;
7528 opti_type = OPTI_TYPE_ZERO_BYTE
7529 | OPTI_TYPE_PRECOMPUTE_INIT
7530 | OPTI_TYPE_PRECOMPUTE_MERKLE
7531 | OPTI_TYPE_MEET_IN_MIDDLE
7532 | OPTI_TYPE_EARLY_SKIP
7533 | OPTI_TYPE_NOT_ITERATED
7534 | OPTI_TYPE_APPENDED_SALT
7535 | OPTI_TYPE_RAW_HASH;
7536 dgst_pos0 = 0;
7537 dgst_pos1 = 3;
7538 dgst_pos2 = 2;
7539 dgst_pos3 = 1;
7540 break;
7541
7542 case 40: hash_type = HASH_TYPE_MD5;
7543 salt_type = SALT_TYPE_INTERN;
7544 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7545 opts_type = OPTS_TYPE_PT_GENERATE_LE
7546 | OPTS_TYPE_PT_ADD80
7547 | OPTS_TYPE_PT_ADDBITS14
7548 | OPTS_TYPE_PT_UNICODE;
7549 kern_type = KERN_TYPE_MD5_SLTPWU;
7550 dgst_size = DGST_SIZE_4_4;
7551 parse_func = md5s_parse_hash;
7552 sort_by_digest = sort_by_digest_4_4;
7553 opti_type = OPTI_TYPE_ZERO_BYTE
7554 | OPTI_TYPE_PRECOMPUTE_INIT
7555 | OPTI_TYPE_PRECOMPUTE_MERKLE
7556 | OPTI_TYPE_EARLY_SKIP
7557 | OPTI_TYPE_NOT_ITERATED
7558 | OPTI_TYPE_PREPENDED_SALT
7559 | OPTI_TYPE_RAW_HASH;
7560 dgst_pos0 = 0;
7561 dgst_pos1 = 3;
7562 dgst_pos2 = 2;
7563 dgst_pos3 = 1;
7564 break;
7565
7566 case 50: hash_type = HASH_TYPE_MD5;
7567 salt_type = SALT_TYPE_INTERN;
7568 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7569 opts_type = OPTS_TYPE_PT_GENERATE_LE
7570 | OPTS_TYPE_ST_ADD80
7571 | OPTS_TYPE_ST_ADDBITS14;
7572 kern_type = KERN_TYPE_HMACMD5_PW;
7573 dgst_size = DGST_SIZE_4_4;
7574 parse_func = hmacmd5_parse_hash;
7575 sort_by_digest = sort_by_digest_4_4;
7576 opti_type = OPTI_TYPE_ZERO_BYTE
7577 | OPTI_TYPE_NOT_ITERATED;
7578 dgst_pos0 = 0;
7579 dgst_pos1 = 3;
7580 dgst_pos2 = 2;
7581 dgst_pos3 = 1;
7582 break;
7583
7584 case 60: hash_type = HASH_TYPE_MD5;
7585 salt_type = SALT_TYPE_INTERN;
7586 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7587 opts_type = OPTS_TYPE_PT_GENERATE_LE
7588 | OPTS_TYPE_PT_ADD80
7589 | OPTS_TYPE_PT_ADDBITS14;
7590 kern_type = KERN_TYPE_HMACMD5_SLT;
7591 dgst_size = DGST_SIZE_4_4;
7592 parse_func = hmacmd5_parse_hash;
7593 sort_by_digest = sort_by_digest_4_4;
7594 opti_type = OPTI_TYPE_ZERO_BYTE
7595 | OPTI_TYPE_NOT_ITERATED;
7596 dgst_pos0 = 0;
7597 dgst_pos1 = 3;
7598 dgst_pos2 = 2;
7599 dgst_pos3 = 1;
7600 break;
7601
7602 case 100: hash_type = HASH_TYPE_SHA1;
7603 salt_type = SALT_TYPE_NONE;
7604 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7605 opts_type = OPTS_TYPE_PT_GENERATE_BE
7606 | OPTS_TYPE_PT_ADD80
7607 | OPTS_TYPE_PT_ADDBITS15;
7608 kern_type = KERN_TYPE_SHA1;
7609 dgst_size = DGST_SIZE_4_5;
7610 parse_func = sha1_parse_hash;
7611 sort_by_digest = sort_by_digest_4_5;
7612 opti_type = OPTI_TYPE_ZERO_BYTE
7613 | OPTI_TYPE_PRECOMPUTE_INIT
7614 | OPTI_TYPE_PRECOMPUTE_MERKLE
7615 | OPTI_TYPE_EARLY_SKIP
7616 | OPTI_TYPE_NOT_ITERATED
7617 | OPTI_TYPE_NOT_SALTED
7618 | OPTI_TYPE_RAW_HASH;
7619 dgst_pos0 = 3;
7620 dgst_pos1 = 4;
7621 dgst_pos2 = 2;
7622 dgst_pos3 = 1;
7623 break;
7624
7625 case 101: hash_type = HASH_TYPE_SHA1;
7626 salt_type = SALT_TYPE_NONE;
7627 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7628 opts_type = OPTS_TYPE_PT_GENERATE_BE
7629 | OPTS_TYPE_PT_ADD80
7630 | OPTS_TYPE_PT_ADDBITS15;
7631 kern_type = KERN_TYPE_SHA1;
7632 dgst_size = DGST_SIZE_4_5;
7633 parse_func = sha1b64_parse_hash;
7634 sort_by_digest = sort_by_digest_4_5;
7635 opti_type = OPTI_TYPE_ZERO_BYTE
7636 | OPTI_TYPE_PRECOMPUTE_INIT
7637 | OPTI_TYPE_PRECOMPUTE_MERKLE
7638 | OPTI_TYPE_EARLY_SKIP
7639 | OPTI_TYPE_NOT_ITERATED
7640 | OPTI_TYPE_NOT_SALTED
7641 | OPTI_TYPE_RAW_HASH;
7642 dgst_pos0 = 3;
7643 dgst_pos1 = 4;
7644 dgst_pos2 = 2;
7645 dgst_pos3 = 1;
7646 break;
7647
7648 case 110: hash_type = HASH_TYPE_SHA1;
7649 salt_type = SALT_TYPE_INTERN;
7650 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7651 opts_type = OPTS_TYPE_PT_GENERATE_BE
7652 | OPTS_TYPE_ST_ADD80
7653 | OPTS_TYPE_ST_ADDBITS15;
7654 kern_type = KERN_TYPE_SHA1_PWSLT;
7655 dgst_size = DGST_SIZE_4_5;
7656 parse_func = sha1s_parse_hash;
7657 sort_by_digest = sort_by_digest_4_5;
7658 opti_type = OPTI_TYPE_ZERO_BYTE
7659 | OPTI_TYPE_PRECOMPUTE_INIT
7660 | OPTI_TYPE_PRECOMPUTE_MERKLE
7661 | OPTI_TYPE_EARLY_SKIP
7662 | OPTI_TYPE_NOT_ITERATED
7663 | OPTI_TYPE_APPENDED_SALT
7664 | OPTI_TYPE_RAW_HASH;
7665 dgst_pos0 = 3;
7666 dgst_pos1 = 4;
7667 dgst_pos2 = 2;
7668 dgst_pos3 = 1;
7669 break;
7670
7671 case 111: hash_type = HASH_TYPE_SHA1;
7672 salt_type = SALT_TYPE_EMBEDDED;
7673 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7674 opts_type = OPTS_TYPE_PT_GENERATE_BE
7675 | OPTS_TYPE_ST_ADD80
7676 | OPTS_TYPE_ST_ADDBITS15;
7677 kern_type = KERN_TYPE_SHA1_PWSLT;
7678 dgst_size = DGST_SIZE_4_5;
7679 parse_func = sha1b64s_parse_hash;
7680 sort_by_digest = sort_by_digest_4_5;
7681 opti_type = OPTI_TYPE_ZERO_BYTE
7682 | OPTI_TYPE_PRECOMPUTE_INIT
7683 | OPTI_TYPE_PRECOMPUTE_MERKLE
7684 | OPTI_TYPE_EARLY_SKIP
7685 | OPTI_TYPE_NOT_ITERATED
7686 | OPTI_TYPE_APPENDED_SALT
7687 | OPTI_TYPE_RAW_HASH;
7688 dgst_pos0 = 3;
7689 dgst_pos1 = 4;
7690 dgst_pos2 = 2;
7691 dgst_pos3 = 1;
7692 break;
7693
7694 case 112: hash_type = HASH_TYPE_SHA1;
7695 salt_type = SALT_TYPE_INTERN;
7696 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7697 opts_type = OPTS_TYPE_PT_GENERATE_BE
7698 | OPTS_TYPE_ST_ADD80
7699 | OPTS_TYPE_ST_ADDBITS15
7700 | OPTS_TYPE_ST_HEX;
7701 kern_type = KERN_TYPE_SHA1_PWSLT;
7702 dgst_size = DGST_SIZE_4_5;
7703 parse_func = oracles_parse_hash;
7704 sort_by_digest = sort_by_digest_4_5;
7705 opti_type = OPTI_TYPE_ZERO_BYTE
7706 | OPTI_TYPE_PRECOMPUTE_INIT
7707 | OPTI_TYPE_PRECOMPUTE_MERKLE
7708 | OPTI_TYPE_EARLY_SKIP
7709 | OPTI_TYPE_NOT_ITERATED
7710 | OPTI_TYPE_APPENDED_SALT
7711 | OPTI_TYPE_RAW_HASH;
7712 dgst_pos0 = 3;
7713 dgst_pos1 = 4;
7714 dgst_pos2 = 2;
7715 dgst_pos3 = 1;
7716 break;
7717
7718 case 120: hash_type = HASH_TYPE_SHA1;
7719 salt_type = SALT_TYPE_INTERN;
7720 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7721 opts_type = OPTS_TYPE_PT_GENERATE_BE
7722 | OPTS_TYPE_PT_ADD80
7723 | OPTS_TYPE_PT_ADDBITS15;
7724 kern_type = KERN_TYPE_SHA1_SLTPW;
7725 dgst_size = DGST_SIZE_4_5;
7726 parse_func = sha1s_parse_hash;
7727 sort_by_digest = sort_by_digest_4_5;
7728 opti_type = OPTI_TYPE_ZERO_BYTE
7729 | OPTI_TYPE_PRECOMPUTE_INIT
7730 | OPTI_TYPE_PRECOMPUTE_MERKLE
7731 | OPTI_TYPE_EARLY_SKIP
7732 | OPTI_TYPE_NOT_ITERATED
7733 | OPTI_TYPE_PREPENDED_SALT
7734 | OPTI_TYPE_RAW_HASH;
7735 dgst_pos0 = 3;
7736 dgst_pos1 = 4;
7737 dgst_pos2 = 2;
7738 dgst_pos3 = 1;
7739 break;
7740
7741 case 121: hash_type = HASH_TYPE_SHA1;
7742 salt_type = SALT_TYPE_INTERN;
7743 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7744 opts_type = OPTS_TYPE_PT_GENERATE_BE
7745 | OPTS_TYPE_PT_ADD80
7746 | OPTS_TYPE_PT_ADDBITS15
7747 | OPTS_TYPE_ST_LOWER;
7748 kern_type = KERN_TYPE_SHA1_SLTPW;
7749 dgst_size = DGST_SIZE_4_5;
7750 parse_func = smf_parse_hash;
7751 sort_by_digest = sort_by_digest_4_5;
7752 opti_type = OPTI_TYPE_ZERO_BYTE
7753 | OPTI_TYPE_PRECOMPUTE_INIT
7754 | OPTI_TYPE_PRECOMPUTE_MERKLE
7755 | OPTI_TYPE_EARLY_SKIP
7756 | OPTI_TYPE_NOT_ITERATED
7757 | OPTI_TYPE_PREPENDED_SALT
7758 | OPTI_TYPE_RAW_HASH;
7759 dgst_pos0 = 3;
7760 dgst_pos1 = 4;
7761 dgst_pos2 = 2;
7762 dgst_pos3 = 1;
7763 break;
7764
7765 case 122: hash_type = HASH_TYPE_SHA1;
7766 salt_type = SALT_TYPE_EMBEDDED;
7767 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7768 opts_type = OPTS_TYPE_PT_GENERATE_BE
7769 | OPTS_TYPE_PT_ADD80
7770 | OPTS_TYPE_PT_ADDBITS15
7771 | OPTS_TYPE_ST_HEX;
7772 kern_type = KERN_TYPE_SHA1_SLTPW;
7773 dgst_size = DGST_SIZE_4_5;
7774 parse_func = osx1_parse_hash;
7775 sort_by_digest = sort_by_digest_4_5;
7776 opti_type = OPTI_TYPE_ZERO_BYTE
7777 | OPTI_TYPE_PRECOMPUTE_INIT
7778 | OPTI_TYPE_PRECOMPUTE_MERKLE
7779 | OPTI_TYPE_EARLY_SKIP
7780 | OPTI_TYPE_NOT_ITERATED
7781 | OPTI_TYPE_PREPENDED_SALT
7782 | OPTI_TYPE_RAW_HASH;
7783 dgst_pos0 = 3;
7784 dgst_pos1 = 4;
7785 dgst_pos2 = 2;
7786 dgst_pos3 = 1;
7787 break;
7788
7789 case 124: hash_type = HASH_TYPE_SHA1;
7790 salt_type = SALT_TYPE_EMBEDDED;
7791 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7792 opts_type = OPTS_TYPE_PT_GENERATE_BE
7793 | OPTS_TYPE_PT_ADD80
7794 | OPTS_TYPE_PT_ADDBITS15;
7795 kern_type = KERN_TYPE_SHA1_SLTPW;
7796 dgst_size = DGST_SIZE_4_5;
7797 parse_func = djangosha1_parse_hash;
7798 sort_by_digest = sort_by_digest_4_5;
7799 opti_type = OPTI_TYPE_ZERO_BYTE
7800 | OPTI_TYPE_PRECOMPUTE_INIT
7801 | OPTI_TYPE_PRECOMPUTE_MERKLE
7802 | OPTI_TYPE_EARLY_SKIP
7803 | OPTI_TYPE_NOT_ITERATED
7804 | OPTI_TYPE_PREPENDED_SALT
7805 | OPTI_TYPE_RAW_HASH;
7806 dgst_pos0 = 3;
7807 dgst_pos1 = 4;
7808 dgst_pos2 = 2;
7809 dgst_pos3 = 1;
7810 break;
7811
7812 case 125: hash_type = HASH_TYPE_SHA1;
7813 salt_type = SALT_TYPE_EMBEDDED;
7814 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7815 opts_type = OPTS_TYPE_PT_GENERATE_BE
7816 | OPTS_TYPE_PT_ADD80
7817 | OPTS_TYPE_PT_ADDBITS15
7818 | OPTS_TYPE_ST_HEX;
7819 kern_type = KERN_TYPE_SHA1_SLTPW;
7820 dgst_size = DGST_SIZE_4_5;
7821 parse_func = arubaos_parse_hash;
7822 sort_by_digest = sort_by_digest_4_5;
7823 opti_type = OPTI_TYPE_ZERO_BYTE
7824 | OPTI_TYPE_PRECOMPUTE_INIT
7825 | OPTI_TYPE_PRECOMPUTE_MERKLE
7826 | OPTI_TYPE_EARLY_SKIP
7827 | OPTI_TYPE_NOT_ITERATED
7828 | OPTI_TYPE_PREPENDED_SALT
7829 | OPTI_TYPE_RAW_HASH;
7830 dgst_pos0 = 3;
7831 dgst_pos1 = 4;
7832 dgst_pos2 = 2;
7833 dgst_pos3 = 1;
7834 break;
7835
7836 case 130: hash_type = HASH_TYPE_SHA1;
7837 salt_type = SALT_TYPE_INTERN;
7838 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7839 opts_type = OPTS_TYPE_PT_GENERATE_BE
7840 | OPTS_TYPE_PT_UNICODE
7841 | OPTS_TYPE_ST_ADD80
7842 | OPTS_TYPE_ST_ADDBITS15;
7843 kern_type = KERN_TYPE_SHA1_PWUSLT;
7844 dgst_size = DGST_SIZE_4_5;
7845 parse_func = sha1s_parse_hash;
7846 sort_by_digest = sort_by_digest_4_5;
7847 opti_type = OPTI_TYPE_ZERO_BYTE
7848 | OPTI_TYPE_PRECOMPUTE_INIT
7849 | OPTI_TYPE_PRECOMPUTE_MERKLE
7850 | OPTI_TYPE_EARLY_SKIP
7851 | OPTI_TYPE_NOT_ITERATED
7852 | OPTI_TYPE_APPENDED_SALT
7853 | OPTI_TYPE_RAW_HASH;
7854 dgst_pos0 = 3;
7855 dgst_pos1 = 4;
7856 dgst_pos2 = 2;
7857 dgst_pos3 = 1;
7858 break;
7859
7860 case 131: hash_type = HASH_TYPE_SHA1;
7861 salt_type = SALT_TYPE_EMBEDDED;
7862 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7863 opts_type = OPTS_TYPE_PT_GENERATE_BE
7864 | OPTS_TYPE_PT_UNICODE
7865 | OPTS_TYPE_PT_UPPER
7866 | OPTS_TYPE_ST_ADD80
7867 | OPTS_TYPE_ST_ADDBITS15
7868 | OPTS_TYPE_ST_HEX;
7869 kern_type = KERN_TYPE_SHA1_PWUSLT;
7870 dgst_size = DGST_SIZE_4_5;
7871 parse_func = mssql2000_parse_hash;
7872 sort_by_digest = sort_by_digest_4_5;
7873 opti_type = OPTI_TYPE_ZERO_BYTE
7874 | OPTI_TYPE_PRECOMPUTE_INIT
7875 | OPTI_TYPE_PRECOMPUTE_MERKLE
7876 | OPTI_TYPE_EARLY_SKIP
7877 | OPTI_TYPE_NOT_ITERATED
7878 | OPTI_TYPE_APPENDED_SALT
7879 | OPTI_TYPE_RAW_HASH;
7880 dgst_pos0 = 3;
7881 dgst_pos1 = 4;
7882 dgst_pos2 = 2;
7883 dgst_pos3 = 1;
7884 break;
7885
7886 case 132: hash_type = HASH_TYPE_SHA1;
7887 salt_type = SALT_TYPE_EMBEDDED;
7888 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7889 opts_type = OPTS_TYPE_PT_GENERATE_BE
7890 | OPTS_TYPE_PT_UNICODE
7891 | OPTS_TYPE_ST_ADD80
7892 | OPTS_TYPE_ST_ADDBITS15
7893 | OPTS_TYPE_ST_HEX;
7894 kern_type = KERN_TYPE_SHA1_PWUSLT;
7895 dgst_size = DGST_SIZE_4_5;
7896 parse_func = mssql2005_parse_hash;
7897 sort_by_digest = sort_by_digest_4_5;
7898 opti_type = OPTI_TYPE_ZERO_BYTE
7899 | OPTI_TYPE_PRECOMPUTE_INIT
7900 | OPTI_TYPE_PRECOMPUTE_MERKLE
7901 | OPTI_TYPE_EARLY_SKIP
7902 | OPTI_TYPE_NOT_ITERATED
7903 | OPTI_TYPE_APPENDED_SALT
7904 | OPTI_TYPE_RAW_HASH;
7905 dgst_pos0 = 3;
7906 dgst_pos1 = 4;
7907 dgst_pos2 = 2;
7908 dgst_pos3 = 1;
7909 break;
7910
7911 case 133: hash_type = HASH_TYPE_SHA1;
7912 salt_type = SALT_TYPE_EMBEDDED;
7913 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7914 opts_type = OPTS_TYPE_PT_GENERATE_BE
7915 | OPTS_TYPE_PT_UNICODE
7916 | OPTS_TYPE_ST_ADD80
7917 | OPTS_TYPE_ST_ADDBITS15;
7918 kern_type = KERN_TYPE_SHA1_PWUSLT;
7919 dgst_size = DGST_SIZE_4_5;
7920 parse_func = peoplesoft_parse_hash;
7921 sort_by_digest = sort_by_digest_4_5;
7922 opti_type = OPTI_TYPE_ZERO_BYTE
7923 | OPTI_TYPE_PRECOMPUTE_INIT
7924 | OPTI_TYPE_PRECOMPUTE_MERKLE
7925 | OPTI_TYPE_EARLY_SKIP
7926 | OPTI_TYPE_NOT_ITERATED
7927 | OPTI_TYPE_APPENDED_SALT
7928 | OPTI_TYPE_RAW_HASH;
7929 dgst_pos0 = 3;
7930 dgst_pos1 = 4;
7931 dgst_pos2 = 2;
7932 dgst_pos3 = 1;
7933 break;
7934
7935 case 140: hash_type = HASH_TYPE_SHA1;
7936 salt_type = SALT_TYPE_INTERN;
7937 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7938 opts_type = OPTS_TYPE_PT_GENERATE_BE
7939 | OPTS_TYPE_PT_ADD80
7940 | OPTS_TYPE_PT_ADDBITS15
7941 | OPTS_TYPE_PT_UNICODE;
7942 kern_type = KERN_TYPE_SHA1_SLTPWU;
7943 dgst_size = DGST_SIZE_4_5;
7944 parse_func = sha1s_parse_hash;
7945 sort_by_digest = sort_by_digest_4_5;
7946 opti_type = OPTI_TYPE_ZERO_BYTE
7947 | OPTI_TYPE_PRECOMPUTE_INIT
7948 | OPTI_TYPE_PRECOMPUTE_MERKLE
7949 | OPTI_TYPE_EARLY_SKIP
7950 | OPTI_TYPE_NOT_ITERATED
7951 | OPTI_TYPE_PREPENDED_SALT
7952 | OPTI_TYPE_RAW_HASH;
7953 dgst_pos0 = 3;
7954 dgst_pos1 = 4;
7955 dgst_pos2 = 2;
7956 dgst_pos3 = 1;
7957 break;
7958
7959 case 141: hash_type = HASH_TYPE_SHA1;
7960 salt_type = SALT_TYPE_EMBEDDED;
7961 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7962 opts_type = OPTS_TYPE_PT_GENERATE_BE
7963 | OPTS_TYPE_PT_ADD80
7964 | OPTS_TYPE_PT_ADDBITS15
7965 | OPTS_TYPE_PT_UNICODE
7966 | OPTS_TYPE_ST_BASE64;
7967 kern_type = KERN_TYPE_SHA1_SLTPWU;
7968 dgst_size = DGST_SIZE_4_5;
7969 parse_func = episerver_parse_hash;
7970 sort_by_digest = sort_by_digest_4_5;
7971 opti_type = OPTI_TYPE_ZERO_BYTE
7972 | OPTI_TYPE_PRECOMPUTE_INIT
7973 | OPTI_TYPE_PRECOMPUTE_MERKLE
7974 | OPTI_TYPE_EARLY_SKIP
7975 | OPTI_TYPE_NOT_ITERATED
7976 | OPTI_TYPE_PREPENDED_SALT
7977 | OPTI_TYPE_RAW_HASH;
7978 dgst_pos0 = 3;
7979 dgst_pos1 = 4;
7980 dgst_pos2 = 2;
7981 dgst_pos3 = 1;
7982 break;
7983
7984 case 150: hash_type = HASH_TYPE_SHA1;
7985 salt_type = SALT_TYPE_INTERN;
7986 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7987 opts_type = OPTS_TYPE_PT_GENERATE_BE
7988 | OPTS_TYPE_ST_ADD80
7989 | OPTS_TYPE_ST_ADDBITS15;
7990 kern_type = KERN_TYPE_HMACSHA1_PW;
7991 dgst_size = DGST_SIZE_4_5;
7992 parse_func = hmacsha1_parse_hash;
7993 sort_by_digest = sort_by_digest_4_5;
7994 opti_type = OPTI_TYPE_ZERO_BYTE
7995 | OPTI_TYPE_NOT_ITERATED;
7996 dgst_pos0 = 3;
7997 dgst_pos1 = 4;
7998 dgst_pos2 = 2;
7999 dgst_pos3 = 1;
8000 break;
8001
8002 case 160: hash_type = HASH_TYPE_SHA1;
8003 salt_type = SALT_TYPE_INTERN;
8004 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8005 opts_type = OPTS_TYPE_PT_GENERATE_BE
8006 | OPTS_TYPE_PT_ADD80
8007 | OPTS_TYPE_PT_ADDBITS15;
8008 kern_type = KERN_TYPE_HMACSHA1_SLT;
8009 dgst_size = DGST_SIZE_4_5;
8010 parse_func = hmacsha1_parse_hash;
8011 sort_by_digest = sort_by_digest_4_5;
8012 opti_type = OPTI_TYPE_ZERO_BYTE
8013 | OPTI_TYPE_NOT_ITERATED;
8014 dgst_pos0 = 3;
8015 dgst_pos1 = 4;
8016 dgst_pos2 = 2;
8017 dgst_pos3 = 1;
8018 break;
8019
8020 case 190: hash_type = HASH_TYPE_SHA1;
8021 salt_type = SALT_TYPE_NONE;
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 kern_type = KERN_TYPE_SHA1_LINKEDIN;
8027 dgst_size = DGST_SIZE_4_5;
8028 parse_func = sha1linkedin_parse_hash;
8029 sort_by_digest = sort_by_digest_4_5;
8030 opti_type = OPTI_TYPE_ZERO_BYTE
8031 | OPTI_TYPE_PRECOMPUTE_INIT
8032 | OPTI_TYPE_EARLY_SKIP
8033 | OPTI_TYPE_NOT_ITERATED
8034 | OPTI_TYPE_NOT_SALTED;
8035 dgst_pos0 = 0;
8036 dgst_pos1 = 4;
8037 dgst_pos2 = 3;
8038 dgst_pos3 = 2;
8039 break;
8040
8041 case 200: hash_type = HASH_TYPE_MYSQL;
8042 salt_type = SALT_TYPE_NONE;
8043 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8044 opts_type = 0;
8045 kern_type = KERN_TYPE_MYSQL;
8046 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8047 parse_func = mysql323_parse_hash;
8048 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8049 opti_type = OPTI_TYPE_ZERO_BYTE;
8050 dgst_pos0 = 0;
8051 dgst_pos1 = 1;
8052 dgst_pos2 = 2;
8053 dgst_pos3 = 3;
8054 break;
8055
8056 case 300: hash_type = HASH_TYPE_SHA1;
8057 salt_type = SALT_TYPE_NONE;
8058 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8059 opts_type = OPTS_TYPE_PT_GENERATE_BE
8060 | OPTS_TYPE_PT_ADD80
8061 | OPTS_TYPE_PT_ADDBITS15;
8062 kern_type = KERN_TYPE_MYSQL41;
8063 dgst_size = DGST_SIZE_4_5;
8064 parse_func = sha1_parse_hash;
8065 sort_by_digest = sort_by_digest_4_5;
8066 opti_type = OPTI_TYPE_ZERO_BYTE
8067 | OPTI_TYPE_PRECOMPUTE_INIT
8068 | OPTI_TYPE_PRECOMPUTE_MERKLE
8069 | OPTI_TYPE_EARLY_SKIP
8070 | OPTI_TYPE_NOT_ITERATED
8071 | OPTI_TYPE_NOT_SALTED;
8072 dgst_pos0 = 3;
8073 dgst_pos1 = 4;
8074 dgst_pos2 = 2;
8075 dgst_pos3 = 1;
8076 break;
8077
8078 case 400: hash_type = HASH_TYPE_MD5;
8079 salt_type = SALT_TYPE_EMBEDDED;
8080 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8081 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8082 kern_type = KERN_TYPE_PHPASS;
8083 dgst_size = DGST_SIZE_4_4;
8084 parse_func = phpass_parse_hash;
8085 sort_by_digest = sort_by_digest_4_4;
8086 opti_type = OPTI_TYPE_ZERO_BYTE
8087 | OPTI_TYPE_SLOW_HASH_SIMD;
8088 dgst_pos0 = 0;
8089 dgst_pos1 = 1;
8090 dgst_pos2 = 2;
8091 dgst_pos3 = 3;
8092 break;
8093
8094 case 500: hash_type = HASH_TYPE_MD5;
8095 salt_type = SALT_TYPE_EMBEDDED;
8096 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8097 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8098 kern_type = KERN_TYPE_MD5CRYPT;
8099 dgst_size = DGST_SIZE_4_4;
8100 parse_func = md5crypt_parse_hash;
8101 sort_by_digest = sort_by_digest_4_4;
8102 opti_type = OPTI_TYPE_ZERO_BYTE;
8103 dgst_pos0 = 0;
8104 dgst_pos1 = 1;
8105 dgst_pos2 = 2;
8106 dgst_pos3 = 3;
8107 break;
8108
8109 case 501: hash_type = HASH_TYPE_MD5;
8110 salt_type = SALT_TYPE_EMBEDDED;
8111 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8112 opts_type = OPTS_TYPE_PT_GENERATE_LE
8113 | OPTS_TYPE_HASH_COPY;
8114 kern_type = KERN_TYPE_MD5CRYPT;
8115 dgst_size = DGST_SIZE_4_4;
8116 parse_func = juniper_parse_hash;
8117 sort_by_digest = sort_by_digest_4_4;
8118 opti_type = OPTI_TYPE_ZERO_BYTE;
8119 dgst_pos0 = 0;
8120 dgst_pos1 = 1;
8121 dgst_pos2 = 2;
8122 dgst_pos3 = 3;
8123 break;
8124
8125 case 900: hash_type = HASH_TYPE_MD4;
8126 salt_type = SALT_TYPE_NONE;
8127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8128 opts_type = OPTS_TYPE_PT_GENERATE_LE
8129 | OPTS_TYPE_PT_ADD80
8130 | OPTS_TYPE_PT_ADDBITS14;
8131 kern_type = KERN_TYPE_MD4;
8132 dgst_size = DGST_SIZE_4_4;
8133 parse_func = md4_parse_hash;
8134 sort_by_digest = sort_by_digest_4_4;
8135 opti_type = OPTI_TYPE_ZERO_BYTE
8136 | OPTI_TYPE_PRECOMPUTE_INIT
8137 | OPTI_TYPE_PRECOMPUTE_MERKLE
8138 | OPTI_TYPE_MEET_IN_MIDDLE
8139 | OPTI_TYPE_EARLY_SKIP
8140 | OPTI_TYPE_NOT_ITERATED
8141 | OPTI_TYPE_NOT_SALTED
8142 | OPTI_TYPE_RAW_HASH;
8143 dgst_pos0 = 0;
8144 dgst_pos1 = 3;
8145 dgst_pos2 = 2;
8146 dgst_pos3 = 1;
8147 break;
8148
8149 case 1000: hash_type = HASH_TYPE_MD4;
8150 salt_type = SALT_TYPE_NONE;
8151 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8152 opts_type = OPTS_TYPE_PT_GENERATE_LE
8153 | OPTS_TYPE_PT_ADD80
8154 | OPTS_TYPE_PT_ADDBITS14
8155 | OPTS_TYPE_PT_UNICODE;
8156 kern_type = KERN_TYPE_MD4_PWU;
8157 dgst_size = DGST_SIZE_4_4;
8158 parse_func = md4_parse_hash;
8159 sort_by_digest = sort_by_digest_4_4;
8160 opti_type = OPTI_TYPE_ZERO_BYTE
8161 | OPTI_TYPE_PRECOMPUTE_INIT
8162 | OPTI_TYPE_PRECOMPUTE_MERKLE
8163 | OPTI_TYPE_MEET_IN_MIDDLE
8164 | OPTI_TYPE_EARLY_SKIP
8165 | OPTI_TYPE_NOT_ITERATED
8166 | OPTI_TYPE_NOT_SALTED
8167 | OPTI_TYPE_RAW_HASH;
8168 dgst_pos0 = 0;
8169 dgst_pos1 = 3;
8170 dgst_pos2 = 2;
8171 dgst_pos3 = 1;
8172 break;
8173
8174 case 1100: hash_type = HASH_TYPE_MD4;
8175 salt_type = SALT_TYPE_INTERN;
8176 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8177 opts_type = OPTS_TYPE_PT_GENERATE_LE
8178 | OPTS_TYPE_PT_ADD80
8179 | OPTS_TYPE_PT_ADDBITS14
8180 | OPTS_TYPE_PT_UNICODE
8181 | OPTS_TYPE_ST_ADD80
8182 | OPTS_TYPE_ST_UNICODE
8183 | OPTS_TYPE_ST_LOWER;
8184 kern_type = KERN_TYPE_MD44_PWUSLT;
8185 dgst_size = DGST_SIZE_4_4;
8186 parse_func = dcc_parse_hash;
8187 sort_by_digest = sort_by_digest_4_4;
8188 opti_type = OPTI_TYPE_ZERO_BYTE
8189 | OPTI_TYPE_PRECOMPUTE_INIT
8190 | OPTI_TYPE_PRECOMPUTE_MERKLE
8191 | OPTI_TYPE_EARLY_SKIP
8192 | OPTI_TYPE_NOT_ITERATED;
8193 dgst_pos0 = 0;
8194 dgst_pos1 = 3;
8195 dgst_pos2 = 2;
8196 dgst_pos3 = 1;
8197 break;
8198
8199 case 1400: hash_type = HASH_TYPE_SHA256;
8200 salt_type = SALT_TYPE_NONE;
8201 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8202 opts_type = OPTS_TYPE_PT_GENERATE_BE
8203 | OPTS_TYPE_PT_ADD80
8204 | OPTS_TYPE_PT_ADDBITS15;
8205 kern_type = KERN_TYPE_SHA256;
8206 dgst_size = DGST_SIZE_4_8;
8207 parse_func = sha256_parse_hash;
8208 sort_by_digest = sort_by_digest_4_8;
8209 opti_type = OPTI_TYPE_ZERO_BYTE
8210 | OPTI_TYPE_PRECOMPUTE_INIT
8211 | OPTI_TYPE_PRECOMPUTE_MERKLE
8212 | OPTI_TYPE_EARLY_SKIP
8213 | OPTI_TYPE_NOT_ITERATED
8214 | OPTI_TYPE_NOT_SALTED
8215 | OPTI_TYPE_RAW_HASH;
8216 dgst_pos0 = 3;
8217 dgst_pos1 = 7;
8218 dgst_pos2 = 2;
8219 dgst_pos3 = 6;
8220 break;
8221
8222 case 1410: hash_type = HASH_TYPE_SHA256;
8223 salt_type = SALT_TYPE_INTERN;
8224 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8225 opts_type = OPTS_TYPE_PT_GENERATE_BE
8226 | OPTS_TYPE_ST_ADD80
8227 | OPTS_TYPE_ST_ADDBITS15;
8228 kern_type = KERN_TYPE_SHA256_PWSLT;
8229 dgst_size = DGST_SIZE_4_8;
8230 parse_func = sha256s_parse_hash;
8231 sort_by_digest = sort_by_digest_4_8;
8232 opti_type = OPTI_TYPE_ZERO_BYTE
8233 | OPTI_TYPE_PRECOMPUTE_INIT
8234 | OPTI_TYPE_PRECOMPUTE_MERKLE
8235 | OPTI_TYPE_EARLY_SKIP
8236 | OPTI_TYPE_NOT_ITERATED
8237 | OPTI_TYPE_APPENDED_SALT
8238 | OPTI_TYPE_RAW_HASH;
8239 dgst_pos0 = 3;
8240 dgst_pos1 = 7;
8241 dgst_pos2 = 2;
8242 dgst_pos3 = 6;
8243 break;
8244
8245 case 1420: hash_type = HASH_TYPE_SHA256;
8246 salt_type = SALT_TYPE_INTERN;
8247 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8248 opts_type = OPTS_TYPE_PT_GENERATE_BE
8249 | OPTS_TYPE_PT_ADD80
8250 | OPTS_TYPE_PT_ADDBITS15;
8251 kern_type = KERN_TYPE_SHA256_SLTPW;
8252 dgst_size = DGST_SIZE_4_8;
8253 parse_func = sha256s_parse_hash;
8254 sort_by_digest = sort_by_digest_4_8;
8255 opti_type = OPTI_TYPE_ZERO_BYTE
8256 | OPTI_TYPE_PRECOMPUTE_INIT
8257 | OPTI_TYPE_PRECOMPUTE_MERKLE
8258 | OPTI_TYPE_EARLY_SKIP
8259 | OPTI_TYPE_NOT_ITERATED
8260 | OPTI_TYPE_PREPENDED_SALT
8261 | OPTI_TYPE_RAW_HASH;
8262 dgst_pos0 = 3;
8263 dgst_pos1 = 7;
8264 dgst_pos2 = 2;
8265 dgst_pos3 = 6;
8266 break;
8267
8268 case 1421: hash_type = HASH_TYPE_SHA256;
8269 salt_type = SALT_TYPE_EMBEDDED;
8270 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8271 opts_type = OPTS_TYPE_PT_GENERATE_BE
8272 | OPTS_TYPE_PT_ADD80
8273 | OPTS_TYPE_PT_ADDBITS15;
8274 kern_type = KERN_TYPE_SHA256_SLTPW;
8275 dgst_size = DGST_SIZE_4_8;
8276 parse_func = hmailserver_parse_hash;
8277 sort_by_digest = sort_by_digest_4_8;
8278 opti_type = OPTI_TYPE_ZERO_BYTE
8279 | OPTI_TYPE_PRECOMPUTE_INIT
8280 | OPTI_TYPE_PRECOMPUTE_MERKLE
8281 | OPTI_TYPE_EARLY_SKIP
8282 | OPTI_TYPE_NOT_ITERATED
8283 | OPTI_TYPE_PREPENDED_SALT
8284 | OPTI_TYPE_RAW_HASH;
8285 dgst_pos0 = 3;
8286 dgst_pos1 = 7;
8287 dgst_pos2 = 2;
8288 dgst_pos3 = 6;
8289 break;
8290
8291 case 1430: hash_type = HASH_TYPE_SHA256;
8292 salt_type = SALT_TYPE_INTERN;
8293 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8294 opts_type = OPTS_TYPE_PT_GENERATE_BE
8295 | OPTS_TYPE_PT_UNICODE
8296 | OPTS_TYPE_ST_ADD80
8297 | OPTS_TYPE_ST_ADDBITS15;
8298 kern_type = KERN_TYPE_SHA256_PWUSLT;
8299 dgst_size = DGST_SIZE_4_8;
8300 parse_func = sha256s_parse_hash;
8301 sort_by_digest = sort_by_digest_4_8;
8302 opti_type = OPTI_TYPE_ZERO_BYTE
8303 | OPTI_TYPE_PRECOMPUTE_INIT
8304 | OPTI_TYPE_PRECOMPUTE_MERKLE
8305 | OPTI_TYPE_EARLY_SKIP
8306 | OPTI_TYPE_NOT_ITERATED
8307 | OPTI_TYPE_APPENDED_SALT
8308 | OPTI_TYPE_RAW_HASH;
8309 dgst_pos0 = 3;
8310 dgst_pos1 = 7;
8311 dgst_pos2 = 2;
8312 dgst_pos3 = 6;
8313 break;
8314
8315 case 1440: hash_type = HASH_TYPE_SHA256;
8316 salt_type = SALT_TYPE_INTERN;
8317 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8318 opts_type = OPTS_TYPE_PT_GENERATE_BE
8319 | OPTS_TYPE_PT_ADD80
8320 | OPTS_TYPE_PT_ADDBITS15
8321 | OPTS_TYPE_PT_UNICODE;
8322 kern_type = KERN_TYPE_SHA256_SLTPWU;
8323 dgst_size = DGST_SIZE_4_8;
8324 parse_func = sha256s_parse_hash;
8325 sort_by_digest = sort_by_digest_4_8;
8326 opti_type = OPTI_TYPE_ZERO_BYTE
8327 | OPTI_TYPE_PRECOMPUTE_INIT
8328 | OPTI_TYPE_PRECOMPUTE_MERKLE
8329 | OPTI_TYPE_EARLY_SKIP
8330 | OPTI_TYPE_NOT_ITERATED
8331 | OPTI_TYPE_PREPENDED_SALT
8332 | OPTI_TYPE_RAW_HASH;
8333 dgst_pos0 = 3;
8334 dgst_pos1 = 7;
8335 dgst_pos2 = 2;
8336 dgst_pos3 = 6;
8337 break;
8338
8339 case 1441: hash_type = HASH_TYPE_SHA256;
8340 salt_type = SALT_TYPE_EMBEDDED;
8341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8342 opts_type = OPTS_TYPE_PT_GENERATE_BE
8343 | OPTS_TYPE_PT_ADD80
8344 | OPTS_TYPE_PT_ADDBITS15
8345 | OPTS_TYPE_PT_UNICODE
8346 | OPTS_TYPE_ST_BASE64;
8347 kern_type = KERN_TYPE_SHA256_SLTPWU;
8348 dgst_size = DGST_SIZE_4_8;
8349 parse_func = episerver4_parse_hash;
8350 sort_by_digest = sort_by_digest_4_8;
8351 opti_type = OPTI_TYPE_ZERO_BYTE
8352 | OPTI_TYPE_PRECOMPUTE_INIT
8353 | OPTI_TYPE_PRECOMPUTE_MERKLE
8354 | OPTI_TYPE_EARLY_SKIP
8355 | OPTI_TYPE_NOT_ITERATED
8356 | OPTI_TYPE_PREPENDED_SALT
8357 | OPTI_TYPE_RAW_HASH;
8358 dgst_pos0 = 3;
8359 dgst_pos1 = 7;
8360 dgst_pos2 = 2;
8361 dgst_pos3 = 6;
8362 break;
8363
8364 case 1450: hash_type = HASH_TYPE_SHA256;
8365 salt_type = SALT_TYPE_INTERN;
8366 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8367 opts_type = OPTS_TYPE_PT_GENERATE_BE
8368 | OPTS_TYPE_ST_ADD80;
8369 kern_type = KERN_TYPE_HMACSHA256_PW;
8370 dgst_size = DGST_SIZE_4_8;
8371 parse_func = hmacsha256_parse_hash;
8372 sort_by_digest = sort_by_digest_4_8;
8373 opti_type = OPTI_TYPE_ZERO_BYTE
8374 | OPTI_TYPE_NOT_ITERATED;
8375 dgst_pos0 = 3;
8376 dgst_pos1 = 7;
8377 dgst_pos2 = 2;
8378 dgst_pos3 = 6;
8379 break;
8380
8381 case 1460: hash_type = HASH_TYPE_SHA256;
8382 salt_type = SALT_TYPE_INTERN;
8383 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8384 opts_type = OPTS_TYPE_PT_GENERATE_BE
8385 | OPTS_TYPE_PT_ADD80
8386 | OPTS_TYPE_PT_ADDBITS15;
8387 kern_type = KERN_TYPE_HMACSHA256_SLT;
8388 dgst_size = DGST_SIZE_4_8;
8389 parse_func = hmacsha256_parse_hash;
8390 sort_by_digest = sort_by_digest_4_8;
8391 opti_type = OPTI_TYPE_ZERO_BYTE
8392 | OPTI_TYPE_NOT_ITERATED;
8393 dgst_pos0 = 3;
8394 dgst_pos1 = 7;
8395 dgst_pos2 = 2;
8396 dgst_pos3 = 6;
8397 break;
8398
8399 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8400 salt_type = SALT_TYPE_EMBEDDED;
8401 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8402 opts_type = OPTS_TYPE_PT_GENERATE_LE
8403 | OPTS_TYPE_PT_BITSLICE;
8404 kern_type = KERN_TYPE_DESCRYPT;
8405 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8406 parse_func = descrypt_parse_hash;
8407 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8408 opti_type = OPTI_TYPE_ZERO_BYTE
8409 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8410 dgst_pos0 = 0;
8411 dgst_pos1 = 1;
8412 dgst_pos2 = 2;
8413 dgst_pos3 = 3;
8414 break;
8415
8416 case 1600: hash_type = HASH_TYPE_MD5;
8417 salt_type = SALT_TYPE_EMBEDDED;
8418 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8419 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8420 kern_type = KERN_TYPE_APR1CRYPT;
8421 dgst_size = DGST_SIZE_4_4;
8422 parse_func = md5apr1_parse_hash;
8423 sort_by_digest = sort_by_digest_4_4;
8424 opti_type = OPTI_TYPE_ZERO_BYTE;
8425 dgst_pos0 = 0;
8426 dgst_pos1 = 1;
8427 dgst_pos2 = 2;
8428 dgst_pos3 = 3;
8429 break;
8430
8431 case 1700: hash_type = HASH_TYPE_SHA512;
8432 salt_type = SALT_TYPE_NONE;
8433 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8434 opts_type = OPTS_TYPE_PT_GENERATE_BE
8435 | OPTS_TYPE_PT_ADD80
8436 | OPTS_TYPE_PT_ADDBITS15;
8437 kern_type = KERN_TYPE_SHA512;
8438 dgst_size = DGST_SIZE_8_8;
8439 parse_func = sha512_parse_hash;
8440 sort_by_digest = sort_by_digest_8_8;
8441 opti_type = OPTI_TYPE_ZERO_BYTE
8442 | OPTI_TYPE_PRECOMPUTE_INIT
8443 | OPTI_TYPE_PRECOMPUTE_MERKLE
8444 | OPTI_TYPE_EARLY_SKIP
8445 | OPTI_TYPE_NOT_ITERATED
8446 | OPTI_TYPE_NOT_SALTED
8447 | OPTI_TYPE_USES_BITS_64
8448 | OPTI_TYPE_RAW_HASH;
8449 dgst_pos0 = 14;
8450 dgst_pos1 = 15;
8451 dgst_pos2 = 6;
8452 dgst_pos3 = 7;
8453 break;
8454
8455 case 1710: hash_type = HASH_TYPE_SHA512;
8456 salt_type = SALT_TYPE_INTERN;
8457 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8458 opts_type = OPTS_TYPE_PT_GENERATE_BE
8459 | OPTS_TYPE_ST_ADD80
8460 | OPTS_TYPE_ST_ADDBITS15;
8461 kern_type = KERN_TYPE_SHA512_PWSLT;
8462 dgst_size = DGST_SIZE_8_8;
8463 parse_func = sha512s_parse_hash;
8464 sort_by_digest = sort_by_digest_8_8;
8465 opti_type = OPTI_TYPE_ZERO_BYTE
8466 | OPTI_TYPE_PRECOMPUTE_INIT
8467 | OPTI_TYPE_PRECOMPUTE_MERKLE
8468 | OPTI_TYPE_EARLY_SKIP
8469 | OPTI_TYPE_NOT_ITERATED
8470 | OPTI_TYPE_APPENDED_SALT
8471 | OPTI_TYPE_USES_BITS_64
8472 | OPTI_TYPE_RAW_HASH;
8473 dgst_pos0 = 14;
8474 dgst_pos1 = 15;
8475 dgst_pos2 = 6;
8476 dgst_pos3 = 7;
8477 break;
8478
8479 case 1711: hash_type = HASH_TYPE_SHA512;
8480 salt_type = SALT_TYPE_EMBEDDED;
8481 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8482 opts_type = OPTS_TYPE_PT_GENERATE_BE
8483 | OPTS_TYPE_ST_ADD80
8484 | OPTS_TYPE_ST_ADDBITS15;
8485 kern_type = KERN_TYPE_SHA512_PWSLT;
8486 dgst_size = DGST_SIZE_8_8;
8487 parse_func = sha512b64s_parse_hash;
8488 sort_by_digest = sort_by_digest_8_8;
8489 opti_type = OPTI_TYPE_ZERO_BYTE
8490 | OPTI_TYPE_PRECOMPUTE_INIT
8491 | OPTI_TYPE_PRECOMPUTE_MERKLE
8492 | OPTI_TYPE_EARLY_SKIP
8493 | OPTI_TYPE_NOT_ITERATED
8494 | OPTI_TYPE_APPENDED_SALT
8495 | OPTI_TYPE_USES_BITS_64
8496 | OPTI_TYPE_RAW_HASH;
8497 dgst_pos0 = 14;
8498 dgst_pos1 = 15;
8499 dgst_pos2 = 6;
8500 dgst_pos3 = 7;
8501 break;
8502
8503 case 1720: hash_type = HASH_TYPE_SHA512;
8504 salt_type = SALT_TYPE_INTERN;
8505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8506 opts_type = OPTS_TYPE_PT_GENERATE_BE
8507 | OPTS_TYPE_PT_ADD80
8508 | OPTS_TYPE_PT_ADDBITS15;
8509 kern_type = KERN_TYPE_SHA512_SLTPW;
8510 dgst_size = DGST_SIZE_8_8;
8511 parse_func = sha512s_parse_hash;
8512 sort_by_digest = sort_by_digest_8_8;
8513 opti_type = OPTI_TYPE_ZERO_BYTE
8514 | OPTI_TYPE_PRECOMPUTE_INIT
8515 | OPTI_TYPE_PRECOMPUTE_MERKLE
8516 | OPTI_TYPE_EARLY_SKIP
8517 | OPTI_TYPE_NOT_ITERATED
8518 | OPTI_TYPE_PREPENDED_SALT
8519 | OPTI_TYPE_USES_BITS_64
8520 | OPTI_TYPE_RAW_HASH;
8521 dgst_pos0 = 14;
8522 dgst_pos1 = 15;
8523 dgst_pos2 = 6;
8524 dgst_pos3 = 7;
8525 break;
8526
8527 case 1722: hash_type = HASH_TYPE_SHA512;
8528 salt_type = SALT_TYPE_EMBEDDED;
8529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8530 opts_type = OPTS_TYPE_PT_GENERATE_BE
8531 | OPTS_TYPE_PT_ADD80
8532 | OPTS_TYPE_PT_ADDBITS15
8533 | OPTS_TYPE_ST_HEX;
8534 kern_type = KERN_TYPE_SHA512_SLTPW;
8535 dgst_size = DGST_SIZE_8_8;
8536 parse_func = osx512_parse_hash;
8537 sort_by_digest = sort_by_digest_8_8;
8538 opti_type = OPTI_TYPE_ZERO_BYTE
8539 | OPTI_TYPE_PRECOMPUTE_INIT
8540 | OPTI_TYPE_PRECOMPUTE_MERKLE
8541 | OPTI_TYPE_EARLY_SKIP
8542 | OPTI_TYPE_NOT_ITERATED
8543 | OPTI_TYPE_PREPENDED_SALT
8544 | OPTI_TYPE_USES_BITS_64
8545 | OPTI_TYPE_RAW_HASH;
8546 dgst_pos0 = 14;
8547 dgst_pos1 = 15;
8548 dgst_pos2 = 6;
8549 dgst_pos3 = 7;
8550 break;
8551
8552 case 1730: hash_type = HASH_TYPE_SHA512;
8553 salt_type = SALT_TYPE_INTERN;
8554 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8555 opts_type = OPTS_TYPE_PT_GENERATE_BE
8556 | OPTS_TYPE_PT_UNICODE
8557 | OPTS_TYPE_ST_ADD80
8558 | OPTS_TYPE_ST_ADDBITS15;
8559 kern_type = KERN_TYPE_SHA512_PWSLTU;
8560 dgst_size = DGST_SIZE_8_8;
8561 parse_func = sha512s_parse_hash;
8562 sort_by_digest = sort_by_digest_8_8;
8563 opti_type = OPTI_TYPE_ZERO_BYTE
8564 | OPTI_TYPE_PRECOMPUTE_INIT
8565 | OPTI_TYPE_PRECOMPUTE_MERKLE
8566 | OPTI_TYPE_EARLY_SKIP
8567 | OPTI_TYPE_NOT_ITERATED
8568 | OPTI_TYPE_APPENDED_SALT
8569 | OPTI_TYPE_USES_BITS_64
8570 | OPTI_TYPE_RAW_HASH;
8571 dgst_pos0 = 14;
8572 dgst_pos1 = 15;
8573 dgst_pos2 = 6;
8574 dgst_pos3 = 7;
8575 break;
8576
8577 case 1731: hash_type = HASH_TYPE_SHA512;
8578 salt_type = SALT_TYPE_EMBEDDED;
8579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8580 opts_type = OPTS_TYPE_PT_GENERATE_BE
8581 | OPTS_TYPE_PT_UNICODE
8582 | OPTS_TYPE_ST_ADD80
8583 | OPTS_TYPE_ST_ADDBITS15
8584 | OPTS_TYPE_ST_HEX;
8585 kern_type = KERN_TYPE_SHA512_PWSLTU;
8586 dgst_size = DGST_SIZE_8_8;
8587 parse_func = mssql2012_parse_hash;
8588 sort_by_digest = sort_by_digest_8_8;
8589 opti_type = OPTI_TYPE_ZERO_BYTE
8590 | OPTI_TYPE_PRECOMPUTE_INIT
8591 | OPTI_TYPE_PRECOMPUTE_MERKLE
8592 | OPTI_TYPE_EARLY_SKIP
8593 | OPTI_TYPE_NOT_ITERATED
8594 | OPTI_TYPE_APPENDED_SALT
8595 | OPTI_TYPE_USES_BITS_64
8596 | OPTI_TYPE_RAW_HASH;
8597 dgst_pos0 = 14;
8598 dgst_pos1 = 15;
8599 dgst_pos2 = 6;
8600 dgst_pos3 = 7;
8601 break;
8602
8603 case 1740: hash_type = HASH_TYPE_SHA512;
8604 salt_type = SALT_TYPE_INTERN;
8605 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8606 opts_type = OPTS_TYPE_PT_GENERATE_BE
8607 | OPTS_TYPE_PT_ADD80
8608 | OPTS_TYPE_PT_ADDBITS15
8609 | OPTS_TYPE_PT_UNICODE;
8610 kern_type = KERN_TYPE_SHA512_SLTPWU;
8611 dgst_size = DGST_SIZE_8_8;
8612 parse_func = sha512s_parse_hash;
8613 sort_by_digest = sort_by_digest_8_8;
8614 opti_type = OPTI_TYPE_ZERO_BYTE
8615 | OPTI_TYPE_PRECOMPUTE_INIT
8616 | OPTI_TYPE_PRECOMPUTE_MERKLE
8617 | OPTI_TYPE_EARLY_SKIP
8618 | OPTI_TYPE_NOT_ITERATED
8619 | OPTI_TYPE_PREPENDED_SALT
8620 | OPTI_TYPE_USES_BITS_64
8621 | OPTI_TYPE_RAW_HASH;
8622 dgst_pos0 = 14;
8623 dgst_pos1 = 15;
8624 dgst_pos2 = 6;
8625 dgst_pos3 = 7;
8626 break;
8627
8628 case 1750: hash_type = HASH_TYPE_SHA512;
8629 salt_type = SALT_TYPE_INTERN;
8630 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8631 opts_type = OPTS_TYPE_PT_GENERATE_BE
8632 | OPTS_TYPE_ST_ADD80;
8633 kern_type = KERN_TYPE_HMACSHA512_PW;
8634 dgst_size = DGST_SIZE_8_8;
8635 parse_func = hmacsha512_parse_hash;
8636 sort_by_digest = sort_by_digest_8_8;
8637 opti_type = OPTI_TYPE_ZERO_BYTE
8638 | OPTI_TYPE_USES_BITS_64
8639 | OPTI_TYPE_NOT_ITERATED;
8640 dgst_pos0 = 14;
8641 dgst_pos1 = 15;
8642 dgst_pos2 = 6;
8643 dgst_pos3 = 7;
8644 break;
8645
8646 case 1760: hash_type = HASH_TYPE_SHA512;
8647 salt_type = SALT_TYPE_INTERN;
8648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8649 opts_type = OPTS_TYPE_PT_GENERATE_BE
8650 | OPTS_TYPE_PT_ADD80
8651 | OPTS_TYPE_PT_ADDBITS15;
8652 kern_type = KERN_TYPE_HMACSHA512_SLT;
8653 dgst_size = DGST_SIZE_8_8;
8654 parse_func = hmacsha512_parse_hash;
8655 sort_by_digest = sort_by_digest_8_8;
8656 opti_type = OPTI_TYPE_ZERO_BYTE
8657 | OPTI_TYPE_USES_BITS_64
8658 | OPTI_TYPE_NOT_ITERATED;
8659 dgst_pos0 = 14;
8660 dgst_pos1 = 15;
8661 dgst_pos2 = 6;
8662 dgst_pos3 = 7;
8663 break;
8664
8665 case 1800: hash_type = HASH_TYPE_SHA512;
8666 salt_type = SALT_TYPE_EMBEDDED;
8667 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8668 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8669 kern_type = KERN_TYPE_SHA512CRYPT;
8670 dgst_size = DGST_SIZE_8_8;
8671 parse_func = sha512crypt_parse_hash;
8672 sort_by_digest = sort_by_digest_8_8;
8673 opti_type = OPTI_TYPE_ZERO_BYTE
8674 | OPTI_TYPE_USES_BITS_64;
8675 dgst_pos0 = 0;
8676 dgst_pos1 = 1;
8677 dgst_pos2 = 2;
8678 dgst_pos3 = 3;
8679 break;
8680
8681 case 2000: hash_type = HASH_TYPE_STDOUT;
8682 salt_type = SALT_TYPE_NONE;
8683 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8684 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8685 kern_type = 0;
8686 dgst_size = DGST_SIZE_4_4;
8687 parse_func = NULL;
8688 sort_by_digest = NULL;
8689 opti_type = 0;
8690 dgst_pos0 = 0;
8691 dgst_pos1 = 0;
8692 dgst_pos2 = 0;
8693 dgst_pos3 = 0;
8694 break;
8695
8696 case 2100: hash_type = HASH_TYPE_DCC2;
8697 salt_type = SALT_TYPE_EMBEDDED;
8698 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8699 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8700 | OPTS_TYPE_ST_LOWER
8701 | OPTS_TYPE_ST_UNICODE;
8702 kern_type = KERN_TYPE_DCC2;
8703 dgst_size = DGST_SIZE_4_4;
8704 parse_func = dcc2_parse_hash;
8705 sort_by_digest = sort_by_digest_4_4;
8706 opti_type = OPTI_TYPE_ZERO_BYTE
8707 | OPTI_TYPE_SLOW_HASH_SIMD;
8708 dgst_pos0 = 0;
8709 dgst_pos1 = 1;
8710 dgst_pos2 = 2;
8711 dgst_pos3 = 3;
8712 break;
8713
8714 case 2400: hash_type = HASH_TYPE_MD5;
8715 salt_type = SALT_TYPE_NONE;
8716 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8717 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8718 kern_type = KERN_TYPE_MD5PIX;
8719 dgst_size = DGST_SIZE_4_4;
8720 parse_func = md5pix_parse_hash;
8721 sort_by_digest = sort_by_digest_4_4;
8722 opti_type = OPTI_TYPE_ZERO_BYTE
8723 | OPTI_TYPE_PRECOMPUTE_INIT
8724 | OPTI_TYPE_PRECOMPUTE_MERKLE
8725 | OPTI_TYPE_EARLY_SKIP
8726 | OPTI_TYPE_NOT_ITERATED
8727 | OPTI_TYPE_NOT_SALTED;
8728 dgst_pos0 = 0;
8729 dgst_pos1 = 3;
8730 dgst_pos2 = 2;
8731 dgst_pos3 = 1;
8732 break;
8733
8734 case 2410: hash_type = HASH_TYPE_MD5;
8735 salt_type = SALT_TYPE_INTERN;
8736 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8737 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8738 kern_type = KERN_TYPE_MD5ASA;
8739 dgst_size = DGST_SIZE_4_4;
8740 parse_func = md5asa_parse_hash;
8741 sort_by_digest = sort_by_digest_4_4;
8742 opti_type = OPTI_TYPE_ZERO_BYTE
8743 | OPTI_TYPE_PRECOMPUTE_INIT
8744 | OPTI_TYPE_PRECOMPUTE_MERKLE
8745 | OPTI_TYPE_EARLY_SKIP
8746 | OPTI_TYPE_NOT_ITERATED;
8747 dgst_pos0 = 0;
8748 dgst_pos1 = 3;
8749 dgst_pos2 = 2;
8750 dgst_pos3 = 1;
8751 break;
8752
8753 case 2500: hash_type = HASH_TYPE_WPA;
8754 salt_type = SALT_TYPE_EMBEDDED;
8755 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8756 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8757 kern_type = KERN_TYPE_WPA;
8758 dgst_size = DGST_SIZE_4_4;
8759 parse_func = wpa_parse_hash;
8760 sort_by_digest = sort_by_digest_4_4;
8761 opti_type = OPTI_TYPE_ZERO_BYTE
8762 | OPTI_TYPE_SLOW_HASH_SIMD;
8763 dgst_pos0 = 0;
8764 dgst_pos1 = 1;
8765 dgst_pos2 = 2;
8766 dgst_pos3 = 3;
8767 break;
8768
8769 case 2600: hash_type = HASH_TYPE_MD5;
8770 salt_type = SALT_TYPE_VIRTUAL;
8771 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8772 opts_type = OPTS_TYPE_PT_GENERATE_LE
8773 | OPTS_TYPE_PT_ADD80
8774 | OPTS_TYPE_PT_ADDBITS14
8775 | OPTS_TYPE_ST_ADD80;
8776 kern_type = KERN_TYPE_MD55_PWSLT1;
8777 dgst_size = DGST_SIZE_4_4;
8778 parse_func = md5md5_parse_hash;
8779 sort_by_digest = sort_by_digest_4_4;
8780 opti_type = OPTI_TYPE_ZERO_BYTE
8781 | OPTI_TYPE_PRECOMPUTE_INIT
8782 | OPTI_TYPE_PRECOMPUTE_MERKLE
8783 | OPTI_TYPE_EARLY_SKIP;
8784 dgst_pos0 = 0;
8785 dgst_pos1 = 3;
8786 dgst_pos2 = 2;
8787 dgst_pos3 = 1;
8788 break;
8789
8790 case 2611: hash_type = HASH_TYPE_MD5;
8791 salt_type = SALT_TYPE_INTERN;
8792 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8793 opts_type = OPTS_TYPE_PT_GENERATE_LE
8794 | OPTS_TYPE_PT_ADD80
8795 | OPTS_TYPE_PT_ADDBITS14
8796 | OPTS_TYPE_ST_ADD80;
8797 kern_type = KERN_TYPE_MD55_PWSLT1;
8798 dgst_size = DGST_SIZE_4_4;
8799 parse_func = vb3_parse_hash;
8800 sort_by_digest = sort_by_digest_4_4;
8801 opti_type = OPTI_TYPE_ZERO_BYTE
8802 | OPTI_TYPE_PRECOMPUTE_INIT
8803 | OPTI_TYPE_PRECOMPUTE_MERKLE
8804 | OPTI_TYPE_EARLY_SKIP;
8805 dgst_pos0 = 0;
8806 dgst_pos1 = 3;
8807 dgst_pos2 = 2;
8808 dgst_pos3 = 1;
8809 break;
8810
8811 case 2612: hash_type = HASH_TYPE_MD5;
8812 salt_type = SALT_TYPE_EMBEDDED;
8813 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8814 opts_type = OPTS_TYPE_PT_GENERATE_LE
8815 | OPTS_TYPE_PT_ADD80
8816 | OPTS_TYPE_PT_ADDBITS14
8817 | OPTS_TYPE_ST_ADD80
8818 | OPTS_TYPE_ST_HEX;
8819 kern_type = KERN_TYPE_MD55_PWSLT1;
8820 dgst_size = DGST_SIZE_4_4;
8821 parse_func = phps_parse_hash;
8822 sort_by_digest = sort_by_digest_4_4;
8823 opti_type = OPTI_TYPE_ZERO_BYTE
8824 | OPTI_TYPE_PRECOMPUTE_INIT
8825 | OPTI_TYPE_PRECOMPUTE_MERKLE
8826 | OPTI_TYPE_EARLY_SKIP;
8827 dgst_pos0 = 0;
8828 dgst_pos1 = 3;
8829 dgst_pos2 = 2;
8830 dgst_pos3 = 1;
8831 break;
8832
8833 case 2711: hash_type = HASH_TYPE_MD5;
8834 salt_type = SALT_TYPE_INTERN;
8835 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8836 opts_type = OPTS_TYPE_PT_GENERATE_LE
8837 | OPTS_TYPE_PT_ADD80
8838 | OPTS_TYPE_PT_ADDBITS14
8839 | OPTS_TYPE_ST_ADD80;
8840 kern_type = KERN_TYPE_MD55_PWSLT2;
8841 dgst_size = DGST_SIZE_4_4;
8842 parse_func = vb30_parse_hash;
8843 sort_by_digest = sort_by_digest_4_4;
8844 opti_type = OPTI_TYPE_ZERO_BYTE
8845 | OPTI_TYPE_PRECOMPUTE_INIT
8846 | OPTI_TYPE_EARLY_SKIP;
8847 dgst_pos0 = 0;
8848 dgst_pos1 = 3;
8849 dgst_pos2 = 2;
8850 dgst_pos3 = 1;
8851 break;
8852
8853 case 2811: hash_type = HASH_TYPE_MD5;
8854 salt_type = SALT_TYPE_INTERN;
8855 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8856 opts_type = OPTS_TYPE_PT_GENERATE_LE
8857 | OPTS_TYPE_PT_ADD80
8858 | OPTS_TYPE_PT_ADDBITS14;
8859 kern_type = KERN_TYPE_MD55_SLTPW;
8860 dgst_size = DGST_SIZE_4_4;
8861 parse_func = ipb2_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_EARLY_SKIP;
8866 dgst_pos0 = 0;
8867 dgst_pos1 = 3;
8868 dgst_pos2 = 2;
8869 dgst_pos3 = 1;
8870 break;
8871
8872 case 3000: hash_type = HASH_TYPE_LM;
8873 salt_type = SALT_TYPE_NONE;
8874 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8875 opts_type = OPTS_TYPE_PT_GENERATE_LE
8876 | OPTS_TYPE_PT_UPPER
8877 | OPTS_TYPE_PT_BITSLICE;
8878 kern_type = KERN_TYPE_LM;
8879 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8880 parse_func = lm_parse_hash;
8881 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8882 opti_type = OPTI_TYPE_ZERO_BYTE
8883 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8884 dgst_pos0 = 0;
8885 dgst_pos1 = 1;
8886 dgst_pos2 = 2;
8887 dgst_pos3 = 3;
8888 break;
8889
8890 case 3100: hash_type = HASH_TYPE_ORACLEH;
8891 salt_type = SALT_TYPE_INTERN;
8892 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8893 opts_type = OPTS_TYPE_PT_GENERATE_LE
8894 | OPTS_TYPE_PT_UPPER
8895 | OPTS_TYPE_ST_UPPER;
8896 kern_type = KERN_TYPE_ORACLEH;
8897 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8898 parse_func = oracleh_parse_hash;
8899 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8900 opti_type = OPTI_TYPE_ZERO_BYTE;
8901 dgst_pos0 = 0;
8902 dgst_pos1 = 1;
8903 dgst_pos2 = 2;
8904 dgst_pos3 = 3;
8905 break;
8906
8907 case 3200: hash_type = HASH_TYPE_BCRYPT;
8908 salt_type = SALT_TYPE_EMBEDDED;
8909 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8910 opts_type = OPTS_TYPE_PT_GENERATE_LE
8911 | OPTS_TYPE_ST_GENERATE_LE;
8912 kern_type = KERN_TYPE_BCRYPT;
8913 dgst_size = DGST_SIZE_4_6;
8914 parse_func = bcrypt_parse_hash;
8915 sort_by_digest = sort_by_digest_4_6;
8916 opti_type = OPTI_TYPE_ZERO_BYTE;
8917 dgst_pos0 = 0;
8918 dgst_pos1 = 1;
8919 dgst_pos2 = 2;
8920 dgst_pos3 = 3;
8921 break;
8922
8923 case 3710: hash_type = HASH_TYPE_MD5;
8924 salt_type = SALT_TYPE_INTERN;
8925 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8926 opts_type = OPTS_TYPE_PT_GENERATE_LE
8927 | OPTS_TYPE_PT_ADD80
8928 | OPTS_TYPE_PT_ADDBITS14;
8929 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8930 dgst_size = DGST_SIZE_4_4;
8931 parse_func = md5s_parse_hash;
8932 sort_by_digest = sort_by_digest_4_4;
8933 opti_type = OPTI_TYPE_ZERO_BYTE
8934 | OPTI_TYPE_PRECOMPUTE_INIT
8935 | OPTI_TYPE_PRECOMPUTE_MERKLE
8936 | OPTI_TYPE_EARLY_SKIP;
8937 dgst_pos0 = 0;
8938 dgst_pos1 = 3;
8939 dgst_pos2 = 2;
8940 dgst_pos3 = 1;
8941 break;
8942
8943 case 3711: hash_type = HASH_TYPE_MD5;
8944 salt_type = SALT_TYPE_EMBEDDED;
8945 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8946 opts_type = OPTS_TYPE_PT_GENERATE_LE
8947 | OPTS_TYPE_PT_ADD80
8948 | OPTS_TYPE_PT_ADDBITS14;
8949 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8950 dgst_size = DGST_SIZE_4_4;
8951 parse_func = mediawiki_b_parse_hash;
8952 sort_by_digest = sort_by_digest_4_4;
8953 opti_type = OPTI_TYPE_ZERO_BYTE
8954 | OPTI_TYPE_PRECOMPUTE_INIT
8955 | OPTI_TYPE_PRECOMPUTE_MERKLE
8956 | OPTI_TYPE_EARLY_SKIP;
8957 dgst_pos0 = 0;
8958 dgst_pos1 = 3;
8959 dgst_pos2 = 2;
8960 dgst_pos3 = 1;
8961 break;
8962
8963 case 3800: 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_ST_ADDBITS14;
8968 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8969 dgst_size = DGST_SIZE_4_4;
8970 parse_func = md5s_parse_hash;
8971 sort_by_digest = sort_by_digest_4_4;
8972 opti_type = OPTI_TYPE_ZERO_BYTE
8973 | OPTI_TYPE_PRECOMPUTE_INIT
8974 | OPTI_TYPE_PRECOMPUTE_MERKLE
8975 | OPTI_TYPE_EARLY_SKIP
8976 | OPTI_TYPE_NOT_ITERATED
8977 | OPTI_TYPE_RAW_HASH;
8978 dgst_pos0 = 0;
8979 dgst_pos1 = 3;
8980 dgst_pos2 = 2;
8981 dgst_pos3 = 1;
8982 break;
8983
8984 case 4300: hash_type = HASH_TYPE_MD5;
8985 salt_type = SALT_TYPE_VIRTUAL;
8986 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8987 opts_type = OPTS_TYPE_PT_GENERATE_LE
8988 | OPTS_TYPE_PT_ADD80
8989 | OPTS_TYPE_PT_ADDBITS14
8990 | OPTS_TYPE_ST_ADD80;
8991 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8992 dgst_size = DGST_SIZE_4_4;
8993 parse_func = md5md5_parse_hash;
8994 sort_by_digest = sort_by_digest_4_4;
8995 opti_type = OPTI_TYPE_ZERO_BYTE
8996 | OPTI_TYPE_PRECOMPUTE_INIT
8997 | OPTI_TYPE_PRECOMPUTE_MERKLE
8998 | OPTI_TYPE_EARLY_SKIP;
8999 dgst_pos0 = 0;
9000 dgst_pos1 = 3;
9001 dgst_pos2 = 2;
9002 dgst_pos3 = 1;
9003 break;
9004
9005
9006 case 4400: hash_type = HASH_TYPE_MD5;
9007 salt_type = SALT_TYPE_NONE;
9008 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9009 opts_type = OPTS_TYPE_PT_GENERATE_BE
9010 | OPTS_TYPE_PT_ADD80
9011 | OPTS_TYPE_PT_ADDBITS15;
9012 kern_type = KERN_TYPE_MD5_SHA1;
9013 dgst_size = DGST_SIZE_4_4;
9014 parse_func = md5_parse_hash;
9015 sort_by_digest = sort_by_digest_4_4;
9016 opti_type = OPTI_TYPE_ZERO_BYTE
9017 | OPTI_TYPE_PRECOMPUTE_INIT
9018 | OPTI_TYPE_PRECOMPUTE_MERKLE
9019 | OPTI_TYPE_EARLY_SKIP
9020 | OPTI_TYPE_NOT_ITERATED
9021 | OPTI_TYPE_NOT_SALTED
9022 | OPTI_TYPE_RAW_HASH;
9023 dgst_pos0 = 0;
9024 dgst_pos1 = 3;
9025 dgst_pos2 = 2;
9026 dgst_pos3 = 1;
9027 break;
9028
9029 case 4500: hash_type = HASH_TYPE_SHA1;
9030 salt_type = SALT_TYPE_NONE;
9031 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9032 opts_type = OPTS_TYPE_PT_GENERATE_BE
9033 | OPTS_TYPE_PT_ADD80
9034 | OPTS_TYPE_PT_ADDBITS15;
9035 kern_type = KERN_TYPE_SHA11;
9036 dgst_size = DGST_SIZE_4_5;
9037 parse_func = sha1_parse_hash;
9038 sort_by_digest = sort_by_digest_4_5;
9039 opti_type = OPTI_TYPE_ZERO_BYTE
9040 | OPTI_TYPE_PRECOMPUTE_INIT
9041 | OPTI_TYPE_PRECOMPUTE_MERKLE
9042 | OPTI_TYPE_EARLY_SKIP
9043 | OPTI_TYPE_NOT_SALTED;
9044 dgst_pos0 = 3;
9045 dgst_pos1 = 4;
9046 dgst_pos2 = 2;
9047 dgst_pos3 = 1;
9048 break;
9049
9050 case 4700: hash_type = HASH_TYPE_SHA1;
9051 salt_type = SALT_TYPE_NONE;
9052 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9053 opts_type = OPTS_TYPE_PT_GENERATE_LE
9054 | OPTS_TYPE_PT_ADD80
9055 | OPTS_TYPE_PT_ADDBITS14;
9056 kern_type = KERN_TYPE_SHA1_MD5;
9057 dgst_size = DGST_SIZE_4_5;
9058 parse_func = sha1_parse_hash;
9059 sort_by_digest = sort_by_digest_4_5;
9060 opti_type = OPTI_TYPE_ZERO_BYTE
9061 | OPTI_TYPE_PRECOMPUTE_INIT
9062 | OPTI_TYPE_PRECOMPUTE_MERKLE
9063 | OPTI_TYPE_EARLY_SKIP
9064 | OPTI_TYPE_NOT_ITERATED
9065 | OPTI_TYPE_NOT_SALTED
9066 | OPTI_TYPE_RAW_HASH;
9067 dgst_pos0 = 3;
9068 dgst_pos1 = 4;
9069 dgst_pos2 = 2;
9070 dgst_pos3 = 1;
9071 break;
9072
9073 case 4800: hash_type = HASH_TYPE_MD5;
9074 salt_type = SALT_TYPE_EMBEDDED;
9075 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9076 opts_type = OPTS_TYPE_PT_GENERATE_LE
9077 | OPTS_TYPE_PT_ADDBITS14;
9078 kern_type = KERN_TYPE_MD5_CHAP;
9079 dgst_size = DGST_SIZE_4_4;
9080 parse_func = chap_parse_hash;
9081 sort_by_digest = sort_by_digest_4_4;
9082 opti_type = OPTI_TYPE_ZERO_BYTE
9083 | OPTI_TYPE_PRECOMPUTE_INIT
9084 | OPTI_TYPE_PRECOMPUTE_MERKLE
9085 | OPTI_TYPE_MEET_IN_MIDDLE
9086 | OPTI_TYPE_EARLY_SKIP
9087 | OPTI_TYPE_NOT_ITERATED
9088 | OPTI_TYPE_RAW_HASH;
9089 dgst_pos0 = 0;
9090 dgst_pos1 = 3;
9091 dgst_pos2 = 2;
9092 dgst_pos3 = 1;
9093 break;
9094
9095 case 4900: hash_type = HASH_TYPE_SHA1;
9096 salt_type = SALT_TYPE_INTERN;
9097 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9098 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9099 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9100 dgst_size = DGST_SIZE_4_5;
9101 parse_func = sha1s_parse_hash;
9102 sort_by_digest = sort_by_digest_4_5;
9103 opti_type = OPTI_TYPE_ZERO_BYTE
9104 | OPTI_TYPE_PRECOMPUTE_INIT
9105 | OPTI_TYPE_PRECOMPUTE_MERKLE
9106 | OPTI_TYPE_EARLY_SKIP;
9107 dgst_pos0 = 3;
9108 dgst_pos1 = 4;
9109 dgst_pos2 = 2;
9110 dgst_pos3 = 1;
9111 break;
9112
9113 case 5000: hash_type = HASH_TYPE_KECCAK;
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_ADD01;
9118 kern_type = KERN_TYPE_KECCAK;
9119 dgst_size = DGST_SIZE_8_25;
9120 parse_func = keccak_parse_hash;
9121 sort_by_digest = sort_by_digest_8_25;
9122 opti_type = OPTI_TYPE_ZERO_BYTE
9123 | OPTI_TYPE_USES_BITS_64
9124 | OPTI_TYPE_RAW_HASH;
9125 dgst_pos0 = 2;
9126 dgst_pos1 = 3;
9127 dgst_pos2 = 4;
9128 dgst_pos3 = 5;
9129 break;
9130
9131 case 5100: hash_type = HASH_TYPE_MD5H;
9132 salt_type = SALT_TYPE_NONE;
9133 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9134 opts_type = OPTS_TYPE_PT_GENERATE_LE
9135 | OPTS_TYPE_PT_ADD80
9136 | OPTS_TYPE_PT_ADDBITS14;
9137 kern_type = KERN_TYPE_MD5H;
9138 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9139 parse_func = md5half_parse_hash;
9140 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9141 opti_type = OPTI_TYPE_ZERO_BYTE
9142 | OPTI_TYPE_RAW_HASH;
9143 dgst_pos0 = 0;
9144 dgst_pos1 = 1;
9145 dgst_pos2 = 2;
9146 dgst_pos3 = 3;
9147 break;
9148
9149 case 5200: hash_type = HASH_TYPE_SHA256;
9150 salt_type = SALT_TYPE_EMBEDDED;
9151 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9152 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9153 kern_type = KERN_TYPE_PSAFE3;
9154 dgst_size = DGST_SIZE_4_8;
9155 parse_func = psafe3_parse_hash;
9156 sort_by_digest = sort_by_digest_4_8;
9157 opti_type = OPTI_TYPE_ZERO_BYTE;
9158 dgst_pos0 = 0;
9159 dgst_pos1 = 1;
9160 dgst_pos2 = 2;
9161 dgst_pos3 = 3;
9162 break;
9163
9164 case 5300: hash_type = HASH_TYPE_MD5;
9165 salt_type = SALT_TYPE_EMBEDDED;
9166 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9167 opts_type = OPTS_TYPE_PT_GENERATE_LE
9168 | OPTS_TYPE_ST_ADD80;
9169 kern_type = KERN_TYPE_IKEPSK_MD5;
9170 dgst_size = DGST_SIZE_4_4;
9171 parse_func = ikepsk_md5_parse_hash;
9172 sort_by_digest = sort_by_digest_4_4;
9173 opti_type = OPTI_TYPE_ZERO_BYTE;
9174 dgst_pos0 = 0;
9175 dgst_pos1 = 3;
9176 dgst_pos2 = 2;
9177 dgst_pos3 = 1;
9178 break;
9179
9180 case 5400: hash_type = HASH_TYPE_SHA1;
9181 salt_type = SALT_TYPE_EMBEDDED;
9182 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9183 opts_type = OPTS_TYPE_PT_GENERATE_BE
9184 | OPTS_TYPE_ST_ADD80;
9185 kern_type = KERN_TYPE_IKEPSK_SHA1;
9186 dgst_size = DGST_SIZE_4_5;
9187 parse_func = ikepsk_sha1_parse_hash;
9188 sort_by_digest = sort_by_digest_4_5;
9189 opti_type = OPTI_TYPE_ZERO_BYTE;
9190 dgst_pos0 = 3;
9191 dgst_pos1 = 4;
9192 dgst_pos2 = 2;
9193 dgst_pos3 = 1;
9194 break;
9195
9196 case 5500: hash_type = HASH_TYPE_NETNTLM;
9197 salt_type = SALT_TYPE_EMBEDDED;
9198 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9199 opts_type = OPTS_TYPE_PT_GENERATE_LE
9200 | OPTS_TYPE_PT_ADD80
9201 | OPTS_TYPE_PT_ADDBITS14
9202 | OPTS_TYPE_PT_UNICODE
9203 | OPTS_TYPE_ST_HEX;
9204 kern_type = KERN_TYPE_NETNTLMv1;
9205 dgst_size = DGST_SIZE_4_4;
9206 parse_func = netntlmv1_parse_hash;
9207 sort_by_digest = sort_by_digest_4_4;
9208 opti_type = OPTI_TYPE_ZERO_BYTE
9209 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9210 dgst_pos0 = 0;
9211 dgst_pos1 = 1;
9212 dgst_pos2 = 2;
9213 dgst_pos3 = 3;
9214 break;
9215
9216 case 5600: hash_type = HASH_TYPE_MD5;
9217 salt_type = SALT_TYPE_EMBEDDED;
9218 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9219 opts_type = OPTS_TYPE_PT_GENERATE_LE
9220 | OPTS_TYPE_PT_ADD80
9221 | OPTS_TYPE_PT_ADDBITS14
9222 | OPTS_TYPE_PT_UNICODE;
9223 kern_type = KERN_TYPE_NETNTLMv2;
9224 dgst_size = DGST_SIZE_4_4;
9225 parse_func = netntlmv2_parse_hash;
9226 sort_by_digest = sort_by_digest_4_4;
9227 opti_type = OPTI_TYPE_ZERO_BYTE;
9228 dgst_pos0 = 0;
9229 dgst_pos1 = 3;
9230 dgst_pos2 = 2;
9231 dgst_pos3 = 1;
9232 break;
9233
9234 case 5700: hash_type = HASH_TYPE_SHA256;
9235 salt_type = SALT_TYPE_NONE;
9236 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9237 opts_type = OPTS_TYPE_PT_GENERATE_BE
9238 | OPTS_TYPE_PT_ADD80
9239 | OPTS_TYPE_PT_ADDBITS15;
9240 kern_type = KERN_TYPE_SHA256;
9241 dgst_size = DGST_SIZE_4_8;
9242 parse_func = cisco4_parse_hash;
9243 sort_by_digest = sort_by_digest_4_8;
9244 opti_type = OPTI_TYPE_ZERO_BYTE
9245 | OPTI_TYPE_PRECOMPUTE_INIT
9246 | OPTI_TYPE_PRECOMPUTE_MERKLE
9247 | OPTI_TYPE_EARLY_SKIP
9248 | OPTI_TYPE_NOT_ITERATED
9249 | OPTI_TYPE_NOT_SALTED
9250 | OPTI_TYPE_RAW_HASH;
9251 dgst_pos0 = 3;
9252 dgst_pos1 = 7;
9253 dgst_pos2 = 2;
9254 dgst_pos3 = 6;
9255 break;
9256
9257 case 5800: hash_type = HASH_TYPE_SHA1;
9258 salt_type = SALT_TYPE_INTERN;
9259 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9260 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9261 | OPTS_TYPE_ST_ADD80;
9262 kern_type = KERN_TYPE_ANDROIDPIN;
9263 dgst_size = DGST_SIZE_4_5;
9264 parse_func = androidpin_parse_hash;
9265 sort_by_digest = sort_by_digest_4_5;
9266 opti_type = OPTI_TYPE_ZERO_BYTE;
9267 dgst_pos0 = 0;
9268 dgst_pos1 = 1;
9269 dgst_pos2 = 2;
9270 dgst_pos3 = 3;
9271 break;
9272
9273 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9274 salt_type = SALT_TYPE_NONE;
9275 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9276 opts_type = OPTS_TYPE_PT_GENERATE_LE
9277 | OPTS_TYPE_PT_ADD80;
9278 kern_type = KERN_TYPE_RIPEMD160;
9279 dgst_size = DGST_SIZE_4_5;
9280 parse_func = ripemd160_parse_hash;
9281 sort_by_digest = sort_by_digest_4_5;
9282 opti_type = OPTI_TYPE_ZERO_BYTE;
9283 dgst_pos0 = 0;
9284 dgst_pos1 = 1;
9285 dgst_pos2 = 2;
9286 dgst_pos3 = 3;
9287 break;
9288
9289 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9290 salt_type = SALT_TYPE_NONE;
9291 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9292 opts_type = OPTS_TYPE_PT_GENERATE_BE
9293 | OPTS_TYPE_PT_ADD80;
9294 kern_type = KERN_TYPE_WHIRLPOOL;
9295 dgst_size = DGST_SIZE_4_16;
9296 parse_func = whirlpool_parse_hash;
9297 sort_by_digest = sort_by_digest_4_16;
9298 opti_type = OPTI_TYPE_ZERO_BYTE;
9299 dgst_pos0 = 0;
9300 dgst_pos1 = 1;
9301 dgst_pos2 = 2;
9302 dgst_pos3 = 3;
9303 break;
9304
9305 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9306 salt_type = SALT_TYPE_EMBEDDED;
9307 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9308 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9309 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9310 dgst_size = DGST_SIZE_4_5;
9311 parse_func = truecrypt_parse_hash_2k;
9312 sort_by_digest = sort_by_digest_4_5;
9313 opti_type = OPTI_TYPE_ZERO_BYTE;
9314 dgst_pos0 = 0;
9315 dgst_pos1 = 1;
9316 dgst_pos2 = 2;
9317 dgst_pos3 = 3;
9318 break;
9319
9320 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9321 salt_type = SALT_TYPE_EMBEDDED;
9322 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9323 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9324 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9325 dgst_size = DGST_SIZE_4_5;
9326 parse_func = truecrypt_parse_hash_2k;
9327 sort_by_digest = sort_by_digest_4_5;
9328 opti_type = OPTI_TYPE_ZERO_BYTE;
9329 dgst_pos0 = 0;
9330 dgst_pos1 = 1;
9331 dgst_pos2 = 2;
9332 dgst_pos3 = 3;
9333 break;
9334
9335 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9336 salt_type = SALT_TYPE_EMBEDDED;
9337 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9338 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9339 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9340 dgst_size = DGST_SIZE_4_5;
9341 parse_func = truecrypt_parse_hash_2k;
9342 sort_by_digest = sort_by_digest_4_5;
9343 opti_type = OPTI_TYPE_ZERO_BYTE;
9344 dgst_pos0 = 0;
9345 dgst_pos1 = 1;
9346 dgst_pos2 = 2;
9347 dgst_pos3 = 3;
9348 break;
9349
9350 case 6221: hash_type = HASH_TYPE_SHA512;
9351 salt_type = SALT_TYPE_EMBEDDED;
9352 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9353 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9354 kern_type = KERN_TYPE_TCSHA512_XTS512;
9355 dgst_size = DGST_SIZE_8_8;
9356 parse_func = truecrypt_parse_hash_1k;
9357 sort_by_digest = sort_by_digest_8_8;
9358 opti_type = OPTI_TYPE_ZERO_BYTE
9359 | OPTI_TYPE_USES_BITS_64;
9360 dgst_pos0 = 0;
9361 dgst_pos1 = 1;
9362 dgst_pos2 = 2;
9363 dgst_pos3 = 3;
9364 break;
9365
9366 case 6222: hash_type = HASH_TYPE_SHA512;
9367 salt_type = SALT_TYPE_EMBEDDED;
9368 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9369 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9370 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9371 dgst_size = DGST_SIZE_8_8;
9372 parse_func = truecrypt_parse_hash_1k;
9373 sort_by_digest = sort_by_digest_8_8;
9374 opti_type = OPTI_TYPE_ZERO_BYTE
9375 | OPTI_TYPE_USES_BITS_64;
9376 dgst_pos0 = 0;
9377 dgst_pos1 = 1;
9378 dgst_pos2 = 2;
9379 dgst_pos3 = 3;
9380 break;
9381
9382 case 6223: hash_type = HASH_TYPE_SHA512;
9383 salt_type = SALT_TYPE_EMBEDDED;
9384 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9385 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9386 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9387 dgst_size = DGST_SIZE_8_8;
9388 parse_func = truecrypt_parse_hash_1k;
9389 sort_by_digest = sort_by_digest_8_8;
9390 opti_type = OPTI_TYPE_ZERO_BYTE
9391 | OPTI_TYPE_USES_BITS_64;
9392 dgst_pos0 = 0;
9393 dgst_pos1 = 1;
9394 dgst_pos2 = 2;
9395 dgst_pos3 = 3;
9396 break;
9397
9398 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9399 salt_type = SALT_TYPE_EMBEDDED;
9400 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9401 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9402 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9403 dgst_size = DGST_SIZE_4_8;
9404 parse_func = truecrypt_parse_hash_1k;
9405 sort_by_digest = sort_by_digest_4_8;
9406 opti_type = OPTI_TYPE_ZERO_BYTE;
9407 dgst_pos0 = 0;
9408 dgst_pos1 = 1;
9409 dgst_pos2 = 2;
9410 dgst_pos3 = 3;
9411 break;
9412
9413 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9414 salt_type = SALT_TYPE_EMBEDDED;
9415 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9416 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9417 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9418 dgst_size = DGST_SIZE_4_8;
9419 parse_func = truecrypt_parse_hash_1k;
9420 sort_by_digest = sort_by_digest_4_8;
9421 opti_type = OPTI_TYPE_ZERO_BYTE;
9422 dgst_pos0 = 0;
9423 dgst_pos1 = 1;
9424 dgst_pos2 = 2;
9425 dgst_pos3 = 3;
9426 break;
9427
9428 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9429 salt_type = SALT_TYPE_EMBEDDED;
9430 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9431 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9432 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9433 dgst_size = DGST_SIZE_4_8;
9434 parse_func = truecrypt_parse_hash_1k;
9435 sort_by_digest = sort_by_digest_4_8;
9436 opti_type = OPTI_TYPE_ZERO_BYTE;
9437 dgst_pos0 = 0;
9438 dgst_pos1 = 1;
9439 dgst_pos2 = 2;
9440 dgst_pos3 = 3;
9441 break;
9442
9443 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9444 salt_type = SALT_TYPE_EMBEDDED;
9445 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9446 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9447 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9448 dgst_size = DGST_SIZE_4_5;
9449 parse_func = truecrypt_parse_hash_1k;
9450 sort_by_digest = sort_by_digest_4_5;
9451 opti_type = OPTI_TYPE_ZERO_BYTE;
9452 dgst_pos0 = 0;
9453 dgst_pos1 = 1;
9454 dgst_pos2 = 2;
9455 dgst_pos3 = 3;
9456 break;
9457
9458 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9459 salt_type = SALT_TYPE_EMBEDDED;
9460 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9461 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9462 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9463 dgst_size = DGST_SIZE_4_5;
9464 parse_func = truecrypt_parse_hash_1k;
9465 sort_by_digest = sort_by_digest_4_5;
9466 opti_type = OPTI_TYPE_ZERO_BYTE;
9467 dgst_pos0 = 0;
9468 dgst_pos1 = 1;
9469 dgst_pos2 = 2;
9470 dgst_pos3 = 3;
9471 break;
9472
9473 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9474 salt_type = SALT_TYPE_EMBEDDED;
9475 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9476 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9477 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9478 dgst_size = DGST_SIZE_4_5;
9479 parse_func = truecrypt_parse_hash_1k;
9480 sort_by_digest = sort_by_digest_4_5;
9481 opti_type = OPTI_TYPE_ZERO_BYTE;
9482 dgst_pos0 = 0;
9483 dgst_pos1 = 1;
9484 dgst_pos2 = 2;
9485 dgst_pos3 = 3;
9486 break;
9487
9488 case 6300: hash_type = HASH_TYPE_MD5;
9489 salt_type = SALT_TYPE_EMBEDDED;
9490 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9491 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9492 kern_type = KERN_TYPE_MD5AIX;
9493 dgst_size = DGST_SIZE_4_4;
9494 parse_func = md5aix_parse_hash;
9495 sort_by_digest = sort_by_digest_4_4;
9496 opti_type = OPTI_TYPE_ZERO_BYTE;
9497 dgst_pos0 = 0;
9498 dgst_pos1 = 1;
9499 dgst_pos2 = 2;
9500 dgst_pos3 = 3;
9501 break;
9502
9503 case 6400: hash_type = HASH_TYPE_SHA256;
9504 salt_type = SALT_TYPE_EMBEDDED;
9505 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9506 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9507 kern_type = KERN_TYPE_SHA256AIX;
9508 dgst_size = DGST_SIZE_4_8;
9509 parse_func = sha256aix_parse_hash;
9510 sort_by_digest = sort_by_digest_4_8;
9511 opti_type = OPTI_TYPE_ZERO_BYTE;
9512 dgst_pos0 = 0;
9513 dgst_pos1 = 1;
9514 dgst_pos2 = 2;
9515 dgst_pos3 = 3;
9516 break;
9517
9518 case 6500: hash_type = HASH_TYPE_SHA512;
9519 salt_type = SALT_TYPE_EMBEDDED;
9520 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9521 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9522 kern_type = KERN_TYPE_SHA512AIX;
9523 dgst_size = DGST_SIZE_8_8;
9524 parse_func = sha512aix_parse_hash;
9525 sort_by_digest = sort_by_digest_8_8;
9526 opti_type = OPTI_TYPE_ZERO_BYTE
9527 | OPTI_TYPE_USES_BITS_64;
9528 dgst_pos0 = 0;
9529 dgst_pos1 = 1;
9530 dgst_pos2 = 2;
9531 dgst_pos3 = 3;
9532 break;
9533
9534 case 6600: hash_type = HASH_TYPE_AES;
9535 salt_type = SALT_TYPE_EMBEDDED;
9536 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9537 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9538 kern_type = KERN_TYPE_AGILEKEY;
9539 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9540 parse_func = agilekey_parse_hash;
9541 sort_by_digest = sort_by_digest_4_5;
9542 opti_type = OPTI_TYPE_ZERO_BYTE;
9543 dgst_pos0 = 0;
9544 dgst_pos1 = 1;
9545 dgst_pos2 = 2;
9546 dgst_pos3 = 3;
9547 break;
9548
9549 case 6700: hash_type = HASH_TYPE_SHA1;
9550 salt_type = SALT_TYPE_EMBEDDED;
9551 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9552 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9553 kern_type = KERN_TYPE_SHA1AIX;
9554 dgst_size = DGST_SIZE_4_5;
9555 parse_func = sha1aix_parse_hash;
9556 sort_by_digest = sort_by_digest_4_5;
9557 opti_type = OPTI_TYPE_ZERO_BYTE;
9558 dgst_pos0 = 0;
9559 dgst_pos1 = 1;
9560 dgst_pos2 = 2;
9561 dgst_pos3 = 3;
9562 break;
9563
9564 case 6800: hash_type = HASH_TYPE_AES;
9565 salt_type = SALT_TYPE_EMBEDDED;
9566 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9567 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9568 kern_type = KERN_TYPE_LASTPASS;
9569 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9570 parse_func = lastpass_parse_hash;
9571 sort_by_digest = sort_by_digest_4_8;
9572 opti_type = OPTI_TYPE_ZERO_BYTE;
9573 dgst_pos0 = 0;
9574 dgst_pos1 = 1;
9575 dgst_pos2 = 2;
9576 dgst_pos3 = 3;
9577 break;
9578
9579 case 6900: hash_type = HASH_TYPE_GOST;
9580 salt_type = SALT_TYPE_NONE;
9581 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9582 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9583 kern_type = KERN_TYPE_GOST;
9584 dgst_size = DGST_SIZE_4_8;
9585 parse_func = gost_parse_hash;
9586 sort_by_digest = sort_by_digest_4_8;
9587 opti_type = OPTI_TYPE_ZERO_BYTE;
9588 dgst_pos0 = 0;
9589 dgst_pos1 = 1;
9590 dgst_pos2 = 2;
9591 dgst_pos3 = 3;
9592 break;
9593
9594 case 7100: hash_type = HASH_TYPE_SHA512;
9595 salt_type = SALT_TYPE_EMBEDDED;
9596 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9597 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9598 kern_type = KERN_TYPE_PBKDF2_SHA512;
9599 dgst_size = DGST_SIZE_8_16;
9600 parse_func = sha512osx_parse_hash;
9601 sort_by_digest = sort_by_digest_8_16;
9602 opti_type = OPTI_TYPE_ZERO_BYTE
9603 | OPTI_TYPE_USES_BITS_64
9604 | OPTI_TYPE_SLOW_HASH_SIMD;
9605 dgst_pos0 = 0;
9606 dgst_pos1 = 1;
9607 dgst_pos2 = 2;
9608 dgst_pos3 = 3;
9609 break;
9610
9611 case 7200: hash_type = HASH_TYPE_SHA512;
9612 salt_type = SALT_TYPE_EMBEDDED;
9613 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9614 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9615 kern_type = KERN_TYPE_PBKDF2_SHA512;
9616 dgst_size = DGST_SIZE_8_16;
9617 parse_func = sha512grub_parse_hash;
9618 sort_by_digest = sort_by_digest_8_16;
9619 opti_type = OPTI_TYPE_ZERO_BYTE
9620 | OPTI_TYPE_USES_BITS_64
9621 | OPTI_TYPE_SLOW_HASH_SIMD;
9622 dgst_pos0 = 0;
9623 dgst_pos1 = 1;
9624 dgst_pos2 = 2;
9625 dgst_pos3 = 3;
9626 break;
9627
9628 case 7300: hash_type = HASH_TYPE_SHA1;
9629 salt_type = SALT_TYPE_EMBEDDED;
9630 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9631 opts_type = OPTS_TYPE_PT_GENERATE_BE
9632 | OPTS_TYPE_ST_ADD80
9633 | OPTS_TYPE_ST_ADDBITS15;
9634 kern_type = KERN_TYPE_RAKP;
9635 dgst_size = DGST_SIZE_4_5;
9636 parse_func = rakp_parse_hash;
9637 sort_by_digest = sort_by_digest_4_5;
9638 opti_type = OPTI_TYPE_ZERO_BYTE
9639 | OPTI_TYPE_NOT_ITERATED;
9640 dgst_pos0 = 3;
9641 dgst_pos1 = 4;
9642 dgst_pos2 = 2;
9643 dgst_pos3 = 1;
9644 break;
9645
9646 case 7400: hash_type = HASH_TYPE_SHA256;
9647 salt_type = SALT_TYPE_EMBEDDED;
9648 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9649 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9650 kern_type = KERN_TYPE_SHA256CRYPT;
9651 dgst_size = DGST_SIZE_4_8;
9652 parse_func = sha256crypt_parse_hash;
9653 sort_by_digest = sort_by_digest_4_8;
9654 opti_type = OPTI_TYPE_ZERO_BYTE;
9655 dgst_pos0 = 0;
9656 dgst_pos1 = 1;
9657 dgst_pos2 = 2;
9658 dgst_pos3 = 3;
9659 break;
9660
9661 case 7500: hash_type = HASH_TYPE_KRB5PA;
9662 salt_type = SALT_TYPE_EMBEDDED;
9663 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9664 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9665 kern_type = KERN_TYPE_KRB5PA;
9666 dgst_size = DGST_SIZE_4_4;
9667 parse_func = krb5pa_parse_hash;
9668 sort_by_digest = sort_by_digest_4_4;
9669 opti_type = OPTI_TYPE_ZERO_BYTE
9670 | OPTI_TYPE_NOT_ITERATED;
9671 dgst_pos0 = 0;
9672 dgst_pos1 = 1;
9673 dgst_pos2 = 2;
9674 dgst_pos3 = 3;
9675 break;
9676
9677 case 7600: hash_type = HASH_TYPE_SHA1;
9678 salt_type = SALT_TYPE_INTERN;
9679 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9680 opts_type = OPTS_TYPE_PT_GENERATE_BE
9681 | OPTS_TYPE_PT_ADD80
9682 | OPTS_TYPE_PT_ADDBITS15;
9683 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9684 dgst_size = DGST_SIZE_4_5;
9685 parse_func = redmine_parse_hash;
9686 sort_by_digest = sort_by_digest_4_5;
9687 opti_type = OPTI_TYPE_ZERO_BYTE
9688 | OPTI_TYPE_PRECOMPUTE_INIT
9689 | OPTI_TYPE_EARLY_SKIP
9690 | OPTI_TYPE_NOT_ITERATED
9691 | OPTI_TYPE_PREPENDED_SALT;
9692 dgst_pos0 = 3;
9693 dgst_pos1 = 4;
9694 dgst_pos2 = 2;
9695 dgst_pos3 = 1;
9696 break;
9697
9698 case 7700: hash_type = HASH_TYPE_SAPB;
9699 salt_type = SALT_TYPE_EMBEDDED;
9700 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9701 opts_type = OPTS_TYPE_PT_GENERATE_LE
9702 | OPTS_TYPE_PT_UPPER
9703 | OPTS_TYPE_ST_UPPER;
9704 kern_type = KERN_TYPE_SAPB;
9705 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9706 parse_func = sapb_parse_hash;
9707 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9708 opti_type = OPTI_TYPE_ZERO_BYTE
9709 | OPTI_TYPE_PRECOMPUTE_INIT
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 7800: hash_type = HASH_TYPE_SAPG;
9718 salt_type = SALT_TYPE_EMBEDDED;
9719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9720 opts_type = OPTS_TYPE_PT_GENERATE_BE
9721 | OPTS_TYPE_ST_ADD80
9722 | OPTS_TYPE_ST_UPPER;
9723 kern_type = KERN_TYPE_SAPG;
9724 dgst_size = DGST_SIZE_4_5;
9725 parse_func = sapg_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_NOT_ITERATED;
9730 dgst_pos0 = 3;
9731 dgst_pos1 = 4;
9732 dgst_pos2 = 2;
9733 dgst_pos3 = 1;
9734 break;
9735
9736 case 7900: hash_type = HASH_TYPE_SHA512;
9737 salt_type = SALT_TYPE_EMBEDDED;
9738 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9739 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9740 kern_type = KERN_TYPE_DRUPAL7;
9741 dgst_size = DGST_SIZE_8_8;
9742 parse_func = drupal7_parse_hash;
9743 sort_by_digest = sort_by_digest_8_8;
9744 opti_type = OPTI_TYPE_ZERO_BYTE
9745 | OPTI_TYPE_USES_BITS_64;
9746 dgst_pos0 = 0;
9747 dgst_pos1 = 1;
9748 dgst_pos2 = 2;
9749 dgst_pos3 = 3;
9750 break;
9751
9752 case 8000: hash_type = HASH_TYPE_SHA256;
9753 salt_type = SALT_TYPE_EMBEDDED;
9754 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9755 opts_type = OPTS_TYPE_PT_GENERATE_BE
9756 | OPTS_TYPE_PT_UNICODE
9757 | OPTS_TYPE_ST_ADD80
9758 | OPTS_TYPE_ST_HEX;
9759 kern_type = KERN_TYPE_SYBASEASE;
9760 dgst_size = DGST_SIZE_4_8;
9761 parse_func = sybasease_parse_hash;
9762 sort_by_digest = sort_by_digest_4_8;
9763 opti_type = OPTI_TYPE_ZERO_BYTE
9764 | OPTI_TYPE_PRECOMPUTE_INIT
9765 | OPTI_TYPE_EARLY_SKIP
9766 | OPTI_TYPE_NOT_ITERATED
9767 | OPTI_TYPE_RAW_HASH;
9768 dgst_pos0 = 3;
9769 dgst_pos1 = 7;
9770 dgst_pos2 = 2;
9771 dgst_pos3 = 6;
9772 break;
9773
9774 case 8100: hash_type = HASH_TYPE_SHA1;
9775 salt_type = SALT_TYPE_EMBEDDED;
9776 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9777 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9778 kern_type = KERN_TYPE_NETSCALER;
9779 dgst_size = DGST_SIZE_4_5;
9780 parse_func = netscaler_parse_hash;
9781 sort_by_digest = sort_by_digest_4_5;
9782 opti_type = OPTI_TYPE_ZERO_BYTE
9783 | OPTI_TYPE_PRECOMPUTE_INIT
9784 | OPTI_TYPE_PRECOMPUTE_MERKLE
9785 | OPTI_TYPE_EARLY_SKIP
9786 | OPTI_TYPE_NOT_ITERATED
9787 | OPTI_TYPE_PREPENDED_SALT
9788 | OPTI_TYPE_RAW_HASH;
9789 dgst_pos0 = 3;
9790 dgst_pos1 = 4;
9791 dgst_pos2 = 2;
9792 dgst_pos3 = 1;
9793 break;
9794
9795 case 8200: hash_type = HASH_TYPE_SHA256;
9796 salt_type = SALT_TYPE_EMBEDDED;
9797 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9798 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9799 kern_type = KERN_TYPE_CLOUDKEY;
9800 dgst_size = DGST_SIZE_4_8;
9801 parse_func = cloudkey_parse_hash;
9802 sort_by_digest = sort_by_digest_4_8;
9803 opti_type = OPTI_TYPE_ZERO_BYTE;
9804 dgst_pos0 = 0;
9805 dgst_pos1 = 1;
9806 dgst_pos2 = 2;
9807 dgst_pos3 = 3;
9808 break;
9809
9810 case 8300: hash_type = HASH_TYPE_SHA1;
9811 salt_type = SALT_TYPE_EMBEDDED;
9812 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9813 opts_type = OPTS_TYPE_PT_GENERATE_BE
9814 | OPTS_TYPE_ST_HEX
9815 | OPTS_TYPE_ST_ADD80;
9816 kern_type = KERN_TYPE_NSEC3;
9817 dgst_size = DGST_SIZE_4_5;
9818 parse_func = nsec3_parse_hash;
9819 sort_by_digest = sort_by_digest_4_5;
9820 opti_type = OPTI_TYPE_ZERO_BYTE;
9821 dgst_pos0 = 3;
9822 dgst_pos1 = 4;
9823 dgst_pos2 = 2;
9824 dgst_pos3 = 1;
9825 break;
9826
9827 case 8400: hash_type = HASH_TYPE_SHA1;
9828 salt_type = SALT_TYPE_INTERN;
9829 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9830 opts_type = OPTS_TYPE_PT_GENERATE_BE
9831 | OPTS_TYPE_PT_ADD80
9832 | OPTS_TYPE_PT_ADDBITS15;
9833 kern_type = KERN_TYPE_WBB3;
9834 dgst_size = DGST_SIZE_4_5;
9835 parse_func = wbb3_parse_hash;
9836 sort_by_digest = sort_by_digest_4_5;
9837 opti_type = OPTI_TYPE_ZERO_BYTE
9838 | OPTI_TYPE_PRECOMPUTE_INIT
9839 | OPTI_TYPE_NOT_ITERATED;
9840 dgst_pos0 = 3;
9841 dgst_pos1 = 4;
9842 dgst_pos2 = 2;
9843 dgst_pos3 = 1;
9844 break;
9845
9846 case 8500: hash_type = HASH_TYPE_DESRACF;
9847 salt_type = SALT_TYPE_EMBEDDED;
9848 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9849 opts_type = OPTS_TYPE_PT_GENERATE_LE
9850 | OPTS_TYPE_ST_UPPER;
9851 kern_type = KERN_TYPE_RACF;
9852 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9853 parse_func = racf_parse_hash;
9854 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9855 opti_type = OPTI_TYPE_ZERO_BYTE
9856 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9857 dgst_pos0 = 0;
9858 dgst_pos1 = 1;
9859 dgst_pos2 = 2;
9860 dgst_pos3 = 3;
9861 break;
9862
9863 case 8600: hash_type = HASH_TYPE_LOTUS5;
9864 salt_type = SALT_TYPE_NONE;
9865 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9866 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9867 kern_type = KERN_TYPE_LOTUS5;
9868 dgst_size = DGST_SIZE_4_4;
9869 parse_func = lotus5_parse_hash;
9870 sort_by_digest = sort_by_digest_4_4;
9871 opti_type = OPTI_TYPE_EARLY_SKIP
9872 | OPTI_TYPE_NOT_ITERATED
9873 | OPTI_TYPE_NOT_SALTED
9874 | OPTI_TYPE_RAW_HASH;
9875 dgst_pos0 = 0;
9876 dgst_pos1 = 1;
9877 dgst_pos2 = 2;
9878 dgst_pos3 = 3;
9879 break;
9880
9881 case 8700: hash_type = HASH_TYPE_LOTUS6;
9882 salt_type = SALT_TYPE_EMBEDDED;
9883 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9884 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9885 kern_type = KERN_TYPE_LOTUS6;
9886 dgst_size = DGST_SIZE_4_4;
9887 parse_func = lotus6_parse_hash;
9888 sort_by_digest = sort_by_digest_4_4;
9889 opti_type = OPTI_TYPE_EARLY_SKIP
9890 | OPTI_TYPE_NOT_ITERATED
9891 | OPTI_TYPE_RAW_HASH;
9892 dgst_pos0 = 0;
9893 dgst_pos1 = 1;
9894 dgst_pos2 = 2;
9895 dgst_pos3 = 3;
9896 break;
9897
9898 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9899 salt_type = SALT_TYPE_EMBEDDED;
9900 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9901 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9902 kern_type = KERN_TYPE_ANDROIDFDE;
9903 dgst_size = DGST_SIZE_4_4;
9904 parse_func = androidfde_parse_hash;
9905 sort_by_digest = sort_by_digest_4_4;
9906 opti_type = OPTI_TYPE_ZERO_BYTE;
9907 dgst_pos0 = 0;
9908 dgst_pos1 = 1;
9909 dgst_pos2 = 2;
9910 dgst_pos3 = 3;
9911 break;
9912
9913 case 8900: hash_type = HASH_TYPE_SCRYPT;
9914 salt_type = SALT_TYPE_EMBEDDED;
9915 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9916 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9917 kern_type = KERN_TYPE_SCRYPT;
9918 dgst_size = DGST_SIZE_4_8;
9919 parse_func = scrypt_parse_hash;
9920 sort_by_digest = sort_by_digest_4_8;
9921 opti_type = OPTI_TYPE_ZERO_BYTE;
9922 dgst_pos0 = 0;
9923 dgst_pos1 = 1;
9924 dgst_pos2 = 2;
9925 dgst_pos3 = 3;
9926 break;
9927
9928 case 9000: hash_type = HASH_TYPE_SHA1;
9929 salt_type = SALT_TYPE_EMBEDDED;
9930 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9931 opts_type = OPTS_TYPE_PT_GENERATE_LE
9932 | OPTS_TYPE_ST_GENERATE_LE;
9933 kern_type = KERN_TYPE_PSAFE2;
9934 dgst_size = DGST_SIZE_4_5;
9935 parse_func = psafe2_parse_hash;
9936 sort_by_digest = sort_by_digest_4_5;
9937 opti_type = OPTI_TYPE_ZERO_BYTE;
9938 dgst_pos0 = 0;
9939 dgst_pos1 = 1;
9940 dgst_pos2 = 2;
9941 dgst_pos3 = 3;
9942 break;
9943
9944 case 9100: hash_type = HASH_TYPE_LOTUS8;
9945 salt_type = SALT_TYPE_EMBEDDED;
9946 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9947 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9948 kern_type = KERN_TYPE_LOTUS8;
9949 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9950 parse_func = lotus8_parse_hash;
9951 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9952 opti_type = OPTI_TYPE_ZERO_BYTE;
9953 dgst_pos0 = 0;
9954 dgst_pos1 = 1;
9955 dgst_pos2 = 2;
9956 dgst_pos3 = 3;
9957 break;
9958
9959 case 9200: hash_type = HASH_TYPE_SHA256;
9960 salt_type = SALT_TYPE_EMBEDDED;
9961 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9962 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9963 kern_type = KERN_TYPE_PBKDF2_SHA256;
9964 dgst_size = DGST_SIZE_4_32;
9965 parse_func = cisco8_parse_hash;
9966 sort_by_digest = sort_by_digest_4_32;
9967 opti_type = OPTI_TYPE_ZERO_BYTE
9968 | OPTI_TYPE_SLOW_HASH_SIMD;
9969 dgst_pos0 = 0;
9970 dgst_pos1 = 1;
9971 dgst_pos2 = 2;
9972 dgst_pos3 = 3;
9973 break;
9974
9975 case 9300: hash_type = HASH_TYPE_SCRYPT;
9976 salt_type = SALT_TYPE_EMBEDDED;
9977 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9978 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9979 kern_type = KERN_TYPE_SCRYPT;
9980 dgst_size = DGST_SIZE_4_8;
9981 parse_func = cisco9_parse_hash;
9982 sort_by_digest = sort_by_digest_4_8;
9983 opti_type = OPTI_TYPE_ZERO_BYTE;
9984 dgst_pos0 = 0;
9985 dgst_pos1 = 1;
9986 dgst_pos2 = 2;
9987 dgst_pos3 = 3;
9988 break;
9989
9990 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9991 salt_type = SALT_TYPE_EMBEDDED;
9992 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9993 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9994 kern_type = KERN_TYPE_OFFICE2007;
9995 dgst_size = DGST_SIZE_4_4;
9996 parse_func = office2007_parse_hash;
9997 sort_by_digest = sort_by_digest_4_4;
9998 opti_type = OPTI_TYPE_ZERO_BYTE;
9999 dgst_pos0 = 0;
10000 dgst_pos1 = 1;
10001 dgst_pos2 = 2;
10002 dgst_pos3 = 3;
10003 break;
10004
10005 case 9500: hash_type = HASH_TYPE_OFFICE2010;
10006 salt_type = SALT_TYPE_EMBEDDED;
10007 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10008 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10009 kern_type = KERN_TYPE_OFFICE2010;
10010 dgst_size = DGST_SIZE_4_4;
10011 parse_func = office2010_parse_hash;
10012 sort_by_digest = sort_by_digest_4_4;
10013 opti_type = OPTI_TYPE_ZERO_BYTE;
10014 dgst_pos0 = 0;
10015 dgst_pos1 = 1;
10016 dgst_pos2 = 2;
10017 dgst_pos3 = 3;
10018 break;
10019
10020 case 9600: hash_type = HASH_TYPE_OFFICE2013;
10021 salt_type = SALT_TYPE_EMBEDDED;
10022 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10023 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10024 kern_type = KERN_TYPE_OFFICE2013;
10025 dgst_size = DGST_SIZE_4_4;
10026 parse_func = office2013_parse_hash;
10027 sort_by_digest = sort_by_digest_4_4;
10028 opti_type = OPTI_TYPE_ZERO_BYTE;
10029 dgst_pos0 = 0;
10030 dgst_pos1 = 1;
10031 dgst_pos2 = 2;
10032 dgst_pos3 = 3;
10033 break;
10034
10035 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
10036 salt_type = SALT_TYPE_EMBEDDED;
10037 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10038 opts_type = OPTS_TYPE_PT_GENERATE_LE
10039 | OPTS_TYPE_PT_ADD80
10040 | OPTS_TYPE_PT_UNICODE;
10041 kern_type = KERN_TYPE_OLDOFFICE01;
10042 dgst_size = DGST_SIZE_4_4;
10043 parse_func = oldoffice01_parse_hash;
10044 sort_by_digest = sort_by_digest_4_4;
10045 opti_type = OPTI_TYPE_ZERO_BYTE
10046 | OPTI_TYPE_PRECOMPUTE_INIT
10047 | OPTI_TYPE_NOT_ITERATED;
10048 dgst_pos0 = 0;
10049 dgst_pos1 = 1;
10050 dgst_pos2 = 2;
10051 dgst_pos3 = 3;
10052 break;
10053
10054 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
10055 salt_type = SALT_TYPE_EMBEDDED;
10056 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10057 opts_type = OPTS_TYPE_PT_GENERATE_LE
10058 | OPTS_TYPE_PT_ADD80;
10059 kern_type = KERN_TYPE_OLDOFFICE01CM1;
10060 dgst_size = DGST_SIZE_4_4;
10061 parse_func = oldoffice01cm1_parse_hash;
10062 sort_by_digest = sort_by_digest_4_4;
10063 opti_type = OPTI_TYPE_ZERO_BYTE
10064 | OPTI_TYPE_PRECOMPUTE_INIT
10065 | OPTI_TYPE_NOT_ITERATED;
10066 dgst_pos0 = 0;
10067 dgst_pos1 = 1;
10068 dgst_pos2 = 2;
10069 dgst_pos3 = 3;
10070 break;
10071
10072 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
10073 salt_type = SALT_TYPE_EMBEDDED;
10074 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10075 opts_type = OPTS_TYPE_PT_GENERATE_LE
10076 | OPTS_TYPE_PT_ADD80
10077 | OPTS_TYPE_PT_UNICODE
10078 | OPTS_TYPE_PT_NEVERCRACK;
10079 kern_type = KERN_TYPE_OLDOFFICE01CM2;
10080 dgst_size = DGST_SIZE_4_4;
10081 parse_func = oldoffice01cm2_parse_hash;
10082 sort_by_digest = sort_by_digest_4_4;
10083 opti_type = OPTI_TYPE_ZERO_BYTE
10084 | OPTI_TYPE_PRECOMPUTE_INIT
10085 | OPTI_TYPE_NOT_ITERATED;
10086 dgst_pos0 = 0;
10087 dgst_pos1 = 1;
10088 dgst_pos2 = 2;
10089 dgst_pos3 = 3;
10090 break;
10091
10092 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
10093 salt_type = SALT_TYPE_EMBEDDED;
10094 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10095 opts_type = OPTS_TYPE_PT_GENERATE_BE
10096 | OPTS_TYPE_PT_ADD80
10097 | OPTS_TYPE_PT_UNICODE;
10098 kern_type = KERN_TYPE_OLDOFFICE34;
10099 dgst_size = DGST_SIZE_4_4;
10100 parse_func = oldoffice34_parse_hash;
10101 sort_by_digest = sort_by_digest_4_4;
10102 opti_type = OPTI_TYPE_ZERO_BYTE
10103 | OPTI_TYPE_PRECOMPUTE_INIT
10104 | OPTI_TYPE_NOT_ITERATED;
10105 dgst_pos0 = 0;
10106 dgst_pos1 = 1;
10107 dgst_pos2 = 2;
10108 dgst_pos3 = 3;
10109 break;
10110
10111 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10112 salt_type = SALT_TYPE_EMBEDDED;
10113 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10114 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10115 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10116 dgst_size = DGST_SIZE_4_4;
10117 parse_func = oldoffice34cm1_parse_hash;
10118 sort_by_digest = sort_by_digest_4_4;
10119 opti_type = OPTI_TYPE_ZERO_BYTE
10120 | OPTI_TYPE_PRECOMPUTE_INIT
10121 | OPTI_TYPE_NOT_ITERATED;
10122 dgst_pos0 = 0;
10123 dgst_pos1 = 1;
10124 dgst_pos2 = 2;
10125 dgst_pos3 = 3;
10126 break;
10127
10128 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10129 salt_type = SALT_TYPE_EMBEDDED;
10130 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10131 opts_type = OPTS_TYPE_PT_GENERATE_BE
10132 | OPTS_TYPE_PT_ADD80
10133 | OPTS_TYPE_PT_UNICODE
10134 | OPTS_TYPE_PT_NEVERCRACK;
10135 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10136 dgst_size = DGST_SIZE_4_4;
10137 parse_func = oldoffice34cm2_parse_hash;
10138 sort_by_digest = sort_by_digest_4_4;
10139 opti_type = OPTI_TYPE_ZERO_BYTE
10140 | OPTI_TYPE_PRECOMPUTE_INIT
10141 | OPTI_TYPE_NOT_ITERATED;
10142 dgst_pos0 = 0;
10143 dgst_pos1 = 1;
10144 dgst_pos2 = 2;
10145 dgst_pos3 = 3;
10146 break;
10147
10148 case 9900: hash_type = HASH_TYPE_MD5;
10149 salt_type = SALT_TYPE_NONE;
10150 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10151 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10152 kern_type = KERN_TYPE_RADMIN2;
10153 dgst_size = DGST_SIZE_4_4;
10154 parse_func = radmin2_parse_hash;
10155 sort_by_digest = sort_by_digest_4_4;
10156 opti_type = OPTI_TYPE_ZERO_BYTE
10157 | OPTI_TYPE_PRECOMPUTE_INIT
10158 | OPTI_TYPE_EARLY_SKIP
10159 | OPTI_TYPE_NOT_ITERATED
10160 | OPTI_TYPE_NOT_SALTED;
10161 dgst_pos0 = 0;
10162 dgst_pos1 = 3;
10163 dgst_pos2 = 2;
10164 dgst_pos3 = 1;
10165 break;
10166
10167 case 10000: hash_type = HASH_TYPE_SHA256;
10168 salt_type = SALT_TYPE_EMBEDDED;
10169 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10170 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10171 kern_type = KERN_TYPE_PBKDF2_SHA256;
10172 dgst_size = DGST_SIZE_4_32;
10173 parse_func = djangopbkdf2_parse_hash;
10174 sort_by_digest = sort_by_digest_4_32;
10175 opti_type = OPTI_TYPE_ZERO_BYTE
10176 | OPTI_TYPE_SLOW_HASH_SIMD;
10177 dgst_pos0 = 0;
10178 dgst_pos1 = 1;
10179 dgst_pos2 = 2;
10180 dgst_pos3 = 3;
10181 break;
10182
10183 case 10100: hash_type = HASH_TYPE_SIPHASH;
10184 salt_type = SALT_TYPE_EMBEDDED;
10185 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10186 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10187 kern_type = KERN_TYPE_SIPHASH;
10188 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10189 parse_func = siphash_parse_hash;
10190 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10191 opti_type = OPTI_TYPE_ZERO_BYTE
10192 | OPTI_TYPE_NOT_ITERATED
10193 | OPTI_TYPE_RAW_HASH;
10194 dgst_pos0 = 0;
10195 dgst_pos1 = 1;
10196 dgst_pos2 = 2;
10197 dgst_pos3 = 3;
10198 break;
10199
10200 case 10200: hash_type = HASH_TYPE_MD5;
10201 salt_type = SALT_TYPE_EMBEDDED;
10202 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10203 opts_type = OPTS_TYPE_PT_GENERATE_LE
10204 | OPTS_TYPE_ST_ADD80
10205 | OPTS_TYPE_ST_ADDBITS14;
10206 kern_type = KERN_TYPE_HMACMD5_PW;
10207 dgst_size = DGST_SIZE_4_4;
10208 parse_func = crammd5_parse_hash;
10209 sort_by_digest = sort_by_digest_4_4;
10210 opti_type = OPTI_TYPE_ZERO_BYTE
10211 | OPTI_TYPE_NOT_ITERATED;
10212 dgst_pos0 = 0;
10213 dgst_pos1 = 3;
10214 dgst_pos2 = 2;
10215 dgst_pos3 = 1;
10216 break;
10217
10218 case 10300: hash_type = HASH_TYPE_SHA1;
10219 salt_type = SALT_TYPE_EMBEDDED;
10220 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10221 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10222 kern_type = KERN_TYPE_SAPH_SHA1;
10223 dgst_size = DGST_SIZE_4_5;
10224 parse_func = saph_sha1_parse_hash;
10225 sort_by_digest = sort_by_digest_4_5;
10226 opti_type = OPTI_TYPE_ZERO_BYTE;
10227 dgst_pos0 = 0;
10228 dgst_pos1 = 1;
10229 dgst_pos2 = 2;
10230 dgst_pos3 = 3;
10231 break;
10232
10233 case 10400: hash_type = HASH_TYPE_PDFU16;
10234 salt_type = SALT_TYPE_EMBEDDED;
10235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10236 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10237 kern_type = KERN_TYPE_PDF11;
10238 dgst_size = DGST_SIZE_4_4;
10239 parse_func = pdf11_parse_hash;
10240 sort_by_digest = sort_by_digest_4_4;
10241 opti_type = OPTI_TYPE_ZERO_BYTE
10242 | OPTI_TYPE_NOT_ITERATED;
10243 dgst_pos0 = 0;
10244 dgst_pos1 = 1;
10245 dgst_pos2 = 2;
10246 dgst_pos3 = 3;
10247 break;
10248
10249 case 10410: hash_type = HASH_TYPE_PDFU16;
10250 salt_type = SALT_TYPE_EMBEDDED;
10251 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10252 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10253 kern_type = KERN_TYPE_PDF11CM1;
10254 dgst_size = DGST_SIZE_4_4;
10255 parse_func = pdf11cm1_parse_hash;
10256 sort_by_digest = sort_by_digest_4_4;
10257 opti_type = OPTI_TYPE_ZERO_BYTE
10258 | OPTI_TYPE_NOT_ITERATED;
10259 dgst_pos0 = 0;
10260 dgst_pos1 = 1;
10261 dgst_pos2 = 2;
10262 dgst_pos3 = 3;
10263 break;
10264
10265 case 10420: hash_type = HASH_TYPE_PDFU16;
10266 salt_type = SALT_TYPE_EMBEDDED;
10267 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10268 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10269 kern_type = KERN_TYPE_PDF11CM2;
10270 dgst_size = DGST_SIZE_4_4;
10271 parse_func = pdf11cm2_parse_hash;
10272 sort_by_digest = sort_by_digest_4_4;
10273 opti_type = OPTI_TYPE_ZERO_BYTE
10274 | OPTI_TYPE_NOT_ITERATED;
10275 dgst_pos0 = 0;
10276 dgst_pos1 = 1;
10277 dgst_pos2 = 2;
10278 dgst_pos3 = 3;
10279 break;
10280
10281 case 10500: hash_type = HASH_TYPE_PDFU16;
10282 salt_type = SALT_TYPE_EMBEDDED;
10283 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10284 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10285 kern_type = KERN_TYPE_PDF14;
10286 dgst_size = DGST_SIZE_4_4;
10287 parse_func = pdf14_parse_hash;
10288 sort_by_digest = sort_by_digest_4_4;
10289 opti_type = OPTI_TYPE_ZERO_BYTE
10290 | OPTI_TYPE_NOT_ITERATED;
10291 dgst_pos0 = 0;
10292 dgst_pos1 = 1;
10293 dgst_pos2 = 2;
10294 dgst_pos3 = 3;
10295 break;
10296
10297 case 10600: hash_type = HASH_TYPE_SHA256;
10298 salt_type = SALT_TYPE_EMBEDDED;
10299 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10300 opts_type = OPTS_TYPE_PT_GENERATE_BE
10301 | OPTS_TYPE_ST_ADD80
10302 | OPTS_TYPE_ST_ADDBITS15
10303 | OPTS_TYPE_HASH_COPY;
10304 kern_type = KERN_TYPE_SHA256_PWSLT;
10305 dgst_size = DGST_SIZE_4_8;
10306 parse_func = pdf17l3_parse_hash;
10307 sort_by_digest = sort_by_digest_4_8;
10308 opti_type = OPTI_TYPE_ZERO_BYTE
10309 | OPTI_TYPE_PRECOMPUTE_INIT
10310 | OPTI_TYPE_PRECOMPUTE_MERKLE
10311 | OPTI_TYPE_EARLY_SKIP
10312 | OPTI_TYPE_NOT_ITERATED
10313 | OPTI_TYPE_APPENDED_SALT
10314 | OPTI_TYPE_RAW_HASH;
10315 dgst_pos0 = 3;
10316 dgst_pos1 = 7;
10317 dgst_pos2 = 2;
10318 dgst_pos3 = 6;
10319 break;
10320
10321 case 10700: hash_type = HASH_TYPE_PDFU32;
10322 salt_type = SALT_TYPE_EMBEDDED;
10323 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10324 opts_type = OPTS_TYPE_PT_GENERATE_LE
10325 | OPTS_TYPE_HASH_COPY;
10326 kern_type = KERN_TYPE_PDF17L8;
10327 dgst_size = DGST_SIZE_4_8;
10328 parse_func = pdf17l8_parse_hash;
10329 sort_by_digest = sort_by_digest_4_8;
10330 opti_type = OPTI_TYPE_ZERO_BYTE
10331 | OPTI_TYPE_NOT_ITERATED;
10332 dgst_pos0 = 0;
10333 dgst_pos1 = 1;
10334 dgst_pos2 = 2;
10335 dgst_pos3 = 3;
10336 break;
10337
10338 case 10800: hash_type = HASH_TYPE_SHA384;
10339 salt_type = SALT_TYPE_NONE;
10340 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10341 opts_type = OPTS_TYPE_PT_GENERATE_BE
10342 | OPTS_TYPE_PT_ADD80
10343 | OPTS_TYPE_PT_ADDBITS15;
10344 kern_type = KERN_TYPE_SHA384;
10345 dgst_size = DGST_SIZE_8_8;
10346 parse_func = sha384_parse_hash;
10347 sort_by_digest = sort_by_digest_8_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_NOT_SALTED
10354 | OPTI_TYPE_USES_BITS_64
10355 | OPTI_TYPE_RAW_HASH;
10356 dgst_pos0 = 6;
10357 dgst_pos1 = 7;
10358 dgst_pos2 = 4;
10359 dgst_pos3 = 5;
10360 break;
10361
10362 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10363 salt_type = SALT_TYPE_EMBEDDED;
10364 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10365 opts_type = OPTS_TYPE_PT_GENERATE_LE
10366 | OPTS_TYPE_ST_BASE64
10367 | OPTS_TYPE_HASH_COPY;
10368 kern_type = KERN_TYPE_PBKDF2_SHA256;
10369 dgst_size = DGST_SIZE_4_32;
10370 parse_func = pbkdf2_sha256_parse_hash;
10371 sort_by_digest = sort_by_digest_4_32;
10372 opti_type = OPTI_TYPE_ZERO_BYTE
10373 | OPTI_TYPE_SLOW_HASH_SIMD;
10374 dgst_pos0 = 0;
10375 dgst_pos1 = 1;
10376 dgst_pos2 = 2;
10377 dgst_pos3 = 3;
10378 break;
10379
10380 case 11000: hash_type = HASH_TYPE_MD5;
10381 salt_type = SALT_TYPE_INTERN;
10382 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10383 opts_type = OPTS_TYPE_PT_GENERATE_LE
10384 | OPTS_TYPE_PT_ADD80;
10385 kern_type = KERN_TYPE_PRESTASHOP;
10386 dgst_size = DGST_SIZE_4_4;
10387 parse_func = prestashop_parse_hash;
10388 sort_by_digest = sort_by_digest_4_4;
10389 opti_type = OPTI_TYPE_ZERO_BYTE
10390 | OPTI_TYPE_PRECOMPUTE_INIT
10391 | OPTI_TYPE_NOT_ITERATED
10392 | OPTI_TYPE_PREPENDED_SALT;
10393 dgst_pos0 = 0;
10394 dgst_pos1 = 3;
10395 dgst_pos2 = 2;
10396 dgst_pos3 = 1;
10397 break;
10398
10399 case 11100: hash_type = HASH_TYPE_MD5;
10400 salt_type = SALT_TYPE_EMBEDDED;
10401 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10402 opts_type = OPTS_TYPE_PT_GENERATE_LE
10403 | OPTS_TYPE_ST_ADD80;
10404 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10405 dgst_size = DGST_SIZE_4_4;
10406 parse_func = postgresql_auth_parse_hash;
10407 sort_by_digest = sort_by_digest_4_4;
10408 opti_type = OPTI_TYPE_ZERO_BYTE
10409 | OPTI_TYPE_PRECOMPUTE_INIT
10410 | OPTI_TYPE_PRECOMPUTE_MERKLE
10411 | OPTI_TYPE_EARLY_SKIP;
10412 dgst_pos0 = 0;
10413 dgst_pos1 = 3;
10414 dgst_pos2 = 2;
10415 dgst_pos3 = 1;
10416 break;
10417
10418 case 11200: hash_type = HASH_TYPE_SHA1;
10419 salt_type = SALT_TYPE_EMBEDDED;
10420 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10421 opts_type = OPTS_TYPE_PT_GENERATE_BE
10422 | OPTS_TYPE_PT_ADD80
10423 | OPTS_TYPE_ST_HEX;
10424 kern_type = KERN_TYPE_MYSQL_AUTH;
10425 dgst_size = DGST_SIZE_4_5;
10426 parse_func = mysql_auth_parse_hash;
10427 sort_by_digest = sort_by_digest_4_5;
10428 opti_type = OPTI_TYPE_ZERO_BYTE
10429 | OPTI_TYPE_EARLY_SKIP;
10430 dgst_pos0 = 3;
10431 dgst_pos1 = 4;
10432 dgst_pos2 = 2;
10433 dgst_pos3 = 1;
10434 break;
10435
10436 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10437 salt_type = SALT_TYPE_EMBEDDED;
10438 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10439 opts_type = OPTS_TYPE_PT_GENERATE_LE
10440 | OPTS_TYPE_ST_HEX
10441 | OPTS_TYPE_ST_ADD80;
10442 kern_type = KERN_TYPE_BITCOIN_WALLET;
10443 dgst_size = DGST_SIZE_4_4;
10444 parse_func = bitcoin_wallet_parse_hash;
10445 sort_by_digest = sort_by_digest_4_4;
10446 opti_type = OPTI_TYPE_ZERO_BYTE;
10447 dgst_pos0 = 0;
10448 dgst_pos1 = 1;
10449 dgst_pos2 = 2;
10450 dgst_pos3 = 3;
10451 break;
10452
10453 case 11400: hash_type = HASH_TYPE_MD5;
10454 salt_type = SALT_TYPE_EMBEDDED;
10455 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10456 opts_type = OPTS_TYPE_PT_GENERATE_LE
10457 | OPTS_TYPE_PT_ADD80
10458 | OPTS_TYPE_HASH_COPY;
10459 kern_type = KERN_TYPE_SIP_AUTH;
10460 dgst_size = DGST_SIZE_4_4;
10461 parse_func = sip_auth_parse_hash;
10462 sort_by_digest = sort_by_digest_4_4;
10463 opti_type = OPTI_TYPE_ZERO_BYTE;
10464 dgst_pos0 = 0;
10465 dgst_pos1 = 3;
10466 dgst_pos2 = 2;
10467 dgst_pos3 = 1;
10468 break;
10469
10470 case 11500: hash_type = HASH_TYPE_CRC32;
10471 salt_type = SALT_TYPE_INTERN;
10472 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10473 opts_type = OPTS_TYPE_PT_GENERATE_LE
10474 | OPTS_TYPE_ST_GENERATE_LE
10475 | OPTS_TYPE_ST_HEX;
10476 kern_type = KERN_TYPE_CRC32;
10477 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10478 parse_func = crc32_parse_hash;
10479 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10480 opti_type = OPTI_TYPE_ZERO_BYTE;
10481 dgst_pos0 = 0;
10482 dgst_pos1 = 1;
10483 dgst_pos2 = 2;
10484 dgst_pos3 = 3;
10485 break;
10486
10487 case 11600: hash_type = HASH_TYPE_AES;
10488 salt_type = SALT_TYPE_EMBEDDED;
10489 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10490 opts_type = OPTS_TYPE_PT_GENERATE_LE
10491 | OPTS_TYPE_PT_NEVERCRACK;
10492 kern_type = KERN_TYPE_SEVEN_ZIP;
10493 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10494 parse_func = seven_zip_parse_hash;
10495 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10496 opti_type = OPTI_TYPE_ZERO_BYTE;
10497 dgst_pos0 = 0;
10498 dgst_pos1 = 1;
10499 dgst_pos2 = 2;
10500 dgst_pos3 = 3;
10501 break;
10502
10503 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10504 salt_type = SALT_TYPE_NONE;
10505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10506 opts_type = OPTS_TYPE_PT_GENERATE_LE
10507 | OPTS_TYPE_PT_ADD01;
10508 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10509 dgst_size = DGST_SIZE_4_8;
10510 parse_func = gost2012sbog_256_parse_hash;
10511 sort_by_digest = sort_by_digest_4_8;
10512 opti_type = OPTI_TYPE_ZERO_BYTE;
10513 dgst_pos0 = 0;
10514 dgst_pos1 = 1;
10515 dgst_pos2 = 2;
10516 dgst_pos3 = 3;
10517 break;
10518
10519 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10520 salt_type = SALT_TYPE_NONE;
10521 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10522 opts_type = OPTS_TYPE_PT_GENERATE_LE
10523 | OPTS_TYPE_PT_ADD01;
10524 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10525 dgst_size = DGST_SIZE_4_16;
10526 parse_func = gost2012sbog_512_parse_hash;
10527 sort_by_digest = sort_by_digest_4_16;
10528 opti_type = OPTI_TYPE_ZERO_BYTE;
10529 dgst_pos0 = 0;
10530 dgst_pos1 = 1;
10531 dgst_pos2 = 2;
10532 dgst_pos3 = 3;
10533 break;
10534
10535 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10536 salt_type = SALT_TYPE_EMBEDDED;
10537 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10538 opts_type = OPTS_TYPE_PT_GENERATE_LE
10539 | OPTS_TYPE_ST_BASE64
10540 | OPTS_TYPE_HASH_COPY;
10541 kern_type = KERN_TYPE_PBKDF2_MD5;
10542 dgst_size = DGST_SIZE_4_32;
10543 parse_func = pbkdf2_md5_parse_hash;
10544 sort_by_digest = sort_by_digest_4_32;
10545 opti_type = OPTI_TYPE_ZERO_BYTE
10546 | OPTI_TYPE_SLOW_HASH_SIMD;
10547 dgst_pos0 = 0;
10548 dgst_pos1 = 1;
10549 dgst_pos2 = 2;
10550 dgst_pos3 = 3;
10551 break;
10552
10553 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10554 salt_type = SALT_TYPE_EMBEDDED;
10555 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10556 opts_type = OPTS_TYPE_PT_GENERATE_LE
10557 | OPTS_TYPE_ST_BASE64
10558 | OPTS_TYPE_HASH_COPY;
10559 kern_type = KERN_TYPE_PBKDF2_SHA1;
10560 dgst_size = DGST_SIZE_4_32;
10561 parse_func = pbkdf2_sha1_parse_hash;
10562 sort_by_digest = sort_by_digest_4_32;
10563 opti_type = OPTI_TYPE_ZERO_BYTE
10564 | OPTI_TYPE_SLOW_HASH_SIMD;
10565 dgst_pos0 = 0;
10566 dgst_pos1 = 1;
10567 dgst_pos2 = 2;
10568 dgst_pos3 = 3;
10569 break;
10570
10571 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10572 salt_type = SALT_TYPE_EMBEDDED;
10573 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10574 opts_type = OPTS_TYPE_PT_GENERATE_LE
10575 | OPTS_TYPE_ST_BASE64
10576 | OPTS_TYPE_HASH_COPY;
10577 kern_type = KERN_TYPE_PBKDF2_SHA512;
10578 dgst_size = DGST_SIZE_8_16;
10579 parse_func = pbkdf2_sha512_parse_hash;
10580 sort_by_digest = sort_by_digest_8_16;
10581 opti_type = OPTI_TYPE_ZERO_BYTE
10582 | OPTI_TYPE_USES_BITS_64
10583 | OPTI_TYPE_SLOW_HASH_SIMD;
10584 dgst_pos0 = 0;
10585 dgst_pos1 = 1;
10586 dgst_pos2 = 2;
10587 dgst_pos3 = 3;
10588 break;
10589
10590 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10591 salt_type = SALT_TYPE_EMBEDDED;
10592 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10593 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10594 kern_type = KERN_TYPE_ECRYPTFS;
10595 dgst_size = DGST_SIZE_8_8;
10596 parse_func = ecryptfs_parse_hash;
10597 sort_by_digest = sort_by_digest_8_8;
10598 opti_type = OPTI_TYPE_ZERO_BYTE
10599 | OPTI_TYPE_USES_BITS_64;
10600 dgst_pos0 = 0;
10601 dgst_pos1 = 1;
10602 dgst_pos2 = 2;
10603 dgst_pos3 = 3;
10604 break;
10605
10606 case 12300: hash_type = HASH_TYPE_ORACLET;
10607 salt_type = SALT_TYPE_EMBEDDED;
10608 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10609 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10610 kern_type = KERN_TYPE_ORACLET;
10611 dgst_size = DGST_SIZE_8_16;
10612 parse_func = oraclet_parse_hash;
10613 sort_by_digest = sort_by_digest_8_16;
10614 opti_type = OPTI_TYPE_ZERO_BYTE
10615 | OPTI_TYPE_USES_BITS_64;
10616 dgst_pos0 = 0;
10617 dgst_pos1 = 1;
10618 dgst_pos2 = 2;
10619 dgst_pos3 = 3;
10620 break;
10621
10622 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10623 salt_type = SALT_TYPE_EMBEDDED;
10624 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10625 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10626 kern_type = KERN_TYPE_BSDICRYPT;
10627 dgst_size = DGST_SIZE_4_4;
10628 parse_func = bsdicrypt_parse_hash;
10629 sort_by_digest = sort_by_digest_4_4;
10630 opti_type = OPTI_TYPE_ZERO_BYTE
10631 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10632 dgst_pos0 = 0;
10633 dgst_pos1 = 1;
10634 dgst_pos2 = 2;
10635 dgst_pos3 = 3;
10636 break;
10637
10638 case 12500: hash_type = HASH_TYPE_RAR3HP;
10639 salt_type = SALT_TYPE_EMBEDDED;
10640 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10641 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10642 kern_type = KERN_TYPE_RAR3;
10643 dgst_size = DGST_SIZE_4_4;
10644 parse_func = rar3hp_parse_hash;
10645 sort_by_digest = sort_by_digest_4_4;
10646 opti_type = OPTI_TYPE_ZERO_BYTE;
10647 dgst_pos0 = 0;
10648 dgst_pos1 = 1;
10649 dgst_pos2 = 2;
10650 dgst_pos3 = 3;
10651 break;
10652
10653 case 12600: hash_type = HASH_TYPE_SHA256;
10654 salt_type = SALT_TYPE_INTERN;
10655 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10656 opts_type = OPTS_TYPE_PT_GENERATE_BE
10657 | OPTS_TYPE_PT_ADD80;
10658 kern_type = KERN_TYPE_CF10;
10659 dgst_size = DGST_SIZE_4_8;
10660 parse_func = cf10_parse_hash;
10661 sort_by_digest = sort_by_digest_4_8;
10662 opti_type = OPTI_TYPE_ZERO_BYTE
10663 | OPTI_TYPE_PRECOMPUTE_INIT
10664 | OPTI_TYPE_EARLY_SKIP
10665 | OPTI_TYPE_NOT_ITERATED;
10666 dgst_pos0 = 3;
10667 dgst_pos1 = 7;
10668 dgst_pos2 = 2;
10669 dgst_pos3 = 6;
10670 break;
10671
10672 case 12700: hash_type = HASH_TYPE_AES;
10673 salt_type = SALT_TYPE_EMBEDDED;
10674 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10675 opts_type = OPTS_TYPE_PT_GENERATE_LE
10676 | OPTS_TYPE_HASH_COPY;
10677 kern_type = KERN_TYPE_MYWALLET;
10678 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10679 parse_func = mywallet_parse_hash;
10680 sort_by_digest = sort_by_digest_4_5;
10681 opti_type = OPTI_TYPE_ZERO_BYTE;
10682 dgst_pos0 = 0;
10683 dgst_pos1 = 1;
10684 dgst_pos2 = 2;
10685 dgst_pos3 = 3;
10686 break;
10687
10688 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10689 salt_type = SALT_TYPE_EMBEDDED;
10690 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10691 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10692 kern_type = KERN_TYPE_MS_DRSR;
10693 dgst_size = DGST_SIZE_4_8;
10694 parse_func = ms_drsr_parse_hash;
10695 sort_by_digest = sort_by_digest_4_8;
10696 opti_type = OPTI_TYPE_ZERO_BYTE;
10697 dgst_pos0 = 0;
10698 dgst_pos1 = 1;
10699 dgst_pos2 = 2;
10700 dgst_pos3 = 3;
10701 break;
10702
10703 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10704 salt_type = SALT_TYPE_EMBEDDED;
10705 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10706 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10707 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10708 dgst_size = DGST_SIZE_4_8;
10709 parse_func = androidfde_samsung_parse_hash;
10710 sort_by_digest = sort_by_digest_4_8;
10711 opti_type = OPTI_TYPE_ZERO_BYTE;
10712 dgst_pos0 = 0;
10713 dgst_pos1 = 1;
10714 dgst_pos2 = 2;
10715 dgst_pos3 = 3;
10716 break;
10717
10718 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10719 salt_type = SALT_TYPE_EMBEDDED;
10720 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10721 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10722 kern_type = KERN_TYPE_RAR5;
10723 dgst_size = DGST_SIZE_4_4;
10724 parse_func = rar5_parse_hash;
10725 sort_by_digest = sort_by_digest_4_4;
10726 opti_type = OPTI_TYPE_ZERO_BYTE;
10727 dgst_pos0 = 0;
10728 dgst_pos1 = 1;
10729 dgst_pos2 = 2;
10730 dgst_pos3 = 3;
10731 break;
10732
10733 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10734 salt_type = SALT_TYPE_EMBEDDED;
10735 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10736 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10737 kern_type = KERN_TYPE_KRB5TGS;
10738 dgst_size = DGST_SIZE_4_4;
10739 parse_func = krb5tgs_parse_hash;
10740 sort_by_digest = sort_by_digest_4_4;
10741 opti_type = OPTI_TYPE_ZERO_BYTE
10742 | OPTI_TYPE_NOT_ITERATED;
10743 dgst_pos0 = 0;
10744 dgst_pos1 = 1;
10745 dgst_pos2 = 2;
10746 dgst_pos3 = 3;
10747 break;
10748
10749 case 13200: hash_type = HASH_TYPE_AES;
10750 salt_type = SALT_TYPE_EMBEDDED;
10751 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10752 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10753 kern_type = KERN_TYPE_AXCRYPT;
10754 dgst_size = DGST_SIZE_4_4;
10755 parse_func = axcrypt_parse_hash;
10756 sort_by_digest = sort_by_digest_4_4;
10757 opti_type = OPTI_TYPE_ZERO_BYTE;
10758 dgst_pos0 = 0;
10759 dgst_pos1 = 1;
10760 dgst_pos2 = 2;
10761 dgst_pos3 = 3;
10762 break;
10763
10764 case 13300: hash_type = HASH_TYPE_SHA1;
10765 salt_type = SALT_TYPE_NONE;
10766 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10767 opts_type = OPTS_TYPE_PT_GENERATE_BE
10768 | OPTS_TYPE_PT_ADD80
10769 | OPTS_TYPE_PT_ADDBITS15;
10770 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10771 dgst_size = DGST_SIZE_4_5;
10772 parse_func = sha1axcrypt_parse_hash;
10773 sort_by_digest = sort_by_digest_4_5;
10774 opti_type = OPTI_TYPE_ZERO_BYTE
10775 | OPTI_TYPE_PRECOMPUTE_INIT
10776 | OPTI_TYPE_EARLY_SKIP
10777 | OPTI_TYPE_NOT_ITERATED
10778 | OPTI_TYPE_NOT_SALTED;
10779 dgst_pos0 = 0;
10780 dgst_pos1 = 4;
10781 dgst_pos2 = 3;
10782 dgst_pos3 = 2;
10783 break;
10784
10785 case 13400: hash_type = HASH_TYPE_AES;
10786 salt_type = SALT_TYPE_EMBEDDED;
10787 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10788 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10789 kern_type = KERN_TYPE_KEEPASS;
10790 dgst_size = DGST_SIZE_4_4;
10791 parse_func = keepass_parse_hash;
10792 sort_by_digest = sort_by_digest_4_4;
10793 opti_type = OPTI_TYPE_ZERO_BYTE;
10794 dgst_pos0 = 0;
10795 dgst_pos1 = 1;
10796 dgst_pos2 = 2;
10797 dgst_pos3 = 3;
10798 break;
10799
10800 case 13500: hash_type = HASH_TYPE_SHA1;
10801 salt_type = SALT_TYPE_EMBEDDED;
10802 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10803 opts_type = OPTS_TYPE_PT_GENERATE_BE
10804 | OPTS_TYPE_PT_UNICODE
10805 | OPTS_TYPE_PT_ADD80;
10806 kern_type = KERN_TYPE_PSTOKEN;
10807 dgst_size = DGST_SIZE_4_5;
10808 parse_func = pstoken_parse_hash;
10809 sort_by_digest = sort_by_digest_4_5;
10810 opti_type = OPTI_TYPE_ZERO_BYTE
10811 | OPTI_TYPE_PRECOMPUTE_INIT
10812 | OPTI_TYPE_EARLY_SKIP
10813 | OPTI_TYPE_NOT_ITERATED
10814 | OPTI_TYPE_PREPENDED_SALT
10815 | OPTI_TYPE_RAW_HASH;
10816 dgst_pos0 = 3;
10817 dgst_pos1 = 4;
10818 dgst_pos2 = 2;
10819 dgst_pos3 = 1;
10820 break;
10821
10822 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10823 salt_type = SALT_TYPE_EMBEDDED;
10824 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10825 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10826 kern_type = KERN_TYPE_ZIP2;
10827 dgst_size = DGST_SIZE_4_4;
10828 parse_func = zip2_parse_hash;
10829 sort_by_digest = sort_by_digest_4_4;
10830 opti_type = OPTI_TYPE_ZERO_BYTE;
10831 dgst_pos0 = 0;
10832 dgst_pos1 = 1;
10833 dgst_pos2 = 2;
10834 dgst_pos3 = 3;
10835 break;
10836
10837 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10838 salt_type = SALT_TYPE_EMBEDDED;
10839 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10840 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10841 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10842 dgst_size = DGST_SIZE_4_5;
10843 parse_func = veracrypt_parse_hash_655331;
10844 sort_by_digest = sort_by_digest_4_5;
10845 opti_type = OPTI_TYPE_ZERO_BYTE;
10846 dgst_pos0 = 0;
10847 dgst_pos1 = 1;
10848 dgst_pos2 = 2;
10849 dgst_pos3 = 3;
10850 break;
10851
10852 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10853 salt_type = SALT_TYPE_EMBEDDED;
10854 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10855 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10856 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10857 dgst_size = DGST_SIZE_4_5;
10858 parse_func = veracrypt_parse_hash_655331;
10859 sort_by_digest = sort_by_digest_4_5;
10860 opti_type = OPTI_TYPE_ZERO_BYTE;
10861 dgst_pos0 = 0;
10862 dgst_pos1 = 1;
10863 dgst_pos2 = 2;
10864 dgst_pos3 = 3;
10865 break;
10866
10867 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10868 salt_type = SALT_TYPE_EMBEDDED;
10869 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10870 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10871 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10872 dgst_size = DGST_SIZE_4_5;
10873 parse_func = veracrypt_parse_hash_655331;
10874 sort_by_digest = sort_by_digest_4_5;
10875 opti_type = OPTI_TYPE_ZERO_BYTE;
10876 dgst_pos0 = 0;
10877 dgst_pos1 = 1;
10878 dgst_pos2 = 2;
10879 dgst_pos3 = 3;
10880 break;
10881
10882 case 13721: hash_type = HASH_TYPE_SHA512;
10883 salt_type = SALT_TYPE_EMBEDDED;
10884 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10885 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10886 kern_type = KERN_TYPE_TCSHA512_XTS512;
10887 dgst_size = DGST_SIZE_8_8;
10888 parse_func = veracrypt_parse_hash_500000;
10889 sort_by_digest = sort_by_digest_8_8;
10890 opti_type = OPTI_TYPE_ZERO_BYTE
10891 | OPTI_TYPE_USES_BITS_64;
10892 dgst_pos0 = 0;
10893 dgst_pos1 = 1;
10894 dgst_pos2 = 2;
10895 dgst_pos3 = 3;
10896 break;
10897
10898 case 13722: hash_type = HASH_TYPE_SHA512;
10899 salt_type = SALT_TYPE_EMBEDDED;
10900 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10901 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10902 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10903 dgst_size = DGST_SIZE_8_8;
10904 parse_func = veracrypt_parse_hash_500000;
10905 sort_by_digest = sort_by_digest_8_8;
10906 opti_type = OPTI_TYPE_ZERO_BYTE
10907 | OPTI_TYPE_USES_BITS_64;
10908 dgst_pos0 = 0;
10909 dgst_pos1 = 1;
10910 dgst_pos2 = 2;
10911 dgst_pos3 = 3;
10912 break;
10913
10914 case 13723: hash_type = HASH_TYPE_SHA512;
10915 salt_type = SALT_TYPE_EMBEDDED;
10916 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10917 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10918 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10919 dgst_size = DGST_SIZE_8_8;
10920 parse_func = veracrypt_parse_hash_500000;
10921 sort_by_digest = sort_by_digest_8_8;
10922 opti_type = OPTI_TYPE_ZERO_BYTE
10923 | OPTI_TYPE_USES_BITS_64;
10924 dgst_pos0 = 0;
10925 dgst_pos1 = 1;
10926 dgst_pos2 = 2;
10927 dgst_pos3 = 3;
10928 break;
10929
10930 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10931 salt_type = SALT_TYPE_EMBEDDED;
10932 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10933 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10934 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10935 dgst_size = DGST_SIZE_4_8;
10936 parse_func = veracrypt_parse_hash_500000;
10937 sort_by_digest = sort_by_digest_4_8;
10938 opti_type = OPTI_TYPE_ZERO_BYTE;
10939 dgst_pos0 = 0;
10940 dgst_pos1 = 1;
10941 dgst_pos2 = 2;
10942 dgst_pos3 = 3;
10943 break;
10944
10945 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10946 salt_type = SALT_TYPE_EMBEDDED;
10947 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10948 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10949 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10950 dgst_size = DGST_SIZE_4_8;
10951 parse_func = veracrypt_parse_hash_500000;
10952 sort_by_digest = sort_by_digest_4_8;
10953 opti_type = OPTI_TYPE_ZERO_BYTE;
10954 dgst_pos0 = 0;
10955 dgst_pos1 = 1;
10956 dgst_pos2 = 2;
10957 dgst_pos3 = 3;
10958 break;
10959
10960 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10961 salt_type = SALT_TYPE_EMBEDDED;
10962 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10963 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10964 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10965 dgst_size = DGST_SIZE_4_8;
10966 parse_func = veracrypt_parse_hash_500000;
10967 sort_by_digest = sort_by_digest_4_8;
10968 opti_type = OPTI_TYPE_ZERO_BYTE;
10969 dgst_pos0 = 0;
10970 dgst_pos1 = 1;
10971 dgst_pos2 = 2;
10972 dgst_pos3 = 3;
10973 break;
10974
10975 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10976 salt_type = SALT_TYPE_EMBEDDED;
10977 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10978 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10979 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10980 dgst_size = DGST_SIZE_4_5;
10981 parse_func = veracrypt_parse_hash_327661;
10982 sort_by_digest = sort_by_digest_4_5;
10983 opti_type = OPTI_TYPE_ZERO_BYTE;
10984 dgst_pos0 = 0;
10985 dgst_pos1 = 1;
10986 dgst_pos2 = 2;
10987 dgst_pos3 = 3;
10988 break;
10989
10990 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10991 salt_type = SALT_TYPE_EMBEDDED;
10992 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10993 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10994 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10995 dgst_size = DGST_SIZE_4_5;
10996 parse_func = veracrypt_parse_hash_327661;
10997 sort_by_digest = sort_by_digest_4_5;
10998 opti_type = OPTI_TYPE_ZERO_BYTE;
10999 dgst_pos0 = 0;
11000 dgst_pos1 = 1;
11001 dgst_pos2 = 2;
11002 dgst_pos3 = 3;
11003 break;
11004
11005 case 13743: hash_type = HASH_TYPE_RIPEMD160;
11006 salt_type = SALT_TYPE_EMBEDDED;
11007 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11008 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11009 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11010 dgst_size = DGST_SIZE_4_5;
11011 parse_func = veracrypt_parse_hash_327661;
11012 sort_by_digest = sort_by_digest_4_5;
11013 opti_type = OPTI_TYPE_ZERO_BYTE;
11014 dgst_pos0 = 0;
11015 dgst_pos1 = 1;
11016 dgst_pos2 = 2;
11017 dgst_pos3 = 3;
11018 break;
11019
11020 case 13751: hash_type = HASH_TYPE_SHA256;
11021 salt_type = SALT_TYPE_EMBEDDED;
11022 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11023 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11024 kern_type = KERN_TYPE_VCSHA256_XTS512;
11025 dgst_size = DGST_SIZE_4_8;
11026 parse_func = veracrypt_parse_hash_500000;
11027 sort_by_digest = sort_by_digest_4_8;
11028 opti_type = OPTI_TYPE_ZERO_BYTE;
11029 dgst_pos0 = 0;
11030 dgst_pos1 = 1;
11031 dgst_pos2 = 2;
11032 dgst_pos3 = 3;
11033 break;
11034
11035 case 13752: hash_type = HASH_TYPE_SHA256;
11036 salt_type = SALT_TYPE_EMBEDDED;
11037 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11038 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11039 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11040 dgst_size = DGST_SIZE_4_8;
11041 parse_func = veracrypt_parse_hash_500000;
11042 sort_by_digest = sort_by_digest_4_8;
11043 opti_type = OPTI_TYPE_ZERO_BYTE;
11044 dgst_pos0 = 0;
11045 dgst_pos1 = 1;
11046 dgst_pos2 = 2;
11047 dgst_pos3 = 3;
11048 break;
11049
11050 case 13753: hash_type = HASH_TYPE_SHA256;
11051 salt_type = SALT_TYPE_EMBEDDED;
11052 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11053 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11054 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11055 dgst_size = DGST_SIZE_4_8;
11056 parse_func = veracrypt_parse_hash_500000;
11057 sort_by_digest = sort_by_digest_4_8;
11058 opti_type = OPTI_TYPE_ZERO_BYTE;
11059 dgst_pos0 = 0;
11060 dgst_pos1 = 1;
11061 dgst_pos2 = 2;
11062 dgst_pos3 = 3;
11063 break;
11064
11065 case 13761: hash_type = HASH_TYPE_SHA256;
11066 salt_type = SALT_TYPE_EMBEDDED;
11067 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11068 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11069 kern_type = KERN_TYPE_VCSHA256_XTS512;
11070 dgst_size = DGST_SIZE_4_8;
11071 parse_func = veracrypt_parse_hash_200000;
11072 sort_by_digest = sort_by_digest_4_8;
11073 opti_type = OPTI_TYPE_ZERO_BYTE;
11074 dgst_pos0 = 0;
11075 dgst_pos1 = 1;
11076 dgst_pos2 = 2;
11077 dgst_pos3 = 3;
11078 break;
11079
11080 case 13762: hash_type = HASH_TYPE_SHA256;
11081 salt_type = SALT_TYPE_EMBEDDED;
11082 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11083 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11084 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11085 dgst_size = DGST_SIZE_4_8;
11086 parse_func = veracrypt_parse_hash_200000;
11087 sort_by_digest = sort_by_digest_4_8;
11088 opti_type = OPTI_TYPE_ZERO_BYTE;
11089 dgst_pos0 = 0;
11090 dgst_pos1 = 1;
11091 dgst_pos2 = 2;
11092 dgst_pos3 = 3;
11093 break;
11094
11095 case 13763: hash_type = HASH_TYPE_SHA256;
11096 salt_type = SALT_TYPE_EMBEDDED;
11097 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11098 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11099 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11100 dgst_size = DGST_SIZE_4_8;
11101 parse_func = veracrypt_parse_hash_200000;
11102 sort_by_digest = sort_by_digest_4_8;
11103 opti_type = OPTI_TYPE_ZERO_BYTE;
11104 dgst_pos0 = 0;
11105 dgst_pos1 = 1;
11106 dgst_pos2 = 2;
11107 dgst_pos3 = 3;
11108 break;
11109
11110 case 13800: hash_type = HASH_TYPE_SHA256;
11111 salt_type = SALT_TYPE_EMBEDDED;
11112 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11113 opts_type = OPTS_TYPE_PT_GENERATE_BE
11114 | OPTS_TYPE_PT_UNICODE;
11115 kern_type = KERN_TYPE_WIN8PHONE;
11116 dgst_size = DGST_SIZE_4_8;
11117 parse_func = win8phone_parse_hash;
11118 sort_by_digest = sort_by_digest_4_8;
11119 opti_type = OPTI_TYPE_ZERO_BYTE
11120 | OPTI_TYPE_PRECOMPUTE_INIT
11121 | OPTI_TYPE_EARLY_SKIP
11122 | OPTI_TYPE_NOT_ITERATED
11123 | OPTI_TYPE_RAW_HASH;
11124 dgst_pos0 = 3;
11125 dgst_pos1 = 7;
11126 dgst_pos2 = 2;
11127 dgst_pos3 = 6;
11128 break;
11129
11130 default: usage_mini_print (PROGNAME); return (-1);
11131 }
11132
11133 /**
11134 * parser
11135 */
11136
11137 data.parse_func = parse_func;
11138
11139 /**
11140 * misc stuff
11141 */
11142
11143 if (hex_salt)
11144 {
11145 if (salt_type == SALT_TYPE_INTERN)
11146 {
11147 opts_type |= OPTS_TYPE_ST_HEX;
11148 }
11149 else
11150 {
11151 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11152
11153 return (-1);
11154 }
11155 }
11156
11157 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11158 | (salt_type == SALT_TYPE_EXTERN)
11159 | (salt_type == SALT_TYPE_EMBEDDED)
11160 | (salt_type == SALT_TYPE_VIRTUAL));
11161
11162 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
11163
11164 data.hash_type = hash_type;
11165 data.attack_mode = attack_mode;
11166 data.attack_kern = attack_kern;
11167 data.attack_exec = attack_exec;
11168 data.kern_type = kern_type;
11169 data.opts_type = opts_type;
11170 data.dgst_size = dgst_size;
11171 data.salt_type = salt_type;
11172 data.isSalted = isSalted;
11173 data.sort_by_digest = sort_by_digest;
11174 data.dgst_pos0 = dgst_pos0;
11175 data.dgst_pos1 = dgst_pos1;
11176 data.dgst_pos2 = dgst_pos2;
11177 data.dgst_pos3 = dgst_pos3;
11178
11179 esalt_size = 0;
11180
11181 switch (hash_mode)
11182 {
11183 case 2500: esalt_size = sizeof (wpa_t); break;
11184 case 5300: esalt_size = sizeof (ikepsk_t); break;
11185 case 5400: esalt_size = sizeof (ikepsk_t); break;
11186 case 5500: esalt_size = sizeof (netntlm_t); break;
11187 case 5600: esalt_size = sizeof (netntlm_t); break;
11188 case 6211: esalt_size = sizeof (tc_t); break;
11189 case 6212: esalt_size = sizeof (tc_t); break;
11190 case 6213: esalt_size = sizeof (tc_t); break;
11191 case 6221: esalt_size = sizeof (tc_t); break;
11192 case 6222: esalt_size = sizeof (tc_t); break;
11193 case 6223: esalt_size = sizeof (tc_t); break;
11194 case 6231: esalt_size = sizeof (tc_t); break;
11195 case 6232: esalt_size = sizeof (tc_t); break;
11196 case 6233: esalt_size = sizeof (tc_t); break;
11197 case 6241: esalt_size = sizeof (tc_t); break;
11198 case 6242: esalt_size = sizeof (tc_t); break;
11199 case 6243: esalt_size = sizeof (tc_t); break;
11200 case 6600: esalt_size = sizeof (agilekey_t); break;
11201 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11202 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
11203 case 7300: esalt_size = sizeof (rakp_t); break;
11204 case 7500: esalt_size = sizeof (krb5pa_t); break;
11205 case 8200: esalt_size = sizeof (cloudkey_t); break;
11206 case 8800: esalt_size = sizeof (androidfde_t); break;
11207 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
11208 case 9400: esalt_size = sizeof (office2007_t); break;
11209 case 9500: esalt_size = sizeof (office2010_t); break;
11210 case 9600: esalt_size = sizeof (office2013_t); break;
11211 case 9700: esalt_size = sizeof (oldoffice01_t); break;
11212 case 9710: esalt_size = sizeof (oldoffice01_t); break;
11213 case 9720: esalt_size = sizeof (oldoffice01_t); break;
11214 case 9800: esalt_size = sizeof (oldoffice34_t); break;
11215 case 9810: esalt_size = sizeof (oldoffice34_t); break;
11216 case 9820: esalt_size = sizeof (oldoffice34_t); break;
11217 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
11218 case 10200: esalt_size = sizeof (cram_md5_t); break;
11219 case 10400: esalt_size = sizeof (pdf_t); break;
11220 case 10410: esalt_size = sizeof (pdf_t); break;
11221 case 10420: esalt_size = sizeof (pdf_t); break;
11222 case 10500: esalt_size = sizeof (pdf_t); break;
11223 case 10600: esalt_size = sizeof (pdf_t); break;
11224 case 10700: esalt_size = sizeof (pdf_t); break;
11225 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
11226 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
11227 case 11400: esalt_size = sizeof (sip_t); break;
11228 case 11600: esalt_size = sizeof (seven_zip_t); break;
11229 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
11230 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
11231 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11232 case 13000: esalt_size = sizeof (rar5_t); break;
11233 case 13100: esalt_size = sizeof (krb5tgs_t); break;
11234 case 13400: esalt_size = sizeof (keepass_t); break;
11235 case 13500: esalt_size = sizeof (pstoken_t); break;
11236 case 13600: esalt_size = sizeof (zip2_t); break;
11237 case 13711: esalt_size = sizeof (tc_t); break;
11238 case 13712: esalt_size = sizeof (tc_t); break;
11239 case 13713: esalt_size = sizeof (tc_t); break;
11240 case 13721: esalt_size = sizeof (tc_t); break;
11241 case 13722: esalt_size = sizeof (tc_t); break;
11242 case 13723: esalt_size = sizeof (tc_t); break;
11243 case 13731: esalt_size = sizeof (tc_t); break;
11244 case 13732: esalt_size = sizeof (tc_t); break;
11245 case 13733: esalt_size = sizeof (tc_t); break;
11246 case 13741: esalt_size = sizeof (tc_t); break;
11247 case 13742: esalt_size = sizeof (tc_t); break;
11248 case 13743: esalt_size = sizeof (tc_t); break;
11249 case 13751: esalt_size = sizeof (tc_t); break;
11250 case 13752: esalt_size = sizeof (tc_t); break;
11251 case 13753: esalt_size = sizeof (tc_t); break;
11252 case 13761: esalt_size = sizeof (tc_t); break;
11253 case 13762: esalt_size = sizeof (tc_t); break;
11254 case 13763: esalt_size = sizeof (tc_t); break;
11255 case 13800: esalt_size = sizeof (win8phone_t); break;
11256 }
11257
11258 data.esalt_size = esalt_size;
11259
11260 /**
11261 * choose dictionary parser
11262 */
11263
11264 if (hash_type == HASH_TYPE_LM)
11265 {
11266 get_next_word_func = get_next_word_lm;
11267 }
11268 else if (opts_type & OPTS_TYPE_PT_UPPER)
11269 {
11270 get_next_word_func = get_next_word_uc;
11271 }
11272 else
11273 {
11274 get_next_word_func = get_next_word_std;
11275 }
11276
11277 /**
11278 * dictstat
11279 */
11280
11281 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11282
11283 #ifdef _POSIX
11284 size_t dictstat_nmemb = 0;
11285 #endif
11286
11287 #ifdef _WIN
11288 uint dictstat_nmemb = 0;
11289 #endif
11290
11291 char dictstat[256] = { 0 };
11292
11293 FILE *dictstat_fp = NULL;
11294
11295 if (keyspace == 0)
11296 {
11297 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11298
11299 dictstat_fp = fopen (dictstat, "rb");
11300
11301 if (dictstat_fp)
11302 {
11303 #ifdef _POSIX
11304 struct stat tmpstat;
11305
11306 fstat (fileno (dictstat_fp), &tmpstat);
11307 #endif
11308
11309 #ifdef _WIN
11310 struct stat64 tmpstat;
11311
11312 _fstat64 (fileno (dictstat_fp), &tmpstat);
11313 #endif
11314
11315 if (tmpstat.st_mtime < COMPTIME)
11316 {
11317 /* with v0.15 the format changed so we have to ensure user is using a good version
11318 since there is no version-header in the dictstat file */
11319
11320 fclose (dictstat_fp);
11321
11322 unlink (dictstat);
11323 }
11324 else
11325 {
11326 while (!feof (dictstat_fp))
11327 {
11328 dictstat_t d;
11329
11330 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11331
11332 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11333
11334 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11335 {
11336 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11337
11338 return -1;
11339 }
11340 }
11341
11342 fclose (dictstat_fp);
11343 }
11344 }
11345 }
11346
11347 /**
11348 * potfile
11349 */
11350
11351 char potfile[256] = { 0 };
11352
11353 if (potfile_path == NULL)
11354 {
11355 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11356 }
11357 else
11358 {
11359 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11360 }
11361
11362 data.pot_fp = NULL;
11363
11364 FILE *out_fp = NULL;
11365 FILE *pot_fp = NULL;
11366
11367 if (show == 1 || left == 1)
11368 {
11369 pot_fp = fopen (potfile, "rb");
11370
11371 if (pot_fp == NULL)
11372 {
11373 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11374
11375 return (-1);
11376 }
11377
11378 if (outfile != NULL)
11379 {
11380 if ((out_fp = fopen (outfile, "ab")) == NULL)
11381 {
11382 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11383
11384 fclose (pot_fp);
11385
11386 return (-1);
11387 }
11388 }
11389 else
11390 {
11391 out_fp = stdout;
11392 }
11393 }
11394 else
11395 {
11396 if (potfile_disable == 0)
11397 {
11398 pot_fp = fopen (potfile, "ab");
11399
11400 if (pot_fp == NULL)
11401 {
11402 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11403
11404 return (-1);
11405 }
11406
11407 data.pot_fp = pot_fp;
11408 }
11409 }
11410
11411 pot_t *pot = NULL;
11412
11413 uint pot_cnt = 0;
11414 uint pot_avail = 0;
11415
11416 if (show == 1 || left == 1)
11417 {
11418 SUPPRESS_OUTPUT = 1;
11419
11420 pot_avail = count_lines (pot_fp);
11421
11422 rewind (pot_fp);
11423
11424 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11425
11426 uint pot_hashes_avail = 0;
11427
11428 uint line_num = 0;
11429
11430 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11431
11432 while (!feof (pot_fp))
11433 {
11434 line_num++;
11435
11436 int line_len = fgetl (pot_fp, line_buf);
11437
11438 if (line_len == 0) continue;
11439
11440 char *plain_buf = line_buf + line_len;
11441
11442 pot_t *pot_ptr = &pot[pot_cnt];
11443
11444 hash_t *hashes_buf = &pot_ptr->hash;
11445
11446 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11447 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11448
11449 if (pot_cnt == pot_hashes_avail)
11450 {
11451 uint pos = 0;
11452
11453 for (pos = 0; pos < INCR_POT; pos++)
11454 {
11455 if ((pot_cnt + pos) >= pot_avail) break;
11456
11457 pot_t *tmp_pot = &pot[pot_cnt + pos];
11458
11459 hash_t *tmp_hash = &tmp_pot->hash;
11460
11461 tmp_hash->digest = mymalloc (dgst_size);
11462
11463 if (isSalted)
11464 {
11465 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11466 }
11467
11468 if (esalt_size)
11469 {
11470 tmp_hash->esalt = mymalloc (esalt_size);
11471 }
11472
11473 pot_hashes_avail++;
11474 }
11475 }
11476
11477 int plain_len = 0;
11478
11479 int parser_status;
11480
11481 int iter = MAX_CUT_TRIES;
11482
11483 do
11484 {
11485 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11486 {
11487 if (line_buf[i] == ':')
11488 {
11489 line_len--;
11490
11491 break;
11492 }
11493 }
11494
11495 if (data.hash_mode != 2500)
11496 {
11497 parser_status = parse_func (line_buf, line_len, hashes_buf);
11498 }
11499 else
11500 {
11501 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11502
11503 if (line_len > max_salt_size)
11504 {
11505 parser_status = PARSER_GLOBAL_LENGTH;
11506 }
11507 else
11508 {
11509 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11510
11511 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11512
11513 hashes_buf->salt->salt_len = line_len;
11514
11515 parser_status = PARSER_OK;
11516 }
11517 }
11518
11519 // if NOT parsed without error, we add the ":" to the plain
11520
11521 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11522 {
11523 plain_len++;
11524 plain_buf--;
11525 }
11526
11527 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11528
11529 if (parser_status < PARSER_GLOBAL_ZERO)
11530 {
11531 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11532
11533 continue;
11534 }
11535
11536 if (plain_len >= 255) continue;
11537
11538 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11539
11540 pot_ptr->plain_len = plain_len;
11541
11542 pot_cnt++;
11543 }
11544
11545 myfree (line_buf);
11546
11547 fclose (pot_fp);
11548
11549 SUPPRESS_OUTPUT = 0;
11550
11551 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11552 }
11553
11554 /**
11555 * word len
11556 */
11557
11558 uint pw_min = PW_MIN;
11559 uint pw_max = PW_MAX;
11560
11561 switch (hash_mode)
11562 {
11563 case 125: if (pw_max > 32) pw_max = 32;
11564 break;
11565 case 400: if (pw_max > 40) pw_max = 40;
11566 break;
11567 case 500: if (pw_max > 16) pw_max = 16;
11568 break;
11569 case 1500: if (pw_max > 8) pw_max = 8;
11570 break;
11571 case 1600: if (pw_max > 16) pw_max = 16;
11572 break;
11573 case 1800: if (pw_max > 16) pw_max = 16;
11574 break;
11575 case 2100: if (pw_max > 16) pw_max = 16;
11576 break;
11577 case 2500: if (pw_min < 8) pw_min = 8;
11578 break;
11579 case 3000: if (pw_max > 7) pw_max = 7;
11580 break;
11581 case 5200: if (pw_max > 24) pw_max = 24;
11582 break;
11583 case 5800: if (pw_max > 16) pw_max = 16;
11584 break;
11585 case 6300: if (pw_max > 16) pw_max = 16;
11586 break;
11587 case 7400: if (pw_max > 16) pw_max = 16;
11588 break;
11589 case 7700: if (pw_max > 8) pw_max = 8;
11590 break;
11591 case 7900: if (pw_max > 48) pw_max = 48;
11592 break;
11593 case 8500: if (pw_max > 8) pw_max = 8;
11594 break;
11595 case 8600: if (pw_max > 16) pw_max = 16;
11596 break;
11597 case 9710: pw_min = 5;
11598 pw_max = 5;
11599 break;
11600 case 9810: pw_min = 5;
11601 pw_max = 5;
11602 break;
11603 case 10410: pw_min = 5;
11604 pw_max = 5;
11605 break;
11606 case 10300: if (pw_max < 3) pw_min = 3;
11607 if (pw_max > 40) pw_max = 40;
11608 break;
11609 case 10500: if (pw_max < 3) pw_min = 3;
11610 if (pw_max > 40) pw_max = 40;
11611 break;
11612 case 10700: if (pw_max > 16) pw_max = 16;
11613 break;
11614 case 11300: if (pw_max > 40) pw_max = 40;
11615 break;
11616 case 11600: if (pw_max > 32) pw_max = 32;
11617 break;
11618 case 12500: if (pw_max > 20) pw_max = 20;
11619 break;
11620 case 12800: if (pw_max > 24) pw_max = 24;
11621 break;
11622 }
11623
11624 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11625 {
11626 switch (attack_kern)
11627 {
11628 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11629 break;
11630 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11631 break;
11632 }
11633 }
11634
11635 /**
11636 * charsets : keep them together for more easy maintainnce
11637 */
11638
11639 cs_t mp_sys[6] = { { { 0 }, 0 } };
11640 cs_t mp_usr[4] = { { { 0 }, 0 } };
11641
11642 mp_setup_sys (mp_sys);
11643
11644 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11645 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11646 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11647 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11648
11649 /**
11650 * load hashes, part I: find input mode, count hashes
11651 */
11652
11653 uint hashlist_mode = 0;
11654 uint hashlist_format = HLFMT_HASHCAT;
11655
11656 uint hashes_avail = 0;
11657
11658 if ((benchmark == 0) && (stdout_flag == 0))
11659 {
11660 struct stat f;
11661
11662 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11663
11664 if ((hash_mode == 2500) ||
11665 (hash_mode == 5200) ||
11666 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11667 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11668 (hash_mode == 9000))
11669 {
11670 hashlist_mode = HL_MODE_ARG;
11671
11672 char *hashfile = myargv[optind];
11673
11674 data.hashfile = hashfile;
11675
11676 logfile_top_var_string ("target", hashfile);
11677 }
11678
11679 if (hashlist_mode == HL_MODE_ARG)
11680 {
11681 if (hash_mode == 2500)
11682 {
11683 struct stat st;
11684
11685 if (stat (data.hashfile, &st) == -1)
11686 {
11687 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11688
11689 return (-1);
11690 }
11691
11692 hashes_avail = st.st_size / sizeof (hccap_t);
11693 }
11694 else
11695 {
11696 hashes_avail = 1;
11697 }
11698 }
11699 else if (hashlist_mode == HL_MODE_FILE)
11700 {
11701 char *hashfile = myargv[optind];
11702
11703 data.hashfile = hashfile;
11704
11705 logfile_top_var_string ("target", hashfile);
11706
11707 FILE *fp = NULL;
11708
11709 if ((fp = fopen (hashfile, "rb")) == NULL)
11710 {
11711 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11712
11713 return (-1);
11714 }
11715
11716 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11717
11718 hashes_avail = count_lines (fp);
11719
11720 rewind (fp);
11721
11722 if (hashes_avail == 0)
11723 {
11724 log_error ("ERROR: hashfile is empty or corrupt");
11725
11726 fclose (fp);
11727
11728 return (-1);
11729 }
11730
11731 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11732
11733 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11734 {
11735 log_error ("ERROR: remove not supported in native hashfile-format mode");
11736
11737 fclose (fp);
11738
11739 return (-1);
11740 }
11741
11742 fclose (fp);
11743 }
11744 }
11745 else
11746 {
11747 hashlist_mode = HL_MODE_ARG;
11748
11749 hashes_avail = 1;
11750 }
11751
11752 if (hash_mode == 3000) hashes_avail *= 2;
11753
11754 data.hashlist_mode = hashlist_mode;
11755 data.hashlist_format = hashlist_format;
11756
11757 logfile_top_uint (hashlist_mode);
11758 logfile_top_uint (hashlist_format);
11759
11760 /**
11761 * load hashes, part II: allocate required memory, set pointers
11762 */
11763
11764 hash_t *hashes_buf = NULL;
11765 void *digests_buf = NULL;
11766 salt_t *salts_buf = NULL;
11767 void *esalts_buf = NULL;
11768
11769 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11770
11771 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11772
11773 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11774 {
11775 u32 hash_pos;
11776
11777 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11778 {
11779 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11780
11781 hashes_buf[hash_pos].hash_info = hash_info;
11782
11783 if (username && (remove || show || left))
11784 {
11785 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11786 }
11787
11788 if (benchmark)
11789 {
11790 hash_info->orighash = (char *) mymalloc (256);
11791 }
11792 }
11793 }
11794
11795 if (isSalted)
11796 {
11797 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11798
11799 if (esalt_size)
11800 {
11801 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11802 }
11803 }
11804 else
11805 {
11806 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11807 }
11808
11809 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11810 {
11811 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11812
11813 if (isSalted)
11814 {
11815 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11816
11817 if (esalt_size)
11818 {
11819 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11820 }
11821 }
11822 else
11823 {
11824 hashes_buf[hash_pos].salt = &salts_buf[0];
11825 }
11826 }
11827
11828 /**
11829 * load hashes, part III: parse hashes or generate them if benchmark
11830 */
11831
11832 uint hashes_cnt = 0;
11833
11834 if (benchmark == 0)
11835 {
11836 if (keyspace == 1)
11837 {
11838 // useless to read hash file for keyspace, cheat a little bit w/ optind
11839 }
11840 else if (stdout_flag == 1)
11841 {
11842 // useless to read hash file for stdout, cheat a little bit w/ optind
11843 }
11844 else if (hashes_avail == 0)
11845 {
11846 }
11847 else if (hashlist_mode == HL_MODE_ARG)
11848 {
11849 char *input_buf = myargv[optind];
11850
11851 uint input_len = strlen (input_buf);
11852
11853 logfile_top_var_string ("target", input_buf);
11854
11855 char *hash_buf = NULL;
11856 int hash_len = 0;
11857
11858 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11859
11860 bool hash_fmt_error = 0;
11861
11862 if (hash_len < 1) hash_fmt_error = 1;
11863 if (hash_buf == NULL) hash_fmt_error = 1;
11864
11865 if (hash_fmt_error)
11866 {
11867 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11868 }
11869 else
11870 {
11871 if (opts_type & OPTS_TYPE_HASH_COPY)
11872 {
11873 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11874
11875 hash_info_tmp->orighash = mystrdup (hash_buf);
11876 }
11877
11878 if (isSalted)
11879 {
11880 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11881 }
11882
11883 int parser_status = PARSER_OK;
11884
11885 if (hash_mode == 2500)
11886 {
11887 if (hash_len == 0)
11888 {
11889 log_error ("ERROR: hccap file not specified");
11890
11891 return (-1);
11892 }
11893
11894 hashlist_mode = HL_MODE_FILE;
11895
11896 data.hashlist_mode = hashlist_mode;
11897
11898 FILE *fp = fopen (hash_buf, "rb");
11899
11900 if (fp == NULL)
11901 {
11902 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11903
11904 return (-1);
11905 }
11906
11907 if (hashes_avail < 1)
11908 {
11909 log_error ("ERROR: hccap file is empty or corrupt");
11910
11911 fclose (fp);
11912
11913 return (-1);
11914 }
11915
11916 uint hccap_size = sizeof (hccap_t);
11917
11918 char *in = (char *) mymalloc (hccap_size);
11919
11920 while (!feof (fp))
11921 {
11922 int n = fread (in, hccap_size, 1, fp);
11923
11924 if (n != 1)
11925 {
11926 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11927
11928 break;
11929 }
11930
11931 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11932
11933 if (parser_status != PARSER_OK)
11934 {
11935 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11936
11937 continue;
11938 }
11939
11940 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11941
11942 if ((show == 1) || (left == 1))
11943 {
11944 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11945
11946 char *salt_ptr = (char *) tmp_salt->salt_buf;
11947
11948 int cur_pos = tmp_salt->salt_len;
11949 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11950
11951 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11952
11953 // do the appending task
11954
11955 snprintf (salt_ptr + cur_pos,
11956 rem_len,
11957 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11958 wpa->orig_mac1[0],
11959 wpa->orig_mac1[1],
11960 wpa->orig_mac1[2],
11961 wpa->orig_mac1[3],
11962 wpa->orig_mac1[4],
11963 wpa->orig_mac1[5],
11964 wpa->orig_mac2[0],
11965 wpa->orig_mac2[1],
11966 wpa->orig_mac2[2],
11967 wpa->orig_mac2[3],
11968 wpa->orig_mac2[4],
11969 wpa->orig_mac2[5]);
11970
11971 // memset () the remaining part of the salt
11972
11973 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11974 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11975
11976 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11977
11978 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11979 }
11980
11981 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);
11982 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);
11983
11984 hashes_cnt++;
11985 }
11986
11987 fclose (fp);
11988
11989 myfree (in);
11990 }
11991 else if (hash_mode == 3000)
11992 {
11993 if (hash_len == 32)
11994 {
11995 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11996
11997 hash_t *lm_hash_left = NULL;
11998
11999 if (parser_status == PARSER_OK)
12000 {
12001 lm_hash_left = &hashes_buf[hashes_cnt];
12002
12003 hashes_cnt++;
12004 }
12005 else
12006 {
12007 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12008 }
12009
12010 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12011
12012 hash_t *lm_hash_right = NULL;
12013
12014 if (parser_status == PARSER_OK)
12015 {
12016 lm_hash_right = &hashes_buf[hashes_cnt];
12017
12018 hashes_cnt++;
12019 }
12020 else
12021 {
12022 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12023 }
12024
12025 // show / left
12026
12027 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12028 {
12029 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);
12030 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);
12031 }
12032 }
12033 else
12034 {
12035 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12036
12037 if (parser_status == PARSER_OK)
12038 {
12039 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12040 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12041 }
12042
12043 if (parser_status == PARSER_OK)
12044 {
12045 hashes_cnt++;
12046 }
12047 else
12048 {
12049 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12050 }
12051 }
12052 }
12053 else
12054 {
12055 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12056
12057 if (parser_status == PARSER_OK)
12058 {
12059 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12060 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12061 }
12062
12063 if (parser_status == PARSER_OK)
12064 {
12065 hashes_cnt++;
12066 }
12067 else
12068 {
12069 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12070 }
12071 }
12072 }
12073 }
12074 else if (hashlist_mode == HL_MODE_FILE)
12075 {
12076 char *hashfile = data.hashfile;
12077
12078 FILE *fp;
12079
12080 if ((fp = fopen (hashfile, "rb")) == NULL)
12081 {
12082 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12083
12084 return (-1);
12085 }
12086
12087 uint line_num = 0;
12088
12089 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12090
12091 while (!feof (fp))
12092 {
12093 line_num++;
12094
12095 int line_len = fgetl (fp, line_buf);
12096
12097 if (line_len == 0) continue;
12098
12099 char *hash_buf = NULL;
12100 int hash_len = 0;
12101
12102 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12103
12104 bool hash_fmt_error = 0;
12105
12106 if (hash_len < 1) hash_fmt_error = 1;
12107 if (hash_buf == NULL) hash_fmt_error = 1;
12108
12109 if (hash_fmt_error)
12110 {
12111 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12112
12113 continue;
12114 }
12115
12116 if (username)
12117 {
12118 char *user_buf = NULL;
12119 int user_len = 0;
12120
12121 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12122
12123 if (remove || show)
12124 {
12125 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12126
12127 *user = (user_t *) mymalloc (sizeof (user_t));
12128
12129 user_t *user_ptr = *user;
12130
12131 if (user_buf != NULL)
12132 {
12133 user_ptr->user_name = mystrdup (user_buf);
12134 }
12135 else
12136 {
12137 user_ptr->user_name = mystrdup ("");
12138 }
12139
12140 user_ptr->user_len = user_len;
12141 }
12142 }
12143
12144 if (opts_type & OPTS_TYPE_HASH_COPY)
12145 {
12146 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12147
12148 hash_info_tmp->orighash = mystrdup (hash_buf);
12149 }
12150
12151 if (isSalted)
12152 {
12153 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12154 }
12155
12156 if (hash_mode == 3000)
12157 {
12158 if (hash_len == 32)
12159 {
12160 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12161
12162 if (parser_status < PARSER_GLOBAL_ZERO)
12163 {
12164 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12165
12166 continue;
12167 }
12168
12169 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12170
12171 hashes_cnt++;
12172
12173 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12174
12175 if (parser_status < PARSER_GLOBAL_ZERO)
12176 {
12177 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12178
12179 continue;
12180 }
12181
12182 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12183
12184 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);
12185
12186 hashes_cnt++;
12187
12188 // show / left
12189
12190 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);
12191 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);
12192 }
12193 else
12194 {
12195 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12196
12197 if (parser_status < PARSER_GLOBAL_ZERO)
12198 {
12199 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12200
12201 continue;
12202 }
12203
12204 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);
12205
12206 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12207 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12208
12209 hashes_cnt++;
12210 }
12211 }
12212 else
12213 {
12214 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12215
12216 if (parser_status < PARSER_GLOBAL_ZERO)
12217 {
12218 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12219
12220 continue;
12221 }
12222
12223 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);
12224
12225 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12226 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12227
12228 hashes_cnt++;
12229 }
12230 }
12231
12232 myfree (line_buf);
12233
12234 fclose (fp);
12235
12236 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12237
12238 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12239 }
12240 }
12241 else
12242 {
12243 if (isSalted)
12244 {
12245 hashes_buf[0].salt->salt_len = 8;
12246
12247 // special salt handling
12248
12249 switch (hash_mode)
12250 {
12251 case 1500: hashes_buf[0].salt->salt_len = 2;
12252 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12253 break;
12254 case 1731: hashes_buf[0].salt->salt_len = 4;
12255 break;
12256 case 2410: hashes_buf[0].salt->salt_len = 4;
12257 break;
12258 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12259 break;
12260 case 3100: hashes_buf[0].salt->salt_len = 1;
12261 break;
12262 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
12263 break;
12264 case 5800: hashes_buf[0].salt->salt_len = 16;
12265 break;
12266 case 6800: hashes_buf[0].salt->salt_len = 32;
12267 break;
12268 case 8400: hashes_buf[0].salt->salt_len = 40;
12269 break;
12270 case 8800: hashes_buf[0].salt->salt_len = 16;
12271 break;
12272 case 8900: hashes_buf[0].salt->salt_len = 16;
12273 hashes_buf[0].salt->scrypt_N = 1024;
12274 hashes_buf[0].salt->scrypt_r = 1;
12275 hashes_buf[0].salt->scrypt_p = 1;
12276 break;
12277 case 9100: hashes_buf[0].salt->salt_len = 16;
12278 break;
12279 case 9300: hashes_buf[0].salt->salt_len = 14;
12280 hashes_buf[0].salt->scrypt_N = 16384;
12281 hashes_buf[0].salt->scrypt_r = 1;
12282 hashes_buf[0].salt->scrypt_p = 1;
12283 break;
12284 case 9400: hashes_buf[0].salt->salt_len = 16;
12285 break;
12286 case 9500: hashes_buf[0].salt->salt_len = 16;
12287 break;
12288 case 9600: hashes_buf[0].salt->salt_len = 16;
12289 break;
12290 case 9700: hashes_buf[0].salt->salt_len = 16;
12291 break;
12292 case 9710: hashes_buf[0].salt->salt_len = 16;
12293 break;
12294 case 9720: hashes_buf[0].salt->salt_len = 16;
12295 break;
12296 case 9800: hashes_buf[0].salt->salt_len = 16;
12297 break;
12298 case 9810: hashes_buf[0].salt->salt_len = 16;
12299 break;
12300 case 9820: hashes_buf[0].salt->salt_len = 16;
12301 break;
12302 case 10300: hashes_buf[0].salt->salt_len = 12;
12303 break;
12304 case 11500: hashes_buf[0].salt->salt_len = 4;
12305 break;
12306 case 11600: hashes_buf[0].salt->salt_len = 4;
12307 break;
12308 case 12400: hashes_buf[0].salt->salt_len = 4;
12309 break;
12310 case 12500: hashes_buf[0].salt->salt_len = 8;
12311 break;
12312 case 12600: hashes_buf[0].salt->salt_len = 64;
12313 break;
12314 }
12315
12316 // special esalt handling
12317
12318 switch (hash_mode)
12319 {
12320 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12321 break;
12322 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12323 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12324 break;
12325 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12326 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12327 break;
12328 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12329 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12330 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12331 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12332 break;
12333 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12334 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12335 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12336 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12337 break;
12338 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12339 break;
12340 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12341 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12342 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12343 break;
12344 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12345 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12346 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12347 break;
12348 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12349 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12350 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12351 break;
12352 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12353 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12354 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12355 break;
12356 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12357 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12358 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12359 break;
12360 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12361 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12362 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12363 break;
12364 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12365 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12366 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12367 break;
12368 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12369 break;
12370 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12371 break;
12372 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12373 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12374 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12375 break;
12376 }
12377 }
12378
12379 // set hashfile
12380
12381 switch (hash_mode)
12382 {
12383 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12384 break;
12385 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12386 break;
12387 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12388 break;
12389 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12390 break;
12391 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12392 break;
12393 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12394 break;
12395 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12396 break;
12397 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12398 break;
12399 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12400 break;
12401 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12402 break;
12403 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12404 break;
12405 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12406 break;
12407 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12408 break;
12409 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12410 break;
12411 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12412 break;
12413 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12414 break;
12415 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12416 break;
12417 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12418 break;
12419 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12420 break;
12421 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12422 break;
12423 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12424 break;
12425 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12426 break;
12427 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12428 break;
12429 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12430 break;
12431 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12432 break;
12433 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12434 break;
12435 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12436 break;
12437 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12438 break;
12439 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12440 break;
12441 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12442 break;
12443 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12444 break;
12445 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12446 break;
12447 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12448 break;
12449 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12450 break;
12451 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12452 break;
12453 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12454 break;
12455 }
12456
12457 // set default iterations
12458
12459 switch (hash_mode)
12460 {
12461 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12462 break;
12463 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12464 break;
12465 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12466 break;
12467 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12468 break;
12469 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12470 break;
12471 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12472 break;
12473 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12474 break;
12475 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12476 break;
12477 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12478 break;
12479 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12480 break;
12481 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12482 break;
12483 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12484 break;
12485 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12486 break;
12487 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12488 break;
12489 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12490 break;
12491 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12492 break;
12493 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12494 break;
12495 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12496 break;
12497 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12498 break;
12499 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12500 break;
12501 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12502 break;
12503 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12504 break;
12505 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12506 break;
12507 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12508 break;
12509 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12510 break;
12511 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12512 break;
12513 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12514 break;
12515 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12516 break;
12517 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12518 break;
12519 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12520 break;
12521 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12522 break;
12523 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12524 break;
12525 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12526 break;
12527 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12528 break;
12529 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12530 break;
12531 case 8900: hashes_buf[0].salt->salt_iter = 1;
12532 break;
12533 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12534 break;
12535 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12536 break;
12537 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12538 break;
12539 case 9300: hashes_buf[0].salt->salt_iter = 1;
12540 break;
12541 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12542 break;
12543 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12544 break;
12545 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12546 break;
12547 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12548 break;
12549 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12550 break;
12551 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12552 break;
12553 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12554 break;
12555 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12556 break;
12557 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12558 break;
12559 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12560 break;
12561 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12562 break;
12563 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12564 break;
12565 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12566 break;
12567 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12568 break;
12569 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12570 break;
12571 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12572 break;
12573 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12574 break;
12575 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12576 break;
12577 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12578 break;
12579 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12580 break;
12581 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12582 break;
12583 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12584 break;
12585 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12586 break;
12587 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12588 break;
12589 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12590 break;
12591 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12592 break;
12593 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12594 break;
12595 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12596 break;
12597 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12598 break;
12599 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12600 break;
12601 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12602 break;
12603 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12604 break;
12605 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12606 break;
12607 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12608 break;
12609 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12610 break;
12611 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12612 break;
12613 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12614 break;
12615 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12616 break;
12617 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12618 break;
12619 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12620 break;
12621 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12622 break;
12623 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12624 break;
12625 }
12626
12627 hashes_cnt = 1;
12628 }
12629
12630 if (show == 1 || left == 1)
12631 {
12632 for (uint i = 0; i < pot_cnt; i++)
12633 {
12634 pot_t *pot_ptr = &pot[i];
12635
12636 hash_t *hashes_buf = &pot_ptr->hash;
12637
12638 local_free (hashes_buf->digest);
12639
12640 if (isSalted)
12641 {
12642 local_free (hashes_buf->salt);
12643 }
12644 }
12645
12646 local_free (pot);
12647
12648 if (data.quiet == 0) log_info_nn ("");
12649
12650 return (0);
12651 }
12652
12653 if ((keyspace == 0) && (stdout_flag == 0))
12654 {
12655 if (hashes_cnt == 0)
12656 {
12657 log_error ("ERROR: No hashes loaded");
12658
12659 return (-1);
12660 }
12661 }
12662
12663 /**
12664 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12665 */
12666
12667 if (data.outfile != NULL)
12668 {
12669 if (data.hashfile != NULL)
12670 {
12671 #ifdef _POSIX
12672 struct stat tmpstat_outfile;
12673 struct stat tmpstat_hashfile;
12674 #endif
12675
12676 #ifdef _WIN
12677 struct stat64 tmpstat_outfile;
12678 struct stat64 tmpstat_hashfile;
12679 #endif
12680
12681 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12682
12683 if (tmp_outfile_fp)
12684 {
12685 #ifdef _POSIX
12686 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12687 #endif
12688
12689 #ifdef _WIN
12690 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12691 #endif
12692
12693 fclose (tmp_outfile_fp);
12694 }
12695
12696 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12697
12698 if (tmp_hashfile_fp)
12699 {
12700 #ifdef _POSIX
12701 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12702 #endif
12703
12704 #ifdef _WIN
12705 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12706 #endif
12707
12708 fclose (tmp_hashfile_fp);
12709 }
12710
12711 if (tmp_outfile_fp && tmp_outfile_fp)
12712 {
12713 tmpstat_outfile.st_mode = 0;
12714 tmpstat_outfile.st_nlink = 0;
12715 tmpstat_outfile.st_uid = 0;
12716 tmpstat_outfile.st_gid = 0;
12717 tmpstat_outfile.st_rdev = 0;
12718 tmpstat_outfile.st_atime = 0;
12719
12720 tmpstat_hashfile.st_mode = 0;
12721 tmpstat_hashfile.st_nlink = 0;
12722 tmpstat_hashfile.st_uid = 0;
12723 tmpstat_hashfile.st_gid = 0;
12724 tmpstat_hashfile.st_rdev = 0;
12725 tmpstat_hashfile.st_atime = 0;
12726
12727 #ifdef _POSIX
12728 tmpstat_outfile.st_blksize = 0;
12729 tmpstat_outfile.st_blocks = 0;
12730
12731 tmpstat_hashfile.st_blksize = 0;
12732 tmpstat_hashfile.st_blocks = 0;
12733 #endif
12734
12735 #ifdef _POSIX
12736 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12737 {
12738 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12739
12740 return (-1);
12741 }
12742 #endif
12743
12744 #ifdef _WIN
12745 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12746 {
12747 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12748
12749 return (-1);
12750 }
12751 #endif
12752 }
12753 }
12754 }
12755
12756 /**
12757 * Remove duplicates
12758 */
12759
12760 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12761
12762 if (isSalted)
12763 {
12764 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12765 }
12766 else
12767 {
12768 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12769 }
12770
12771 uint hashes_cnt_orig = hashes_cnt;
12772
12773 hashes_cnt = 1;
12774
12775 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12776 {
12777 if (isSalted)
12778 {
12779 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12780 {
12781 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12782 }
12783 }
12784 else
12785 {
12786 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12787 }
12788
12789 if (hashes_pos > hashes_cnt)
12790 {
12791 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12792 }
12793
12794 hashes_cnt++;
12795 }
12796
12797 /**
12798 * Potfile removes
12799 */
12800
12801 uint potfile_remove_cracks = 0;
12802
12803 if (potfile_disable == 0)
12804 {
12805 hash_t hash_buf;
12806
12807 hash_buf.digest = mymalloc (dgst_size);
12808 hash_buf.salt = NULL;
12809 hash_buf.esalt = NULL;
12810 hash_buf.hash_info = NULL;
12811 hash_buf.cracked = 0;
12812
12813 if (isSalted)
12814 {
12815 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12816 }
12817
12818 if (esalt_size)
12819 {
12820 hash_buf.esalt = mymalloc (esalt_size);
12821 }
12822
12823 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12824
12825 // no solution for these special hash types (for instane because they use hashfile in output etc)
12826 if ((hash_mode != 5200) &&
12827 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12828 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12829 (hash_mode != 9000))
12830 {
12831 FILE *fp = fopen (potfile, "rb");
12832
12833 if (fp != NULL)
12834 {
12835 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12836
12837 // to be safe work with a copy (because of line_len loop, i etc)
12838 // moved up here because it's easier to handle continue case
12839 // it's just 64kb
12840
12841 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12842
12843 while (!feof (fp))
12844 {
12845 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12846
12847 if (ptr == NULL) break;
12848
12849 int line_len = strlen (line_buf);
12850
12851 if (line_len == 0) continue;
12852
12853 int iter = MAX_CUT_TRIES;
12854
12855 for (int i = line_len - 1; i && iter; i--, line_len--)
12856 {
12857 if (line_buf[i] != ':') continue;
12858
12859 if (isSalted)
12860 {
12861 memset (hash_buf.salt, 0, sizeof (salt_t));
12862 }
12863
12864 hash_t *found = NULL;
12865
12866 if (hash_mode == 6800)
12867 {
12868 if (i < 64) // 64 = 16 * uint in salt_buf[]
12869 {
12870 // manipulate salt_buf
12871 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12872
12873 hash_buf.salt->salt_len = i;
12874
12875 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12876 }
12877 }
12878 else if (hash_mode == 2500)
12879 {
12880 if (i < 64) // 64 = 16 * uint in salt_buf[]
12881 {
12882 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12883 // manipulate salt_buf
12884
12885 memcpy (line_buf_cpy, line_buf, i);
12886
12887 char *mac2_pos = strrchr (line_buf_cpy, ':');
12888
12889 if (mac2_pos == NULL) continue;
12890
12891 mac2_pos[0] = 0;
12892 mac2_pos++;
12893
12894 if (strlen (mac2_pos) != 12) continue;
12895
12896 char *mac1_pos = strrchr (line_buf_cpy, ':');
12897
12898 if (mac1_pos == NULL) continue;
12899
12900 mac1_pos[0] = 0;
12901 mac1_pos++;
12902
12903 if (strlen (mac1_pos) != 12) continue;
12904
12905 uint essid_length = mac1_pos - line_buf_cpy - 1;
12906
12907 // here we need the ESSID
12908 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12909
12910 hash_buf.salt->salt_len = essid_length;
12911
12912 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12913
12914 if (found)
12915 {
12916 wpa_t *wpa = (wpa_t *) found->esalt;
12917
12918 // compare hex string(s) vs binary MAC address(es)
12919
12920 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12921 {
12922 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12923 {
12924 found = NULL;
12925
12926 break;
12927 }
12928 }
12929
12930 // early skip ;)
12931 if (!found) continue;
12932
12933 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12934 {
12935 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12936 {
12937 found = NULL;
12938
12939 break;
12940 }
12941 }
12942 }
12943 }
12944 }
12945 else
12946 {
12947 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12948
12949 if (parser_status == PARSER_OK)
12950 {
12951 if (isSalted)
12952 {
12953 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12954 }
12955 else
12956 {
12957 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12958 }
12959 }
12960 }
12961
12962 if (found == NULL) continue;
12963
12964 if (!found->cracked) potfile_remove_cracks++;
12965
12966 found->cracked = 1;
12967
12968 if (found) break;
12969
12970 iter--;
12971 }
12972 }
12973
12974 myfree (line_buf_cpy);
12975
12976 myfree (line_buf);
12977
12978 fclose (fp);
12979 }
12980 }
12981
12982 if (esalt_size)
12983 {
12984 local_free (hash_buf.esalt);
12985 }
12986
12987 if (isSalted)
12988 {
12989 local_free (hash_buf.salt);
12990 }
12991
12992 local_free (hash_buf.digest);
12993 }
12994
12995 /**
12996 * Now generate all the buffers required for later
12997 */
12998
12999 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
13000
13001 salt_t *salts_buf_new = NULL;
13002 void *esalts_buf_new = NULL;
13003
13004 if (isSalted)
13005 {
13006 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
13007
13008 if (esalt_size)
13009 {
13010 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
13011 }
13012 }
13013 else
13014 {
13015 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13016 }
13017
13018 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13019
13020 uint digests_cnt = hashes_cnt;
13021 uint digests_done = 0;
13022
13023 size_t size_digests = digests_cnt * dgst_size;
13024 size_t size_shown = digests_cnt * sizeof (uint);
13025
13026 uint *digests_shown = (uint *) mymalloc (size_shown);
13027 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13028
13029 uint salts_cnt = 0;
13030 uint salts_done = 0;
13031
13032 hashinfo_t **hash_info = NULL;
13033
13034 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13035 {
13036 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13037
13038 if (username && (remove || show))
13039 {
13040 uint user_pos;
13041
13042 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13043 {
13044 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13045
13046 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13047 }
13048 }
13049 }
13050
13051 uint *salts_shown = (uint *) mymalloc (size_shown);
13052
13053 salt_t *salt_buf;
13054
13055 {
13056 // copied from inner loop
13057
13058 salt_buf = &salts_buf_new[salts_cnt];
13059
13060 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13061
13062 if (esalt_size)
13063 {
13064 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13065 }
13066
13067 salt_buf->digests_cnt = 0;
13068 salt_buf->digests_done = 0;
13069 salt_buf->digests_offset = 0;
13070
13071 salts_cnt++;
13072 }
13073
13074 if (hashes_buf[0].cracked == 1)
13075 {
13076 digests_shown[0] = 1;
13077
13078 digests_done++;
13079
13080 salt_buf->digests_done++;
13081 }
13082
13083 salt_buf->digests_cnt++;
13084
13085 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13086
13087 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13088 {
13089 hash_info[0] = hashes_buf[0].hash_info;
13090 }
13091
13092 // copy from inner loop
13093
13094 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13095 {
13096 if (isSalted)
13097 {
13098 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13099 {
13100 salt_buf = &salts_buf_new[salts_cnt];
13101
13102 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13103
13104 if (esalt_size)
13105 {
13106 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13107 }
13108
13109 salt_buf->digests_cnt = 0;
13110 salt_buf->digests_done = 0;
13111 salt_buf->digests_offset = hashes_pos;
13112
13113 salts_cnt++;
13114 }
13115 }
13116
13117 if (hashes_buf[hashes_pos].cracked == 1)
13118 {
13119 digests_shown[hashes_pos] = 1;
13120
13121 digests_done++;
13122
13123 salt_buf->digests_done++;
13124 }
13125
13126 salt_buf->digests_cnt++;
13127
13128 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13129
13130 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13131 {
13132 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13133 }
13134 }
13135
13136 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13137 {
13138 salt_t *salt_buf = &salts_buf_new[salt_pos];
13139
13140 if (salt_buf->digests_done == salt_buf->digests_cnt)
13141 {
13142 salts_shown[salt_pos] = 1;
13143
13144 salts_done++;
13145 }
13146
13147 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13148 }
13149
13150 local_free (digests_buf);
13151 local_free (salts_buf);
13152 local_free (esalts_buf);
13153
13154 digests_buf = digests_buf_new;
13155 salts_buf = salts_buf_new;
13156 esalts_buf = esalts_buf_new;
13157
13158 local_free (hashes_buf);
13159
13160 /**
13161 * special modification not set from parser
13162 */
13163
13164 switch (hash_mode)
13165 {
13166 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13167 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13168 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13169 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13170 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13171 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13172 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13173 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13174 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13175 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13176 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13177 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13178 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13179 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13180 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13181 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13182 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13183 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13184 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13185 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13186 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13187 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13188 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13189 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13190 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13191 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13192 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13193 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13194 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13195 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13196 }
13197
13198 if (truecrypt_keyfiles)
13199 {
13200 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13201
13202 char *keyfiles = strdup (truecrypt_keyfiles);
13203
13204 char *keyfile = strtok (keyfiles, ",");
13205
13206 do
13207 {
13208 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13209
13210 } while ((keyfile = strtok (NULL, ",")) != NULL);
13211
13212 free (keyfiles);
13213 }
13214
13215 if (veracrypt_keyfiles)
13216 {
13217 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13218
13219 char *keyfiles = strdup (veracrypt_keyfiles);
13220
13221 char *keyfile = strtok (keyfiles, ",");
13222
13223 do
13224 {
13225 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13226
13227 } while ((keyfile = strtok (NULL, ",")) != NULL);
13228
13229 free (keyfiles);
13230 }
13231
13232 data.digests_cnt = digests_cnt;
13233 data.digests_done = digests_done;
13234 data.digests_buf = digests_buf;
13235 data.digests_shown = digests_shown;
13236 data.digests_shown_tmp = digests_shown_tmp;
13237
13238 data.salts_cnt = salts_cnt;
13239 data.salts_done = salts_done;
13240 data.salts_buf = salts_buf;
13241 data.salts_shown = salts_shown;
13242
13243 data.esalts_buf = esalts_buf;
13244 data.hash_info = hash_info;
13245
13246 /**
13247 * Automatic Optimizers
13248 */
13249
13250 if (salts_cnt == 1)
13251 opti_type |= OPTI_TYPE_SINGLE_SALT;
13252
13253 if (digests_cnt == 1)
13254 opti_type |= OPTI_TYPE_SINGLE_HASH;
13255
13256 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13257 opti_type |= OPTI_TYPE_NOT_ITERATED;
13258
13259 if (attack_mode == ATTACK_MODE_BF)
13260 opti_type |= OPTI_TYPE_BRUTE_FORCE;
13261
13262 data.opti_type = opti_type;
13263
13264 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13265 {
13266 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13267 {
13268 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13269 {
13270 if (opts_type & OPTS_TYPE_ST_ADD80)
13271 {
13272 opts_type &= ~OPTS_TYPE_ST_ADD80;
13273 opts_type |= OPTS_TYPE_PT_ADD80;
13274 }
13275
13276 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13277 {
13278 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13279 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13280 }
13281
13282 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13283 {
13284 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13285 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13286 }
13287 }
13288 }
13289 }
13290
13291 /**
13292 * Some algorithm, like descrypt, can benefit from JIT compilation
13293 */
13294
13295 int force_jit_compilation = -1;
13296
13297 if (hash_mode == 8900)
13298 {
13299 force_jit_compilation = 8900;
13300 }
13301 else if (hash_mode == 9300)
13302 {
13303 force_jit_compilation = 8900;
13304 }
13305 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13306 {
13307 force_jit_compilation = 1500;
13308 }
13309
13310 /**
13311 * generate bitmap tables
13312 */
13313
13314 const uint bitmap_shift1 = 5;
13315 const uint bitmap_shift2 = 13;
13316
13317 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13318
13319 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13320 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13321 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13322 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13323 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13324 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13325 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13326 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13327
13328 uint bitmap_bits;
13329 uint bitmap_nums;
13330 uint bitmap_mask;
13331 uint bitmap_size;
13332
13333 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13334 {
13335 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13336
13337 bitmap_nums = 1 << bitmap_bits;
13338
13339 bitmap_mask = bitmap_nums - 1;
13340
13341 bitmap_size = bitmap_nums * sizeof (uint);
13342
13343 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13344
13345 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;
13346 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;
13347
13348 break;
13349 }
13350
13351 bitmap_nums = 1 << bitmap_bits;
13352
13353 bitmap_mask = bitmap_nums - 1;
13354
13355 bitmap_size = bitmap_nums * sizeof (uint);
13356
13357 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);
13358 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);
13359
13360 /**
13361 * prepare quick rule
13362 */
13363
13364 data.rule_buf_l = rule_buf_l;
13365 data.rule_buf_r = rule_buf_r;
13366
13367 int rule_len_l = (int) strlen (rule_buf_l);
13368 int rule_len_r = (int) strlen (rule_buf_r);
13369
13370 data.rule_len_l = rule_len_l;
13371 data.rule_len_r = rule_len_r;
13372
13373 /**
13374 * load rules
13375 */
13376
13377 uint *all_kernel_rules_cnt = NULL;
13378
13379 kernel_rule_t **all_kernel_rules_buf = NULL;
13380
13381 if (rp_files_cnt)
13382 {
13383 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13384
13385 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13386 }
13387
13388 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13389
13390 int rule_len = 0;
13391
13392 for (uint i = 0; i < rp_files_cnt; i++)
13393 {
13394 uint kernel_rules_avail = 0;
13395
13396 uint kernel_rules_cnt = 0;
13397
13398 kernel_rule_t *kernel_rules_buf = NULL;
13399
13400 char *rp_file = rp_files[i];
13401
13402 char in[BLOCK_SIZE] = { 0 };
13403 char out[BLOCK_SIZE] = { 0 };
13404
13405 FILE *fp = NULL;
13406
13407 uint rule_line = 0;
13408
13409 if ((fp = fopen (rp_file, "rb")) == NULL)
13410 {
13411 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13412
13413 return (-1);
13414 }
13415
13416 while (!feof (fp))
13417 {
13418 memset (rule_buf, 0, HCBUFSIZ);
13419
13420 rule_len = fgetl (fp, rule_buf);
13421
13422 rule_line++;
13423
13424 if (rule_len == 0) continue;
13425
13426 if (rule_buf[0] == '#') continue;
13427
13428 if (kernel_rules_avail == kernel_rules_cnt)
13429 {
13430 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13431
13432 kernel_rules_avail += INCR_RULES;
13433 }
13434
13435 memset (in, 0, BLOCK_SIZE);
13436 memset (out, 0, BLOCK_SIZE);
13437
13438 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13439
13440 if (result == -1)
13441 {
13442 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13443
13444 continue;
13445 }
13446
13447 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13448 {
13449 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13450
13451 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13452
13453 continue;
13454 }
13455
13456 /* its so slow
13457 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13458 {
13459 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13460
13461 continue;
13462 }
13463 */
13464
13465 kernel_rules_cnt++;
13466 }
13467
13468 fclose (fp);
13469
13470 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13471
13472 all_kernel_rules_buf[i] = kernel_rules_buf;
13473 }
13474
13475 /**
13476 * merge rules or automatic rule generator
13477 */
13478
13479 uint kernel_rules_cnt = 0;
13480
13481 kernel_rule_t *kernel_rules_buf = NULL;
13482
13483 if (attack_mode == ATTACK_MODE_STRAIGHT)
13484 {
13485 if (rp_files_cnt)
13486 {
13487 kernel_rules_cnt = 1;
13488
13489 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13490
13491 repeats[0] = kernel_rules_cnt;
13492
13493 for (uint i = 0; i < rp_files_cnt; i++)
13494 {
13495 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13496
13497 repeats[i + 1] = kernel_rules_cnt;
13498 }
13499
13500 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13501
13502 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13503
13504 for (uint i = 0; i < kernel_rules_cnt; i++)
13505 {
13506 uint out_pos = 0;
13507
13508 kernel_rule_t *out = &kernel_rules_buf[i];
13509
13510 for (uint j = 0; j < rp_files_cnt; j++)
13511 {
13512 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13513 uint in_pos;
13514
13515 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13516
13517 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13518 {
13519 if (out_pos == RULES_MAX - 1)
13520 {
13521 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13522
13523 break;
13524 }
13525
13526 out->cmds[out_pos] = in->cmds[in_pos];
13527 }
13528 }
13529 }
13530
13531 local_free (repeats);
13532 }
13533 else if (rp_gen)
13534 {
13535 uint kernel_rules_avail = 0;
13536
13537 while (kernel_rules_cnt < rp_gen)
13538 {
13539 if (kernel_rules_avail == kernel_rules_cnt)
13540 {
13541 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13542
13543 kernel_rules_avail += INCR_RULES;
13544 }
13545
13546 memset (rule_buf, 0, HCBUFSIZ);
13547
13548 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13549
13550 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13551
13552 kernel_rules_cnt++;
13553 }
13554 }
13555 }
13556
13557 myfree (rule_buf);
13558
13559 /**
13560 * generate NOP rules
13561 */
13562
13563 if (kernel_rules_cnt == 0)
13564 {
13565 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13566
13567 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13568
13569 kernel_rules_cnt++;
13570 }
13571
13572 data.kernel_rules_cnt = kernel_rules_cnt;
13573 data.kernel_rules_buf = kernel_rules_buf;
13574
13575 /**
13576 * OpenCL platforms: detect
13577 */
13578
13579 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13580 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13581
13582 cl_uint platforms_cnt = 0;
13583 cl_uint platform_devices_cnt = 0;
13584
13585 if (keyspace == 0)
13586 {
13587 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13588
13589 if (platforms_cnt == 0)
13590 {
13591 log_info ("");
13592 log_info ("ATTENTION! No OpenCL compatible platform found");
13593 log_info ("");
13594 log_info ("You're probably missing the OpenCL runtime installation");
13595 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13596 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13597 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13598 log_info ("");
13599
13600 return (-1);
13601 }
13602
13603 if (opencl_platforms_filter != (uint) -1)
13604 {
13605 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13606
13607 if (opencl_platforms_filter > platform_cnt_mask)
13608 {
13609 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13610
13611 return (-1);
13612 }
13613 }
13614 }
13615
13616 /**
13617 * OpenCL device types:
13618 * 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.
13619 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13620 */
13621
13622 if (opencl_device_types == NULL)
13623 {
13624 cl_device_type device_types_all = 0;
13625
13626 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13627 {
13628 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13629
13630 cl_platform_id platform = platforms[platform_id];
13631
13632 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13633
13634 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13635 {
13636 cl_device_id device = platform_devices[platform_devices_id];
13637
13638 cl_device_type device_type;
13639
13640 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13641
13642 device_types_all |= device_type;
13643 }
13644 }
13645
13646 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13647 {
13648 device_types_filter |= CL_DEVICE_TYPE_CPU;
13649 }
13650 }
13651
13652 /**
13653 * OpenCL devices: simply push all devices from all platforms into the same device array
13654 */
13655
13656 int need_adl = 0;
13657 int need_nvapi = 0;
13658 int need_nvml = 0;
13659 int need_xnvctrl = 0;
13660
13661 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13662
13663 data.devices_param = devices_param;
13664
13665 uint devices_cnt = 0;
13666
13667 uint devices_active = 0;
13668
13669 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13670 {
13671 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13672
13673 cl_platform_id platform = platforms[platform_id];
13674
13675 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13676
13677 char platform_vendor[INFOSZ] = { 0 };
13678
13679 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13680
13681 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13682 // this causes trouble with vendor id based macros
13683 // we'll assign generic to those without special optimization available
13684
13685 cl_uint platform_vendor_id = 0;
13686
13687 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13688 {
13689 platform_vendor_id = VENDOR_ID_AMD;
13690 }
13691 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13692 {
13693 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13694 }
13695 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13696 {
13697 platform_vendor_id = VENDOR_ID_APPLE;
13698 }
13699 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13700 {
13701 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13702 }
13703 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13704 {
13705 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13706 }
13707 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13708 {
13709 platform_vendor_id = VENDOR_ID_MESA;
13710 }
13711 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13712 {
13713 platform_vendor_id = VENDOR_ID_NV;
13714 }
13715 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13716 {
13717 platform_vendor_id = VENDOR_ID_POCL;
13718 }
13719 else
13720 {
13721 platform_vendor_id = VENDOR_ID_GENERIC;
13722 }
13723
13724 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13725 {
13726 size_t param_value_size = 0;
13727
13728 const uint device_id = devices_cnt;
13729
13730 hc_device_param_t *device_param = &data.devices_param[device_id];
13731
13732 device_param->platform_vendor_id = platform_vendor_id;
13733
13734 device_param->device = platform_devices[platform_devices_id];
13735
13736 device_param->device_id = device_id;
13737
13738 device_param->platform_devices_id = platform_devices_id;
13739
13740 // device_type
13741
13742 cl_device_type device_type;
13743
13744 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13745
13746 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13747
13748 device_param->device_type = device_type;
13749
13750 // device_name
13751
13752 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13753
13754 char *device_name = (char *) mymalloc (param_value_size);
13755
13756 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13757
13758 device_param->device_name = device_name;
13759
13760 // device_vendor
13761
13762 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13763
13764 char *device_vendor = (char *) mymalloc (param_value_size);
13765
13766 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13767
13768 device_param->device_vendor = device_vendor;
13769
13770 cl_uint device_vendor_id = 0;
13771
13772 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13773 {
13774 device_vendor_id = VENDOR_ID_AMD;
13775 }
13776 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13777 {
13778 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13779 }
13780 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13781 {
13782 device_vendor_id = VENDOR_ID_APPLE;
13783 }
13784 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13785 {
13786 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13787 }
13788 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13789 {
13790 device_vendor_id = VENDOR_ID_INTEL_SDK;
13791 }
13792 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13793 {
13794 device_vendor_id = VENDOR_ID_MESA;
13795 }
13796 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13797 {
13798 device_vendor_id = VENDOR_ID_NV;
13799 }
13800 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13801 {
13802 device_vendor_id = VENDOR_ID_POCL;
13803 }
13804 else
13805 {
13806 device_vendor_id = VENDOR_ID_GENERIC;
13807 }
13808
13809 device_param->device_vendor_id = device_vendor_id;
13810
13811 // tuning db
13812
13813 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13814
13815 // device_version
13816
13817 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13818
13819 char *device_version = (char *) mymalloc (param_value_size);
13820
13821 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13822
13823 device_param->device_version = device_version;
13824
13825 // device_opencl_version
13826
13827 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13828
13829 char *device_opencl_version = (char *) mymalloc (param_value_size);
13830
13831 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13832
13833 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13834
13835 myfree (device_opencl_version);
13836
13837 // vector_width
13838
13839 cl_uint vector_width;
13840
13841 if (opencl_vector_width_chgd == 0)
13842 {
13843 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13844 {
13845 if (opti_type & OPTI_TYPE_USES_BITS_64)
13846 {
13847 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13848 }
13849 else
13850 {
13851 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13852 }
13853 }
13854 else
13855 {
13856 vector_width = (cl_uint) tuningdb_entry->vector_width;
13857 }
13858 }
13859 else
13860 {
13861 vector_width = opencl_vector_width;
13862 }
13863
13864 if (vector_width > 16) vector_width = 16;
13865
13866 device_param->vector_width = vector_width;
13867
13868 // max_compute_units
13869
13870 cl_uint device_processors;
13871
13872 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13873
13874 device_param->device_processors = device_processors;
13875
13876 // device_maxmem_alloc
13877 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13878
13879 cl_ulong device_maxmem_alloc;
13880
13881 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13882
13883 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13884
13885 // device_global_mem
13886
13887 cl_ulong device_global_mem;
13888
13889 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13890
13891 device_param->device_global_mem = device_global_mem;
13892
13893 // max_work_group_size
13894
13895 size_t device_maxworkgroup_size;
13896
13897 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13898
13899 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13900
13901 // max_clock_frequency
13902
13903 cl_uint device_maxclock_frequency;
13904
13905 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13906
13907 device_param->device_maxclock_frequency = device_maxclock_frequency;
13908
13909 // device_endian_little
13910
13911 cl_bool device_endian_little;
13912
13913 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13914
13915 if (device_endian_little == CL_FALSE)
13916 {
13917 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13918
13919 device_param->skipped = 1;
13920 }
13921
13922 // device_available
13923
13924 cl_bool device_available;
13925
13926 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13927
13928 if (device_available == CL_FALSE)
13929 {
13930 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13931
13932 device_param->skipped = 1;
13933 }
13934
13935 // device_compiler_available
13936
13937 cl_bool device_compiler_available;
13938
13939 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13940
13941 if (device_compiler_available == CL_FALSE)
13942 {
13943 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13944
13945 device_param->skipped = 1;
13946 }
13947
13948 // device_execution_capabilities
13949
13950 cl_device_exec_capabilities device_execution_capabilities;
13951
13952 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13953
13954 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13955 {
13956 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13957
13958 device_param->skipped = 1;
13959 }
13960
13961 // device_extensions
13962
13963 size_t device_extensions_size;
13964
13965 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13966
13967 char *device_extensions = mymalloc (device_extensions_size + 1);
13968
13969 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13970
13971 if (strstr (device_extensions, "base_atomics") == 0)
13972 {
13973 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13974
13975 device_param->skipped = 1;
13976 }
13977
13978 if (strstr (device_extensions, "byte_addressable_store") == 0)
13979 {
13980 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13981
13982 device_param->skipped = 1;
13983 }
13984
13985 myfree (device_extensions);
13986
13987 // device_local_mem_size
13988
13989 cl_ulong device_local_mem_size;
13990
13991 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13992
13993 if (device_local_mem_size < 32768)
13994 {
13995 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13996
13997 device_param->skipped = 1;
13998 }
13999
14000 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
14001 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
14002 // This results in both utilizing it for 50%
14003 // However, Intel has much better SIMD control over their own hardware
14004 // It makes sense to give them full control over their own hardware
14005
14006 if (device_type & CL_DEVICE_TYPE_CPU)
14007 {
14008 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14009 {
14010 if (data.force == 0)
14011 {
14012 if (algorithm_pos == 0)
14013 {
14014 log_info ("Device #%u: WARNING: not native intel opencl runtime, expect massive speed loss", device_id + 1);
14015 log_info (" You can use --force to override this but do not post error reports if you do so");
14016 }
14017
14018 device_param->skipped = 1;
14019 }
14020 }
14021 }
14022
14023 // skipped
14024
14025 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14026 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14027
14028 // driver_version
14029
14030 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14031
14032 char *driver_version = (char *) mymalloc (param_value_size);
14033
14034 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14035
14036 device_param->driver_version = driver_version;
14037
14038 // device_name_chksum
14039
14040 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14041
14042 #if __x86_64__
14043 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);
14044 #else
14045 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);
14046 #endif
14047
14048 uint device_name_digest[4] = { 0 };
14049
14050 md5_64 ((uint *) device_name_chksum, device_name_digest);
14051
14052 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14053
14054 device_param->device_name_chksum = device_name_chksum;
14055
14056 // device_processor_cores
14057
14058 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14059 {
14060 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14061 {
14062 need_adl = 1;
14063 }
14064
14065 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14066 {
14067 need_nvml = 1;
14068
14069 #ifdef _POSIX
14070 need_xnvctrl = 1;
14071 #endif
14072
14073 #ifdef _WIN
14074 need_nvapi = 1;
14075 #endif
14076 }
14077 }
14078
14079 // device_processor_cores
14080
14081 if (device_type & CL_DEVICE_TYPE_CPU)
14082 {
14083 cl_uint device_processor_cores = 1;
14084
14085 device_param->device_processor_cores = device_processor_cores;
14086 }
14087
14088 if (device_type & CL_DEVICE_TYPE_GPU)
14089 {
14090 if (device_vendor_id == VENDOR_ID_AMD)
14091 {
14092 cl_uint device_processor_cores = 0;
14093
14094 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
14095
14096 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
14097
14098 device_param->device_processor_cores = device_processor_cores;
14099 }
14100 else if (device_vendor_id == VENDOR_ID_NV)
14101 {
14102 cl_uint kernel_exec_timeout = 0;
14103
14104 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14105
14106 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14107
14108 device_param->kernel_exec_timeout = kernel_exec_timeout;
14109
14110 cl_uint device_processor_cores = 0;
14111
14112 #define CL_DEVICE_WARP_SIZE_NV 0x4003
14113
14114 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
14115
14116 device_param->device_processor_cores = device_processor_cores;
14117
14118 cl_uint sm_minor = 0;
14119 cl_uint sm_major = 0;
14120
14121 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14122 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14123
14124 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14125 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14126
14127 device_param->sm_minor = sm_minor;
14128 device_param->sm_major = sm_major;
14129
14130 // CPU burning loop damper
14131 // Value is given as number between 0-100
14132 // By default 100%
14133
14134 device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14135
14136 if (nvidia_spin_damp_chgd == 0)
14137 {
14138 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14139 {
14140 /**
14141 * the workaround is not a friend of rule based attacks
14142 * the words from the wordlist combined with fast and slow rules cause
14143 * fluctuations which cause inaccurate wait time estimations
14144 * using a reduced damping percentage almost compensates this
14145 */
14146
14147 device_param->nvidia_spin_damp = 64;
14148 }
14149 }
14150
14151 device_param->nvidia_spin_damp /= 100;
14152 }
14153 else
14154 {
14155 cl_uint device_processor_cores = 1;
14156
14157 device_param->device_processor_cores = device_processor_cores;
14158 }
14159 }
14160
14161 // display results
14162
14163 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14164 {
14165 if (machine_readable == 0)
14166 {
14167 if (device_param->skipped == 0)
14168 {
14169 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14170 device_id + 1,
14171 device_name,
14172 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14173 (unsigned int) (device_global_mem / 1024 / 1024),
14174 (unsigned int) device_processors);
14175 }
14176 else
14177 {
14178 log_info ("Device #%u: %s, skipped",
14179 device_id + 1,
14180 device_name);
14181 }
14182 }
14183 }
14184
14185 // common driver check
14186
14187 if (device_param->skipped == 0)
14188 {
14189 if (device_type & CL_DEVICE_TYPE_GPU)
14190 {
14191 if (platform_vendor_id == VENDOR_ID_AMD)
14192 {
14193 int catalyst_check = (force == 1) ? 0 : 1;
14194
14195 int catalyst_warn = 0;
14196
14197 int catalyst_broken = 0;
14198
14199 if (catalyst_check == 1)
14200 {
14201 catalyst_warn = 1;
14202
14203 // v14.9 and higher
14204 if (atoi (device_param->driver_version) >= 1573)
14205 {
14206 catalyst_warn = 0;
14207 }
14208
14209 catalyst_check = 0;
14210 }
14211
14212 if (catalyst_broken == 1)
14213 {
14214 log_info ("");
14215 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
14216 log_info ("It will pass over cracked hashes and does not report them as cracked");
14217 log_info ("You are STRONGLY encouraged not to use it");
14218 log_info ("You can use --force to override this but do not post error reports if you do so");
14219 log_info ("");
14220
14221 return (-1);
14222 }
14223
14224 if (catalyst_warn == 1)
14225 {
14226 log_info ("");
14227 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
14228 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
14229 log_info ("See hashcat's homepage for official supported catalyst drivers");
14230 #ifdef _WIN
14231 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14232 #endif
14233 log_info ("You can use --force to override this but do not post error reports if you do so");
14234 log_info ("");
14235
14236 return (-1);
14237 }
14238 }
14239 else if (platform_vendor_id == VENDOR_ID_NV)
14240 {
14241 if (device_param->kernel_exec_timeout != 0)
14242 {
14243 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);
14244 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14245 }
14246 }
14247 }
14248
14249 /* turns out pocl still creates segfaults (because of llvm)
14250 if (device_type & CL_DEVICE_TYPE_CPU)
14251 {
14252 if (platform_vendor_id == VENDOR_ID_AMD)
14253 {
14254 if (force == 0)
14255 {
14256 log_info ("");
14257 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14258 log_info ("You are STRONGLY encouraged not to use it");
14259 log_info ("You can use --force to override this but do not post error reports if you do so");
14260 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14261 log_info ("");
14262
14263 return (-1);
14264 }
14265 }
14266 }
14267 */
14268
14269 /**
14270 * kernel accel and loops tuning db adjustment
14271 */
14272
14273 device_param->kernel_accel_min = 1;
14274 device_param->kernel_accel_max = 1024;
14275
14276 device_param->kernel_loops_min = 1;
14277 device_param->kernel_loops_max = 1024;
14278
14279 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14280
14281 if (tuningdb_entry)
14282 {
14283 u32 _kernel_accel = tuningdb_entry->kernel_accel;
14284 u32 _kernel_loops = tuningdb_entry->kernel_loops;
14285
14286 if (_kernel_accel)
14287 {
14288 device_param->kernel_accel_min = _kernel_accel;
14289 device_param->kernel_accel_max = _kernel_accel;
14290 }
14291
14292 if (_kernel_loops)
14293 {
14294 if (workload_profile == 1)
14295 {
14296 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14297 }
14298 else if (workload_profile == 2)
14299 {
14300 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14301 }
14302
14303 device_param->kernel_loops_min = _kernel_loops;
14304 device_param->kernel_loops_max = _kernel_loops;
14305 }
14306 }
14307
14308 // commandline parameters overwrite tuningdb entries
14309
14310 if (kernel_accel)
14311 {
14312 device_param->kernel_accel_min = kernel_accel;
14313 device_param->kernel_accel_max = kernel_accel;
14314 }
14315
14316 if (kernel_loops)
14317 {
14318 device_param->kernel_loops_min = kernel_loops;
14319 device_param->kernel_loops_max = kernel_loops;
14320 }
14321
14322 /**
14323 * activate device
14324 */
14325
14326 devices_active++;
14327 }
14328
14329 // next please
14330
14331 devices_cnt++;
14332 }
14333 }
14334
14335 if (keyspace == 0 && devices_active == 0)
14336 {
14337 log_error ("ERROR: No devices found/left");
14338
14339 return (-1);
14340 }
14341
14342 // 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)
14343
14344 if (devices_filter != (uint) -1)
14345 {
14346 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14347
14348 if (devices_filter > devices_cnt_mask)
14349 {
14350 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14351
14352 return (-1);
14353 }
14354 }
14355
14356 data.devices_cnt = devices_cnt;
14357
14358 data.devices_active = devices_active;
14359
14360 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14361 {
14362 if (machine_readable == 0)
14363 {
14364 log_info ("");
14365 }
14366 }
14367
14368 /**
14369 * HM devices: init
14370 */
14371
14372 #ifdef HAVE_HWMON
14373 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14374 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14375 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14376 hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX] = { { 0 } };
14377
14378 if (gpu_temp_disable == 0)
14379 {
14380 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14381 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14382 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14383 XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));
14384
14385 data.hm_adl = NULL;
14386 data.hm_nvapi = NULL;
14387 data.hm_nvml = NULL;
14388 data.hm_xnvctrl = NULL;
14389
14390 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14391 {
14392 data.hm_nvml = nvml;
14393 }
14394
14395 if (data.hm_nvml)
14396 {
14397 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14398 {
14399 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14400
14401 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14402
14403 int tmp_out = 0;
14404
14405 for (int i = 0; i < tmp_in; i++)
14406 {
14407 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14408 }
14409
14410 for (int i = 0; i < tmp_out; i++)
14411 {
14412 unsigned int speed;
14413
14414 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14415
14416 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14417
14418 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14419 }
14420 }
14421 }
14422
14423 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14424 {
14425 data.hm_nvapi = nvapi;
14426 }
14427
14428 if (data.hm_nvapi)
14429 {
14430 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14431 {
14432 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14433
14434 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14435
14436 int tmp_out = 0;
14437
14438 for (int i = 0; i < tmp_in; i++)
14439 {
14440 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14441 }
14442 }
14443 }
14444
14445 if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0))
14446 {
14447 data.hm_xnvctrl = xnvctrl;
14448 }
14449
14450 if (data.hm_xnvctrl)
14451 {
14452 if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
14453 {
14454 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14455 {
14456 hc_device_param_t *device_param = &data.devices_param[device_id];
14457
14458 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14459
14460 hm_adapters_xnvctrl[device_id].xnvctrl = device_id;
14461
14462 int speed = 0;
14463
14464 if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
14465 }
14466 }
14467 }
14468
14469 if ((need_adl == 1) && (adl_init (adl) == 0))
14470 {
14471 data.hm_adl = adl;
14472 }
14473
14474 if (data.hm_adl)
14475 {
14476 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14477 {
14478 // total number of adapters
14479
14480 int hm_adapters_num;
14481
14482 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14483
14484 // adapter info
14485
14486 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14487
14488 if (lpAdapterInfo == NULL) return (-1);
14489
14490 // get a list (of ids of) valid/usable adapters
14491
14492 int num_adl_adapters = 0;
14493
14494 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14495
14496 if (num_adl_adapters > 0)
14497 {
14498 hc_thread_mutex_lock (mux_adl);
14499
14500 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14501
14502 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14503
14504 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14505 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14506
14507 hc_thread_mutex_unlock (mux_adl);
14508 }
14509
14510 myfree (valid_adl_device_list);
14511 myfree (lpAdapterInfo);
14512 }
14513 }
14514
14515 if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl)
14516 {
14517 gpu_temp_disable = 1;
14518 }
14519 }
14520
14521 /**
14522 * OpenCL devices: allocate buffer for device specific information
14523 */
14524
14525 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14526 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14527
14528 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14529
14530 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14531
14532 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14533
14534 /**
14535 * User-defined GPU temp handling
14536 */
14537
14538 if (gpu_temp_disable == 1)
14539 {
14540 gpu_temp_abort = 0;
14541 gpu_temp_retain = 0;
14542 }
14543
14544 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14545 {
14546 if (gpu_temp_abort < gpu_temp_retain)
14547 {
14548 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14549
14550 return (-1);
14551 }
14552 }
14553
14554 data.gpu_temp_disable = gpu_temp_disable;
14555 data.gpu_temp_abort = gpu_temp_abort;
14556 data.gpu_temp_retain = gpu_temp_retain;
14557 #endif
14558
14559 /**
14560 * enable custom signal handler(s)
14561 */
14562
14563 if (benchmark == 0)
14564 {
14565 hc_signal (sigHandler_default);
14566 }
14567 else
14568 {
14569 hc_signal (sigHandler_benchmark);
14570 }
14571
14572 /**
14573 * inform the user
14574 */
14575
14576 if (data.quiet == 0)
14577 {
14578 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14579
14580 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);
14581
14582 if (attack_mode == ATTACK_MODE_STRAIGHT)
14583 {
14584 log_info ("Rules: %u", kernel_rules_cnt);
14585 }
14586
14587 if (opti_type)
14588 {
14589 log_info ("Applicable Optimizers:");
14590
14591 for (uint i = 0; i < 32; i++)
14592 {
14593 const uint opti_bit = 1u << i;
14594
14595 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14596 }
14597 }
14598
14599 /**
14600 * Watchdog and Temperature balance
14601 */
14602
14603 #ifdef HAVE_HWMON
14604 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14605 {
14606 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14607 }
14608
14609 if (gpu_temp_abort == 0)
14610 {
14611 log_info ("Watchdog: Temperature abort trigger disabled");
14612 }
14613 else
14614 {
14615 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14616 }
14617
14618 if (gpu_temp_retain == 0)
14619 {
14620 log_info ("Watchdog: Temperature retain trigger disabled");
14621 }
14622 else
14623 {
14624 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14625 }
14626
14627 if (data.quiet == 0) log_info ("");
14628 #endif
14629 }
14630
14631 #ifdef HAVE_HWMON
14632
14633 /**
14634 * HM devices: copy
14635 */
14636
14637 if (gpu_temp_disable == 0)
14638 {
14639 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14640 {
14641 hc_device_param_t *device_param = &data.devices_param[device_id];
14642
14643 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14644
14645 if (device_param->skipped) continue;
14646
14647 const uint platform_devices_id = device_param->platform_devices_id;
14648
14649 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14650 {
14651 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14652 data.hm_device[device_id].nvapi = 0;
14653 data.hm_device[device_id].nvml = 0;
14654 data.hm_device[device_id].xnvctrl = 0;
14655 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14656 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14657 data.hm_device[device_id].fan_set_supported = hm_adapters_adl[platform_devices_id].fan_set_supported;
14658 }
14659
14660 if (device_param->device_vendor_id == VENDOR_ID_NV)
14661 {
14662 data.hm_device[device_id].adl = 0;
14663 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14664 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14665 data.hm_device[device_id].xnvctrl = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
14666 data.hm_device[device_id].od_version = 0;
14667 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14668 data.hm_device[device_id].fan_set_supported = 0;
14669 }
14670 }
14671 }
14672
14673 /**
14674 * powertune on user request
14675 */
14676
14677 if (powertune_enable == 1)
14678 {
14679 hc_thread_mutex_lock (mux_adl);
14680
14681 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14682 {
14683 hc_device_param_t *device_param = &data.devices_param[device_id];
14684
14685 if (device_param->skipped) continue;
14686
14687 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14688 {
14689 /**
14690 * Temporary fix:
14691 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14692 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14693 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14694 * Driver / ADL bug?
14695 */
14696
14697 if (data.hm_device[device_id].od_version == 6)
14698 {
14699 int ADL_rc;
14700
14701 // check powertune capabilities first, if not available then skip device
14702
14703 int powertune_supported = 0;
14704
14705 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14706 {
14707 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14708
14709 return (-1);
14710 }
14711
14712 // first backup current value, we will restore it later
14713
14714 if (powertune_supported != 0)
14715 {
14716 // powercontrol settings
14717
14718 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14719
14720 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14721 {
14722 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14723 }
14724
14725 if (ADL_rc != ADL_OK)
14726 {
14727 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14728
14729 return (-1);
14730 }
14731
14732 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14733 {
14734 log_error ("ERROR: Failed to set new ADL PowerControl values");
14735
14736 return (-1);
14737 }
14738
14739 // clocks
14740
14741 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14742
14743 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14744
14745 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)
14746 {
14747 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14748
14749 return (-1);
14750 }
14751
14752 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14753
14754 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14755
14756 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14757 {
14758 log_error ("ERROR: Failed to get ADL device capabilities");
14759
14760 return (-1);
14761 }
14762
14763 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14764 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14765
14766 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14767 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14768
14769 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14770 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14771
14772 // warning if profile has too low max values
14773
14774 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14775 {
14776 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14777 }
14778
14779 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14780 {
14781 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14782 }
14783
14784 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14785
14786 performance_state->iNumberOfPerformanceLevels = 2;
14787
14788 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14789 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14790 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14791 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14792
14793 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)
14794 {
14795 log_info ("ERROR: Failed to set ADL performance state");
14796
14797 return (-1);
14798 }
14799
14800 local_free (performance_state);
14801 }
14802
14803 // set powertune value only
14804
14805 if (powertune_supported != 0)
14806 {
14807 // powertune set
14808 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14809
14810 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14811 {
14812 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14813
14814 return (-1);
14815 }
14816
14817 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14818 {
14819 log_error ("ERROR: Failed to set new ADL PowerControl values");
14820
14821 return (-1);
14822 }
14823 }
14824 }
14825 }
14826
14827 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14828 {
14829 // first backup current value, we will restore it later
14830
14831 unsigned int limit;
14832
14833 int powertune_supported = 0;
14834
14835 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14836 {
14837 powertune_supported = 1;
14838 }
14839
14840 // if backup worked, activate the maximum allowed
14841
14842 if (powertune_supported != 0)
14843 {
14844 unsigned int minLimit;
14845 unsigned int maxLimit;
14846
14847 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14848 {
14849 if (maxLimit > 0)
14850 {
14851 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14852 {
14853 // now we can be sure we need to reset later
14854
14855 nvml_power_limit[device_id] = limit;
14856 }
14857 }
14858 }
14859 }
14860 }
14861 }
14862
14863 hc_thread_mutex_unlock (mux_adl);
14864 }
14865
14866 #endif // HAVE_HWMON
14867
14868 #ifdef DEBUG
14869 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14870 #endif
14871
14872 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14873
14874 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14875 {
14876 /**
14877 * host buffer
14878 */
14879
14880 hc_device_param_t *device_param = &data.devices_param[device_id];
14881
14882 if (device_param->skipped) continue;
14883
14884 /**
14885 * device properties
14886 */
14887
14888 const char *device_name_chksum = device_param->device_name_chksum;
14889 const u32 device_processors = device_param->device_processors;
14890 const u32 device_processor_cores = device_param->device_processor_cores;
14891
14892 /**
14893 * create context for each device
14894 */
14895
14896 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14897
14898 /**
14899 * create command-queue
14900 */
14901
14902 // not supported with NV
14903 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14904
14905 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14906
14907 /**
14908 * kernel threads: some algorithms need a fixed kernel-threads count
14909 * because of shared memory usage or bitslice
14910 * there needs to be some upper limit, otherwise there's too much overhead
14911 */
14912
14913 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14914
14915 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14916 {
14917 kernel_threads = KERNEL_THREADS_MAX_CPU;
14918 }
14919
14920 if (hash_mode == 1500) kernel_threads = 64; // DES
14921 if (hash_mode == 3000) kernel_threads = 64; // DES
14922 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14923 if (hash_mode == 7500) kernel_threads = 64; // RC4
14924 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14925 if (hash_mode == 9700) kernel_threads = 64; // RC4
14926 if (hash_mode == 9710) kernel_threads = 64; // RC4
14927 if (hash_mode == 9800) kernel_threads = 64; // RC4
14928 if (hash_mode == 9810) kernel_threads = 64; // RC4
14929 if (hash_mode == 10400) kernel_threads = 64; // RC4
14930 if (hash_mode == 10410) kernel_threads = 64; // RC4
14931 if (hash_mode == 10500) kernel_threads = 64; // RC4
14932 if (hash_mode == 13100) kernel_threads = 64; // RC4
14933
14934 device_param->kernel_threads = kernel_threads;
14935
14936 device_param->hardware_power = device_processors * kernel_threads;
14937
14938 /**
14939 * create input buffers on device : calculate size of fixed memory buffers
14940 */
14941
14942 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14943 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14944
14945 device_param->size_root_css = size_root_css;
14946 device_param->size_markov_css = size_markov_css;
14947
14948 size_t size_results = sizeof (uint);
14949
14950 device_param->size_results = size_results;
14951
14952 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14953 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14954
14955 size_t size_plains = digests_cnt * sizeof (plain_t);
14956 size_t size_salts = salts_cnt * sizeof (salt_t);
14957 size_t size_esalts = salts_cnt * esalt_size;
14958
14959 device_param->size_plains = size_plains;
14960 device_param->size_digests = size_digests;
14961 device_param->size_shown = size_shown;
14962 device_param->size_salts = size_salts;
14963
14964 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14965 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14966 size_t size_tm = 32 * sizeof (bs_word_t);
14967
14968 // scryptV stuff
14969
14970 size_t size_scryptV = 1;
14971
14972 if ((hash_mode == 8900) || (hash_mode == 9300))
14973 {
14974 uint tmto_start = 0;
14975 uint tmto_stop = 10;
14976
14977 if (scrypt_tmto)
14978 {
14979 tmto_start = scrypt_tmto;
14980 }
14981 else
14982 {
14983 // in case the user did not specify the tmto manually
14984 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14985 // but set the lower end only in case the user has a device with too less memory
14986
14987 if (hash_mode == 8900)
14988 {
14989 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14990 {
14991 tmto_start = 1;
14992 }
14993 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14994 {
14995 tmto_start = 2;
14996 }
14997 }
14998 else if (hash_mode == 9300)
14999 {
15000 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15001 {
15002 tmto_start = 2;
15003 }
15004 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15005 {
15006 tmto_start = 2;
15007 }
15008 }
15009 }
15010
15011 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
15012 {
15013 // TODO: in theory the following calculation needs to be done per salt, not global
15014 // we assume all hashes have the same scrypt settings
15015
15016 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
15017
15018 size_scryptV /= 1 << tmto;
15019
15020 size_scryptV *= device_processors * device_processor_cores;
15021
15022 if (size_scryptV > device_param->device_maxmem_alloc)
15023 {
15024 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15025
15026 continue;
15027 }
15028
15029 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
15030 {
15031 data.salts_buf[salts_pos].scrypt_tmto = tmto;
15032 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
15033 }
15034
15035 break;
15036 }
15037
15038 if (data.salts_buf[0].scrypt_phy == 0)
15039 {
15040 log_error ("ERROR: can't allocate enough device memory");
15041
15042 return -1;
15043 }
15044
15045 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
15046 }
15047
15048 /**
15049 * some algorithms need a fixed kernel-loops count
15050 */
15051
15052 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15053 {
15054 const u32 kernel_loops_fixed = 1024;
15055
15056 device_param->kernel_loops_min = kernel_loops_fixed;
15057 device_param->kernel_loops_max = kernel_loops_fixed;
15058 }
15059
15060 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15061 {
15062 const u32 kernel_loops_fixed = 1024;
15063
15064 device_param->kernel_loops_min = kernel_loops_fixed;
15065 device_param->kernel_loops_max = kernel_loops_fixed;
15066 }
15067
15068 if (hash_mode == 8900)
15069 {
15070 const u32 kernel_loops_fixed = 1;
15071
15072 device_param->kernel_loops_min = kernel_loops_fixed;
15073 device_param->kernel_loops_max = kernel_loops_fixed;
15074 }
15075
15076 if (hash_mode == 9300)
15077 {
15078 const u32 kernel_loops_fixed = 1;
15079
15080 device_param->kernel_loops_min = kernel_loops_fixed;
15081 device_param->kernel_loops_max = kernel_loops_fixed;
15082 }
15083
15084 if (hash_mode == 12500)
15085 {
15086 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15087
15088 device_param->kernel_loops_min = kernel_loops_fixed;
15089 device_param->kernel_loops_max = kernel_loops_fixed;
15090 }
15091
15092 /**
15093 * some algorithms have a maximum kernel-loops count
15094 */
15095
15096 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15097 {
15098 u32 innerloop_cnt = 0;
15099
15100 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15101 {
15102 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15103 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15104 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15105 }
15106 else
15107 {
15108 innerloop_cnt = data.salts_buf[0].salt_iter;
15109 }
15110
15111 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15112 (innerloop_cnt <= device_param->kernel_loops_max))
15113 {
15114 device_param->kernel_loops_max = innerloop_cnt;
15115 }
15116 }
15117
15118 u32 kernel_accel_min = device_param->kernel_accel_min;
15119 u32 kernel_accel_max = device_param->kernel_accel_max;
15120
15121 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15122
15123 size_t size_pws = 4;
15124 size_t size_tmps = 4;
15125 size_t size_hooks = 4;
15126
15127 while (kernel_accel_max >= kernel_accel_min)
15128 {
15129 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15130
15131 // size_pws
15132
15133 size_pws = kernel_power_max * sizeof (pw_t);
15134
15135 // size_tmps
15136
15137 switch (hash_mode)
15138 {
15139 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15140 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15141 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15142 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15143 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15144 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15145 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15146 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15147 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15148 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15149 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15150 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15151 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15152 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15153 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15154 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15155 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15156 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15157 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15158 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15159 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15160 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15161 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15162 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
15163 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
15164 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
15165 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
15166 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
15167 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15168 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15169 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
15170 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
15171 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15172 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
15173 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15174 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
15175 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
15176 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15177 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15178 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
15179 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
15180 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
15181 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15182 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
15183 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
15184 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
15185 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
15186 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15187 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
15188 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
15189 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
15190 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15191 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15192 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
15193 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
15194 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
15195 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
15196 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
15197 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15198 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15199 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15200 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
15201 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
15202 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15203 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15204 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15205 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15206 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15207 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15208 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15209 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15210 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15211 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15212 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15213 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15214 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15215 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15216 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15217 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15218 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15219 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15220 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15221 };
15222
15223 // size_hooks
15224
15225 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15226 {
15227 switch (hash_mode)
15228 {
15229 }
15230 }
15231
15232 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15233 // if not, decrease amplifier and try again
15234
15235 int skip = 0;
15236
15237 const u64 size_total
15238 = bitmap_size
15239 + bitmap_size
15240 + bitmap_size
15241 + bitmap_size
15242 + bitmap_size
15243 + bitmap_size
15244 + bitmap_size
15245 + bitmap_size
15246 + size_bfs
15247 + size_combs
15248 + size_digests
15249 + size_esalts
15250 + size_hooks
15251 + size_markov_css
15252 + size_plains
15253 + size_pws
15254 + size_pws // not a bug
15255 + size_results
15256 + size_root_css
15257 + size_rules
15258 + size_rules_c
15259 + size_salts
15260 + size_scryptV
15261 + size_shown
15262 + size_tm
15263 + size_tmps;
15264
15265 // Don't ask me, ask AMD!
15266
15267 if (size_total > device_param->device_maxmem_alloc) skip = 1;
15268 if (size_total > device_param->device_global_mem) skip = 1;
15269
15270 if (skip == 1)
15271 {
15272 kernel_accel_max--;
15273
15274 continue;
15275 }
15276
15277 break;
15278 }
15279
15280 /*
15281 if (kernel_accel_max == 0)
15282 {
15283 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
15284
15285 return -1;
15286 }
15287 */
15288
15289 device_param->kernel_accel_min = kernel_accel_min;
15290 device_param->kernel_accel_max = kernel_accel_max;
15291
15292 /*
15293 if (kernel_accel_max < kernel_accel)
15294 {
15295 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
15296
15297 device_param->kernel_accel = kernel_accel_max;
15298 }
15299 */
15300
15301 device_param->size_bfs = size_bfs;
15302 device_param->size_combs = size_combs;
15303 device_param->size_rules = size_rules;
15304 device_param->size_rules_c = size_rules_c;
15305 device_param->size_pws = size_pws;
15306 device_param->size_tmps = size_tmps;
15307 device_param->size_hooks = size_hooks;
15308
15309 /**
15310 * default building options
15311 */
15312
15313 char build_opts[1024] = { 0 };
15314
15315 // we don't have sm_* on vendors not NV but it doesn't matter
15316
15317 #if _WIN
15318 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\\OpenCL\\\" -I '%s\\OpenCL\\' -I %s\\OpenCL\\ -I\"%s\\OpenCL\\\" -I'%s\\OpenCL\\' -I%s\\OpenCL\\", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
15319 #else
15320 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s/OpenCL/\" -I '%s/OpenCL/' -I %s/OpenCL/ -I\"%s/OpenCL/\" -I'%s/OpenCL/' -I%s/OpenCL/", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
15321 #endif
15322
15323 char build_opts_new[1024] = { 0 };
15324
15325 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u -DKERN_TYPE=%u -D_unroll -cl-std=CL1.1", build_opts, device_param->device_vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type);
15326
15327 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
15328
15329 /*
15330 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
15331 {
15332 // we do vectorizing much better than the auto-vectorizer
15333
15334 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
15335
15336 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
15337 }
15338 */
15339
15340 #ifdef DEBUG
15341 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15342 #endif
15343
15344 /**
15345 * main kernel
15346 */
15347
15348 {
15349 /**
15350 * kernel source filename
15351 */
15352
15353 char source_file[256] = { 0 };
15354
15355 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15356
15357 struct stat sst;
15358
15359 if (stat (source_file, &sst) == -1)
15360 {
15361 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15362
15363 return -1;
15364 }
15365
15366 /**
15367 * kernel cached filename
15368 */
15369
15370 char cached_file[256] = { 0 };
15371
15372 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15373
15374 int cached = 1;
15375
15376 struct stat cst;
15377
15378 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15379 {
15380 cached = 0;
15381 }
15382
15383 /**
15384 * kernel compile or load
15385 */
15386
15387 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15388
15389 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15390
15391 if (force_jit_compilation == -1)
15392 {
15393 if (cached == 0)
15394 {
15395 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15396
15397 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15398
15399 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15400
15401 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15402
15403 #ifdef DEBUG
15404 size_t build_log_size = 0;
15405
15406 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15407
15408 if (build_log_size > 1)
15409 {
15410 char *build_log = (char *) malloc (build_log_size + 1);
15411
15412 memset (build_log, 0, build_log_size + 1);
15413
15414 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15415
15416 puts (build_log);
15417
15418 free (build_log);
15419 }
15420 #endif
15421
15422 if (rc != 0)
15423 {
15424 device_param->skipped = true;
15425
15426 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15427
15428 continue;
15429 }
15430
15431 size_t binary_size;
15432
15433 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15434
15435 u8 *binary = (u8 *) mymalloc (binary_size);
15436
15437 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15438
15439 writeProgramBin (cached_file, binary, binary_size);
15440
15441 local_free (binary);
15442 }
15443 else
15444 {
15445 #ifdef DEBUG
15446 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15447 #endif
15448
15449 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15450
15451 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15452
15453 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15454 }
15455 }
15456 else
15457 {
15458 #ifdef DEBUG
15459 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15460 #endif
15461
15462 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15463
15464 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15465
15466 char build_opts_update[1024] = { 0 };
15467
15468 if (force_jit_compilation == 1500)
15469 {
15470 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15471 }
15472 else if (force_jit_compilation == 8900)
15473 {
15474 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);
15475 }
15476 else
15477 {
15478 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15479 }
15480
15481 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15482
15483 #ifdef DEBUG
15484 size_t build_log_size = 0;
15485
15486 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15487
15488 if (build_log_size > 1)
15489 {
15490 char *build_log = (char *) malloc (build_log_size + 1);
15491
15492 memset (build_log, 0, build_log_size + 1);
15493
15494 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15495
15496 puts (build_log);
15497
15498 free (build_log);
15499 }
15500 #endif
15501
15502 if (rc != 0)
15503 {
15504 device_param->skipped = true;
15505
15506 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15507 }
15508 }
15509
15510 local_free (kernel_lengths);
15511 local_free (kernel_sources[0]);
15512 local_free (kernel_sources);
15513 }
15514
15515 /**
15516 * word generator kernel
15517 */
15518
15519 if (attack_mode != ATTACK_MODE_STRAIGHT)
15520 {
15521 /**
15522 * kernel mp source filename
15523 */
15524
15525 char source_file[256] = { 0 };
15526
15527 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15528
15529 struct stat sst;
15530
15531 if (stat (source_file, &sst) == -1)
15532 {
15533 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15534
15535 return -1;
15536 }
15537
15538 /**
15539 * kernel mp cached filename
15540 */
15541
15542 char cached_file[256] = { 0 };
15543
15544 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15545
15546 int cached = 1;
15547
15548 struct stat cst;
15549
15550 if (stat (cached_file, &cst) == -1)
15551 {
15552 cached = 0;
15553 }
15554
15555 /**
15556 * kernel compile or load
15557 */
15558
15559 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15560
15561 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15562
15563 if (cached == 0)
15564 {
15565 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15566 if (quiet == 0) log_info ("");
15567
15568 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15569
15570 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15571
15572 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15573
15574 if (rc != 0)
15575 {
15576 device_param->skipped = true;
15577
15578 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15579
15580 continue;
15581 }
15582
15583 size_t binary_size;
15584
15585 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15586
15587 u8 *binary = (u8 *) mymalloc (binary_size);
15588
15589 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15590
15591 writeProgramBin (cached_file, binary, binary_size);
15592
15593 local_free (binary);
15594 }
15595 else
15596 {
15597 #ifdef DEBUG
15598 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15599 #endif
15600
15601 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15602
15603 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15604
15605 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15606 }
15607
15608 local_free (kernel_lengths);
15609 local_free (kernel_sources[0]);
15610 local_free (kernel_sources);
15611 }
15612
15613 /**
15614 * amplifier kernel
15615 */
15616
15617 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15618 {
15619
15620 }
15621 else
15622 {
15623 /**
15624 * kernel amp source filename
15625 */
15626
15627 char source_file[256] = { 0 };
15628
15629 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15630
15631 struct stat sst;
15632
15633 if (stat (source_file, &sst) == -1)
15634 {
15635 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15636
15637 return -1;
15638 }
15639
15640 /**
15641 * kernel amp cached filename
15642 */
15643
15644 char cached_file[256] = { 0 };
15645
15646 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15647
15648 int cached = 1;
15649
15650 struct stat cst;
15651
15652 if (stat (cached_file, &cst) == -1)
15653 {
15654 cached = 0;
15655 }
15656
15657 /**
15658 * kernel compile or load
15659 */
15660
15661 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15662
15663 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15664
15665 if (cached == 0)
15666 {
15667 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15668 if (quiet == 0) log_info ("");
15669
15670 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15671
15672 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15673
15674 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15675
15676 if (rc != 0)
15677 {
15678 device_param->skipped = true;
15679
15680 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15681
15682 continue;
15683 }
15684
15685 size_t binary_size;
15686
15687 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15688
15689 u8 *binary = (u8 *) mymalloc (binary_size);
15690
15691 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15692
15693 writeProgramBin (cached_file, binary, binary_size);
15694
15695 local_free (binary);
15696 }
15697 else
15698 {
15699 #ifdef DEBUG
15700 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15701 #endif
15702
15703 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15704
15705 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15706
15707 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15708 }
15709
15710 local_free (kernel_lengths);
15711 local_free (kernel_sources[0]);
15712 local_free (kernel_sources);
15713 }
15714
15715 // some algorithm collide too fast, make that impossible
15716
15717 if (benchmark == 1)
15718 {
15719 ((uint *) digests_buf)[0] = -1;
15720 ((uint *) digests_buf)[1] = -1;
15721 ((uint *) digests_buf)[2] = -1;
15722 ((uint *) digests_buf)[3] = -1;
15723 }
15724
15725 /**
15726 * global buffers
15727 */
15728
15729 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15730 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15731 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15732 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15733 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15734 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15735 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15736 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15737 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15738 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15739 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15740 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15741 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15742 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15743 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15744 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15745 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15746 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15747
15748 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);
15749 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);
15750 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);
15751 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);
15752 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);
15753 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);
15754 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);
15755 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);
15756 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15757 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15758 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15759
15760 /**
15761 * special buffers
15762 */
15763
15764 if (attack_kern == ATTACK_KERN_STRAIGHT)
15765 {
15766 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15767 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15768
15769 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15770 }
15771 else if (attack_kern == ATTACK_KERN_COMBI)
15772 {
15773 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15774 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15775 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15776 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15777 }
15778 else if (attack_kern == ATTACK_KERN_BF)
15779 {
15780 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15781 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15782 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15783 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15784 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15785 }
15786
15787 if (size_esalts)
15788 {
15789 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15790
15791 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15792 }
15793
15794 /**
15795 * main host data
15796 */
15797
15798 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15799
15800 device_param->pws_buf = pws_buf;
15801
15802 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15803
15804 device_param->combs_buf = combs_buf;
15805
15806 void *hooks_buf = mymalloc (size_hooks);
15807
15808 device_param->hooks_buf = hooks_buf;
15809
15810 /**
15811 * kernel args
15812 */
15813
15814 device_param->kernel_params_buf32[21] = bitmap_mask;
15815 device_param->kernel_params_buf32[22] = bitmap_shift1;
15816 device_param->kernel_params_buf32[23] = bitmap_shift2;
15817 device_param->kernel_params_buf32[24] = 0; // salt_pos
15818 device_param->kernel_params_buf32[25] = 0; // loop_pos
15819 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15820 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15821 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15822 device_param->kernel_params_buf32[29] = 0; // digests_offset
15823 device_param->kernel_params_buf32[30] = 0; // combs_mode
15824 device_param->kernel_params_buf32[31] = 0; // gid_max
15825
15826 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15827 ? &device_param->d_pws_buf
15828 : &device_param->d_pws_amp_buf;
15829 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15830 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15831 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15832 device_param->kernel_params[ 4] = &device_param->d_tmps;
15833 device_param->kernel_params[ 5] = &device_param->d_hooks;
15834 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15835 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15836 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15837 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15838 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15839 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15840 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15841 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15842 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15843 device_param->kernel_params[15] = &device_param->d_digests_buf;
15844 device_param->kernel_params[16] = &device_param->d_digests_shown;
15845 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15846 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15847 device_param->kernel_params[19] = &device_param->d_result;
15848 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15849 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15850 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15851 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15852 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15853 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15854 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15855 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15856 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15857 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15858 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15859 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15860
15861 device_param->kernel_params_mp_buf64[3] = 0;
15862 device_param->kernel_params_mp_buf32[4] = 0;
15863 device_param->kernel_params_mp_buf32[5] = 0;
15864 device_param->kernel_params_mp_buf32[6] = 0;
15865 device_param->kernel_params_mp_buf32[7] = 0;
15866 device_param->kernel_params_mp_buf32[8] = 0;
15867
15868 device_param->kernel_params_mp[0] = NULL;
15869 device_param->kernel_params_mp[1] = NULL;
15870 device_param->kernel_params_mp[2] = NULL;
15871 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15872 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15873 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15874 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15875 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15876 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15877
15878 device_param->kernel_params_mp_l_buf64[3] = 0;
15879 device_param->kernel_params_mp_l_buf32[4] = 0;
15880 device_param->kernel_params_mp_l_buf32[5] = 0;
15881 device_param->kernel_params_mp_l_buf32[6] = 0;
15882 device_param->kernel_params_mp_l_buf32[7] = 0;
15883 device_param->kernel_params_mp_l_buf32[8] = 0;
15884 device_param->kernel_params_mp_l_buf32[9] = 0;
15885
15886 device_param->kernel_params_mp_l[0] = NULL;
15887 device_param->kernel_params_mp_l[1] = NULL;
15888 device_param->kernel_params_mp_l[2] = NULL;
15889 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15890 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15891 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15892 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15893 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15894 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15895 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15896
15897 device_param->kernel_params_mp_r_buf64[3] = 0;
15898 device_param->kernel_params_mp_r_buf32[4] = 0;
15899 device_param->kernel_params_mp_r_buf32[5] = 0;
15900 device_param->kernel_params_mp_r_buf32[6] = 0;
15901 device_param->kernel_params_mp_r_buf32[7] = 0;
15902 device_param->kernel_params_mp_r_buf32[8] = 0;
15903
15904 device_param->kernel_params_mp_r[0] = NULL;
15905 device_param->kernel_params_mp_r[1] = NULL;
15906 device_param->kernel_params_mp_r[2] = NULL;
15907 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15908 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15909 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15910 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15911 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15912 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15913
15914 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15915 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15916
15917 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15918 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15919 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15920 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15921 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15922 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15923 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15924
15925 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15926 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15927
15928 device_param->kernel_params_memset_buf32[1] = 0; // value
15929 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15930
15931 device_param->kernel_params_memset[0] = NULL;
15932 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15933 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15934
15935 /**
15936 * kernel name
15937 */
15938
15939 size_t kernel_wgs_tmp;
15940
15941 char kernel_name[64] = { 0 };
15942
15943 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15944 {
15945 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15946 {
15947 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15948
15949 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15950
15951 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15952
15953 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15954
15955 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15956
15957 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15958 }
15959 else
15960 {
15961 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15962
15963 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15964
15965 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15966
15967 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15968
15969 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15970
15971 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15972 }
15973
15974 if (data.attack_mode == ATTACK_MODE_BF)
15975 {
15976 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15977 {
15978 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15979
15980 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15981
15982 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);
15983 }
15984 }
15985 }
15986 else
15987 {
15988 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15989
15990 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15991
15992 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15993
15994 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15995
15996 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15997
15998 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15999
16000 if (opts_type & OPTS_TYPE_HOOK12)
16001 {
16002 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
16003
16004 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16005
16006 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);
16007 }
16008
16009 if (opts_type & OPTS_TYPE_HOOK23)
16010 {
16011 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
16012
16013 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16014
16015 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);
16016 }
16017 }
16018
16019 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);
16020 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);
16021 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);
16022
16023 for (uint i = 0; i <= 20; i++)
16024 {
16025 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
16026 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
16027 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
16028
16029 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
16030 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
16031 }
16032
16033 for (uint i = 21; i <= 31; i++)
16034 {
16035 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
16036 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
16037 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
16038
16039 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
16040 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
16041 }
16042
16043 // GPU memset
16044
16045 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
16046
16047 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);
16048
16049 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
16050 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
16051 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
16052
16053 // MP start
16054
16055 if (attack_mode == ATTACK_MODE_BF)
16056 {
16057 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
16058 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
16059
16060 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);
16061 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);
16062
16063 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16064 {
16065 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
16066 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
16067 }
16068 }
16069 else if (attack_mode == ATTACK_MODE_HYBRID1)
16070 {
16071 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16072
16073 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);
16074 }
16075 else if (attack_mode == ATTACK_MODE_HYBRID2)
16076 {
16077 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16078
16079 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);
16080 }
16081
16082 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16083 {
16084 // nothing to do
16085 }
16086 else
16087 {
16088 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
16089
16090 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);
16091 }
16092
16093 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16094 {
16095 // nothing to do
16096 }
16097 else
16098 {
16099 for (uint i = 0; i < 5; i++)
16100 {
16101 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
16102 }
16103
16104 for (uint i = 5; i < 7; i++)
16105 {
16106 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
16107 }
16108 }
16109
16110 // maybe this has been updated by clGetKernelWorkGroupInfo()
16111 // value can only be decreased, so we don't need to reallocate buffers
16112
16113 device_param->kernel_threads = kernel_threads;
16114
16115 // zero some data buffers
16116
16117 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
16118 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
16119 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
16120 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
16121 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
16122 run_kernel_bzero (device_param, device_param->d_result, size_results);
16123
16124 /**
16125 * special buffers
16126 */
16127
16128 if (attack_kern == ATTACK_KERN_STRAIGHT)
16129 {
16130 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
16131 }
16132 else if (attack_kern == ATTACK_KERN_COMBI)
16133 {
16134 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
16135 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
16136 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16137 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16138 }
16139 else if (attack_kern == ATTACK_KERN_BF)
16140 {
16141 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
16142 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
16143 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
16144 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16145 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16146 }
16147
16148 #if defined(HAVE_HWMON)
16149
16150 /**
16151 * Store initial fanspeed if gpu_temp_retain is enabled
16152 */
16153
16154 if (gpu_temp_disable == 0)
16155 {
16156 if (gpu_temp_retain != 0)
16157 {
16158 hc_thread_mutex_lock (mux_adl);
16159
16160 if (data.hm_device[device_id].fan_get_supported == 1)
16161 {
16162 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
16163 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
16164
16165 temp_retain_fanspeed_value[device_id] = fanspeed;
16166 temp_retain_fanpolicy_value[device_id] = fanpolicy;
16167
16168 // we also set it to tell the OS we take control over the fan and it's automatic controller
16169 // if it was set to automatic. we do not control user-defined fanspeeds.
16170
16171 if (fanpolicy == 1)
16172 {
16173 data.hm_device[device_id].fan_set_supported = 1;
16174
16175 int rc = -1;
16176
16177 if (device_param->device_vendor_id == VENDOR_ID_AMD)
16178 {
16179 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
16180 }
16181 else if (device_param->device_vendor_id == VENDOR_ID_NV)
16182 {
16183 #ifdef _POSIX
16184 rc = hm_set_fanspeed_with_device_id_xnvctrl (device_id, fanspeed);
16185 #endif
16186 }
16187
16188 if (rc == 0)
16189 {
16190 data.hm_device[device_id].fan_set_supported = 1;
16191 }
16192 else
16193 {
16194 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
16195
16196 data.hm_device[device_id].fan_set_supported = 0;
16197 }
16198 }
16199 else
16200 {
16201 data.hm_device[device_id].fan_set_supported = 0;
16202 }
16203 }
16204
16205 hc_thread_mutex_unlock (mux_adl);
16206 }
16207 }
16208
16209 #endif // HAVE_HWMON
16210 }
16211
16212 if (data.quiet == 0) log_info_nn ("");
16213
16214 /**
16215 * In benchmark-mode, inform user which algorithm is checked
16216 */
16217
16218 if (benchmark == 1)
16219 {
16220 if (machine_readable == 0)
16221 {
16222 quiet = 0;
16223
16224 data.quiet = quiet;
16225
16226 char *hash_type = strhashtype (data.hash_mode); // not a bug
16227
16228 log_info ("Hashtype: %s", hash_type);
16229 log_info ("");
16230 }
16231 }
16232
16233 /**
16234 * keep track of the progress
16235 */
16236
16237 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16238 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16239 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16240
16241 /**
16242 * open filehandles
16243 */
16244
16245 #if _WIN
16246 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
16247 {
16248 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
16249
16250 return (-1);
16251 }
16252
16253 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
16254 {
16255 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
16256
16257 return (-1);
16258 }
16259
16260 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
16261 {
16262 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
16263
16264 return (-1);
16265 }
16266 #endif
16267
16268 /**
16269 * dictionary pad
16270 */
16271
16272 segment_size *= (1024 * 1024);
16273
16274 data.segment_size = segment_size;
16275
16276 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
16277
16278 wl_data->buf = (char *) mymalloc (segment_size);
16279 wl_data->avail = segment_size;
16280 wl_data->incr = segment_size;
16281 wl_data->cnt = 0;
16282 wl_data->pos = 0;
16283
16284 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
16285
16286 data.wordlist_mode = wordlist_mode;
16287
16288 cs_t *css_buf = NULL;
16289 uint css_cnt = 0;
16290 uint dictcnt = 0;
16291 uint maskcnt = 1;
16292 char **masks = NULL;
16293 char **dictfiles = NULL;
16294
16295 uint mask_from_file = 0;
16296
16297 if (attack_mode == ATTACK_MODE_STRAIGHT)
16298 {
16299 if (wordlist_mode == WL_MODE_FILE)
16300 {
16301 int wls_left = myargc - (optind + 1);
16302
16303 for (int i = 0; i < wls_left; i++)
16304 {
16305 char *l0_filename = myargv[optind + 1 + i];
16306
16307 struct stat l0_stat;
16308
16309 if (stat (l0_filename, &l0_stat) == -1)
16310 {
16311 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
16312
16313 return (-1);
16314 }
16315
16316 uint is_dir = S_ISDIR (l0_stat.st_mode);
16317
16318 if (is_dir == 0)
16319 {
16320 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16321
16322 dictcnt++;
16323
16324 dictfiles[dictcnt - 1] = l0_filename;
16325 }
16326 else
16327 {
16328 // do not allow --keyspace w/ a directory
16329
16330 if (keyspace == 1)
16331 {
16332 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16333
16334 return (-1);
16335 }
16336
16337 char **dictionary_files = NULL;
16338
16339 dictionary_files = scan_directory (l0_filename);
16340
16341 if (dictionary_files != NULL)
16342 {
16343 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16344
16345 for (int d = 0; dictionary_files[d] != NULL; d++)
16346 {
16347 char *l1_filename = dictionary_files[d];
16348
16349 struct stat l1_stat;
16350
16351 if (stat (l1_filename, &l1_stat) == -1)
16352 {
16353 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16354
16355 return (-1);
16356 }
16357
16358 if (S_ISREG (l1_stat.st_mode))
16359 {
16360 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16361
16362 dictcnt++;
16363
16364 dictfiles[dictcnt - 1] = strdup (l1_filename);
16365 }
16366 }
16367 }
16368
16369 local_free (dictionary_files);
16370 }
16371 }
16372
16373 if (dictcnt < 1)
16374 {
16375 log_error ("ERROR: No usable dictionary file found.");
16376
16377 return (-1);
16378 }
16379 }
16380 else if (wordlist_mode == WL_MODE_STDIN)
16381 {
16382 dictcnt = 1;
16383 }
16384 }
16385 else if (attack_mode == ATTACK_MODE_COMBI)
16386 {
16387 // display
16388
16389 char *dictfile1 = myargv[optind + 1 + 0];
16390 char *dictfile2 = myargv[optind + 1 + 1];
16391
16392 // find the bigger dictionary and use as base
16393
16394 FILE *fp1 = NULL;
16395 FILE *fp2 = NULL;
16396
16397 struct stat tmp_stat;
16398
16399 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16400 {
16401 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16402
16403 return (-1);
16404 }
16405
16406 if (stat (dictfile1, &tmp_stat) == -1)
16407 {
16408 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16409
16410 fclose (fp1);
16411
16412 return (-1);
16413 }
16414
16415 if (S_ISDIR (tmp_stat.st_mode))
16416 {
16417 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16418
16419 fclose (fp1);
16420
16421 return (-1);
16422 }
16423
16424 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16425 {
16426 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16427
16428 fclose (fp1);
16429
16430 return (-1);
16431 }
16432
16433 if (stat (dictfile2, &tmp_stat) == -1)
16434 {
16435 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16436
16437 fclose (fp1);
16438 fclose (fp2);
16439
16440 return (-1);
16441 }
16442
16443 if (S_ISDIR (tmp_stat.st_mode))
16444 {
16445 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16446
16447 fclose (fp1);
16448 fclose (fp2);
16449
16450 return (-1);
16451 }
16452
16453 data.combs_cnt = 1;
16454
16455 data.quiet = 1;
16456
16457 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16458
16459 data.quiet = quiet;
16460
16461 if (words1_cnt == 0)
16462 {
16463 log_error ("ERROR: %s: empty file", dictfile1);
16464
16465 fclose (fp1);
16466 fclose (fp2);
16467
16468 return (-1);
16469 }
16470
16471 data.combs_cnt = 1;
16472
16473 data.quiet = 1;
16474
16475 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16476
16477 data.quiet = quiet;
16478
16479 if (words2_cnt == 0)
16480 {
16481 log_error ("ERROR: %s: empty file", dictfile2);
16482
16483 fclose (fp1);
16484 fclose (fp2);
16485
16486 return (-1);
16487 }
16488
16489 fclose (fp1);
16490 fclose (fp2);
16491
16492 data.dictfile = dictfile1;
16493 data.dictfile2 = dictfile2;
16494
16495 if (words1_cnt >= words2_cnt)
16496 {
16497 data.combs_cnt = words2_cnt;
16498 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16499
16500 dictfiles = &data.dictfile;
16501
16502 dictcnt = 1;
16503 }
16504 else
16505 {
16506 data.combs_cnt = words1_cnt;
16507 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16508
16509 dictfiles = &data.dictfile2;
16510
16511 dictcnt = 1;
16512
16513 // we also have to switch wordlist related rules!
16514
16515 char *tmpc = data.rule_buf_l;
16516
16517 data.rule_buf_l = data.rule_buf_r;
16518 data.rule_buf_r = tmpc;
16519
16520 int tmpi = data.rule_len_l;
16521
16522 data.rule_len_l = data.rule_len_r;
16523 data.rule_len_r = tmpi;
16524 }
16525 }
16526 else if (attack_mode == ATTACK_MODE_BF)
16527 {
16528 char *mask = NULL;
16529
16530 maskcnt = 0;
16531
16532 if (benchmark == 0)
16533 {
16534 mask = myargv[optind + 1];
16535
16536 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16537
16538 if ((optind + 2) <= myargc)
16539 {
16540 struct stat file_stat;
16541
16542 if (stat (mask, &file_stat) == -1)
16543 {
16544 maskcnt = 1;
16545
16546 masks[maskcnt - 1] = mystrdup (mask);
16547 }
16548 else
16549 {
16550 int wls_left = myargc - (optind + 1);
16551
16552 uint masks_avail = INCR_MASKS;
16553
16554 for (int i = 0; i < wls_left; i++)
16555 {
16556 if (i != 0)
16557 {
16558 mask = myargv[optind + 1 + i];
16559
16560 if (stat (mask, &file_stat) == -1)
16561 {
16562 log_error ("ERROR: %s: %s", mask, strerror (errno));
16563
16564 return (-1);
16565 }
16566 }
16567
16568 uint is_file = S_ISREG (file_stat.st_mode);
16569
16570 if (is_file == 1)
16571 {
16572 FILE *mask_fp;
16573
16574 if ((mask_fp = fopen (mask, "r")) == NULL)
16575 {
16576 log_error ("ERROR: %s: %s", mask, strerror (errno));
16577
16578 return (-1);
16579 }
16580
16581 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16582
16583 while (!feof (mask_fp))
16584 {
16585 memset (line_buf, 0, HCBUFSIZ);
16586
16587 int line_len = fgetl (mask_fp, line_buf);
16588
16589 if (line_len == 0) continue;
16590
16591 if (line_buf[0] == '#') continue;
16592
16593 if (masks_avail == maskcnt)
16594 {
16595 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16596
16597 masks_avail += INCR_MASKS;
16598 }
16599
16600 masks[maskcnt] = mystrdup (line_buf);
16601
16602 maskcnt++;
16603 }
16604
16605 myfree (line_buf);
16606
16607 fclose (mask_fp);
16608 }
16609 else
16610 {
16611 log_error ("ERROR: %s: unsupported file-type", mask);
16612
16613 return (-1);
16614 }
16615 }
16616
16617 mask_from_file = 1;
16618 }
16619 }
16620 else
16621 {
16622 custom_charset_1 = (char *) "?l?d?u";
16623 custom_charset_2 = (char *) "?l?d";
16624 custom_charset_3 = (char *) "?l?d*!$@_";
16625
16626 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16627 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16628 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16629
16630 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16631
16632 wordlist_mode = WL_MODE_MASK;
16633
16634 data.wordlist_mode = wordlist_mode;
16635
16636 increment = 1;
16637
16638 maskcnt = 1;
16639 }
16640 }
16641 else
16642 {
16643 /**
16644 * generate full masks and charsets
16645 */
16646
16647 masks = (char **) mymalloc (sizeof (char *));
16648
16649 switch (hash_mode)
16650 {
16651 case 1731: pw_min = 5;
16652 pw_max = 5;
16653 mask = mystrdup ("?b?b?b?b?b");
16654 break;
16655 case 12500: pw_min = 5;
16656 pw_max = 5;
16657 mask = mystrdup ("?b?b?b?b?b");
16658 break;
16659 default: pw_min = 7;
16660 pw_max = 7;
16661 mask = mystrdup ("?b?b?b?b?b?b?b");
16662 break;
16663 }
16664
16665 maskcnt = 1;
16666
16667 masks[maskcnt - 1] = mystrdup (mask);
16668
16669 wordlist_mode = WL_MODE_MASK;
16670
16671 data.wordlist_mode = wordlist_mode;
16672
16673 increment = 1;
16674 }
16675
16676 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16677
16678 if (increment)
16679 {
16680 if (increment_min > pw_min) pw_min = increment_min;
16681
16682 if (increment_max < pw_max) pw_max = increment_max;
16683 }
16684 }
16685 else if (attack_mode == ATTACK_MODE_HYBRID1)
16686 {
16687 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16688
16689 // display
16690
16691 char *mask = myargv[myargc - 1];
16692
16693 maskcnt = 0;
16694
16695 masks = (char **) mymalloc (1 * sizeof (char *));
16696
16697 // mod
16698
16699 struct stat file_stat;
16700
16701 if (stat (mask, &file_stat) == -1)
16702 {
16703 maskcnt = 1;
16704
16705 masks[maskcnt - 1] = mystrdup (mask);
16706 }
16707 else
16708 {
16709 uint is_file = S_ISREG (file_stat.st_mode);
16710
16711 if (is_file == 1)
16712 {
16713 FILE *mask_fp;
16714
16715 if ((mask_fp = fopen (mask, "r")) == NULL)
16716 {
16717 log_error ("ERROR: %s: %s", mask, strerror (errno));
16718
16719 return (-1);
16720 }
16721
16722 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16723
16724 uint masks_avail = 1;
16725
16726 while (!feof (mask_fp))
16727 {
16728 memset (line_buf, 0, HCBUFSIZ);
16729
16730 int line_len = fgetl (mask_fp, line_buf);
16731
16732 if (line_len == 0) continue;
16733
16734 if (line_buf[0] == '#') continue;
16735
16736 if (masks_avail == maskcnt)
16737 {
16738 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16739
16740 masks_avail += INCR_MASKS;
16741 }
16742
16743 masks[maskcnt] = mystrdup (line_buf);
16744
16745 maskcnt++;
16746 }
16747
16748 myfree (line_buf);
16749
16750 fclose (mask_fp);
16751
16752 mask_from_file = 1;
16753 }
16754 else
16755 {
16756 maskcnt = 1;
16757
16758 masks[maskcnt - 1] = mystrdup (mask);
16759 }
16760 }
16761
16762 // base
16763
16764 int wls_left = myargc - (optind + 2);
16765
16766 for (int i = 0; i < wls_left; i++)
16767 {
16768 char *filename = myargv[optind + 1 + i];
16769
16770 struct stat file_stat;
16771
16772 if (stat (filename, &file_stat) == -1)
16773 {
16774 log_error ("ERROR: %s: %s", filename, strerror (errno));
16775
16776 return (-1);
16777 }
16778
16779 uint is_dir = S_ISDIR (file_stat.st_mode);
16780
16781 if (is_dir == 0)
16782 {
16783 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16784
16785 dictcnt++;
16786
16787 dictfiles[dictcnt - 1] = filename;
16788 }
16789 else
16790 {
16791 // do not allow --keyspace w/ a directory
16792
16793 if (keyspace == 1)
16794 {
16795 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16796
16797 return (-1);
16798 }
16799
16800 char **dictionary_files = NULL;
16801
16802 dictionary_files = scan_directory (filename);
16803
16804 if (dictionary_files != NULL)
16805 {
16806 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16807
16808 for (int d = 0; dictionary_files[d] != NULL; d++)
16809 {
16810 char *l1_filename = dictionary_files[d];
16811
16812 struct stat l1_stat;
16813
16814 if (stat (l1_filename, &l1_stat) == -1)
16815 {
16816 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16817
16818 return (-1);
16819 }
16820
16821 if (S_ISREG (l1_stat.st_mode))
16822 {
16823 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16824
16825 dictcnt++;
16826
16827 dictfiles[dictcnt - 1] = strdup (l1_filename);
16828 }
16829 }
16830 }
16831
16832 local_free (dictionary_files);
16833 }
16834 }
16835
16836 if (dictcnt < 1)
16837 {
16838 log_error ("ERROR: No usable dictionary file found.");
16839
16840 return (-1);
16841 }
16842
16843 if (increment)
16844 {
16845 maskcnt = 0;
16846
16847 uint mask_min = increment_min; // we can't reject smaller masks here
16848 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16849
16850 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16851 {
16852 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16853
16854 if (cur_mask == NULL) break;
16855
16856 masks[maskcnt] = cur_mask;
16857
16858 maskcnt++;
16859
16860 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16861 }
16862 }
16863 }
16864 else if (attack_mode == ATTACK_MODE_HYBRID2)
16865 {
16866 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16867
16868 // display
16869
16870 char *mask = myargv[optind + 1 + 0];
16871
16872 maskcnt = 0;
16873
16874 masks = (char **) mymalloc (1 * sizeof (char *));
16875
16876 // mod
16877
16878 struct stat file_stat;
16879
16880 if (stat (mask, &file_stat) == -1)
16881 {
16882 maskcnt = 1;
16883
16884 masks[maskcnt - 1] = mystrdup (mask);
16885 }
16886 else
16887 {
16888 uint is_file = S_ISREG (file_stat.st_mode);
16889
16890 if (is_file == 1)
16891 {
16892 FILE *mask_fp;
16893
16894 if ((mask_fp = fopen (mask, "r")) == NULL)
16895 {
16896 log_error ("ERROR: %s: %s", mask, strerror (errno));
16897
16898 return (-1);
16899 }
16900
16901 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16902
16903 uint masks_avail = 1;
16904
16905 while (!feof (mask_fp))
16906 {
16907 memset (line_buf, 0, HCBUFSIZ);
16908
16909 int line_len = fgetl (mask_fp, line_buf);
16910
16911 if (line_len == 0) continue;
16912
16913 if (line_buf[0] == '#') continue;
16914
16915 if (masks_avail == maskcnt)
16916 {
16917 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16918
16919 masks_avail += INCR_MASKS;
16920 }
16921
16922 masks[maskcnt] = mystrdup (line_buf);
16923
16924 maskcnt++;
16925 }
16926
16927 myfree (line_buf);
16928
16929 fclose (mask_fp);
16930
16931 mask_from_file = 1;
16932 }
16933 else
16934 {
16935 maskcnt = 1;
16936
16937 masks[maskcnt - 1] = mystrdup (mask);
16938 }
16939 }
16940
16941 // base
16942
16943 int wls_left = myargc - (optind + 2);
16944
16945 for (int i = 0; i < wls_left; i++)
16946 {
16947 char *filename = myargv[optind + 2 + i];
16948
16949 struct stat file_stat;
16950
16951 if (stat (filename, &file_stat) == -1)
16952 {
16953 log_error ("ERROR: %s: %s", filename, strerror (errno));
16954
16955 return (-1);
16956 }
16957
16958 uint is_dir = S_ISDIR (file_stat.st_mode);
16959
16960 if (is_dir == 0)
16961 {
16962 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16963
16964 dictcnt++;
16965
16966 dictfiles[dictcnt - 1] = filename;
16967 }
16968 else
16969 {
16970 // do not allow --keyspace w/ a directory
16971
16972 if (keyspace == 1)
16973 {
16974 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16975
16976 return (-1);
16977 }
16978
16979 char **dictionary_files = NULL;
16980
16981 dictionary_files = scan_directory (filename);
16982
16983 if (dictionary_files != NULL)
16984 {
16985 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16986
16987 for (int d = 0; dictionary_files[d] != NULL; d++)
16988 {
16989 char *l1_filename = dictionary_files[d];
16990
16991 struct stat l1_stat;
16992
16993 if (stat (l1_filename, &l1_stat) == -1)
16994 {
16995 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16996
16997 return (-1);
16998 }
16999
17000 if (S_ISREG (l1_stat.st_mode))
17001 {
17002 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17003
17004 dictcnt++;
17005
17006 dictfiles[dictcnt - 1] = strdup (l1_filename);
17007 }
17008 }
17009 }
17010
17011 local_free (dictionary_files);
17012 }
17013 }
17014
17015 if (dictcnt < 1)
17016 {
17017 log_error ("ERROR: No usable dictionary file found.");
17018
17019 return (-1);
17020 }
17021
17022 if (increment)
17023 {
17024 maskcnt = 0;
17025
17026 uint mask_min = increment_min; // we can't reject smaller masks here
17027 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17028
17029 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17030 {
17031 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17032
17033 if (cur_mask == NULL) break;
17034
17035 masks[maskcnt] = cur_mask;
17036
17037 maskcnt++;
17038
17039 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17040 }
17041 }
17042 }
17043
17044 data.pw_min = pw_min;
17045 data.pw_max = pw_max;
17046
17047 /**
17048 * weak hash check
17049 */
17050
17051 if (weak_hash_threshold >= salts_cnt)
17052 {
17053 hc_device_param_t *device_param = NULL;
17054
17055 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17056 {
17057 device_param = &data.devices_param[device_id];
17058
17059 if (device_param->skipped) continue;
17060
17061 break;
17062 }
17063
17064 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
17065
17066 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
17067 {
17068 weak_hash_check (device_param, salt_pos);
17069 }
17070
17071 // Display hack, guarantee that there is at least one \r before real start
17072
17073 //if (data.quiet == 0) log_info ("");
17074 }
17075
17076 /**
17077 * status and monitor threads
17078 */
17079
17080 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
17081
17082 uint i_threads_cnt = 0;
17083
17084 hc_thread_t *i_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17085
17086 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17087 {
17088 if (stdout_flag == 0)
17089 {
17090 hc_thread_create (i_threads[i_threads_cnt], thread_keypress, &benchmark);
17091
17092 i_threads_cnt++;
17093 }
17094 }
17095
17096 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
17097
17098 uint ni_threads_cnt = 0;
17099
17100 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17101
17102 if (stdout_flag == 0)
17103 {
17104 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
17105
17106 ni_threads_cnt++;
17107 }
17108
17109 /**
17110 * Outfile remove
17111 */
17112
17113 if (keyspace == 0)
17114 {
17115 if (outfile_check_timer != 0)
17116 {
17117 if (data.outfile_check_directory != NULL)
17118 {
17119 if ((hash_mode != 5200) &&
17120 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
17121 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
17122 (hash_mode != 9000))
17123 {
17124 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
17125
17126 ni_threads_cnt++;
17127 }
17128 else
17129 {
17130 outfile_check_timer = 0;
17131 }
17132 }
17133 else
17134 {
17135 outfile_check_timer = 0;
17136 }
17137 }
17138 }
17139
17140 /**
17141 * Inform the user if we got some hashes remove because of the pot file remove feature
17142 */
17143
17144 if (data.quiet == 0)
17145 {
17146 if (potfile_remove_cracks > 0)
17147 {
17148 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
17149 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
17150 }
17151 }
17152
17153 data.outfile_check_timer = outfile_check_timer;
17154
17155 /**
17156 * main loop
17157 */
17158
17159 char **induction_dictionaries = NULL;
17160
17161 int induction_dictionaries_cnt = 0;
17162
17163 hcstat_table_t *root_table_buf = NULL;
17164 hcstat_table_t *markov_table_buf = NULL;
17165
17166 uint initial_restore_done = 0;
17167
17168 data.maskcnt = maskcnt;
17169
17170 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
17171 {
17172 if (data.devices_status == STATUS_CRACKED) break;
17173
17174 data.devices_status = STATUS_INIT;
17175
17176 if (maskpos > rd->maskpos)
17177 {
17178 rd->dictpos = 0;
17179 }
17180
17181 rd->maskpos = maskpos;
17182 data.maskpos = maskpos;
17183
17184 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
17185 {
17186 char *mask = masks[maskpos];
17187
17188 if (mask_from_file == 1)
17189 {
17190 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
17191
17192 char *str_ptr;
17193 uint str_pos;
17194
17195 uint mask_offset = 0;
17196
17197 uint separator_cnt;
17198
17199 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
17200 {
17201 str_ptr = strstr (mask + mask_offset, ",");
17202
17203 if (str_ptr == NULL) break;
17204
17205 str_pos = str_ptr - mask;
17206
17207 // escaped separator, i.e. "\,"
17208
17209 if (str_pos > 0)
17210 {
17211 if (mask[str_pos - 1] == '\\')
17212 {
17213 separator_cnt --;
17214
17215 mask_offset = str_pos + 1;
17216
17217 continue;
17218 }
17219 }
17220
17221 // reset the offset
17222
17223 mask_offset = 0;
17224
17225 mask[str_pos] = '\0';
17226
17227 switch (separator_cnt)
17228 {
17229 case 0:
17230 mp_reset_usr (mp_usr, 0);
17231
17232 custom_charset_1 = mask;
17233 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17234 break;
17235
17236 case 1:
17237 mp_reset_usr (mp_usr, 1);
17238
17239 custom_charset_2 = mask;
17240 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17241 break;
17242
17243 case 2:
17244 mp_reset_usr (mp_usr, 2);
17245
17246 custom_charset_3 = mask;
17247 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17248 break;
17249
17250 case 3:
17251 mp_reset_usr (mp_usr, 3);
17252
17253 custom_charset_4 = mask;
17254 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
17255 break;
17256 }
17257
17258 mask = mask + str_pos + 1;
17259 }
17260 }
17261
17262 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17263 {
17264 if (maskpos > 0)
17265 {
17266 local_free (css_buf);
17267 local_free (data.root_css_buf);
17268 local_free (data.markov_css_buf);
17269
17270 local_free (masks[maskpos - 1]);
17271 }
17272
17273 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17274
17275 data.mask = mask;
17276 data.css_cnt = css_cnt;
17277 data.css_buf = css_buf;
17278
17279 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17280
17281 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17282
17283 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17284 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17285
17286 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17287
17288 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17289
17290 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17291 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17292
17293 data.root_css_buf = root_css_buf;
17294 data.markov_css_buf = markov_css_buf;
17295
17296 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17297
17298 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17299
17300 local_free (root_table_buf);
17301 local_free (markov_table_buf);
17302
17303 // args
17304
17305 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17306 {
17307 hc_device_param_t *device_param = &data.devices_param[device_id];
17308
17309 if (device_param->skipped) continue;
17310
17311 device_param->kernel_params_mp[0] = &device_param->d_combs;
17312 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
17313 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
17314
17315 device_param->kernel_params_mp_buf64[3] = 0;
17316 device_param->kernel_params_mp_buf32[4] = css_cnt;
17317 device_param->kernel_params_mp_buf32[5] = 0;
17318 device_param->kernel_params_mp_buf32[6] = 0;
17319 device_param->kernel_params_mp_buf32[7] = 0;
17320
17321 if (attack_mode == ATTACK_MODE_HYBRID1)
17322 {
17323 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
17324 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
17325 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
17326 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
17327 }
17328 else if (attack_mode == ATTACK_MODE_HYBRID2)
17329 {
17330 device_param->kernel_params_mp_buf32[5] = 0;
17331 device_param->kernel_params_mp_buf32[6] = 0;
17332 device_param->kernel_params_mp_buf32[7] = 0;
17333 }
17334
17335 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]);
17336 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]);
17337 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]);
17338
17339 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);
17340 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);
17341 }
17342 }
17343 else if (attack_mode == ATTACK_MODE_BF)
17344 {
17345 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
17346
17347 if (increment)
17348 {
17349 for (uint i = 0; i < dictcnt; i++)
17350 {
17351 local_free (dictfiles[i]);
17352 }
17353
17354 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17355 {
17356 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17357
17358 if (l1_filename == NULL) break;
17359
17360 dictcnt++;
17361
17362 dictfiles[dictcnt - 1] = l1_filename;
17363 }
17364 }
17365 else
17366 {
17367 dictcnt++;
17368
17369 dictfiles[dictcnt - 1] = mask;
17370 }
17371
17372 if (dictcnt == 0)
17373 {
17374 log_error ("ERROR: Mask is too small");
17375
17376 return (-1);
17377 }
17378 }
17379 }
17380
17381 free (induction_dictionaries);
17382
17383 // induction_dictionaries_cnt = 0; // implied
17384
17385 if (attack_mode != ATTACK_MODE_BF)
17386 {
17387 if (keyspace == 0)
17388 {
17389 induction_dictionaries = scan_directory (induction_directory);
17390
17391 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17392 }
17393 }
17394
17395 if (induction_dictionaries_cnt)
17396 {
17397 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17398 }
17399
17400 /**
17401 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17402 */
17403 if (keyspace == 1)
17404 {
17405 if ((maskcnt > 1) || (dictcnt > 1))
17406 {
17407 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17408
17409 return (-1);
17410 }
17411 }
17412
17413 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17414 {
17415 char *subid = logfile_generate_subid ();
17416
17417 data.subid = subid;
17418
17419 logfile_sub_msg ("START");
17420
17421 data.devices_status = STATUS_INIT;
17422
17423 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17424 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17425 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17426
17427 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17428
17429 data.cpt_pos = 0;
17430
17431 data.cpt_start = time (NULL);
17432
17433 data.cpt_total = 0;
17434
17435 if (data.restore == 0)
17436 {
17437 rd->words_cur = skip;
17438
17439 skip = 0;
17440
17441 data.skip = 0;
17442 }
17443
17444 data.ms_paused = 0;
17445
17446 data.kernel_power_final = 0;
17447
17448 data.words_cur = rd->words_cur;
17449
17450 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17451 {
17452 hc_device_param_t *device_param = &data.devices_param[device_id];
17453
17454 if (device_param->skipped) continue;
17455
17456 device_param->speed_pos = 0;
17457
17458 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17459 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17460
17461 device_param->exec_pos = 0;
17462
17463 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17464
17465 device_param->outerloop_pos = 0;
17466 device_param->outerloop_left = 0;
17467 device_param->innerloop_pos = 0;
17468 device_param->innerloop_left = 0;
17469
17470 // some more resets:
17471
17472 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17473
17474 device_param->pws_cnt = 0;
17475
17476 device_param->words_off = 0;
17477 device_param->words_done = 0;
17478 }
17479
17480 // figure out some workload
17481
17482 if (attack_mode == ATTACK_MODE_STRAIGHT)
17483 {
17484 if (data.wordlist_mode == WL_MODE_FILE)
17485 {
17486 char *dictfile = NULL;
17487
17488 if (induction_dictionaries_cnt)
17489 {
17490 dictfile = induction_dictionaries[0];
17491 }
17492 else
17493 {
17494 dictfile = dictfiles[dictpos];
17495 }
17496
17497 data.dictfile = dictfile;
17498
17499 logfile_sub_string (dictfile);
17500
17501 for (uint i = 0; i < rp_files_cnt; i++)
17502 {
17503 logfile_sub_var_string ("rulefile", rp_files[i]);
17504 }
17505
17506 FILE *fd2 = fopen (dictfile, "rb");
17507
17508 if (fd2 == NULL)
17509 {
17510 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17511
17512 return (-1);
17513 }
17514
17515 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17516
17517 fclose (fd2);
17518
17519 if (data.words_cnt == 0)
17520 {
17521 if (data.devices_status == STATUS_CRACKED) break;
17522 if (data.devices_status == STATUS_ABORTED) break;
17523
17524 dictpos++;
17525
17526 continue;
17527 }
17528 }
17529 }
17530 else if (attack_mode == ATTACK_MODE_COMBI)
17531 {
17532 char *dictfile = data.dictfile;
17533 char *dictfile2 = data.dictfile2;
17534
17535 logfile_sub_string (dictfile);
17536 logfile_sub_string (dictfile2);
17537
17538 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17539 {
17540 FILE *fd2 = fopen (dictfile, "rb");
17541
17542 if (fd2 == NULL)
17543 {
17544 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17545
17546 return (-1);
17547 }
17548
17549 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17550
17551 fclose (fd2);
17552 }
17553 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17554 {
17555 FILE *fd2 = fopen (dictfile2, "rb");
17556
17557 if (fd2 == NULL)
17558 {
17559 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17560
17561 return (-1);
17562 }
17563
17564 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17565
17566 fclose (fd2);
17567 }
17568
17569 if (data.words_cnt == 0)
17570 {
17571 if (data.devices_status == STATUS_CRACKED) break;
17572 if (data.devices_status == STATUS_ABORTED) break;
17573
17574 dictpos++;
17575
17576 continue;
17577 }
17578 }
17579 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17580 {
17581 char *dictfile = NULL;
17582
17583 if (induction_dictionaries_cnt)
17584 {
17585 dictfile = induction_dictionaries[0];
17586 }
17587 else
17588 {
17589 dictfile = dictfiles[dictpos];
17590 }
17591
17592 data.dictfile = dictfile;
17593
17594 char *mask = data.mask;
17595
17596 logfile_sub_string (dictfile);
17597 logfile_sub_string (mask);
17598
17599 FILE *fd2 = fopen (dictfile, "rb");
17600
17601 if (fd2 == NULL)
17602 {
17603 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17604
17605 return (-1);
17606 }
17607
17608 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17609
17610 fclose (fd2);
17611
17612 if (data.words_cnt == 0)
17613 {
17614 if (data.devices_status == STATUS_CRACKED) break;
17615 if (data.devices_status == STATUS_ABORTED) break;
17616
17617 dictpos++;
17618
17619 continue;
17620 }
17621 }
17622 else if (attack_mode == ATTACK_MODE_BF)
17623 {
17624 local_free (css_buf);
17625 local_free (data.root_css_buf);
17626 local_free (data.markov_css_buf);
17627
17628 char *mask = dictfiles[dictpos];
17629
17630 logfile_sub_string (mask);
17631
17632 // base
17633
17634 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17635
17636 if (opts_type & OPTS_TYPE_PT_UNICODE)
17637 {
17638 uint css_cnt_unicode = css_cnt * 2;
17639
17640 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17641
17642 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17643 {
17644 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17645
17646 css_buf_unicode[j + 1].cs_buf[0] = 0;
17647 css_buf_unicode[j + 1].cs_len = 1;
17648 }
17649
17650 free (css_buf);
17651
17652 css_buf = css_buf_unicode;
17653 css_cnt = css_cnt_unicode;
17654 }
17655
17656 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17657
17658 uint mask_min = pw_min;
17659 uint mask_max = pw_max;
17660
17661 if (opts_type & OPTS_TYPE_PT_UNICODE)
17662 {
17663 mask_min *= 2;
17664 mask_max *= 2;
17665 }
17666
17667 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17668 {
17669 if (css_cnt < mask_min)
17670 {
17671 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17672 }
17673
17674 if (css_cnt > mask_max)
17675 {
17676 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17677 }
17678
17679 // skip to next mask
17680
17681 dictpos++;
17682
17683 rd->dictpos = dictpos;
17684
17685 logfile_sub_msg ("STOP");
17686
17687 continue;
17688 }
17689
17690 uint save_css_cnt = css_cnt;
17691
17692 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17693 {
17694 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17695 {
17696 uint salt_len = (uint) data.salts_buf[0].salt_len;
17697 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17698
17699 uint css_cnt_salt = css_cnt + salt_len;
17700
17701 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17702
17703 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17704
17705 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17706 {
17707 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17708 css_buf_salt[j].cs_len = 1;
17709 }
17710
17711 free (css_buf);
17712
17713 css_buf = css_buf_salt;
17714 css_cnt = css_cnt_salt;
17715 }
17716 }
17717
17718 data.mask = mask;
17719 data.css_cnt = css_cnt;
17720 data.css_buf = css_buf;
17721
17722 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17723
17724 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17725
17726 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17727
17728 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17729 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17730
17731 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17732
17733 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17734
17735 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17736 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17737
17738 data.root_css_buf = root_css_buf;
17739 data.markov_css_buf = markov_css_buf;
17740
17741 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17742
17743 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17744
17745 local_free (root_table_buf);
17746 local_free (markov_table_buf);
17747
17748 // copy + args
17749
17750 uint css_cnt_l = css_cnt;
17751 uint css_cnt_r;
17752
17753 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17754 {
17755 if (save_css_cnt < 6)
17756 {
17757 css_cnt_r = 1;
17758 }
17759 else if (save_css_cnt == 6)
17760 {
17761 css_cnt_r = 2;
17762 }
17763 else
17764 {
17765 if (opts_type & OPTS_TYPE_PT_UNICODE)
17766 {
17767 if (save_css_cnt == 8 || save_css_cnt == 10)
17768 {
17769 css_cnt_r = 2;
17770 }
17771 else
17772 {
17773 css_cnt_r = 4;
17774 }
17775 }
17776 else
17777 {
17778 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17779 {
17780 css_cnt_r = 3;
17781 }
17782 else
17783 {
17784 css_cnt_r = 4;
17785 }
17786 }
17787 }
17788 }
17789 else
17790 {
17791 css_cnt_r = 1;
17792
17793 /* unfinished code?
17794 int sum = css_buf[css_cnt_r - 1].cs_len;
17795
17796 for (uint i = 1; i < 4 && i < css_cnt; i++)
17797 {
17798 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17799
17800 css_cnt_r++;
17801
17802 sum *= css_buf[css_cnt_r - 1].cs_len;
17803 }
17804 */
17805 }
17806
17807 css_cnt_l -= css_cnt_r;
17808
17809 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17810
17811 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17812 {
17813 hc_device_param_t *device_param = &data.devices_param[device_id];
17814
17815 if (device_param->skipped) continue;
17816
17817 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17818 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17819 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17820
17821 device_param->kernel_params_mp_l_buf64[3] = 0;
17822 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17823 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17824 device_param->kernel_params_mp_l_buf32[6] = 0;
17825 device_param->kernel_params_mp_l_buf32[7] = 0;
17826 device_param->kernel_params_mp_l_buf32[8] = 0;
17827
17828 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17829 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17830 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17831 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17832
17833 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17834 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17835 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17836
17837 device_param->kernel_params_mp_r_buf64[3] = 0;
17838 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17839 device_param->kernel_params_mp_r_buf32[5] = 0;
17840 device_param->kernel_params_mp_r_buf32[6] = 0;
17841 device_param->kernel_params_mp_r_buf32[7] = 0;
17842
17843 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]);
17844 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]);
17845 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]);
17846
17847 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]);
17848 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]);
17849 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]);
17850
17851 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);
17852 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);
17853 }
17854 }
17855
17856 u64 words_base = data.words_cnt;
17857
17858 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17859 {
17860 if (data.kernel_rules_cnt)
17861 {
17862 words_base /= data.kernel_rules_cnt;
17863 }
17864 }
17865 else if (data.attack_kern == ATTACK_KERN_COMBI)
17866 {
17867 if (data.combs_cnt)
17868 {
17869 words_base /= data.combs_cnt;
17870 }
17871 }
17872 else if (data.attack_kern == ATTACK_KERN_BF)
17873 {
17874 if (data.bfs_cnt)
17875 {
17876 words_base /= data.bfs_cnt;
17877 }
17878 }
17879
17880 data.words_base = words_base;
17881
17882 if (keyspace == 1)
17883 {
17884 log_info ("%llu", (unsigned long long int) words_base);
17885
17886 return (0);
17887 }
17888
17889 if (data.words_cur > data.words_base)
17890 {
17891 log_error ("ERROR: restore value greater keyspace");
17892
17893 return (-1);
17894 }
17895
17896 if (data.words_cur)
17897 {
17898 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17899 {
17900 for (uint i = 0; i < data.salts_cnt; i++)
17901 {
17902 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17903 }
17904 }
17905 else if (data.attack_kern == ATTACK_KERN_COMBI)
17906 {
17907 for (uint i = 0; i < data.salts_cnt; i++)
17908 {
17909 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17910 }
17911 }
17912 else if (data.attack_kern == ATTACK_KERN_BF)
17913 {
17914 for (uint i = 0; i < data.salts_cnt; i++)
17915 {
17916 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17917 }
17918 }
17919 }
17920
17921 /*
17922 * Update loopback file
17923 */
17924
17925 if (loopback == 1)
17926 {
17927 time_t now;
17928
17929 time (&now);
17930
17931 uint random_num = get_random_num (0, 9999);
17932
17933 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17934
17935 data.loopback_file = loopback_file;
17936 }
17937
17938 /*
17939 * Update dictionary statistic
17940 */
17941
17942 if (keyspace == 0)
17943 {
17944 dictstat_fp = fopen (dictstat, "wb");
17945
17946 if (dictstat_fp)
17947 {
17948 lock_file (dictstat_fp);
17949
17950 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17951
17952 fclose (dictstat_fp);
17953 }
17954 }
17955
17956 /**
17957 * create autotune threads
17958 */
17959
17960 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17961
17962 data.devices_status = STATUS_AUTOTUNE;
17963
17964 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17965 {
17966 hc_device_param_t *device_param = &devices_param[device_id];
17967
17968 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
17969 }
17970
17971 hc_thread_wait (data.devices_cnt, c_threads);
17972
17973 /*
17974 * Inform user about possible slow speeds
17975 */
17976
17977 uint hardware_power_all = 0;
17978
17979 uint kernel_power_all = 0;
17980
17981 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17982 {
17983 hc_device_param_t *device_param = &devices_param[device_id];
17984
17985 hardware_power_all += device_param->hardware_power;
17986
17987 kernel_power_all += device_param->kernel_power;
17988 }
17989
17990 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
17991
17992 data.kernel_power_all = kernel_power_all;
17993
17994 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17995 {
17996 if (data.words_base < kernel_power_all)
17997 {
17998 if (quiet == 0)
17999 {
18000 log_info ("ATTENTION!");
18001 log_info (" The wordlist or mask you are using is too small.");
18002 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
18003 log_info (" The cracking speed will drop.");
18004 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
18005 log_info ("");
18006 }
18007 }
18008 }
18009
18010 /**
18011 * create cracker threads
18012 */
18013
18014 data.devices_status = STATUS_RUNNING;
18015
18016 if (initial_restore_done == 0)
18017 {
18018 if (data.restore_disable == 0) cycle_restore ();
18019
18020 initial_restore_done = 1;
18021 }
18022
18023 hc_timer_set (&data.timer_running);
18024
18025 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18026 {
18027 if ((quiet == 0) && (status == 0) && (benchmark == 0))
18028 {
18029 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
18030 if (quiet == 0) fflush (stdout);
18031 }
18032 }
18033 else if (wordlist_mode == WL_MODE_STDIN)
18034 {
18035 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
18036 if (data.quiet == 0) log_info ("");
18037 }
18038
18039 time_t runtime_start;
18040
18041 time (&runtime_start);
18042
18043 data.runtime_start = runtime_start;
18044
18045 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18046 {
18047 hc_device_param_t *device_param = &devices_param[device_id];
18048
18049 if (wordlist_mode == WL_MODE_STDIN)
18050 {
18051 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
18052 }
18053 else
18054 {
18055 hc_thread_create (c_threads[device_id], thread_calc, device_param);
18056 }
18057 }
18058
18059 hc_thread_wait (data.devices_cnt, c_threads);
18060
18061 local_free (c_threads);
18062
18063 data.restore = 0;
18064
18065 // finalize task
18066
18067 logfile_sub_var_uint ("status-after-work", data.devices_status);
18068
18069 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18070
18071 if (data.devices_status == STATUS_CRACKED) break;
18072 if (data.devices_status == STATUS_ABORTED) break;
18073
18074 if (data.devices_status == STATUS_BYPASS)
18075 {
18076 data.devices_status = STATUS_RUNNING;
18077 }
18078
18079 if (induction_dictionaries_cnt)
18080 {
18081 unlink (induction_dictionaries[0]);
18082 }
18083
18084 free (induction_dictionaries);
18085
18086 if (attack_mode != ATTACK_MODE_BF)
18087 {
18088 induction_dictionaries = scan_directory (induction_directory);
18089
18090 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18091 }
18092
18093 if (benchmark == 0)
18094 {
18095 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
18096 {
18097 if (quiet == 0) clear_prompt ();
18098
18099 if (quiet == 0) log_info ("");
18100
18101 if (status == 1)
18102 {
18103 status_display ();
18104 }
18105 else
18106 {
18107 if (quiet == 0) status_display ();
18108 }
18109
18110 if (quiet == 0) log_info ("");
18111 }
18112 }
18113
18114 if (attack_mode == ATTACK_MODE_BF)
18115 {
18116 dictpos++;
18117
18118 rd->dictpos = dictpos;
18119 }
18120 else
18121 {
18122 if (induction_dictionaries_cnt)
18123 {
18124 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18125 }
18126 else
18127 {
18128 dictpos++;
18129
18130 rd->dictpos = dictpos;
18131 }
18132 }
18133
18134 time_t runtime_stop;
18135
18136 time (&runtime_stop);
18137
18138 data.runtime_stop = runtime_stop;
18139
18140 logfile_sub_uint (runtime_start);
18141 logfile_sub_uint (runtime_stop);
18142
18143 logfile_sub_msg ("STOP");
18144
18145 global_free (subid);
18146 }
18147
18148 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18149
18150 if (data.devices_status == STATUS_CRACKED) break;
18151 if (data.devices_status == STATUS_ABORTED) break;
18152 if (data.devices_status == STATUS_QUIT) break;
18153
18154 if (data.devices_status == STATUS_BYPASS)
18155 {
18156 data.devices_status = STATUS_RUNNING;
18157 }
18158 }
18159
18160 // 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
18161
18162 if (attack_mode == ATTACK_MODE_STRAIGHT)
18163 {
18164 if (data.wordlist_mode == WL_MODE_FILE)
18165 {
18166 if (data.dictfile == NULL)
18167 {
18168 if (dictfiles != NULL)
18169 {
18170 data.dictfile = dictfiles[0];
18171
18172 hc_timer_set (&data.timer_running);
18173 }
18174 }
18175 }
18176 }
18177 // NOTE: combi is okay because it is already set beforehand
18178 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
18179 {
18180 if (data.dictfile == NULL)
18181 {
18182 if (dictfiles != NULL)
18183 {
18184 hc_timer_set (&data.timer_running);
18185
18186 data.dictfile = dictfiles[0];
18187 }
18188 }
18189 }
18190 else if (attack_mode == ATTACK_MODE_BF)
18191 {
18192 if (data.mask == NULL)
18193 {
18194 hc_timer_set (&data.timer_running);
18195
18196 data.mask = masks[0];
18197 }
18198 }
18199
18200 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18201 {
18202 data.devices_status = STATUS_EXHAUSTED;
18203 }
18204
18205 // if cracked / aborted remove last induction dictionary
18206
18207 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
18208 {
18209 struct stat induct_stat;
18210
18211 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
18212 {
18213 unlink (induction_dictionaries[file_pos]);
18214 }
18215 }
18216
18217 // wait for non-interactive threads
18218
18219 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
18220 {
18221 hc_thread_wait (1, &ni_threads[thread_idx]);
18222 }
18223
18224 local_free (ni_threads);
18225
18226 // wait for interactive threads
18227
18228 for (uint thread_idx = 0; thread_idx < i_threads_cnt; thread_idx++)
18229 {
18230 hc_thread_wait (1, &i_threads[thread_idx]);
18231 }
18232
18233 local_free (i_threads);
18234
18235 // we dont need restore file anymore
18236 if (data.restore_disable == 0)
18237 {
18238 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
18239 {
18240 unlink (eff_restore_file);
18241 unlink (new_restore_file);
18242 }
18243 else
18244 {
18245 cycle_restore ();
18246 }
18247 }
18248
18249 // finally save left hashes
18250
18251 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
18252 {
18253 save_hash ();
18254 }
18255
18256 /**
18257 * Clean up
18258 */
18259
18260 if (benchmark == 1)
18261 {
18262 status_benchmark ();
18263
18264 if (machine_readable == 0)
18265 {
18266 log_info ("");
18267 }
18268 }
18269 else
18270 {
18271 if (quiet == 0) clear_prompt ();
18272
18273 if (quiet == 0) log_info ("");
18274
18275 if (status == 1)
18276 {
18277 status_display ();
18278 }
18279 else
18280 {
18281 if (quiet == 0) status_display ();
18282 }
18283
18284 if (quiet == 0) log_info ("");
18285 }
18286
18287 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18288 {
18289 hc_device_param_t *device_param = &data.devices_param[device_id];
18290
18291 if (device_param->skipped) continue;
18292
18293 local_free (device_param->combs_buf);
18294
18295 local_free (device_param->hooks_buf);
18296
18297 local_free (device_param->device_name);
18298
18299 local_free (device_param->device_name_chksum);
18300
18301 local_free (device_param->device_version);
18302
18303 local_free (device_param->driver_version);
18304
18305 if (device_param->pws_buf) myfree (device_param->pws_buf);
18306 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
18307 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
18308 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
18309 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
18310 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
18311 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
18312 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
18313 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
18314 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
18315 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
18316 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
18317 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
18318 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
18319 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
18320 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
18321 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
18322 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
18323 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
18324 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
18325 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
18326 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
18327 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
18328 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
18329 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
18330 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
18331 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
18332 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
18333 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
18334
18335 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
18336 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
18337 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
18338 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
18339 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
18340 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
18341 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
18342 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
18343 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
18344 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
18345 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
18346
18347 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
18348 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
18349 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
18350
18351 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
18352 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
18353 }
18354
18355 // reset default fan speed
18356
18357 #ifdef HAVE_HWMON
18358 if (gpu_temp_disable == 0)
18359 {
18360 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
18361 {
18362 hc_thread_mutex_lock (mux_adl);
18363
18364 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18365 {
18366 hc_device_param_t *device_param = &data.devices_param[device_id];
18367
18368 if (device_param->skipped) continue;
18369
18370 if (data.hm_device[device_id].fan_set_supported == 1)
18371 {
18372 int fanspeed = temp_retain_fanspeed_value[device_id];
18373 int fanpolicy = temp_retain_fanpolicy_value[device_id];
18374
18375 if (fanpolicy == 1)
18376 {
18377 int rc = -1;
18378
18379 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18380 {
18381 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
18382 }
18383 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18384 {
18385 #ifdef _POSIX
18386 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE);
18387 #endif
18388 }
18389
18390 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18391 }
18392 }
18393 }
18394
18395 hc_thread_mutex_unlock (mux_adl);
18396 }
18397 }
18398
18399 // reset power tuning
18400
18401 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
18402 {
18403 hc_thread_mutex_lock (mux_adl);
18404
18405 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18406 {
18407 hc_device_param_t *device_param = &data.devices_param[device_id];
18408
18409 if (device_param->skipped) continue;
18410
18411 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18412 {
18413 if (data.hm_device[device_id].od_version == 6)
18414 {
18415 // check powertune capabilities first, if not available then skip device
18416
18417 int powertune_supported = 0;
18418
18419 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18420 {
18421 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18422
18423 return (-1);
18424 }
18425
18426 if (powertune_supported != 0)
18427 {
18428 // powercontrol settings
18429
18430 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18431 {
18432 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18433
18434 return (-1);
18435 }
18436
18437 // clocks
18438
18439 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18440
18441 performance_state->iNumberOfPerformanceLevels = 2;
18442
18443 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18444 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18445 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18446 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18447
18448 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18449 {
18450 log_info ("ERROR: Failed to restore ADL performance state");
18451
18452 return (-1);
18453 }
18454
18455 local_free (performance_state);
18456 }
18457 }
18458 }
18459
18460 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18461 {
18462 unsigned int limit = nvml_power_limit[device_id];
18463
18464 if (limit > 0)
18465 {
18466 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18467 }
18468 }
18469 }
18470
18471 hc_thread_mutex_unlock (mux_adl);
18472 }
18473
18474 if (gpu_temp_disable == 0)
18475 {
18476 if (data.hm_nvml)
18477 {
18478 hm_NVML_nvmlShutdown (data.hm_nvml);
18479
18480 nvml_close (data.hm_nvml);
18481
18482 data.hm_nvml = NULL;
18483 }
18484
18485 if (data.hm_nvapi)
18486 {
18487 hm_NvAPI_Unload (data.hm_nvapi);
18488
18489 nvapi_close (data.hm_nvapi);
18490
18491 data.hm_nvapi = NULL;
18492 }
18493
18494 if (data.hm_xnvctrl)
18495 {
18496 hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);
18497
18498 xnvctrl_close (data.hm_xnvctrl);
18499
18500 data.hm_xnvctrl = NULL;
18501 }
18502
18503 if (data.hm_adl)
18504 {
18505 hm_ADL_Main_Control_Destroy (data.hm_adl);
18506
18507 adl_close (data.hm_adl);
18508
18509 data.hm_adl = NULL;
18510 }
18511 }
18512 #endif // HAVE_HWMON
18513
18514 // free memory
18515
18516 local_free (masks);
18517
18518 local_free (dictstat_base);
18519
18520 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18521 {
18522 pot_t *pot_ptr = &pot[pot_pos];
18523
18524 hash_t *hash = &pot_ptr->hash;
18525
18526 local_free (hash->digest);
18527
18528 if (isSalted)
18529 {
18530 local_free (hash->salt);
18531 }
18532 }
18533
18534 local_free (pot);
18535
18536 local_free (all_kernel_rules_cnt);
18537 local_free (all_kernel_rules_buf);
18538
18539 local_free (wl_data->buf);
18540 local_free (wl_data);
18541
18542 local_free (bitmap_s1_a);
18543 local_free (bitmap_s1_b);
18544 local_free (bitmap_s1_c);
18545 local_free (bitmap_s1_d);
18546 local_free (bitmap_s2_a);
18547 local_free (bitmap_s2_b);
18548 local_free (bitmap_s2_c);
18549 local_free (bitmap_s2_d);
18550
18551 #ifdef HAVE_HWMON
18552 local_free (temp_retain_fanspeed_value);
18553 local_free (od_clock_mem_status);
18554 local_free (od_power_control_status);
18555 local_free (nvml_power_limit);
18556 #endif
18557
18558 global_free (devices_param);
18559
18560 global_free (kernel_rules_buf);
18561
18562 global_free (root_css_buf);
18563 global_free (markov_css_buf);
18564
18565 global_free (digests_buf);
18566 global_free (digests_shown);
18567 global_free (digests_shown_tmp);
18568
18569 global_free (salts_buf);
18570 global_free (salts_shown);
18571
18572 global_free (esalts_buf);
18573
18574 global_free (words_progress_done);
18575 global_free (words_progress_rejected);
18576 global_free (words_progress_restored);
18577
18578 if (pot_fp) fclose (pot_fp);
18579
18580 if (data.devices_status == STATUS_QUIT) break;
18581 }
18582
18583 // destroy others mutex
18584
18585 hc_thread_mutex_delete (mux_dispatcher);
18586 hc_thread_mutex_delete (mux_counter);
18587 hc_thread_mutex_delete (mux_display);
18588 hc_thread_mutex_delete (mux_adl);
18589
18590 // free memory
18591
18592 local_free (eff_restore_file);
18593 local_free (new_restore_file);
18594
18595 local_free (rd);
18596
18597 // tuning db
18598
18599 tuning_db_destroy (tuning_db);
18600
18601 // loopback
18602
18603 local_free (loopback_file);
18604
18605 if (loopback == 1) unlink (loopback_file);
18606
18607 // induction directory
18608
18609 if (induction_dir == NULL)
18610 {
18611 if (attack_mode != ATTACK_MODE_BF)
18612 {
18613 if (rmdir (induction_directory) == -1)
18614 {
18615 if (errno == ENOENT)
18616 {
18617 // good, we can ignore
18618 }
18619 else if (errno == ENOTEMPTY)
18620 {
18621 // good, we can ignore
18622 }
18623 else
18624 {
18625 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18626
18627 return (-1);
18628 }
18629 }
18630
18631 local_free (induction_directory);
18632 }
18633 }
18634
18635 // outfile-check directory
18636
18637 if (outfile_check_dir == NULL)
18638 {
18639 if (rmdir (outfile_check_directory) == -1)
18640 {
18641 if (errno == ENOENT)
18642 {
18643 // good, we can ignore
18644 }
18645 else if (errno == ENOTEMPTY)
18646 {
18647 // good, we can ignore
18648 }
18649 else
18650 {
18651 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18652
18653 return (-1);
18654 }
18655 }
18656
18657 local_free (outfile_check_directory);
18658 }
18659
18660 time_t proc_stop;
18661
18662 time (&proc_stop);
18663
18664 logfile_top_uint (proc_start);
18665 logfile_top_uint (proc_stop);
18666
18667 logfile_top_msg ("STOP");
18668
18669 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18670 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18671
18672 if (data.ocl) ocl_close (data.ocl);
18673
18674 if (data.devices_status == STATUS_ABORTED) return 2;
18675 if (data.devices_status == STATUS_QUIT) return 2;
18676 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18677 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18678 if (data.devices_status == STATUS_CRACKED) return 0;
18679
18680 return -1;
18681 }
Hashcat additions to support pwdhash