projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Added --gpu-temp-retain support for windows through nvapi
[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 _WIN
4239 hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1);
4240 #endif
4241
4242 #ifdef _LINUX
4243 hm_set_fanspeed_with_device_id_xnvctrl (device_id, fan_speed_new);
4244 #endif
4245 }
4246
4247 fan_speed_chgd[device_id] = 1;
4248 }
4249
4250 temp_diff_old[device_id] = temp_diff_new;
4251 }
4252 }
4253 }
4254 }
4255 }
4256
4257 hc_thread_mutex_unlock (mux_adl);
4258 }
4259 #endif // HAVE_HWMON
4260
4261 if (restore_check == 1)
4262 {
4263 restore_left--;
4264
4265 if (restore_left == 0)
4266 {
4267 if (data.restore_disable == 0) cycle_restore ();
4268
4269 restore_left = data.restore_timer;
4270 }
4271 }
4272
4273 if ((runtime_check == 1) && (data.runtime_start > 0))
4274 {
4275 time_t runtime_cur;
4276
4277 time (&runtime_cur);
4278
4279 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4280
4281 if (runtime_left <= 0)
4282 {
4283 if (data.benchmark == 0)
4284 {
4285 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4286 }
4287
4288 if (data.devices_status != STATUS_QUIT) myabort ();
4289 }
4290 }
4291
4292 if (remove_check == 1)
4293 {
4294 remove_left--;
4295
4296 if (remove_left == 0)
4297 {
4298 if (data.digests_saved != data.digests_done)
4299 {
4300 data.digests_saved = data.digests_done;
4301
4302 save_hash ();
4303 }
4304
4305 remove_left = data.remove_timer;
4306 }
4307 }
4308
4309 if (status_check == 1)
4310 {
4311 status_left--;
4312
4313 if (status_left == 0)
4314 {
4315 //hc_thread_mutex_lock (mux_display);
4316
4317 if (data.quiet == 0) clear_prompt ();
4318
4319 if (data.quiet == 0) log_info ("");
4320
4321 status_display ();
4322
4323 if (data.quiet == 0) log_info ("");
4324
4325 //hc_thread_mutex_unlock (mux_display);
4326
4327 status_left = data.status_timer;
4328 }
4329 }
4330 }
4331
4332 #ifdef HAVE_HWMON
4333 myfree (fan_speed_chgd);
4334
4335 myfree (temp_diff_old);
4336 myfree (temp_diff_sum);
4337 #endif
4338
4339 p = NULL;
4340
4341 return (p);
4342 }
4343
4344 static void *thread_outfile_remove (void *p)
4345 {
4346 // some hash-dependent constants
4347 char *outfile_dir = data.outfile_check_directory;
4348 uint dgst_size = data.dgst_size;
4349 uint isSalted = data.isSalted;
4350 uint esalt_size = data.esalt_size;
4351 uint hash_mode = data.hash_mode;
4352
4353 uint outfile_check_timer = data.outfile_check_timer;
4354
4355 char separator = data.separator;
4356
4357 // some hash-dependent functions
4358 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4359 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4360
4361 // buffers
4362 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4363
4364 hash_buf.digest = mymalloc (dgst_size);
4365
4366 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4367
4368 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4369
4370 uint digest_buf[64] = { 0 };
4371
4372 outfile_data_t *out_info = NULL;
4373
4374 char **out_files = NULL;
4375
4376 time_t folder_mtime = 0;
4377
4378 int out_cnt = 0;
4379
4380 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4381
4382 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4383 {
4384 hc_sleep (1);
4385
4386 if (data.devices_status != STATUS_RUNNING) continue;
4387
4388 check_left--;
4389
4390 if (check_left == 0)
4391 {
4392 struct stat outfile_check_stat;
4393
4394 if (stat (outfile_dir, &outfile_check_stat) == 0)
4395 {
4396 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4397
4398 if (is_dir == 1)
4399 {
4400 if (outfile_check_stat.st_mtime > folder_mtime)
4401 {
4402 char **out_files_new = scan_directory (outfile_dir);
4403
4404 int out_cnt_new = count_dictionaries (out_files_new);
4405
4406 outfile_data_t *out_info_new = NULL;
4407
4408 if (out_cnt_new > 0)
4409 {
4410 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4411
4412 for (int i = 0; i < out_cnt_new; i++)
4413 {
4414 out_info_new[i].file_name = out_files_new[i];
4415
4416 // check if there are files that we have seen/checked before (and not changed)
4417
4418 for (int j = 0; j < out_cnt; j++)
4419 {
4420 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4421 {
4422 struct stat outfile_stat;
4423
4424 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4425 {
4426 if (outfile_stat.st_ctime == out_info[j].ctime)
4427 {
4428 out_info_new[i].ctime = out_info[j].ctime;
4429 out_info_new[i].seek = out_info[j].seek;
4430 }
4431 }
4432 }
4433 }
4434 }
4435 }
4436
4437 local_free (out_info);
4438 local_free (out_files);
4439
4440 out_files = out_files_new;
4441 out_cnt = out_cnt_new;
4442 out_info = out_info_new;
4443
4444 folder_mtime = outfile_check_stat.st_mtime;
4445 }
4446
4447 for (int j = 0; j < out_cnt; j++)
4448 {
4449 FILE *fp = fopen (out_info[j].file_name, "rb");
4450
4451 if (fp != NULL)
4452 {
4453 //hc_thread_mutex_lock (mux_display);
4454
4455 #ifdef _POSIX
4456 struct stat outfile_stat;
4457
4458 fstat (fileno (fp), &outfile_stat);
4459 #endif
4460
4461 #ifdef _WIN
4462 struct stat64 outfile_stat;
4463
4464 _fstat64 (fileno (fp), &outfile_stat);
4465 #endif
4466
4467 if (outfile_stat.st_ctime > out_info[j].ctime)
4468 {
4469 out_info[j].ctime = outfile_stat.st_ctime;
4470 out_info[j].seek = 0;
4471 }
4472
4473 fseek (fp, out_info[j].seek, SEEK_SET);
4474
4475 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4476
4477 while (!feof (fp))
4478 {
4479 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4480
4481 if (ptr == NULL) break;
4482
4483 int line_len = strlen (line_buf);
4484
4485 if (line_len <= 0) continue;
4486
4487 int iter = MAX_CUT_TRIES;
4488
4489 for (uint i = line_len - 1; i && iter; i--, line_len--)
4490 {
4491 if (line_buf[i] != separator) continue;
4492
4493 int parser_status = PARSER_OK;
4494
4495 if ((hash_mode != 2500) && (hash_mode != 6800))
4496 {
4497 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4498 }
4499
4500 uint found = 0;
4501
4502 if (parser_status == PARSER_OK)
4503 {
4504 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4505 {
4506 if (data.salts_shown[salt_pos] == 1) continue;
4507
4508 salt_t *salt_buf = &data.salts_buf[salt_pos];
4509
4510 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4511 {
4512 uint idx = salt_buf->digests_offset + digest_pos;
4513
4514 if (data.digests_shown[idx] == 1) continue;
4515
4516 uint cracked = 0;
4517
4518 if (hash_mode == 6800)
4519 {
4520 if (i == salt_buf->salt_len)
4521 {
4522 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4523 }
4524 }
4525 else if (hash_mode == 2500)
4526 {
4527 // BSSID : MAC1 : MAC2 (:plain)
4528 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4529 {
4530 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4531
4532 if (!cracked) continue;
4533
4534 // now compare MAC1 and MAC2 too, since we have this additional info
4535 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4536 char *mac2_pos = mac1_pos + 12 + 1;
4537
4538 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4539 wpa_t *wpa = &wpas[salt_pos];
4540
4541 // compare hex string(s) vs binary MAC address(es)
4542
4543 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4544 {
4545 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4546 {
4547 cracked = 0;
4548
4549 break;
4550 }
4551 }
4552
4553 // early skip ;)
4554 if (!cracked) continue;
4555
4556 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4557 {
4558 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4559 {
4560 cracked = 0;
4561
4562 break;
4563 }
4564 }
4565 }
4566 }
4567 else
4568 {
4569 char *digests_buf_ptr = (char *) data.digests_buf;
4570
4571 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4572
4573 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4574 }
4575
4576 if (cracked == 1)
4577 {
4578 found = 1;
4579
4580 data.digests_shown[idx] = 1;
4581
4582 data.digests_done++;
4583
4584 salt_buf->digests_done++;
4585
4586 if (salt_buf->digests_done == salt_buf->digests_cnt)
4587 {
4588 data.salts_shown[salt_pos] = 1;
4589
4590 data.salts_done++;
4591
4592 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4593 }
4594 }
4595 }
4596
4597 if (data.devices_status == STATUS_CRACKED) break;
4598 }
4599 }
4600
4601 if (found) break;
4602
4603 if (data.devices_status == STATUS_CRACKED) break;
4604
4605 iter--;
4606 }
4607
4608 if (data.devices_status == STATUS_CRACKED) break;
4609 }
4610
4611 myfree (line_buf);
4612
4613 out_info[j].seek = ftell (fp);
4614
4615 //hc_thread_mutex_unlock (mux_display);
4616
4617 fclose (fp);
4618 }
4619 }
4620 }
4621 }
4622
4623 check_left = outfile_check_timer;
4624 }
4625 }
4626
4627 if (esalt_size) local_free (hash_buf.esalt);
4628
4629 if (isSalted) local_free (hash_buf.salt);
4630
4631 local_free (hash_buf.digest);
4632
4633 local_free (out_info);
4634
4635 local_free (out_files);
4636
4637 p = NULL;
4638
4639 return (p);
4640 }
4641
4642 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4643 {
4644 //if (device_param->pws_cnt < device_param->kernel_power)
4645 //{
4646 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4647
4648 u8 *ptr = (u8 *) pw->i;
4649
4650 memcpy (ptr, pw_buf, pw_len);
4651
4652 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4653
4654 pw->pw_len = pw_len;
4655
4656 device_param->pws_cnt++;
4657 //}
4658 //else
4659 //{
4660 // fprintf (stderr, "BUG pw_add()!!\n");
4661 //
4662 // return;
4663 //}
4664 }
4665
4666 static void set_kernel_power_final (const u64 kernel_power_final)
4667 {
4668 if (data.quiet == 0)
4669 {
4670 clear_prompt ();
4671
4672 //log_info ("");
4673
4674 log_info ("INFO: approaching final keyspace, workload adjusted");
4675 log_info ("");
4676
4677 fprintf (stdout, "%s", PROMPT);
4678
4679 fflush (stdout);
4680 }
4681
4682 data.kernel_power_final = kernel_power_final;
4683 }
4684
4685 static u32 get_power (hc_device_param_t *device_param)
4686 {
4687 const u64 kernel_power_final = data.kernel_power_final;
4688
4689 if (kernel_power_final)
4690 {
4691 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4692
4693 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4694
4695 // work should be at least the hardware power available without any accelerator
4696
4697 const u64 work = MAX (words_left_device, device_param->hardware_power);
4698
4699 return work;
4700 }
4701
4702 return device_param->kernel_power;
4703 }
4704
4705 static uint get_work (hc_device_param_t *device_param, const u64 max)
4706 {
4707 hc_thread_mutex_lock (mux_dispatcher);
4708
4709 const u64 words_cur = data.words_cur;
4710 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4711
4712 device_param->words_off = words_cur;
4713
4714 const u64 kernel_power_all = data.kernel_power_all;
4715
4716 const u64 words_left = words_base - words_cur;
4717
4718 if (words_left < kernel_power_all)
4719 {
4720 if (data.kernel_power_final == 0)
4721 {
4722 set_kernel_power_final (words_left);
4723 }
4724 }
4725
4726 const u32 kernel_power = get_power (device_param);
4727
4728 uint work = MIN (words_left, kernel_power);
4729
4730 work = MIN (work, max);
4731
4732 data.words_cur += work;
4733
4734 hc_thread_mutex_unlock (mux_dispatcher);
4735
4736 return work;
4737 }
4738
4739 static void *thread_autotune (void *p)
4740 {
4741 hc_device_param_t *device_param = (hc_device_param_t *) p;
4742
4743 if (device_param->skipped) return NULL;
4744
4745 autotune (device_param);
4746
4747 return NULL;
4748 }
4749
4750 static void *thread_calc_stdin (void *p)
4751 {
4752 hc_device_param_t *device_param = (hc_device_param_t *) p;
4753
4754 if (device_param->skipped) return NULL;
4755
4756 char *buf = (char *) mymalloc (HCBUFSIZ);
4757
4758 const uint attack_kern = data.attack_kern;
4759
4760 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4761 {
4762 hc_thread_mutex_lock (mux_dispatcher);
4763
4764 if (feof (stdin) != 0)
4765 {
4766 hc_thread_mutex_unlock (mux_dispatcher);
4767
4768 break;
4769 }
4770
4771 uint words_cur = 0;
4772
4773 while (words_cur < device_param->kernel_power)
4774 {
4775 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4776
4777 if (line_buf == NULL) break;
4778
4779 uint line_len = in_superchop (line_buf);
4780
4781 line_len = convert_from_hex (line_buf, line_len);
4782
4783 // post-process rule engine
4784
4785 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4786 {
4787 char rule_buf_out[BLOCK_SIZE] = { 0 };
4788
4789 int rule_len_out = -1;
4790
4791 if (line_len < BLOCK_SIZE)
4792 {
4793 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4794 }
4795
4796 if (rule_len_out < 0) continue;
4797
4798 line_buf = rule_buf_out;
4799 line_len = rule_len_out;
4800 }
4801
4802 if (line_len > PW_MAX)
4803 {
4804 continue;
4805 }
4806
4807 // hmm that's always the case, or?
4808
4809 if (attack_kern == ATTACK_KERN_STRAIGHT)
4810 {
4811 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4812 {
4813 hc_thread_mutex_lock (mux_counter);
4814
4815 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4816 {
4817 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4818 }
4819
4820 hc_thread_mutex_unlock (mux_counter);
4821
4822 continue;
4823 }
4824 }
4825
4826 pw_add (device_param, (u8 *) line_buf, line_len);
4827
4828 words_cur++;
4829
4830 if (data.devices_status == STATUS_CRACKED) break;
4831 if (data.devices_status == STATUS_ABORTED) break;
4832 if (data.devices_status == STATUS_QUIT) break;
4833 if (data.devices_status == STATUS_BYPASS) break;
4834 }
4835
4836 hc_thread_mutex_unlock (mux_dispatcher);
4837
4838 if (data.devices_status == STATUS_CRACKED) break;
4839 if (data.devices_status == STATUS_ABORTED) break;
4840 if (data.devices_status == STATUS_QUIT) break;
4841 if (data.devices_status == STATUS_BYPASS) break;
4842
4843 // flush
4844
4845 const uint pws_cnt = device_param->pws_cnt;
4846
4847 if (pws_cnt)
4848 {
4849 run_copy (device_param, pws_cnt);
4850
4851 run_cracker (device_param, pws_cnt);
4852
4853 device_param->pws_cnt = 0;
4854
4855 /*
4856 still required?
4857 if (attack_kern == ATTACK_KERN_STRAIGHT)
4858 {
4859 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4860 }
4861 else if (attack_kern == ATTACK_KERN_COMBI)
4862 {
4863 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4864 }
4865 */
4866 }
4867 }
4868
4869 device_param->kernel_accel = 0;
4870 device_param->kernel_loops = 0;
4871
4872 myfree (buf);
4873
4874 return NULL;
4875 }
4876
4877 static void *thread_calc (void *p)
4878 {
4879 hc_device_param_t *device_param = (hc_device_param_t *) p;
4880
4881 if (device_param->skipped) return NULL;
4882
4883 const uint attack_mode = data.attack_mode;
4884 const uint attack_kern = data.attack_kern;
4885
4886 if (attack_mode == ATTACK_MODE_BF)
4887 {
4888 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4889 {
4890 const uint work = get_work (device_param, -1);
4891
4892 if (work == 0) break;
4893
4894 const u64 words_off = device_param->words_off;
4895 const u64 words_fin = words_off + work;
4896
4897 const uint pws_cnt = work;
4898
4899 device_param->pws_cnt = pws_cnt;
4900
4901 if (pws_cnt)
4902 {
4903 run_copy (device_param, pws_cnt);
4904
4905 run_cracker (device_param, pws_cnt);
4906
4907 device_param->pws_cnt = 0;
4908
4909 /*
4910 still required?
4911 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4912 */
4913 }
4914
4915 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4916
4917 if (data.devices_status == STATUS_CRACKED) break;
4918 if (data.devices_status == STATUS_ABORTED) break;
4919 if (data.devices_status == STATUS_QUIT) break;
4920 if (data.devices_status == STATUS_BYPASS) break;
4921
4922 if (data.benchmark == 1) break;
4923
4924 device_param->words_done = words_fin;
4925 }
4926 }
4927 else
4928 {
4929 const uint segment_size = data.segment_size;
4930
4931 char *dictfile = data.dictfile;
4932
4933 if (attack_mode == ATTACK_MODE_COMBI)
4934 {
4935 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4936 {
4937 dictfile = data.dictfile2;
4938 }
4939 }
4940
4941 FILE *fd = fopen (dictfile, "rb");
4942
4943 if (fd == NULL)
4944 {
4945 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4946
4947 return NULL;
4948 }
4949
4950 if (attack_mode == ATTACK_MODE_COMBI)
4951 {
4952 const uint combs_mode = data.combs_mode;
4953
4954 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4955 {
4956 const char *dictfilec = data.dictfile2;
4957
4958 FILE *combs_fp = fopen (dictfilec, "rb");
4959
4960 if (combs_fp == NULL)
4961 {
4962 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4963
4964 fclose (fd);
4965
4966 return NULL;
4967 }
4968
4969 device_param->combs_fp = combs_fp;
4970 }
4971 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4972 {
4973 const char *dictfilec = data.dictfile;
4974
4975 FILE *combs_fp = fopen (dictfilec, "rb");
4976
4977 if (combs_fp == NULL)
4978 {
4979 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4980
4981 fclose (fd);
4982
4983 return NULL;
4984 }
4985
4986 device_param->combs_fp = combs_fp;
4987 }
4988 }
4989
4990 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4991
4992 wl_data->buf = (char *) mymalloc (segment_size);
4993 wl_data->avail = segment_size;
4994 wl_data->incr = segment_size;
4995 wl_data->cnt = 0;
4996 wl_data->pos = 0;
4997
4998 u64 words_cur = 0;
4999
5000 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5001 {
5002 u64 words_off = 0;
5003 u64 words_fin = 0;
5004
5005 u64 max = -1;
5006
5007 while (max)
5008 {
5009 const uint work = get_work (device_param, max);
5010
5011 if (work == 0) break;
5012
5013 max = 0;
5014
5015 words_off = device_param->words_off;
5016 words_fin = words_off + work;
5017
5018 char *line_buf;
5019 uint line_len;
5020
5021 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5022
5023 for ( ; words_cur < words_fin; words_cur++)
5024 {
5025 get_next_word (wl_data, fd, &line_buf, &line_len);
5026
5027 line_len = convert_from_hex (line_buf, line_len);
5028
5029 // post-process rule engine
5030
5031 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5032 {
5033 char rule_buf_out[BLOCK_SIZE] = { 0 };
5034
5035 int rule_len_out = -1;
5036
5037 if (line_len < BLOCK_SIZE)
5038 {
5039 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5040 }
5041
5042 if (rule_len_out < 0) continue;
5043
5044 line_buf = rule_buf_out;
5045 line_len = rule_len_out;
5046 }
5047
5048 if (attack_kern == ATTACK_KERN_STRAIGHT)
5049 {
5050 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5051 {
5052 max++;
5053
5054 hc_thread_mutex_lock (mux_counter);
5055
5056 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5057 {
5058 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5059 }
5060
5061 hc_thread_mutex_unlock (mux_counter);
5062
5063 continue;
5064 }
5065 }
5066 else if (attack_kern == ATTACK_KERN_COMBI)
5067 {
5068 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5069 // since we still need to combine the plains
5070
5071 if (line_len > data.pw_max)
5072 {
5073 max++;
5074
5075 hc_thread_mutex_lock (mux_counter);
5076
5077 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5078 {
5079 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5080 }
5081
5082 hc_thread_mutex_unlock (mux_counter);
5083
5084 continue;
5085 }
5086 }
5087
5088 pw_add (device_param, (u8 *) line_buf, line_len);
5089
5090 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5091
5092 if (data.devices_status == STATUS_CRACKED) break;
5093 if (data.devices_status == STATUS_ABORTED) break;
5094 if (data.devices_status == STATUS_QUIT) break;
5095 if (data.devices_status == STATUS_BYPASS) break;
5096 }
5097
5098 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5099
5100 if (data.devices_status == STATUS_CRACKED) break;
5101 if (data.devices_status == STATUS_ABORTED) break;
5102 if (data.devices_status == STATUS_QUIT) break;
5103 if (data.devices_status == STATUS_BYPASS) break;
5104 }
5105
5106 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5107
5108 if (data.devices_status == STATUS_CRACKED) break;
5109 if (data.devices_status == STATUS_ABORTED) break;
5110 if (data.devices_status == STATUS_QUIT) break;
5111 if (data.devices_status == STATUS_BYPASS) break;
5112
5113 //
5114 // flush
5115 //
5116
5117 const uint pws_cnt = device_param->pws_cnt;
5118
5119 if (pws_cnt)
5120 {
5121 run_copy (device_param, pws_cnt);
5122
5123 run_cracker (device_param, pws_cnt);
5124
5125 device_param->pws_cnt = 0;
5126
5127 /*
5128 still required?
5129 if (attack_kern == ATTACK_KERN_STRAIGHT)
5130 {
5131 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5132 }
5133 else if (attack_kern == ATTACK_KERN_COMBI)
5134 {
5135 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5136 }
5137 */
5138 }
5139
5140 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5141
5142 if (data.devices_status == STATUS_CRACKED) break;
5143 if (data.devices_status == STATUS_ABORTED) break;
5144 if (data.devices_status == STATUS_QUIT) break;
5145 if (data.devices_status == STATUS_BYPASS) break;
5146
5147 if (words_fin == 0) break;
5148
5149 device_param->words_done = words_fin;
5150 }
5151
5152 if (attack_mode == ATTACK_MODE_COMBI)
5153 {
5154 fclose (device_param->combs_fp);
5155 }
5156
5157 free (wl_data->buf);
5158 free (wl_data);
5159
5160 fclose (fd);
5161 }
5162
5163 device_param->kernel_accel = 0;
5164 device_param->kernel_loops = 0;
5165
5166 return NULL;
5167 }
5168
5169 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5170 {
5171 if (!device_param)
5172 {
5173 log_error ("ERROR: %s : Invalid argument", __func__);
5174
5175 exit (-1);
5176 }
5177
5178 salt_t *salt_buf = &data.salts_buf[salt_pos];
5179
5180 device_param->kernel_params_buf32[24] = salt_pos;
5181 device_param->kernel_params_buf32[27] = 1;
5182 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
5183 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
5184 device_param->kernel_params_buf32[30] = 0;
5185 device_param->kernel_params_buf32[31] = 1;
5186
5187 char *dictfile_old = data.dictfile;
5188
5189 const char *weak_hash_check = "weak-hash-check";
5190
5191 data.dictfile = (char *) weak_hash_check;
5192
5193 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5194
5195 data.kernel_rules_buf[0].cmds[0] = 0;
5196
5197 /**
5198 * run the kernel
5199 */
5200
5201 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5202 {
5203 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5204 }
5205 else
5206 {
5207 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5208
5209 uint loop_step = 16;
5210
5211 const uint iter = salt_buf->salt_iter;
5212
5213 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5214 {
5215 uint loop_left = iter - loop_pos;
5216
5217 loop_left = MIN (loop_left, loop_step);
5218
5219 device_param->kernel_params_buf32[25] = loop_pos;
5220 device_param->kernel_params_buf32[26] = loop_left;
5221
5222 run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5223 }
5224
5225 run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5226 }
5227
5228 /**
5229 * result
5230 */
5231
5232 check_cracked (device_param, salt_pos);
5233
5234 /**
5235 * cleanup
5236 */
5237
5238 device_param->kernel_params_buf32[24] = 0;
5239 device_param->kernel_params_buf32[25] = 0;
5240 device_param->kernel_params_buf32[26] = 0;
5241 device_param->kernel_params_buf32[27] = 0;
5242 device_param->kernel_params_buf32[28] = 0;
5243 device_param->kernel_params_buf32[29] = 0;
5244 device_param->kernel_params_buf32[30] = 0;
5245 device_param->kernel_params_buf32[31] = 0;
5246
5247 data.dictfile = dictfile_old;
5248
5249 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5250 }
5251
5252 // hlfmt hashcat
5253
5254 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5255 {
5256 if (data.username == 0)
5257 {
5258 *hashbuf_pos = line_buf;
5259 *hashbuf_len = line_len;
5260 }
5261 else
5262 {
5263 char *pos = line_buf;
5264 int len = line_len;
5265
5266 for (int i = 0; i < line_len; i++, pos++, len--)
5267 {
5268 if (line_buf[i] == data.separator)
5269 {
5270 pos++;
5271
5272 len--;
5273
5274 break;
5275 }
5276 }
5277
5278 *hashbuf_pos = pos;
5279 *hashbuf_len = len;
5280 }
5281 }
5282
5283 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5284 {
5285 char *pos = NULL;
5286 int len = 0;
5287
5288 int sep_cnt = 0;
5289
5290 for (int i = 0; i < line_len; i++)
5291 {
5292 if (line_buf[i] == data.separator)
5293 {
5294 sep_cnt++;
5295
5296 continue;
5297 }
5298
5299 if (sep_cnt == 0)
5300 {
5301 if (pos == NULL) pos = line_buf + i;
5302
5303 len++;
5304 }
5305 }
5306
5307 *userbuf_pos = pos;
5308 *userbuf_len = len;
5309 }
5310
5311 // hlfmt pwdump
5312
5313 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5314 {
5315 int sep_cnt = 0;
5316
5317 int sep2_len = 0;
5318 int sep3_len = 0;
5319
5320 for (int i = 0; i < line_len; i++)
5321 {
5322 if (line_buf[i] == ':')
5323 {
5324 sep_cnt++;
5325
5326 continue;
5327 }
5328
5329 if (sep_cnt == 2) sep2_len++;
5330 if (sep_cnt == 3) sep3_len++;
5331 }
5332
5333 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5334
5335 return 0;
5336 }
5337
5338 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5339 {
5340 char *pos = NULL;
5341 int len = 0;
5342
5343 int sep_cnt = 0;
5344
5345 for (int i = 0; i < line_len; i++)
5346 {
5347 if (line_buf[i] == ':')
5348 {
5349 sep_cnt++;
5350
5351 continue;
5352 }
5353
5354 if (data.hash_mode == 1000)
5355 {
5356 if (sep_cnt == 3)
5357 {
5358 if (pos == NULL) pos = line_buf + i;
5359
5360 len++;
5361 }
5362 }
5363 else if (data.hash_mode == 3000)
5364 {
5365 if (sep_cnt == 2)
5366 {
5367 if (pos == NULL) pos = line_buf + i;
5368
5369 len++;
5370 }
5371 }
5372 }
5373
5374 *hashbuf_pos = pos;
5375 *hashbuf_len = len;
5376 }
5377
5378 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5379 {
5380 char *pos = NULL;
5381 int len = 0;
5382
5383 int sep_cnt = 0;
5384
5385 for (int i = 0; i < line_len; i++)
5386 {
5387 if (line_buf[i] == ':')
5388 {
5389 sep_cnt++;
5390
5391 continue;
5392 }
5393
5394 if (sep_cnt == 0)
5395 {
5396 if (pos == NULL) pos = line_buf + i;
5397
5398 len++;
5399 }
5400 }
5401
5402 *userbuf_pos = pos;
5403 *userbuf_len = len;
5404 }
5405
5406 // hlfmt passwd
5407
5408 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5409 {
5410 int sep_cnt = 0;
5411
5412 char sep5_first = 0;
5413 char sep6_first = 0;
5414
5415 for (int i = 0; i < line_len; i++)
5416 {
5417 if (line_buf[i] == ':')
5418 {
5419 sep_cnt++;
5420
5421 continue;
5422 }
5423
5424 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5425 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5426 }
5427
5428 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5429
5430 return 0;
5431 }
5432
5433 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5434 {
5435 char *pos = NULL;
5436 int len = 0;
5437
5438 int sep_cnt = 0;
5439
5440 for (int i = 0; i < line_len; i++)
5441 {
5442 if (line_buf[i] == ':')
5443 {
5444 sep_cnt++;
5445
5446 continue;
5447 }
5448
5449 if (sep_cnt == 1)
5450 {
5451 if (pos == NULL) pos = line_buf + i;
5452
5453 len++;
5454 }
5455 }
5456
5457 *hashbuf_pos = pos;
5458 *hashbuf_len = len;
5459 }
5460
5461 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5462 {
5463 char *pos = NULL;
5464 int len = 0;
5465
5466 int sep_cnt = 0;
5467
5468 for (int i = 0; i < line_len; i++)
5469 {
5470 if (line_buf[i] == ':')
5471 {
5472 sep_cnt++;
5473
5474 continue;
5475 }
5476
5477 if (sep_cnt == 0)
5478 {
5479 if (pos == NULL) pos = line_buf + i;
5480
5481 len++;
5482 }
5483 }
5484
5485 *userbuf_pos = pos;
5486 *userbuf_len = len;
5487 }
5488
5489 // hlfmt shadow
5490
5491 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5492 {
5493 int sep_cnt = 0;
5494
5495 for (int i = 0; i < line_len; i++)
5496 {
5497 if (line_buf[i] == ':') sep_cnt++;
5498 }
5499
5500 if (sep_cnt == 8) return 1;
5501
5502 return 0;
5503 }
5504
5505 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5506 {
5507 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5508 }
5509
5510 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5511 {
5512 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5513 }
5514
5515 // hlfmt main
5516
5517 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5518 {
5519 switch (hashfile_format)
5520 {
5521 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5522 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5523 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5524 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5525 }
5526 }
5527
5528 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5529 {
5530 switch (hashfile_format)
5531 {
5532 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5533 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5534 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5535 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5536 }
5537 }
5538
5539 char *strhlfmt (const uint hashfile_format)
5540 {
5541 switch (hashfile_format)
5542 {
5543 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5544 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5545 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5546 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5547 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5548 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5549 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5550 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5551 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5552 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5553 }
5554
5555 return ((char *) "Unknown");
5556 }
5557
5558 static uint hlfmt_detect (FILE *fp, uint max_check)
5559 {
5560 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5561
5562 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5563 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5564
5565 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5566
5567 uint num_check = 0;
5568
5569 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5570
5571 while (!feof (fp))
5572 {
5573 int line_len = fgetl (fp, line_buf);
5574
5575 if (line_len == 0) continue;
5576
5577 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5578 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5579 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5580
5581 if (num_check == max_check) break;
5582
5583 num_check++;
5584 }
5585
5586 myfree (line_buf);
5587
5588 uint hashlist_format = HLFMT_HASHCAT;
5589
5590 for (int i = 1; i < HLFMTS_CNT; i++)
5591 {
5592 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5593
5594 hashlist_format = i;
5595 }
5596
5597 free (formats_cnt);
5598
5599 return hashlist_format;
5600 }
5601
5602 /**
5603 * some further helper function
5604 */
5605
5606 // wrapper around mymalloc for ADL
5607
5608 #if defined(HAVE_HWMON)
5609 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5610 {
5611 return mymalloc (iSize);
5612 }
5613 #endif
5614
5615 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)
5616 {
5617 u64 collisions = 0;
5618
5619 const uint dgst_pos0 = data.dgst_pos0;
5620 const uint dgst_pos1 = data.dgst_pos1;
5621 const uint dgst_pos2 = data.dgst_pos2;
5622 const uint dgst_pos3 = data.dgst_pos3;
5623
5624 memset (bitmap_a, 0, bitmap_size);
5625 memset (bitmap_b, 0, bitmap_size);
5626 memset (bitmap_c, 0, bitmap_size);
5627 memset (bitmap_d, 0, bitmap_size);
5628
5629 for (uint i = 0; i < digests_cnt; i++)
5630 {
5631 uint *digest_ptr = (uint *) digests_buf_ptr;
5632
5633 digests_buf_ptr += dgst_size;
5634
5635 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5636 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5637 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5638 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5639
5640 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5641 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5642 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5643 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5644
5645 if (bitmap_a[idx0] & val0) collisions++;
5646 if (bitmap_b[idx1] & val1) collisions++;
5647 if (bitmap_c[idx2] & val2) collisions++;
5648 if (bitmap_d[idx3] & val3) collisions++;
5649
5650 bitmap_a[idx0] |= val0;
5651 bitmap_b[idx1] |= val1;
5652 bitmap_c[idx2] |= val2;
5653 bitmap_d[idx3] |= val3;
5654
5655 if (collisions >= collisions_max) return 0x7fffffff;
5656 }
5657
5658 return collisions;
5659 }
5660
5661 /**
5662 * main
5663 */
5664
5665 #ifdef WIN
5666 void SetConsoleWindowSize (const int x)
5667 {
5668 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5669
5670 if (h == INVALID_HANDLE_VALUE) return;
5671
5672 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5673
5674 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5675
5676 SMALL_RECT *sr = &bufferInfo.srWindow;
5677
5678 sr->Right = MAX (sr->Right, x - 1);
5679
5680 COORD co;
5681
5682 co.X = sr->Right + 1;
5683 co.Y = 9999;
5684
5685 if (!SetConsoleScreenBufferSize (h, co)) return;
5686
5687 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5688 }
5689 #endif
5690
5691 int main (int argc, char **argv)
5692 {
5693 #ifdef WIN
5694 SetConsoleWindowSize (132);
5695 #endif
5696
5697 /**
5698 * To help users a bit
5699 */
5700
5701 char *compute = getenv ("COMPUTE");
5702
5703 if (compute)
5704 {
5705 static char display[100];
5706
5707 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5708
5709 putenv (display);
5710 }
5711 else
5712 {
5713 if (getenv ("DISPLAY") == NULL)
5714 putenv ((char *) "DISPLAY=:0");
5715 }
5716
5717 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5718 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5719
5720 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5721 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5722
5723 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5724 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5725
5726 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5727 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5728
5729 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5730 putenv ((char *) "POCL_KERNEL_CACHE=0");
5731
5732 umask (077);
5733
5734 /**
5735 * Real init
5736 */
5737
5738 memset (&data, 0, sizeof (hc_global_data_t));
5739
5740 time_t proc_start;
5741
5742 time (&proc_start);
5743
5744 data.proc_start = proc_start;
5745
5746 int myargc = argc;
5747 char **myargv = argv;
5748
5749 hc_thread_mutex_init (mux_dispatcher);
5750 hc_thread_mutex_init (mux_counter);
5751 hc_thread_mutex_init (mux_display);
5752 hc_thread_mutex_init (mux_adl);
5753
5754 /**
5755 * commandline parameters
5756 */
5757
5758 uint usage = USAGE;
5759 uint version = VERSION;
5760 uint quiet = QUIET;
5761 uint benchmark = BENCHMARK;
5762 uint stdout_flag = STDOUT_FLAG;
5763 uint show = SHOW;
5764 uint left = LEFT;
5765 uint username = USERNAME;
5766 uint remove = REMOVE;
5767 uint remove_timer = REMOVE_TIMER;
5768 u64 skip = SKIP;
5769 u64 limit = LIMIT;
5770 uint keyspace = KEYSPACE;
5771 uint potfile_disable = POTFILE_DISABLE;
5772 char *potfile_path = NULL;
5773 uint debug_mode = DEBUG_MODE;
5774 char *debug_file = NULL;
5775 char *induction_dir = NULL;
5776 char *outfile_check_dir = NULL;
5777 uint force = FORCE;
5778 uint runtime = RUNTIME;
5779 uint hash_mode = HASH_MODE;
5780 uint attack_mode = ATTACK_MODE;
5781 uint markov_disable = MARKOV_DISABLE;
5782 uint markov_classic = MARKOV_CLASSIC;
5783 uint markov_threshold = MARKOV_THRESHOLD;
5784 char *markov_hcstat = NULL;
5785 char *outfile = NULL;
5786 uint outfile_format = OUTFILE_FORMAT;
5787 uint outfile_autohex = OUTFILE_AUTOHEX;
5788 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5789 uint restore = RESTORE;
5790 uint restore_timer = RESTORE_TIMER;
5791 uint restore_disable = RESTORE_DISABLE;
5792 uint status = STATUS;
5793 uint status_timer = STATUS_TIMER;
5794 uint machine_readable = MACHINE_READABLE;
5795 uint loopback = LOOPBACK;
5796 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5797 char *session = NULL;
5798 uint hex_charset = HEX_CHARSET;
5799 uint hex_salt = HEX_SALT;
5800 uint hex_wordlist = HEX_WORDLIST;
5801 uint rp_gen = RP_GEN;
5802 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5803 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5804 uint rp_gen_seed = RP_GEN_SEED;
5805 char *rule_buf_l = (char *) RULE_BUF_L;
5806 char *rule_buf_r = (char *) RULE_BUF_R;
5807 uint increment = INCREMENT;
5808 uint increment_min = INCREMENT_MIN;
5809 uint increment_max = INCREMENT_MAX;
5810 char *cpu_affinity = NULL;
5811 OCL_PTR *ocl = NULL;
5812 char *opencl_devices = NULL;
5813 char *opencl_platforms = NULL;
5814 char *opencl_device_types = NULL;
5815 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5816 char *truecrypt_keyfiles = NULL;
5817 char *veracrypt_keyfiles = NULL;
5818 uint veracrypt_pim = 0;
5819 uint workload_profile = WORKLOAD_PROFILE;
5820 uint kernel_accel = KERNEL_ACCEL;
5821 uint kernel_loops = KERNEL_LOOPS;
5822 uint nvidia_spin_damp = NVIDIA_SPIN_DAMP;
5823 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5824 #ifdef HAVE_HWMON
5825 uint gpu_temp_abort = GPU_TEMP_ABORT;
5826 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5827 uint powertune_enable = POWERTUNE_ENABLE;
5828 #endif
5829 uint logfile_disable = LOGFILE_DISABLE;
5830 uint segment_size = SEGMENT_SIZE;
5831 uint scrypt_tmto = SCRYPT_TMTO;
5832 char separator = SEPARATOR;
5833 uint bitmap_min = BITMAP_MIN;
5834 uint bitmap_max = BITMAP_MAX;
5835 char *custom_charset_1 = NULL;
5836 char *custom_charset_2 = NULL;
5837 char *custom_charset_3 = NULL;
5838 char *custom_charset_4 = NULL;
5839
5840 #define IDX_HELP 'h'
5841 #define IDX_VERSION 'V'
5842 #define IDX_VERSION_LOWER 'v'
5843 #define IDX_QUIET 0xff02
5844 #define IDX_SHOW 0xff03
5845 #define IDX_LEFT 0xff04
5846 #define IDX_REMOVE 0xff05
5847 #define IDX_REMOVE_TIMER 0xff37
5848 #define IDX_SKIP 's'
5849 #define IDX_LIMIT 'l'
5850 #define IDX_KEYSPACE 0xff35
5851 #define IDX_POTFILE_DISABLE 0xff06
5852 #define IDX_POTFILE_PATH 0xffe0
5853 #define IDX_DEBUG_MODE 0xff43
5854 #define IDX_DEBUG_FILE 0xff44
5855 #define IDX_INDUCTION_DIR 0xff46
5856 #define IDX_OUTFILE_CHECK_DIR 0xff47
5857 #define IDX_USERNAME 0xff07
5858 #define IDX_FORCE 0xff08
5859 #define IDX_RUNTIME 0xff09
5860 #define IDX_BENCHMARK 'b'
5861 #define IDX_STDOUT_FLAG 0xff77
5862 #define IDX_HASH_MODE 'm'
5863 #define IDX_ATTACK_MODE 'a'
5864 #define IDX_RP_FILE 'r'
5865 #define IDX_RP_GEN 'g'
5866 #define IDX_RP_GEN_FUNC_MIN 0xff10
5867 #define IDX_RP_GEN_FUNC_MAX 0xff11
5868 #define IDX_RP_GEN_SEED 0xff34
5869 #define IDX_RULE_BUF_L 'j'
5870 #define IDX_RULE_BUF_R 'k'
5871 #define IDX_INCREMENT 'i'
5872 #define IDX_INCREMENT_MIN 0xff12
5873 #define IDX_INCREMENT_MAX 0xff13
5874 #define IDX_OUTFILE 'o'
5875 #define IDX_OUTFILE_FORMAT 0xff14
5876 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5877 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5878 #define IDX_RESTORE 0xff15
5879 #define IDX_RESTORE_DISABLE 0xff27
5880 #define IDX_STATUS 0xff17
5881 #define IDX_STATUS_TIMER 0xff18
5882 #define IDX_MACHINE_READABLE 0xff50
5883 #define IDX_LOOPBACK 0xff38
5884 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5885 #define IDX_SESSION 0xff19
5886 #define IDX_HEX_CHARSET 0xff20
5887 #define IDX_HEX_SALT 0xff21
5888 #define IDX_HEX_WORDLIST 0xff40
5889 #define IDX_MARKOV_DISABLE 0xff22
5890 #define IDX_MARKOV_CLASSIC 0xff23
5891 #define IDX_MARKOV_THRESHOLD 't'
5892 #define IDX_MARKOV_HCSTAT 0xff24
5893 #define IDX_CPU_AFFINITY 0xff25
5894 #define IDX_OPENCL_DEVICES 'd'
5895 #define IDX_OPENCL_PLATFORMS 0xff72
5896 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5897 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5898 #define IDX_WORKLOAD_PROFILE 'w'
5899 #define IDX_KERNEL_ACCEL 'n'
5900 #define IDX_KERNEL_LOOPS 'u'
5901 #define IDX_NVIDIA_SPIN_DAMP 0xff79
5902 #define IDX_GPU_TEMP_DISABLE 0xff29
5903 #define IDX_GPU_TEMP_ABORT 0xff30
5904 #define IDX_GPU_TEMP_RETAIN 0xff31
5905 #define IDX_POWERTUNE_ENABLE 0xff41
5906 #define IDX_LOGFILE_DISABLE 0xff51
5907 #define IDX_TRUECRYPT_KEYFILES 0xff52
5908 #define IDX_VERACRYPT_KEYFILES 0xff53
5909 #define IDX_VERACRYPT_PIM 0xff54
5910 #define IDX_SCRYPT_TMTO 0xff61
5911 #define IDX_SEGMENT_SIZE 'c'
5912 #define IDX_SEPARATOR 'p'
5913 #define IDX_BITMAP_MIN 0xff70
5914 #define IDX_BITMAP_MAX 0xff71
5915 #define IDX_CUSTOM_CHARSET_1 '1'
5916 #define IDX_CUSTOM_CHARSET_2 '2'
5917 #define IDX_CUSTOM_CHARSET_3 '3'
5918 #define IDX_CUSTOM_CHARSET_4 '4'
5919
5920 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5921
5922 struct option long_options[] =
5923 {
5924 {"help", no_argument, 0, IDX_HELP},
5925 {"version", no_argument, 0, IDX_VERSION},
5926 {"quiet", no_argument, 0, IDX_QUIET},
5927 {"show", no_argument, 0, IDX_SHOW},
5928 {"left", no_argument, 0, IDX_LEFT},
5929 {"username", no_argument, 0, IDX_USERNAME},
5930 {"remove", no_argument, 0, IDX_REMOVE},
5931 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5932 {"skip", required_argument, 0, IDX_SKIP},
5933 {"limit", required_argument, 0, IDX_LIMIT},
5934 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5935 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5936 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5937 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5938 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5939 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5940 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5941 {"force", no_argument, 0, IDX_FORCE},
5942 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5943 {"stdout", no_argument, 0, IDX_STDOUT_FLAG},
5944 {"restore", no_argument, 0, IDX_RESTORE},
5945 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5946 {"status", no_argument, 0, IDX_STATUS},
5947 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5948 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5949 {"loopback", no_argument, 0, IDX_LOOPBACK},
5950 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5951 {"session", required_argument, 0, IDX_SESSION},
5952 {"runtime", required_argument, 0, IDX_RUNTIME},
5953 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5954 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5955 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5956 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5957 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5958 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5959 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5960 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5961 {"rules-file", required_argument, 0, IDX_RP_FILE},
5962 {"outfile", required_argument, 0, IDX_OUTFILE},
5963 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5964 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5965 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5966 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5967 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5968 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5969 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5970 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5971 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5972 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5973 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5974 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5975 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5976 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5977 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5978 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5979 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5980 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5981 {"nvidia-spin-damp", required_argument, 0, IDX_NVIDIA_SPIN_DAMP},
5982 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5983 #ifdef HAVE_HWMON
5984 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5985 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5986 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5987 #endif // HAVE_HWMON
5988 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5989 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5990 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5991 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5992 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5993 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5994 {"seperator", required_argument, 0, IDX_SEPARATOR},
5995 {"separator", required_argument, 0, IDX_SEPARATOR},
5996 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5997 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5998 {"increment", no_argument, 0, IDX_INCREMENT},
5999 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
6000 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
6001 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
6002 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
6003 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
6004 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
6005 {0, 0, 0, 0}
6006 };
6007
6008 uint rp_files_cnt = 0;
6009
6010 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6011
6012 int option_index = 0;
6013 int c = -1;
6014
6015 optind = 1;
6016 optopt = 0;
6017
6018 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6019 {
6020 switch (c)
6021 {
6022 case IDX_HELP: usage = 1; break;
6023 case IDX_VERSION:
6024 case IDX_VERSION_LOWER: version = 1; break;
6025 case IDX_RESTORE: restore = 1; break;
6026 case IDX_SESSION: session = optarg; break;
6027 case IDX_SHOW: show = 1; break;
6028 case IDX_LEFT: left = 1; break;
6029 case '?': return (-1);
6030 }
6031 }
6032
6033 if (optopt != 0)
6034 {
6035 log_error ("ERROR: Invalid argument specified");
6036
6037 return (-1);
6038 }
6039
6040 /**
6041 * exit functions
6042 */
6043
6044 if (version)
6045 {
6046 log_info ("%s", VERSION_TAG);
6047
6048 return (0);
6049 }
6050
6051 if (usage)
6052 {
6053 usage_big_print (PROGNAME);
6054
6055 return (0);
6056 }
6057
6058 /**
6059 * session needs to be set, always!
6060 */
6061
6062 if (session == NULL) session = (char *) PROGNAME;
6063
6064 /**
6065 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6066 */
6067
6068 char *exec_path = get_exec_path ();
6069
6070 #ifdef LINUX
6071
6072 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6073 char *resolved_exec_path = realpath (exec_path, NULL);
6074
6075 char *install_dir = get_install_dir (resolved_exec_path);
6076 char *profile_dir = NULL;
6077 char *session_dir = NULL;
6078 char *shared_dir = NULL;
6079
6080 if (strcmp (install_dir, resolved_install_folder) == 0)
6081 {
6082 struct passwd *pw = getpwuid (getuid ());
6083
6084 const char *homedir = pw->pw_dir;
6085
6086 profile_dir = get_profile_dir (homedir);
6087 session_dir = get_session_dir (profile_dir);
6088 shared_dir = strdup (SHARED_FOLDER);
6089
6090 mkdir (profile_dir, 0700);
6091 mkdir (session_dir, 0700);
6092 }
6093 else
6094 {
6095 profile_dir = install_dir;
6096 session_dir = install_dir;
6097 shared_dir = install_dir;
6098 }
6099
6100 myfree (resolved_install_folder);
6101 myfree (resolved_exec_path);
6102
6103 #else
6104
6105 char *install_dir = get_install_dir (exec_path);
6106 char *profile_dir = install_dir;
6107 char *session_dir = install_dir;
6108 char *shared_dir = install_dir;
6109
6110 #endif
6111
6112 data.install_dir = install_dir;
6113 data.profile_dir = profile_dir;
6114 data.session_dir = session_dir;
6115 data.shared_dir = shared_dir;
6116
6117 myfree (exec_path);
6118
6119 /**
6120 * kernel cache, we need to make sure folder exist
6121 */
6122
6123 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6124
6125 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6126
6127 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6128
6129 mkdir (kernels_folder, 0700);
6130
6131 myfree (kernels_folder);
6132
6133 /**
6134 * session
6135 */
6136
6137 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6138
6139 data.session = session;
6140
6141 char *eff_restore_file = (char *) mymalloc (session_size);
6142 char *new_restore_file = (char *) mymalloc (session_size);
6143
6144 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
6145 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6146
6147 data.eff_restore_file = eff_restore_file;
6148 data.new_restore_file = new_restore_file;
6149
6150 if (((show == 1) || (left == 1)) && (restore == 1))
6151 {
6152 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6153 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6154
6155 return (-1);
6156 }
6157
6158 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6159 if ((show == 1) || (left == 1))
6160 {
6161 restore_disable = 1;
6162
6163 restore = 0;
6164 }
6165
6166 data.restore_disable = restore_disable;
6167
6168 restore_data_t *rd = init_restore (argc, argv);
6169
6170 data.rd = rd;
6171
6172 /**
6173 * restore file
6174 */
6175
6176 if (restore == 1)
6177 {
6178 read_restore (eff_restore_file, rd);
6179
6180 if (rd->version_bin < RESTORE_MIN)
6181 {
6182 log_error ("ERROR: Incompatible restore-file version");
6183
6184 return (-1);
6185 }
6186
6187 myargc = rd->argc;
6188 myargv = rd->argv;
6189
6190 #ifdef _POSIX
6191 rd->pid = getpid ();
6192 #elif _WIN
6193 rd->pid = GetCurrentProcessId ();
6194 #endif
6195 }
6196
6197 uint hash_mode_chgd = 0;
6198 uint runtime_chgd = 0;
6199 uint kernel_loops_chgd = 0;
6200 uint kernel_accel_chgd = 0;
6201 uint nvidia_spin_damp_chgd = 0;
6202 uint attack_mode_chgd = 0;
6203 uint outfile_format_chgd = 0;
6204 uint rp_gen_seed_chgd = 0;
6205 uint remove_timer_chgd = 0;
6206 uint increment_min_chgd = 0;
6207 uint increment_max_chgd = 0;
6208 uint workload_profile_chgd = 0;
6209 uint opencl_vector_width_chgd = 0;
6210
6211 optind = 1;
6212 optopt = 0;
6213 option_index = 0;
6214
6215 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6216 {
6217 switch (c)
6218 {
6219 //case IDX_HELP: usage = 1; break;
6220 //case IDX_VERSION: version = 1; break;
6221 //case IDX_RESTORE: restore = 1; break;
6222 case IDX_QUIET: quiet = 1; break;
6223 //case IDX_SHOW: show = 1; break;
6224 case IDX_SHOW: break;
6225 //case IDX_LEFT: left = 1; break;
6226 case IDX_LEFT: break;
6227 case IDX_USERNAME: username = 1; break;
6228 case IDX_REMOVE: remove = 1; break;
6229 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6230 remove_timer_chgd = 1; break;
6231 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6232 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6233 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6234 case IDX_DEBUG_FILE: debug_file = optarg; break;
6235 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6236 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6237 case IDX_FORCE: force = 1; break;
6238 case IDX_SKIP: skip = atoll (optarg); break;
6239 case IDX_LIMIT: limit = atoll (optarg); break;
6240 case IDX_KEYSPACE: keyspace = 1; break;
6241 case IDX_BENCHMARK: benchmark = 1; break;
6242 case IDX_STDOUT_FLAG: stdout_flag = 1; break;
6243 case IDX_RESTORE: break;
6244 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6245 case IDX_STATUS: status = 1; break;
6246 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6247 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6248 case IDX_LOOPBACK: loopback = 1; break;
6249 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6250 //case IDX_SESSION: session = optarg; break;
6251 case IDX_SESSION: break;
6252 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6253 hash_mode_chgd = 1; break;
6254 case IDX_RUNTIME: runtime = atoi (optarg);
6255 runtime_chgd = 1; break;
6256 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6257 attack_mode_chgd = 1; break;
6258 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6259 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6260 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6261 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6262 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6263 rp_gen_seed_chgd = 1; break;
6264 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6265 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6266 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6267 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6268 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6269 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6270 case IDX_OUTFILE: outfile = optarg; break;
6271 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6272 outfile_format_chgd = 1; break;
6273 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6274 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6275 case IDX_HEX_CHARSET: hex_charset = 1; break;
6276 case IDX_HEX_SALT: hex_salt = 1; break;
6277 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6278 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6279 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6280 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6281 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6282 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6283 opencl_vector_width_chgd = 1; break;
6284 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6285 workload_profile_chgd = 1; break;
6286 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6287 kernel_accel_chgd = 1; break;
6288 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6289 kernel_loops_chgd = 1; break;
6290 case IDX_NVIDIA_SPIN_DAMP: nvidia_spin_damp = atoi (optarg);
6291 nvidia_spin_damp_chgd = 1; break;
6292 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6293 #ifdef HAVE_HWMON
6294 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6295 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6296 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6297 #endif // HAVE_HWMON
6298 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6299 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6300 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6301 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6302 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6303 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6304 case IDX_SEPARATOR: separator = optarg[0]; break;
6305 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6306 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6307 case IDX_INCREMENT: increment = 1; break;
6308 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6309 increment_min_chgd = 1; break;
6310 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6311 increment_max_chgd = 1; break;
6312 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6313 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6314 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6315 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6316
6317 default:
6318 log_error ("ERROR: Invalid argument specified");
6319 return (-1);
6320 }
6321 }
6322
6323 if (optopt != 0)
6324 {
6325 log_error ("ERROR: Invalid argument specified");
6326
6327 return (-1);
6328 }
6329
6330 /**
6331 * Inform user things getting started,
6332 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6333 * - we do not need to check algorithm_pos
6334 */
6335
6336 if (quiet == 0)
6337 {
6338 if (benchmark == 1)
6339 {
6340 if (machine_readable == 0)
6341 {
6342 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6343 log_info ("");
6344 log_info ("Note: Reported benchmark cracking speed = real cracking speed");
6345 log_info ("To verify, run hashcat like this: only_one_hash.txt -a 3 -w 3 ?b?b?b?b?b?b?b");
6346 log_info ("");
6347 }
6348 else
6349 {
6350 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6351 }
6352 }
6353 else if (restore == 1)
6354 {
6355 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6356 log_info ("");
6357 }
6358 else if (stdout_flag == 1)
6359 {
6360 // do nothing
6361 }
6362 else
6363 {
6364 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6365 log_info ("");
6366 }
6367 }
6368
6369 /**
6370 * sanity check
6371 */
6372
6373 if (attack_mode > 7)
6374 {
6375 log_error ("ERROR: Invalid attack-mode specified");
6376
6377 return (-1);
6378 }
6379
6380 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6381 {
6382 log_error ("ERROR: Invalid runtime specified");
6383
6384 return (-1);
6385 }
6386
6387 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6388 {
6389 log_error ("ERROR: Invalid hash-type specified");
6390
6391 return (-1);
6392 }
6393
6394 // renamed hash modes
6395
6396 if (hash_mode_chgd)
6397 {
6398 int n = -1;
6399
6400 switch (hash_mode)
6401 {
6402 case 123: n = 124;
6403 break;
6404 }
6405
6406 if (n >= 0)
6407 {
6408 log_error ("Old -m specified, use -m %d instead", n);
6409
6410 return (-1);
6411 }
6412 }
6413
6414 if (username == 1)
6415 {
6416 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6417 {
6418 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6419
6420 return (-1);
6421 }
6422 }
6423
6424 if (outfile_format > 16)
6425 {
6426 log_error ("ERROR: Invalid outfile-format specified");
6427
6428 return (-1);
6429 }
6430
6431 if (left == 1)
6432 {
6433 if (outfile_format_chgd == 1)
6434 {
6435 if (outfile_format > 1)
6436 {
6437 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6438
6439 return (-1);
6440 }
6441 }
6442 else
6443 {
6444 outfile_format = OUTFILE_FMT_HASH;
6445 }
6446 }
6447
6448 if (show == 1)
6449 {
6450 if (outfile_format_chgd == 1)
6451 {
6452 if ((outfile_format > 7) && (outfile_format < 16))
6453 {
6454 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6455
6456 return (-1);
6457 }
6458 }
6459 }
6460
6461 if (increment_min < INCREMENT_MIN)
6462 {
6463 log_error ("ERROR: Invalid increment-min specified");
6464
6465 return (-1);
6466 }
6467
6468 if (increment_max > INCREMENT_MAX)
6469 {
6470 log_error ("ERROR: Invalid increment-max specified");
6471
6472 return (-1);
6473 }
6474
6475 if (increment_min > increment_max)
6476 {
6477 log_error ("ERROR: Invalid increment-min specified");
6478
6479 return (-1);
6480 }
6481
6482 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6483 {
6484 log_error ("ERROR: increment is not allowed in attack-mode 0");
6485
6486 return (-1);
6487 }
6488
6489 if ((increment == 0) && (increment_min_chgd == 1))
6490 {
6491 log_error ("ERROR: increment-min is only supported together with increment switch");
6492
6493 return (-1);
6494 }
6495
6496 if ((increment == 0) && (increment_max_chgd == 1))
6497 {
6498 log_error ("ERROR: increment-max is only supported together with increment switch");
6499
6500 return (-1);
6501 }
6502
6503 if (rp_files_cnt && rp_gen)
6504 {
6505 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6506
6507 return (-1);
6508 }
6509
6510 if (rp_files_cnt || rp_gen)
6511 {
6512 if (attack_mode != ATTACK_MODE_STRAIGHT)
6513 {
6514 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6515
6516 return (-1);
6517 }
6518 }
6519
6520 if (rp_gen_func_min > rp_gen_func_max)
6521 {
6522 log_error ("ERROR: Invalid rp-gen-func-min specified");
6523
6524 return (-1);
6525 }
6526
6527 if (kernel_accel_chgd == 1)
6528 {
6529 if (force == 0)
6530 {
6531 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6532 log_info ("Please consider using the option -w instead");
6533 log_info ("You can use --force to override this but do not post error reports if you do so");
6534 log_info ("");
6535
6536 return (-1);
6537 }
6538
6539 if (kernel_accel < 1)
6540 {
6541 log_error ("ERROR: Invalid kernel-accel specified");
6542
6543 return (-1);
6544 }
6545
6546 if (kernel_accel > 1024)
6547 {
6548 log_error ("ERROR: Invalid kernel-accel specified");
6549
6550 return (-1);
6551 }
6552 }
6553
6554 if (kernel_loops_chgd == 1)
6555 {
6556 if (force == 0)
6557 {
6558 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6559 log_info ("Please consider using the option -w instead");
6560 log_info ("You can use --force to override this but do not post error reports if you do so");
6561 log_info ("");
6562
6563 return (-1);
6564 }
6565
6566 if (kernel_loops < 1)
6567 {
6568 log_error ("ERROR: Invalid kernel-loops specified");
6569
6570 return (-1);
6571 }
6572
6573 if (kernel_loops > 1024)
6574 {
6575 log_error ("ERROR: Invalid kernel-loops specified");
6576
6577 return (-1);
6578 }
6579 }
6580
6581 if ((workload_profile < 1) || (workload_profile > 4))
6582 {
6583 log_error ("ERROR: workload-profile %i not available", workload_profile);
6584
6585 return (-1);
6586 }
6587
6588 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6589 {
6590 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6591
6592 return (-1);
6593 }
6594
6595 if (show == 1 || left == 1)
6596 {
6597 attack_mode = ATTACK_MODE_NONE;
6598
6599 if (remove == 1)
6600 {
6601 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6602
6603 return (-1);
6604 }
6605
6606 if (potfile_disable == 1)
6607 {
6608 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6609
6610 return (-1);
6611 }
6612 }
6613
6614 uint attack_kern = ATTACK_KERN_NONE;
6615
6616 switch (attack_mode)
6617 {
6618 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6619 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6620 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6621 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6622 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6623 }
6624
6625 if (benchmark == 1)
6626 {
6627 if (myargv[optind] != 0)
6628 {
6629 log_error ("ERROR: Invalid argument for benchmark mode specified");
6630
6631 return (-1);
6632 }
6633
6634 if (attack_mode_chgd == 1)
6635 {
6636 if (attack_mode != ATTACK_MODE_BF)
6637 {
6638 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6639
6640 return (-1);
6641 }
6642 }
6643 }
6644 else
6645 {
6646 if (stdout_flag == 1) // no hash here
6647 {
6648 optind--;
6649 }
6650
6651 if (keyspace == 1)
6652 {
6653 int num_additional_params = 1;
6654
6655 if (attack_kern == ATTACK_KERN_COMBI)
6656 {
6657 num_additional_params = 2;
6658 }
6659
6660 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6661
6662 if (keyspace_wordlist_specified == 0) optind--;
6663 }
6664
6665 if (attack_kern == ATTACK_KERN_NONE)
6666 {
6667 if ((optind + 1) != myargc)
6668 {
6669 usage_mini_print (myargv[0]);
6670
6671 return (-1);
6672 }
6673 }
6674 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6675 {
6676 if ((optind + 1) > myargc)
6677 {
6678 usage_mini_print (myargv[0]);
6679
6680 return (-1);
6681 }
6682 }
6683 else if (attack_kern == ATTACK_KERN_COMBI)
6684 {
6685 if ((optind + 3) != myargc)
6686 {
6687 usage_mini_print (myargv[0]);
6688
6689 return (-1);
6690 }
6691 }
6692 else if (attack_kern == ATTACK_KERN_BF)
6693 {
6694 if ((optind + 1) > myargc)
6695 {
6696 usage_mini_print (myargv[0]);
6697
6698 return (-1);
6699 }
6700 }
6701 else
6702 {
6703 usage_mini_print (myargv[0]);
6704
6705 return (-1);
6706 }
6707 }
6708
6709 if (skip != 0 && limit != 0)
6710 {
6711 limit += skip;
6712 }
6713
6714 if (keyspace == 1)
6715 {
6716 if (show == 1)
6717 {
6718 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6719
6720 return (-1);
6721 }
6722 else if (left == 1)
6723 {
6724 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6725
6726 return (-1);
6727 }
6728
6729 potfile_disable = 1;
6730
6731 restore_disable = 1;
6732
6733 restore = 0;
6734
6735 weak_hash_threshold = 0;
6736
6737 quiet = 1;
6738 }
6739
6740 if (stdout_flag == 1)
6741 {
6742 status_timer = 0;
6743 restore_timer = 0;
6744 restore_disable = 1;
6745 restore = 0;
6746 potfile_disable = 1;
6747 weak_hash_threshold = 0;
6748 gpu_temp_disable = 1;
6749 hash_mode = 2000;
6750 quiet = 1;
6751 outfile_format = OUTFILE_FMT_PLAIN;
6752 kernel_accel = 1024;
6753 kernel_loops = 1024;
6754 force = 1;
6755 outfile_check_timer = 0;
6756 }
6757
6758 if (remove_timer_chgd == 1)
6759 {
6760 if (remove == 0)
6761 {
6762 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6763
6764 return (-1);
6765 }
6766
6767 if (remove_timer < 1)
6768 {
6769 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6770
6771 return (-1);
6772 }
6773 }
6774
6775 if (loopback == 1)
6776 {
6777 if (attack_mode == ATTACK_MODE_STRAIGHT)
6778 {
6779 if ((rp_files_cnt == 0) && (rp_gen == 0))
6780 {
6781 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6782
6783 return (-1);
6784 }
6785 }
6786 else
6787 {
6788 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6789
6790 return (-1);
6791 }
6792 }
6793
6794 if (debug_mode > 0)
6795 {
6796 if (attack_mode != ATTACK_MODE_STRAIGHT)
6797 {
6798 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6799
6800 return (-1);
6801 }
6802
6803 if ((rp_files_cnt == 0) && (rp_gen == 0))
6804 {
6805 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6806
6807 return (-1);
6808 }
6809 }
6810
6811 if (debug_mode > 4)
6812 {
6813 log_error ("ERROR: Invalid debug-mode specified");
6814
6815 return (-1);
6816 }
6817
6818 if (debug_file != NULL)
6819 {
6820 if (debug_mode < 1)
6821 {
6822 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6823
6824 return (-1);
6825 }
6826 }
6827
6828 if (induction_dir != NULL)
6829 {
6830 if (attack_mode == ATTACK_MODE_BF)
6831 {
6832 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6833
6834 return (-1);
6835 }
6836 }
6837
6838 if (attack_mode != ATTACK_MODE_STRAIGHT)
6839 {
6840 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6841 {
6842 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6843
6844 return (-1);
6845 }
6846
6847 weak_hash_threshold = 0;
6848 }
6849
6850 if (nvidia_spin_damp > 100)
6851 {
6852 log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)");
6853
6854 return (-1);
6855 }
6856
6857
6858 /**
6859 * induction directory
6860 */
6861
6862 char *induction_directory = NULL;
6863
6864 if (attack_mode != ATTACK_MODE_BF)
6865 {
6866 if (induction_dir == NULL)
6867 {
6868 induction_directory = (char *) mymalloc (session_size);
6869
6870 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6871
6872 // create induction folder if it does not already exist
6873
6874 if (keyspace == 0)
6875 {
6876 if (rmdir (induction_directory) == -1)
6877 {
6878 if (errno == ENOENT)
6879 {
6880 // good, we can ignore
6881 }
6882 else if (errno == ENOTEMPTY)
6883 {
6884 char *induction_directory_mv = (char *) mymalloc (session_size);
6885
6886 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6887
6888 if (rename (induction_directory, induction_directory_mv) != 0)
6889 {
6890 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6891
6892 return (-1);
6893 }
6894 }
6895 else
6896 {
6897 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6898
6899 return (-1);
6900 }
6901 }
6902
6903 if (mkdir (induction_directory, 0700) == -1)
6904 {
6905 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6906
6907 return (-1);
6908 }
6909 }
6910 }
6911 else
6912 {
6913 induction_directory = induction_dir;
6914 }
6915 }
6916
6917 data.induction_directory = induction_directory;
6918
6919 /**
6920 * loopback
6921 */
6922
6923 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6924
6925 char *loopback_file = (char *) mymalloc (loopback_size);
6926
6927 /**
6928 * tuning db
6929 */
6930
6931 char tuning_db_file[256] = { 0 };
6932
6933 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6934
6935 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6936
6937 /**
6938 * outfile-check directory
6939 */
6940
6941 char *outfile_check_directory = NULL;
6942
6943 if (outfile_check_dir == NULL)
6944 {
6945 outfile_check_directory = (char *) mymalloc (session_size);
6946
6947 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6948 }
6949 else
6950 {
6951 outfile_check_directory = outfile_check_dir;
6952 }
6953
6954 data.outfile_check_directory = outfile_check_directory;
6955
6956 if (keyspace == 0)
6957 {
6958 struct stat outfile_check_stat;
6959
6960 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6961 {
6962 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6963
6964 if (is_dir == 0)
6965 {
6966 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6967
6968 return (-1);
6969 }
6970 }
6971 else if (outfile_check_dir == NULL)
6972 {
6973 if (mkdir (outfile_check_directory, 0700) == -1)
6974 {
6975 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6976
6977 return (-1);
6978 }
6979 }
6980 }
6981
6982 /**
6983 * special other stuff
6984 */
6985
6986 if (hash_mode == 9710)
6987 {
6988 outfile_format = 5;
6989 outfile_format_chgd = 1;
6990 }
6991
6992 if (hash_mode == 9810)
6993 {
6994 outfile_format = 5;
6995 outfile_format_chgd = 1;
6996 }
6997
6998 if (hash_mode == 10410)
6999 {
7000 outfile_format = 5;
7001 outfile_format_chgd = 1;
7002 }
7003
7004 /**
7005 * store stuff
7006 */
7007
7008 data.hash_mode = hash_mode;
7009 data.restore = restore;
7010 data.restore_timer = restore_timer;
7011 data.restore_disable = restore_disable;
7012 data.status = status;
7013 data.status_timer = status_timer;
7014 data.machine_readable = machine_readable;
7015 data.loopback = loopback;
7016 data.runtime = runtime;
7017 data.remove = remove;
7018 data.remove_timer = remove_timer;
7019 data.debug_mode = debug_mode;
7020 data.debug_file = debug_file;
7021 data.username = username;
7022 data.quiet = quiet;
7023 data.outfile = outfile;
7024 data.outfile_format = outfile_format;
7025 data.outfile_autohex = outfile_autohex;
7026 data.hex_charset = hex_charset;
7027 data.hex_salt = hex_salt;
7028 data.hex_wordlist = hex_wordlist;
7029 data.separator = separator;
7030 data.rp_files = rp_files;
7031 data.rp_files_cnt = rp_files_cnt;
7032 data.rp_gen = rp_gen;
7033 data.rp_gen_seed = rp_gen_seed;
7034 data.force = force;
7035 data.benchmark = benchmark;
7036 data.skip = skip;
7037 data.limit = limit;
7038 #ifdef HAVE_HWMON
7039 data.powertune_enable = powertune_enable;
7040 #endif
7041 data.logfile_disable = logfile_disable;
7042 data.truecrypt_keyfiles = truecrypt_keyfiles;
7043 data.veracrypt_keyfiles = veracrypt_keyfiles;
7044 data.veracrypt_pim = veracrypt_pim;
7045 data.scrypt_tmto = scrypt_tmto;
7046 data.workload_profile = workload_profile;
7047
7048 /**
7049 * cpu affinity
7050 */
7051
7052 if (cpu_affinity)
7053 {
7054 set_cpu_affinity (cpu_affinity);
7055 }
7056
7057 if (rp_gen_seed_chgd == 0)
7058 {
7059 srand (proc_start);
7060 }
7061 else
7062 {
7063 srand (rp_gen_seed);
7064 }
7065
7066 /**
7067 * logfile init
7068 */
7069
7070 if (logfile_disable == 0)
7071 {
7072 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7073
7074 char *logfile = (char *) mymalloc (logfile_size);
7075
7076 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7077
7078 data.logfile = logfile;
7079
7080 char *topid = logfile_generate_topid ();
7081
7082 data.topid = topid;
7083 }
7084
7085 // logfile_append() checks for logfile_disable internally to make it easier from here
7086
7087 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7088 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7089 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7090 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7091 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7092 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7093 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7094 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7095 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7096 #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));
7097
7098 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7099 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7100 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7101 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7102 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7103 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7104 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7105 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7106
7107 logfile_top_msg ("START");
7108
7109 logfile_top_uint (attack_mode);
7110 logfile_top_uint (attack_kern);
7111 logfile_top_uint (benchmark);
7112 logfile_top_uint (stdout_flag);
7113 logfile_top_uint (bitmap_min);
7114 logfile_top_uint (bitmap_max);
7115 logfile_top_uint (debug_mode);
7116 logfile_top_uint (force);
7117 logfile_top_uint (kernel_accel);
7118 logfile_top_uint (kernel_loops);
7119 logfile_top_uint (nvidia_spin_damp);
7120 logfile_top_uint (gpu_temp_disable);
7121 #ifdef HAVE_HWMON
7122 logfile_top_uint (gpu_temp_abort);
7123 logfile_top_uint (gpu_temp_retain);
7124 #endif
7125 logfile_top_uint (hash_mode);
7126 logfile_top_uint (hex_charset);
7127 logfile_top_uint (hex_salt);
7128 logfile_top_uint (hex_wordlist);
7129 logfile_top_uint (increment);
7130 logfile_top_uint (increment_max);
7131 logfile_top_uint (increment_min);
7132 logfile_top_uint (keyspace);
7133 logfile_top_uint (left);
7134 logfile_top_uint (logfile_disable);
7135 logfile_top_uint (loopback);
7136 logfile_top_uint (markov_classic);
7137 logfile_top_uint (markov_disable);
7138 logfile_top_uint (markov_threshold);
7139 logfile_top_uint (outfile_autohex);
7140 logfile_top_uint (outfile_check_timer);
7141 logfile_top_uint (outfile_format);
7142 logfile_top_uint (potfile_disable);
7143 logfile_top_string (potfile_path);
7144 #if defined(HAVE_HWMON)
7145 logfile_top_uint (powertune_enable);
7146 #endif
7147 logfile_top_uint (scrypt_tmto);
7148 logfile_top_uint (quiet);
7149 logfile_top_uint (remove);
7150 logfile_top_uint (remove_timer);
7151 logfile_top_uint (restore);
7152 logfile_top_uint (restore_disable);
7153 logfile_top_uint (restore_timer);
7154 logfile_top_uint (rp_gen);
7155 logfile_top_uint (rp_gen_func_max);
7156 logfile_top_uint (rp_gen_func_min);
7157 logfile_top_uint (rp_gen_seed);
7158 logfile_top_uint (runtime);
7159 logfile_top_uint (segment_size);
7160 logfile_top_uint (show);
7161 logfile_top_uint (status);
7162 logfile_top_uint (machine_readable);
7163 logfile_top_uint (status_timer);
7164 logfile_top_uint (usage);
7165 logfile_top_uint (username);
7166 logfile_top_uint (version);
7167 logfile_top_uint (weak_hash_threshold);
7168 logfile_top_uint (workload_profile);
7169 logfile_top_uint64 (limit);
7170 logfile_top_uint64 (skip);
7171 logfile_top_char (separator);
7172 logfile_top_string (cpu_affinity);
7173 logfile_top_string (custom_charset_1);
7174 logfile_top_string (custom_charset_2);
7175 logfile_top_string (custom_charset_3);
7176 logfile_top_string (custom_charset_4);
7177 logfile_top_string (debug_file);
7178 logfile_top_string (opencl_devices);
7179 logfile_top_string (opencl_platforms);
7180 logfile_top_string (opencl_device_types);
7181 logfile_top_uint (opencl_vector_width);
7182 logfile_top_string (induction_dir);
7183 logfile_top_string (markov_hcstat);
7184 logfile_top_string (outfile);
7185 logfile_top_string (outfile_check_dir);
7186 logfile_top_string (rule_buf_l);
7187 logfile_top_string (rule_buf_r);
7188 logfile_top_string (session);
7189 logfile_top_string (truecrypt_keyfiles);
7190 logfile_top_string (veracrypt_keyfiles);
7191 logfile_top_uint (veracrypt_pim);
7192
7193 /**
7194 * Init OpenCL library loader
7195 */
7196
7197 if (keyspace == 0)
7198 {
7199 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7200
7201 ocl_init (ocl);
7202
7203 data.ocl = ocl;
7204 }
7205
7206 /**
7207 * OpenCL platform selection
7208 */
7209
7210 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7211
7212 /**
7213 * OpenCL device selection
7214 */
7215
7216 u32 devices_filter = setup_devices_filter (opencl_devices);
7217
7218 /**
7219 * OpenCL device type selection
7220 */
7221
7222 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7223
7224 /**
7225 * benchmark
7226 */
7227
7228 if (benchmark == 1)
7229 {
7230 /**
7231 * disable useless stuff for benchmark
7232 */
7233
7234 status_timer = 0;
7235 restore_timer = 0;
7236 restore_disable = 1;
7237 potfile_disable = 1;
7238 weak_hash_threshold = 0;
7239 nvidia_spin_damp = 0;
7240 gpu_temp_disable = 1;
7241 outfile_check_timer = 0;
7242
7243 #ifdef HAVE_HWMON
7244 if (powertune_enable == 1)
7245 {
7246 gpu_temp_disable = 0;
7247 }
7248 #endif
7249
7250 data.status_timer = status_timer;
7251 data.restore_timer = restore_timer;
7252 data.restore_disable = restore_disable;
7253 data.outfile_check_timer = outfile_check_timer;
7254
7255 /**
7256 * force attack mode to be bruteforce
7257 */
7258
7259 attack_mode = ATTACK_MODE_BF;
7260 attack_kern = ATTACK_KERN_BF;
7261
7262 if (workload_profile_chgd == 0)
7263 {
7264 workload_profile = 3;
7265
7266 data.workload_profile = workload_profile;
7267 }
7268 }
7269
7270 /**
7271 * config
7272 */
7273
7274 uint hash_type = 0;
7275 uint salt_type = 0;
7276 uint attack_exec = 0;
7277 uint opts_type = 0;
7278 uint kern_type = 0;
7279 uint dgst_size = 0;
7280 uint esalt_size = 0;
7281 uint opti_type = 0;
7282 uint dgst_pos0 = -1;
7283 uint dgst_pos1 = -1;
7284 uint dgst_pos2 = -1;
7285 uint dgst_pos3 = -1;
7286
7287 int (*parse_func) (char *, uint, hash_t *);
7288 int (*sort_by_digest) (const void *, const void *);
7289
7290 uint algorithm_pos = 0;
7291 uint algorithm_max = 1;
7292
7293 uint *algorithms = default_benchmark_algorithms;
7294
7295 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7296
7297 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7298 {
7299 /*
7300 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7301 * the following algos are skipped entirely
7302 */
7303
7304 if (algorithm_pos > 0)
7305 {
7306 local_free (rd);
7307
7308 rd = init_restore (argc, argv);
7309
7310 data.rd = rd;
7311 }
7312
7313 /**
7314 * update hash_mode in case of multihash benchmark
7315 */
7316
7317 if (benchmark == 1)
7318 {
7319 if (hash_mode_chgd == 0)
7320 {
7321 hash_mode = algorithms[algorithm_pos];
7322
7323 data.hash_mode = hash_mode;
7324 }
7325
7326 quiet = 1;
7327
7328 data.quiet = quiet;
7329 }
7330
7331 switch (hash_mode)
7332 {
7333 case 0: hash_type = HASH_TYPE_MD5;
7334 salt_type = SALT_TYPE_NONE;
7335 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7336 opts_type = OPTS_TYPE_PT_GENERATE_LE
7337 | OPTS_TYPE_PT_ADD80
7338 | OPTS_TYPE_PT_ADDBITS14;
7339 kern_type = KERN_TYPE_MD5;
7340 dgst_size = DGST_SIZE_4_4;
7341 parse_func = md5_parse_hash;
7342 sort_by_digest = sort_by_digest_4_4;
7343 opti_type = OPTI_TYPE_ZERO_BYTE
7344 | OPTI_TYPE_PRECOMPUTE_INIT
7345 | OPTI_TYPE_PRECOMPUTE_MERKLE
7346 | OPTI_TYPE_MEET_IN_MIDDLE
7347 | OPTI_TYPE_EARLY_SKIP
7348 | OPTI_TYPE_NOT_ITERATED
7349 | OPTI_TYPE_NOT_SALTED
7350 | OPTI_TYPE_RAW_HASH;
7351 dgst_pos0 = 0;
7352 dgst_pos1 = 3;
7353 dgst_pos2 = 2;
7354 dgst_pos3 = 1;
7355 break;
7356
7357 case 10: hash_type = HASH_TYPE_MD5;
7358 salt_type = SALT_TYPE_INTERN;
7359 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7360 opts_type = OPTS_TYPE_PT_GENERATE_LE
7361 | OPTS_TYPE_ST_ADD80
7362 | OPTS_TYPE_ST_ADDBITS14;
7363 kern_type = KERN_TYPE_MD5_PWSLT;
7364 dgst_size = DGST_SIZE_4_4;
7365 parse_func = md5s_parse_hash;
7366 sort_by_digest = sort_by_digest_4_4;
7367 opti_type = OPTI_TYPE_ZERO_BYTE
7368 | OPTI_TYPE_PRECOMPUTE_INIT
7369 | OPTI_TYPE_PRECOMPUTE_MERKLE
7370 | OPTI_TYPE_MEET_IN_MIDDLE
7371 | OPTI_TYPE_EARLY_SKIP
7372 | OPTI_TYPE_NOT_ITERATED
7373 | OPTI_TYPE_APPENDED_SALT
7374 | OPTI_TYPE_RAW_HASH;
7375 dgst_pos0 = 0;
7376 dgst_pos1 = 3;
7377 dgst_pos2 = 2;
7378 dgst_pos3 = 1;
7379 break;
7380
7381 case 11: hash_type = HASH_TYPE_MD5;
7382 salt_type = SALT_TYPE_INTERN;
7383 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7384 opts_type = OPTS_TYPE_PT_GENERATE_LE
7385 | OPTS_TYPE_ST_ADD80
7386 | OPTS_TYPE_ST_ADDBITS14;
7387 kern_type = KERN_TYPE_MD5_PWSLT;
7388 dgst_size = DGST_SIZE_4_4;
7389 parse_func = joomla_parse_hash;
7390 sort_by_digest = sort_by_digest_4_4;
7391 opti_type = OPTI_TYPE_ZERO_BYTE
7392 | OPTI_TYPE_PRECOMPUTE_INIT
7393 | OPTI_TYPE_PRECOMPUTE_MERKLE
7394 | OPTI_TYPE_MEET_IN_MIDDLE
7395 | OPTI_TYPE_EARLY_SKIP
7396 | OPTI_TYPE_NOT_ITERATED
7397 | OPTI_TYPE_APPENDED_SALT
7398 | OPTI_TYPE_RAW_HASH;
7399 dgst_pos0 = 0;
7400 dgst_pos1 = 3;
7401 dgst_pos2 = 2;
7402 dgst_pos3 = 1;
7403 break;
7404
7405 case 12: hash_type = HASH_TYPE_MD5;
7406 salt_type = SALT_TYPE_INTERN;
7407 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7408 opts_type = OPTS_TYPE_PT_GENERATE_LE
7409 | OPTS_TYPE_ST_ADD80
7410 | OPTS_TYPE_ST_ADDBITS14;
7411 kern_type = KERN_TYPE_MD5_PWSLT;
7412 dgst_size = DGST_SIZE_4_4;
7413 parse_func = postgresql_parse_hash;
7414 sort_by_digest = sort_by_digest_4_4;
7415 opti_type = OPTI_TYPE_ZERO_BYTE
7416 | OPTI_TYPE_PRECOMPUTE_INIT
7417 | OPTI_TYPE_PRECOMPUTE_MERKLE
7418 | OPTI_TYPE_MEET_IN_MIDDLE
7419 | OPTI_TYPE_EARLY_SKIP
7420 | OPTI_TYPE_NOT_ITERATED
7421 | OPTI_TYPE_APPENDED_SALT
7422 | OPTI_TYPE_RAW_HASH;
7423 dgst_pos0 = 0;
7424 dgst_pos1 = 3;
7425 dgst_pos2 = 2;
7426 dgst_pos3 = 1;
7427 break;
7428
7429 case 20: hash_type = HASH_TYPE_MD5;
7430 salt_type = SALT_TYPE_INTERN;
7431 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7432 opts_type = OPTS_TYPE_PT_GENERATE_LE
7433 | OPTS_TYPE_PT_ADD80
7434 | OPTS_TYPE_PT_ADDBITS14;
7435 kern_type = KERN_TYPE_MD5_SLTPW;
7436 dgst_size = DGST_SIZE_4_4;
7437 parse_func = md5s_parse_hash;
7438 sort_by_digest = sort_by_digest_4_4;
7439 opti_type = OPTI_TYPE_ZERO_BYTE
7440 | OPTI_TYPE_PRECOMPUTE_INIT
7441 | OPTI_TYPE_PRECOMPUTE_MERKLE
7442 | OPTI_TYPE_EARLY_SKIP
7443 | OPTI_TYPE_NOT_ITERATED
7444 | OPTI_TYPE_PREPENDED_SALT
7445 | OPTI_TYPE_RAW_HASH;
7446 dgst_pos0 = 0;
7447 dgst_pos1 = 3;
7448 dgst_pos2 = 2;
7449 dgst_pos3 = 1;
7450 break;
7451
7452 case 21: hash_type = HASH_TYPE_MD5;
7453 salt_type = SALT_TYPE_INTERN;
7454 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7455 opts_type = OPTS_TYPE_PT_GENERATE_LE
7456 | OPTS_TYPE_PT_ADD80
7457 | OPTS_TYPE_PT_ADDBITS14;
7458 kern_type = KERN_TYPE_MD5_SLTPW;
7459 dgst_size = DGST_SIZE_4_4;
7460 parse_func = osc_parse_hash;
7461 sort_by_digest = sort_by_digest_4_4;
7462 opti_type = OPTI_TYPE_ZERO_BYTE
7463 | OPTI_TYPE_PRECOMPUTE_INIT
7464 | OPTI_TYPE_PRECOMPUTE_MERKLE
7465 | OPTI_TYPE_EARLY_SKIP
7466 | OPTI_TYPE_NOT_ITERATED
7467 | OPTI_TYPE_PREPENDED_SALT
7468 | OPTI_TYPE_RAW_HASH;
7469 dgst_pos0 = 0;
7470 dgst_pos1 = 3;
7471 dgst_pos2 = 2;
7472 dgst_pos3 = 1;
7473 break;
7474
7475 case 22: hash_type = HASH_TYPE_MD5;
7476 salt_type = SALT_TYPE_EMBEDDED;
7477 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7478 opts_type = OPTS_TYPE_PT_GENERATE_LE
7479 | OPTS_TYPE_PT_ADD80
7480 | OPTS_TYPE_PT_ADDBITS14;
7481 kern_type = KERN_TYPE_MD5_SLTPW;
7482 dgst_size = DGST_SIZE_4_4;
7483 parse_func = netscreen_parse_hash;
7484 sort_by_digest = sort_by_digest_4_4;
7485 opti_type = OPTI_TYPE_ZERO_BYTE
7486 | OPTI_TYPE_PRECOMPUTE_INIT
7487 | OPTI_TYPE_PRECOMPUTE_MERKLE
7488 | OPTI_TYPE_EARLY_SKIP
7489 | OPTI_TYPE_NOT_ITERATED
7490 | OPTI_TYPE_PREPENDED_SALT
7491 | OPTI_TYPE_RAW_HASH;
7492 dgst_pos0 = 0;
7493 dgst_pos1 = 3;
7494 dgst_pos2 = 2;
7495 dgst_pos3 = 1;
7496 break;
7497
7498 case 23: hash_type = HASH_TYPE_MD5;
7499 salt_type = SALT_TYPE_EMBEDDED;
7500 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7501 opts_type = OPTS_TYPE_PT_GENERATE_LE
7502 | OPTS_TYPE_PT_ADD80
7503 | OPTS_TYPE_PT_ADDBITS14;
7504 kern_type = KERN_TYPE_MD5_SLTPW;
7505 dgst_size = DGST_SIZE_4_4;
7506 parse_func = skype_parse_hash;
7507 sort_by_digest = sort_by_digest_4_4;
7508 opti_type = OPTI_TYPE_ZERO_BYTE
7509 | OPTI_TYPE_PRECOMPUTE_INIT
7510 | OPTI_TYPE_PRECOMPUTE_MERKLE
7511 | OPTI_TYPE_EARLY_SKIP
7512 | OPTI_TYPE_NOT_ITERATED
7513 | OPTI_TYPE_PREPENDED_SALT
7514 | OPTI_TYPE_RAW_HASH;
7515 dgst_pos0 = 0;
7516 dgst_pos1 = 3;
7517 dgst_pos2 = 2;
7518 dgst_pos3 = 1;
7519 break;
7520
7521 case 30: hash_type = HASH_TYPE_MD5;
7522 salt_type = SALT_TYPE_INTERN;
7523 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7524 opts_type = OPTS_TYPE_PT_GENERATE_LE
7525 | OPTS_TYPE_PT_UNICODE
7526 | OPTS_TYPE_ST_ADD80
7527 | OPTS_TYPE_ST_ADDBITS14;
7528 kern_type = KERN_TYPE_MD5_PWUSLT;
7529 dgst_size = DGST_SIZE_4_4;
7530 parse_func = md5s_parse_hash;
7531 sort_by_digest = sort_by_digest_4_4;
7532 opti_type = OPTI_TYPE_ZERO_BYTE
7533 | OPTI_TYPE_PRECOMPUTE_INIT
7534 | OPTI_TYPE_PRECOMPUTE_MERKLE
7535 | OPTI_TYPE_MEET_IN_MIDDLE
7536 | OPTI_TYPE_EARLY_SKIP
7537 | OPTI_TYPE_NOT_ITERATED
7538 | OPTI_TYPE_APPENDED_SALT
7539 | OPTI_TYPE_RAW_HASH;
7540 dgst_pos0 = 0;
7541 dgst_pos1 = 3;
7542 dgst_pos2 = 2;
7543 dgst_pos3 = 1;
7544 break;
7545
7546 case 40: hash_type = HASH_TYPE_MD5;
7547 salt_type = SALT_TYPE_INTERN;
7548 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7549 opts_type = OPTS_TYPE_PT_GENERATE_LE
7550 | OPTS_TYPE_PT_ADD80
7551 | OPTS_TYPE_PT_ADDBITS14
7552 | OPTS_TYPE_PT_UNICODE;
7553 kern_type = KERN_TYPE_MD5_SLTPWU;
7554 dgst_size = DGST_SIZE_4_4;
7555 parse_func = md5s_parse_hash;
7556 sort_by_digest = sort_by_digest_4_4;
7557 opti_type = OPTI_TYPE_ZERO_BYTE
7558 | OPTI_TYPE_PRECOMPUTE_INIT
7559 | OPTI_TYPE_PRECOMPUTE_MERKLE
7560 | OPTI_TYPE_EARLY_SKIP
7561 | OPTI_TYPE_NOT_ITERATED
7562 | OPTI_TYPE_PREPENDED_SALT
7563 | OPTI_TYPE_RAW_HASH;
7564 dgst_pos0 = 0;
7565 dgst_pos1 = 3;
7566 dgst_pos2 = 2;
7567 dgst_pos3 = 1;
7568 break;
7569
7570 case 50: hash_type = HASH_TYPE_MD5;
7571 salt_type = SALT_TYPE_INTERN;
7572 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7573 opts_type = OPTS_TYPE_PT_GENERATE_LE
7574 | OPTS_TYPE_ST_ADD80
7575 | OPTS_TYPE_ST_ADDBITS14;
7576 kern_type = KERN_TYPE_HMACMD5_PW;
7577 dgst_size = DGST_SIZE_4_4;
7578 parse_func = hmacmd5_parse_hash;
7579 sort_by_digest = sort_by_digest_4_4;
7580 opti_type = OPTI_TYPE_ZERO_BYTE
7581 | OPTI_TYPE_NOT_ITERATED;
7582 dgst_pos0 = 0;
7583 dgst_pos1 = 3;
7584 dgst_pos2 = 2;
7585 dgst_pos3 = 1;
7586 break;
7587
7588 case 60: hash_type = HASH_TYPE_MD5;
7589 salt_type = SALT_TYPE_INTERN;
7590 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7591 opts_type = OPTS_TYPE_PT_GENERATE_LE
7592 | OPTS_TYPE_PT_ADD80
7593 | OPTS_TYPE_PT_ADDBITS14;
7594 kern_type = KERN_TYPE_HMACMD5_SLT;
7595 dgst_size = DGST_SIZE_4_4;
7596 parse_func = hmacmd5_parse_hash;
7597 sort_by_digest = sort_by_digest_4_4;
7598 opti_type = OPTI_TYPE_ZERO_BYTE
7599 | OPTI_TYPE_NOT_ITERATED;
7600 dgst_pos0 = 0;
7601 dgst_pos1 = 3;
7602 dgst_pos2 = 2;
7603 dgst_pos3 = 1;
7604 break;
7605
7606 case 100: hash_type = HASH_TYPE_SHA1;
7607 salt_type = SALT_TYPE_NONE;
7608 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7609 opts_type = OPTS_TYPE_PT_GENERATE_BE
7610 | OPTS_TYPE_PT_ADD80
7611 | OPTS_TYPE_PT_ADDBITS15;
7612 kern_type = KERN_TYPE_SHA1;
7613 dgst_size = DGST_SIZE_4_5;
7614 parse_func = sha1_parse_hash;
7615 sort_by_digest = sort_by_digest_4_5;
7616 opti_type = OPTI_TYPE_ZERO_BYTE
7617 | OPTI_TYPE_PRECOMPUTE_INIT
7618 | OPTI_TYPE_PRECOMPUTE_MERKLE
7619 | OPTI_TYPE_EARLY_SKIP
7620 | OPTI_TYPE_NOT_ITERATED
7621 | OPTI_TYPE_NOT_SALTED
7622 | OPTI_TYPE_RAW_HASH;
7623 dgst_pos0 = 3;
7624 dgst_pos1 = 4;
7625 dgst_pos2 = 2;
7626 dgst_pos3 = 1;
7627 break;
7628
7629 case 101: hash_type = HASH_TYPE_SHA1;
7630 salt_type = SALT_TYPE_NONE;
7631 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7632 opts_type = OPTS_TYPE_PT_GENERATE_BE
7633 | OPTS_TYPE_PT_ADD80
7634 | OPTS_TYPE_PT_ADDBITS15;
7635 kern_type = KERN_TYPE_SHA1;
7636 dgst_size = DGST_SIZE_4_5;
7637 parse_func = sha1b64_parse_hash;
7638 sort_by_digest = sort_by_digest_4_5;
7639 opti_type = OPTI_TYPE_ZERO_BYTE
7640 | OPTI_TYPE_PRECOMPUTE_INIT
7641 | OPTI_TYPE_PRECOMPUTE_MERKLE
7642 | OPTI_TYPE_EARLY_SKIP
7643 | OPTI_TYPE_NOT_ITERATED
7644 | OPTI_TYPE_NOT_SALTED
7645 | OPTI_TYPE_RAW_HASH;
7646 dgst_pos0 = 3;
7647 dgst_pos1 = 4;
7648 dgst_pos2 = 2;
7649 dgst_pos3 = 1;
7650 break;
7651
7652 case 110: hash_type = HASH_TYPE_SHA1;
7653 salt_type = SALT_TYPE_INTERN;
7654 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7655 opts_type = OPTS_TYPE_PT_GENERATE_BE
7656 | OPTS_TYPE_ST_ADD80
7657 | OPTS_TYPE_ST_ADDBITS15;
7658 kern_type = KERN_TYPE_SHA1_PWSLT;
7659 dgst_size = DGST_SIZE_4_5;
7660 parse_func = sha1s_parse_hash;
7661 sort_by_digest = sort_by_digest_4_5;
7662 opti_type = OPTI_TYPE_ZERO_BYTE
7663 | OPTI_TYPE_PRECOMPUTE_INIT
7664 | OPTI_TYPE_PRECOMPUTE_MERKLE
7665 | OPTI_TYPE_EARLY_SKIP
7666 | OPTI_TYPE_NOT_ITERATED
7667 | OPTI_TYPE_APPENDED_SALT
7668 | OPTI_TYPE_RAW_HASH;
7669 dgst_pos0 = 3;
7670 dgst_pos1 = 4;
7671 dgst_pos2 = 2;
7672 dgst_pos3 = 1;
7673 break;
7674
7675 case 111: hash_type = HASH_TYPE_SHA1;
7676 salt_type = SALT_TYPE_EMBEDDED;
7677 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7678 opts_type = OPTS_TYPE_PT_GENERATE_BE
7679 | OPTS_TYPE_ST_ADD80
7680 | OPTS_TYPE_ST_ADDBITS15;
7681 kern_type = KERN_TYPE_SHA1_PWSLT;
7682 dgst_size = DGST_SIZE_4_5;
7683 parse_func = sha1b64s_parse_hash;
7684 sort_by_digest = sort_by_digest_4_5;
7685 opti_type = OPTI_TYPE_ZERO_BYTE
7686 | OPTI_TYPE_PRECOMPUTE_INIT
7687 | OPTI_TYPE_PRECOMPUTE_MERKLE
7688 | OPTI_TYPE_EARLY_SKIP
7689 | OPTI_TYPE_NOT_ITERATED
7690 | OPTI_TYPE_APPENDED_SALT
7691 | OPTI_TYPE_RAW_HASH;
7692 dgst_pos0 = 3;
7693 dgst_pos1 = 4;
7694 dgst_pos2 = 2;
7695 dgst_pos3 = 1;
7696 break;
7697
7698 case 112: hash_type = HASH_TYPE_SHA1;
7699 salt_type = SALT_TYPE_INTERN;
7700 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7701 opts_type = OPTS_TYPE_PT_GENERATE_BE
7702 | OPTS_TYPE_ST_ADD80
7703 | OPTS_TYPE_ST_ADDBITS15
7704 | OPTS_TYPE_ST_HEX;
7705 kern_type = KERN_TYPE_SHA1_PWSLT;
7706 dgst_size = DGST_SIZE_4_5;
7707 parse_func = oracles_parse_hash;
7708 sort_by_digest = sort_by_digest_4_5;
7709 opti_type = OPTI_TYPE_ZERO_BYTE
7710 | OPTI_TYPE_PRECOMPUTE_INIT
7711 | OPTI_TYPE_PRECOMPUTE_MERKLE
7712 | OPTI_TYPE_EARLY_SKIP
7713 | OPTI_TYPE_NOT_ITERATED
7714 | OPTI_TYPE_APPENDED_SALT
7715 | OPTI_TYPE_RAW_HASH;
7716 dgst_pos0 = 3;
7717 dgst_pos1 = 4;
7718 dgst_pos2 = 2;
7719 dgst_pos3 = 1;
7720 break;
7721
7722 case 120: hash_type = HASH_TYPE_SHA1;
7723 salt_type = SALT_TYPE_INTERN;
7724 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7725 opts_type = OPTS_TYPE_PT_GENERATE_BE
7726 | OPTS_TYPE_PT_ADD80
7727 | OPTS_TYPE_PT_ADDBITS15;
7728 kern_type = KERN_TYPE_SHA1_SLTPW;
7729 dgst_size = DGST_SIZE_4_5;
7730 parse_func = sha1s_parse_hash;
7731 sort_by_digest = sort_by_digest_4_5;
7732 opti_type = OPTI_TYPE_ZERO_BYTE
7733 | OPTI_TYPE_PRECOMPUTE_INIT
7734 | OPTI_TYPE_PRECOMPUTE_MERKLE
7735 | OPTI_TYPE_EARLY_SKIP
7736 | OPTI_TYPE_NOT_ITERATED
7737 | OPTI_TYPE_PREPENDED_SALT
7738 | OPTI_TYPE_RAW_HASH;
7739 dgst_pos0 = 3;
7740 dgst_pos1 = 4;
7741 dgst_pos2 = 2;
7742 dgst_pos3 = 1;
7743 break;
7744
7745 case 121: hash_type = HASH_TYPE_SHA1;
7746 salt_type = SALT_TYPE_INTERN;
7747 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7748 opts_type = OPTS_TYPE_PT_GENERATE_BE
7749 | OPTS_TYPE_PT_ADD80
7750 | OPTS_TYPE_PT_ADDBITS15
7751 | OPTS_TYPE_ST_LOWER;
7752 kern_type = KERN_TYPE_SHA1_SLTPW;
7753 dgst_size = DGST_SIZE_4_5;
7754 parse_func = smf_parse_hash;
7755 sort_by_digest = sort_by_digest_4_5;
7756 opti_type = OPTI_TYPE_ZERO_BYTE
7757 | OPTI_TYPE_PRECOMPUTE_INIT
7758 | OPTI_TYPE_PRECOMPUTE_MERKLE
7759 | OPTI_TYPE_EARLY_SKIP
7760 | OPTI_TYPE_NOT_ITERATED
7761 | OPTI_TYPE_PREPENDED_SALT
7762 | OPTI_TYPE_RAW_HASH;
7763 dgst_pos0 = 3;
7764 dgst_pos1 = 4;
7765 dgst_pos2 = 2;
7766 dgst_pos3 = 1;
7767 break;
7768
7769 case 122: hash_type = HASH_TYPE_SHA1;
7770 salt_type = SALT_TYPE_EMBEDDED;
7771 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7772 opts_type = OPTS_TYPE_PT_GENERATE_BE
7773 | OPTS_TYPE_PT_ADD80
7774 | OPTS_TYPE_PT_ADDBITS15
7775 | OPTS_TYPE_ST_HEX;
7776 kern_type = KERN_TYPE_SHA1_SLTPW;
7777 dgst_size = DGST_SIZE_4_5;
7778 parse_func = osx1_parse_hash;
7779 sort_by_digest = sort_by_digest_4_5;
7780 opti_type = OPTI_TYPE_ZERO_BYTE
7781 | OPTI_TYPE_PRECOMPUTE_INIT
7782 | OPTI_TYPE_PRECOMPUTE_MERKLE
7783 | OPTI_TYPE_EARLY_SKIP
7784 | OPTI_TYPE_NOT_ITERATED
7785 | OPTI_TYPE_PREPENDED_SALT
7786 | OPTI_TYPE_RAW_HASH;
7787 dgst_pos0 = 3;
7788 dgst_pos1 = 4;
7789 dgst_pos2 = 2;
7790 dgst_pos3 = 1;
7791 break;
7792
7793 case 124: hash_type = HASH_TYPE_SHA1;
7794 salt_type = SALT_TYPE_EMBEDDED;
7795 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7796 opts_type = OPTS_TYPE_PT_GENERATE_BE
7797 | OPTS_TYPE_PT_ADD80
7798 | OPTS_TYPE_PT_ADDBITS15;
7799 kern_type = KERN_TYPE_SHA1_SLTPW;
7800 dgst_size = DGST_SIZE_4_5;
7801 parse_func = djangosha1_parse_hash;
7802 sort_by_digest = sort_by_digest_4_5;
7803 opti_type = OPTI_TYPE_ZERO_BYTE
7804 | OPTI_TYPE_PRECOMPUTE_INIT
7805 | OPTI_TYPE_PRECOMPUTE_MERKLE
7806 | OPTI_TYPE_EARLY_SKIP
7807 | OPTI_TYPE_NOT_ITERATED
7808 | OPTI_TYPE_PREPENDED_SALT
7809 | OPTI_TYPE_RAW_HASH;
7810 dgst_pos0 = 3;
7811 dgst_pos1 = 4;
7812 dgst_pos2 = 2;
7813 dgst_pos3 = 1;
7814 break;
7815
7816 case 125: hash_type = HASH_TYPE_SHA1;
7817 salt_type = SALT_TYPE_EMBEDDED;
7818 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7819 opts_type = OPTS_TYPE_PT_GENERATE_BE
7820 | OPTS_TYPE_PT_ADD80
7821 | OPTS_TYPE_PT_ADDBITS15
7822 | OPTS_TYPE_ST_HEX;
7823 kern_type = KERN_TYPE_SHA1_SLTPW;
7824 dgst_size = DGST_SIZE_4_5;
7825 parse_func = arubaos_parse_hash;
7826 sort_by_digest = sort_by_digest_4_5;
7827 opti_type = OPTI_TYPE_ZERO_BYTE
7828 | OPTI_TYPE_PRECOMPUTE_INIT
7829 | OPTI_TYPE_PRECOMPUTE_MERKLE
7830 | OPTI_TYPE_EARLY_SKIP
7831 | OPTI_TYPE_NOT_ITERATED
7832 | OPTI_TYPE_PREPENDED_SALT
7833 | OPTI_TYPE_RAW_HASH;
7834 dgst_pos0 = 3;
7835 dgst_pos1 = 4;
7836 dgst_pos2 = 2;
7837 dgst_pos3 = 1;
7838 break;
7839
7840 case 130: hash_type = HASH_TYPE_SHA1;
7841 salt_type = SALT_TYPE_INTERN;
7842 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7843 opts_type = OPTS_TYPE_PT_GENERATE_BE
7844 | OPTS_TYPE_PT_UNICODE
7845 | OPTS_TYPE_ST_ADD80
7846 | OPTS_TYPE_ST_ADDBITS15;
7847 kern_type = KERN_TYPE_SHA1_PWUSLT;
7848 dgst_size = DGST_SIZE_4_5;
7849 parse_func = sha1s_parse_hash;
7850 sort_by_digest = sort_by_digest_4_5;
7851 opti_type = OPTI_TYPE_ZERO_BYTE
7852 | OPTI_TYPE_PRECOMPUTE_INIT
7853 | OPTI_TYPE_PRECOMPUTE_MERKLE
7854 | OPTI_TYPE_EARLY_SKIP
7855 | OPTI_TYPE_NOT_ITERATED
7856 | OPTI_TYPE_APPENDED_SALT
7857 | OPTI_TYPE_RAW_HASH;
7858 dgst_pos0 = 3;
7859 dgst_pos1 = 4;
7860 dgst_pos2 = 2;
7861 dgst_pos3 = 1;
7862 break;
7863
7864 case 131: hash_type = HASH_TYPE_SHA1;
7865 salt_type = SALT_TYPE_EMBEDDED;
7866 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7867 opts_type = OPTS_TYPE_PT_GENERATE_BE
7868 | OPTS_TYPE_PT_UNICODE
7869 | OPTS_TYPE_PT_UPPER
7870 | OPTS_TYPE_ST_ADD80
7871 | OPTS_TYPE_ST_ADDBITS15
7872 | OPTS_TYPE_ST_HEX;
7873 kern_type = KERN_TYPE_SHA1_PWUSLT;
7874 dgst_size = DGST_SIZE_4_5;
7875 parse_func = mssql2000_parse_hash;
7876 sort_by_digest = sort_by_digest_4_5;
7877 opti_type = OPTI_TYPE_ZERO_BYTE
7878 | OPTI_TYPE_PRECOMPUTE_INIT
7879 | OPTI_TYPE_PRECOMPUTE_MERKLE
7880 | OPTI_TYPE_EARLY_SKIP
7881 | OPTI_TYPE_NOT_ITERATED
7882 | OPTI_TYPE_APPENDED_SALT
7883 | OPTI_TYPE_RAW_HASH;
7884 dgst_pos0 = 3;
7885 dgst_pos1 = 4;
7886 dgst_pos2 = 2;
7887 dgst_pos3 = 1;
7888 break;
7889
7890 case 132: hash_type = HASH_TYPE_SHA1;
7891 salt_type = SALT_TYPE_EMBEDDED;
7892 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7893 opts_type = OPTS_TYPE_PT_GENERATE_BE
7894 | OPTS_TYPE_PT_UNICODE
7895 | OPTS_TYPE_ST_ADD80
7896 | OPTS_TYPE_ST_ADDBITS15
7897 | OPTS_TYPE_ST_HEX;
7898 kern_type = KERN_TYPE_SHA1_PWUSLT;
7899 dgst_size = DGST_SIZE_4_5;
7900 parse_func = mssql2005_parse_hash;
7901 sort_by_digest = sort_by_digest_4_5;
7902 opti_type = OPTI_TYPE_ZERO_BYTE
7903 | OPTI_TYPE_PRECOMPUTE_INIT
7904 | OPTI_TYPE_PRECOMPUTE_MERKLE
7905 | OPTI_TYPE_EARLY_SKIP
7906 | OPTI_TYPE_NOT_ITERATED
7907 | OPTI_TYPE_APPENDED_SALT
7908 | OPTI_TYPE_RAW_HASH;
7909 dgst_pos0 = 3;
7910 dgst_pos1 = 4;
7911 dgst_pos2 = 2;
7912 dgst_pos3 = 1;
7913 break;
7914
7915 case 133: hash_type = HASH_TYPE_SHA1;
7916 salt_type = SALT_TYPE_EMBEDDED;
7917 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7918 opts_type = OPTS_TYPE_PT_GENERATE_BE
7919 | OPTS_TYPE_PT_UNICODE
7920 | OPTS_TYPE_ST_ADD80
7921 | OPTS_TYPE_ST_ADDBITS15;
7922 kern_type = KERN_TYPE_SHA1_PWUSLT;
7923 dgst_size = DGST_SIZE_4_5;
7924 parse_func = peoplesoft_parse_hash;
7925 sort_by_digest = sort_by_digest_4_5;
7926 opti_type = OPTI_TYPE_ZERO_BYTE
7927 | OPTI_TYPE_PRECOMPUTE_INIT
7928 | OPTI_TYPE_PRECOMPUTE_MERKLE
7929 | OPTI_TYPE_EARLY_SKIP
7930 | OPTI_TYPE_NOT_ITERATED
7931 | OPTI_TYPE_APPENDED_SALT
7932 | OPTI_TYPE_RAW_HASH;
7933 dgst_pos0 = 3;
7934 dgst_pos1 = 4;
7935 dgst_pos2 = 2;
7936 dgst_pos3 = 1;
7937 break;
7938
7939 case 140: hash_type = HASH_TYPE_SHA1;
7940 salt_type = SALT_TYPE_INTERN;
7941 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7942 opts_type = OPTS_TYPE_PT_GENERATE_BE
7943 | OPTS_TYPE_PT_ADD80
7944 | OPTS_TYPE_PT_ADDBITS15
7945 | OPTS_TYPE_PT_UNICODE;
7946 kern_type = KERN_TYPE_SHA1_SLTPWU;
7947 dgst_size = DGST_SIZE_4_5;
7948 parse_func = sha1s_parse_hash;
7949 sort_by_digest = sort_by_digest_4_5;
7950 opti_type = OPTI_TYPE_ZERO_BYTE
7951 | OPTI_TYPE_PRECOMPUTE_INIT
7952 | OPTI_TYPE_PRECOMPUTE_MERKLE
7953 | OPTI_TYPE_EARLY_SKIP
7954 | OPTI_TYPE_NOT_ITERATED
7955 | OPTI_TYPE_PREPENDED_SALT
7956 | OPTI_TYPE_RAW_HASH;
7957 dgst_pos0 = 3;
7958 dgst_pos1 = 4;
7959 dgst_pos2 = 2;
7960 dgst_pos3 = 1;
7961 break;
7962
7963 case 141: hash_type = HASH_TYPE_SHA1;
7964 salt_type = SALT_TYPE_EMBEDDED;
7965 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7966 opts_type = OPTS_TYPE_PT_GENERATE_BE
7967 | OPTS_TYPE_PT_ADD80
7968 | OPTS_TYPE_PT_ADDBITS15
7969 | OPTS_TYPE_PT_UNICODE
7970 | OPTS_TYPE_ST_BASE64;
7971 kern_type = KERN_TYPE_SHA1_SLTPWU;
7972 dgst_size = DGST_SIZE_4_5;
7973 parse_func = episerver_parse_hash;
7974 sort_by_digest = sort_by_digest_4_5;
7975 opti_type = OPTI_TYPE_ZERO_BYTE
7976 | OPTI_TYPE_PRECOMPUTE_INIT
7977 | OPTI_TYPE_PRECOMPUTE_MERKLE
7978 | OPTI_TYPE_EARLY_SKIP
7979 | OPTI_TYPE_NOT_ITERATED
7980 | OPTI_TYPE_PREPENDED_SALT
7981 | OPTI_TYPE_RAW_HASH;
7982 dgst_pos0 = 3;
7983 dgst_pos1 = 4;
7984 dgst_pos2 = 2;
7985 dgst_pos3 = 1;
7986 break;
7987
7988 case 150: hash_type = HASH_TYPE_SHA1;
7989 salt_type = SALT_TYPE_INTERN;
7990 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7991 opts_type = OPTS_TYPE_PT_GENERATE_BE
7992 | OPTS_TYPE_ST_ADD80
7993 | OPTS_TYPE_ST_ADDBITS15;
7994 kern_type = KERN_TYPE_HMACSHA1_PW;
7995 dgst_size = DGST_SIZE_4_5;
7996 parse_func = hmacsha1_parse_hash;
7997 sort_by_digest = sort_by_digest_4_5;
7998 opti_type = OPTI_TYPE_ZERO_BYTE
7999 | OPTI_TYPE_NOT_ITERATED;
8000 dgst_pos0 = 3;
8001 dgst_pos1 = 4;
8002 dgst_pos2 = 2;
8003 dgst_pos3 = 1;
8004 break;
8005
8006 case 160: hash_type = HASH_TYPE_SHA1;
8007 salt_type = SALT_TYPE_INTERN;
8008 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8009 opts_type = OPTS_TYPE_PT_GENERATE_BE
8010 | OPTS_TYPE_PT_ADD80
8011 | OPTS_TYPE_PT_ADDBITS15;
8012 kern_type = KERN_TYPE_HMACSHA1_SLT;
8013 dgst_size = DGST_SIZE_4_5;
8014 parse_func = hmacsha1_parse_hash;
8015 sort_by_digest = sort_by_digest_4_5;
8016 opti_type = OPTI_TYPE_ZERO_BYTE
8017 | OPTI_TYPE_NOT_ITERATED;
8018 dgst_pos0 = 3;
8019 dgst_pos1 = 4;
8020 dgst_pos2 = 2;
8021 dgst_pos3 = 1;
8022 break;
8023
8024 case 190: hash_type = HASH_TYPE_SHA1;
8025 salt_type = SALT_TYPE_NONE;
8026 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8027 opts_type = OPTS_TYPE_PT_GENERATE_BE
8028 | OPTS_TYPE_PT_ADD80
8029 | OPTS_TYPE_PT_ADDBITS15;
8030 kern_type = KERN_TYPE_SHA1_LINKEDIN;
8031 dgst_size = DGST_SIZE_4_5;
8032 parse_func = sha1linkedin_parse_hash;
8033 sort_by_digest = sort_by_digest_4_5;
8034 opti_type = OPTI_TYPE_ZERO_BYTE
8035 | OPTI_TYPE_PRECOMPUTE_INIT
8036 | OPTI_TYPE_EARLY_SKIP
8037 | OPTI_TYPE_NOT_ITERATED
8038 | OPTI_TYPE_NOT_SALTED;
8039 dgst_pos0 = 0;
8040 dgst_pos1 = 4;
8041 dgst_pos2 = 3;
8042 dgst_pos3 = 2;
8043 break;
8044
8045 case 200: hash_type = HASH_TYPE_MYSQL;
8046 salt_type = SALT_TYPE_NONE;
8047 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8048 opts_type = 0;
8049 kern_type = KERN_TYPE_MYSQL;
8050 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8051 parse_func = mysql323_parse_hash;
8052 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8053 opti_type = OPTI_TYPE_ZERO_BYTE;
8054 dgst_pos0 = 0;
8055 dgst_pos1 = 1;
8056 dgst_pos2 = 2;
8057 dgst_pos3 = 3;
8058 break;
8059
8060 case 300: hash_type = HASH_TYPE_SHA1;
8061 salt_type = SALT_TYPE_NONE;
8062 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8063 opts_type = OPTS_TYPE_PT_GENERATE_BE
8064 | OPTS_TYPE_PT_ADD80
8065 | OPTS_TYPE_PT_ADDBITS15;
8066 kern_type = KERN_TYPE_MYSQL41;
8067 dgst_size = DGST_SIZE_4_5;
8068 parse_func = sha1_parse_hash;
8069 sort_by_digest = sort_by_digest_4_5;
8070 opti_type = OPTI_TYPE_ZERO_BYTE
8071 | OPTI_TYPE_PRECOMPUTE_INIT
8072 | OPTI_TYPE_PRECOMPUTE_MERKLE
8073 | OPTI_TYPE_EARLY_SKIP
8074 | OPTI_TYPE_NOT_ITERATED
8075 | OPTI_TYPE_NOT_SALTED;
8076 dgst_pos0 = 3;
8077 dgst_pos1 = 4;
8078 dgst_pos2 = 2;
8079 dgst_pos3 = 1;
8080 break;
8081
8082 case 400: hash_type = HASH_TYPE_MD5;
8083 salt_type = SALT_TYPE_EMBEDDED;
8084 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8085 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8086 kern_type = KERN_TYPE_PHPASS;
8087 dgst_size = DGST_SIZE_4_4;
8088 parse_func = phpass_parse_hash;
8089 sort_by_digest = sort_by_digest_4_4;
8090 opti_type = OPTI_TYPE_ZERO_BYTE
8091 | OPTI_TYPE_SLOW_HASH_SIMD;
8092 dgst_pos0 = 0;
8093 dgst_pos1 = 1;
8094 dgst_pos2 = 2;
8095 dgst_pos3 = 3;
8096 break;
8097
8098 case 500: hash_type = HASH_TYPE_MD5;
8099 salt_type = SALT_TYPE_EMBEDDED;
8100 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8101 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8102 kern_type = KERN_TYPE_MD5CRYPT;
8103 dgst_size = DGST_SIZE_4_4;
8104 parse_func = md5crypt_parse_hash;
8105 sort_by_digest = sort_by_digest_4_4;
8106 opti_type = OPTI_TYPE_ZERO_BYTE;
8107 dgst_pos0 = 0;
8108 dgst_pos1 = 1;
8109 dgst_pos2 = 2;
8110 dgst_pos3 = 3;
8111 break;
8112
8113 case 501: hash_type = HASH_TYPE_MD5;
8114 salt_type = SALT_TYPE_EMBEDDED;
8115 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8116 opts_type = OPTS_TYPE_PT_GENERATE_LE
8117 | OPTS_TYPE_HASH_COPY;
8118 kern_type = KERN_TYPE_MD5CRYPT;
8119 dgst_size = DGST_SIZE_4_4;
8120 parse_func = juniper_parse_hash;
8121 sort_by_digest = sort_by_digest_4_4;
8122 opti_type = OPTI_TYPE_ZERO_BYTE;
8123 dgst_pos0 = 0;
8124 dgst_pos1 = 1;
8125 dgst_pos2 = 2;
8126 dgst_pos3 = 3;
8127 break;
8128
8129 case 900: hash_type = HASH_TYPE_MD4;
8130 salt_type = SALT_TYPE_NONE;
8131 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8132 opts_type = OPTS_TYPE_PT_GENERATE_LE
8133 | OPTS_TYPE_PT_ADD80
8134 | OPTS_TYPE_PT_ADDBITS14;
8135 kern_type = KERN_TYPE_MD4;
8136 dgst_size = DGST_SIZE_4_4;
8137 parse_func = md4_parse_hash;
8138 sort_by_digest = sort_by_digest_4_4;
8139 opti_type = OPTI_TYPE_ZERO_BYTE
8140 | OPTI_TYPE_PRECOMPUTE_INIT
8141 | OPTI_TYPE_PRECOMPUTE_MERKLE
8142 | OPTI_TYPE_MEET_IN_MIDDLE
8143 | OPTI_TYPE_EARLY_SKIP
8144 | OPTI_TYPE_NOT_ITERATED
8145 | OPTI_TYPE_NOT_SALTED
8146 | OPTI_TYPE_RAW_HASH;
8147 dgst_pos0 = 0;
8148 dgst_pos1 = 3;
8149 dgst_pos2 = 2;
8150 dgst_pos3 = 1;
8151 break;
8152
8153 case 1000: hash_type = HASH_TYPE_MD4;
8154 salt_type = SALT_TYPE_NONE;
8155 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8156 opts_type = OPTS_TYPE_PT_GENERATE_LE
8157 | OPTS_TYPE_PT_ADD80
8158 | OPTS_TYPE_PT_ADDBITS14
8159 | OPTS_TYPE_PT_UNICODE;
8160 kern_type = KERN_TYPE_MD4_PWU;
8161 dgst_size = DGST_SIZE_4_4;
8162 parse_func = md4_parse_hash;
8163 sort_by_digest = sort_by_digest_4_4;
8164 opti_type = OPTI_TYPE_ZERO_BYTE
8165 | OPTI_TYPE_PRECOMPUTE_INIT
8166 | OPTI_TYPE_PRECOMPUTE_MERKLE
8167 | OPTI_TYPE_MEET_IN_MIDDLE
8168 | OPTI_TYPE_EARLY_SKIP
8169 | OPTI_TYPE_NOT_ITERATED
8170 | OPTI_TYPE_NOT_SALTED
8171 | OPTI_TYPE_RAW_HASH;
8172 dgst_pos0 = 0;
8173 dgst_pos1 = 3;
8174 dgst_pos2 = 2;
8175 dgst_pos3 = 1;
8176 break;
8177
8178 case 1100: hash_type = HASH_TYPE_MD4;
8179 salt_type = SALT_TYPE_INTERN;
8180 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8181 opts_type = OPTS_TYPE_PT_GENERATE_LE
8182 | OPTS_TYPE_PT_ADD80
8183 | OPTS_TYPE_PT_ADDBITS14
8184 | OPTS_TYPE_PT_UNICODE
8185 | OPTS_TYPE_ST_ADD80
8186 | OPTS_TYPE_ST_UNICODE
8187 | OPTS_TYPE_ST_LOWER;
8188 kern_type = KERN_TYPE_MD44_PWUSLT;
8189 dgst_size = DGST_SIZE_4_4;
8190 parse_func = dcc_parse_hash;
8191 sort_by_digest = sort_by_digest_4_4;
8192 opti_type = OPTI_TYPE_ZERO_BYTE
8193 | OPTI_TYPE_PRECOMPUTE_INIT
8194 | OPTI_TYPE_PRECOMPUTE_MERKLE
8195 | OPTI_TYPE_EARLY_SKIP
8196 | OPTI_TYPE_NOT_ITERATED;
8197 dgst_pos0 = 0;
8198 dgst_pos1 = 3;
8199 dgst_pos2 = 2;
8200 dgst_pos3 = 1;
8201 break;
8202
8203 case 1400: hash_type = HASH_TYPE_SHA256;
8204 salt_type = SALT_TYPE_NONE;
8205 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8206 opts_type = OPTS_TYPE_PT_GENERATE_BE
8207 | OPTS_TYPE_PT_ADD80
8208 | OPTS_TYPE_PT_ADDBITS15;
8209 kern_type = KERN_TYPE_SHA256;
8210 dgst_size = DGST_SIZE_4_8;
8211 parse_func = sha256_parse_hash;
8212 sort_by_digest = sort_by_digest_4_8;
8213 opti_type = OPTI_TYPE_ZERO_BYTE
8214 | OPTI_TYPE_PRECOMPUTE_INIT
8215 | OPTI_TYPE_PRECOMPUTE_MERKLE
8216 | OPTI_TYPE_EARLY_SKIP
8217 | OPTI_TYPE_NOT_ITERATED
8218 | OPTI_TYPE_NOT_SALTED
8219 | OPTI_TYPE_RAW_HASH;
8220 dgst_pos0 = 3;
8221 dgst_pos1 = 7;
8222 dgst_pos2 = 2;
8223 dgst_pos3 = 6;
8224 break;
8225
8226 case 1410: hash_type = HASH_TYPE_SHA256;
8227 salt_type = SALT_TYPE_INTERN;
8228 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8229 opts_type = OPTS_TYPE_PT_GENERATE_BE
8230 | OPTS_TYPE_ST_ADD80
8231 | OPTS_TYPE_ST_ADDBITS15;
8232 kern_type = KERN_TYPE_SHA256_PWSLT;
8233 dgst_size = DGST_SIZE_4_8;
8234 parse_func = sha256s_parse_hash;
8235 sort_by_digest = sort_by_digest_4_8;
8236 opti_type = OPTI_TYPE_ZERO_BYTE
8237 | OPTI_TYPE_PRECOMPUTE_INIT
8238 | OPTI_TYPE_PRECOMPUTE_MERKLE
8239 | OPTI_TYPE_EARLY_SKIP
8240 | OPTI_TYPE_NOT_ITERATED
8241 | OPTI_TYPE_APPENDED_SALT
8242 | OPTI_TYPE_RAW_HASH;
8243 dgst_pos0 = 3;
8244 dgst_pos1 = 7;
8245 dgst_pos2 = 2;
8246 dgst_pos3 = 6;
8247 break;
8248
8249 case 1420: hash_type = HASH_TYPE_SHA256;
8250 salt_type = SALT_TYPE_INTERN;
8251 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8252 opts_type = OPTS_TYPE_PT_GENERATE_BE
8253 | OPTS_TYPE_PT_ADD80
8254 | OPTS_TYPE_PT_ADDBITS15;
8255 kern_type = KERN_TYPE_SHA256_SLTPW;
8256 dgst_size = DGST_SIZE_4_8;
8257 parse_func = sha256s_parse_hash;
8258 sort_by_digest = sort_by_digest_4_8;
8259 opti_type = OPTI_TYPE_ZERO_BYTE
8260 | OPTI_TYPE_PRECOMPUTE_INIT
8261 | OPTI_TYPE_PRECOMPUTE_MERKLE
8262 | OPTI_TYPE_EARLY_SKIP
8263 | OPTI_TYPE_NOT_ITERATED
8264 | OPTI_TYPE_PREPENDED_SALT
8265 | OPTI_TYPE_RAW_HASH;
8266 dgst_pos0 = 3;
8267 dgst_pos1 = 7;
8268 dgst_pos2 = 2;
8269 dgst_pos3 = 6;
8270 break;
8271
8272 case 1421: hash_type = HASH_TYPE_SHA256;
8273 salt_type = SALT_TYPE_EMBEDDED;
8274 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8275 opts_type = OPTS_TYPE_PT_GENERATE_BE
8276 | OPTS_TYPE_PT_ADD80
8277 | OPTS_TYPE_PT_ADDBITS15;
8278 kern_type = KERN_TYPE_SHA256_SLTPW;
8279 dgst_size = DGST_SIZE_4_8;
8280 parse_func = hmailserver_parse_hash;
8281 sort_by_digest = sort_by_digest_4_8;
8282 opti_type = OPTI_TYPE_ZERO_BYTE
8283 | OPTI_TYPE_PRECOMPUTE_INIT
8284 | OPTI_TYPE_PRECOMPUTE_MERKLE
8285 | OPTI_TYPE_EARLY_SKIP
8286 | OPTI_TYPE_NOT_ITERATED
8287 | OPTI_TYPE_PREPENDED_SALT
8288 | OPTI_TYPE_RAW_HASH;
8289 dgst_pos0 = 3;
8290 dgst_pos1 = 7;
8291 dgst_pos2 = 2;
8292 dgst_pos3 = 6;
8293 break;
8294
8295 case 1430: hash_type = HASH_TYPE_SHA256;
8296 salt_type = SALT_TYPE_INTERN;
8297 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8298 opts_type = OPTS_TYPE_PT_GENERATE_BE
8299 | OPTS_TYPE_PT_UNICODE
8300 | OPTS_TYPE_ST_ADD80
8301 | OPTS_TYPE_ST_ADDBITS15;
8302 kern_type = KERN_TYPE_SHA256_PWUSLT;
8303 dgst_size = DGST_SIZE_4_8;
8304 parse_func = sha256s_parse_hash;
8305 sort_by_digest = sort_by_digest_4_8;
8306 opti_type = OPTI_TYPE_ZERO_BYTE
8307 | OPTI_TYPE_PRECOMPUTE_INIT
8308 | OPTI_TYPE_PRECOMPUTE_MERKLE
8309 | OPTI_TYPE_EARLY_SKIP
8310 | OPTI_TYPE_NOT_ITERATED
8311 | OPTI_TYPE_APPENDED_SALT
8312 | OPTI_TYPE_RAW_HASH;
8313 dgst_pos0 = 3;
8314 dgst_pos1 = 7;
8315 dgst_pos2 = 2;
8316 dgst_pos3 = 6;
8317 break;
8318
8319 case 1440: hash_type = HASH_TYPE_SHA256;
8320 salt_type = SALT_TYPE_INTERN;
8321 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8322 opts_type = OPTS_TYPE_PT_GENERATE_BE
8323 | OPTS_TYPE_PT_ADD80
8324 | OPTS_TYPE_PT_ADDBITS15
8325 | OPTS_TYPE_PT_UNICODE;
8326 kern_type = KERN_TYPE_SHA256_SLTPWU;
8327 dgst_size = DGST_SIZE_4_8;
8328 parse_func = sha256s_parse_hash;
8329 sort_by_digest = sort_by_digest_4_8;
8330 opti_type = OPTI_TYPE_ZERO_BYTE
8331 | OPTI_TYPE_PRECOMPUTE_INIT
8332 | OPTI_TYPE_PRECOMPUTE_MERKLE
8333 | OPTI_TYPE_EARLY_SKIP
8334 | OPTI_TYPE_NOT_ITERATED
8335 | OPTI_TYPE_PREPENDED_SALT
8336 | OPTI_TYPE_RAW_HASH;
8337 dgst_pos0 = 3;
8338 dgst_pos1 = 7;
8339 dgst_pos2 = 2;
8340 dgst_pos3 = 6;
8341 break;
8342
8343 case 1441: hash_type = HASH_TYPE_SHA256;
8344 salt_type = SALT_TYPE_EMBEDDED;
8345 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8346 opts_type = OPTS_TYPE_PT_GENERATE_BE
8347 | OPTS_TYPE_PT_ADD80
8348 | OPTS_TYPE_PT_ADDBITS15
8349 | OPTS_TYPE_PT_UNICODE
8350 | OPTS_TYPE_ST_BASE64;
8351 kern_type = KERN_TYPE_SHA256_SLTPWU;
8352 dgst_size = DGST_SIZE_4_8;
8353 parse_func = episerver4_parse_hash;
8354 sort_by_digest = sort_by_digest_4_8;
8355 opti_type = OPTI_TYPE_ZERO_BYTE
8356 | OPTI_TYPE_PRECOMPUTE_INIT
8357 | OPTI_TYPE_PRECOMPUTE_MERKLE
8358 | OPTI_TYPE_EARLY_SKIP
8359 | OPTI_TYPE_NOT_ITERATED
8360 | OPTI_TYPE_PREPENDED_SALT
8361 | OPTI_TYPE_RAW_HASH;
8362 dgst_pos0 = 3;
8363 dgst_pos1 = 7;
8364 dgst_pos2 = 2;
8365 dgst_pos3 = 6;
8366 break;
8367
8368 case 1450: hash_type = HASH_TYPE_SHA256;
8369 salt_type = SALT_TYPE_INTERN;
8370 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8371 opts_type = OPTS_TYPE_PT_GENERATE_BE
8372 | OPTS_TYPE_ST_ADD80;
8373 kern_type = KERN_TYPE_HMACSHA256_PW;
8374 dgst_size = DGST_SIZE_4_8;
8375 parse_func = hmacsha256_parse_hash;
8376 sort_by_digest = sort_by_digest_4_8;
8377 opti_type = OPTI_TYPE_ZERO_BYTE
8378 | OPTI_TYPE_NOT_ITERATED;
8379 dgst_pos0 = 3;
8380 dgst_pos1 = 7;
8381 dgst_pos2 = 2;
8382 dgst_pos3 = 6;
8383 break;
8384
8385 case 1460: hash_type = HASH_TYPE_SHA256;
8386 salt_type = SALT_TYPE_INTERN;
8387 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8388 opts_type = OPTS_TYPE_PT_GENERATE_BE
8389 | OPTS_TYPE_PT_ADD80
8390 | OPTS_TYPE_PT_ADDBITS15;
8391 kern_type = KERN_TYPE_HMACSHA256_SLT;
8392 dgst_size = DGST_SIZE_4_8;
8393 parse_func = hmacsha256_parse_hash;
8394 sort_by_digest = sort_by_digest_4_8;
8395 opti_type = OPTI_TYPE_ZERO_BYTE
8396 | OPTI_TYPE_NOT_ITERATED;
8397 dgst_pos0 = 3;
8398 dgst_pos1 = 7;
8399 dgst_pos2 = 2;
8400 dgst_pos3 = 6;
8401 break;
8402
8403 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8404 salt_type = SALT_TYPE_EMBEDDED;
8405 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8406 opts_type = OPTS_TYPE_PT_GENERATE_LE
8407 | OPTS_TYPE_PT_BITSLICE;
8408 kern_type = KERN_TYPE_DESCRYPT;
8409 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8410 parse_func = descrypt_parse_hash;
8411 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8412 opti_type = OPTI_TYPE_ZERO_BYTE
8413 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8414 dgst_pos0 = 0;
8415 dgst_pos1 = 1;
8416 dgst_pos2 = 2;
8417 dgst_pos3 = 3;
8418 break;
8419
8420 case 1600: hash_type = HASH_TYPE_MD5;
8421 salt_type = SALT_TYPE_EMBEDDED;
8422 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8423 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8424 kern_type = KERN_TYPE_APR1CRYPT;
8425 dgst_size = DGST_SIZE_4_4;
8426 parse_func = md5apr1_parse_hash;
8427 sort_by_digest = sort_by_digest_4_4;
8428 opti_type = OPTI_TYPE_ZERO_BYTE;
8429 dgst_pos0 = 0;
8430 dgst_pos1 = 1;
8431 dgst_pos2 = 2;
8432 dgst_pos3 = 3;
8433 break;
8434
8435 case 1700: hash_type = HASH_TYPE_SHA512;
8436 salt_type = SALT_TYPE_NONE;
8437 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8438 opts_type = OPTS_TYPE_PT_GENERATE_BE
8439 | OPTS_TYPE_PT_ADD80
8440 | OPTS_TYPE_PT_ADDBITS15;
8441 kern_type = KERN_TYPE_SHA512;
8442 dgst_size = DGST_SIZE_8_8;
8443 parse_func = sha512_parse_hash;
8444 sort_by_digest = sort_by_digest_8_8;
8445 opti_type = OPTI_TYPE_ZERO_BYTE
8446 | OPTI_TYPE_PRECOMPUTE_INIT
8447 | OPTI_TYPE_PRECOMPUTE_MERKLE
8448 | OPTI_TYPE_EARLY_SKIP
8449 | OPTI_TYPE_NOT_ITERATED
8450 | OPTI_TYPE_NOT_SALTED
8451 | OPTI_TYPE_USES_BITS_64
8452 | OPTI_TYPE_RAW_HASH;
8453 dgst_pos0 = 14;
8454 dgst_pos1 = 15;
8455 dgst_pos2 = 6;
8456 dgst_pos3 = 7;
8457 break;
8458
8459 case 1710: hash_type = HASH_TYPE_SHA512;
8460 salt_type = SALT_TYPE_INTERN;
8461 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8462 opts_type = OPTS_TYPE_PT_GENERATE_BE
8463 | OPTS_TYPE_ST_ADD80
8464 | OPTS_TYPE_ST_ADDBITS15;
8465 kern_type = KERN_TYPE_SHA512_PWSLT;
8466 dgst_size = DGST_SIZE_8_8;
8467 parse_func = sha512s_parse_hash;
8468 sort_by_digest = sort_by_digest_8_8;
8469 opti_type = OPTI_TYPE_ZERO_BYTE
8470 | OPTI_TYPE_PRECOMPUTE_INIT
8471 | OPTI_TYPE_PRECOMPUTE_MERKLE
8472 | OPTI_TYPE_EARLY_SKIP
8473 | OPTI_TYPE_NOT_ITERATED
8474 | OPTI_TYPE_APPENDED_SALT
8475 | OPTI_TYPE_USES_BITS_64
8476 | OPTI_TYPE_RAW_HASH;
8477 dgst_pos0 = 14;
8478 dgst_pos1 = 15;
8479 dgst_pos2 = 6;
8480 dgst_pos3 = 7;
8481 break;
8482
8483 case 1711: hash_type = HASH_TYPE_SHA512;
8484 salt_type = SALT_TYPE_EMBEDDED;
8485 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8486 opts_type = OPTS_TYPE_PT_GENERATE_BE
8487 | OPTS_TYPE_ST_ADD80
8488 | OPTS_TYPE_ST_ADDBITS15;
8489 kern_type = KERN_TYPE_SHA512_PWSLT;
8490 dgst_size = DGST_SIZE_8_8;
8491 parse_func = sha512b64s_parse_hash;
8492 sort_by_digest = sort_by_digest_8_8;
8493 opti_type = OPTI_TYPE_ZERO_BYTE
8494 | OPTI_TYPE_PRECOMPUTE_INIT
8495 | OPTI_TYPE_PRECOMPUTE_MERKLE
8496 | OPTI_TYPE_EARLY_SKIP
8497 | OPTI_TYPE_NOT_ITERATED
8498 | OPTI_TYPE_APPENDED_SALT
8499 | OPTI_TYPE_USES_BITS_64
8500 | OPTI_TYPE_RAW_HASH;
8501 dgst_pos0 = 14;
8502 dgst_pos1 = 15;
8503 dgst_pos2 = 6;
8504 dgst_pos3 = 7;
8505 break;
8506
8507 case 1720: hash_type = HASH_TYPE_SHA512;
8508 salt_type = SALT_TYPE_INTERN;
8509 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8510 opts_type = OPTS_TYPE_PT_GENERATE_BE
8511 | OPTS_TYPE_PT_ADD80
8512 | OPTS_TYPE_PT_ADDBITS15;
8513 kern_type = KERN_TYPE_SHA512_SLTPW;
8514 dgst_size = DGST_SIZE_8_8;
8515 parse_func = sha512s_parse_hash;
8516 sort_by_digest = sort_by_digest_8_8;
8517 opti_type = OPTI_TYPE_ZERO_BYTE
8518 | OPTI_TYPE_PRECOMPUTE_INIT
8519 | OPTI_TYPE_PRECOMPUTE_MERKLE
8520 | OPTI_TYPE_EARLY_SKIP
8521 | OPTI_TYPE_NOT_ITERATED
8522 | OPTI_TYPE_PREPENDED_SALT
8523 | OPTI_TYPE_USES_BITS_64
8524 | OPTI_TYPE_RAW_HASH;
8525 dgst_pos0 = 14;
8526 dgst_pos1 = 15;
8527 dgst_pos2 = 6;
8528 dgst_pos3 = 7;
8529 break;
8530
8531 case 1722: hash_type = HASH_TYPE_SHA512;
8532 salt_type = SALT_TYPE_EMBEDDED;
8533 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8534 opts_type = OPTS_TYPE_PT_GENERATE_BE
8535 | OPTS_TYPE_PT_ADD80
8536 | OPTS_TYPE_PT_ADDBITS15
8537 | OPTS_TYPE_ST_HEX;
8538 kern_type = KERN_TYPE_SHA512_SLTPW;
8539 dgst_size = DGST_SIZE_8_8;
8540 parse_func = osx512_parse_hash;
8541 sort_by_digest = sort_by_digest_8_8;
8542 opti_type = OPTI_TYPE_ZERO_BYTE
8543 | OPTI_TYPE_PRECOMPUTE_INIT
8544 | OPTI_TYPE_PRECOMPUTE_MERKLE
8545 | OPTI_TYPE_EARLY_SKIP
8546 | OPTI_TYPE_NOT_ITERATED
8547 | OPTI_TYPE_PREPENDED_SALT
8548 | OPTI_TYPE_USES_BITS_64
8549 | OPTI_TYPE_RAW_HASH;
8550 dgst_pos0 = 14;
8551 dgst_pos1 = 15;
8552 dgst_pos2 = 6;
8553 dgst_pos3 = 7;
8554 break;
8555
8556 case 1730: hash_type = HASH_TYPE_SHA512;
8557 salt_type = SALT_TYPE_INTERN;
8558 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8559 opts_type = OPTS_TYPE_PT_GENERATE_BE
8560 | OPTS_TYPE_PT_UNICODE
8561 | OPTS_TYPE_ST_ADD80
8562 | OPTS_TYPE_ST_ADDBITS15;
8563 kern_type = KERN_TYPE_SHA512_PWSLTU;
8564 dgst_size = DGST_SIZE_8_8;
8565 parse_func = sha512s_parse_hash;
8566 sort_by_digest = sort_by_digest_8_8;
8567 opti_type = OPTI_TYPE_ZERO_BYTE
8568 | OPTI_TYPE_PRECOMPUTE_INIT
8569 | OPTI_TYPE_PRECOMPUTE_MERKLE
8570 | OPTI_TYPE_EARLY_SKIP
8571 | OPTI_TYPE_NOT_ITERATED
8572 | OPTI_TYPE_APPENDED_SALT
8573 | OPTI_TYPE_USES_BITS_64
8574 | OPTI_TYPE_RAW_HASH;
8575 dgst_pos0 = 14;
8576 dgst_pos1 = 15;
8577 dgst_pos2 = 6;
8578 dgst_pos3 = 7;
8579 break;
8580
8581 case 1731: hash_type = HASH_TYPE_SHA512;
8582 salt_type = SALT_TYPE_EMBEDDED;
8583 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8584 opts_type = OPTS_TYPE_PT_GENERATE_BE
8585 | OPTS_TYPE_PT_UNICODE
8586 | OPTS_TYPE_ST_ADD80
8587 | OPTS_TYPE_ST_ADDBITS15
8588 | OPTS_TYPE_ST_HEX;
8589 kern_type = KERN_TYPE_SHA512_PWSLTU;
8590 dgst_size = DGST_SIZE_8_8;
8591 parse_func = mssql2012_parse_hash;
8592 sort_by_digest = sort_by_digest_8_8;
8593 opti_type = OPTI_TYPE_ZERO_BYTE
8594 | OPTI_TYPE_PRECOMPUTE_INIT
8595 | OPTI_TYPE_PRECOMPUTE_MERKLE
8596 | OPTI_TYPE_EARLY_SKIP
8597 | OPTI_TYPE_NOT_ITERATED
8598 | OPTI_TYPE_APPENDED_SALT
8599 | OPTI_TYPE_USES_BITS_64
8600 | OPTI_TYPE_RAW_HASH;
8601 dgst_pos0 = 14;
8602 dgst_pos1 = 15;
8603 dgst_pos2 = 6;
8604 dgst_pos3 = 7;
8605 break;
8606
8607 case 1740: hash_type = HASH_TYPE_SHA512;
8608 salt_type = SALT_TYPE_INTERN;
8609 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8610 opts_type = OPTS_TYPE_PT_GENERATE_BE
8611 | OPTS_TYPE_PT_ADD80
8612 | OPTS_TYPE_PT_ADDBITS15
8613 | OPTS_TYPE_PT_UNICODE;
8614 kern_type = KERN_TYPE_SHA512_SLTPWU;
8615 dgst_size = DGST_SIZE_8_8;
8616 parse_func = sha512s_parse_hash;
8617 sort_by_digest = sort_by_digest_8_8;
8618 opti_type = OPTI_TYPE_ZERO_BYTE
8619 | OPTI_TYPE_PRECOMPUTE_INIT
8620 | OPTI_TYPE_PRECOMPUTE_MERKLE
8621 | OPTI_TYPE_EARLY_SKIP
8622 | OPTI_TYPE_NOT_ITERATED
8623 | OPTI_TYPE_PREPENDED_SALT
8624 | OPTI_TYPE_USES_BITS_64
8625 | OPTI_TYPE_RAW_HASH;
8626 dgst_pos0 = 14;
8627 dgst_pos1 = 15;
8628 dgst_pos2 = 6;
8629 dgst_pos3 = 7;
8630 break;
8631
8632 case 1750: hash_type = HASH_TYPE_SHA512;
8633 salt_type = SALT_TYPE_INTERN;
8634 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8635 opts_type = OPTS_TYPE_PT_GENERATE_BE
8636 | OPTS_TYPE_ST_ADD80;
8637 kern_type = KERN_TYPE_HMACSHA512_PW;
8638 dgst_size = DGST_SIZE_8_8;
8639 parse_func = hmacsha512_parse_hash;
8640 sort_by_digest = sort_by_digest_8_8;
8641 opti_type = OPTI_TYPE_ZERO_BYTE
8642 | OPTI_TYPE_USES_BITS_64
8643 | OPTI_TYPE_NOT_ITERATED;
8644 dgst_pos0 = 14;
8645 dgst_pos1 = 15;
8646 dgst_pos2 = 6;
8647 dgst_pos3 = 7;
8648 break;
8649
8650 case 1760: hash_type = HASH_TYPE_SHA512;
8651 salt_type = SALT_TYPE_INTERN;
8652 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8653 opts_type = OPTS_TYPE_PT_GENERATE_BE
8654 | OPTS_TYPE_PT_ADD80
8655 | OPTS_TYPE_PT_ADDBITS15;
8656 kern_type = KERN_TYPE_HMACSHA512_SLT;
8657 dgst_size = DGST_SIZE_8_8;
8658 parse_func = hmacsha512_parse_hash;
8659 sort_by_digest = sort_by_digest_8_8;
8660 opti_type = OPTI_TYPE_ZERO_BYTE
8661 | OPTI_TYPE_USES_BITS_64
8662 | OPTI_TYPE_NOT_ITERATED;
8663 dgst_pos0 = 14;
8664 dgst_pos1 = 15;
8665 dgst_pos2 = 6;
8666 dgst_pos3 = 7;
8667 break;
8668
8669 case 1800: hash_type = HASH_TYPE_SHA512;
8670 salt_type = SALT_TYPE_EMBEDDED;
8671 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8672 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8673 kern_type = KERN_TYPE_SHA512CRYPT;
8674 dgst_size = DGST_SIZE_8_8;
8675 parse_func = sha512crypt_parse_hash;
8676 sort_by_digest = sort_by_digest_8_8;
8677 opti_type = OPTI_TYPE_ZERO_BYTE
8678 | OPTI_TYPE_USES_BITS_64;
8679 dgst_pos0 = 0;
8680 dgst_pos1 = 1;
8681 dgst_pos2 = 2;
8682 dgst_pos3 = 3;
8683 break;
8684
8685 case 2000: hash_type = HASH_TYPE_STDOUT;
8686 salt_type = SALT_TYPE_NONE;
8687 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8688 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8689 kern_type = 0;
8690 dgst_size = DGST_SIZE_4_4;
8691 parse_func = NULL;
8692 sort_by_digest = NULL;
8693 opti_type = 0;
8694 dgst_pos0 = 0;
8695 dgst_pos1 = 0;
8696 dgst_pos2 = 0;
8697 dgst_pos3 = 0;
8698 break;
8699
8700 case 2100: hash_type = HASH_TYPE_DCC2;
8701 salt_type = SALT_TYPE_EMBEDDED;
8702 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8703 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8704 | OPTS_TYPE_ST_LOWER
8705 | OPTS_TYPE_ST_UNICODE;
8706 kern_type = KERN_TYPE_DCC2;
8707 dgst_size = DGST_SIZE_4_4;
8708 parse_func = dcc2_parse_hash;
8709 sort_by_digest = sort_by_digest_4_4;
8710 opti_type = OPTI_TYPE_ZERO_BYTE
8711 | OPTI_TYPE_SLOW_HASH_SIMD;
8712 dgst_pos0 = 0;
8713 dgst_pos1 = 1;
8714 dgst_pos2 = 2;
8715 dgst_pos3 = 3;
8716 break;
8717
8718 case 2400: hash_type = HASH_TYPE_MD5;
8719 salt_type = SALT_TYPE_NONE;
8720 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8721 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8722 kern_type = KERN_TYPE_MD5PIX;
8723 dgst_size = DGST_SIZE_4_4;
8724 parse_func = md5pix_parse_hash;
8725 sort_by_digest = sort_by_digest_4_4;
8726 opti_type = OPTI_TYPE_ZERO_BYTE
8727 | OPTI_TYPE_PRECOMPUTE_INIT
8728 | OPTI_TYPE_PRECOMPUTE_MERKLE
8729 | OPTI_TYPE_EARLY_SKIP
8730 | OPTI_TYPE_NOT_ITERATED
8731 | OPTI_TYPE_NOT_SALTED;
8732 dgst_pos0 = 0;
8733 dgst_pos1 = 3;
8734 dgst_pos2 = 2;
8735 dgst_pos3 = 1;
8736 break;
8737
8738 case 2410: hash_type = HASH_TYPE_MD5;
8739 salt_type = SALT_TYPE_INTERN;
8740 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8741 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8742 kern_type = KERN_TYPE_MD5ASA;
8743 dgst_size = DGST_SIZE_4_4;
8744 parse_func = md5asa_parse_hash;
8745 sort_by_digest = sort_by_digest_4_4;
8746 opti_type = OPTI_TYPE_ZERO_BYTE
8747 | OPTI_TYPE_PRECOMPUTE_INIT
8748 | OPTI_TYPE_PRECOMPUTE_MERKLE
8749 | OPTI_TYPE_EARLY_SKIP
8750 | OPTI_TYPE_NOT_ITERATED;
8751 dgst_pos0 = 0;
8752 dgst_pos1 = 3;
8753 dgst_pos2 = 2;
8754 dgst_pos3 = 1;
8755 break;
8756
8757 case 2500: hash_type = HASH_TYPE_WPA;
8758 salt_type = SALT_TYPE_EMBEDDED;
8759 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8760 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8761 kern_type = KERN_TYPE_WPA;
8762 dgst_size = DGST_SIZE_4_4;
8763 parse_func = wpa_parse_hash;
8764 sort_by_digest = sort_by_digest_4_4;
8765 opti_type = OPTI_TYPE_ZERO_BYTE
8766 | OPTI_TYPE_SLOW_HASH_SIMD;
8767 dgst_pos0 = 0;
8768 dgst_pos1 = 1;
8769 dgst_pos2 = 2;
8770 dgst_pos3 = 3;
8771 break;
8772
8773 case 2600: hash_type = HASH_TYPE_MD5;
8774 salt_type = SALT_TYPE_VIRTUAL;
8775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8776 opts_type = OPTS_TYPE_PT_GENERATE_LE
8777 | OPTS_TYPE_PT_ADD80
8778 | OPTS_TYPE_PT_ADDBITS14
8779 | OPTS_TYPE_ST_ADD80;
8780 kern_type = KERN_TYPE_MD55_PWSLT1;
8781 dgst_size = DGST_SIZE_4_4;
8782 parse_func = md5md5_parse_hash;
8783 sort_by_digest = sort_by_digest_4_4;
8784 opti_type = OPTI_TYPE_ZERO_BYTE
8785 | OPTI_TYPE_PRECOMPUTE_INIT
8786 | OPTI_TYPE_PRECOMPUTE_MERKLE
8787 | OPTI_TYPE_EARLY_SKIP;
8788 dgst_pos0 = 0;
8789 dgst_pos1 = 3;
8790 dgst_pos2 = 2;
8791 dgst_pos3 = 1;
8792 break;
8793
8794 case 2611: hash_type = HASH_TYPE_MD5;
8795 salt_type = SALT_TYPE_INTERN;
8796 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8797 opts_type = OPTS_TYPE_PT_GENERATE_LE
8798 | OPTS_TYPE_PT_ADD80
8799 | OPTS_TYPE_PT_ADDBITS14
8800 | OPTS_TYPE_ST_ADD80;
8801 kern_type = KERN_TYPE_MD55_PWSLT1;
8802 dgst_size = DGST_SIZE_4_4;
8803 parse_func = vb3_parse_hash;
8804 sort_by_digest = sort_by_digest_4_4;
8805 opti_type = OPTI_TYPE_ZERO_BYTE
8806 | OPTI_TYPE_PRECOMPUTE_INIT
8807 | OPTI_TYPE_PRECOMPUTE_MERKLE
8808 | OPTI_TYPE_EARLY_SKIP;
8809 dgst_pos0 = 0;
8810 dgst_pos1 = 3;
8811 dgst_pos2 = 2;
8812 dgst_pos3 = 1;
8813 break;
8814
8815 case 2612: hash_type = HASH_TYPE_MD5;
8816 salt_type = SALT_TYPE_EMBEDDED;
8817 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8818 opts_type = OPTS_TYPE_PT_GENERATE_LE
8819 | OPTS_TYPE_PT_ADD80
8820 | OPTS_TYPE_PT_ADDBITS14
8821 | OPTS_TYPE_ST_ADD80
8822 | OPTS_TYPE_ST_HEX;
8823 kern_type = KERN_TYPE_MD55_PWSLT1;
8824 dgst_size = DGST_SIZE_4_4;
8825 parse_func = phps_parse_hash;
8826 sort_by_digest = sort_by_digest_4_4;
8827 opti_type = OPTI_TYPE_ZERO_BYTE
8828 | OPTI_TYPE_PRECOMPUTE_INIT
8829 | OPTI_TYPE_PRECOMPUTE_MERKLE
8830 | OPTI_TYPE_EARLY_SKIP;
8831 dgst_pos0 = 0;
8832 dgst_pos1 = 3;
8833 dgst_pos2 = 2;
8834 dgst_pos3 = 1;
8835 break;
8836
8837 case 2711: hash_type = HASH_TYPE_MD5;
8838 salt_type = SALT_TYPE_INTERN;
8839 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8840 opts_type = OPTS_TYPE_PT_GENERATE_LE
8841 | OPTS_TYPE_PT_ADD80
8842 | OPTS_TYPE_PT_ADDBITS14
8843 | OPTS_TYPE_ST_ADD80;
8844 kern_type = KERN_TYPE_MD55_PWSLT2;
8845 dgst_size = DGST_SIZE_4_4;
8846 parse_func = vb30_parse_hash;
8847 sort_by_digest = sort_by_digest_4_4;
8848 opti_type = OPTI_TYPE_ZERO_BYTE
8849 | OPTI_TYPE_PRECOMPUTE_INIT
8850 | OPTI_TYPE_EARLY_SKIP;
8851 dgst_pos0 = 0;
8852 dgst_pos1 = 3;
8853 dgst_pos2 = 2;
8854 dgst_pos3 = 1;
8855 break;
8856
8857 case 2811: hash_type = HASH_TYPE_MD5;
8858 salt_type = SALT_TYPE_INTERN;
8859 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8860 opts_type = OPTS_TYPE_PT_GENERATE_LE
8861 | OPTS_TYPE_PT_ADD80
8862 | OPTS_TYPE_PT_ADDBITS14;
8863 kern_type = KERN_TYPE_MD55_SLTPW;
8864 dgst_size = DGST_SIZE_4_4;
8865 parse_func = ipb2_parse_hash;
8866 sort_by_digest = sort_by_digest_4_4;
8867 opti_type = OPTI_TYPE_ZERO_BYTE
8868 | OPTI_TYPE_PRECOMPUTE_INIT
8869 | OPTI_TYPE_EARLY_SKIP;
8870 dgst_pos0 = 0;
8871 dgst_pos1 = 3;
8872 dgst_pos2 = 2;
8873 dgst_pos3 = 1;
8874 break;
8875
8876 case 3000: hash_type = HASH_TYPE_LM;
8877 salt_type = SALT_TYPE_NONE;
8878 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8879 opts_type = OPTS_TYPE_PT_GENERATE_LE
8880 | OPTS_TYPE_PT_UPPER
8881 | OPTS_TYPE_PT_BITSLICE;
8882 kern_type = KERN_TYPE_LM;
8883 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8884 parse_func = lm_parse_hash;
8885 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8886 opti_type = OPTI_TYPE_ZERO_BYTE
8887 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8888 dgst_pos0 = 0;
8889 dgst_pos1 = 1;
8890 dgst_pos2 = 2;
8891 dgst_pos3 = 3;
8892 break;
8893
8894 case 3100: hash_type = HASH_TYPE_ORACLEH;
8895 salt_type = SALT_TYPE_INTERN;
8896 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8897 opts_type = OPTS_TYPE_PT_GENERATE_LE
8898 | OPTS_TYPE_PT_UPPER
8899 | OPTS_TYPE_ST_UPPER;
8900 kern_type = KERN_TYPE_ORACLEH;
8901 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8902 parse_func = oracleh_parse_hash;
8903 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8904 opti_type = OPTI_TYPE_ZERO_BYTE;
8905 dgst_pos0 = 0;
8906 dgst_pos1 = 1;
8907 dgst_pos2 = 2;
8908 dgst_pos3 = 3;
8909 break;
8910
8911 case 3200: hash_type = HASH_TYPE_BCRYPT;
8912 salt_type = SALT_TYPE_EMBEDDED;
8913 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8914 opts_type = OPTS_TYPE_PT_GENERATE_LE
8915 | OPTS_TYPE_ST_GENERATE_LE;
8916 kern_type = KERN_TYPE_BCRYPT;
8917 dgst_size = DGST_SIZE_4_6;
8918 parse_func = bcrypt_parse_hash;
8919 sort_by_digest = sort_by_digest_4_6;
8920 opti_type = OPTI_TYPE_ZERO_BYTE;
8921 dgst_pos0 = 0;
8922 dgst_pos1 = 1;
8923 dgst_pos2 = 2;
8924 dgst_pos3 = 3;
8925 break;
8926
8927 case 3710: hash_type = HASH_TYPE_MD5;
8928 salt_type = SALT_TYPE_INTERN;
8929 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8930 opts_type = OPTS_TYPE_PT_GENERATE_LE
8931 | OPTS_TYPE_PT_ADD80
8932 | OPTS_TYPE_PT_ADDBITS14;
8933 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8934 dgst_size = DGST_SIZE_4_4;
8935 parse_func = md5s_parse_hash;
8936 sort_by_digest = sort_by_digest_4_4;
8937 opti_type = OPTI_TYPE_ZERO_BYTE
8938 | OPTI_TYPE_PRECOMPUTE_INIT
8939 | OPTI_TYPE_PRECOMPUTE_MERKLE
8940 | OPTI_TYPE_EARLY_SKIP;
8941 dgst_pos0 = 0;
8942 dgst_pos1 = 3;
8943 dgst_pos2 = 2;
8944 dgst_pos3 = 1;
8945 break;
8946
8947 case 3711: hash_type = HASH_TYPE_MD5;
8948 salt_type = SALT_TYPE_EMBEDDED;
8949 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8950 opts_type = OPTS_TYPE_PT_GENERATE_LE
8951 | OPTS_TYPE_PT_ADD80
8952 | OPTS_TYPE_PT_ADDBITS14;
8953 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8954 dgst_size = DGST_SIZE_4_4;
8955 parse_func = mediawiki_b_parse_hash;
8956 sort_by_digest = sort_by_digest_4_4;
8957 opti_type = OPTI_TYPE_ZERO_BYTE
8958 | OPTI_TYPE_PRECOMPUTE_INIT
8959 | OPTI_TYPE_PRECOMPUTE_MERKLE
8960 | OPTI_TYPE_EARLY_SKIP;
8961 dgst_pos0 = 0;
8962 dgst_pos1 = 3;
8963 dgst_pos2 = 2;
8964 dgst_pos3 = 1;
8965 break;
8966
8967 case 3800: hash_type = HASH_TYPE_MD5;
8968 salt_type = SALT_TYPE_INTERN;
8969 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8970 opts_type = OPTS_TYPE_PT_GENERATE_LE
8971 | OPTS_TYPE_ST_ADDBITS14;
8972 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8973 dgst_size = DGST_SIZE_4_4;
8974 parse_func = md5s_parse_hash;
8975 sort_by_digest = sort_by_digest_4_4;
8976 opti_type = OPTI_TYPE_ZERO_BYTE
8977 | OPTI_TYPE_PRECOMPUTE_INIT
8978 | OPTI_TYPE_PRECOMPUTE_MERKLE
8979 | OPTI_TYPE_EARLY_SKIP
8980 | OPTI_TYPE_NOT_ITERATED
8981 | OPTI_TYPE_RAW_HASH;
8982 dgst_pos0 = 0;
8983 dgst_pos1 = 3;
8984 dgst_pos2 = 2;
8985 dgst_pos3 = 1;
8986 break;
8987
8988 case 4300: hash_type = HASH_TYPE_MD5;
8989 salt_type = SALT_TYPE_VIRTUAL;
8990 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8991 opts_type = OPTS_TYPE_PT_GENERATE_LE
8992 | OPTS_TYPE_PT_ADD80
8993 | OPTS_TYPE_PT_ADDBITS14
8994 | OPTS_TYPE_ST_ADD80;
8995 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8996 dgst_size = DGST_SIZE_4_4;
8997 parse_func = md5md5_parse_hash;
8998 sort_by_digest = sort_by_digest_4_4;
8999 opti_type = OPTI_TYPE_ZERO_BYTE
9000 | OPTI_TYPE_PRECOMPUTE_INIT
9001 | OPTI_TYPE_PRECOMPUTE_MERKLE
9002 | OPTI_TYPE_EARLY_SKIP;
9003 dgst_pos0 = 0;
9004 dgst_pos1 = 3;
9005 dgst_pos2 = 2;
9006 dgst_pos3 = 1;
9007 break;
9008
9009
9010 case 4400: hash_type = HASH_TYPE_MD5;
9011 salt_type = SALT_TYPE_NONE;
9012 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9013 opts_type = OPTS_TYPE_PT_GENERATE_BE
9014 | OPTS_TYPE_PT_ADD80
9015 | OPTS_TYPE_PT_ADDBITS15;
9016 kern_type = KERN_TYPE_MD5_SHA1;
9017 dgst_size = DGST_SIZE_4_4;
9018 parse_func = md5_parse_hash;
9019 sort_by_digest = sort_by_digest_4_4;
9020 opti_type = OPTI_TYPE_ZERO_BYTE
9021 | OPTI_TYPE_PRECOMPUTE_INIT
9022 | OPTI_TYPE_PRECOMPUTE_MERKLE
9023 | OPTI_TYPE_EARLY_SKIP
9024 | OPTI_TYPE_NOT_ITERATED
9025 | OPTI_TYPE_NOT_SALTED
9026 | OPTI_TYPE_RAW_HASH;
9027 dgst_pos0 = 0;
9028 dgst_pos1 = 3;
9029 dgst_pos2 = 2;
9030 dgst_pos3 = 1;
9031 break;
9032
9033 case 4500: hash_type = HASH_TYPE_SHA1;
9034 salt_type = SALT_TYPE_NONE;
9035 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9036 opts_type = OPTS_TYPE_PT_GENERATE_BE
9037 | OPTS_TYPE_PT_ADD80
9038 | OPTS_TYPE_PT_ADDBITS15;
9039 kern_type = KERN_TYPE_SHA11;
9040 dgst_size = DGST_SIZE_4_5;
9041 parse_func = sha1_parse_hash;
9042 sort_by_digest = sort_by_digest_4_5;
9043 opti_type = OPTI_TYPE_ZERO_BYTE
9044 | OPTI_TYPE_PRECOMPUTE_INIT
9045 | OPTI_TYPE_PRECOMPUTE_MERKLE
9046 | OPTI_TYPE_EARLY_SKIP
9047 | OPTI_TYPE_NOT_SALTED;
9048 dgst_pos0 = 3;
9049 dgst_pos1 = 4;
9050 dgst_pos2 = 2;
9051 dgst_pos3 = 1;
9052 break;
9053
9054 case 4700: hash_type = HASH_TYPE_SHA1;
9055 salt_type = SALT_TYPE_NONE;
9056 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9057 opts_type = OPTS_TYPE_PT_GENERATE_LE
9058 | OPTS_TYPE_PT_ADD80
9059 | OPTS_TYPE_PT_ADDBITS14;
9060 kern_type = KERN_TYPE_SHA1_MD5;
9061 dgst_size = DGST_SIZE_4_5;
9062 parse_func = sha1_parse_hash;
9063 sort_by_digest = sort_by_digest_4_5;
9064 opti_type = OPTI_TYPE_ZERO_BYTE
9065 | OPTI_TYPE_PRECOMPUTE_INIT
9066 | OPTI_TYPE_PRECOMPUTE_MERKLE
9067 | OPTI_TYPE_EARLY_SKIP
9068 | OPTI_TYPE_NOT_ITERATED
9069 | OPTI_TYPE_NOT_SALTED
9070 | OPTI_TYPE_RAW_HASH;
9071 dgst_pos0 = 3;
9072 dgst_pos1 = 4;
9073 dgst_pos2 = 2;
9074 dgst_pos3 = 1;
9075 break;
9076
9077 case 4800: hash_type = HASH_TYPE_MD5;
9078 salt_type = SALT_TYPE_EMBEDDED;
9079 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9080 opts_type = OPTS_TYPE_PT_GENERATE_LE
9081 | OPTS_TYPE_PT_ADDBITS14;
9082 kern_type = KERN_TYPE_MD5_CHAP;
9083 dgst_size = DGST_SIZE_4_4;
9084 parse_func = chap_parse_hash;
9085 sort_by_digest = sort_by_digest_4_4;
9086 opti_type = OPTI_TYPE_ZERO_BYTE
9087 | OPTI_TYPE_PRECOMPUTE_INIT
9088 | OPTI_TYPE_PRECOMPUTE_MERKLE
9089 | OPTI_TYPE_MEET_IN_MIDDLE
9090 | OPTI_TYPE_EARLY_SKIP
9091 | OPTI_TYPE_NOT_ITERATED
9092 | OPTI_TYPE_RAW_HASH;
9093 dgst_pos0 = 0;
9094 dgst_pos1 = 3;
9095 dgst_pos2 = 2;
9096 dgst_pos3 = 1;
9097 break;
9098
9099 case 4900: hash_type = HASH_TYPE_SHA1;
9100 salt_type = SALT_TYPE_INTERN;
9101 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9102 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9103 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9104 dgst_size = DGST_SIZE_4_5;
9105 parse_func = sha1s_parse_hash;
9106 sort_by_digest = sort_by_digest_4_5;
9107 opti_type = OPTI_TYPE_ZERO_BYTE
9108 | OPTI_TYPE_PRECOMPUTE_INIT
9109 | OPTI_TYPE_PRECOMPUTE_MERKLE
9110 | OPTI_TYPE_EARLY_SKIP;
9111 dgst_pos0 = 3;
9112 dgst_pos1 = 4;
9113 dgst_pos2 = 2;
9114 dgst_pos3 = 1;
9115 break;
9116
9117 case 5000: hash_type = HASH_TYPE_KECCAK;
9118 salt_type = SALT_TYPE_EMBEDDED;
9119 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9120 opts_type = OPTS_TYPE_PT_GENERATE_LE
9121 | OPTS_TYPE_PT_ADD01;
9122 kern_type = KERN_TYPE_KECCAK;
9123 dgst_size = DGST_SIZE_8_25;
9124 parse_func = keccak_parse_hash;
9125 sort_by_digest = sort_by_digest_8_25;
9126 opti_type = OPTI_TYPE_ZERO_BYTE
9127 | OPTI_TYPE_USES_BITS_64
9128 | OPTI_TYPE_RAW_HASH;
9129 dgst_pos0 = 2;
9130 dgst_pos1 = 3;
9131 dgst_pos2 = 4;
9132 dgst_pos3 = 5;
9133 break;
9134
9135 case 5100: hash_type = HASH_TYPE_MD5H;
9136 salt_type = SALT_TYPE_NONE;
9137 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9138 opts_type = OPTS_TYPE_PT_GENERATE_LE
9139 | OPTS_TYPE_PT_ADD80
9140 | OPTS_TYPE_PT_ADDBITS14;
9141 kern_type = KERN_TYPE_MD5H;
9142 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9143 parse_func = md5half_parse_hash;
9144 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9145 opti_type = OPTI_TYPE_ZERO_BYTE
9146 | OPTI_TYPE_RAW_HASH;
9147 dgst_pos0 = 0;
9148 dgst_pos1 = 1;
9149 dgst_pos2 = 2;
9150 dgst_pos3 = 3;
9151 break;
9152
9153 case 5200: hash_type = HASH_TYPE_SHA256;
9154 salt_type = SALT_TYPE_EMBEDDED;
9155 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9156 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9157 kern_type = KERN_TYPE_PSAFE3;
9158 dgst_size = DGST_SIZE_4_8;
9159 parse_func = psafe3_parse_hash;
9160 sort_by_digest = sort_by_digest_4_8;
9161 opti_type = OPTI_TYPE_ZERO_BYTE;
9162 dgst_pos0 = 0;
9163 dgst_pos1 = 1;
9164 dgst_pos2 = 2;
9165 dgst_pos3 = 3;
9166 break;
9167
9168 case 5300: hash_type = HASH_TYPE_MD5;
9169 salt_type = SALT_TYPE_EMBEDDED;
9170 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9171 opts_type = OPTS_TYPE_PT_GENERATE_LE
9172 | OPTS_TYPE_ST_ADD80;
9173 kern_type = KERN_TYPE_IKEPSK_MD5;
9174 dgst_size = DGST_SIZE_4_4;
9175 parse_func = ikepsk_md5_parse_hash;
9176 sort_by_digest = sort_by_digest_4_4;
9177 opti_type = OPTI_TYPE_ZERO_BYTE;
9178 dgst_pos0 = 0;
9179 dgst_pos1 = 3;
9180 dgst_pos2 = 2;
9181 dgst_pos3 = 1;
9182 break;
9183
9184 case 5400: hash_type = HASH_TYPE_SHA1;
9185 salt_type = SALT_TYPE_EMBEDDED;
9186 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9187 opts_type = OPTS_TYPE_PT_GENERATE_BE
9188 | OPTS_TYPE_ST_ADD80;
9189 kern_type = KERN_TYPE_IKEPSK_SHA1;
9190 dgst_size = DGST_SIZE_4_5;
9191 parse_func = ikepsk_sha1_parse_hash;
9192 sort_by_digest = sort_by_digest_4_5;
9193 opti_type = OPTI_TYPE_ZERO_BYTE;
9194 dgst_pos0 = 3;
9195 dgst_pos1 = 4;
9196 dgst_pos2 = 2;
9197 dgst_pos3 = 1;
9198 break;
9199
9200 case 5500: hash_type = HASH_TYPE_NETNTLM;
9201 salt_type = SALT_TYPE_EMBEDDED;
9202 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9203 opts_type = OPTS_TYPE_PT_GENERATE_LE
9204 | OPTS_TYPE_PT_ADD80
9205 | OPTS_TYPE_PT_ADDBITS14
9206 | OPTS_TYPE_PT_UNICODE
9207 | OPTS_TYPE_ST_HEX;
9208 kern_type = KERN_TYPE_NETNTLMv1;
9209 dgst_size = DGST_SIZE_4_4;
9210 parse_func = netntlmv1_parse_hash;
9211 sort_by_digest = sort_by_digest_4_4;
9212 opti_type = OPTI_TYPE_ZERO_BYTE
9213 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9214 dgst_pos0 = 0;
9215 dgst_pos1 = 1;
9216 dgst_pos2 = 2;
9217 dgst_pos3 = 3;
9218 break;
9219
9220 case 5600: hash_type = HASH_TYPE_MD5;
9221 salt_type = SALT_TYPE_EMBEDDED;
9222 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9223 opts_type = OPTS_TYPE_PT_GENERATE_LE
9224 | OPTS_TYPE_PT_ADD80
9225 | OPTS_TYPE_PT_ADDBITS14
9226 | OPTS_TYPE_PT_UNICODE;
9227 kern_type = KERN_TYPE_NETNTLMv2;
9228 dgst_size = DGST_SIZE_4_4;
9229 parse_func = netntlmv2_parse_hash;
9230 sort_by_digest = sort_by_digest_4_4;
9231 opti_type = OPTI_TYPE_ZERO_BYTE;
9232 dgst_pos0 = 0;
9233 dgst_pos1 = 3;
9234 dgst_pos2 = 2;
9235 dgst_pos3 = 1;
9236 break;
9237
9238 case 5700: hash_type = HASH_TYPE_SHA256;
9239 salt_type = SALT_TYPE_NONE;
9240 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9241 opts_type = OPTS_TYPE_PT_GENERATE_BE
9242 | OPTS_TYPE_PT_ADD80
9243 | OPTS_TYPE_PT_ADDBITS15;
9244 kern_type = KERN_TYPE_SHA256;
9245 dgst_size = DGST_SIZE_4_8;
9246 parse_func = cisco4_parse_hash;
9247 sort_by_digest = sort_by_digest_4_8;
9248 opti_type = OPTI_TYPE_ZERO_BYTE
9249 | OPTI_TYPE_PRECOMPUTE_INIT
9250 | OPTI_TYPE_PRECOMPUTE_MERKLE
9251 | OPTI_TYPE_EARLY_SKIP
9252 | OPTI_TYPE_NOT_ITERATED
9253 | OPTI_TYPE_NOT_SALTED
9254 | OPTI_TYPE_RAW_HASH;
9255 dgst_pos0 = 3;
9256 dgst_pos1 = 7;
9257 dgst_pos2 = 2;
9258 dgst_pos3 = 6;
9259 break;
9260
9261 case 5800: hash_type = HASH_TYPE_SHA1;
9262 salt_type = SALT_TYPE_INTERN;
9263 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9264 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9265 | OPTS_TYPE_ST_ADD80;
9266 kern_type = KERN_TYPE_ANDROIDPIN;
9267 dgst_size = DGST_SIZE_4_5;
9268 parse_func = androidpin_parse_hash;
9269 sort_by_digest = sort_by_digest_4_5;
9270 opti_type = OPTI_TYPE_ZERO_BYTE;
9271 dgst_pos0 = 0;
9272 dgst_pos1 = 1;
9273 dgst_pos2 = 2;
9274 dgst_pos3 = 3;
9275 break;
9276
9277 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9278 salt_type = SALT_TYPE_NONE;
9279 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9280 opts_type = OPTS_TYPE_PT_GENERATE_LE
9281 | OPTS_TYPE_PT_ADD80;
9282 kern_type = KERN_TYPE_RIPEMD160;
9283 dgst_size = DGST_SIZE_4_5;
9284 parse_func = ripemd160_parse_hash;
9285 sort_by_digest = sort_by_digest_4_5;
9286 opti_type = OPTI_TYPE_ZERO_BYTE;
9287 dgst_pos0 = 0;
9288 dgst_pos1 = 1;
9289 dgst_pos2 = 2;
9290 dgst_pos3 = 3;
9291 break;
9292
9293 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9294 salt_type = SALT_TYPE_NONE;
9295 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9296 opts_type = OPTS_TYPE_PT_GENERATE_BE
9297 | OPTS_TYPE_PT_ADD80;
9298 kern_type = KERN_TYPE_WHIRLPOOL;
9299 dgst_size = DGST_SIZE_4_16;
9300 parse_func = whirlpool_parse_hash;
9301 sort_by_digest = sort_by_digest_4_16;
9302 opti_type = OPTI_TYPE_ZERO_BYTE;
9303 dgst_pos0 = 0;
9304 dgst_pos1 = 1;
9305 dgst_pos2 = 2;
9306 dgst_pos3 = 3;
9307 break;
9308
9309 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9310 salt_type = SALT_TYPE_EMBEDDED;
9311 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9312 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9313 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9314 dgst_size = DGST_SIZE_4_5;
9315 parse_func = truecrypt_parse_hash_2k;
9316 sort_by_digest = sort_by_digest_4_5;
9317 opti_type = OPTI_TYPE_ZERO_BYTE;
9318 dgst_pos0 = 0;
9319 dgst_pos1 = 1;
9320 dgst_pos2 = 2;
9321 dgst_pos3 = 3;
9322 break;
9323
9324 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9325 salt_type = SALT_TYPE_EMBEDDED;
9326 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9327 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9328 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9329 dgst_size = DGST_SIZE_4_5;
9330 parse_func = truecrypt_parse_hash_2k;
9331 sort_by_digest = sort_by_digest_4_5;
9332 opti_type = OPTI_TYPE_ZERO_BYTE;
9333 dgst_pos0 = 0;
9334 dgst_pos1 = 1;
9335 dgst_pos2 = 2;
9336 dgst_pos3 = 3;
9337 break;
9338
9339 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9340 salt_type = SALT_TYPE_EMBEDDED;
9341 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9342 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9343 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9344 dgst_size = DGST_SIZE_4_5;
9345 parse_func = truecrypt_parse_hash_2k;
9346 sort_by_digest = sort_by_digest_4_5;
9347 opti_type = OPTI_TYPE_ZERO_BYTE;
9348 dgst_pos0 = 0;
9349 dgst_pos1 = 1;
9350 dgst_pos2 = 2;
9351 dgst_pos3 = 3;
9352 break;
9353
9354 case 6221: hash_type = HASH_TYPE_SHA512;
9355 salt_type = SALT_TYPE_EMBEDDED;
9356 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9357 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9358 kern_type = KERN_TYPE_TCSHA512_XTS512;
9359 dgst_size = DGST_SIZE_8_8;
9360 parse_func = truecrypt_parse_hash_1k;
9361 sort_by_digest = sort_by_digest_8_8;
9362 opti_type = OPTI_TYPE_ZERO_BYTE
9363 | OPTI_TYPE_USES_BITS_64;
9364 dgst_pos0 = 0;
9365 dgst_pos1 = 1;
9366 dgst_pos2 = 2;
9367 dgst_pos3 = 3;
9368 break;
9369
9370 case 6222: hash_type = HASH_TYPE_SHA512;
9371 salt_type = SALT_TYPE_EMBEDDED;
9372 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9373 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9374 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9375 dgst_size = DGST_SIZE_8_8;
9376 parse_func = truecrypt_parse_hash_1k;
9377 sort_by_digest = sort_by_digest_8_8;
9378 opti_type = OPTI_TYPE_ZERO_BYTE
9379 | OPTI_TYPE_USES_BITS_64;
9380 dgst_pos0 = 0;
9381 dgst_pos1 = 1;
9382 dgst_pos2 = 2;
9383 dgst_pos3 = 3;
9384 break;
9385
9386 case 6223: hash_type = HASH_TYPE_SHA512;
9387 salt_type = SALT_TYPE_EMBEDDED;
9388 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9389 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9390 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9391 dgst_size = DGST_SIZE_8_8;
9392 parse_func = truecrypt_parse_hash_1k;
9393 sort_by_digest = sort_by_digest_8_8;
9394 opti_type = OPTI_TYPE_ZERO_BYTE
9395 | OPTI_TYPE_USES_BITS_64;
9396 dgst_pos0 = 0;
9397 dgst_pos1 = 1;
9398 dgst_pos2 = 2;
9399 dgst_pos3 = 3;
9400 break;
9401
9402 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9403 salt_type = SALT_TYPE_EMBEDDED;
9404 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9405 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9406 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9407 dgst_size = DGST_SIZE_4_8;
9408 parse_func = truecrypt_parse_hash_1k;
9409 sort_by_digest = sort_by_digest_4_8;
9410 opti_type = OPTI_TYPE_ZERO_BYTE;
9411 dgst_pos0 = 0;
9412 dgst_pos1 = 1;
9413 dgst_pos2 = 2;
9414 dgst_pos3 = 3;
9415 break;
9416
9417 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9418 salt_type = SALT_TYPE_EMBEDDED;
9419 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9420 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9421 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9422 dgst_size = DGST_SIZE_4_8;
9423 parse_func = truecrypt_parse_hash_1k;
9424 sort_by_digest = sort_by_digest_4_8;
9425 opti_type = OPTI_TYPE_ZERO_BYTE;
9426 dgst_pos0 = 0;
9427 dgst_pos1 = 1;
9428 dgst_pos2 = 2;
9429 dgst_pos3 = 3;
9430 break;
9431
9432 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9433 salt_type = SALT_TYPE_EMBEDDED;
9434 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9435 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9436 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9437 dgst_size = DGST_SIZE_4_8;
9438 parse_func = truecrypt_parse_hash_1k;
9439 sort_by_digest = sort_by_digest_4_8;
9440 opti_type = OPTI_TYPE_ZERO_BYTE;
9441 dgst_pos0 = 0;
9442 dgst_pos1 = 1;
9443 dgst_pos2 = 2;
9444 dgst_pos3 = 3;
9445 break;
9446
9447 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9448 salt_type = SALT_TYPE_EMBEDDED;
9449 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9450 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9451 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9452 dgst_size = DGST_SIZE_4_5;
9453 parse_func = truecrypt_parse_hash_1k;
9454 sort_by_digest = sort_by_digest_4_5;
9455 opti_type = OPTI_TYPE_ZERO_BYTE;
9456 dgst_pos0 = 0;
9457 dgst_pos1 = 1;
9458 dgst_pos2 = 2;
9459 dgst_pos3 = 3;
9460 break;
9461
9462 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9463 salt_type = SALT_TYPE_EMBEDDED;
9464 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9465 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9466 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9467 dgst_size = DGST_SIZE_4_5;
9468 parse_func = truecrypt_parse_hash_1k;
9469 sort_by_digest = sort_by_digest_4_5;
9470 opti_type = OPTI_TYPE_ZERO_BYTE;
9471 dgst_pos0 = 0;
9472 dgst_pos1 = 1;
9473 dgst_pos2 = 2;
9474 dgst_pos3 = 3;
9475 break;
9476
9477 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9478 salt_type = SALT_TYPE_EMBEDDED;
9479 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9480 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9481 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9482 dgst_size = DGST_SIZE_4_5;
9483 parse_func = truecrypt_parse_hash_1k;
9484 sort_by_digest = sort_by_digest_4_5;
9485 opti_type = OPTI_TYPE_ZERO_BYTE;
9486 dgst_pos0 = 0;
9487 dgst_pos1 = 1;
9488 dgst_pos2 = 2;
9489 dgst_pos3 = 3;
9490 break;
9491
9492 case 6300: hash_type = HASH_TYPE_MD5;
9493 salt_type = SALT_TYPE_EMBEDDED;
9494 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9495 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9496 kern_type = KERN_TYPE_MD5AIX;
9497 dgst_size = DGST_SIZE_4_4;
9498 parse_func = md5aix_parse_hash;
9499 sort_by_digest = sort_by_digest_4_4;
9500 opti_type = OPTI_TYPE_ZERO_BYTE;
9501 dgst_pos0 = 0;
9502 dgst_pos1 = 1;
9503 dgst_pos2 = 2;
9504 dgst_pos3 = 3;
9505 break;
9506
9507 case 6400: hash_type = HASH_TYPE_SHA256;
9508 salt_type = SALT_TYPE_EMBEDDED;
9509 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9510 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9511 kern_type = KERN_TYPE_SHA256AIX;
9512 dgst_size = DGST_SIZE_4_8;
9513 parse_func = sha256aix_parse_hash;
9514 sort_by_digest = sort_by_digest_4_8;
9515 opti_type = OPTI_TYPE_ZERO_BYTE;
9516 dgst_pos0 = 0;
9517 dgst_pos1 = 1;
9518 dgst_pos2 = 2;
9519 dgst_pos3 = 3;
9520 break;
9521
9522 case 6500: hash_type = HASH_TYPE_SHA512;
9523 salt_type = SALT_TYPE_EMBEDDED;
9524 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9525 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9526 kern_type = KERN_TYPE_SHA512AIX;
9527 dgst_size = DGST_SIZE_8_8;
9528 parse_func = sha512aix_parse_hash;
9529 sort_by_digest = sort_by_digest_8_8;
9530 opti_type = OPTI_TYPE_ZERO_BYTE
9531 | OPTI_TYPE_USES_BITS_64;
9532 dgst_pos0 = 0;
9533 dgst_pos1 = 1;
9534 dgst_pos2 = 2;
9535 dgst_pos3 = 3;
9536 break;
9537
9538 case 6600: hash_type = HASH_TYPE_AES;
9539 salt_type = SALT_TYPE_EMBEDDED;
9540 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9541 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9542 kern_type = KERN_TYPE_AGILEKEY;
9543 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9544 parse_func = agilekey_parse_hash;
9545 sort_by_digest = sort_by_digest_4_5;
9546 opti_type = OPTI_TYPE_ZERO_BYTE;
9547 dgst_pos0 = 0;
9548 dgst_pos1 = 1;
9549 dgst_pos2 = 2;
9550 dgst_pos3 = 3;
9551 break;
9552
9553 case 6700: hash_type = HASH_TYPE_SHA1;
9554 salt_type = SALT_TYPE_EMBEDDED;
9555 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9556 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9557 kern_type = KERN_TYPE_SHA1AIX;
9558 dgst_size = DGST_SIZE_4_5;
9559 parse_func = sha1aix_parse_hash;
9560 sort_by_digest = sort_by_digest_4_5;
9561 opti_type = OPTI_TYPE_ZERO_BYTE;
9562 dgst_pos0 = 0;
9563 dgst_pos1 = 1;
9564 dgst_pos2 = 2;
9565 dgst_pos3 = 3;
9566 break;
9567
9568 case 6800: hash_type = HASH_TYPE_AES;
9569 salt_type = SALT_TYPE_EMBEDDED;
9570 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9571 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9572 kern_type = KERN_TYPE_LASTPASS;
9573 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9574 parse_func = lastpass_parse_hash;
9575 sort_by_digest = sort_by_digest_4_8;
9576 opti_type = OPTI_TYPE_ZERO_BYTE;
9577 dgst_pos0 = 0;
9578 dgst_pos1 = 1;
9579 dgst_pos2 = 2;
9580 dgst_pos3 = 3;
9581 break;
9582
9583 case 6900: hash_type = HASH_TYPE_GOST;
9584 salt_type = SALT_TYPE_NONE;
9585 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9586 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9587 kern_type = KERN_TYPE_GOST;
9588 dgst_size = DGST_SIZE_4_8;
9589 parse_func = gost_parse_hash;
9590 sort_by_digest = sort_by_digest_4_8;
9591 opti_type = OPTI_TYPE_ZERO_BYTE;
9592 dgst_pos0 = 0;
9593 dgst_pos1 = 1;
9594 dgst_pos2 = 2;
9595 dgst_pos3 = 3;
9596 break;
9597
9598 case 7100: hash_type = HASH_TYPE_SHA512;
9599 salt_type = SALT_TYPE_EMBEDDED;
9600 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9601 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9602 kern_type = KERN_TYPE_PBKDF2_SHA512;
9603 dgst_size = DGST_SIZE_8_16;
9604 parse_func = sha512osx_parse_hash;
9605 sort_by_digest = sort_by_digest_8_16;
9606 opti_type = OPTI_TYPE_ZERO_BYTE
9607 | OPTI_TYPE_USES_BITS_64
9608 | OPTI_TYPE_SLOW_HASH_SIMD;
9609 dgst_pos0 = 0;
9610 dgst_pos1 = 1;
9611 dgst_pos2 = 2;
9612 dgst_pos3 = 3;
9613 break;
9614
9615 case 7200: hash_type = HASH_TYPE_SHA512;
9616 salt_type = SALT_TYPE_EMBEDDED;
9617 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9618 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9619 kern_type = KERN_TYPE_PBKDF2_SHA512;
9620 dgst_size = DGST_SIZE_8_16;
9621 parse_func = sha512grub_parse_hash;
9622 sort_by_digest = sort_by_digest_8_16;
9623 opti_type = OPTI_TYPE_ZERO_BYTE
9624 | OPTI_TYPE_USES_BITS_64
9625 | OPTI_TYPE_SLOW_HASH_SIMD;
9626 dgst_pos0 = 0;
9627 dgst_pos1 = 1;
9628 dgst_pos2 = 2;
9629 dgst_pos3 = 3;
9630 break;
9631
9632 case 7300: hash_type = HASH_TYPE_SHA1;
9633 salt_type = SALT_TYPE_EMBEDDED;
9634 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9635 opts_type = OPTS_TYPE_PT_GENERATE_BE
9636 | OPTS_TYPE_ST_ADD80
9637 | OPTS_TYPE_ST_ADDBITS15;
9638 kern_type = KERN_TYPE_RAKP;
9639 dgst_size = DGST_SIZE_4_5;
9640 parse_func = rakp_parse_hash;
9641 sort_by_digest = sort_by_digest_4_5;
9642 opti_type = OPTI_TYPE_ZERO_BYTE
9643 | OPTI_TYPE_NOT_ITERATED;
9644 dgst_pos0 = 3;
9645 dgst_pos1 = 4;
9646 dgst_pos2 = 2;
9647 dgst_pos3 = 1;
9648 break;
9649
9650 case 7400: hash_type = HASH_TYPE_SHA256;
9651 salt_type = SALT_TYPE_EMBEDDED;
9652 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9653 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9654 kern_type = KERN_TYPE_SHA256CRYPT;
9655 dgst_size = DGST_SIZE_4_8;
9656 parse_func = sha256crypt_parse_hash;
9657 sort_by_digest = sort_by_digest_4_8;
9658 opti_type = OPTI_TYPE_ZERO_BYTE;
9659 dgst_pos0 = 0;
9660 dgst_pos1 = 1;
9661 dgst_pos2 = 2;
9662 dgst_pos3 = 3;
9663 break;
9664
9665 case 7500: hash_type = HASH_TYPE_KRB5PA;
9666 salt_type = SALT_TYPE_EMBEDDED;
9667 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9668 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9669 kern_type = KERN_TYPE_KRB5PA;
9670 dgst_size = DGST_SIZE_4_4;
9671 parse_func = krb5pa_parse_hash;
9672 sort_by_digest = sort_by_digest_4_4;
9673 opti_type = OPTI_TYPE_ZERO_BYTE
9674 | OPTI_TYPE_NOT_ITERATED;
9675 dgst_pos0 = 0;
9676 dgst_pos1 = 1;
9677 dgst_pos2 = 2;
9678 dgst_pos3 = 3;
9679 break;
9680
9681 case 7600: hash_type = HASH_TYPE_SHA1;
9682 salt_type = SALT_TYPE_INTERN;
9683 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9684 opts_type = OPTS_TYPE_PT_GENERATE_BE
9685 | OPTS_TYPE_PT_ADD80
9686 | OPTS_TYPE_PT_ADDBITS15;
9687 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9688 dgst_size = DGST_SIZE_4_5;
9689 parse_func = redmine_parse_hash;
9690 sort_by_digest = sort_by_digest_4_5;
9691 opti_type = OPTI_TYPE_ZERO_BYTE
9692 | OPTI_TYPE_PRECOMPUTE_INIT
9693 | OPTI_TYPE_EARLY_SKIP
9694 | OPTI_TYPE_NOT_ITERATED
9695 | OPTI_TYPE_PREPENDED_SALT;
9696 dgst_pos0 = 3;
9697 dgst_pos1 = 4;
9698 dgst_pos2 = 2;
9699 dgst_pos3 = 1;
9700 break;
9701
9702 case 7700: hash_type = HASH_TYPE_SAPB;
9703 salt_type = SALT_TYPE_EMBEDDED;
9704 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9705 opts_type = OPTS_TYPE_PT_GENERATE_LE
9706 | OPTS_TYPE_PT_UPPER
9707 | OPTS_TYPE_ST_UPPER;
9708 kern_type = KERN_TYPE_SAPB;
9709 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9710 parse_func = sapb_parse_hash;
9711 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9712 opti_type = OPTI_TYPE_ZERO_BYTE
9713 | OPTI_TYPE_PRECOMPUTE_INIT
9714 | OPTI_TYPE_NOT_ITERATED;
9715 dgst_pos0 = 0;
9716 dgst_pos1 = 1;
9717 dgst_pos2 = 2;
9718 dgst_pos3 = 3;
9719 break;
9720
9721 case 7800: hash_type = HASH_TYPE_SAPG;
9722 salt_type = SALT_TYPE_EMBEDDED;
9723 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9724 opts_type = OPTS_TYPE_PT_GENERATE_BE
9725 | OPTS_TYPE_ST_ADD80
9726 | OPTS_TYPE_ST_UPPER;
9727 kern_type = KERN_TYPE_SAPG;
9728 dgst_size = DGST_SIZE_4_5;
9729 parse_func = sapg_parse_hash;
9730 sort_by_digest = sort_by_digest_4_5;
9731 opti_type = OPTI_TYPE_ZERO_BYTE
9732 | OPTI_TYPE_PRECOMPUTE_INIT
9733 | OPTI_TYPE_NOT_ITERATED;
9734 dgst_pos0 = 3;
9735 dgst_pos1 = 4;
9736 dgst_pos2 = 2;
9737 dgst_pos3 = 1;
9738 break;
9739
9740 case 7900: hash_type = HASH_TYPE_SHA512;
9741 salt_type = SALT_TYPE_EMBEDDED;
9742 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9743 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9744 kern_type = KERN_TYPE_DRUPAL7;
9745 dgst_size = DGST_SIZE_8_8;
9746 parse_func = drupal7_parse_hash;
9747 sort_by_digest = sort_by_digest_8_8;
9748 opti_type = OPTI_TYPE_ZERO_BYTE
9749 | OPTI_TYPE_USES_BITS_64;
9750 dgst_pos0 = 0;
9751 dgst_pos1 = 1;
9752 dgst_pos2 = 2;
9753 dgst_pos3 = 3;
9754 break;
9755
9756 case 8000: hash_type = HASH_TYPE_SHA256;
9757 salt_type = SALT_TYPE_EMBEDDED;
9758 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9759 opts_type = OPTS_TYPE_PT_GENERATE_BE
9760 | OPTS_TYPE_PT_UNICODE
9761 | OPTS_TYPE_ST_ADD80
9762 | OPTS_TYPE_ST_HEX;
9763 kern_type = KERN_TYPE_SYBASEASE;
9764 dgst_size = DGST_SIZE_4_8;
9765 parse_func = sybasease_parse_hash;
9766 sort_by_digest = sort_by_digest_4_8;
9767 opti_type = OPTI_TYPE_ZERO_BYTE
9768 | OPTI_TYPE_PRECOMPUTE_INIT
9769 | OPTI_TYPE_EARLY_SKIP
9770 | OPTI_TYPE_NOT_ITERATED
9771 | OPTI_TYPE_RAW_HASH;
9772 dgst_pos0 = 3;
9773 dgst_pos1 = 7;
9774 dgst_pos2 = 2;
9775 dgst_pos3 = 6;
9776 break;
9777
9778 case 8100: hash_type = HASH_TYPE_SHA1;
9779 salt_type = SALT_TYPE_EMBEDDED;
9780 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9781 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9782 kern_type = KERN_TYPE_NETSCALER;
9783 dgst_size = DGST_SIZE_4_5;
9784 parse_func = netscaler_parse_hash;
9785 sort_by_digest = sort_by_digest_4_5;
9786 opti_type = OPTI_TYPE_ZERO_BYTE
9787 | OPTI_TYPE_PRECOMPUTE_INIT
9788 | OPTI_TYPE_PRECOMPUTE_MERKLE
9789 | OPTI_TYPE_EARLY_SKIP
9790 | OPTI_TYPE_NOT_ITERATED
9791 | OPTI_TYPE_PREPENDED_SALT
9792 | OPTI_TYPE_RAW_HASH;
9793 dgst_pos0 = 3;
9794 dgst_pos1 = 4;
9795 dgst_pos2 = 2;
9796 dgst_pos3 = 1;
9797 break;
9798
9799 case 8200: hash_type = HASH_TYPE_SHA256;
9800 salt_type = SALT_TYPE_EMBEDDED;
9801 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9802 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9803 kern_type = KERN_TYPE_CLOUDKEY;
9804 dgst_size = DGST_SIZE_4_8;
9805 parse_func = cloudkey_parse_hash;
9806 sort_by_digest = sort_by_digest_4_8;
9807 opti_type = OPTI_TYPE_ZERO_BYTE;
9808 dgst_pos0 = 0;
9809 dgst_pos1 = 1;
9810 dgst_pos2 = 2;
9811 dgst_pos3 = 3;
9812 break;
9813
9814 case 8300: hash_type = HASH_TYPE_SHA1;
9815 salt_type = SALT_TYPE_EMBEDDED;
9816 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9817 opts_type = OPTS_TYPE_PT_GENERATE_BE
9818 | OPTS_TYPE_ST_HEX
9819 | OPTS_TYPE_ST_ADD80;
9820 kern_type = KERN_TYPE_NSEC3;
9821 dgst_size = DGST_SIZE_4_5;
9822 parse_func = nsec3_parse_hash;
9823 sort_by_digest = sort_by_digest_4_5;
9824 opti_type = OPTI_TYPE_ZERO_BYTE;
9825 dgst_pos0 = 3;
9826 dgst_pos1 = 4;
9827 dgst_pos2 = 2;
9828 dgst_pos3 = 1;
9829 break;
9830
9831 case 8400: hash_type = HASH_TYPE_SHA1;
9832 salt_type = SALT_TYPE_INTERN;
9833 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9834 opts_type = OPTS_TYPE_PT_GENERATE_BE
9835 | OPTS_TYPE_PT_ADD80
9836 | OPTS_TYPE_PT_ADDBITS15;
9837 kern_type = KERN_TYPE_WBB3;
9838 dgst_size = DGST_SIZE_4_5;
9839 parse_func = wbb3_parse_hash;
9840 sort_by_digest = sort_by_digest_4_5;
9841 opti_type = OPTI_TYPE_ZERO_BYTE
9842 | OPTI_TYPE_PRECOMPUTE_INIT
9843 | OPTI_TYPE_NOT_ITERATED;
9844 dgst_pos0 = 3;
9845 dgst_pos1 = 4;
9846 dgst_pos2 = 2;
9847 dgst_pos3 = 1;
9848 break;
9849
9850 case 8500: hash_type = HASH_TYPE_DESRACF;
9851 salt_type = SALT_TYPE_EMBEDDED;
9852 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9853 opts_type = OPTS_TYPE_PT_GENERATE_LE
9854 | OPTS_TYPE_ST_UPPER;
9855 kern_type = KERN_TYPE_RACF;
9856 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9857 parse_func = racf_parse_hash;
9858 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9859 opti_type = OPTI_TYPE_ZERO_BYTE
9860 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9861 dgst_pos0 = 0;
9862 dgst_pos1 = 1;
9863 dgst_pos2 = 2;
9864 dgst_pos3 = 3;
9865 break;
9866
9867 case 8600: hash_type = HASH_TYPE_LOTUS5;
9868 salt_type = SALT_TYPE_NONE;
9869 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9870 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9871 kern_type = KERN_TYPE_LOTUS5;
9872 dgst_size = DGST_SIZE_4_4;
9873 parse_func = lotus5_parse_hash;
9874 sort_by_digest = sort_by_digest_4_4;
9875 opti_type = OPTI_TYPE_EARLY_SKIP
9876 | OPTI_TYPE_NOT_ITERATED
9877 | OPTI_TYPE_NOT_SALTED
9878 | OPTI_TYPE_RAW_HASH;
9879 dgst_pos0 = 0;
9880 dgst_pos1 = 1;
9881 dgst_pos2 = 2;
9882 dgst_pos3 = 3;
9883 break;
9884
9885 case 8700: hash_type = HASH_TYPE_LOTUS6;
9886 salt_type = SALT_TYPE_EMBEDDED;
9887 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9888 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9889 kern_type = KERN_TYPE_LOTUS6;
9890 dgst_size = DGST_SIZE_4_4;
9891 parse_func = lotus6_parse_hash;
9892 sort_by_digest = sort_by_digest_4_4;
9893 opti_type = OPTI_TYPE_EARLY_SKIP
9894 | OPTI_TYPE_NOT_ITERATED
9895 | OPTI_TYPE_RAW_HASH;
9896 dgst_pos0 = 0;
9897 dgst_pos1 = 1;
9898 dgst_pos2 = 2;
9899 dgst_pos3 = 3;
9900 break;
9901
9902 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9903 salt_type = SALT_TYPE_EMBEDDED;
9904 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9905 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9906 kern_type = KERN_TYPE_ANDROIDFDE;
9907 dgst_size = DGST_SIZE_4_4;
9908 parse_func = androidfde_parse_hash;
9909 sort_by_digest = sort_by_digest_4_4;
9910 opti_type = OPTI_TYPE_ZERO_BYTE;
9911 dgst_pos0 = 0;
9912 dgst_pos1 = 1;
9913 dgst_pos2 = 2;
9914 dgst_pos3 = 3;
9915 break;
9916
9917 case 8900: hash_type = HASH_TYPE_SCRYPT;
9918 salt_type = SALT_TYPE_EMBEDDED;
9919 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9920 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9921 kern_type = KERN_TYPE_SCRYPT;
9922 dgst_size = DGST_SIZE_4_8;
9923 parse_func = scrypt_parse_hash;
9924 sort_by_digest = sort_by_digest_4_8;
9925 opti_type = OPTI_TYPE_ZERO_BYTE;
9926 dgst_pos0 = 0;
9927 dgst_pos1 = 1;
9928 dgst_pos2 = 2;
9929 dgst_pos3 = 3;
9930 break;
9931
9932 case 9000: hash_type = HASH_TYPE_SHA1;
9933 salt_type = SALT_TYPE_EMBEDDED;
9934 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9935 opts_type = OPTS_TYPE_PT_GENERATE_LE
9936 | OPTS_TYPE_ST_GENERATE_LE;
9937 kern_type = KERN_TYPE_PSAFE2;
9938 dgst_size = DGST_SIZE_4_5;
9939 parse_func = psafe2_parse_hash;
9940 sort_by_digest = sort_by_digest_4_5;
9941 opti_type = OPTI_TYPE_ZERO_BYTE;
9942 dgst_pos0 = 0;
9943 dgst_pos1 = 1;
9944 dgst_pos2 = 2;
9945 dgst_pos3 = 3;
9946 break;
9947
9948 case 9100: hash_type = HASH_TYPE_LOTUS8;
9949 salt_type = SALT_TYPE_EMBEDDED;
9950 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9951 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9952 kern_type = KERN_TYPE_LOTUS8;
9953 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9954 parse_func = lotus8_parse_hash;
9955 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9956 opti_type = OPTI_TYPE_ZERO_BYTE;
9957 dgst_pos0 = 0;
9958 dgst_pos1 = 1;
9959 dgst_pos2 = 2;
9960 dgst_pos3 = 3;
9961 break;
9962
9963 case 9200: hash_type = HASH_TYPE_SHA256;
9964 salt_type = SALT_TYPE_EMBEDDED;
9965 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9966 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9967 kern_type = KERN_TYPE_PBKDF2_SHA256;
9968 dgst_size = DGST_SIZE_4_32;
9969 parse_func = cisco8_parse_hash;
9970 sort_by_digest = sort_by_digest_4_32;
9971 opti_type = OPTI_TYPE_ZERO_BYTE
9972 | OPTI_TYPE_SLOW_HASH_SIMD;
9973 dgst_pos0 = 0;
9974 dgst_pos1 = 1;
9975 dgst_pos2 = 2;
9976 dgst_pos3 = 3;
9977 break;
9978
9979 case 9300: hash_type = HASH_TYPE_SCRYPT;
9980 salt_type = SALT_TYPE_EMBEDDED;
9981 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9982 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9983 kern_type = KERN_TYPE_SCRYPT;
9984 dgst_size = DGST_SIZE_4_8;
9985 parse_func = cisco9_parse_hash;
9986 sort_by_digest = sort_by_digest_4_8;
9987 opti_type = OPTI_TYPE_ZERO_BYTE;
9988 dgst_pos0 = 0;
9989 dgst_pos1 = 1;
9990 dgst_pos2 = 2;
9991 dgst_pos3 = 3;
9992 break;
9993
9994 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9995 salt_type = SALT_TYPE_EMBEDDED;
9996 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9997 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9998 kern_type = KERN_TYPE_OFFICE2007;
9999 dgst_size = DGST_SIZE_4_4;
10000 parse_func = office2007_parse_hash;
10001 sort_by_digest = sort_by_digest_4_4;
10002 opti_type = OPTI_TYPE_ZERO_BYTE;
10003 dgst_pos0 = 0;
10004 dgst_pos1 = 1;
10005 dgst_pos2 = 2;
10006 dgst_pos3 = 3;
10007 break;
10008
10009 case 9500: hash_type = HASH_TYPE_OFFICE2010;
10010 salt_type = SALT_TYPE_EMBEDDED;
10011 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10012 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10013 kern_type = KERN_TYPE_OFFICE2010;
10014 dgst_size = DGST_SIZE_4_4;
10015 parse_func = office2010_parse_hash;
10016 sort_by_digest = sort_by_digest_4_4;
10017 opti_type = OPTI_TYPE_ZERO_BYTE;
10018 dgst_pos0 = 0;
10019 dgst_pos1 = 1;
10020 dgst_pos2 = 2;
10021 dgst_pos3 = 3;
10022 break;
10023
10024 case 9600: hash_type = HASH_TYPE_OFFICE2013;
10025 salt_type = SALT_TYPE_EMBEDDED;
10026 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10027 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10028 kern_type = KERN_TYPE_OFFICE2013;
10029 dgst_size = DGST_SIZE_4_4;
10030 parse_func = office2013_parse_hash;
10031 sort_by_digest = sort_by_digest_4_4;
10032 opti_type = OPTI_TYPE_ZERO_BYTE;
10033 dgst_pos0 = 0;
10034 dgst_pos1 = 1;
10035 dgst_pos2 = 2;
10036 dgst_pos3 = 3;
10037 break;
10038
10039 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
10040 salt_type = SALT_TYPE_EMBEDDED;
10041 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10042 opts_type = OPTS_TYPE_PT_GENERATE_LE
10043 | OPTS_TYPE_PT_ADD80
10044 | OPTS_TYPE_PT_UNICODE;
10045 kern_type = KERN_TYPE_OLDOFFICE01;
10046 dgst_size = DGST_SIZE_4_4;
10047 parse_func = oldoffice01_parse_hash;
10048 sort_by_digest = sort_by_digest_4_4;
10049 opti_type = OPTI_TYPE_ZERO_BYTE
10050 | OPTI_TYPE_PRECOMPUTE_INIT
10051 | OPTI_TYPE_NOT_ITERATED;
10052 dgst_pos0 = 0;
10053 dgst_pos1 = 1;
10054 dgst_pos2 = 2;
10055 dgst_pos3 = 3;
10056 break;
10057
10058 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
10059 salt_type = SALT_TYPE_EMBEDDED;
10060 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10061 opts_type = OPTS_TYPE_PT_GENERATE_LE
10062 | OPTS_TYPE_PT_ADD80;
10063 kern_type = KERN_TYPE_OLDOFFICE01CM1;
10064 dgst_size = DGST_SIZE_4_4;
10065 parse_func = oldoffice01cm1_parse_hash;
10066 sort_by_digest = sort_by_digest_4_4;
10067 opti_type = OPTI_TYPE_ZERO_BYTE
10068 | OPTI_TYPE_PRECOMPUTE_INIT
10069 | OPTI_TYPE_NOT_ITERATED;
10070 dgst_pos0 = 0;
10071 dgst_pos1 = 1;
10072 dgst_pos2 = 2;
10073 dgst_pos3 = 3;
10074 break;
10075
10076 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
10077 salt_type = SALT_TYPE_EMBEDDED;
10078 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10079 opts_type = OPTS_TYPE_PT_GENERATE_LE
10080 | OPTS_TYPE_PT_ADD80
10081 | OPTS_TYPE_PT_UNICODE
10082 | OPTS_TYPE_PT_NEVERCRACK;
10083 kern_type = KERN_TYPE_OLDOFFICE01CM2;
10084 dgst_size = DGST_SIZE_4_4;
10085 parse_func = oldoffice01cm2_parse_hash;
10086 sort_by_digest = sort_by_digest_4_4;
10087 opti_type = OPTI_TYPE_ZERO_BYTE
10088 | OPTI_TYPE_PRECOMPUTE_INIT
10089 | OPTI_TYPE_NOT_ITERATED;
10090 dgst_pos0 = 0;
10091 dgst_pos1 = 1;
10092 dgst_pos2 = 2;
10093 dgst_pos3 = 3;
10094 break;
10095
10096 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
10097 salt_type = SALT_TYPE_EMBEDDED;
10098 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10099 opts_type = OPTS_TYPE_PT_GENERATE_BE
10100 | OPTS_TYPE_PT_ADD80
10101 | OPTS_TYPE_PT_UNICODE;
10102 kern_type = KERN_TYPE_OLDOFFICE34;
10103 dgst_size = DGST_SIZE_4_4;
10104 parse_func = oldoffice34_parse_hash;
10105 sort_by_digest = sort_by_digest_4_4;
10106 opti_type = OPTI_TYPE_ZERO_BYTE
10107 | OPTI_TYPE_PRECOMPUTE_INIT
10108 | OPTI_TYPE_NOT_ITERATED;
10109 dgst_pos0 = 0;
10110 dgst_pos1 = 1;
10111 dgst_pos2 = 2;
10112 dgst_pos3 = 3;
10113 break;
10114
10115 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10116 salt_type = SALT_TYPE_EMBEDDED;
10117 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10118 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10119 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10120 dgst_size = DGST_SIZE_4_4;
10121 parse_func = oldoffice34cm1_parse_hash;
10122 sort_by_digest = sort_by_digest_4_4;
10123 opti_type = OPTI_TYPE_ZERO_BYTE
10124 | OPTI_TYPE_PRECOMPUTE_INIT
10125 | OPTI_TYPE_NOT_ITERATED;
10126 dgst_pos0 = 0;
10127 dgst_pos1 = 1;
10128 dgst_pos2 = 2;
10129 dgst_pos3 = 3;
10130 break;
10131
10132 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10133 salt_type = SALT_TYPE_EMBEDDED;
10134 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10135 opts_type = OPTS_TYPE_PT_GENERATE_BE
10136 | OPTS_TYPE_PT_ADD80
10137 | OPTS_TYPE_PT_UNICODE
10138 | OPTS_TYPE_PT_NEVERCRACK;
10139 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10140 dgst_size = DGST_SIZE_4_4;
10141 parse_func = oldoffice34cm2_parse_hash;
10142 sort_by_digest = sort_by_digest_4_4;
10143 opti_type = OPTI_TYPE_ZERO_BYTE
10144 | OPTI_TYPE_PRECOMPUTE_INIT
10145 | OPTI_TYPE_NOT_ITERATED;
10146 dgst_pos0 = 0;
10147 dgst_pos1 = 1;
10148 dgst_pos2 = 2;
10149 dgst_pos3 = 3;
10150 break;
10151
10152 case 9900: hash_type = HASH_TYPE_MD5;
10153 salt_type = SALT_TYPE_NONE;
10154 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10155 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10156 kern_type = KERN_TYPE_RADMIN2;
10157 dgst_size = DGST_SIZE_4_4;
10158 parse_func = radmin2_parse_hash;
10159 sort_by_digest = sort_by_digest_4_4;
10160 opti_type = OPTI_TYPE_ZERO_BYTE
10161 | OPTI_TYPE_PRECOMPUTE_INIT
10162 | OPTI_TYPE_EARLY_SKIP
10163 | OPTI_TYPE_NOT_ITERATED
10164 | OPTI_TYPE_NOT_SALTED;
10165 dgst_pos0 = 0;
10166 dgst_pos1 = 3;
10167 dgst_pos2 = 2;
10168 dgst_pos3 = 1;
10169 break;
10170
10171 case 10000: hash_type = HASH_TYPE_SHA256;
10172 salt_type = SALT_TYPE_EMBEDDED;
10173 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10174 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10175 kern_type = KERN_TYPE_PBKDF2_SHA256;
10176 dgst_size = DGST_SIZE_4_32;
10177 parse_func = djangopbkdf2_parse_hash;
10178 sort_by_digest = sort_by_digest_4_32;
10179 opti_type = OPTI_TYPE_ZERO_BYTE
10180 | OPTI_TYPE_SLOW_HASH_SIMD;
10181 dgst_pos0 = 0;
10182 dgst_pos1 = 1;
10183 dgst_pos2 = 2;
10184 dgst_pos3 = 3;
10185 break;
10186
10187 case 10100: hash_type = HASH_TYPE_SIPHASH;
10188 salt_type = SALT_TYPE_EMBEDDED;
10189 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10190 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10191 kern_type = KERN_TYPE_SIPHASH;
10192 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10193 parse_func = siphash_parse_hash;
10194 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10195 opti_type = OPTI_TYPE_ZERO_BYTE
10196 | OPTI_TYPE_NOT_ITERATED
10197 | OPTI_TYPE_RAW_HASH;
10198 dgst_pos0 = 0;
10199 dgst_pos1 = 1;
10200 dgst_pos2 = 2;
10201 dgst_pos3 = 3;
10202 break;
10203
10204 case 10200: hash_type = HASH_TYPE_MD5;
10205 salt_type = SALT_TYPE_EMBEDDED;
10206 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10207 opts_type = OPTS_TYPE_PT_GENERATE_LE
10208 | OPTS_TYPE_ST_ADD80
10209 | OPTS_TYPE_ST_ADDBITS14;
10210 kern_type = KERN_TYPE_HMACMD5_PW;
10211 dgst_size = DGST_SIZE_4_4;
10212 parse_func = crammd5_parse_hash;
10213 sort_by_digest = sort_by_digest_4_4;
10214 opti_type = OPTI_TYPE_ZERO_BYTE
10215 | OPTI_TYPE_NOT_ITERATED;
10216 dgst_pos0 = 0;
10217 dgst_pos1 = 3;
10218 dgst_pos2 = 2;
10219 dgst_pos3 = 1;
10220 break;
10221
10222 case 10300: hash_type = HASH_TYPE_SHA1;
10223 salt_type = SALT_TYPE_EMBEDDED;
10224 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10225 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10226 kern_type = KERN_TYPE_SAPH_SHA1;
10227 dgst_size = DGST_SIZE_4_5;
10228 parse_func = saph_sha1_parse_hash;
10229 sort_by_digest = sort_by_digest_4_5;
10230 opti_type = OPTI_TYPE_ZERO_BYTE;
10231 dgst_pos0 = 0;
10232 dgst_pos1 = 1;
10233 dgst_pos2 = 2;
10234 dgst_pos3 = 3;
10235 break;
10236
10237 case 10400: hash_type = HASH_TYPE_PDFU16;
10238 salt_type = SALT_TYPE_EMBEDDED;
10239 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10240 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10241 kern_type = KERN_TYPE_PDF11;
10242 dgst_size = DGST_SIZE_4_4;
10243 parse_func = pdf11_parse_hash;
10244 sort_by_digest = sort_by_digest_4_4;
10245 opti_type = OPTI_TYPE_ZERO_BYTE
10246 | OPTI_TYPE_NOT_ITERATED;
10247 dgst_pos0 = 0;
10248 dgst_pos1 = 1;
10249 dgst_pos2 = 2;
10250 dgst_pos3 = 3;
10251 break;
10252
10253 case 10410: hash_type = HASH_TYPE_PDFU16;
10254 salt_type = SALT_TYPE_EMBEDDED;
10255 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10256 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10257 kern_type = KERN_TYPE_PDF11CM1;
10258 dgst_size = DGST_SIZE_4_4;
10259 parse_func = pdf11cm1_parse_hash;
10260 sort_by_digest = sort_by_digest_4_4;
10261 opti_type = OPTI_TYPE_ZERO_BYTE
10262 | OPTI_TYPE_NOT_ITERATED;
10263 dgst_pos0 = 0;
10264 dgst_pos1 = 1;
10265 dgst_pos2 = 2;
10266 dgst_pos3 = 3;
10267 break;
10268
10269 case 10420: hash_type = HASH_TYPE_PDFU16;
10270 salt_type = SALT_TYPE_EMBEDDED;
10271 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10272 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10273 kern_type = KERN_TYPE_PDF11CM2;
10274 dgst_size = DGST_SIZE_4_4;
10275 parse_func = pdf11cm2_parse_hash;
10276 sort_by_digest = sort_by_digest_4_4;
10277 opti_type = OPTI_TYPE_ZERO_BYTE
10278 | OPTI_TYPE_NOT_ITERATED;
10279 dgst_pos0 = 0;
10280 dgst_pos1 = 1;
10281 dgst_pos2 = 2;
10282 dgst_pos3 = 3;
10283 break;
10284
10285 case 10500: hash_type = HASH_TYPE_PDFU16;
10286 salt_type = SALT_TYPE_EMBEDDED;
10287 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10288 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10289 kern_type = KERN_TYPE_PDF14;
10290 dgst_size = DGST_SIZE_4_4;
10291 parse_func = pdf14_parse_hash;
10292 sort_by_digest = sort_by_digest_4_4;
10293 opti_type = OPTI_TYPE_ZERO_BYTE
10294 | OPTI_TYPE_NOT_ITERATED;
10295 dgst_pos0 = 0;
10296 dgst_pos1 = 1;
10297 dgst_pos2 = 2;
10298 dgst_pos3 = 3;
10299 break;
10300
10301 case 10600: hash_type = HASH_TYPE_SHA256;
10302 salt_type = SALT_TYPE_EMBEDDED;
10303 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10304 opts_type = OPTS_TYPE_PT_GENERATE_BE
10305 | OPTS_TYPE_ST_ADD80
10306 | OPTS_TYPE_ST_ADDBITS15
10307 | OPTS_TYPE_HASH_COPY;
10308 kern_type = KERN_TYPE_SHA256_PWSLT;
10309 dgst_size = DGST_SIZE_4_8;
10310 parse_func = pdf17l3_parse_hash;
10311 sort_by_digest = sort_by_digest_4_8;
10312 opti_type = OPTI_TYPE_ZERO_BYTE
10313 | OPTI_TYPE_PRECOMPUTE_INIT
10314 | OPTI_TYPE_PRECOMPUTE_MERKLE
10315 | OPTI_TYPE_EARLY_SKIP
10316 | OPTI_TYPE_NOT_ITERATED
10317 | OPTI_TYPE_APPENDED_SALT
10318 | OPTI_TYPE_RAW_HASH;
10319 dgst_pos0 = 3;
10320 dgst_pos1 = 7;
10321 dgst_pos2 = 2;
10322 dgst_pos3 = 6;
10323 break;
10324
10325 case 10700: hash_type = HASH_TYPE_PDFU32;
10326 salt_type = SALT_TYPE_EMBEDDED;
10327 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10328 opts_type = OPTS_TYPE_PT_GENERATE_LE
10329 | OPTS_TYPE_HASH_COPY;
10330 kern_type = KERN_TYPE_PDF17L8;
10331 dgst_size = DGST_SIZE_4_8;
10332 parse_func = pdf17l8_parse_hash;
10333 sort_by_digest = sort_by_digest_4_8;
10334 opti_type = OPTI_TYPE_ZERO_BYTE
10335 | OPTI_TYPE_NOT_ITERATED;
10336 dgst_pos0 = 0;
10337 dgst_pos1 = 1;
10338 dgst_pos2 = 2;
10339 dgst_pos3 = 3;
10340 break;
10341
10342 case 10800: hash_type = HASH_TYPE_SHA384;
10343 salt_type = SALT_TYPE_NONE;
10344 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10345 opts_type = OPTS_TYPE_PT_GENERATE_BE
10346 | OPTS_TYPE_PT_ADD80
10347 | OPTS_TYPE_PT_ADDBITS15;
10348 kern_type = KERN_TYPE_SHA384;
10349 dgst_size = DGST_SIZE_8_8;
10350 parse_func = sha384_parse_hash;
10351 sort_by_digest = sort_by_digest_8_8;
10352 opti_type = OPTI_TYPE_ZERO_BYTE
10353 | OPTI_TYPE_PRECOMPUTE_INIT
10354 | OPTI_TYPE_PRECOMPUTE_MERKLE
10355 | OPTI_TYPE_EARLY_SKIP
10356 | OPTI_TYPE_NOT_ITERATED
10357 | OPTI_TYPE_NOT_SALTED
10358 | OPTI_TYPE_USES_BITS_64
10359 | OPTI_TYPE_RAW_HASH;
10360 dgst_pos0 = 6;
10361 dgst_pos1 = 7;
10362 dgst_pos2 = 4;
10363 dgst_pos3 = 5;
10364 break;
10365
10366 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10367 salt_type = SALT_TYPE_EMBEDDED;
10368 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10369 opts_type = OPTS_TYPE_PT_GENERATE_LE
10370 | OPTS_TYPE_ST_BASE64
10371 | OPTS_TYPE_HASH_COPY;
10372 kern_type = KERN_TYPE_PBKDF2_SHA256;
10373 dgst_size = DGST_SIZE_4_32;
10374 parse_func = pbkdf2_sha256_parse_hash;
10375 sort_by_digest = sort_by_digest_4_32;
10376 opti_type = OPTI_TYPE_ZERO_BYTE
10377 | OPTI_TYPE_SLOW_HASH_SIMD;
10378 dgst_pos0 = 0;
10379 dgst_pos1 = 1;
10380 dgst_pos2 = 2;
10381 dgst_pos3 = 3;
10382 break;
10383
10384 case 11000: hash_type = HASH_TYPE_MD5;
10385 salt_type = SALT_TYPE_INTERN;
10386 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10387 opts_type = OPTS_TYPE_PT_GENERATE_LE
10388 | OPTS_TYPE_PT_ADD80;
10389 kern_type = KERN_TYPE_PRESTASHOP;
10390 dgst_size = DGST_SIZE_4_4;
10391 parse_func = prestashop_parse_hash;
10392 sort_by_digest = sort_by_digest_4_4;
10393 opti_type = OPTI_TYPE_ZERO_BYTE
10394 | OPTI_TYPE_PRECOMPUTE_INIT
10395 | OPTI_TYPE_NOT_ITERATED
10396 | OPTI_TYPE_PREPENDED_SALT;
10397 dgst_pos0 = 0;
10398 dgst_pos1 = 3;
10399 dgst_pos2 = 2;
10400 dgst_pos3 = 1;
10401 break;
10402
10403 case 11100: hash_type = HASH_TYPE_MD5;
10404 salt_type = SALT_TYPE_EMBEDDED;
10405 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10406 opts_type = OPTS_TYPE_PT_GENERATE_LE
10407 | OPTS_TYPE_ST_ADD80;
10408 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10409 dgst_size = DGST_SIZE_4_4;
10410 parse_func = postgresql_auth_parse_hash;
10411 sort_by_digest = sort_by_digest_4_4;
10412 opti_type = OPTI_TYPE_ZERO_BYTE
10413 | OPTI_TYPE_PRECOMPUTE_INIT
10414 | OPTI_TYPE_PRECOMPUTE_MERKLE
10415 | OPTI_TYPE_EARLY_SKIP;
10416 dgst_pos0 = 0;
10417 dgst_pos1 = 3;
10418 dgst_pos2 = 2;
10419 dgst_pos3 = 1;
10420 break;
10421
10422 case 11200: hash_type = HASH_TYPE_SHA1;
10423 salt_type = SALT_TYPE_EMBEDDED;
10424 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10425 opts_type = OPTS_TYPE_PT_GENERATE_BE
10426 | OPTS_TYPE_PT_ADD80
10427 | OPTS_TYPE_ST_HEX;
10428 kern_type = KERN_TYPE_MYSQL_AUTH;
10429 dgst_size = DGST_SIZE_4_5;
10430 parse_func = mysql_auth_parse_hash;
10431 sort_by_digest = sort_by_digest_4_5;
10432 opti_type = OPTI_TYPE_ZERO_BYTE
10433 | OPTI_TYPE_EARLY_SKIP;
10434 dgst_pos0 = 3;
10435 dgst_pos1 = 4;
10436 dgst_pos2 = 2;
10437 dgst_pos3 = 1;
10438 break;
10439
10440 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10441 salt_type = SALT_TYPE_EMBEDDED;
10442 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10443 opts_type = OPTS_TYPE_PT_GENERATE_LE
10444 | OPTS_TYPE_ST_HEX
10445 | OPTS_TYPE_ST_ADD80;
10446 kern_type = KERN_TYPE_BITCOIN_WALLET;
10447 dgst_size = DGST_SIZE_4_4;
10448 parse_func = bitcoin_wallet_parse_hash;
10449 sort_by_digest = sort_by_digest_4_4;
10450 opti_type = OPTI_TYPE_ZERO_BYTE;
10451 dgst_pos0 = 0;
10452 dgst_pos1 = 1;
10453 dgst_pos2 = 2;
10454 dgst_pos3 = 3;
10455 break;
10456
10457 case 11400: hash_type = HASH_TYPE_MD5;
10458 salt_type = SALT_TYPE_EMBEDDED;
10459 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10460 opts_type = OPTS_TYPE_PT_GENERATE_LE
10461 | OPTS_TYPE_PT_ADD80
10462 | OPTS_TYPE_HASH_COPY;
10463 kern_type = KERN_TYPE_SIP_AUTH;
10464 dgst_size = DGST_SIZE_4_4;
10465 parse_func = sip_auth_parse_hash;
10466 sort_by_digest = sort_by_digest_4_4;
10467 opti_type = OPTI_TYPE_ZERO_BYTE;
10468 dgst_pos0 = 0;
10469 dgst_pos1 = 3;
10470 dgst_pos2 = 2;
10471 dgst_pos3 = 1;
10472 break;
10473
10474 case 11500: hash_type = HASH_TYPE_CRC32;
10475 salt_type = SALT_TYPE_INTERN;
10476 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10477 opts_type = OPTS_TYPE_PT_GENERATE_LE
10478 | OPTS_TYPE_ST_GENERATE_LE
10479 | OPTS_TYPE_ST_HEX;
10480 kern_type = KERN_TYPE_CRC32;
10481 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10482 parse_func = crc32_parse_hash;
10483 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10484 opti_type = OPTI_TYPE_ZERO_BYTE;
10485 dgst_pos0 = 0;
10486 dgst_pos1 = 1;
10487 dgst_pos2 = 2;
10488 dgst_pos3 = 3;
10489 break;
10490
10491 case 11600: hash_type = HASH_TYPE_AES;
10492 salt_type = SALT_TYPE_EMBEDDED;
10493 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10494 opts_type = OPTS_TYPE_PT_GENERATE_LE
10495 | OPTS_TYPE_PT_NEVERCRACK;
10496 kern_type = KERN_TYPE_SEVEN_ZIP;
10497 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10498 parse_func = seven_zip_parse_hash;
10499 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10500 opti_type = OPTI_TYPE_ZERO_BYTE;
10501 dgst_pos0 = 0;
10502 dgst_pos1 = 1;
10503 dgst_pos2 = 2;
10504 dgst_pos3 = 3;
10505 break;
10506
10507 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10508 salt_type = SALT_TYPE_NONE;
10509 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10510 opts_type = OPTS_TYPE_PT_GENERATE_LE
10511 | OPTS_TYPE_PT_ADD01;
10512 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10513 dgst_size = DGST_SIZE_4_8;
10514 parse_func = gost2012sbog_256_parse_hash;
10515 sort_by_digest = sort_by_digest_4_8;
10516 opti_type = OPTI_TYPE_ZERO_BYTE;
10517 dgst_pos0 = 0;
10518 dgst_pos1 = 1;
10519 dgst_pos2 = 2;
10520 dgst_pos3 = 3;
10521 break;
10522
10523 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10524 salt_type = SALT_TYPE_NONE;
10525 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10526 opts_type = OPTS_TYPE_PT_GENERATE_LE
10527 | OPTS_TYPE_PT_ADD01;
10528 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10529 dgst_size = DGST_SIZE_4_16;
10530 parse_func = gost2012sbog_512_parse_hash;
10531 sort_by_digest = sort_by_digest_4_16;
10532 opti_type = OPTI_TYPE_ZERO_BYTE;
10533 dgst_pos0 = 0;
10534 dgst_pos1 = 1;
10535 dgst_pos2 = 2;
10536 dgst_pos3 = 3;
10537 break;
10538
10539 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10540 salt_type = SALT_TYPE_EMBEDDED;
10541 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10542 opts_type = OPTS_TYPE_PT_GENERATE_LE
10543 | OPTS_TYPE_ST_BASE64
10544 | OPTS_TYPE_HASH_COPY;
10545 kern_type = KERN_TYPE_PBKDF2_MD5;
10546 dgst_size = DGST_SIZE_4_32;
10547 parse_func = pbkdf2_md5_parse_hash;
10548 sort_by_digest = sort_by_digest_4_32;
10549 opti_type = OPTI_TYPE_ZERO_BYTE
10550 | OPTI_TYPE_SLOW_HASH_SIMD;
10551 dgst_pos0 = 0;
10552 dgst_pos1 = 1;
10553 dgst_pos2 = 2;
10554 dgst_pos3 = 3;
10555 break;
10556
10557 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10558 salt_type = SALT_TYPE_EMBEDDED;
10559 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10560 opts_type = OPTS_TYPE_PT_GENERATE_LE
10561 | OPTS_TYPE_ST_BASE64
10562 | OPTS_TYPE_HASH_COPY;
10563 kern_type = KERN_TYPE_PBKDF2_SHA1;
10564 dgst_size = DGST_SIZE_4_32;
10565 parse_func = pbkdf2_sha1_parse_hash;
10566 sort_by_digest = sort_by_digest_4_32;
10567 opti_type = OPTI_TYPE_ZERO_BYTE
10568 | OPTI_TYPE_SLOW_HASH_SIMD;
10569 dgst_pos0 = 0;
10570 dgst_pos1 = 1;
10571 dgst_pos2 = 2;
10572 dgst_pos3 = 3;
10573 break;
10574
10575 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10576 salt_type = SALT_TYPE_EMBEDDED;
10577 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10578 opts_type = OPTS_TYPE_PT_GENERATE_LE
10579 | OPTS_TYPE_ST_BASE64
10580 | OPTS_TYPE_HASH_COPY;
10581 kern_type = KERN_TYPE_PBKDF2_SHA512;
10582 dgst_size = DGST_SIZE_8_16;
10583 parse_func = pbkdf2_sha512_parse_hash;
10584 sort_by_digest = sort_by_digest_8_16;
10585 opti_type = OPTI_TYPE_ZERO_BYTE
10586 | OPTI_TYPE_USES_BITS_64
10587 | OPTI_TYPE_SLOW_HASH_SIMD;
10588 dgst_pos0 = 0;
10589 dgst_pos1 = 1;
10590 dgst_pos2 = 2;
10591 dgst_pos3 = 3;
10592 break;
10593
10594 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10595 salt_type = SALT_TYPE_EMBEDDED;
10596 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10597 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10598 kern_type = KERN_TYPE_ECRYPTFS;
10599 dgst_size = DGST_SIZE_8_8;
10600 parse_func = ecryptfs_parse_hash;
10601 sort_by_digest = sort_by_digest_8_8;
10602 opti_type = OPTI_TYPE_ZERO_BYTE
10603 | OPTI_TYPE_USES_BITS_64;
10604 dgst_pos0 = 0;
10605 dgst_pos1 = 1;
10606 dgst_pos2 = 2;
10607 dgst_pos3 = 3;
10608 break;
10609
10610 case 12300: hash_type = HASH_TYPE_ORACLET;
10611 salt_type = SALT_TYPE_EMBEDDED;
10612 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10613 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10614 kern_type = KERN_TYPE_ORACLET;
10615 dgst_size = DGST_SIZE_8_16;
10616 parse_func = oraclet_parse_hash;
10617 sort_by_digest = sort_by_digest_8_16;
10618 opti_type = OPTI_TYPE_ZERO_BYTE
10619 | OPTI_TYPE_USES_BITS_64;
10620 dgst_pos0 = 0;
10621 dgst_pos1 = 1;
10622 dgst_pos2 = 2;
10623 dgst_pos3 = 3;
10624 break;
10625
10626 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10627 salt_type = SALT_TYPE_EMBEDDED;
10628 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10629 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10630 kern_type = KERN_TYPE_BSDICRYPT;
10631 dgst_size = DGST_SIZE_4_4;
10632 parse_func = bsdicrypt_parse_hash;
10633 sort_by_digest = sort_by_digest_4_4;
10634 opti_type = OPTI_TYPE_ZERO_BYTE
10635 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10636 dgst_pos0 = 0;
10637 dgst_pos1 = 1;
10638 dgst_pos2 = 2;
10639 dgst_pos3 = 3;
10640 break;
10641
10642 case 12500: hash_type = HASH_TYPE_RAR3HP;
10643 salt_type = SALT_TYPE_EMBEDDED;
10644 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10645 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10646 kern_type = KERN_TYPE_RAR3;
10647 dgst_size = DGST_SIZE_4_4;
10648 parse_func = rar3hp_parse_hash;
10649 sort_by_digest = sort_by_digest_4_4;
10650 opti_type = OPTI_TYPE_ZERO_BYTE;
10651 dgst_pos0 = 0;
10652 dgst_pos1 = 1;
10653 dgst_pos2 = 2;
10654 dgst_pos3 = 3;
10655 break;
10656
10657 case 12600: hash_type = HASH_TYPE_SHA256;
10658 salt_type = SALT_TYPE_INTERN;
10659 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10660 opts_type = OPTS_TYPE_PT_GENERATE_BE
10661 | OPTS_TYPE_PT_ADD80;
10662 kern_type = KERN_TYPE_CF10;
10663 dgst_size = DGST_SIZE_4_8;
10664 parse_func = cf10_parse_hash;
10665 sort_by_digest = sort_by_digest_4_8;
10666 opti_type = OPTI_TYPE_ZERO_BYTE
10667 | OPTI_TYPE_PRECOMPUTE_INIT
10668 | OPTI_TYPE_EARLY_SKIP
10669 | OPTI_TYPE_NOT_ITERATED;
10670 dgst_pos0 = 3;
10671 dgst_pos1 = 7;
10672 dgst_pos2 = 2;
10673 dgst_pos3 = 6;
10674 break;
10675
10676 case 12700: hash_type = HASH_TYPE_AES;
10677 salt_type = SALT_TYPE_EMBEDDED;
10678 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10679 opts_type = OPTS_TYPE_PT_GENERATE_LE
10680 | OPTS_TYPE_HASH_COPY;
10681 kern_type = KERN_TYPE_MYWALLET;
10682 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10683 parse_func = mywallet_parse_hash;
10684 sort_by_digest = sort_by_digest_4_5;
10685 opti_type = OPTI_TYPE_ZERO_BYTE;
10686 dgst_pos0 = 0;
10687 dgst_pos1 = 1;
10688 dgst_pos2 = 2;
10689 dgst_pos3 = 3;
10690 break;
10691
10692 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10693 salt_type = SALT_TYPE_EMBEDDED;
10694 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10695 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10696 kern_type = KERN_TYPE_MS_DRSR;
10697 dgst_size = DGST_SIZE_4_8;
10698 parse_func = ms_drsr_parse_hash;
10699 sort_by_digest = sort_by_digest_4_8;
10700 opti_type = OPTI_TYPE_ZERO_BYTE;
10701 dgst_pos0 = 0;
10702 dgst_pos1 = 1;
10703 dgst_pos2 = 2;
10704 dgst_pos3 = 3;
10705 break;
10706
10707 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10708 salt_type = SALT_TYPE_EMBEDDED;
10709 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10710 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10711 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10712 dgst_size = DGST_SIZE_4_8;
10713 parse_func = androidfde_samsung_parse_hash;
10714 sort_by_digest = sort_by_digest_4_8;
10715 opti_type = OPTI_TYPE_ZERO_BYTE;
10716 dgst_pos0 = 0;
10717 dgst_pos1 = 1;
10718 dgst_pos2 = 2;
10719 dgst_pos3 = 3;
10720 break;
10721
10722 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10723 salt_type = SALT_TYPE_EMBEDDED;
10724 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10725 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10726 kern_type = KERN_TYPE_RAR5;
10727 dgst_size = DGST_SIZE_4_4;
10728 parse_func = rar5_parse_hash;
10729 sort_by_digest = sort_by_digest_4_4;
10730 opti_type = OPTI_TYPE_ZERO_BYTE;
10731 dgst_pos0 = 0;
10732 dgst_pos1 = 1;
10733 dgst_pos2 = 2;
10734 dgst_pos3 = 3;
10735 break;
10736
10737 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10738 salt_type = SALT_TYPE_EMBEDDED;
10739 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10740 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10741 kern_type = KERN_TYPE_KRB5TGS;
10742 dgst_size = DGST_SIZE_4_4;
10743 parse_func = krb5tgs_parse_hash;
10744 sort_by_digest = sort_by_digest_4_4;
10745 opti_type = OPTI_TYPE_ZERO_BYTE
10746 | OPTI_TYPE_NOT_ITERATED;
10747 dgst_pos0 = 0;
10748 dgst_pos1 = 1;
10749 dgst_pos2 = 2;
10750 dgst_pos3 = 3;
10751 break;
10752
10753 case 13200: hash_type = HASH_TYPE_AES;
10754 salt_type = SALT_TYPE_EMBEDDED;
10755 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10756 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10757 kern_type = KERN_TYPE_AXCRYPT;
10758 dgst_size = DGST_SIZE_4_4;
10759 parse_func = axcrypt_parse_hash;
10760 sort_by_digest = sort_by_digest_4_4;
10761 opti_type = OPTI_TYPE_ZERO_BYTE;
10762 dgst_pos0 = 0;
10763 dgst_pos1 = 1;
10764 dgst_pos2 = 2;
10765 dgst_pos3 = 3;
10766 break;
10767
10768 case 13300: hash_type = HASH_TYPE_SHA1;
10769 salt_type = SALT_TYPE_NONE;
10770 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10771 opts_type = OPTS_TYPE_PT_GENERATE_BE
10772 | OPTS_TYPE_PT_ADD80
10773 | OPTS_TYPE_PT_ADDBITS15;
10774 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10775 dgst_size = DGST_SIZE_4_5;
10776 parse_func = sha1axcrypt_parse_hash;
10777 sort_by_digest = sort_by_digest_4_5;
10778 opti_type = OPTI_TYPE_ZERO_BYTE
10779 | OPTI_TYPE_PRECOMPUTE_INIT
10780 | OPTI_TYPE_EARLY_SKIP
10781 | OPTI_TYPE_NOT_ITERATED
10782 | OPTI_TYPE_NOT_SALTED;
10783 dgst_pos0 = 0;
10784 dgst_pos1 = 4;
10785 dgst_pos2 = 3;
10786 dgst_pos3 = 2;
10787 break;
10788
10789 case 13400: hash_type = HASH_TYPE_AES;
10790 salt_type = SALT_TYPE_EMBEDDED;
10791 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10792 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10793 kern_type = KERN_TYPE_KEEPASS;
10794 dgst_size = DGST_SIZE_4_4;
10795 parse_func = keepass_parse_hash;
10796 sort_by_digest = sort_by_digest_4_4;
10797 opti_type = OPTI_TYPE_ZERO_BYTE;
10798 dgst_pos0 = 0;
10799 dgst_pos1 = 1;
10800 dgst_pos2 = 2;
10801 dgst_pos3 = 3;
10802 break;
10803
10804 case 13500: hash_type = HASH_TYPE_SHA1;
10805 salt_type = SALT_TYPE_EMBEDDED;
10806 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10807 opts_type = OPTS_TYPE_PT_GENERATE_BE
10808 | OPTS_TYPE_PT_UNICODE
10809 | OPTS_TYPE_PT_ADD80;
10810 kern_type = KERN_TYPE_PSTOKEN;
10811 dgst_size = DGST_SIZE_4_5;
10812 parse_func = pstoken_parse_hash;
10813 sort_by_digest = sort_by_digest_4_5;
10814 opti_type = OPTI_TYPE_ZERO_BYTE
10815 | OPTI_TYPE_PRECOMPUTE_INIT
10816 | OPTI_TYPE_EARLY_SKIP
10817 | OPTI_TYPE_NOT_ITERATED
10818 | OPTI_TYPE_PREPENDED_SALT
10819 | OPTI_TYPE_RAW_HASH;
10820 dgst_pos0 = 3;
10821 dgst_pos1 = 4;
10822 dgst_pos2 = 2;
10823 dgst_pos3 = 1;
10824 break;
10825
10826 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10827 salt_type = SALT_TYPE_EMBEDDED;
10828 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10829 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10830 kern_type = KERN_TYPE_ZIP2;
10831 dgst_size = DGST_SIZE_4_4;
10832 parse_func = zip2_parse_hash;
10833 sort_by_digest = sort_by_digest_4_4;
10834 opti_type = OPTI_TYPE_ZERO_BYTE;
10835 dgst_pos0 = 0;
10836 dgst_pos1 = 1;
10837 dgst_pos2 = 2;
10838 dgst_pos3 = 3;
10839 break;
10840
10841 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10842 salt_type = SALT_TYPE_EMBEDDED;
10843 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10844 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10845 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10846 dgst_size = DGST_SIZE_4_5;
10847 parse_func = veracrypt_parse_hash_655331;
10848 sort_by_digest = sort_by_digest_4_5;
10849 opti_type = OPTI_TYPE_ZERO_BYTE;
10850 dgst_pos0 = 0;
10851 dgst_pos1 = 1;
10852 dgst_pos2 = 2;
10853 dgst_pos3 = 3;
10854 break;
10855
10856 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10857 salt_type = SALT_TYPE_EMBEDDED;
10858 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10859 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10860 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10861 dgst_size = DGST_SIZE_4_5;
10862 parse_func = veracrypt_parse_hash_655331;
10863 sort_by_digest = sort_by_digest_4_5;
10864 opti_type = OPTI_TYPE_ZERO_BYTE;
10865 dgst_pos0 = 0;
10866 dgst_pos1 = 1;
10867 dgst_pos2 = 2;
10868 dgst_pos3 = 3;
10869 break;
10870
10871 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10872 salt_type = SALT_TYPE_EMBEDDED;
10873 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10874 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10875 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10876 dgst_size = DGST_SIZE_4_5;
10877 parse_func = veracrypt_parse_hash_655331;
10878 sort_by_digest = sort_by_digest_4_5;
10879 opti_type = OPTI_TYPE_ZERO_BYTE;
10880 dgst_pos0 = 0;
10881 dgst_pos1 = 1;
10882 dgst_pos2 = 2;
10883 dgst_pos3 = 3;
10884 break;
10885
10886 case 13721: hash_type = HASH_TYPE_SHA512;
10887 salt_type = SALT_TYPE_EMBEDDED;
10888 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10889 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10890 kern_type = KERN_TYPE_TCSHA512_XTS512;
10891 dgst_size = DGST_SIZE_8_8;
10892 parse_func = veracrypt_parse_hash_500000;
10893 sort_by_digest = sort_by_digest_8_8;
10894 opti_type = OPTI_TYPE_ZERO_BYTE
10895 | OPTI_TYPE_USES_BITS_64;
10896 dgst_pos0 = 0;
10897 dgst_pos1 = 1;
10898 dgst_pos2 = 2;
10899 dgst_pos3 = 3;
10900 break;
10901
10902 case 13722: hash_type = HASH_TYPE_SHA512;
10903 salt_type = SALT_TYPE_EMBEDDED;
10904 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10905 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10906 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10907 dgst_size = DGST_SIZE_8_8;
10908 parse_func = veracrypt_parse_hash_500000;
10909 sort_by_digest = sort_by_digest_8_8;
10910 opti_type = OPTI_TYPE_ZERO_BYTE
10911 | OPTI_TYPE_USES_BITS_64;
10912 dgst_pos0 = 0;
10913 dgst_pos1 = 1;
10914 dgst_pos2 = 2;
10915 dgst_pos3 = 3;
10916 break;
10917
10918 case 13723: hash_type = HASH_TYPE_SHA512;
10919 salt_type = SALT_TYPE_EMBEDDED;
10920 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10921 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10922 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10923 dgst_size = DGST_SIZE_8_8;
10924 parse_func = veracrypt_parse_hash_500000;
10925 sort_by_digest = sort_by_digest_8_8;
10926 opti_type = OPTI_TYPE_ZERO_BYTE
10927 | OPTI_TYPE_USES_BITS_64;
10928 dgst_pos0 = 0;
10929 dgst_pos1 = 1;
10930 dgst_pos2 = 2;
10931 dgst_pos3 = 3;
10932 break;
10933
10934 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10935 salt_type = SALT_TYPE_EMBEDDED;
10936 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10937 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10938 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10939 dgst_size = DGST_SIZE_4_8;
10940 parse_func = veracrypt_parse_hash_500000;
10941 sort_by_digest = sort_by_digest_4_8;
10942 opti_type = OPTI_TYPE_ZERO_BYTE;
10943 dgst_pos0 = 0;
10944 dgst_pos1 = 1;
10945 dgst_pos2 = 2;
10946 dgst_pos3 = 3;
10947 break;
10948
10949 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10950 salt_type = SALT_TYPE_EMBEDDED;
10951 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10952 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10953 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10954 dgst_size = DGST_SIZE_4_8;
10955 parse_func = veracrypt_parse_hash_500000;
10956 sort_by_digest = sort_by_digest_4_8;
10957 opti_type = OPTI_TYPE_ZERO_BYTE;
10958 dgst_pos0 = 0;
10959 dgst_pos1 = 1;
10960 dgst_pos2 = 2;
10961 dgst_pos3 = 3;
10962 break;
10963
10964 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10965 salt_type = SALT_TYPE_EMBEDDED;
10966 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10967 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10968 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10969 dgst_size = DGST_SIZE_4_8;
10970 parse_func = veracrypt_parse_hash_500000;
10971 sort_by_digest = sort_by_digest_4_8;
10972 opti_type = OPTI_TYPE_ZERO_BYTE;
10973 dgst_pos0 = 0;
10974 dgst_pos1 = 1;
10975 dgst_pos2 = 2;
10976 dgst_pos3 = 3;
10977 break;
10978
10979 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10980 salt_type = SALT_TYPE_EMBEDDED;
10981 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10982 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10983 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10984 dgst_size = DGST_SIZE_4_5;
10985 parse_func = veracrypt_parse_hash_327661;
10986 sort_by_digest = sort_by_digest_4_5;
10987 opti_type = OPTI_TYPE_ZERO_BYTE;
10988 dgst_pos0 = 0;
10989 dgst_pos1 = 1;
10990 dgst_pos2 = 2;
10991 dgst_pos3 = 3;
10992 break;
10993
10994 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10995 salt_type = SALT_TYPE_EMBEDDED;
10996 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10997 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10998 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10999 dgst_size = DGST_SIZE_4_5;
11000 parse_func = veracrypt_parse_hash_327661;
11001 sort_by_digest = sort_by_digest_4_5;
11002 opti_type = OPTI_TYPE_ZERO_BYTE;
11003 dgst_pos0 = 0;
11004 dgst_pos1 = 1;
11005 dgst_pos2 = 2;
11006 dgst_pos3 = 3;
11007 break;
11008
11009 case 13743: hash_type = HASH_TYPE_RIPEMD160;
11010 salt_type = SALT_TYPE_EMBEDDED;
11011 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11012 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11013 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11014 dgst_size = DGST_SIZE_4_5;
11015 parse_func = veracrypt_parse_hash_327661;
11016 sort_by_digest = sort_by_digest_4_5;
11017 opti_type = OPTI_TYPE_ZERO_BYTE;
11018 dgst_pos0 = 0;
11019 dgst_pos1 = 1;
11020 dgst_pos2 = 2;
11021 dgst_pos3 = 3;
11022 break;
11023
11024 case 13751: hash_type = HASH_TYPE_SHA256;
11025 salt_type = SALT_TYPE_EMBEDDED;
11026 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11027 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11028 kern_type = KERN_TYPE_VCSHA256_XTS512;
11029 dgst_size = DGST_SIZE_4_8;
11030 parse_func = veracrypt_parse_hash_500000;
11031 sort_by_digest = sort_by_digest_4_8;
11032 opti_type = OPTI_TYPE_ZERO_BYTE;
11033 dgst_pos0 = 0;
11034 dgst_pos1 = 1;
11035 dgst_pos2 = 2;
11036 dgst_pos3 = 3;
11037 break;
11038
11039 case 13752: hash_type = HASH_TYPE_SHA256;
11040 salt_type = SALT_TYPE_EMBEDDED;
11041 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11042 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11043 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11044 dgst_size = DGST_SIZE_4_8;
11045 parse_func = veracrypt_parse_hash_500000;
11046 sort_by_digest = sort_by_digest_4_8;
11047 opti_type = OPTI_TYPE_ZERO_BYTE;
11048 dgst_pos0 = 0;
11049 dgst_pos1 = 1;
11050 dgst_pos2 = 2;
11051 dgst_pos3 = 3;
11052 break;
11053
11054 case 13753: hash_type = HASH_TYPE_SHA256;
11055 salt_type = SALT_TYPE_EMBEDDED;
11056 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11057 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11058 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11059 dgst_size = DGST_SIZE_4_8;
11060 parse_func = veracrypt_parse_hash_500000;
11061 sort_by_digest = sort_by_digest_4_8;
11062 opti_type = OPTI_TYPE_ZERO_BYTE;
11063 dgst_pos0 = 0;
11064 dgst_pos1 = 1;
11065 dgst_pos2 = 2;
11066 dgst_pos3 = 3;
11067 break;
11068
11069 case 13761: hash_type = HASH_TYPE_SHA256;
11070 salt_type = SALT_TYPE_EMBEDDED;
11071 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11072 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11073 kern_type = KERN_TYPE_VCSHA256_XTS512;
11074 dgst_size = DGST_SIZE_4_8;
11075 parse_func = veracrypt_parse_hash_200000;
11076 sort_by_digest = sort_by_digest_4_8;
11077 opti_type = OPTI_TYPE_ZERO_BYTE;
11078 dgst_pos0 = 0;
11079 dgst_pos1 = 1;
11080 dgst_pos2 = 2;
11081 dgst_pos3 = 3;
11082 break;
11083
11084 case 13762: hash_type = HASH_TYPE_SHA256;
11085 salt_type = SALT_TYPE_EMBEDDED;
11086 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11087 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11088 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11089 dgst_size = DGST_SIZE_4_8;
11090 parse_func = veracrypt_parse_hash_200000;
11091 sort_by_digest = sort_by_digest_4_8;
11092 opti_type = OPTI_TYPE_ZERO_BYTE;
11093 dgst_pos0 = 0;
11094 dgst_pos1 = 1;
11095 dgst_pos2 = 2;
11096 dgst_pos3 = 3;
11097 break;
11098
11099 case 13763: hash_type = HASH_TYPE_SHA256;
11100 salt_type = SALT_TYPE_EMBEDDED;
11101 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11102 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11103 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11104 dgst_size = DGST_SIZE_4_8;
11105 parse_func = veracrypt_parse_hash_200000;
11106 sort_by_digest = sort_by_digest_4_8;
11107 opti_type = OPTI_TYPE_ZERO_BYTE;
11108 dgst_pos0 = 0;
11109 dgst_pos1 = 1;
11110 dgst_pos2 = 2;
11111 dgst_pos3 = 3;
11112 break;
11113
11114 case 13800: hash_type = HASH_TYPE_SHA256;
11115 salt_type = SALT_TYPE_EMBEDDED;
11116 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11117 opts_type = OPTS_TYPE_PT_GENERATE_BE
11118 | OPTS_TYPE_PT_UNICODE;
11119 kern_type = KERN_TYPE_WIN8PHONE;
11120 dgst_size = DGST_SIZE_4_8;
11121 parse_func = win8phone_parse_hash;
11122 sort_by_digest = sort_by_digest_4_8;
11123 opti_type = OPTI_TYPE_ZERO_BYTE
11124 | OPTI_TYPE_PRECOMPUTE_INIT
11125 | OPTI_TYPE_EARLY_SKIP
11126 | OPTI_TYPE_NOT_ITERATED
11127 | OPTI_TYPE_RAW_HASH;
11128 dgst_pos0 = 3;
11129 dgst_pos1 = 7;
11130 dgst_pos2 = 2;
11131 dgst_pos3 = 6;
11132 break;
11133
11134 default: usage_mini_print (PROGNAME); return (-1);
11135 }
11136
11137 /**
11138 * parser
11139 */
11140
11141 data.parse_func = parse_func;
11142
11143 /**
11144 * misc stuff
11145 */
11146
11147 if (hex_salt)
11148 {
11149 if (salt_type == SALT_TYPE_INTERN)
11150 {
11151 opts_type |= OPTS_TYPE_ST_HEX;
11152 }
11153 else
11154 {
11155 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11156
11157 return (-1);
11158 }
11159 }
11160
11161 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11162 | (salt_type == SALT_TYPE_EXTERN)
11163 | (salt_type == SALT_TYPE_EMBEDDED)
11164 | (salt_type == SALT_TYPE_VIRTUAL));
11165
11166 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
11167
11168 data.hash_type = hash_type;
11169 data.attack_mode = attack_mode;
11170 data.attack_kern = attack_kern;
11171 data.attack_exec = attack_exec;
11172 data.kern_type = kern_type;
11173 data.opts_type = opts_type;
11174 data.dgst_size = dgst_size;
11175 data.salt_type = salt_type;
11176 data.isSalted = isSalted;
11177 data.sort_by_digest = sort_by_digest;
11178 data.dgst_pos0 = dgst_pos0;
11179 data.dgst_pos1 = dgst_pos1;
11180 data.dgst_pos2 = dgst_pos2;
11181 data.dgst_pos3 = dgst_pos3;
11182
11183 esalt_size = 0;
11184
11185 switch (hash_mode)
11186 {
11187 case 2500: esalt_size = sizeof (wpa_t); break;
11188 case 5300: esalt_size = sizeof (ikepsk_t); break;
11189 case 5400: esalt_size = sizeof (ikepsk_t); break;
11190 case 5500: esalt_size = sizeof (netntlm_t); break;
11191 case 5600: esalt_size = sizeof (netntlm_t); break;
11192 case 6211: esalt_size = sizeof (tc_t); break;
11193 case 6212: esalt_size = sizeof (tc_t); break;
11194 case 6213: esalt_size = sizeof (tc_t); break;
11195 case 6221: esalt_size = sizeof (tc_t); break;
11196 case 6222: esalt_size = sizeof (tc_t); break;
11197 case 6223: esalt_size = sizeof (tc_t); break;
11198 case 6231: esalt_size = sizeof (tc_t); break;
11199 case 6232: esalt_size = sizeof (tc_t); break;
11200 case 6233: esalt_size = sizeof (tc_t); break;
11201 case 6241: esalt_size = sizeof (tc_t); break;
11202 case 6242: esalt_size = sizeof (tc_t); break;
11203 case 6243: esalt_size = sizeof (tc_t); break;
11204 case 6600: esalt_size = sizeof (agilekey_t); break;
11205 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11206 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
11207 case 7300: esalt_size = sizeof (rakp_t); break;
11208 case 7500: esalt_size = sizeof (krb5pa_t); break;
11209 case 8200: esalt_size = sizeof (cloudkey_t); break;
11210 case 8800: esalt_size = sizeof (androidfde_t); break;
11211 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
11212 case 9400: esalt_size = sizeof (office2007_t); break;
11213 case 9500: esalt_size = sizeof (office2010_t); break;
11214 case 9600: esalt_size = sizeof (office2013_t); break;
11215 case 9700: esalt_size = sizeof (oldoffice01_t); break;
11216 case 9710: esalt_size = sizeof (oldoffice01_t); break;
11217 case 9720: esalt_size = sizeof (oldoffice01_t); break;
11218 case 9800: esalt_size = sizeof (oldoffice34_t); break;
11219 case 9810: esalt_size = sizeof (oldoffice34_t); break;
11220 case 9820: esalt_size = sizeof (oldoffice34_t); break;
11221 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
11222 case 10200: esalt_size = sizeof (cram_md5_t); break;
11223 case 10400: esalt_size = sizeof (pdf_t); break;
11224 case 10410: esalt_size = sizeof (pdf_t); break;
11225 case 10420: esalt_size = sizeof (pdf_t); break;
11226 case 10500: esalt_size = sizeof (pdf_t); break;
11227 case 10600: esalt_size = sizeof (pdf_t); break;
11228 case 10700: esalt_size = sizeof (pdf_t); break;
11229 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
11230 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
11231 case 11400: esalt_size = sizeof (sip_t); break;
11232 case 11600: esalt_size = sizeof (seven_zip_t); break;
11233 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
11234 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
11235 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11236 case 13000: esalt_size = sizeof (rar5_t); break;
11237 case 13100: esalt_size = sizeof (krb5tgs_t); break;
11238 case 13400: esalt_size = sizeof (keepass_t); break;
11239 case 13500: esalt_size = sizeof (pstoken_t); break;
11240 case 13600: esalt_size = sizeof (zip2_t); break;
11241 case 13711: esalt_size = sizeof (tc_t); break;
11242 case 13712: esalt_size = sizeof (tc_t); break;
11243 case 13713: esalt_size = sizeof (tc_t); break;
11244 case 13721: esalt_size = sizeof (tc_t); break;
11245 case 13722: esalt_size = sizeof (tc_t); break;
11246 case 13723: esalt_size = sizeof (tc_t); break;
11247 case 13731: esalt_size = sizeof (tc_t); break;
11248 case 13732: esalt_size = sizeof (tc_t); break;
11249 case 13733: esalt_size = sizeof (tc_t); break;
11250 case 13741: esalt_size = sizeof (tc_t); break;
11251 case 13742: esalt_size = sizeof (tc_t); break;
11252 case 13743: esalt_size = sizeof (tc_t); break;
11253 case 13751: esalt_size = sizeof (tc_t); break;
11254 case 13752: esalt_size = sizeof (tc_t); break;
11255 case 13753: esalt_size = sizeof (tc_t); break;
11256 case 13761: esalt_size = sizeof (tc_t); break;
11257 case 13762: esalt_size = sizeof (tc_t); break;
11258 case 13763: esalt_size = sizeof (tc_t); break;
11259 case 13800: esalt_size = sizeof (win8phone_t); break;
11260 }
11261
11262 data.esalt_size = esalt_size;
11263
11264 /**
11265 * choose dictionary parser
11266 */
11267
11268 if (hash_type == HASH_TYPE_LM)
11269 {
11270 get_next_word_func = get_next_word_lm;
11271 }
11272 else if (opts_type & OPTS_TYPE_PT_UPPER)
11273 {
11274 get_next_word_func = get_next_word_uc;
11275 }
11276 else
11277 {
11278 get_next_word_func = get_next_word_std;
11279 }
11280
11281 /**
11282 * dictstat
11283 */
11284
11285 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11286
11287 #ifdef _POSIX
11288 size_t dictstat_nmemb = 0;
11289 #endif
11290
11291 #ifdef _WIN
11292 uint dictstat_nmemb = 0;
11293 #endif
11294
11295 char dictstat[256] = { 0 };
11296
11297 FILE *dictstat_fp = NULL;
11298
11299 if (keyspace == 0)
11300 {
11301 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11302
11303 dictstat_fp = fopen (dictstat, "rb");
11304
11305 if (dictstat_fp)
11306 {
11307 #ifdef _POSIX
11308 struct stat tmpstat;
11309
11310 fstat (fileno (dictstat_fp), &tmpstat);
11311 #endif
11312
11313 #ifdef _WIN
11314 struct stat64 tmpstat;
11315
11316 _fstat64 (fileno (dictstat_fp), &tmpstat);
11317 #endif
11318
11319 if (tmpstat.st_mtime < COMPTIME)
11320 {
11321 /* with v0.15 the format changed so we have to ensure user is using a good version
11322 since there is no version-header in the dictstat file */
11323
11324 fclose (dictstat_fp);
11325
11326 unlink (dictstat);
11327 }
11328 else
11329 {
11330 while (!feof (dictstat_fp))
11331 {
11332 dictstat_t d;
11333
11334 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11335
11336 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11337
11338 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11339 {
11340 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11341
11342 return -1;
11343 }
11344 }
11345
11346 fclose (dictstat_fp);
11347 }
11348 }
11349 }
11350
11351 /**
11352 * potfile
11353 */
11354
11355 char potfile[256] = { 0 };
11356
11357 if (potfile_path == NULL)
11358 {
11359 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11360 }
11361 else
11362 {
11363 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11364 }
11365
11366 data.pot_fp = NULL;
11367
11368 FILE *out_fp = NULL;
11369 FILE *pot_fp = NULL;
11370
11371 if (show == 1 || left == 1)
11372 {
11373 pot_fp = fopen (potfile, "rb");
11374
11375 if (pot_fp == NULL)
11376 {
11377 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11378
11379 return (-1);
11380 }
11381
11382 if (outfile != NULL)
11383 {
11384 if ((out_fp = fopen (outfile, "ab")) == NULL)
11385 {
11386 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11387
11388 fclose (pot_fp);
11389
11390 return (-1);
11391 }
11392 }
11393 else
11394 {
11395 out_fp = stdout;
11396 }
11397 }
11398 else
11399 {
11400 if (potfile_disable == 0)
11401 {
11402 pot_fp = fopen (potfile, "ab");
11403
11404 if (pot_fp == NULL)
11405 {
11406 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11407
11408 return (-1);
11409 }
11410
11411 data.pot_fp = pot_fp;
11412 }
11413 }
11414
11415 pot_t *pot = NULL;
11416
11417 uint pot_cnt = 0;
11418 uint pot_avail = 0;
11419
11420 if (show == 1 || left == 1)
11421 {
11422 SUPPRESS_OUTPUT = 1;
11423
11424 pot_avail = count_lines (pot_fp);
11425
11426 rewind (pot_fp);
11427
11428 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11429
11430 uint pot_hashes_avail = 0;
11431
11432 uint line_num = 0;
11433
11434 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11435
11436 while (!feof (pot_fp))
11437 {
11438 line_num++;
11439
11440 int line_len = fgetl (pot_fp, line_buf);
11441
11442 if (line_len == 0) continue;
11443
11444 char *plain_buf = line_buf + line_len;
11445
11446 pot_t *pot_ptr = &pot[pot_cnt];
11447
11448 hash_t *hashes_buf = &pot_ptr->hash;
11449
11450 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11451 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11452
11453 if (pot_cnt == pot_hashes_avail)
11454 {
11455 uint pos = 0;
11456
11457 for (pos = 0; pos < INCR_POT; pos++)
11458 {
11459 if ((pot_cnt + pos) >= pot_avail) break;
11460
11461 pot_t *tmp_pot = &pot[pot_cnt + pos];
11462
11463 hash_t *tmp_hash = &tmp_pot->hash;
11464
11465 tmp_hash->digest = mymalloc (dgst_size);
11466
11467 if (isSalted)
11468 {
11469 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11470 }
11471
11472 if (esalt_size)
11473 {
11474 tmp_hash->esalt = mymalloc (esalt_size);
11475 }
11476
11477 pot_hashes_avail++;
11478 }
11479 }
11480
11481 int plain_len = 0;
11482
11483 int parser_status;
11484
11485 int iter = MAX_CUT_TRIES;
11486
11487 do
11488 {
11489 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11490 {
11491 if (line_buf[i] == ':')
11492 {
11493 line_len--;
11494
11495 break;
11496 }
11497 }
11498
11499 if (data.hash_mode != 2500)
11500 {
11501 parser_status = parse_func (line_buf, line_len, hashes_buf);
11502 }
11503 else
11504 {
11505 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11506
11507 if (line_len > max_salt_size)
11508 {
11509 parser_status = PARSER_GLOBAL_LENGTH;
11510 }
11511 else
11512 {
11513 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11514
11515 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11516
11517 hashes_buf->salt->salt_len = line_len;
11518
11519 parser_status = PARSER_OK;
11520 }
11521 }
11522
11523 // if NOT parsed without error, we add the ":" to the plain
11524
11525 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11526 {
11527 plain_len++;
11528 plain_buf--;
11529 }
11530
11531 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11532
11533 if (parser_status < PARSER_GLOBAL_ZERO)
11534 {
11535 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11536
11537 continue;
11538 }
11539
11540 if (plain_len >= 255) continue;
11541
11542 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11543
11544 pot_ptr->plain_len = plain_len;
11545
11546 pot_cnt++;
11547 }
11548
11549 myfree (line_buf);
11550
11551 fclose (pot_fp);
11552
11553 SUPPRESS_OUTPUT = 0;
11554
11555 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11556 }
11557
11558 /**
11559 * word len
11560 */
11561
11562 uint pw_min = PW_MIN;
11563 uint pw_max = PW_MAX;
11564
11565 switch (hash_mode)
11566 {
11567 case 125: if (pw_max > 32) pw_max = 32;
11568 break;
11569 case 400: if (pw_max > 40) pw_max = 40;
11570 break;
11571 case 500: if (pw_max > 16) pw_max = 16;
11572 break;
11573 case 1500: if (pw_max > 8) pw_max = 8;
11574 break;
11575 case 1600: if (pw_max > 16) pw_max = 16;
11576 break;
11577 case 1800: if (pw_max > 16) pw_max = 16;
11578 break;
11579 case 2100: if (pw_max > 16) pw_max = 16;
11580 break;
11581 case 2500: if (pw_min < 8) pw_min = 8;
11582 break;
11583 case 3000: if (pw_max > 7) pw_max = 7;
11584 break;
11585 case 5200: if (pw_max > 24) pw_max = 24;
11586 break;
11587 case 5800: if (pw_max > 16) pw_max = 16;
11588 break;
11589 case 6300: if (pw_max > 16) pw_max = 16;
11590 break;
11591 case 7400: if (pw_max > 16) pw_max = 16;
11592 break;
11593 case 7700: if (pw_max > 8) pw_max = 8;
11594 break;
11595 case 7900: if (pw_max > 48) pw_max = 48;
11596 break;
11597 case 8500: if (pw_max > 8) pw_max = 8;
11598 break;
11599 case 8600: if (pw_max > 16) pw_max = 16;
11600 break;
11601 case 9710: pw_min = 5;
11602 pw_max = 5;
11603 break;
11604 case 9810: pw_min = 5;
11605 pw_max = 5;
11606 break;
11607 case 10410: pw_min = 5;
11608 pw_max = 5;
11609 break;
11610 case 10300: if (pw_max < 3) pw_min = 3;
11611 if (pw_max > 40) pw_max = 40;
11612 break;
11613 case 10500: if (pw_max < 3) pw_min = 3;
11614 if (pw_max > 40) pw_max = 40;
11615 break;
11616 case 10700: if (pw_max > 16) pw_max = 16;
11617 break;
11618 case 11300: if (pw_max > 40) pw_max = 40;
11619 break;
11620 case 11600: if (pw_max > 32) pw_max = 32;
11621 break;
11622 case 12500: if (pw_max > 20) pw_max = 20;
11623 break;
11624 case 12800: if (pw_max > 24) pw_max = 24;
11625 break;
11626 }
11627
11628 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11629 {
11630 switch (attack_kern)
11631 {
11632 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11633 break;
11634 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11635 break;
11636 }
11637 }
11638
11639 /**
11640 * charsets : keep them together for more easy maintainnce
11641 */
11642
11643 cs_t mp_sys[6] = { { { 0 }, 0 } };
11644 cs_t mp_usr[4] = { { { 0 }, 0 } };
11645
11646 mp_setup_sys (mp_sys);
11647
11648 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11649 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11650 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11651 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11652
11653 /**
11654 * load hashes, part I: find input mode, count hashes
11655 */
11656
11657 uint hashlist_mode = 0;
11658 uint hashlist_format = HLFMT_HASHCAT;
11659
11660 uint hashes_avail = 0;
11661
11662 if ((benchmark == 0) && (stdout_flag == 0))
11663 {
11664 struct stat f;
11665
11666 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11667
11668 if ((hash_mode == 2500) ||
11669 (hash_mode == 5200) ||
11670 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11671 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11672 (hash_mode == 9000))
11673 {
11674 hashlist_mode = HL_MODE_ARG;
11675
11676 char *hashfile = myargv[optind];
11677
11678 data.hashfile = hashfile;
11679
11680 logfile_top_var_string ("target", hashfile);
11681 }
11682
11683 if (hashlist_mode == HL_MODE_ARG)
11684 {
11685 if (hash_mode == 2500)
11686 {
11687 struct stat st;
11688
11689 if (stat (data.hashfile, &st) == -1)
11690 {
11691 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11692
11693 return (-1);
11694 }
11695
11696 hashes_avail = st.st_size / sizeof (hccap_t);
11697 }
11698 else
11699 {
11700 hashes_avail = 1;
11701 }
11702 }
11703 else if (hashlist_mode == HL_MODE_FILE)
11704 {
11705 char *hashfile = myargv[optind];
11706
11707 data.hashfile = hashfile;
11708
11709 logfile_top_var_string ("target", hashfile);
11710
11711 FILE *fp = NULL;
11712
11713 if ((fp = fopen (hashfile, "rb")) == NULL)
11714 {
11715 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11716
11717 return (-1);
11718 }
11719
11720 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11721
11722 hashes_avail = count_lines (fp);
11723
11724 rewind (fp);
11725
11726 if (hashes_avail == 0)
11727 {
11728 log_error ("ERROR: hashfile is empty or corrupt");
11729
11730 fclose (fp);
11731
11732 return (-1);
11733 }
11734
11735 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11736
11737 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11738 {
11739 log_error ("ERROR: remove not supported in native hashfile-format mode");
11740
11741 fclose (fp);
11742
11743 return (-1);
11744 }
11745
11746 fclose (fp);
11747 }
11748 }
11749 else
11750 {
11751 hashlist_mode = HL_MODE_ARG;
11752
11753 hashes_avail = 1;
11754 }
11755
11756 if (hash_mode == 3000) hashes_avail *= 2;
11757
11758 data.hashlist_mode = hashlist_mode;
11759 data.hashlist_format = hashlist_format;
11760
11761 logfile_top_uint (hashlist_mode);
11762 logfile_top_uint (hashlist_format);
11763
11764 /**
11765 * load hashes, part II: allocate required memory, set pointers
11766 */
11767
11768 hash_t *hashes_buf = NULL;
11769 void *digests_buf = NULL;
11770 salt_t *salts_buf = NULL;
11771 void *esalts_buf = NULL;
11772
11773 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11774
11775 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11776
11777 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11778 {
11779 u32 hash_pos;
11780
11781 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11782 {
11783 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11784
11785 hashes_buf[hash_pos].hash_info = hash_info;
11786
11787 if (username && (remove || show || left))
11788 {
11789 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11790 }
11791
11792 if (benchmark)
11793 {
11794 hash_info->orighash = (char *) mymalloc (256);
11795 }
11796 }
11797 }
11798
11799 if (isSalted)
11800 {
11801 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11802
11803 if (esalt_size)
11804 {
11805 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11806 }
11807 }
11808 else
11809 {
11810 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11811 }
11812
11813 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11814 {
11815 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11816
11817 if (isSalted)
11818 {
11819 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11820
11821 if (esalt_size)
11822 {
11823 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11824 }
11825 }
11826 else
11827 {
11828 hashes_buf[hash_pos].salt = &salts_buf[0];
11829 }
11830 }
11831
11832 /**
11833 * load hashes, part III: parse hashes or generate them if benchmark
11834 */
11835
11836 uint hashes_cnt = 0;
11837
11838 if (benchmark == 0)
11839 {
11840 if (keyspace == 1)
11841 {
11842 // useless to read hash file for keyspace, cheat a little bit w/ optind
11843 }
11844 else if (stdout_flag == 1)
11845 {
11846 // useless to read hash file for stdout, cheat a little bit w/ optind
11847 }
11848 else if (hashes_avail == 0)
11849 {
11850 }
11851 else if (hashlist_mode == HL_MODE_ARG)
11852 {
11853 char *input_buf = myargv[optind];
11854
11855 uint input_len = strlen (input_buf);
11856
11857 logfile_top_var_string ("target", input_buf);
11858
11859 char *hash_buf = NULL;
11860 int hash_len = 0;
11861
11862 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11863
11864 bool hash_fmt_error = 0;
11865
11866 if (hash_len < 1) hash_fmt_error = 1;
11867 if (hash_buf == NULL) hash_fmt_error = 1;
11868
11869 if (hash_fmt_error)
11870 {
11871 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11872 }
11873 else
11874 {
11875 if (opts_type & OPTS_TYPE_HASH_COPY)
11876 {
11877 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11878
11879 hash_info_tmp->orighash = mystrdup (hash_buf);
11880 }
11881
11882 if (isSalted)
11883 {
11884 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11885 }
11886
11887 int parser_status = PARSER_OK;
11888
11889 if (hash_mode == 2500)
11890 {
11891 if (hash_len == 0)
11892 {
11893 log_error ("ERROR: hccap file not specified");
11894
11895 return (-1);
11896 }
11897
11898 hashlist_mode = HL_MODE_FILE;
11899
11900 data.hashlist_mode = hashlist_mode;
11901
11902 FILE *fp = fopen (hash_buf, "rb");
11903
11904 if (fp == NULL)
11905 {
11906 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11907
11908 return (-1);
11909 }
11910
11911 if (hashes_avail < 1)
11912 {
11913 log_error ("ERROR: hccap file is empty or corrupt");
11914
11915 fclose (fp);
11916
11917 return (-1);
11918 }
11919
11920 uint hccap_size = sizeof (hccap_t);
11921
11922 char *in = (char *) mymalloc (hccap_size);
11923
11924 while (!feof (fp))
11925 {
11926 int n = fread (in, hccap_size, 1, fp);
11927
11928 if (n != 1)
11929 {
11930 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11931
11932 break;
11933 }
11934
11935 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11936
11937 if (parser_status != PARSER_OK)
11938 {
11939 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11940
11941 continue;
11942 }
11943
11944 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11945
11946 if ((show == 1) || (left == 1))
11947 {
11948 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11949
11950 char *salt_ptr = (char *) tmp_salt->salt_buf;
11951
11952 int cur_pos = tmp_salt->salt_len;
11953 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11954
11955 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11956
11957 // do the appending task
11958
11959 snprintf (salt_ptr + cur_pos,
11960 rem_len,
11961 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11962 wpa->orig_mac1[0],
11963 wpa->orig_mac1[1],
11964 wpa->orig_mac1[2],
11965 wpa->orig_mac1[3],
11966 wpa->orig_mac1[4],
11967 wpa->orig_mac1[5],
11968 wpa->orig_mac2[0],
11969 wpa->orig_mac2[1],
11970 wpa->orig_mac2[2],
11971 wpa->orig_mac2[3],
11972 wpa->orig_mac2[4],
11973 wpa->orig_mac2[5]);
11974
11975 // memset () the remaining part of the salt
11976
11977 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11978 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11979
11980 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11981
11982 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11983 }
11984
11985 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);
11986 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);
11987
11988 hashes_cnt++;
11989 }
11990
11991 fclose (fp);
11992
11993 myfree (in);
11994 }
11995 else if (hash_mode == 3000)
11996 {
11997 if (hash_len == 32)
11998 {
11999 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12000
12001 hash_t *lm_hash_left = NULL;
12002
12003 if (parser_status == PARSER_OK)
12004 {
12005 lm_hash_left = &hashes_buf[hashes_cnt];
12006
12007 hashes_cnt++;
12008 }
12009 else
12010 {
12011 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12012 }
12013
12014 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12015
12016 hash_t *lm_hash_right = NULL;
12017
12018 if (parser_status == PARSER_OK)
12019 {
12020 lm_hash_right = &hashes_buf[hashes_cnt];
12021
12022 hashes_cnt++;
12023 }
12024 else
12025 {
12026 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12027 }
12028
12029 // show / left
12030
12031 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12032 {
12033 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);
12034 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);
12035 }
12036 }
12037 else
12038 {
12039 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12040
12041 if (parser_status == PARSER_OK)
12042 {
12043 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12044 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12045 }
12046
12047 if (parser_status == PARSER_OK)
12048 {
12049 hashes_cnt++;
12050 }
12051 else
12052 {
12053 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12054 }
12055 }
12056 }
12057 else
12058 {
12059 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12060
12061 if (parser_status == PARSER_OK)
12062 {
12063 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12064 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12065 }
12066
12067 if (parser_status == PARSER_OK)
12068 {
12069 hashes_cnt++;
12070 }
12071 else
12072 {
12073 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12074 }
12075 }
12076 }
12077 }
12078 else if (hashlist_mode == HL_MODE_FILE)
12079 {
12080 char *hashfile = data.hashfile;
12081
12082 FILE *fp;
12083
12084 if ((fp = fopen (hashfile, "rb")) == NULL)
12085 {
12086 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12087
12088 return (-1);
12089 }
12090
12091 uint line_num = 0;
12092
12093 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12094
12095 while (!feof (fp))
12096 {
12097 line_num++;
12098
12099 int line_len = fgetl (fp, line_buf);
12100
12101 if (line_len == 0) continue;
12102
12103 char *hash_buf = NULL;
12104 int hash_len = 0;
12105
12106 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12107
12108 bool hash_fmt_error = 0;
12109
12110 if (hash_len < 1) hash_fmt_error = 1;
12111 if (hash_buf == NULL) hash_fmt_error = 1;
12112
12113 if (hash_fmt_error)
12114 {
12115 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12116
12117 continue;
12118 }
12119
12120 if (username)
12121 {
12122 char *user_buf = NULL;
12123 int user_len = 0;
12124
12125 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12126
12127 if (remove || show)
12128 {
12129 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12130
12131 *user = (user_t *) mymalloc (sizeof (user_t));
12132
12133 user_t *user_ptr = *user;
12134
12135 if (user_buf != NULL)
12136 {
12137 user_ptr->user_name = mystrdup (user_buf);
12138 }
12139 else
12140 {
12141 user_ptr->user_name = mystrdup ("");
12142 }
12143
12144 user_ptr->user_len = user_len;
12145 }
12146 }
12147
12148 if (opts_type & OPTS_TYPE_HASH_COPY)
12149 {
12150 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12151
12152 hash_info_tmp->orighash = mystrdup (hash_buf);
12153 }
12154
12155 if (isSalted)
12156 {
12157 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12158 }
12159
12160 if (hash_mode == 3000)
12161 {
12162 if (hash_len == 32)
12163 {
12164 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12165
12166 if (parser_status < PARSER_GLOBAL_ZERO)
12167 {
12168 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12169
12170 continue;
12171 }
12172
12173 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12174
12175 hashes_cnt++;
12176
12177 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12178
12179 if (parser_status < PARSER_GLOBAL_ZERO)
12180 {
12181 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12182
12183 continue;
12184 }
12185
12186 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12187
12188 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);
12189
12190 hashes_cnt++;
12191
12192 // show / left
12193
12194 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);
12195 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);
12196 }
12197 else
12198 {
12199 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12200
12201 if (parser_status < PARSER_GLOBAL_ZERO)
12202 {
12203 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12204
12205 continue;
12206 }
12207
12208 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);
12209
12210 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12211 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12212
12213 hashes_cnt++;
12214 }
12215 }
12216 else
12217 {
12218 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12219
12220 if (parser_status < PARSER_GLOBAL_ZERO)
12221 {
12222 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12223
12224 continue;
12225 }
12226
12227 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);
12228
12229 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12230 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12231
12232 hashes_cnt++;
12233 }
12234 }
12235
12236 myfree (line_buf);
12237
12238 fclose (fp);
12239
12240 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12241
12242 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12243 }
12244 }
12245 else
12246 {
12247 if (isSalted)
12248 {
12249 hashes_buf[0].salt->salt_len = 8;
12250
12251 // special salt handling
12252
12253 switch (hash_mode)
12254 {
12255 case 1500: hashes_buf[0].salt->salt_len = 2;
12256 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12257 break;
12258 case 1731: hashes_buf[0].salt->salt_len = 4;
12259 break;
12260 case 2410: hashes_buf[0].salt->salt_len = 4;
12261 break;
12262 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12263 break;
12264 case 3100: hashes_buf[0].salt->salt_len = 1;
12265 break;
12266 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
12267 break;
12268 case 5800: hashes_buf[0].salt->salt_len = 16;
12269 break;
12270 case 6800: hashes_buf[0].salt->salt_len = 32;
12271 break;
12272 case 8400: hashes_buf[0].salt->salt_len = 40;
12273 break;
12274 case 8800: hashes_buf[0].salt->salt_len = 16;
12275 break;
12276 case 8900: hashes_buf[0].salt->salt_len = 16;
12277 hashes_buf[0].salt->scrypt_N = 1024;
12278 hashes_buf[0].salt->scrypt_r = 1;
12279 hashes_buf[0].salt->scrypt_p = 1;
12280 break;
12281 case 9100: hashes_buf[0].salt->salt_len = 16;
12282 break;
12283 case 9300: hashes_buf[0].salt->salt_len = 14;
12284 hashes_buf[0].salt->scrypt_N = 16384;
12285 hashes_buf[0].salt->scrypt_r = 1;
12286 hashes_buf[0].salt->scrypt_p = 1;
12287 break;
12288 case 9400: hashes_buf[0].salt->salt_len = 16;
12289 break;
12290 case 9500: hashes_buf[0].salt->salt_len = 16;
12291 break;
12292 case 9600: hashes_buf[0].salt->salt_len = 16;
12293 break;
12294 case 9700: hashes_buf[0].salt->salt_len = 16;
12295 break;
12296 case 9710: hashes_buf[0].salt->salt_len = 16;
12297 break;
12298 case 9720: hashes_buf[0].salt->salt_len = 16;
12299 break;
12300 case 9800: hashes_buf[0].salt->salt_len = 16;
12301 break;
12302 case 9810: hashes_buf[0].salt->salt_len = 16;
12303 break;
12304 case 9820: hashes_buf[0].salt->salt_len = 16;
12305 break;
12306 case 10300: hashes_buf[0].salt->salt_len = 12;
12307 break;
12308 case 11500: hashes_buf[0].salt->salt_len = 4;
12309 break;
12310 case 11600: hashes_buf[0].salt->salt_len = 4;
12311 break;
12312 case 12400: hashes_buf[0].salt->salt_len = 4;
12313 break;
12314 case 12500: hashes_buf[0].salt->salt_len = 8;
12315 break;
12316 case 12600: hashes_buf[0].salt->salt_len = 64;
12317 break;
12318 }
12319
12320 // special esalt handling
12321
12322 switch (hash_mode)
12323 {
12324 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12325 break;
12326 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12327 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12328 break;
12329 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12330 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12331 break;
12332 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12333 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12334 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12335 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12336 break;
12337 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12338 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12339 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12340 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12341 break;
12342 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12343 break;
12344 case 10400: ((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 10410: ((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 10420: ((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 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12357 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12358 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12359 break;
12360 case 10600: ((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 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12365 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12366 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12367 break;
12368 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12369 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12370 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12371 break;
12372 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12373 break;
12374 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12375 break;
12376 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12377 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12378 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12379 break;
12380 }
12381 }
12382
12383 // set hashfile
12384
12385 switch (hash_mode)
12386 {
12387 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12388 break;
12389 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12390 break;
12391 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12392 break;
12393 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12394 break;
12395 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12396 break;
12397 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12398 break;
12399 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12400 break;
12401 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12402 break;
12403 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12404 break;
12405 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12406 break;
12407 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12408 break;
12409 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12410 break;
12411 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12412 break;
12413 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12414 break;
12415 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12416 break;
12417 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12418 break;
12419 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12420 break;
12421 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12422 break;
12423 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12424 break;
12425 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12426 break;
12427 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12428 break;
12429 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12430 break;
12431 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12432 break;
12433 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12434 break;
12435 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12436 break;
12437 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12438 break;
12439 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12440 break;
12441 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12442 break;
12443 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12444 break;
12445 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12446 break;
12447 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12448 break;
12449 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12450 break;
12451 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12452 break;
12453 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12454 break;
12455 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12456 break;
12457 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12458 break;
12459 }
12460
12461 // set default iterations
12462
12463 switch (hash_mode)
12464 {
12465 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12466 break;
12467 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12468 break;
12469 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12470 break;
12471 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12472 break;
12473 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12474 break;
12475 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12476 break;
12477 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12478 break;
12479 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12480 break;
12481 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12482 break;
12483 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12484 break;
12485 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12486 break;
12487 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12488 break;
12489 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12490 break;
12491 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12492 break;
12493 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12494 break;
12495 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12496 break;
12497 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12498 break;
12499 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12500 break;
12501 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12502 break;
12503 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12504 break;
12505 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12506 break;
12507 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12508 break;
12509 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12510 break;
12511 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12512 break;
12513 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12514 break;
12515 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12516 break;
12517 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12518 break;
12519 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12520 break;
12521 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12522 break;
12523 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12524 break;
12525 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12526 break;
12527 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12528 break;
12529 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12530 break;
12531 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12532 break;
12533 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12534 break;
12535 case 8900: hashes_buf[0].salt->salt_iter = 1;
12536 break;
12537 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12538 break;
12539 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12540 break;
12541 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12542 break;
12543 case 9300: hashes_buf[0].salt->salt_iter = 1;
12544 break;
12545 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12546 break;
12547 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12548 break;
12549 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12550 break;
12551 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12552 break;
12553 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12554 break;
12555 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12556 break;
12557 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12558 break;
12559 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12560 break;
12561 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12562 break;
12563 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12564 break;
12565 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12566 break;
12567 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12568 break;
12569 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12570 break;
12571 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12572 break;
12573 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12574 break;
12575 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12576 break;
12577 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12578 break;
12579 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12580 break;
12581 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12582 break;
12583 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12584 break;
12585 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12586 break;
12587 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12588 break;
12589 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12590 break;
12591 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12592 break;
12593 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12594 break;
12595 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12596 break;
12597 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12598 break;
12599 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12600 break;
12601 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12602 break;
12603 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12604 break;
12605 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12606 break;
12607 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12608 break;
12609 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12610 break;
12611 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12612 break;
12613 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12614 break;
12615 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12616 break;
12617 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12618 break;
12619 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12620 break;
12621 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12622 break;
12623 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12624 break;
12625 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12626 break;
12627 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12628 break;
12629 }
12630
12631 hashes_cnt = 1;
12632 }
12633
12634 if (show == 1 || left == 1)
12635 {
12636 for (uint i = 0; i < pot_cnt; i++)
12637 {
12638 pot_t *pot_ptr = &pot[i];
12639
12640 hash_t *hashes_buf = &pot_ptr->hash;
12641
12642 local_free (hashes_buf->digest);
12643
12644 if (isSalted)
12645 {
12646 local_free (hashes_buf->salt);
12647 }
12648 }
12649
12650 local_free (pot);
12651
12652 if (data.quiet == 0) log_info_nn ("");
12653
12654 return (0);
12655 }
12656
12657 if ((keyspace == 0) && (stdout_flag == 0))
12658 {
12659 if (hashes_cnt == 0)
12660 {
12661 log_error ("ERROR: No hashes loaded");
12662
12663 return (-1);
12664 }
12665 }
12666
12667 /**
12668 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12669 */
12670
12671 if (data.outfile != NULL)
12672 {
12673 if (data.hashfile != NULL)
12674 {
12675 #ifdef _POSIX
12676 struct stat tmpstat_outfile;
12677 struct stat tmpstat_hashfile;
12678 #endif
12679
12680 #ifdef _WIN
12681 struct stat64 tmpstat_outfile;
12682 struct stat64 tmpstat_hashfile;
12683 #endif
12684
12685 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12686
12687 if (tmp_outfile_fp)
12688 {
12689 #ifdef _POSIX
12690 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12691 #endif
12692
12693 #ifdef _WIN
12694 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12695 #endif
12696
12697 fclose (tmp_outfile_fp);
12698 }
12699
12700 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12701
12702 if (tmp_hashfile_fp)
12703 {
12704 #ifdef _POSIX
12705 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12706 #endif
12707
12708 #ifdef _WIN
12709 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12710 #endif
12711
12712 fclose (tmp_hashfile_fp);
12713 }
12714
12715 if (tmp_outfile_fp && tmp_outfile_fp)
12716 {
12717 tmpstat_outfile.st_mode = 0;
12718 tmpstat_outfile.st_nlink = 0;
12719 tmpstat_outfile.st_uid = 0;
12720 tmpstat_outfile.st_gid = 0;
12721 tmpstat_outfile.st_rdev = 0;
12722 tmpstat_outfile.st_atime = 0;
12723
12724 tmpstat_hashfile.st_mode = 0;
12725 tmpstat_hashfile.st_nlink = 0;
12726 tmpstat_hashfile.st_uid = 0;
12727 tmpstat_hashfile.st_gid = 0;
12728 tmpstat_hashfile.st_rdev = 0;
12729 tmpstat_hashfile.st_atime = 0;
12730
12731 #ifdef _POSIX
12732 tmpstat_outfile.st_blksize = 0;
12733 tmpstat_outfile.st_blocks = 0;
12734
12735 tmpstat_hashfile.st_blksize = 0;
12736 tmpstat_hashfile.st_blocks = 0;
12737 #endif
12738
12739 #ifdef _POSIX
12740 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12741 {
12742 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12743
12744 return (-1);
12745 }
12746 #endif
12747
12748 #ifdef _WIN
12749 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12750 {
12751 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12752
12753 return (-1);
12754 }
12755 #endif
12756 }
12757 }
12758 }
12759
12760 /**
12761 * Remove duplicates
12762 */
12763
12764 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12765
12766 if (isSalted)
12767 {
12768 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12769 }
12770 else
12771 {
12772 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12773 }
12774
12775 uint hashes_cnt_orig = hashes_cnt;
12776
12777 hashes_cnt = 1;
12778
12779 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12780 {
12781 if (isSalted)
12782 {
12783 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12784 {
12785 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12786 }
12787 }
12788 else
12789 {
12790 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12791 }
12792
12793 if (hashes_pos > hashes_cnt)
12794 {
12795 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12796 }
12797
12798 hashes_cnt++;
12799 }
12800
12801 /**
12802 * Potfile removes
12803 */
12804
12805 uint potfile_remove_cracks = 0;
12806
12807 if (potfile_disable == 0)
12808 {
12809 hash_t hash_buf;
12810
12811 hash_buf.digest = mymalloc (dgst_size);
12812 hash_buf.salt = NULL;
12813 hash_buf.esalt = NULL;
12814 hash_buf.hash_info = NULL;
12815 hash_buf.cracked = 0;
12816
12817 if (isSalted)
12818 {
12819 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12820 }
12821
12822 if (esalt_size)
12823 {
12824 hash_buf.esalt = mymalloc (esalt_size);
12825 }
12826
12827 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12828
12829 // no solution for these special hash types (for instane because they use hashfile in output etc)
12830 if ((hash_mode != 5200) &&
12831 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12832 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12833 (hash_mode != 9000))
12834 {
12835 FILE *fp = fopen (potfile, "rb");
12836
12837 if (fp != NULL)
12838 {
12839 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12840
12841 // to be safe work with a copy (because of line_len loop, i etc)
12842 // moved up here because it's easier to handle continue case
12843 // it's just 64kb
12844
12845 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12846
12847 while (!feof (fp))
12848 {
12849 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12850
12851 if (ptr == NULL) break;
12852
12853 int line_len = strlen (line_buf);
12854
12855 if (line_len == 0) continue;
12856
12857 int iter = MAX_CUT_TRIES;
12858
12859 for (int i = line_len - 1; i && iter; i--, line_len--)
12860 {
12861 if (line_buf[i] != ':') continue;
12862
12863 if (isSalted)
12864 {
12865 memset (hash_buf.salt, 0, sizeof (salt_t));
12866 }
12867
12868 hash_t *found = NULL;
12869
12870 if (hash_mode == 6800)
12871 {
12872 if (i < 64) // 64 = 16 * uint in salt_buf[]
12873 {
12874 // manipulate salt_buf
12875 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12876
12877 hash_buf.salt->salt_len = i;
12878
12879 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12880 }
12881 }
12882 else if (hash_mode == 2500)
12883 {
12884 if (i < 64) // 64 = 16 * uint in salt_buf[]
12885 {
12886 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12887 // manipulate salt_buf
12888
12889 memcpy (line_buf_cpy, line_buf, i);
12890
12891 char *mac2_pos = strrchr (line_buf_cpy, ':');
12892
12893 if (mac2_pos == NULL) continue;
12894
12895 mac2_pos[0] = 0;
12896 mac2_pos++;
12897
12898 if (strlen (mac2_pos) != 12) continue;
12899
12900 char *mac1_pos = strrchr (line_buf_cpy, ':');
12901
12902 if (mac1_pos == NULL) continue;
12903
12904 mac1_pos[0] = 0;
12905 mac1_pos++;
12906
12907 if (strlen (mac1_pos) != 12) continue;
12908
12909 uint essid_length = mac1_pos - line_buf_cpy - 1;
12910
12911 // here we need the ESSID
12912 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12913
12914 hash_buf.salt->salt_len = essid_length;
12915
12916 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12917
12918 if (found)
12919 {
12920 wpa_t *wpa = (wpa_t *) found->esalt;
12921
12922 // compare hex string(s) vs binary MAC address(es)
12923
12924 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12925 {
12926 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12927 {
12928 found = NULL;
12929
12930 break;
12931 }
12932 }
12933
12934 // early skip ;)
12935 if (!found) continue;
12936
12937 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12938 {
12939 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12940 {
12941 found = NULL;
12942
12943 break;
12944 }
12945 }
12946 }
12947 }
12948 }
12949 else
12950 {
12951 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12952
12953 if (parser_status == PARSER_OK)
12954 {
12955 if (isSalted)
12956 {
12957 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12958 }
12959 else
12960 {
12961 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12962 }
12963 }
12964 }
12965
12966 if (found == NULL) continue;
12967
12968 if (!found->cracked) potfile_remove_cracks++;
12969
12970 found->cracked = 1;
12971
12972 if (found) break;
12973
12974 iter--;
12975 }
12976 }
12977
12978 myfree (line_buf_cpy);
12979
12980 myfree (line_buf);
12981
12982 fclose (fp);
12983 }
12984 }
12985
12986 if (esalt_size)
12987 {
12988 local_free (hash_buf.esalt);
12989 }
12990
12991 if (isSalted)
12992 {
12993 local_free (hash_buf.salt);
12994 }
12995
12996 local_free (hash_buf.digest);
12997 }
12998
12999 /**
13000 * Now generate all the buffers required for later
13001 */
13002
13003 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
13004
13005 salt_t *salts_buf_new = NULL;
13006 void *esalts_buf_new = NULL;
13007
13008 if (isSalted)
13009 {
13010 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
13011
13012 if (esalt_size)
13013 {
13014 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
13015 }
13016 }
13017 else
13018 {
13019 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13020 }
13021
13022 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13023
13024 uint digests_cnt = hashes_cnt;
13025 uint digests_done = 0;
13026
13027 size_t size_digests = digests_cnt * dgst_size;
13028 size_t size_shown = digests_cnt * sizeof (uint);
13029
13030 uint *digests_shown = (uint *) mymalloc (size_shown);
13031 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13032
13033 uint salts_cnt = 0;
13034 uint salts_done = 0;
13035
13036 hashinfo_t **hash_info = NULL;
13037
13038 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13039 {
13040 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13041
13042 if (username && (remove || show))
13043 {
13044 uint user_pos;
13045
13046 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13047 {
13048 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13049
13050 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13051 }
13052 }
13053 }
13054
13055 uint *salts_shown = (uint *) mymalloc (size_shown);
13056
13057 salt_t *salt_buf;
13058
13059 {
13060 // copied from inner loop
13061
13062 salt_buf = &salts_buf_new[salts_cnt];
13063
13064 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13065
13066 if (esalt_size)
13067 {
13068 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13069 }
13070
13071 salt_buf->digests_cnt = 0;
13072 salt_buf->digests_done = 0;
13073 salt_buf->digests_offset = 0;
13074
13075 salts_cnt++;
13076 }
13077
13078 if (hashes_buf[0].cracked == 1)
13079 {
13080 digests_shown[0] = 1;
13081
13082 digests_done++;
13083
13084 salt_buf->digests_done++;
13085 }
13086
13087 salt_buf->digests_cnt++;
13088
13089 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13090
13091 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13092 {
13093 hash_info[0] = hashes_buf[0].hash_info;
13094 }
13095
13096 // copy from inner loop
13097
13098 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13099 {
13100 if (isSalted)
13101 {
13102 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13103 {
13104 salt_buf = &salts_buf_new[salts_cnt];
13105
13106 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13107
13108 if (esalt_size)
13109 {
13110 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13111 }
13112
13113 salt_buf->digests_cnt = 0;
13114 salt_buf->digests_done = 0;
13115 salt_buf->digests_offset = hashes_pos;
13116
13117 salts_cnt++;
13118 }
13119 }
13120
13121 if (hashes_buf[hashes_pos].cracked == 1)
13122 {
13123 digests_shown[hashes_pos] = 1;
13124
13125 digests_done++;
13126
13127 salt_buf->digests_done++;
13128 }
13129
13130 salt_buf->digests_cnt++;
13131
13132 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13133
13134 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13135 {
13136 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13137 }
13138 }
13139
13140 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13141 {
13142 salt_t *salt_buf = &salts_buf_new[salt_pos];
13143
13144 if (salt_buf->digests_done == salt_buf->digests_cnt)
13145 {
13146 salts_shown[salt_pos] = 1;
13147
13148 salts_done++;
13149 }
13150
13151 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13152 }
13153
13154 local_free (digests_buf);
13155 local_free (salts_buf);
13156 local_free (esalts_buf);
13157
13158 digests_buf = digests_buf_new;
13159 salts_buf = salts_buf_new;
13160 esalts_buf = esalts_buf_new;
13161
13162 local_free (hashes_buf);
13163
13164 /**
13165 * special modification not set from parser
13166 */
13167
13168 switch (hash_mode)
13169 {
13170 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13171 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13172 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13173 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13174 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13175 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13176 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13177 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13178 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13179 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13180 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13181 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13182 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13183 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13184 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13185 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13186 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13187 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13188 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13189 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13190 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13191 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13192 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13193 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13194 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13195 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13196 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13197 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13198 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13199 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13200 }
13201
13202 if (truecrypt_keyfiles)
13203 {
13204 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13205
13206 char *keyfiles = strdup (truecrypt_keyfiles);
13207
13208 char *keyfile = strtok (keyfiles, ",");
13209
13210 do
13211 {
13212 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13213
13214 } while ((keyfile = strtok (NULL, ",")) != NULL);
13215
13216 free (keyfiles);
13217 }
13218
13219 if (veracrypt_keyfiles)
13220 {
13221 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13222
13223 char *keyfiles = strdup (veracrypt_keyfiles);
13224
13225 char *keyfile = strtok (keyfiles, ",");
13226
13227 do
13228 {
13229 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13230
13231 } while ((keyfile = strtok (NULL, ",")) != NULL);
13232
13233 free (keyfiles);
13234 }
13235
13236 data.digests_cnt = digests_cnt;
13237 data.digests_done = digests_done;
13238 data.digests_buf = digests_buf;
13239 data.digests_shown = digests_shown;
13240 data.digests_shown_tmp = digests_shown_tmp;
13241
13242 data.salts_cnt = salts_cnt;
13243 data.salts_done = salts_done;
13244 data.salts_buf = salts_buf;
13245 data.salts_shown = salts_shown;
13246
13247 data.esalts_buf = esalts_buf;
13248 data.hash_info = hash_info;
13249
13250 /**
13251 * Automatic Optimizers
13252 */
13253
13254 if (salts_cnt == 1)
13255 opti_type |= OPTI_TYPE_SINGLE_SALT;
13256
13257 if (digests_cnt == 1)
13258 opti_type |= OPTI_TYPE_SINGLE_HASH;
13259
13260 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13261 opti_type |= OPTI_TYPE_NOT_ITERATED;
13262
13263 if (attack_mode == ATTACK_MODE_BF)
13264 opti_type |= OPTI_TYPE_BRUTE_FORCE;
13265
13266 data.opti_type = opti_type;
13267
13268 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13269 {
13270 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13271 {
13272 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13273 {
13274 if (opts_type & OPTS_TYPE_ST_ADD80)
13275 {
13276 opts_type &= ~OPTS_TYPE_ST_ADD80;
13277 opts_type |= OPTS_TYPE_PT_ADD80;
13278 }
13279
13280 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13281 {
13282 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13283 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13284 }
13285
13286 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13287 {
13288 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13289 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13290 }
13291 }
13292 }
13293 }
13294
13295 /**
13296 * Some algorithm, like descrypt, can benefit from JIT compilation
13297 */
13298
13299 int force_jit_compilation = -1;
13300
13301 if (hash_mode == 8900)
13302 {
13303 force_jit_compilation = 8900;
13304 }
13305 else if (hash_mode == 9300)
13306 {
13307 force_jit_compilation = 8900;
13308 }
13309 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13310 {
13311 force_jit_compilation = 1500;
13312 }
13313
13314 /**
13315 * generate bitmap tables
13316 */
13317
13318 const uint bitmap_shift1 = 5;
13319 const uint bitmap_shift2 = 13;
13320
13321 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13322
13323 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13324 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13325 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13326 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13327 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13328 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13329 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13330 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13331
13332 uint bitmap_bits;
13333 uint bitmap_nums;
13334 uint bitmap_mask;
13335 uint bitmap_size;
13336
13337 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13338 {
13339 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13340
13341 bitmap_nums = 1 << bitmap_bits;
13342
13343 bitmap_mask = bitmap_nums - 1;
13344
13345 bitmap_size = bitmap_nums * sizeof (uint);
13346
13347 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13348
13349 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;
13350 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;
13351
13352 break;
13353 }
13354
13355 bitmap_nums = 1 << bitmap_bits;
13356
13357 bitmap_mask = bitmap_nums - 1;
13358
13359 bitmap_size = bitmap_nums * sizeof (uint);
13360
13361 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);
13362 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);
13363
13364 /**
13365 * prepare quick rule
13366 */
13367
13368 data.rule_buf_l = rule_buf_l;
13369 data.rule_buf_r = rule_buf_r;
13370
13371 int rule_len_l = (int) strlen (rule_buf_l);
13372 int rule_len_r = (int) strlen (rule_buf_r);
13373
13374 data.rule_len_l = rule_len_l;
13375 data.rule_len_r = rule_len_r;
13376
13377 /**
13378 * load rules
13379 */
13380
13381 uint *all_kernel_rules_cnt = NULL;
13382
13383 kernel_rule_t **all_kernel_rules_buf = NULL;
13384
13385 if (rp_files_cnt)
13386 {
13387 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13388
13389 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13390 }
13391
13392 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13393
13394 int rule_len = 0;
13395
13396 for (uint i = 0; i < rp_files_cnt; i++)
13397 {
13398 uint kernel_rules_avail = 0;
13399
13400 uint kernel_rules_cnt = 0;
13401
13402 kernel_rule_t *kernel_rules_buf = NULL;
13403
13404 char *rp_file = rp_files[i];
13405
13406 char in[BLOCK_SIZE] = { 0 };
13407 char out[BLOCK_SIZE] = { 0 };
13408
13409 FILE *fp = NULL;
13410
13411 uint rule_line = 0;
13412
13413 if ((fp = fopen (rp_file, "rb")) == NULL)
13414 {
13415 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13416
13417 return (-1);
13418 }
13419
13420 while (!feof (fp))
13421 {
13422 memset (rule_buf, 0, HCBUFSIZ);
13423
13424 rule_len = fgetl (fp, rule_buf);
13425
13426 rule_line++;
13427
13428 if (rule_len == 0) continue;
13429
13430 if (rule_buf[0] == '#') continue;
13431
13432 if (kernel_rules_avail == kernel_rules_cnt)
13433 {
13434 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13435
13436 kernel_rules_avail += INCR_RULES;
13437 }
13438
13439 memset (in, 0, BLOCK_SIZE);
13440 memset (out, 0, BLOCK_SIZE);
13441
13442 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13443
13444 if (result == -1)
13445 {
13446 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13447
13448 continue;
13449 }
13450
13451 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13452 {
13453 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13454
13455 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13456
13457 continue;
13458 }
13459
13460 /* its so slow
13461 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13462 {
13463 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13464
13465 continue;
13466 }
13467 */
13468
13469 kernel_rules_cnt++;
13470 }
13471
13472 fclose (fp);
13473
13474 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13475
13476 all_kernel_rules_buf[i] = kernel_rules_buf;
13477 }
13478
13479 /**
13480 * merge rules or automatic rule generator
13481 */
13482
13483 uint kernel_rules_cnt = 0;
13484
13485 kernel_rule_t *kernel_rules_buf = NULL;
13486
13487 if (attack_mode == ATTACK_MODE_STRAIGHT)
13488 {
13489 if (rp_files_cnt)
13490 {
13491 kernel_rules_cnt = 1;
13492
13493 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13494
13495 repeats[0] = kernel_rules_cnt;
13496
13497 for (uint i = 0; i < rp_files_cnt; i++)
13498 {
13499 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13500
13501 repeats[i + 1] = kernel_rules_cnt;
13502 }
13503
13504 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13505
13506 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13507
13508 for (uint i = 0; i < kernel_rules_cnt; i++)
13509 {
13510 uint out_pos = 0;
13511
13512 kernel_rule_t *out = &kernel_rules_buf[i];
13513
13514 for (uint j = 0; j < rp_files_cnt; j++)
13515 {
13516 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13517 uint in_pos;
13518
13519 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13520
13521 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13522 {
13523 if (out_pos == RULES_MAX - 1)
13524 {
13525 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13526
13527 break;
13528 }
13529
13530 out->cmds[out_pos] = in->cmds[in_pos];
13531 }
13532 }
13533 }
13534
13535 local_free (repeats);
13536 }
13537 else if (rp_gen)
13538 {
13539 uint kernel_rules_avail = 0;
13540
13541 while (kernel_rules_cnt < rp_gen)
13542 {
13543 if (kernel_rules_avail == kernel_rules_cnt)
13544 {
13545 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13546
13547 kernel_rules_avail += INCR_RULES;
13548 }
13549
13550 memset (rule_buf, 0, HCBUFSIZ);
13551
13552 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13553
13554 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13555
13556 kernel_rules_cnt++;
13557 }
13558 }
13559 }
13560
13561 myfree (rule_buf);
13562
13563 /**
13564 * generate NOP rules
13565 */
13566
13567 if (kernel_rules_cnt == 0)
13568 {
13569 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13570
13571 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13572
13573 kernel_rules_cnt++;
13574 }
13575
13576 data.kernel_rules_cnt = kernel_rules_cnt;
13577 data.kernel_rules_buf = kernel_rules_buf;
13578
13579 /**
13580 * OpenCL platforms: detect
13581 */
13582
13583 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13584 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13585
13586 cl_uint platforms_cnt = 0;
13587 cl_uint platform_devices_cnt = 0;
13588
13589 if (keyspace == 0)
13590 {
13591 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13592
13593 if (platforms_cnt == 0)
13594 {
13595 log_info ("");
13596 log_info ("ATTENTION! No OpenCL compatible platform found");
13597 log_info ("");
13598 log_info ("You're probably missing the OpenCL runtime installation");
13599 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13600 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13601 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13602 log_info ("");
13603
13604 return (-1);
13605 }
13606
13607 if (opencl_platforms_filter != (uint) -1)
13608 {
13609 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13610
13611 if (opencl_platforms_filter > platform_cnt_mask)
13612 {
13613 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13614
13615 return (-1);
13616 }
13617 }
13618 }
13619
13620 /**
13621 * OpenCL device types:
13622 * 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.
13623 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13624 */
13625
13626 if (opencl_device_types == NULL)
13627 {
13628 cl_device_type device_types_all = 0;
13629
13630 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13631 {
13632 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13633
13634 cl_platform_id platform = platforms[platform_id];
13635
13636 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13637
13638 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13639 {
13640 cl_device_id device = platform_devices[platform_devices_id];
13641
13642 cl_device_type device_type;
13643
13644 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13645
13646 device_types_all |= device_type;
13647 }
13648 }
13649
13650 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13651 {
13652 device_types_filter |= CL_DEVICE_TYPE_CPU;
13653 }
13654 }
13655
13656 /**
13657 * OpenCL devices: simply push all devices from all platforms into the same device array
13658 */
13659
13660 int need_adl = 0;
13661 int need_nvapi = 0;
13662 int need_nvml = 0;
13663 int need_xnvctrl = 0;
13664
13665 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13666
13667 data.devices_param = devices_param;
13668
13669 uint devices_cnt = 0;
13670
13671 uint devices_active = 0;
13672
13673 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13674 {
13675 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13676
13677 cl_platform_id platform = platforms[platform_id];
13678
13679 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13680
13681 char platform_vendor[INFOSZ] = { 0 };
13682
13683 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13684
13685 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13686 // this causes trouble with vendor id based macros
13687 // we'll assign generic to those without special optimization available
13688
13689 cl_uint platform_vendor_id = 0;
13690
13691 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13692 {
13693 platform_vendor_id = VENDOR_ID_AMD;
13694 }
13695 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13696 {
13697 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13698 }
13699 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13700 {
13701 platform_vendor_id = VENDOR_ID_APPLE;
13702 }
13703 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13704 {
13705 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13706 }
13707 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13708 {
13709 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13710 }
13711 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13712 {
13713 platform_vendor_id = VENDOR_ID_MESA;
13714 }
13715 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13716 {
13717 platform_vendor_id = VENDOR_ID_NV;
13718 }
13719 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13720 {
13721 platform_vendor_id = VENDOR_ID_POCL;
13722 }
13723 else
13724 {
13725 platform_vendor_id = VENDOR_ID_GENERIC;
13726 }
13727
13728 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13729 {
13730 size_t param_value_size = 0;
13731
13732 const uint device_id = devices_cnt;
13733
13734 hc_device_param_t *device_param = &data.devices_param[device_id];
13735
13736 device_param->platform_vendor_id = platform_vendor_id;
13737
13738 device_param->device = platform_devices[platform_devices_id];
13739
13740 device_param->device_id = device_id;
13741
13742 device_param->platform_devices_id = platform_devices_id;
13743
13744 // device_type
13745
13746 cl_device_type device_type;
13747
13748 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13749
13750 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13751
13752 device_param->device_type = device_type;
13753
13754 // device_name
13755
13756 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13757
13758 char *device_name = (char *) mymalloc (param_value_size);
13759
13760 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13761
13762 device_param->device_name = device_name;
13763
13764 // device_vendor
13765
13766 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13767
13768 char *device_vendor = (char *) mymalloc (param_value_size);
13769
13770 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13771
13772 device_param->device_vendor = device_vendor;
13773
13774 cl_uint device_vendor_id = 0;
13775
13776 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13777 {
13778 device_vendor_id = VENDOR_ID_AMD;
13779 }
13780 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13781 {
13782 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13783 }
13784 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13785 {
13786 device_vendor_id = VENDOR_ID_APPLE;
13787 }
13788 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13789 {
13790 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13791 }
13792 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13793 {
13794 device_vendor_id = VENDOR_ID_INTEL_SDK;
13795 }
13796 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13797 {
13798 device_vendor_id = VENDOR_ID_MESA;
13799 }
13800 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13801 {
13802 device_vendor_id = VENDOR_ID_NV;
13803 }
13804 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13805 {
13806 device_vendor_id = VENDOR_ID_POCL;
13807 }
13808 else
13809 {
13810 device_vendor_id = VENDOR_ID_GENERIC;
13811 }
13812
13813 device_param->device_vendor_id = device_vendor_id;
13814
13815 // tuning db
13816
13817 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13818
13819 // device_version
13820
13821 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13822
13823 char *device_version = (char *) mymalloc (param_value_size);
13824
13825 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13826
13827 device_param->device_version = device_version;
13828
13829 // device_opencl_version
13830
13831 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13832
13833 char *device_opencl_version = (char *) mymalloc (param_value_size);
13834
13835 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13836
13837 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13838
13839 myfree (device_opencl_version);
13840
13841 // vector_width
13842
13843 cl_uint vector_width;
13844
13845 if (opencl_vector_width_chgd == 0)
13846 {
13847 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13848 {
13849 if (opti_type & OPTI_TYPE_USES_BITS_64)
13850 {
13851 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13852 }
13853 else
13854 {
13855 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13856 }
13857 }
13858 else
13859 {
13860 vector_width = (cl_uint) tuningdb_entry->vector_width;
13861 }
13862 }
13863 else
13864 {
13865 vector_width = opencl_vector_width;
13866 }
13867
13868 if (vector_width > 16) vector_width = 16;
13869
13870 device_param->vector_width = vector_width;
13871
13872 // max_compute_units
13873
13874 cl_uint device_processors;
13875
13876 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13877
13878 device_param->device_processors = device_processors;
13879
13880 // device_maxmem_alloc
13881 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13882
13883 cl_ulong device_maxmem_alloc;
13884
13885 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13886
13887 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13888
13889 // device_global_mem
13890
13891 cl_ulong device_global_mem;
13892
13893 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13894
13895 device_param->device_global_mem = device_global_mem;
13896
13897 // max_work_group_size
13898
13899 size_t device_maxworkgroup_size;
13900
13901 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13902
13903 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13904
13905 // max_clock_frequency
13906
13907 cl_uint device_maxclock_frequency;
13908
13909 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13910
13911 device_param->device_maxclock_frequency = device_maxclock_frequency;
13912
13913 // device_endian_little
13914
13915 cl_bool device_endian_little;
13916
13917 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13918
13919 if (device_endian_little == CL_FALSE)
13920 {
13921 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13922
13923 device_param->skipped = 1;
13924 }
13925
13926 // device_available
13927
13928 cl_bool device_available;
13929
13930 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13931
13932 if (device_available == CL_FALSE)
13933 {
13934 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13935
13936 device_param->skipped = 1;
13937 }
13938
13939 // device_compiler_available
13940
13941 cl_bool device_compiler_available;
13942
13943 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13944
13945 if (device_compiler_available == CL_FALSE)
13946 {
13947 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13948
13949 device_param->skipped = 1;
13950 }
13951
13952 // device_execution_capabilities
13953
13954 cl_device_exec_capabilities device_execution_capabilities;
13955
13956 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13957
13958 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13959 {
13960 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13961
13962 device_param->skipped = 1;
13963 }
13964
13965 // device_extensions
13966
13967 size_t device_extensions_size;
13968
13969 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13970
13971 char *device_extensions = mymalloc (device_extensions_size + 1);
13972
13973 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13974
13975 if (strstr (device_extensions, "base_atomics") == 0)
13976 {
13977 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13978
13979 device_param->skipped = 1;
13980 }
13981
13982 if (strstr (device_extensions, "byte_addressable_store") == 0)
13983 {
13984 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13985
13986 device_param->skipped = 1;
13987 }
13988
13989 myfree (device_extensions);
13990
13991 // device_local_mem_size
13992
13993 cl_ulong device_local_mem_size;
13994
13995 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13996
13997 if (device_local_mem_size < 32768)
13998 {
13999 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
14000
14001 device_param->skipped = 1;
14002 }
14003
14004 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
14005 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
14006 // This results in both utilizing it for 50%
14007 // However, Intel has much better SIMD control over their own hardware
14008 // It makes sense to give them full control over their own hardware
14009
14010 if (device_type & CL_DEVICE_TYPE_CPU)
14011 {
14012 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14013 {
14014 if (data.force == 0)
14015 {
14016 if (algorithm_pos == 0)
14017 {
14018 log_info ("Device #%u: WARNING: not native intel opencl runtime, expect massive speed loss", device_id + 1);
14019 log_info (" You can use --force to override this but do not post error reports if you do so");
14020 }
14021
14022 device_param->skipped = 1;
14023 }
14024 }
14025 }
14026
14027 // skipped
14028
14029 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14030 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14031
14032 // driver_version
14033
14034 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14035
14036 char *driver_version = (char *) mymalloc (param_value_size);
14037
14038 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14039
14040 device_param->driver_version = driver_version;
14041
14042 // device_name_chksum
14043
14044 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14045
14046 #if __x86_64__
14047 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);
14048 #else
14049 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);
14050 #endif
14051
14052 uint device_name_digest[4] = { 0 };
14053
14054 md5_64 ((uint *) device_name_chksum, device_name_digest);
14055
14056 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14057
14058 device_param->device_name_chksum = device_name_chksum;
14059
14060 // device_processor_cores
14061
14062 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14063 {
14064 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14065 {
14066 need_adl = 1;
14067 }
14068
14069 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14070 {
14071 need_nvml = 1;
14072
14073 #ifdef _LINUX
14074 need_xnvctrl = 1;
14075 #endif
14076
14077 #ifdef _WIN
14078 need_nvapi = 1;
14079 #endif
14080 }
14081 }
14082
14083 // device_processor_cores
14084
14085 if (device_type & CL_DEVICE_TYPE_CPU)
14086 {
14087 cl_uint device_processor_cores = 1;
14088
14089 device_param->device_processor_cores = device_processor_cores;
14090 }
14091
14092 if (device_type & CL_DEVICE_TYPE_GPU)
14093 {
14094 if (device_vendor_id == VENDOR_ID_AMD)
14095 {
14096 cl_uint device_processor_cores = 0;
14097
14098 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
14099
14100 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
14101
14102 device_param->device_processor_cores = device_processor_cores;
14103 }
14104 else if (device_vendor_id == VENDOR_ID_NV)
14105 {
14106 cl_uint kernel_exec_timeout = 0;
14107
14108 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14109
14110 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14111
14112 device_param->kernel_exec_timeout = kernel_exec_timeout;
14113
14114 cl_uint device_processor_cores = 0;
14115
14116 #define CL_DEVICE_WARP_SIZE_NV 0x4003
14117
14118 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
14119
14120 device_param->device_processor_cores = device_processor_cores;
14121
14122 cl_uint sm_minor = 0;
14123 cl_uint sm_major = 0;
14124
14125 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14126 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14127
14128 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14129 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14130
14131 device_param->sm_minor = sm_minor;
14132 device_param->sm_major = sm_major;
14133
14134 // CPU burning loop damper
14135 // Value is given as number between 0-100
14136 // By default 100%
14137
14138 device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14139
14140 if (nvidia_spin_damp_chgd == 0)
14141 {
14142 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14143 {
14144 /**
14145 * the workaround is not a friend of rule based attacks
14146 * the words from the wordlist combined with fast and slow rules cause
14147 * fluctuations which cause inaccurate wait time estimations
14148 * using a reduced damping percentage almost compensates this
14149 */
14150
14151 device_param->nvidia_spin_damp = 64;
14152 }
14153 }
14154
14155 device_param->nvidia_spin_damp /= 100;
14156 }
14157 else
14158 {
14159 cl_uint device_processor_cores = 1;
14160
14161 device_param->device_processor_cores = device_processor_cores;
14162 }
14163 }
14164
14165 // display results
14166
14167 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14168 {
14169 if (machine_readable == 0)
14170 {
14171 if (device_param->skipped == 0)
14172 {
14173 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14174 device_id + 1,
14175 device_name,
14176 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14177 (unsigned int) (device_global_mem / 1024 / 1024),
14178 (unsigned int) device_processors);
14179 }
14180 else
14181 {
14182 log_info ("Device #%u: %s, skipped",
14183 device_id + 1,
14184 device_name);
14185 }
14186 }
14187 }
14188
14189 // common driver check
14190
14191 if (device_param->skipped == 0)
14192 {
14193 if (device_type & CL_DEVICE_TYPE_GPU)
14194 {
14195 if (platform_vendor_id == VENDOR_ID_AMD)
14196 {
14197 int catalyst_check = (force == 1) ? 0 : 1;
14198
14199 int catalyst_warn = 0;
14200
14201 int catalyst_broken = 0;
14202
14203 if (catalyst_check == 1)
14204 {
14205 catalyst_warn = 1;
14206
14207 // v14.9 and higher
14208 if (atoi (device_param->driver_version) >= 1573)
14209 {
14210 catalyst_warn = 0;
14211 }
14212
14213 catalyst_check = 0;
14214 }
14215
14216 if (catalyst_broken == 1)
14217 {
14218 log_info ("");
14219 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
14220 log_info ("It will pass over cracked hashes and does not report them as cracked");
14221 log_info ("You are STRONGLY encouraged not to use it");
14222 log_info ("You can use --force to override this but do not post error reports if you do so");
14223 log_info ("");
14224
14225 return (-1);
14226 }
14227
14228 if (catalyst_warn == 1)
14229 {
14230 log_info ("");
14231 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
14232 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
14233 log_info ("See hashcat's homepage for official supported catalyst drivers");
14234 #ifdef _WIN
14235 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14236 #endif
14237 log_info ("You can use --force to override this but do not post error reports if you do so");
14238 log_info ("");
14239
14240 return (-1);
14241 }
14242 }
14243 else if (platform_vendor_id == VENDOR_ID_NV)
14244 {
14245 if (device_param->kernel_exec_timeout != 0)
14246 {
14247 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);
14248 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14249 }
14250 }
14251 }
14252
14253 /* turns out pocl still creates segfaults (because of llvm)
14254 if (device_type & CL_DEVICE_TYPE_CPU)
14255 {
14256 if (platform_vendor_id == VENDOR_ID_AMD)
14257 {
14258 if (force == 0)
14259 {
14260 log_info ("");
14261 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14262 log_info ("You are STRONGLY encouraged not to use it");
14263 log_info ("You can use --force to override this but do not post error reports if you do so");
14264 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14265 log_info ("");
14266
14267 return (-1);
14268 }
14269 }
14270 }
14271 */
14272
14273 /**
14274 * kernel accel and loops tuning db adjustment
14275 */
14276
14277 device_param->kernel_accel_min = 1;
14278 device_param->kernel_accel_max = 1024;
14279
14280 device_param->kernel_loops_min = 1;
14281 device_param->kernel_loops_max = 1024;
14282
14283 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14284
14285 if (tuningdb_entry)
14286 {
14287 u32 _kernel_accel = tuningdb_entry->kernel_accel;
14288 u32 _kernel_loops = tuningdb_entry->kernel_loops;
14289
14290 if (_kernel_accel)
14291 {
14292 device_param->kernel_accel_min = _kernel_accel;
14293 device_param->kernel_accel_max = _kernel_accel;
14294 }
14295
14296 if (_kernel_loops)
14297 {
14298 if (workload_profile == 1)
14299 {
14300 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14301 }
14302 else if (workload_profile == 2)
14303 {
14304 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14305 }
14306
14307 device_param->kernel_loops_min = _kernel_loops;
14308 device_param->kernel_loops_max = _kernel_loops;
14309 }
14310 }
14311
14312 // commandline parameters overwrite tuningdb entries
14313
14314 if (kernel_accel)
14315 {
14316 device_param->kernel_accel_min = kernel_accel;
14317 device_param->kernel_accel_max = kernel_accel;
14318 }
14319
14320 if (kernel_loops)
14321 {
14322 device_param->kernel_loops_min = kernel_loops;
14323 device_param->kernel_loops_max = kernel_loops;
14324 }
14325
14326 /**
14327 * activate device
14328 */
14329
14330 devices_active++;
14331 }
14332
14333 // next please
14334
14335 devices_cnt++;
14336 }
14337 }
14338
14339 if (keyspace == 0 && devices_active == 0)
14340 {
14341 log_error ("ERROR: No devices found/left");
14342
14343 return (-1);
14344 }
14345
14346 // 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)
14347
14348 if (devices_filter != (uint) -1)
14349 {
14350 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14351
14352 if (devices_filter > devices_cnt_mask)
14353 {
14354 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14355
14356 return (-1);
14357 }
14358 }
14359
14360 data.devices_cnt = devices_cnt;
14361
14362 data.devices_active = devices_active;
14363
14364 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14365 {
14366 if (machine_readable == 0)
14367 {
14368 log_info ("");
14369 }
14370 }
14371
14372 /**
14373 * HM devices: init
14374 */
14375
14376 #ifdef HAVE_HWMON
14377 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14378 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14379 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14380 hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX] = { { 0 } };
14381
14382 if (gpu_temp_disable == 0)
14383 {
14384 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14385 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14386 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14387 XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));
14388
14389 data.hm_adl = NULL;
14390 data.hm_nvapi = NULL;
14391 data.hm_nvml = NULL;
14392 data.hm_xnvctrl = NULL;
14393
14394 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14395 {
14396 data.hm_nvml = nvml;
14397 }
14398
14399 if (data.hm_nvml)
14400 {
14401 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14402 {
14403 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14404
14405 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14406
14407 int tmp_out = 0;
14408
14409 for (int i = 0; i < tmp_in; i++)
14410 {
14411 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14412 }
14413
14414 for (int i = 0; i < tmp_out; i++)
14415 {
14416 unsigned int speed;
14417
14418 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14419
14420 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14421
14422 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14423 }
14424 }
14425 }
14426
14427 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14428 {
14429 data.hm_nvapi = nvapi;
14430 }
14431
14432 if (data.hm_nvapi)
14433 {
14434 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14435 {
14436 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14437
14438 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14439
14440 int tmp_out = 0;
14441
14442 for (int i = 0; i < tmp_in; i++)
14443 {
14444 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14445 }
14446 }
14447 }
14448
14449 if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0))
14450 {
14451 data.hm_xnvctrl = xnvctrl;
14452 }
14453
14454 if (data.hm_xnvctrl)
14455 {
14456 if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
14457 {
14458 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14459 {
14460 hc_device_param_t *device_param = &data.devices_param[device_id];
14461
14462 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14463
14464 hm_adapters_xnvctrl[device_id].xnvctrl = device_id;
14465
14466 int speed = 0;
14467
14468 if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
14469 }
14470 }
14471 }
14472
14473 if ((need_adl == 1) && (adl_init (adl) == 0))
14474 {
14475 data.hm_adl = adl;
14476 }
14477
14478 if (data.hm_adl)
14479 {
14480 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14481 {
14482 // total number of adapters
14483
14484 int hm_adapters_num;
14485
14486 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14487
14488 // adapter info
14489
14490 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14491
14492 if (lpAdapterInfo == NULL) return (-1);
14493
14494 // get a list (of ids of) valid/usable adapters
14495
14496 int num_adl_adapters = 0;
14497
14498 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14499
14500 if (num_adl_adapters > 0)
14501 {
14502 hc_thread_mutex_lock (mux_adl);
14503
14504 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14505
14506 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14507
14508 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14509 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14510
14511 hc_thread_mutex_unlock (mux_adl);
14512 }
14513
14514 myfree (valid_adl_device_list);
14515 myfree (lpAdapterInfo);
14516 }
14517 }
14518
14519 if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14520 {
14521 gpu_temp_disable = 1;
14522 }
14523 }
14524
14525 /**
14526 * OpenCL devices: allocate buffer for device specific information
14527 */
14528
14529 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14530 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14531
14532 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14533
14534 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14535
14536 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14537
14538 /**
14539 * User-defined GPU temp handling
14540 */
14541
14542 if (gpu_temp_disable == 1)
14543 {
14544 gpu_temp_abort = 0;
14545 gpu_temp_retain = 0;
14546 }
14547
14548 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14549 {
14550 if (gpu_temp_abort < gpu_temp_retain)
14551 {
14552 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14553
14554 return (-1);
14555 }
14556 }
14557
14558 data.gpu_temp_disable = gpu_temp_disable;
14559 data.gpu_temp_abort = gpu_temp_abort;
14560 data.gpu_temp_retain = gpu_temp_retain;
14561 #endif
14562
14563 /**
14564 * enable custom signal handler(s)
14565 */
14566
14567 if (benchmark == 0)
14568 {
14569 hc_signal (sigHandler_default);
14570 }
14571 else
14572 {
14573 hc_signal (sigHandler_benchmark);
14574 }
14575
14576 /**
14577 * inform the user
14578 */
14579
14580 if (data.quiet == 0)
14581 {
14582 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14583
14584 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);
14585
14586 if (attack_mode == ATTACK_MODE_STRAIGHT)
14587 {
14588 log_info ("Rules: %u", kernel_rules_cnt);
14589 }
14590
14591 if (opti_type)
14592 {
14593 log_info ("Applicable Optimizers:");
14594
14595 for (uint i = 0; i < 32; i++)
14596 {
14597 const uint opti_bit = 1u << i;
14598
14599 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14600 }
14601 }
14602
14603 /**
14604 * Watchdog and Temperature balance
14605 */
14606
14607 #ifdef HAVE_HWMON
14608 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14609 {
14610 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14611 }
14612
14613 if (gpu_temp_abort == 0)
14614 {
14615 log_info ("Watchdog: Temperature abort trigger disabled");
14616 }
14617 else
14618 {
14619 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14620 }
14621
14622 if (gpu_temp_retain == 0)
14623 {
14624 log_info ("Watchdog: Temperature retain trigger disabled");
14625 }
14626 else
14627 {
14628 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14629 }
14630
14631 if (data.quiet == 0) log_info ("");
14632 #endif
14633 }
14634
14635 #ifdef HAVE_HWMON
14636
14637 /**
14638 * HM devices: copy
14639 */
14640
14641 if (gpu_temp_disable == 0)
14642 {
14643 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14644 {
14645 hc_device_param_t *device_param = &data.devices_param[device_id];
14646
14647 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14648
14649 if (device_param->skipped) continue;
14650
14651 const uint platform_devices_id = device_param->platform_devices_id;
14652
14653 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14654 {
14655 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14656 data.hm_device[device_id].nvapi = 0;
14657 data.hm_device[device_id].nvml = 0;
14658 data.hm_device[device_id].xnvctrl = 0;
14659 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14660 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14661 data.hm_device[device_id].fan_set_supported = 0;
14662 }
14663
14664 if (device_param->device_vendor_id == VENDOR_ID_NV)
14665 {
14666 data.hm_device[device_id].adl = 0;
14667 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14668 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14669 data.hm_device[device_id].xnvctrl = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
14670 data.hm_device[device_id].od_version = 0;
14671 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14672 data.hm_device[device_id].fan_set_supported = 0;
14673 }
14674 }
14675 }
14676
14677 /**
14678 * powertune on user request
14679 */
14680
14681 if (powertune_enable == 1)
14682 {
14683 hc_thread_mutex_lock (mux_adl);
14684
14685 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14686 {
14687 hc_device_param_t *device_param = &data.devices_param[device_id];
14688
14689 if (device_param->skipped) continue;
14690
14691 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14692 {
14693 /**
14694 * Temporary fix:
14695 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14696 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14697 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14698 * Driver / ADL bug?
14699 */
14700
14701 if (data.hm_device[device_id].od_version == 6)
14702 {
14703 int ADL_rc;
14704
14705 // check powertune capabilities first, if not available then skip device
14706
14707 int powertune_supported = 0;
14708
14709 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14710 {
14711 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14712
14713 return (-1);
14714 }
14715
14716 // first backup current value, we will restore it later
14717
14718 if (powertune_supported != 0)
14719 {
14720 // powercontrol settings
14721
14722 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14723
14724 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14725 {
14726 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14727 }
14728
14729 if (ADL_rc != ADL_OK)
14730 {
14731 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14732
14733 return (-1);
14734 }
14735
14736 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14737 {
14738 log_error ("ERROR: Failed to set new ADL PowerControl values");
14739
14740 return (-1);
14741 }
14742
14743 // clocks
14744
14745 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14746
14747 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14748
14749 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)
14750 {
14751 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14752
14753 return (-1);
14754 }
14755
14756 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14757
14758 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14759
14760 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14761 {
14762 log_error ("ERROR: Failed to get ADL device capabilities");
14763
14764 return (-1);
14765 }
14766
14767 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14768 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14769
14770 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14771 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14772
14773 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14774 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14775
14776 // warning if profile has too low max values
14777
14778 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14779 {
14780 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14781 }
14782
14783 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14784 {
14785 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14786 }
14787
14788 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14789
14790 performance_state->iNumberOfPerformanceLevels = 2;
14791
14792 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14793 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14794 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14795 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14796
14797 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)
14798 {
14799 log_info ("ERROR: Failed to set ADL performance state");
14800
14801 return (-1);
14802 }
14803
14804 local_free (performance_state);
14805 }
14806
14807 // set powertune value only
14808
14809 if (powertune_supported != 0)
14810 {
14811 // powertune set
14812 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14813
14814 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14815 {
14816 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14817
14818 return (-1);
14819 }
14820
14821 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14822 {
14823 log_error ("ERROR: Failed to set new ADL PowerControl values");
14824
14825 return (-1);
14826 }
14827 }
14828 }
14829 }
14830
14831 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14832 {
14833 // first backup current value, we will restore it later
14834
14835 unsigned int limit;
14836
14837 int powertune_supported = 0;
14838
14839 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14840 {
14841 powertune_supported = 1;
14842 }
14843
14844 // if backup worked, activate the maximum allowed
14845
14846 if (powertune_supported != 0)
14847 {
14848 unsigned int minLimit;
14849 unsigned int maxLimit;
14850
14851 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14852 {
14853 if (maxLimit > 0)
14854 {
14855 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14856 {
14857 // now we can be sure we need to reset later
14858
14859 nvml_power_limit[device_id] = limit;
14860 }
14861 }
14862 }
14863 }
14864 }
14865 }
14866
14867 hc_thread_mutex_unlock (mux_adl);
14868 }
14869
14870 #endif // HAVE_HWMON
14871
14872 #ifdef DEBUG
14873 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14874 #endif
14875
14876 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14877
14878 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14879 {
14880 /**
14881 * host buffer
14882 */
14883
14884 hc_device_param_t *device_param = &data.devices_param[device_id];
14885
14886 if (device_param->skipped) continue;
14887
14888 /**
14889 * device properties
14890 */
14891
14892 const char *device_name_chksum = device_param->device_name_chksum;
14893 const u32 device_processors = device_param->device_processors;
14894 const u32 device_processor_cores = device_param->device_processor_cores;
14895
14896 /**
14897 * create context for each device
14898 */
14899
14900 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14901
14902 /**
14903 * create command-queue
14904 */
14905
14906 // not supported with NV
14907 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14908
14909 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14910
14911 /**
14912 * kernel threads: some algorithms need a fixed kernel-threads count
14913 * because of shared memory usage or bitslice
14914 * there needs to be some upper limit, otherwise there's too much overhead
14915 */
14916
14917 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14918
14919 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14920 {
14921 kernel_threads = KERNEL_THREADS_MAX_CPU;
14922 }
14923
14924 if (hash_mode == 1500) kernel_threads = 64; // DES
14925 if (hash_mode == 3000) kernel_threads = 64; // DES
14926 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14927 if (hash_mode == 7500) kernel_threads = 64; // RC4
14928 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14929 if (hash_mode == 9700) kernel_threads = 64; // RC4
14930 if (hash_mode == 9710) kernel_threads = 64; // RC4
14931 if (hash_mode == 9800) kernel_threads = 64; // RC4
14932 if (hash_mode == 9810) kernel_threads = 64; // RC4
14933 if (hash_mode == 10400) kernel_threads = 64; // RC4
14934 if (hash_mode == 10410) kernel_threads = 64; // RC4
14935 if (hash_mode == 10500) kernel_threads = 64; // RC4
14936 if (hash_mode == 13100) kernel_threads = 64; // RC4
14937
14938 device_param->kernel_threads = kernel_threads;
14939
14940 device_param->hardware_power = device_processors * kernel_threads;
14941
14942 /**
14943 * create input buffers on device : calculate size of fixed memory buffers
14944 */
14945
14946 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14947 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14948
14949 device_param->size_root_css = size_root_css;
14950 device_param->size_markov_css = size_markov_css;
14951
14952 size_t size_results = sizeof (uint);
14953
14954 device_param->size_results = size_results;
14955
14956 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14957 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14958
14959 size_t size_plains = digests_cnt * sizeof (plain_t);
14960 size_t size_salts = salts_cnt * sizeof (salt_t);
14961 size_t size_esalts = salts_cnt * esalt_size;
14962
14963 device_param->size_plains = size_plains;
14964 device_param->size_digests = size_digests;
14965 device_param->size_shown = size_shown;
14966 device_param->size_salts = size_salts;
14967
14968 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14969 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14970 size_t size_tm = 32 * sizeof (bs_word_t);
14971
14972 // scryptV stuff
14973
14974 size_t size_scryptV = 1;
14975
14976 if ((hash_mode == 8900) || (hash_mode == 9300))
14977 {
14978 uint tmto_start = 0;
14979 uint tmto_stop = 10;
14980
14981 if (scrypt_tmto)
14982 {
14983 tmto_start = scrypt_tmto;
14984 }
14985 else
14986 {
14987 // in case the user did not specify the tmto manually
14988 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14989 // but set the lower end only in case the user has a device with too less memory
14990
14991 if (hash_mode == 8900)
14992 {
14993 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14994 {
14995 tmto_start = 1;
14996 }
14997 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14998 {
14999 tmto_start = 2;
15000 }
15001 }
15002 else if (hash_mode == 9300)
15003 {
15004 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15005 {
15006 tmto_start = 2;
15007 }
15008 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15009 {
15010 tmto_start = 2;
15011 }
15012 }
15013 }
15014
15015 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
15016 {
15017 // TODO: in theory the following calculation needs to be done per salt, not global
15018 // we assume all hashes have the same scrypt settings
15019
15020 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
15021
15022 size_scryptV /= 1 << tmto;
15023
15024 size_scryptV *= device_processors * device_processor_cores;
15025
15026 if (size_scryptV > device_param->device_maxmem_alloc)
15027 {
15028 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15029
15030 continue;
15031 }
15032
15033 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
15034 {
15035 data.salts_buf[salts_pos].scrypt_tmto = tmto;
15036 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
15037 }
15038
15039 break;
15040 }
15041
15042 if (data.salts_buf[0].scrypt_phy == 0)
15043 {
15044 log_error ("ERROR: can't allocate enough device memory");
15045
15046 return -1;
15047 }
15048
15049 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
15050 }
15051
15052 /**
15053 * some algorithms need a fixed kernel-loops count
15054 */
15055
15056 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15057 {
15058 const u32 kernel_loops_fixed = 1024;
15059
15060 device_param->kernel_loops_min = kernel_loops_fixed;
15061 device_param->kernel_loops_max = kernel_loops_fixed;
15062 }
15063
15064 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15065 {
15066 const u32 kernel_loops_fixed = 1024;
15067
15068 device_param->kernel_loops_min = kernel_loops_fixed;
15069 device_param->kernel_loops_max = kernel_loops_fixed;
15070 }
15071
15072 if (hash_mode == 8900)
15073 {
15074 const u32 kernel_loops_fixed = 1;
15075
15076 device_param->kernel_loops_min = kernel_loops_fixed;
15077 device_param->kernel_loops_max = kernel_loops_fixed;
15078 }
15079
15080 if (hash_mode == 9300)
15081 {
15082 const u32 kernel_loops_fixed = 1;
15083
15084 device_param->kernel_loops_min = kernel_loops_fixed;
15085 device_param->kernel_loops_max = kernel_loops_fixed;
15086 }
15087
15088 if (hash_mode == 12500)
15089 {
15090 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15091
15092 device_param->kernel_loops_min = kernel_loops_fixed;
15093 device_param->kernel_loops_max = kernel_loops_fixed;
15094 }
15095
15096 /**
15097 * some algorithms have a maximum kernel-loops count
15098 */
15099
15100 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15101 {
15102 u32 innerloop_cnt = 0;
15103
15104 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15105 {
15106 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15107 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15108 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15109 }
15110 else
15111 {
15112 innerloop_cnt = data.salts_buf[0].salt_iter;
15113 }
15114
15115 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15116 (innerloop_cnt <= device_param->kernel_loops_max))
15117 {
15118 device_param->kernel_loops_max = innerloop_cnt;
15119 }
15120 }
15121
15122 u32 kernel_accel_min = device_param->kernel_accel_min;
15123 u32 kernel_accel_max = device_param->kernel_accel_max;
15124
15125 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15126
15127 size_t size_pws = 4;
15128 size_t size_tmps = 4;
15129 size_t size_hooks = 4;
15130
15131 while (kernel_accel_max >= kernel_accel_min)
15132 {
15133 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15134
15135 // size_pws
15136
15137 size_pws = kernel_power_max * sizeof (pw_t);
15138
15139 // size_tmps
15140
15141 switch (hash_mode)
15142 {
15143 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15144 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15145 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15146 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15147 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15148 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15149 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15150 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15151 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15152 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15153 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15154 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15155 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15156 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15157 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15158 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15159 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15160 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15161 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15162 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15163 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15164 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15165 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15166 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
15167 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
15168 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
15169 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
15170 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
15171 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15172 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15173 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
15174 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
15175 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15176 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
15177 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15178 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
15179 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
15180 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15181 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15182 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
15183 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
15184 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
15185 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15186 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
15187 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
15188 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
15189 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
15190 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15191 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
15192 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
15193 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
15194 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15195 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15196 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
15197 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
15198 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
15199 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
15200 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
15201 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15202 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15203 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15204 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
15205 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
15206 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15207 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15208 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15209 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15210 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15211 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15212 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15213 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15214 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15215 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15216 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15217 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15218 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15219 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15220 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15221 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15222 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15223 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15224 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15225 };
15226
15227 // size_hooks
15228
15229 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15230 {
15231 switch (hash_mode)
15232 {
15233 }
15234 }
15235
15236 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15237 // if not, decrease amplifier and try again
15238
15239 int skip = 0;
15240
15241 const u64 size_total
15242 = bitmap_size
15243 + bitmap_size
15244 + bitmap_size
15245 + bitmap_size
15246 + bitmap_size
15247 + bitmap_size
15248 + bitmap_size
15249 + bitmap_size
15250 + size_bfs
15251 + size_combs
15252 + size_digests
15253 + size_esalts
15254 + size_hooks
15255 + size_markov_css
15256 + size_plains
15257 + size_pws
15258 + size_pws // not a bug
15259 + size_results
15260 + size_root_css
15261 + size_rules
15262 + size_rules_c
15263 + size_salts
15264 + size_scryptV
15265 + size_shown
15266 + size_tm
15267 + size_tmps;
15268
15269 // Don't ask me, ask AMD!
15270
15271 if (size_total > device_param->device_maxmem_alloc) skip = 1;
15272 if (size_total > device_param->device_global_mem) skip = 1;
15273
15274 if (skip == 1)
15275 {
15276 kernel_accel_max--;
15277
15278 continue;
15279 }
15280
15281 break;
15282 }
15283
15284 /*
15285 if (kernel_accel_max == 0)
15286 {
15287 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
15288
15289 return -1;
15290 }
15291 */
15292
15293 device_param->kernel_accel_min = kernel_accel_min;
15294 device_param->kernel_accel_max = kernel_accel_max;
15295
15296 /*
15297 if (kernel_accel_max < kernel_accel)
15298 {
15299 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
15300
15301 device_param->kernel_accel = kernel_accel_max;
15302 }
15303 */
15304
15305 device_param->size_bfs = size_bfs;
15306 device_param->size_combs = size_combs;
15307 device_param->size_rules = size_rules;
15308 device_param->size_rules_c = size_rules_c;
15309 device_param->size_pws = size_pws;
15310 device_param->size_tmps = size_tmps;
15311 device_param->size_hooks = size_hooks;
15312
15313 /**
15314 * default building options
15315 */
15316
15317 char build_opts[1024] = { 0 };
15318
15319 // we don't have sm_* on vendors not NV but it doesn't matter
15320
15321 #if _WIN
15322 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);
15323 #else
15324 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);
15325 #endif
15326
15327 char build_opts_new[1024] = { 0 };
15328
15329 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);
15330
15331 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
15332
15333 /*
15334 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
15335 {
15336 // we do vectorizing much better than the auto-vectorizer
15337
15338 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
15339
15340 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
15341 }
15342 */
15343
15344 #ifdef DEBUG
15345 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15346 #endif
15347
15348 /**
15349 * main kernel
15350 */
15351
15352 {
15353 /**
15354 * kernel source filename
15355 */
15356
15357 char source_file[256] = { 0 };
15358
15359 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15360
15361 struct stat sst;
15362
15363 if (stat (source_file, &sst) == -1)
15364 {
15365 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15366
15367 return -1;
15368 }
15369
15370 /**
15371 * kernel cached filename
15372 */
15373
15374 char cached_file[256] = { 0 };
15375
15376 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15377
15378 int cached = 1;
15379
15380 struct stat cst;
15381
15382 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15383 {
15384 cached = 0;
15385 }
15386
15387 /**
15388 * kernel compile or load
15389 */
15390
15391 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15392
15393 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15394
15395 if (force_jit_compilation == -1)
15396 {
15397 if (cached == 0)
15398 {
15399 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15400
15401 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15402
15403 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15404
15405 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15406
15407 #ifdef DEBUG
15408 size_t build_log_size = 0;
15409
15410 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15411
15412 if (build_log_size > 1)
15413 {
15414 char *build_log = (char *) malloc (build_log_size + 1);
15415
15416 memset (build_log, 0, build_log_size + 1);
15417
15418 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15419
15420 puts (build_log);
15421
15422 free (build_log);
15423 }
15424 #endif
15425
15426 if (rc != 0)
15427 {
15428 device_param->skipped = true;
15429
15430 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15431
15432 continue;
15433 }
15434
15435 size_t binary_size;
15436
15437 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15438
15439 u8 *binary = (u8 *) mymalloc (binary_size);
15440
15441 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15442
15443 writeProgramBin (cached_file, binary, binary_size);
15444
15445 local_free (binary);
15446 }
15447 else
15448 {
15449 #ifdef DEBUG
15450 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15451 #endif
15452
15453 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15454
15455 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15456
15457 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15458 }
15459 }
15460 else
15461 {
15462 #ifdef DEBUG
15463 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15464 #endif
15465
15466 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15467
15468 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15469
15470 char build_opts_update[1024] = { 0 };
15471
15472 if (force_jit_compilation == 1500)
15473 {
15474 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15475 }
15476 else if (force_jit_compilation == 8900)
15477 {
15478 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);
15479 }
15480 else
15481 {
15482 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15483 }
15484
15485 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15486
15487 #ifdef DEBUG
15488 size_t build_log_size = 0;
15489
15490 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15491
15492 if (build_log_size > 1)
15493 {
15494 char *build_log = (char *) malloc (build_log_size + 1);
15495
15496 memset (build_log, 0, build_log_size + 1);
15497
15498 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15499
15500 puts (build_log);
15501
15502 free (build_log);
15503 }
15504 #endif
15505
15506 if (rc != 0)
15507 {
15508 device_param->skipped = true;
15509
15510 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15511 }
15512 }
15513
15514 local_free (kernel_lengths);
15515 local_free (kernel_sources[0]);
15516 local_free (kernel_sources);
15517 }
15518
15519 /**
15520 * word generator kernel
15521 */
15522
15523 if (attack_mode != ATTACK_MODE_STRAIGHT)
15524 {
15525 /**
15526 * kernel mp source filename
15527 */
15528
15529 char source_file[256] = { 0 };
15530
15531 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15532
15533 struct stat sst;
15534
15535 if (stat (source_file, &sst) == -1)
15536 {
15537 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15538
15539 return -1;
15540 }
15541
15542 /**
15543 * kernel mp cached filename
15544 */
15545
15546 char cached_file[256] = { 0 };
15547
15548 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15549
15550 int cached = 1;
15551
15552 struct stat cst;
15553
15554 if (stat (cached_file, &cst) == -1)
15555 {
15556 cached = 0;
15557 }
15558
15559 /**
15560 * kernel compile or load
15561 */
15562
15563 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15564
15565 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15566
15567 if (cached == 0)
15568 {
15569 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15570 if (quiet == 0) log_info ("");
15571
15572 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15573
15574 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15575
15576 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15577
15578 if (rc != 0)
15579 {
15580 device_param->skipped = true;
15581
15582 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15583
15584 continue;
15585 }
15586
15587 size_t binary_size;
15588
15589 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15590
15591 u8 *binary = (u8 *) mymalloc (binary_size);
15592
15593 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15594
15595 writeProgramBin (cached_file, binary, binary_size);
15596
15597 local_free (binary);
15598 }
15599 else
15600 {
15601 #ifdef DEBUG
15602 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15603 #endif
15604
15605 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15606
15607 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15608
15609 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15610 }
15611
15612 local_free (kernel_lengths);
15613 local_free (kernel_sources[0]);
15614 local_free (kernel_sources);
15615 }
15616
15617 /**
15618 * amplifier kernel
15619 */
15620
15621 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15622 {
15623
15624 }
15625 else
15626 {
15627 /**
15628 * kernel amp source filename
15629 */
15630
15631 char source_file[256] = { 0 };
15632
15633 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15634
15635 struct stat sst;
15636
15637 if (stat (source_file, &sst) == -1)
15638 {
15639 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15640
15641 return -1;
15642 }
15643
15644 /**
15645 * kernel amp cached filename
15646 */
15647
15648 char cached_file[256] = { 0 };
15649
15650 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15651
15652 int cached = 1;
15653
15654 struct stat cst;
15655
15656 if (stat (cached_file, &cst) == -1)
15657 {
15658 cached = 0;
15659 }
15660
15661 /**
15662 * kernel compile or load
15663 */
15664
15665 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15666
15667 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15668
15669 if (cached == 0)
15670 {
15671 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15672 if (quiet == 0) log_info ("");
15673
15674 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15675
15676 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15677
15678 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15679
15680 if (rc != 0)
15681 {
15682 device_param->skipped = true;
15683
15684 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15685
15686 continue;
15687 }
15688
15689 size_t binary_size;
15690
15691 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15692
15693 u8 *binary = (u8 *) mymalloc (binary_size);
15694
15695 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15696
15697 writeProgramBin (cached_file, binary, binary_size);
15698
15699 local_free (binary);
15700 }
15701 else
15702 {
15703 #ifdef DEBUG
15704 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15705 #endif
15706
15707 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15708
15709 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15710
15711 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15712 }
15713
15714 local_free (kernel_lengths);
15715 local_free (kernel_sources[0]);
15716 local_free (kernel_sources);
15717 }
15718
15719 // some algorithm collide too fast, make that impossible
15720
15721 if (benchmark == 1)
15722 {
15723 ((uint *) digests_buf)[0] = -1;
15724 ((uint *) digests_buf)[1] = -1;
15725 ((uint *) digests_buf)[2] = -1;
15726 ((uint *) digests_buf)[3] = -1;
15727 }
15728
15729 /**
15730 * global buffers
15731 */
15732
15733 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15734 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15735 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15736 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15737 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15738 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15739 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15740 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15741 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15742 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15743 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15744 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15745 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15746 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15747 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15748 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15749 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15750 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15751
15752 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);
15753 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);
15754 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);
15755 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);
15756 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);
15757 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);
15758 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);
15759 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);
15760 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15761 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15762 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15763
15764 /**
15765 * special buffers
15766 */
15767
15768 if (attack_kern == ATTACK_KERN_STRAIGHT)
15769 {
15770 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15771 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15772
15773 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15774 }
15775 else if (attack_kern == ATTACK_KERN_COMBI)
15776 {
15777 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15778 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15779 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15780 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15781 }
15782 else if (attack_kern == ATTACK_KERN_BF)
15783 {
15784 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15785 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15786 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15787 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15788 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15789 }
15790
15791 if (size_esalts)
15792 {
15793 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15794
15795 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15796 }
15797
15798 /**
15799 * main host data
15800 */
15801
15802 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15803
15804 device_param->pws_buf = pws_buf;
15805
15806 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15807
15808 device_param->combs_buf = combs_buf;
15809
15810 void *hooks_buf = mymalloc (size_hooks);
15811
15812 device_param->hooks_buf = hooks_buf;
15813
15814 /**
15815 * kernel args
15816 */
15817
15818 device_param->kernel_params_buf32[21] = bitmap_mask;
15819 device_param->kernel_params_buf32[22] = bitmap_shift1;
15820 device_param->kernel_params_buf32[23] = bitmap_shift2;
15821 device_param->kernel_params_buf32[24] = 0; // salt_pos
15822 device_param->kernel_params_buf32[25] = 0; // loop_pos
15823 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15824 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15825 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15826 device_param->kernel_params_buf32[29] = 0; // digests_offset
15827 device_param->kernel_params_buf32[30] = 0; // combs_mode
15828 device_param->kernel_params_buf32[31] = 0; // gid_max
15829
15830 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15831 ? &device_param->d_pws_buf
15832 : &device_param->d_pws_amp_buf;
15833 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15834 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15835 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15836 device_param->kernel_params[ 4] = &device_param->d_tmps;
15837 device_param->kernel_params[ 5] = &device_param->d_hooks;
15838 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15839 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15840 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15841 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15842 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15843 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15844 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15845 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15846 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15847 device_param->kernel_params[15] = &device_param->d_digests_buf;
15848 device_param->kernel_params[16] = &device_param->d_digests_shown;
15849 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15850 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15851 device_param->kernel_params[19] = &device_param->d_result;
15852 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15853 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15854 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15855 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15856 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15857 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15858 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15859 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15860 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15861 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15862 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15863 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15864
15865 device_param->kernel_params_mp_buf64[3] = 0;
15866 device_param->kernel_params_mp_buf32[4] = 0;
15867 device_param->kernel_params_mp_buf32[5] = 0;
15868 device_param->kernel_params_mp_buf32[6] = 0;
15869 device_param->kernel_params_mp_buf32[7] = 0;
15870 device_param->kernel_params_mp_buf32[8] = 0;
15871
15872 device_param->kernel_params_mp[0] = NULL;
15873 device_param->kernel_params_mp[1] = NULL;
15874 device_param->kernel_params_mp[2] = NULL;
15875 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15876 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15877 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15878 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15879 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15880 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15881
15882 device_param->kernel_params_mp_l_buf64[3] = 0;
15883 device_param->kernel_params_mp_l_buf32[4] = 0;
15884 device_param->kernel_params_mp_l_buf32[5] = 0;
15885 device_param->kernel_params_mp_l_buf32[6] = 0;
15886 device_param->kernel_params_mp_l_buf32[7] = 0;
15887 device_param->kernel_params_mp_l_buf32[8] = 0;
15888 device_param->kernel_params_mp_l_buf32[9] = 0;
15889
15890 device_param->kernel_params_mp_l[0] = NULL;
15891 device_param->kernel_params_mp_l[1] = NULL;
15892 device_param->kernel_params_mp_l[2] = NULL;
15893 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15894 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15895 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15896 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15897 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15898 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15899 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15900
15901 device_param->kernel_params_mp_r_buf64[3] = 0;
15902 device_param->kernel_params_mp_r_buf32[4] = 0;
15903 device_param->kernel_params_mp_r_buf32[5] = 0;
15904 device_param->kernel_params_mp_r_buf32[6] = 0;
15905 device_param->kernel_params_mp_r_buf32[7] = 0;
15906 device_param->kernel_params_mp_r_buf32[8] = 0;
15907
15908 device_param->kernel_params_mp_r[0] = NULL;
15909 device_param->kernel_params_mp_r[1] = NULL;
15910 device_param->kernel_params_mp_r[2] = NULL;
15911 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15912 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15913 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15914 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15915 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15916 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15917
15918 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15919 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15920
15921 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15922 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15923 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15924 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15925 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15926 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15927 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15928
15929 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15930 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15931
15932 device_param->kernel_params_memset_buf32[1] = 0; // value
15933 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15934
15935 device_param->kernel_params_memset[0] = NULL;
15936 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15937 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15938
15939 /**
15940 * kernel name
15941 */
15942
15943 size_t kernel_wgs_tmp;
15944
15945 char kernel_name[64] = { 0 };
15946
15947 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15948 {
15949 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15950 {
15951 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15952
15953 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15954
15955 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15956
15957 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15958
15959 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15960
15961 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15962 }
15963 else
15964 {
15965 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15966
15967 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15968
15969 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15970
15971 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15972
15973 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15974
15975 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15976 }
15977
15978 if (data.attack_mode == ATTACK_MODE_BF)
15979 {
15980 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15981 {
15982 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15983
15984 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15985
15986 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);
15987 }
15988 }
15989 }
15990 else
15991 {
15992 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15993
15994 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15995
15996 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15997
15998 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15999
16000 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
16001
16002 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16003
16004 if (opts_type & OPTS_TYPE_HOOK12)
16005 {
16006 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
16007
16008 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16009
16010 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);
16011 }
16012
16013 if (opts_type & OPTS_TYPE_HOOK23)
16014 {
16015 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
16016
16017 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16018
16019 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);
16020 }
16021 }
16022
16023 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);
16024 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);
16025 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);
16026
16027 for (uint i = 0; i <= 20; i++)
16028 {
16029 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
16030 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
16031 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
16032
16033 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
16034 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
16035 }
16036
16037 for (uint i = 21; i <= 31; i++)
16038 {
16039 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
16040 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
16041 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
16042
16043 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
16044 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
16045 }
16046
16047 // GPU memset
16048
16049 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
16050
16051 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);
16052
16053 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
16054 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
16055 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
16056
16057 // MP start
16058
16059 if (attack_mode == ATTACK_MODE_BF)
16060 {
16061 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
16062 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
16063
16064 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);
16065 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);
16066
16067 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16068 {
16069 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
16070 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
16071 }
16072 }
16073 else if (attack_mode == ATTACK_MODE_HYBRID1)
16074 {
16075 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16076
16077 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);
16078 }
16079 else if (attack_mode == ATTACK_MODE_HYBRID2)
16080 {
16081 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16082
16083 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);
16084 }
16085
16086 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16087 {
16088 // nothing to do
16089 }
16090 else
16091 {
16092 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
16093
16094 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);
16095 }
16096
16097 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16098 {
16099 // nothing to do
16100 }
16101 else
16102 {
16103 for (uint i = 0; i < 5; i++)
16104 {
16105 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
16106 }
16107
16108 for (uint i = 5; i < 7; i++)
16109 {
16110 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
16111 }
16112 }
16113
16114 // maybe this has been updated by clGetKernelWorkGroupInfo()
16115 // value can only be decreased, so we don't need to reallocate buffers
16116
16117 device_param->kernel_threads = kernel_threads;
16118
16119 // zero some data buffers
16120
16121 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
16122 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
16123 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
16124 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
16125 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
16126 run_kernel_bzero (device_param, device_param->d_result, size_results);
16127
16128 /**
16129 * special buffers
16130 */
16131
16132 if (attack_kern == ATTACK_KERN_STRAIGHT)
16133 {
16134 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
16135 }
16136 else if (attack_kern == ATTACK_KERN_COMBI)
16137 {
16138 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
16139 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
16140 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16141 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16142 }
16143 else if (attack_kern == ATTACK_KERN_BF)
16144 {
16145 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
16146 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
16147 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
16148 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16149 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16150 }
16151
16152 #if defined(HAVE_HWMON)
16153
16154 /**
16155 * Store initial fanspeed if gpu_temp_retain is enabled
16156 */
16157
16158 if (gpu_temp_disable == 0)
16159 {
16160 if (gpu_temp_retain != 0)
16161 {
16162 hc_thread_mutex_lock (mux_adl);
16163
16164 if (data.hm_device[device_id].fan_get_supported == 1)
16165 {
16166 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
16167 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
16168
16169 temp_retain_fanspeed_value[device_id] = fanspeed;
16170 temp_retain_fanpolicy_value[device_id] = fanpolicy;
16171
16172 // we also set it to tell the OS we take control over the fan and it's automatic controller
16173 // if it was set to automatic. we do not control user-defined fanspeeds.
16174
16175 if (fanpolicy == 1)
16176 {
16177 data.hm_device[device_id].fan_set_supported = 1;
16178
16179 int rc = -1;
16180
16181 if (device_param->device_vendor_id == VENDOR_ID_AMD)
16182 {
16183 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
16184 }
16185 else if (device_param->device_vendor_id == VENDOR_ID_NV)
16186 {
16187 #ifdef _WIN
16188 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
16189 #endif
16190
16191 #ifdef _LINUX
16192 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE);
16193 #endif
16194 }
16195
16196 if (rc == 0)
16197 {
16198 data.hm_device[device_id].fan_set_supported = 1;
16199 }
16200 else
16201 {
16202 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
16203
16204 data.hm_device[device_id].fan_set_supported = 0;
16205 }
16206 }
16207 else
16208 {
16209 data.hm_device[device_id].fan_set_supported = 0;
16210 }
16211 }
16212
16213 hc_thread_mutex_unlock (mux_adl);
16214 }
16215 }
16216
16217 #endif // HAVE_HWMON
16218 }
16219
16220 if (data.quiet == 0) log_info_nn ("");
16221
16222 /**
16223 * In benchmark-mode, inform user which algorithm is checked
16224 */
16225
16226 if (benchmark == 1)
16227 {
16228 if (machine_readable == 0)
16229 {
16230 quiet = 0;
16231
16232 data.quiet = quiet;
16233
16234 char *hash_type = strhashtype (data.hash_mode); // not a bug
16235
16236 log_info ("Hashtype: %s", hash_type);
16237 log_info ("");
16238 }
16239 }
16240
16241 /**
16242 * keep track of the progress
16243 */
16244
16245 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16246 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16247 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16248
16249 /**
16250 * open filehandles
16251 */
16252
16253 #if _WIN
16254 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
16255 {
16256 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
16257
16258 return (-1);
16259 }
16260
16261 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
16262 {
16263 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
16264
16265 return (-1);
16266 }
16267
16268 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
16269 {
16270 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
16271
16272 return (-1);
16273 }
16274 #endif
16275
16276 /**
16277 * dictionary pad
16278 */
16279
16280 segment_size *= (1024 * 1024);
16281
16282 data.segment_size = segment_size;
16283
16284 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
16285
16286 wl_data->buf = (char *) mymalloc (segment_size);
16287 wl_data->avail = segment_size;
16288 wl_data->incr = segment_size;
16289 wl_data->cnt = 0;
16290 wl_data->pos = 0;
16291
16292 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
16293
16294 data.wordlist_mode = wordlist_mode;
16295
16296 cs_t *css_buf = NULL;
16297 uint css_cnt = 0;
16298 uint dictcnt = 0;
16299 uint maskcnt = 1;
16300 char **masks = NULL;
16301 char **dictfiles = NULL;
16302
16303 uint mask_from_file = 0;
16304
16305 if (attack_mode == ATTACK_MODE_STRAIGHT)
16306 {
16307 if (wordlist_mode == WL_MODE_FILE)
16308 {
16309 int wls_left = myargc - (optind + 1);
16310
16311 for (int i = 0; i < wls_left; i++)
16312 {
16313 char *l0_filename = myargv[optind + 1 + i];
16314
16315 struct stat l0_stat;
16316
16317 if (stat (l0_filename, &l0_stat) == -1)
16318 {
16319 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
16320
16321 return (-1);
16322 }
16323
16324 uint is_dir = S_ISDIR (l0_stat.st_mode);
16325
16326 if (is_dir == 0)
16327 {
16328 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16329
16330 dictcnt++;
16331
16332 dictfiles[dictcnt - 1] = l0_filename;
16333 }
16334 else
16335 {
16336 // do not allow --keyspace w/ a directory
16337
16338 if (keyspace == 1)
16339 {
16340 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16341
16342 return (-1);
16343 }
16344
16345 char **dictionary_files = NULL;
16346
16347 dictionary_files = scan_directory (l0_filename);
16348
16349 if (dictionary_files != NULL)
16350 {
16351 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16352
16353 for (int d = 0; dictionary_files[d] != NULL; d++)
16354 {
16355 char *l1_filename = dictionary_files[d];
16356
16357 struct stat l1_stat;
16358
16359 if (stat (l1_filename, &l1_stat) == -1)
16360 {
16361 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16362
16363 return (-1);
16364 }
16365
16366 if (S_ISREG (l1_stat.st_mode))
16367 {
16368 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16369
16370 dictcnt++;
16371
16372 dictfiles[dictcnt - 1] = strdup (l1_filename);
16373 }
16374 }
16375 }
16376
16377 local_free (dictionary_files);
16378 }
16379 }
16380
16381 if (dictcnt < 1)
16382 {
16383 log_error ("ERROR: No usable dictionary file found.");
16384
16385 return (-1);
16386 }
16387 }
16388 else if (wordlist_mode == WL_MODE_STDIN)
16389 {
16390 dictcnt = 1;
16391 }
16392 }
16393 else if (attack_mode == ATTACK_MODE_COMBI)
16394 {
16395 // display
16396
16397 char *dictfile1 = myargv[optind + 1 + 0];
16398 char *dictfile2 = myargv[optind + 1 + 1];
16399
16400 // find the bigger dictionary and use as base
16401
16402 FILE *fp1 = NULL;
16403 FILE *fp2 = NULL;
16404
16405 struct stat tmp_stat;
16406
16407 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16408 {
16409 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16410
16411 return (-1);
16412 }
16413
16414 if (stat (dictfile1, &tmp_stat) == -1)
16415 {
16416 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16417
16418 fclose (fp1);
16419
16420 return (-1);
16421 }
16422
16423 if (S_ISDIR (tmp_stat.st_mode))
16424 {
16425 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16426
16427 fclose (fp1);
16428
16429 return (-1);
16430 }
16431
16432 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16433 {
16434 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16435
16436 fclose (fp1);
16437
16438 return (-1);
16439 }
16440
16441 if (stat (dictfile2, &tmp_stat) == -1)
16442 {
16443 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16444
16445 fclose (fp1);
16446 fclose (fp2);
16447
16448 return (-1);
16449 }
16450
16451 if (S_ISDIR (tmp_stat.st_mode))
16452 {
16453 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16454
16455 fclose (fp1);
16456 fclose (fp2);
16457
16458 return (-1);
16459 }
16460
16461 data.combs_cnt = 1;
16462
16463 data.quiet = 1;
16464
16465 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16466
16467 data.quiet = quiet;
16468
16469 if (words1_cnt == 0)
16470 {
16471 log_error ("ERROR: %s: empty file", dictfile1);
16472
16473 fclose (fp1);
16474 fclose (fp2);
16475
16476 return (-1);
16477 }
16478
16479 data.combs_cnt = 1;
16480
16481 data.quiet = 1;
16482
16483 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16484
16485 data.quiet = quiet;
16486
16487 if (words2_cnt == 0)
16488 {
16489 log_error ("ERROR: %s: empty file", dictfile2);
16490
16491 fclose (fp1);
16492 fclose (fp2);
16493
16494 return (-1);
16495 }
16496
16497 fclose (fp1);
16498 fclose (fp2);
16499
16500 data.dictfile = dictfile1;
16501 data.dictfile2 = dictfile2;
16502
16503 if (words1_cnt >= words2_cnt)
16504 {
16505 data.combs_cnt = words2_cnt;
16506 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16507
16508 dictfiles = &data.dictfile;
16509
16510 dictcnt = 1;
16511 }
16512 else
16513 {
16514 data.combs_cnt = words1_cnt;
16515 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16516
16517 dictfiles = &data.dictfile2;
16518
16519 dictcnt = 1;
16520
16521 // we also have to switch wordlist related rules!
16522
16523 char *tmpc = data.rule_buf_l;
16524
16525 data.rule_buf_l = data.rule_buf_r;
16526 data.rule_buf_r = tmpc;
16527
16528 int tmpi = data.rule_len_l;
16529
16530 data.rule_len_l = data.rule_len_r;
16531 data.rule_len_r = tmpi;
16532 }
16533 }
16534 else if (attack_mode == ATTACK_MODE_BF)
16535 {
16536 char *mask = NULL;
16537
16538 maskcnt = 0;
16539
16540 if (benchmark == 0)
16541 {
16542 mask = myargv[optind + 1];
16543
16544 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16545
16546 if ((optind + 2) <= myargc)
16547 {
16548 struct stat file_stat;
16549
16550 if (stat (mask, &file_stat) == -1)
16551 {
16552 maskcnt = 1;
16553
16554 masks[maskcnt - 1] = mystrdup (mask);
16555 }
16556 else
16557 {
16558 int wls_left = myargc - (optind + 1);
16559
16560 uint masks_avail = INCR_MASKS;
16561
16562 for (int i = 0; i < wls_left; i++)
16563 {
16564 if (i != 0)
16565 {
16566 mask = myargv[optind + 1 + i];
16567
16568 if (stat (mask, &file_stat) == -1)
16569 {
16570 log_error ("ERROR: %s: %s", mask, strerror (errno));
16571
16572 return (-1);
16573 }
16574 }
16575
16576 uint is_file = S_ISREG (file_stat.st_mode);
16577
16578 if (is_file == 1)
16579 {
16580 FILE *mask_fp;
16581
16582 if ((mask_fp = fopen (mask, "r")) == NULL)
16583 {
16584 log_error ("ERROR: %s: %s", mask, strerror (errno));
16585
16586 return (-1);
16587 }
16588
16589 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16590
16591 while (!feof (mask_fp))
16592 {
16593 memset (line_buf, 0, HCBUFSIZ);
16594
16595 int line_len = fgetl (mask_fp, line_buf);
16596
16597 if (line_len == 0) continue;
16598
16599 if (line_buf[0] == '#') continue;
16600
16601 if (masks_avail == maskcnt)
16602 {
16603 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16604
16605 masks_avail += INCR_MASKS;
16606 }
16607
16608 masks[maskcnt] = mystrdup (line_buf);
16609
16610 maskcnt++;
16611 }
16612
16613 myfree (line_buf);
16614
16615 fclose (mask_fp);
16616 }
16617 else
16618 {
16619 log_error ("ERROR: %s: unsupported file-type", mask);
16620
16621 return (-1);
16622 }
16623 }
16624
16625 mask_from_file = 1;
16626 }
16627 }
16628 else
16629 {
16630 custom_charset_1 = (char *) "?l?d?u";
16631 custom_charset_2 = (char *) "?l?d";
16632 custom_charset_3 = (char *) "?l?d*!$@_";
16633
16634 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16635 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16636 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16637
16638 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16639
16640 wordlist_mode = WL_MODE_MASK;
16641
16642 data.wordlist_mode = wordlist_mode;
16643
16644 increment = 1;
16645
16646 maskcnt = 1;
16647 }
16648 }
16649 else
16650 {
16651 /**
16652 * generate full masks and charsets
16653 */
16654
16655 masks = (char **) mymalloc (sizeof (char *));
16656
16657 switch (hash_mode)
16658 {
16659 case 1731: pw_min = 5;
16660 pw_max = 5;
16661 mask = mystrdup ("?b?b?b?b?b");
16662 break;
16663 case 12500: pw_min = 5;
16664 pw_max = 5;
16665 mask = mystrdup ("?b?b?b?b?b");
16666 break;
16667 default: pw_min = 7;
16668 pw_max = 7;
16669 mask = mystrdup ("?b?b?b?b?b?b?b");
16670 break;
16671 }
16672
16673 maskcnt = 1;
16674
16675 masks[maskcnt - 1] = mystrdup (mask);
16676
16677 wordlist_mode = WL_MODE_MASK;
16678
16679 data.wordlist_mode = wordlist_mode;
16680
16681 increment = 1;
16682 }
16683
16684 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16685
16686 if (increment)
16687 {
16688 if (increment_min > pw_min) pw_min = increment_min;
16689
16690 if (increment_max < pw_max) pw_max = increment_max;
16691 }
16692 }
16693 else if (attack_mode == ATTACK_MODE_HYBRID1)
16694 {
16695 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16696
16697 // display
16698
16699 char *mask = myargv[myargc - 1];
16700
16701 maskcnt = 0;
16702
16703 masks = (char **) mymalloc (1 * sizeof (char *));
16704
16705 // mod
16706
16707 struct stat file_stat;
16708
16709 if (stat (mask, &file_stat) == -1)
16710 {
16711 maskcnt = 1;
16712
16713 masks[maskcnt - 1] = mystrdup (mask);
16714 }
16715 else
16716 {
16717 uint is_file = S_ISREG (file_stat.st_mode);
16718
16719 if (is_file == 1)
16720 {
16721 FILE *mask_fp;
16722
16723 if ((mask_fp = fopen (mask, "r")) == NULL)
16724 {
16725 log_error ("ERROR: %s: %s", mask, strerror (errno));
16726
16727 return (-1);
16728 }
16729
16730 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16731
16732 uint masks_avail = 1;
16733
16734 while (!feof (mask_fp))
16735 {
16736 memset (line_buf, 0, HCBUFSIZ);
16737
16738 int line_len = fgetl (mask_fp, line_buf);
16739
16740 if (line_len == 0) continue;
16741
16742 if (line_buf[0] == '#') continue;
16743
16744 if (masks_avail == maskcnt)
16745 {
16746 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16747
16748 masks_avail += INCR_MASKS;
16749 }
16750
16751 masks[maskcnt] = mystrdup (line_buf);
16752
16753 maskcnt++;
16754 }
16755
16756 myfree (line_buf);
16757
16758 fclose (mask_fp);
16759
16760 mask_from_file = 1;
16761 }
16762 else
16763 {
16764 maskcnt = 1;
16765
16766 masks[maskcnt - 1] = mystrdup (mask);
16767 }
16768 }
16769
16770 // base
16771
16772 int wls_left = myargc - (optind + 2);
16773
16774 for (int i = 0; i < wls_left; i++)
16775 {
16776 char *filename = myargv[optind + 1 + i];
16777
16778 struct stat file_stat;
16779
16780 if (stat (filename, &file_stat) == -1)
16781 {
16782 log_error ("ERROR: %s: %s", filename, strerror (errno));
16783
16784 return (-1);
16785 }
16786
16787 uint is_dir = S_ISDIR (file_stat.st_mode);
16788
16789 if (is_dir == 0)
16790 {
16791 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16792
16793 dictcnt++;
16794
16795 dictfiles[dictcnt - 1] = filename;
16796 }
16797 else
16798 {
16799 // do not allow --keyspace w/ a directory
16800
16801 if (keyspace == 1)
16802 {
16803 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16804
16805 return (-1);
16806 }
16807
16808 char **dictionary_files = NULL;
16809
16810 dictionary_files = scan_directory (filename);
16811
16812 if (dictionary_files != NULL)
16813 {
16814 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16815
16816 for (int d = 0; dictionary_files[d] != NULL; d++)
16817 {
16818 char *l1_filename = dictionary_files[d];
16819
16820 struct stat l1_stat;
16821
16822 if (stat (l1_filename, &l1_stat) == -1)
16823 {
16824 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16825
16826 return (-1);
16827 }
16828
16829 if (S_ISREG (l1_stat.st_mode))
16830 {
16831 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16832
16833 dictcnt++;
16834
16835 dictfiles[dictcnt - 1] = strdup (l1_filename);
16836 }
16837 }
16838 }
16839
16840 local_free (dictionary_files);
16841 }
16842 }
16843
16844 if (dictcnt < 1)
16845 {
16846 log_error ("ERROR: No usable dictionary file found.");
16847
16848 return (-1);
16849 }
16850
16851 if (increment)
16852 {
16853 maskcnt = 0;
16854
16855 uint mask_min = increment_min; // we can't reject smaller masks here
16856 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16857
16858 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16859 {
16860 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16861
16862 if (cur_mask == NULL) break;
16863
16864 masks[maskcnt] = cur_mask;
16865
16866 maskcnt++;
16867
16868 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16869 }
16870 }
16871 }
16872 else if (attack_mode == ATTACK_MODE_HYBRID2)
16873 {
16874 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16875
16876 // display
16877
16878 char *mask = myargv[optind + 1 + 0];
16879
16880 maskcnt = 0;
16881
16882 masks = (char **) mymalloc (1 * sizeof (char *));
16883
16884 // mod
16885
16886 struct stat file_stat;
16887
16888 if (stat (mask, &file_stat) == -1)
16889 {
16890 maskcnt = 1;
16891
16892 masks[maskcnt - 1] = mystrdup (mask);
16893 }
16894 else
16895 {
16896 uint is_file = S_ISREG (file_stat.st_mode);
16897
16898 if (is_file == 1)
16899 {
16900 FILE *mask_fp;
16901
16902 if ((mask_fp = fopen (mask, "r")) == NULL)
16903 {
16904 log_error ("ERROR: %s: %s", mask, strerror (errno));
16905
16906 return (-1);
16907 }
16908
16909 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16910
16911 uint masks_avail = 1;
16912
16913 while (!feof (mask_fp))
16914 {
16915 memset (line_buf, 0, HCBUFSIZ);
16916
16917 int line_len = fgetl (mask_fp, line_buf);
16918
16919 if (line_len == 0) continue;
16920
16921 if (line_buf[0] == '#') continue;
16922
16923 if (masks_avail == maskcnt)
16924 {
16925 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16926
16927 masks_avail += INCR_MASKS;
16928 }
16929
16930 masks[maskcnt] = mystrdup (line_buf);
16931
16932 maskcnt++;
16933 }
16934
16935 myfree (line_buf);
16936
16937 fclose (mask_fp);
16938
16939 mask_from_file = 1;
16940 }
16941 else
16942 {
16943 maskcnt = 1;
16944
16945 masks[maskcnt - 1] = mystrdup (mask);
16946 }
16947 }
16948
16949 // base
16950
16951 int wls_left = myargc - (optind + 2);
16952
16953 for (int i = 0; i < wls_left; i++)
16954 {
16955 char *filename = myargv[optind + 2 + i];
16956
16957 struct stat file_stat;
16958
16959 if (stat (filename, &file_stat) == -1)
16960 {
16961 log_error ("ERROR: %s: %s", filename, strerror (errno));
16962
16963 return (-1);
16964 }
16965
16966 uint is_dir = S_ISDIR (file_stat.st_mode);
16967
16968 if (is_dir == 0)
16969 {
16970 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16971
16972 dictcnt++;
16973
16974 dictfiles[dictcnt - 1] = filename;
16975 }
16976 else
16977 {
16978 // do not allow --keyspace w/ a directory
16979
16980 if (keyspace == 1)
16981 {
16982 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16983
16984 return (-1);
16985 }
16986
16987 char **dictionary_files = NULL;
16988
16989 dictionary_files = scan_directory (filename);
16990
16991 if (dictionary_files != NULL)
16992 {
16993 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16994
16995 for (int d = 0; dictionary_files[d] != NULL; d++)
16996 {
16997 char *l1_filename = dictionary_files[d];
16998
16999 struct stat l1_stat;
17000
17001 if (stat (l1_filename, &l1_stat) == -1)
17002 {
17003 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17004
17005 return (-1);
17006 }
17007
17008 if (S_ISREG (l1_stat.st_mode))
17009 {
17010 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17011
17012 dictcnt++;
17013
17014 dictfiles[dictcnt - 1] = strdup (l1_filename);
17015 }
17016 }
17017 }
17018
17019 local_free (dictionary_files);
17020 }
17021 }
17022
17023 if (dictcnt < 1)
17024 {
17025 log_error ("ERROR: No usable dictionary file found.");
17026
17027 return (-1);
17028 }
17029
17030 if (increment)
17031 {
17032 maskcnt = 0;
17033
17034 uint mask_min = increment_min; // we can't reject smaller masks here
17035 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17036
17037 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17038 {
17039 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17040
17041 if (cur_mask == NULL) break;
17042
17043 masks[maskcnt] = cur_mask;
17044
17045 maskcnt++;
17046
17047 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17048 }
17049 }
17050 }
17051
17052 data.pw_min = pw_min;
17053 data.pw_max = pw_max;
17054
17055 /**
17056 * weak hash check
17057 */
17058
17059 if (weak_hash_threshold >= salts_cnt)
17060 {
17061 hc_device_param_t *device_param = NULL;
17062
17063 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17064 {
17065 device_param = &data.devices_param[device_id];
17066
17067 if (device_param->skipped) continue;
17068
17069 break;
17070 }
17071
17072 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
17073
17074 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
17075 {
17076 weak_hash_check (device_param, salt_pos);
17077 }
17078
17079 // Display hack, guarantee that there is at least one \r before real start
17080
17081 //if (data.quiet == 0) log_info ("");
17082 }
17083
17084 /**
17085 * status and monitor threads
17086 */
17087
17088 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
17089
17090 uint i_threads_cnt = 0;
17091
17092 hc_thread_t *i_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17093
17094 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17095 {
17096 if (stdout_flag == 0)
17097 {
17098 hc_thread_create (i_threads[i_threads_cnt], thread_keypress, &benchmark);
17099
17100 i_threads_cnt++;
17101 }
17102 }
17103
17104 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
17105
17106 uint ni_threads_cnt = 0;
17107
17108 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17109
17110 if (stdout_flag == 0)
17111 {
17112 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
17113
17114 ni_threads_cnt++;
17115 }
17116
17117 /**
17118 * Outfile remove
17119 */
17120
17121 if (keyspace == 0)
17122 {
17123 if (outfile_check_timer != 0)
17124 {
17125 if (data.outfile_check_directory != NULL)
17126 {
17127 if ((hash_mode != 5200) &&
17128 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
17129 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
17130 (hash_mode != 9000))
17131 {
17132 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
17133
17134 ni_threads_cnt++;
17135 }
17136 else
17137 {
17138 outfile_check_timer = 0;
17139 }
17140 }
17141 else
17142 {
17143 outfile_check_timer = 0;
17144 }
17145 }
17146 }
17147
17148 /**
17149 * Inform the user if we got some hashes remove because of the pot file remove feature
17150 */
17151
17152 if (data.quiet == 0)
17153 {
17154 if (potfile_remove_cracks > 0)
17155 {
17156 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
17157 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
17158 }
17159 }
17160
17161 data.outfile_check_timer = outfile_check_timer;
17162
17163 /**
17164 * main loop
17165 */
17166
17167 char **induction_dictionaries = NULL;
17168
17169 int induction_dictionaries_cnt = 0;
17170
17171 hcstat_table_t *root_table_buf = NULL;
17172 hcstat_table_t *markov_table_buf = NULL;
17173
17174 uint initial_restore_done = 0;
17175
17176 data.maskcnt = maskcnt;
17177
17178 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
17179 {
17180 if (data.devices_status == STATUS_CRACKED) break;
17181
17182 data.devices_status = STATUS_INIT;
17183
17184 if (maskpos > rd->maskpos)
17185 {
17186 rd->dictpos = 0;
17187 }
17188
17189 rd->maskpos = maskpos;
17190 data.maskpos = maskpos;
17191
17192 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
17193 {
17194 char *mask = masks[maskpos];
17195
17196 if (mask_from_file == 1)
17197 {
17198 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
17199
17200 char *str_ptr;
17201 uint str_pos;
17202
17203 uint mask_offset = 0;
17204
17205 uint separator_cnt;
17206
17207 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
17208 {
17209 str_ptr = strstr (mask + mask_offset, ",");
17210
17211 if (str_ptr == NULL) break;
17212
17213 str_pos = str_ptr - mask;
17214
17215 // escaped separator, i.e. "\,"
17216
17217 if (str_pos > 0)
17218 {
17219 if (mask[str_pos - 1] == '\\')
17220 {
17221 separator_cnt --;
17222
17223 mask_offset = str_pos + 1;
17224
17225 continue;
17226 }
17227 }
17228
17229 // reset the offset
17230
17231 mask_offset = 0;
17232
17233 mask[str_pos] = '\0';
17234
17235 switch (separator_cnt)
17236 {
17237 case 0:
17238 mp_reset_usr (mp_usr, 0);
17239
17240 custom_charset_1 = mask;
17241 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17242 break;
17243
17244 case 1:
17245 mp_reset_usr (mp_usr, 1);
17246
17247 custom_charset_2 = mask;
17248 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17249 break;
17250
17251 case 2:
17252 mp_reset_usr (mp_usr, 2);
17253
17254 custom_charset_3 = mask;
17255 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17256 break;
17257
17258 case 3:
17259 mp_reset_usr (mp_usr, 3);
17260
17261 custom_charset_4 = mask;
17262 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
17263 break;
17264 }
17265
17266 mask = mask + str_pos + 1;
17267 }
17268 }
17269
17270 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17271 {
17272 if (maskpos > 0)
17273 {
17274 local_free (css_buf);
17275 local_free (data.root_css_buf);
17276 local_free (data.markov_css_buf);
17277
17278 local_free (masks[maskpos - 1]);
17279 }
17280
17281 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17282
17283 data.mask = mask;
17284 data.css_cnt = css_cnt;
17285 data.css_buf = css_buf;
17286
17287 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17288
17289 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17290
17291 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17292 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17293
17294 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17295
17296 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17297
17298 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17299 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17300
17301 data.root_css_buf = root_css_buf;
17302 data.markov_css_buf = markov_css_buf;
17303
17304 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17305
17306 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17307
17308 local_free (root_table_buf);
17309 local_free (markov_table_buf);
17310
17311 // args
17312
17313 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17314 {
17315 hc_device_param_t *device_param = &data.devices_param[device_id];
17316
17317 if (device_param->skipped) continue;
17318
17319 device_param->kernel_params_mp[0] = &device_param->d_combs;
17320 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
17321 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
17322
17323 device_param->kernel_params_mp_buf64[3] = 0;
17324 device_param->kernel_params_mp_buf32[4] = css_cnt;
17325 device_param->kernel_params_mp_buf32[5] = 0;
17326 device_param->kernel_params_mp_buf32[6] = 0;
17327 device_param->kernel_params_mp_buf32[7] = 0;
17328
17329 if (attack_mode == ATTACK_MODE_HYBRID1)
17330 {
17331 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
17332 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
17333 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
17334 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
17335 }
17336 else if (attack_mode == ATTACK_MODE_HYBRID2)
17337 {
17338 device_param->kernel_params_mp_buf32[5] = 0;
17339 device_param->kernel_params_mp_buf32[6] = 0;
17340 device_param->kernel_params_mp_buf32[7] = 0;
17341 }
17342
17343 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]);
17344 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]);
17345 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]);
17346
17347 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);
17348 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);
17349 }
17350 }
17351 else if (attack_mode == ATTACK_MODE_BF)
17352 {
17353 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
17354
17355 if (increment)
17356 {
17357 for (uint i = 0; i < dictcnt; i++)
17358 {
17359 local_free (dictfiles[i]);
17360 }
17361
17362 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17363 {
17364 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17365
17366 if (l1_filename == NULL) break;
17367
17368 dictcnt++;
17369
17370 dictfiles[dictcnt - 1] = l1_filename;
17371 }
17372 }
17373 else
17374 {
17375 dictcnt++;
17376
17377 dictfiles[dictcnt - 1] = mask;
17378 }
17379
17380 if (dictcnt == 0)
17381 {
17382 log_error ("ERROR: Mask is too small");
17383
17384 return (-1);
17385 }
17386 }
17387 }
17388
17389 free (induction_dictionaries);
17390
17391 // induction_dictionaries_cnt = 0; // implied
17392
17393 if (attack_mode != ATTACK_MODE_BF)
17394 {
17395 if (keyspace == 0)
17396 {
17397 induction_dictionaries = scan_directory (induction_directory);
17398
17399 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17400 }
17401 }
17402
17403 if (induction_dictionaries_cnt)
17404 {
17405 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17406 }
17407
17408 /**
17409 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17410 */
17411 if (keyspace == 1)
17412 {
17413 if ((maskcnt > 1) || (dictcnt > 1))
17414 {
17415 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17416
17417 return (-1);
17418 }
17419 }
17420
17421 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17422 {
17423 char *subid = logfile_generate_subid ();
17424
17425 data.subid = subid;
17426
17427 logfile_sub_msg ("START");
17428
17429 data.devices_status = STATUS_INIT;
17430
17431 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17432 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17433 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17434
17435 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17436
17437 data.cpt_pos = 0;
17438
17439 data.cpt_start = time (NULL);
17440
17441 data.cpt_total = 0;
17442
17443 if (data.restore == 0)
17444 {
17445 rd->words_cur = skip;
17446
17447 skip = 0;
17448
17449 data.skip = 0;
17450 }
17451
17452 data.ms_paused = 0;
17453
17454 data.kernel_power_final = 0;
17455
17456 data.words_cur = rd->words_cur;
17457
17458 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17459 {
17460 hc_device_param_t *device_param = &data.devices_param[device_id];
17461
17462 if (device_param->skipped) continue;
17463
17464 device_param->speed_pos = 0;
17465
17466 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17467 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17468
17469 device_param->exec_pos = 0;
17470
17471 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17472
17473 device_param->outerloop_pos = 0;
17474 device_param->outerloop_left = 0;
17475 device_param->innerloop_pos = 0;
17476 device_param->innerloop_left = 0;
17477
17478 // some more resets:
17479
17480 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17481
17482 device_param->pws_cnt = 0;
17483
17484 device_param->words_off = 0;
17485 device_param->words_done = 0;
17486 }
17487
17488 // figure out some workload
17489
17490 if (attack_mode == ATTACK_MODE_STRAIGHT)
17491 {
17492 if (data.wordlist_mode == WL_MODE_FILE)
17493 {
17494 char *dictfile = NULL;
17495
17496 if (induction_dictionaries_cnt)
17497 {
17498 dictfile = induction_dictionaries[0];
17499 }
17500 else
17501 {
17502 dictfile = dictfiles[dictpos];
17503 }
17504
17505 data.dictfile = dictfile;
17506
17507 logfile_sub_string (dictfile);
17508
17509 for (uint i = 0; i < rp_files_cnt; i++)
17510 {
17511 logfile_sub_var_string ("rulefile", rp_files[i]);
17512 }
17513
17514 FILE *fd2 = fopen (dictfile, "rb");
17515
17516 if (fd2 == NULL)
17517 {
17518 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17519
17520 return (-1);
17521 }
17522
17523 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17524
17525 fclose (fd2);
17526
17527 if (data.words_cnt == 0)
17528 {
17529 if (data.devices_status == STATUS_CRACKED) break;
17530 if (data.devices_status == STATUS_ABORTED) break;
17531
17532 dictpos++;
17533
17534 continue;
17535 }
17536 }
17537 }
17538 else if (attack_mode == ATTACK_MODE_COMBI)
17539 {
17540 char *dictfile = data.dictfile;
17541 char *dictfile2 = data.dictfile2;
17542
17543 logfile_sub_string (dictfile);
17544 logfile_sub_string (dictfile2);
17545
17546 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17547 {
17548 FILE *fd2 = fopen (dictfile, "rb");
17549
17550 if (fd2 == NULL)
17551 {
17552 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17553
17554 return (-1);
17555 }
17556
17557 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17558
17559 fclose (fd2);
17560 }
17561 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17562 {
17563 FILE *fd2 = fopen (dictfile2, "rb");
17564
17565 if (fd2 == NULL)
17566 {
17567 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17568
17569 return (-1);
17570 }
17571
17572 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17573
17574 fclose (fd2);
17575 }
17576
17577 if (data.words_cnt == 0)
17578 {
17579 if (data.devices_status == STATUS_CRACKED) break;
17580 if (data.devices_status == STATUS_ABORTED) break;
17581
17582 dictpos++;
17583
17584 continue;
17585 }
17586 }
17587 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17588 {
17589 char *dictfile = NULL;
17590
17591 if (induction_dictionaries_cnt)
17592 {
17593 dictfile = induction_dictionaries[0];
17594 }
17595 else
17596 {
17597 dictfile = dictfiles[dictpos];
17598 }
17599
17600 data.dictfile = dictfile;
17601
17602 char *mask = data.mask;
17603
17604 logfile_sub_string (dictfile);
17605 logfile_sub_string (mask);
17606
17607 FILE *fd2 = fopen (dictfile, "rb");
17608
17609 if (fd2 == NULL)
17610 {
17611 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17612
17613 return (-1);
17614 }
17615
17616 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17617
17618 fclose (fd2);
17619
17620 if (data.words_cnt == 0)
17621 {
17622 if (data.devices_status == STATUS_CRACKED) break;
17623 if (data.devices_status == STATUS_ABORTED) break;
17624
17625 dictpos++;
17626
17627 continue;
17628 }
17629 }
17630 else if (attack_mode == ATTACK_MODE_BF)
17631 {
17632 local_free (css_buf);
17633 local_free (data.root_css_buf);
17634 local_free (data.markov_css_buf);
17635
17636 char *mask = dictfiles[dictpos];
17637
17638 logfile_sub_string (mask);
17639
17640 // base
17641
17642 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17643
17644 if (opts_type & OPTS_TYPE_PT_UNICODE)
17645 {
17646 uint css_cnt_unicode = css_cnt * 2;
17647
17648 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17649
17650 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17651 {
17652 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17653
17654 css_buf_unicode[j + 1].cs_buf[0] = 0;
17655 css_buf_unicode[j + 1].cs_len = 1;
17656 }
17657
17658 free (css_buf);
17659
17660 css_buf = css_buf_unicode;
17661 css_cnt = css_cnt_unicode;
17662 }
17663
17664 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17665
17666 uint mask_min = pw_min;
17667 uint mask_max = pw_max;
17668
17669 if (opts_type & OPTS_TYPE_PT_UNICODE)
17670 {
17671 mask_min *= 2;
17672 mask_max *= 2;
17673 }
17674
17675 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17676 {
17677 if (css_cnt < mask_min)
17678 {
17679 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17680 }
17681
17682 if (css_cnt > mask_max)
17683 {
17684 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17685 }
17686
17687 // skip to next mask
17688
17689 dictpos++;
17690
17691 rd->dictpos = dictpos;
17692
17693 logfile_sub_msg ("STOP");
17694
17695 continue;
17696 }
17697
17698 uint save_css_cnt = css_cnt;
17699
17700 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17701 {
17702 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17703 {
17704 uint salt_len = (uint) data.salts_buf[0].salt_len;
17705 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17706
17707 uint css_cnt_salt = css_cnt + salt_len;
17708
17709 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17710
17711 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17712
17713 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17714 {
17715 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17716 css_buf_salt[j].cs_len = 1;
17717 }
17718
17719 free (css_buf);
17720
17721 css_buf = css_buf_salt;
17722 css_cnt = css_cnt_salt;
17723 }
17724 }
17725
17726 data.mask = mask;
17727 data.css_cnt = css_cnt;
17728 data.css_buf = css_buf;
17729
17730 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17731
17732 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17733
17734 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17735
17736 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17737 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17738
17739 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17740
17741 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17742
17743 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17744 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17745
17746 data.root_css_buf = root_css_buf;
17747 data.markov_css_buf = markov_css_buf;
17748
17749 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17750
17751 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17752
17753 local_free (root_table_buf);
17754 local_free (markov_table_buf);
17755
17756 // copy + args
17757
17758 uint css_cnt_l = css_cnt;
17759 uint css_cnt_r;
17760
17761 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17762 {
17763 if (save_css_cnt < 6)
17764 {
17765 css_cnt_r = 1;
17766 }
17767 else if (save_css_cnt == 6)
17768 {
17769 css_cnt_r = 2;
17770 }
17771 else
17772 {
17773 if (opts_type & OPTS_TYPE_PT_UNICODE)
17774 {
17775 if (save_css_cnt == 8 || save_css_cnt == 10)
17776 {
17777 css_cnt_r = 2;
17778 }
17779 else
17780 {
17781 css_cnt_r = 4;
17782 }
17783 }
17784 else
17785 {
17786 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17787 {
17788 css_cnt_r = 3;
17789 }
17790 else
17791 {
17792 css_cnt_r = 4;
17793 }
17794 }
17795 }
17796 }
17797 else
17798 {
17799 css_cnt_r = 1;
17800
17801 /* unfinished code?
17802 int sum = css_buf[css_cnt_r - 1].cs_len;
17803
17804 for (uint i = 1; i < 4 && i < css_cnt; i++)
17805 {
17806 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17807
17808 css_cnt_r++;
17809
17810 sum *= css_buf[css_cnt_r - 1].cs_len;
17811 }
17812 */
17813 }
17814
17815 css_cnt_l -= css_cnt_r;
17816
17817 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17818
17819 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17820 {
17821 hc_device_param_t *device_param = &data.devices_param[device_id];
17822
17823 if (device_param->skipped) continue;
17824
17825 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17826 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17827 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17828
17829 device_param->kernel_params_mp_l_buf64[3] = 0;
17830 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17831 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17832 device_param->kernel_params_mp_l_buf32[6] = 0;
17833 device_param->kernel_params_mp_l_buf32[7] = 0;
17834 device_param->kernel_params_mp_l_buf32[8] = 0;
17835
17836 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17837 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17838 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17839 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17840
17841 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17842 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17843 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17844
17845 device_param->kernel_params_mp_r_buf64[3] = 0;
17846 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17847 device_param->kernel_params_mp_r_buf32[5] = 0;
17848 device_param->kernel_params_mp_r_buf32[6] = 0;
17849 device_param->kernel_params_mp_r_buf32[7] = 0;
17850
17851 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]);
17852 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]);
17853 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]);
17854
17855 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]);
17856 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]);
17857 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]);
17858
17859 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);
17860 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);
17861 }
17862 }
17863
17864 u64 words_base = data.words_cnt;
17865
17866 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17867 {
17868 if (data.kernel_rules_cnt)
17869 {
17870 words_base /= data.kernel_rules_cnt;
17871 }
17872 }
17873 else if (data.attack_kern == ATTACK_KERN_COMBI)
17874 {
17875 if (data.combs_cnt)
17876 {
17877 words_base /= data.combs_cnt;
17878 }
17879 }
17880 else if (data.attack_kern == ATTACK_KERN_BF)
17881 {
17882 if (data.bfs_cnt)
17883 {
17884 words_base /= data.bfs_cnt;
17885 }
17886 }
17887
17888 data.words_base = words_base;
17889
17890 if (keyspace == 1)
17891 {
17892 log_info ("%llu", (unsigned long long int) words_base);
17893
17894 return (0);
17895 }
17896
17897 if (data.words_cur > data.words_base)
17898 {
17899 log_error ("ERROR: restore value greater keyspace");
17900
17901 return (-1);
17902 }
17903
17904 if (data.words_cur)
17905 {
17906 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17907 {
17908 for (uint i = 0; i < data.salts_cnt; i++)
17909 {
17910 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17911 }
17912 }
17913 else if (data.attack_kern == ATTACK_KERN_COMBI)
17914 {
17915 for (uint i = 0; i < data.salts_cnt; i++)
17916 {
17917 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17918 }
17919 }
17920 else if (data.attack_kern == ATTACK_KERN_BF)
17921 {
17922 for (uint i = 0; i < data.salts_cnt; i++)
17923 {
17924 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17925 }
17926 }
17927 }
17928
17929 /*
17930 * Update loopback file
17931 */
17932
17933 if (loopback == 1)
17934 {
17935 time_t now;
17936
17937 time (&now);
17938
17939 uint random_num = get_random_num (0, 9999);
17940
17941 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17942
17943 data.loopback_file = loopback_file;
17944 }
17945
17946 /*
17947 * Update dictionary statistic
17948 */
17949
17950 if (keyspace == 0)
17951 {
17952 dictstat_fp = fopen (dictstat, "wb");
17953
17954 if (dictstat_fp)
17955 {
17956 lock_file (dictstat_fp);
17957
17958 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17959
17960 fclose (dictstat_fp);
17961 }
17962 }
17963
17964 /**
17965 * create autotune threads
17966 */
17967
17968 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17969
17970 data.devices_status = STATUS_AUTOTUNE;
17971
17972 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17973 {
17974 hc_device_param_t *device_param = &devices_param[device_id];
17975
17976 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
17977 }
17978
17979 hc_thread_wait (data.devices_cnt, c_threads);
17980
17981 /*
17982 * Inform user about possible slow speeds
17983 */
17984
17985 uint hardware_power_all = 0;
17986
17987 uint kernel_power_all = 0;
17988
17989 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17990 {
17991 hc_device_param_t *device_param = &devices_param[device_id];
17992
17993 hardware_power_all += device_param->hardware_power;
17994
17995 kernel_power_all += device_param->kernel_power;
17996 }
17997
17998 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
17999
18000 data.kernel_power_all = kernel_power_all;
18001
18002 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18003 {
18004 if (data.words_base < kernel_power_all)
18005 {
18006 if (quiet == 0)
18007 {
18008 log_info ("ATTENTION!");
18009 log_info (" The wordlist or mask you are using is too small.");
18010 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
18011 log_info (" The cracking speed will drop.");
18012 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
18013 log_info ("");
18014 }
18015 }
18016 }
18017
18018 /**
18019 * create cracker threads
18020 */
18021
18022 data.devices_status = STATUS_RUNNING;
18023
18024 if (initial_restore_done == 0)
18025 {
18026 if (data.restore_disable == 0) cycle_restore ();
18027
18028 initial_restore_done = 1;
18029 }
18030
18031 hc_timer_set (&data.timer_running);
18032
18033 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18034 {
18035 if ((quiet == 0) && (status == 0) && (benchmark == 0))
18036 {
18037 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
18038 if (quiet == 0) fflush (stdout);
18039 }
18040 }
18041 else if (wordlist_mode == WL_MODE_STDIN)
18042 {
18043 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
18044 if (data.quiet == 0) log_info ("");
18045 }
18046
18047 time_t runtime_start;
18048
18049 time (&runtime_start);
18050
18051 data.runtime_start = runtime_start;
18052
18053 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18054 {
18055 hc_device_param_t *device_param = &devices_param[device_id];
18056
18057 if (wordlist_mode == WL_MODE_STDIN)
18058 {
18059 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
18060 }
18061 else
18062 {
18063 hc_thread_create (c_threads[device_id], thread_calc, device_param);
18064 }
18065 }
18066
18067 hc_thread_wait (data.devices_cnt, c_threads);
18068
18069 local_free (c_threads);
18070
18071 data.restore = 0;
18072
18073 // finalize task
18074
18075 logfile_sub_var_uint ("status-after-work", data.devices_status);
18076
18077 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18078
18079 if (data.devices_status == STATUS_CRACKED) break;
18080 if (data.devices_status == STATUS_ABORTED) break;
18081
18082 if (data.devices_status == STATUS_BYPASS)
18083 {
18084 data.devices_status = STATUS_RUNNING;
18085 }
18086
18087 if (induction_dictionaries_cnt)
18088 {
18089 unlink (induction_dictionaries[0]);
18090 }
18091
18092 free (induction_dictionaries);
18093
18094 if (attack_mode != ATTACK_MODE_BF)
18095 {
18096 induction_dictionaries = scan_directory (induction_directory);
18097
18098 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18099 }
18100
18101 if (benchmark == 0)
18102 {
18103 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
18104 {
18105 if (quiet == 0) clear_prompt ();
18106
18107 if (quiet == 0) log_info ("");
18108
18109 if (status == 1)
18110 {
18111 status_display ();
18112 }
18113 else
18114 {
18115 if (quiet == 0) status_display ();
18116 }
18117
18118 if (quiet == 0) log_info ("");
18119 }
18120 }
18121
18122 if (attack_mode == ATTACK_MODE_BF)
18123 {
18124 dictpos++;
18125
18126 rd->dictpos = dictpos;
18127 }
18128 else
18129 {
18130 if (induction_dictionaries_cnt)
18131 {
18132 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18133 }
18134 else
18135 {
18136 dictpos++;
18137
18138 rd->dictpos = dictpos;
18139 }
18140 }
18141
18142 time_t runtime_stop;
18143
18144 time (&runtime_stop);
18145
18146 data.runtime_stop = runtime_stop;
18147
18148 logfile_sub_uint (runtime_start);
18149 logfile_sub_uint (runtime_stop);
18150
18151 logfile_sub_msg ("STOP");
18152
18153 global_free (subid);
18154 }
18155
18156 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18157
18158 if (data.devices_status == STATUS_CRACKED) break;
18159 if (data.devices_status == STATUS_ABORTED) break;
18160 if (data.devices_status == STATUS_QUIT) break;
18161
18162 if (data.devices_status == STATUS_BYPASS)
18163 {
18164 data.devices_status = STATUS_RUNNING;
18165 }
18166 }
18167
18168 // 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
18169
18170 if (attack_mode == ATTACK_MODE_STRAIGHT)
18171 {
18172 if (data.wordlist_mode == WL_MODE_FILE)
18173 {
18174 if (data.dictfile == NULL)
18175 {
18176 if (dictfiles != NULL)
18177 {
18178 data.dictfile = dictfiles[0];
18179
18180 hc_timer_set (&data.timer_running);
18181 }
18182 }
18183 }
18184 }
18185 // NOTE: combi is okay because it is already set beforehand
18186 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
18187 {
18188 if (data.dictfile == NULL)
18189 {
18190 if (dictfiles != NULL)
18191 {
18192 hc_timer_set (&data.timer_running);
18193
18194 data.dictfile = dictfiles[0];
18195 }
18196 }
18197 }
18198 else if (attack_mode == ATTACK_MODE_BF)
18199 {
18200 if (data.mask == NULL)
18201 {
18202 hc_timer_set (&data.timer_running);
18203
18204 data.mask = masks[0];
18205 }
18206 }
18207
18208 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18209 {
18210 data.devices_status = STATUS_EXHAUSTED;
18211 }
18212
18213 // if cracked / aborted remove last induction dictionary
18214
18215 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
18216 {
18217 struct stat induct_stat;
18218
18219 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
18220 {
18221 unlink (induction_dictionaries[file_pos]);
18222 }
18223 }
18224
18225 // wait for non-interactive threads
18226
18227 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
18228 {
18229 hc_thread_wait (1, &ni_threads[thread_idx]);
18230 }
18231
18232 local_free (ni_threads);
18233
18234 // wait for interactive threads
18235
18236 for (uint thread_idx = 0; thread_idx < i_threads_cnt; thread_idx++)
18237 {
18238 hc_thread_wait (1, &i_threads[thread_idx]);
18239 }
18240
18241 local_free (i_threads);
18242
18243 // we dont need restore file anymore
18244 if (data.restore_disable == 0)
18245 {
18246 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
18247 {
18248 unlink (eff_restore_file);
18249 unlink (new_restore_file);
18250 }
18251 else
18252 {
18253 cycle_restore ();
18254 }
18255 }
18256
18257 // finally save left hashes
18258
18259 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
18260 {
18261 save_hash ();
18262 }
18263
18264 /**
18265 * Clean up
18266 */
18267
18268 if (benchmark == 1)
18269 {
18270 status_benchmark ();
18271
18272 if (machine_readable == 0)
18273 {
18274 log_info ("");
18275 }
18276 }
18277 else
18278 {
18279 if (quiet == 0) clear_prompt ();
18280
18281 if (quiet == 0) log_info ("");
18282
18283 if (status == 1)
18284 {
18285 status_display ();
18286 }
18287 else
18288 {
18289 if (quiet == 0) status_display ();
18290 }
18291
18292 if (quiet == 0) log_info ("");
18293 }
18294
18295 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18296 {
18297 hc_device_param_t *device_param = &data.devices_param[device_id];
18298
18299 if (device_param->skipped) continue;
18300
18301 local_free (device_param->combs_buf);
18302
18303 local_free (device_param->hooks_buf);
18304
18305 local_free (device_param->device_name);
18306
18307 local_free (device_param->device_name_chksum);
18308
18309 local_free (device_param->device_version);
18310
18311 local_free (device_param->driver_version);
18312
18313 if (device_param->pws_buf) myfree (device_param->pws_buf);
18314 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
18315 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
18316 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
18317 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
18318 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
18319 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
18320 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
18321 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
18322 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
18323 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
18324 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
18325 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
18326 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
18327 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
18328 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
18329 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
18330 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
18331 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
18332 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
18333 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
18334 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
18335 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
18336 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
18337 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
18338 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
18339 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
18340 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
18341 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
18342
18343 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
18344 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
18345 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
18346 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
18347 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
18348 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
18349 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
18350 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
18351 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
18352 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
18353 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
18354
18355 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
18356 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
18357 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
18358
18359 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
18360 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
18361 }
18362
18363 // reset default fan speed
18364
18365 #ifdef HAVE_HWMON
18366 if (gpu_temp_disable == 0)
18367 {
18368 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
18369 {
18370 hc_thread_mutex_lock (mux_adl);
18371
18372 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18373 {
18374 hc_device_param_t *device_param = &data.devices_param[device_id];
18375
18376 if (device_param->skipped) continue;
18377
18378 if (data.hm_device[device_id].fan_set_supported == 1)
18379 {
18380 int fanspeed = temp_retain_fanspeed_value[device_id];
18381 int fanpolicy = temp_retain_fanpolicy_value[device_id];
18382
18383 if (fanpolicy == 1)
18384 {
18385 int rc = -1;
18386
18387 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18388 {
18389 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
18390 }
18391 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18392 {
18393 #ifdef _WIN
18394 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, fanpolicy);
18395 #endif
18396
18397 #ifdef _LINUX
18398 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE);
18399 #endif
18400 }
18401
18402 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18403 }
18404 }
18405 }
18406
18407 hc_thread_mutex_unlock (mux_adl);
18408 }
18409 }
18410
18411 // reset power tuning
18412
18413 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
18414 {
18415 hc_thread_mutex_lock (mux_adl);
18416
18417 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18418 {
18419 hc_device_param_t *device_param = &data.devices_param[device_id];
18420
18421 if (device_param->skipped) continue;
18422
18423 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18424 {
18425 if (data.hm_device[device_id].od_version == 6)
18426 {
18427 // check powertune capabilities first, if not available then skip device
18428
18429 int powertune_supported = 0;
18430
18431 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18432 {
18433 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18434
18435 return (-1);
18436 }
18437
18438 if (powertune_supported != 0)
18439 {
18440 // powercontrol settings
18441
18442 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18443 {
18444 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18445
18446 return (-1);
18447 }
18448
18449 // clocks
18450
18451 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18452
18453 performance_state->iNumberOfPerformanceLevels = 2;
18454
18455 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18456 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18457 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18458 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18459
18460 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18461 {
18462 log_info ("ERROR: Failed to restore ADL performance state");
18463
18464 return (-1);
18465 }
18466
18467 local_free (performance_state);
18468 }
18469 }
18470 }
18471
18472 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18473 {
18474 unsigned int limit = nvml_power_limit[device_id];
18475
18476 if (limit > 0)
18477 {
18478 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18479 }
18480 }
18481 }
18482
18483 hc_thread_mutex_unlock (mux_adl);
18484 }
18485
18486 if (gpu_temp_disable == 0)
18487 {
18488 if (data.hm_nvml)
18489 {
18490 hm_NVML_nvmlShutdown (data.hm_nvml);
18491
18492 nvml_close (data.hm_nvml);
18493
18494 data.hm_nvml = NULL;
18495 }
18496
18497 if (data.hm_nvapi)
18498 {
18499 hm_NvAPI_Unload (data.hm_nvapi);
18500
18501 nvapi_close (data.hm_nvapi);
18502
18503 data.hm_nvapi = NULL;
18504 }
18505
18506 if (data.hm_xnvctrl)
18507 {
18508 hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);
18509
18510 xnvctrl_close (data.hm_xnvctrl);
18511
18512 data.hm_xnvctrl = NULL;
18513 }
18514
18515 if (data.hm_adl)
18516 {
18517 hm_ADL_Main_Control_Destroy (data.hm_adl);
18518
18519 adl_close (data.hm_adl);
18520
18521 data.hm_adl = NULL;
18522 }
18523 }
18524 #endif // HAVE_HWMON
18525
18526 // free memory
18527
18528 local_free (masks);
18529
18530 local_free (dictstat_base);
18531
18532 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18533 {
18534 pot_t *pot_ptr = &pot[pot_pos];
18535
18536 hash_t *hash = &pot_ptr->hash;
18537
18538 local_free (hash->digest);
18539
18540 if (isSalted)
18541 {
18542 local_free (hash->salt);
18543 }
18544 }
18545
18546 local_free (pot);
18547
18548 local_free (all_kernel_rules_cnt);
18549 local_free (all_kernel_rules_buf);
18550
18551 local_free (wl_data->buf);
18552 local_free (wl_data);
18553
18554 local_free (bitmap_s1_a);
18555 local_free (bitmap_s1_b);
18556 local_free (bitmap_s1_c);
18557 local_free (bitmap_s1_d);
18558 local_free (bitmap_s2_a);
18559 local_free (bitmap_s2_b);
18560 local_free (bitmap_s2_c);
18561 local_free (bitmap_s2_d);
18562
18563 #ifdef HAVE_HWMON
18564 local_free (temp_retain_fanspeed_value);
18565 local_free (od_clock_mem_status);
18566 local_free (od_power_control_status);
18567 local_free (nvml_power_limit);
18568 #endif
18569
18570 global_free (devices_param);
18571
18572 global_free (kernel_rules_buf);
18573
18574 global_free (root_css_buf);
18575 global_free (markov_css_buf);
18576
18577 global_free (digests_buf);
18578 global_free (digests_shown);
18579 global_free (digests_shown_tmp);
18580
18581 global_free (salts_buf);
18582 global_free (salts_shown);
18583
18584 global_free (esalts_buf);
18585
18586 global_free (words_progress_done);
18587 global_free (words_progress_rejected);
18588 global_free (words_progress_restored);
18589
18590 if (pot_fp) fclose (pot_fp);
18591
18592 if (data.devices_status == STATUS_QUIT) break;
18593 }
18594
18595 // destroy others mutex
18596
18597 hc_thread_mutex_delete (mux_dispatcher);
18598 hc_thread_mutex_delete (mux_counter);
18599 hc_thread_mutex_delete (mux_display);
18600 hc_thread_mutex_delete (mux_adl);
18601
18602 // free memory
18603
18604 local_free (eff_restore_file);
18605 local_free (new_restore_file);
18606
18607 local_free (rd);
18608
18609 // tuning db
18610
18611 tuning_db_destroy (tuning_db);
18612
18613 // loopback
18614
18615 local_free (loopback_file);
18616
18617 if (loopback == 1) unlink (loopback_file);
18618
18619 // induction directory
18620
18621 if (induction_dir == NULL)
18622 {
18623 if (attack_mode != ATTACK_MODE_BF)
18624 {
18625 if (rmdir (induction_directory) == -1)
18626 {
18627 if (errno == ENOENT)
18628 {
18629 // good, we can ignore
18630 }
18631 else if (errno == ENOTEMPTY)
18632 {
18633 // good, we can ignore
18634 }
18635 else
18636 {
18637 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18638
18639 return (-1);
18640 }
18641 }
18642
18643 local_free (induction_directory);
18644 }
18645 }
18646
18647 // outfile-check directory
18648
18649 if (outfile_check_dir == NULL)
18650 {
18651 if (rmdir (outfile_check_directory) == -1)
18652 {
18653 if (errno == ENOENT)
18654 {
18655 // good, we can ignore
18656 }
18657 else if (errno == ENOTEMPTY)
18658 {
18659 // good, we can ignore
18660 }
18661 else
18662 {
18663 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18664
18665 return (-1);
18666 }
18667 }
18668
18669 local_free (outfile_check_directory);
18670 }
18671
18672 time_t proc_stop;
18673
18674 time (&proc_stop);
18675
18676 logfile_top_uint (proc_start);
18677 logfile_top_uint (proc_stop);
18678
18679 logfile_top_msg ("STOP");
18680
18681 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18682 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18683
18684 if (data.ocl) ocl_close (data.ocl);
18685
18686 if (data.devices_status == STATUS_ABORTED) return 2;
18687 if (data.devices_status == STATUS_QUIT) return 2;
18688 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18689 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18690 if (data.devices_status == STATUS_CRACKED) return 0;
18691
18692 return -1;
18693 }
Hashcat additions to support pwdhash