projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fix some devices_status handling
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define STDOUT_FLAG 0
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define MACHINE_READABLE 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define NVIDIA_SPIN_DAMP 100
79 #define GPU_TEMP_DISABLE 0
80 #define GPU_TEMP_ABORT 90
81 #define GPU_TEMP_RETAIN 65
82 #define WORKLOAD_PROFILE 2
83 #define KERNEL_ACCEL 0
84 #define KERNEL_LOOPS 0
85 #define KERNEL_RULES 1024
86 #define KERNEL_COMBS 1024
87 #define KERNEL_BFS 1024
88 #define KERNEL_THREADS_MAX 256
89 #define KERNEL_THREADS_MAX_CPU 16
90 #define POWERTUNE_ENABLE 0
91 #define LOGFILE_DISABLE 0
92 #define SCRYPT_TMTO 0
93 #define OPENCL_VECTOR_WIDTH 0
94
95 #define WL_MODE_STDIN 1
96 #define WL_MODE_FILE 2
97 #define WL_MODE_MASK 3
98
99 #define HL_MODE_FILE 4
100 #define HL_MODE_ARG 5
101
102 #define HLFMTS_CNT 11
103 #define HLFMT_HASHCAT 0
104 #define HLFMT_PWDUMP 1
105 #define HLFMT_PASSWD 2
106 #define HLFMT_SHADOW 3
107 #define HLFMT_DCC 4
108 #define HLFMT_DCC2 5
109 #define HLFMT_NETNTLM1 7
110 #define HLFMT_NETNTLM2 8
111 #define HLFMT_NSLDAP 9
112 #define HLFMT_NSLDAPS 10
113
114 #define HLFMT_TEXT_HASHCAT "native hashcat"
115 #define HLFMT_TEXT_PWDUMP "pwdump"
116 #define HLFMT_TEXT_PASSWD "passwd"
117 #define HLFMT_TEXT_SHADOW "shadow"
118 #define HLFMT_TEXT_DCC "DCC"
119 #define HLFMT_TEXT_DCC2 "DCC 2"
120 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
121 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
122 #define HLFMT_TEXT_NSLDAP "nsldap"
123 #define HLFMT_TEXT_NSLDAPS "nsldaps"
124
125 #define ATTACK_MODE_STRAIGHT 0
126 #define ATTACK_MODE_COMBI 1
127 #define ATTACK_MODE_TOGGLE 2
128 #define ATTACK_MODE_BF 3
129 #define ATTACK_MODE_PERM 4
130 #define ATTACK_MODE_TABLE 5
131 #define ATTACK_MODE_HYBRID1 6
132 #define ATTACK_MODE_HYBRID2 7
133 #define ATTACK_MODE_NONE 100
134
135 #define ATTACK_KERN_STRAIGHT 0
136 #define ATTACK_KERN_COMBI 1
137 #define ATTACK_KERN_BF 3
138 #define ATTACK_KERN_NONE 100
139
140 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
141 #define ATTACK_EXEC_INSIDE_KERNEL 11
142
143 #define COMBINATOR_MODE_BASE_LEFT 10001
144 #define COMBINATOR_MODE_BASE_RIGHT 10002
145
146 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
147 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
148
149 #define MAX_CUT_TRIES 4
150
151 #define MAX_DICTSTAT 10000
152
153 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
154
155 #define NVIDIA_100PERCENTCPU_WORKAROUND 100
156
157 #define global_free(attr) \
158 { \
159 myfree ((void *) data.attr); \
160 \
161 data.attr = NULL; \
162 }
163
164 #define local_free(attr) \
165 { \
166 myfree ((void *) attr); \
167 \
168 attr = NULL; \
169 }
170
171 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
172 #define HC_API_CALL __stdcall
173 #else
174 #define HC_API_CALL
175 #endif
176
177 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
178 {
179 900,
180 0,
181 5100,
182 100,
183 1400,
184 10800,
185 1700,
186 5000,
187 10100,
188 6000,
189 6100,
190 6900,
191 11700,
192 11800,
193 400,
194 8900,
195 11900,
196 12000,
197 10900,
198 12100,
199 23,
200 2500,
201 5300,
202 5400,
203 5500,
204 5600,
205 7300,
206 7500,
207 13100,
208 8300,
209 11100,
210 11200,
211 11400,
212 121,
213 2611,
214 2711,
215 2811,
216 8400,
217 11,
218 2612,
219 7900,
220 21,
221 11000,
222 124,
223 10000,
224 3711,
225 7600,
226 12,
227 131,
228 132,
229 1731,
230 200,
231 300,
232 3100,
233 112,
234 12300,
235 8000,
236 141,
237 1441,
238 1600,
239 12600,
240 1421,
241 101,
242 111,
243 1711,
244 3000,
245 1000,
246 1100,
247 2100,
248 12800,
249 1500,
250 12400,
251 500,
252 3200,
253 7400,
254 1800,
255 122,
256 1722,
257 7100,
258 6300,
259 6700,
260 6400,
261 6500,
262 2400,
263 2410,
264 5700,
265 9200,
266 9300,
267 22,
268 501,
269 5800,
270 8100,
271 8500,
272 7200,
273 9900,
274 7700,
275 7800,
276 10300,
277 8600,
278 8700,
279 9100,
280 133,
281 13500,
282 11600,
283 13600,
284 12500,
285 13000,
286 13200,
287 13300,
288 6211,
289 6221,
290 6231,
291 6241,
292 13711,
293 13721,
294 13731,
295 13741,
296 13751,
297 13761,
298 8800,
299 12900,
300 12200,
301 9700,
302 9710,
303 9800,
304 9810,
305 9400,
306 9500,
307 9600,
308 10400,
309 10410,
310 10500,
311 10600,
312 10700,
313 9000,
314 5200,
315 6800,
316 6600,
317 8200,
318 11300,
319 12700,
320 13400,
321 125
322 };
323
324 /**
325 * types
326 */
327
328 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
329
330 /**
331 * globals
332 */
333
334 static unsigned int full01 = 0x01010101;
335 static unsigned int full80 = 0x80808080;
336
337 int SUPPRESS_OUTPUT = 0;
338
339 hc_thread_mutex_t mux_adl;
340 hc_thread_mutex_t mux_counter;
341 hc_thread_mutex_t mux_dispatcher;
342 hc_thread_mutex_t mux_display;
343
344 hc_global_data_t data;
345
346 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
347
348 const char *USAGE_MINI[] =
349 {
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "Try --help for more help.",
353 NULL
354 };
355
356 const char *USAGE_BIG[] =
357 {
358 "%s, advanced password recovery",
359 "",
360 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
361 "",
362 "- [ Options ] -",
363 "",
364 " Options Short / Long | Type | Description | Example",
365 "===============================+======+======================================================+=======================",
366 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
367 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
368 " -V, --version | | Print version |",
369 " -h, --help | | Print help |",
370 " --quiet | | Suppress output |",
371 " --hex-charset | | Assume charset is given in hex |",
372 " --hex-salt | | Assume salt is given in hex |",
373 " --hex-wordlist | | Assume words in wordlist is given in hex |",
374 " --force | | Ignore warnings |",
375 " --status | | Enable automatic update of the status-screen |",
376 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
377 " --machine-readable | | Display the status view in a machine readable format |",
378 " --loopback | | Add new plains to induct directory |",
379 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
380 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
381 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
382 " --markov-classic | | Enables classic markov-chains, no per-position |",
383 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
384 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
385 " --session | Str | Define specific session name | --session=mysession",
386 " --restore | | Restore session from --session |",
387 " --restore-disable | | Do not write restore file |",
388 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
389 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
390 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
391 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
392 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
393 " --stdout | | Do not crack a hash, instead print candidates only |",
394 " --show | | Compare hashlist with potfile; Show cracked hashes |",
395 " --left | | Compare hashlist with potfile; Show uncracked hashes |",
396 " --username | | Enable ignoring of usernames in hashfile |",
397 " --remove | | Enable remove of hash once it is cracked |",
398 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
399 " --potfile-disable | | Do not write potfile |",
400 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
401 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
402 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
403 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
404 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
405 " --logfile-disable | | Disable the logfile |",
406 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
407 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
408 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
409 " -b, --benchmark | | Run benchmark |",
410 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
411 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
412 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
413 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
414 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
415 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
416 " -D, --opencl-device-types | Str | OpenCL device-types to use, separate with comma | -D 1",
417 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
418 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
419 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
420 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
421 " --nvidia-spin-damp | Num | Workaround NVidias CPU burning loop bug, in percent | --nvidia-spin-damp=50",
422 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
423 #ifdef HAVE_HWMON
424 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
425 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
426 " --powertune-enable | | Enable power tuning, restores settings when finished |",
427 #endif
428 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
429 " -s, --skip | Num | Skip X words from the start | -s 1000000",
430 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
431 " --keyspace | | Show keyspace base:mod values and quit |",
432 " -j, --rule-left | Rule | Single rule applied to each word from left wordlist | -j 'c'",
433 " -k, --rule-right | Rule | Single rule applied to each word from right wordlist | -k '^-'",
434 " -r, --rules-file | File | Multiple rules applied to each word from wordlists | -r rules/best64.rule",
435 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
436 " --generate-rules-func-min | Num | Force min X funcs per rule |",
437 " --generate-rules-func-max | Num | Force max X funcs per rule |",
438 " --generate-rules-seed | Num | Force RNG seed set to X |",
439 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
440 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
441 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
442 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
443 " -i, --increment | | Enable mask increment mode |",
444 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
445 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
446 "",
447 "- [ Hash modes ] -",
448 "",
449 " # | Name | Category",
450 " ======+==================================================+======================================",
451 " 900 | MD4 | Raw Hash",
452 " 0 | MD5 | Raw Hash",
453 " 5100 | Half MD5 | Raw Hash",
454 " 100 | SHA1 | Raw Hash",
455 " 10800 | SHA-384 | Raw Hash",
456 " 1400 | SHA-256 | Raw Hash",
457 " 1700 | SHA-512 | Raw Hash",
458 " 5000 | SHA-3(Keccak) | Raw Hash",
459 " 10100 | SipHash | Raw Hash",
460 " 6000 | RipeMD160 | Raw Hash",
461 " 6100 | Whirlpool | Raw Hash",
462 " 6900 | GOST R 34.11-94 | Raw Hash",
463 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
464 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
465 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
466 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
467 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
468 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
469 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
470 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
471 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
472 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
473 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
474 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
475 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
476 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
477 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
478 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
479 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
480 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
481 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
482 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
483 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
484 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
485 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
486 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
487 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
488 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
489 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
490 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
491 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
492 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
493 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
494 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
495 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
496 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
497 " 400 | phpass | Generic KDF",
498 " 8900 | scrypt | Generic KDF",
499 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
500 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
501 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
502 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
503 " 23 | Skype | Network protocols",
504 " 2500 | WPA/WPA2 | Network protocols",
505 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
506 " 5300 | IKE-PSK MD5 | Network protocols",
507 " 5400 | IKE-PSK SHA1 | Network protocols",
508 " 5500 | NetNTLMv1 | Network protocols",
509 " 5500 | NetNTLMv1 + ESS | Network protocols",
510 " 5600 | NetNTLMv2 | Network protocols",
511 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
512 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
513 " 8300 | DNSSEC (NSEC3) | Network protocols",
514 " 10200 | Cram MD5 | Network protocols",
515 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
516 " 11200 | MySQL CRAM (SHA1) | Network protocols",
517 " 11400 | SIP digest authentication (MD5) | Network protocols",
518 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
519 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
520 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
521 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
522 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
523 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
524 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
525 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
526 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
527 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
528 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
529 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
530 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
531 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
532 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
533 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
534 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
535 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
536 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
537 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
538 " 12 | PostgreSQL | Database Server",
539 " 131 | MSSQL(2000) | Database Server",
540 " 132 | MSSQL(2005) | Database Server",
541 " 1731 | MSSQL(2012) | Database Server",
542 " 1731 | MSSQL(2014) | Database Server",
543 " 200 | MySQL323 | Database Server",
544 " 300 | MySQL4.1/MySQL5 | Database Server",
545 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
546 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
547 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
548 " 8000 | Sybase ASE | Database Server",
549 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
550 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
551 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
552 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
553 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
554 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
555 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
556 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
557 " 11500 | CRC32 | Checksums",
558 " 3000 | LM | Operating-Systems",
559 " 1000 | NTLM | Operating-Systems",
560 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
561 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
562 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
563 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
564 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
565 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
566 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
567 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
568 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
569 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
570 " 1722 | OSX v10.7 | Operating-Systems",
571 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
572 " 6300 | AIX {smd5} | Operating-Systems",
573 " 6700 | AIX {ssha1} | Operating-Systems",
574 " 6400 | AIX {ssha256} | Operating-Systems",
575 " 6500 | AIX {ssha512} | Operating-Systems",
576 " 2400 | Cisco-PIX | Operating-Systems",
577 " 2410 | Cisco-ASA | Operating-Systems",
578 " 500 | Cisco-IOS $1$ | Operating-Systems",
579 " 5700 | Cisco-IOS $4$ | Operating-Systems",
580 " 9200 | Cisco-IOS $8$ | Operating-Systems",
581 " 9300 | Cisco-IOS $9$ | Operating-Systems",
582 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
583 " 501 | Juniper IVE | Operating-Systems",
584 " 5800 | Android PIN | Operating-Systems",
585 " 13800 | Windows 8+ phone PIN/Password | Operating-Systems",
586 " 8100 | Citrix Netscaler | Operating-Systems",
587 " 8500 | RACF | Operating-Systems",
588 " 7200 | GRUB 2 | Operating-Systems",
589 " 9900 | Radmin2 | Operating-Systems",
590 " 125 | ArubaOS | Operating-Systems",
591 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
592 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
593 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
594 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
595 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
596 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
597 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
598 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
599 " 11600 | 7-Zip | Archives",
600 " 12500 | RAR3-hp | Archives",
601 " 13000 | RAR5 | Archives",
602 " 13200 | AxCrypt | Archives",
603 " 13300 | AxCrypt in memory SHA1 | Archives",
604 " 13600 | WinZip | Archives",
605 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
606 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
607 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
608 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
609 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
610 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
611 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
612 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
613 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
614 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
615 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
616 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
617 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
618 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
619 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
620 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
621 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
622 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
623 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
624 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
625 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
626 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
627 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
628 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
629 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
630 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
631 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
632 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
633 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
634 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
635 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
636 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
637 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
638 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
639 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
640 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
641 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
642 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
643 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
644 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
645 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
646 " 9400 | MS Office 2007 | Documents",
647 " 9500 | MS Office 2010 | Documents",
648 " 9600 | MS Office 2013 | Documents",
649 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
650 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
651 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
652 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
653 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
654 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
655 " 9000 | Password Safe v2 | Password Managers",
656 " 5200 | Password Safe v3 | Password Managers",
657 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
658 " 6600 | 1Password, agilekeychain | Password Managers",
659 " 8200 | 1Password, cloudkeychain | Password Managers",
660 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
661 " 12700 | Blockchain, My Wallet | Password Managers",
662 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
663 "",
664 "- [ Outfile Formats ] -",
665 "",
666 " # | Format",
667 " ===+========",
668 " 1 | hash[:salt]",
669 " 2 | plain",
670 " 3 | hash[:salt]:plain",
671 " 4 | hex_plain",
672 " 5 | hash[:salt]:hex_plain",
673 " 6 | plain:hex_plain",
674 " 7 | hash[:salt]:plain:hex_plain",
675 " 8 | crackpos",
676 " 9 | hash[:salt]:crack_pos",
677 " 10 | plain:crack_pos",
678 " 11 | hash[:salt]:plain:crack_pos",
679 " 12 | hex_plain:crack_pos",
680 " 13 | hash[:salt]:hex_plain:crack_pos",
681 " 14 | plain:hex_plain:crack_pos",
682 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
683 "",
684 "- [ Rule Debugging Modes ] -",
685 "",
686 " # | Format",
687 " ===+========",
688 " 1 | Finding-Rule",
689 " 2 | Original-Word",
690 " 3 | Original-Word:Finding-Rule",
691 " 4 | Original-Word:Finding-Rule:Processed-Word",
692 "",
693 "- [ Attack Modes ] -",
694 "",
695 " # | Mode",
696 " ===+======",
697 " 0 | Straight",
698 " 1 | Combination",
699 " 3 | Brute-force",
700 " 6 | Hybrid Wordlist + Mask",
701 " 7 | Hybrid Mask + Wordlist",
702 "",
703 "- [ Built-in Charsets ] -",
704 "",
705 " ? | Charset",
706 " ===+=========",
707 " l | abcdefghijklmnopqrstuvwxyz",
708 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
709 " d | 0123456789",
710 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
711 " a | ?l?u?d?s",
712 " b | 0x00 - 0xff",
713 "",
714 "- [ OpenCL Device Types ] -",
715 "",
716 " # | Device Type",
717 " ===+=============",
718 " 1 | CPU",
719 " 2 | GPU",
720 " 3 | FPGA, DSP, Co-Processor",
721 "",
722 "- [ Workload Profiles ] -",
723 "",
724 " # | Performance | Runtime | Power Consumption | Desktop Impact",
725 " ===+=============+=========+===================+=================",
726 " 1 | Low | 2 ms | Low | Minimal",
727 " 2 | Default | 12 ms | Economic | Noticeable",
728 " 3 | High | 96 ms | High | Unresponsive",
729 " 4 | Nightmare | 480 ms | Insane | Headless",
730 "",
731 "- [ Basic Examples ] -",
732 "",
733 " Attack- | Hash- |",
734 " Mode | Type | Example command",
735 " ==================+=======+==================================================================",
736 " Wordlist | $P$ | %s -a 0 -m 400 example400.hash example.dict",
737 " Wordlist + Rules | MD5 | %s -a 0 -m 0 example0.hash example.dict -r rules/best64.rule",
738 " Brute-Force | MD5 | %s -a 3 -m 0 example0.hash ?a?a?a?a?a?a",
739 " Combinator | MD5 | %s -a 1 -m 0 example0.hash example.dict example.dict",
740 "",
741 "If you still have no idea what just happened try following pages:",
742 "",
743 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
744 "* https://hashcat.net/wiki/#frequently_asked_questions",
745 NULL
746 };
747
748 /**
749 * hashcat specific functions
750 */
751
752 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
753 {
754 int exec_pos = (int) device_param->exec_pos - last_num_entries;
755
756 if (exec_pos < 0) exec_pos += EXEC_CACHE;
757
758 double exec_ms_sum = 0;
759
760 int exec_ms_cnt = 0;
761
762 for (int i = 0; i < last_num_entries; i++)
763 {
764 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
765
766 if (exec_ms)
767 {
768 exec_ms_sum += exec_ms;
769
770 exec_ms_cnt++;
771 }
772 }
773
774 if (exec_ms_cnt == 0) return 0;
775
776 return exec_ms_sum / exec_ms_cnt;
777 }
778
779 void status_display_machine_readable ()
780 {
781 FILE *out = stdout;
782
783 fprintf (out, "STATUS\t%u\t", data.devices_status);
784
785 /**
786 * speed new
787 */
788
789 fprintf (out, "SPEED\t");
790
791 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
792 {
793 hc_device_param_t *device_param = &data.devices_param[device_id];
794
795 if (device_param->skipped) continue;
796
797 u64 speed_cnt = 0;
798 double speed_ms = 0;
799
800 for (int i = 0; i < SPEED_CACHE; i++)
801 {
802 speed_cnt += device_param->speed_cnt[i];
803 speed_ms += device_param->speed_ms[i];
804 }
805
806 speed_cnt /= SPEED_CACHE;
807 speed_ms /= SPEED_CACHE;
808
809 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
810 }
811
812 /**
813 * exec time
814 */
815
816 fprintf (out, "EXEC_RUNTIME\t");
817
818 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
819 {
820 hc_device_param_t *device_param = &data.devices_param[device_id];
821
822 if (device_param->skipped) continue;
823
824 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
825
826 fprintf (out, "%f\t", exec_ms_avg);
827 }
828
829 /**
830 * words_cur
831 */
832
833 u64 words_cur = get_lowest_words_done ();
834
835 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
836
837 /**
838 * counter
839 */
840
841 u64 progress_total = data.words_cnt * data.salts_cnt;
842
843 u64 all_done = 0;
844 u64 all_rejected = 0;
845 u64 all_restored = 0;
846
847 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
848 {
849 all_done += data.words_progress_done[salt_pos];
850 all_rejected += data.words_progress_rejected[salt_pos];
851 all_restored += data.words_progress_restored[salt_pos];
852 }
853
854 u64 progress_cur = all_restored + all_done + all_rejected;
855 u64 progress_end = progress_total;
856
857 u64 progress_skip = 0;
858
859 if (data.skip)
860 {
861 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
862
863 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
864 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
865 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
866 }
867
868 if (data.limit)
869 {
870 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
871
872 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
873 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
874 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
875 }
876
877 u64 progress_cur_relative_skip = progress_cur - progress_skip;
878 u64 progress_end_relative_skip = progress_end - progress_skip;
879
880 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
881
882 /**
883 * cracks
884 */
885
886 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
887 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
888
889 /**
890 * temperature
891 */
892
893 #ifdef HAVE_HWMON
894 if (data.gpu_temp_disable == 0)
895 {
896 fprintf (out, "TEMP\t");
897
898 hc_thread_mutex_lock (mux_adl);
899
900 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
901 {
902 hc_device_param_t *device_param = &data.devices_param[device_id];
903
904 if (device_param->skipped) continue;
905
906 int temp = hm_get_temperature_with_device_id (device_id);
907
908 fprintf (out, "%d\t", temp);
909 }
910
911 hc_thread_mutex_unlock (mux_adl);
912 }
913 #endif // HAVE_HWMON
914
915 /**
916 * flush
917 */
918
919 #ifdef _WIN
920 fputc ('\r', out);
921 fputc ('\n', out);
922 #endif
923
924 #ifdef _POSIX
925 fputc ('\n', out);
926 #endif
927
928 fflush (out);
929 }
930
931 void status_display ()
932 {
933 if (data.devices_status == STATUS_INIT) return;
934 if (data.devices_status == STATUS_STARTING) return;
935
936 if (data.machine_readable == 1)
937 {
938 status_display_machine_readable ();
939
940 return;
941 }
942
943 char tmp_buf[1000] = { 0 };
944
945 uint tmp_len = 0;
946
947 log_info ("Session.Name...: %s", data.session);
948
949 char *status_type = strstatus (data.devices_status);
950
951 uint hash_mode = data.hash_mode;
952
953 char *hash_type = strhashtype (hash_mode); // not a bug
954
955 log_info ("Status.........: %s", status_type);
956
957 /**
958 * show rules
959 */
960
961 if (data.rp_files_cnt)
962 {
963 uint i;
964
965 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
966 {
967 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
968 }
969
970 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
971
972 log_info ("Rules.Type.....: %s", tmp_buf);
973
974 tmp_len = 0;
975 }
976
977 if (data.rp_gen)
978 {
979 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
980
981 if (data.rp_gen_seed)
982 {
983 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
984 }
985 }
986
987 /**
988 * show input
989 */
990
991 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
992 {
993 if (data.wordlist_mode == WL_MODE_FILE)
994 {
995 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
996 }
997 else if (data.wordlist_mode == WL_MODE_STDIN)
998 {
999 log_info ("Input.Mode.....: Pipe");
1000 }
1001 }
1002 else if (data.attack_mode == ATTACK_MODE_COMBI)
1003 {
1004 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1005 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1006 }
1007 else if (data.attack_mode == ATTACK_MODE_BF)
1008 {
1009 char *mask = data.mask;
1010
1011 if (mask != NULL)
1012 {
1013 uint mask_len = data.css_cnt;
1014
1015 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1016
1017 if (mask_len > 0)
1018 {
1019 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1020 {
1021 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1022 {
1023 mask_len -= data.salts_buf[0].salt_len;
1024 }
1025 }
1026
1027 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1028
1029 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1030 }
1031
1032 if (data.maskcnt > 1)
1033 {
1034 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1035
1036 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1037 }
1038
1039 log_info ("Input.Mode.....: %s", tmp_buf);
1040 }
1041
1042 tmp_len = 0;
1043 }
1044 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1045 {
1046 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1047 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1048 }
1049 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1050 {
1051 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1052 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1053 }
1054
1055 if (data.digests_cnt == 1)
1056 {
1057 if (data.hash_mode == 2500)
1058 {
1059 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1060
1061 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1062 (char *) data.salts_buf[0].salt_buf,
1063 wpa->orig_mac1[0],
1064 wpa->orig_mac1[1],
1065 wpa->orig_mac1[2],
1066 wpa->orig_mac1[3],
1067 wpa->orig_mac1[4],
1068 wpa->orig_mac1[5],
1069 wpa->orig_mac2[0],
1070 wpa->orig_mac2[1],
1071 wpa->orig_mac2[2],
1072 wpa->orig_mac2[3],
1073 wpa->orig_mac2[4],
1074 wpa->orig_mac2[5]);
1075 }
1076 else if (data.hash_mode == 5200)
1077 {
1078 log_info ("Hash.Target....: File (%s)", data.hashfile);
1079 }
1080 else if (data.hash_mode == 9000)
1081 {
1082 log_info ("Hash.Target....: File (%s)", data.hashfile);
1083 }
1084 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1085 {
1086 log_info ("Hash.Target....: File (%s)", data.hashfile);
1087 }
1088 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1089 {
1090 log_info ("Hash.Target....: File (%s)", data.hashfile);
1091 }
1092 else
1093 {
1094 char out_buf[HCBUFSIZ] = { 0 };
1095
1096 ascii_digest (out_buf, 0, 0);
1097
1098 // limit length
1099 if (strlen (out_buf) > 40)
1100 {
1101 out_buf[41] = '.';
1102 out_buf[42] = '.';
1103 out_buf[43] = '.';
1104 out_buf[44] = 0;
1105 }
1106
1107 log_info ("Hash.Target....: %s", out_buf);
1108 }
1109 }
1110 else
1111 {
1112 if (data.hash_mode == 3000)
1113 {
1114 char out_buf1[32] = { 0 };
1115 char out_buf2[32] = { 0 };
1116
1117 ascii_digest (out_buf1, 0, 0);
1118 ascii_digest (out_buf2, 0, 1);
1119
1120 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1121 }
1122 else
1123 {
1124 log_info ("Hash.Target....: File (%s)", data.hashfile);
1125 }
1126 }
1127
1128 log_info ("Hash.Type......: %s", hash_type);
1129
1130 /**
1131 * speed new
1132 */
1133
1134 u64 speed_cnt[DEVICES_MAX] = { 0 };
1135 double speed_ms[DEVICES_MAX] = { 0 };
1136
1137 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1138 {
1139 hc_device_param_t *device_param = &data.devices_param[device_id];
1140
1141 if (device_param->skipped) continue;
1142
1143 speed_cnt[device_id] = 0;
1144 speed_ms[device_id] = 0;
1145
1146 for (int i = 0; i < SPEED_CACHE; i++)
1147 {
1148 speed_cnt[device_id] += device_param->speed_cnt[i];
1149 speed_ms[device_id] += device_param->speed_ms[i];
1150 }
1151
1152 speed_cnt[device_id] /= SPEED_CACHE;
1153 speed_ms[device_id] /= SPEED_CACHE;
1154 }
1155
1156 double hashes_all_ms = 0;
1157
1158 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1159
1160 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1161 {
1162 hc_device_param_t *device_param = &data.devices_param[device_id];
1163
1164 if (device_param->skipped) continue;
1165
1166 hashes_dev_ms[device_id] = 0;
1167
1168 if (speed_ms[device_id])
1169 {
1170 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1171
1172 hashes_all_ms += hashes_dev_ms[device_id];
1173 }
1174 }
1175
1176 /**
1177 * exec time
1178 */
1179
1180 double exec_all_ms[DEVICES_MAX] = { 0 };
1181
1182 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1183 {
1184 hc_device_param_t *device_param = &data.devices_param[device_id];
1185
1186 if (device_param->skipped) continue;
1187
1188 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1189
1190 exec_all_ms[device_id] = exec_ms_avg;
1191 }
1192
1193 /**
1194 * timers
1195 */
1196
1197 double ms_running = 0;
1198
1199 hc_timer_get (data.timer_running, ms_running);
1200
1201 double ms_paused = data.ms_paused;
1202
1203 if (data.devices_status == STATUS_PAUSED)
1204 {
1205 double ms_paused_tmp = 0;
1206
1207 hc_timer_get (data.timer_paused, ms_paused_tmp);
1208
1209 ms_paused += ms_paused_tmp;
1210 }
1211
1212 #ifdef WIN
1213
1214 __time64_t sec_run = ms_running / 1000;
1215
1216 #else
1217
1218 time_t sec_run = ms_running / 1000;
1219
1220 #endif
1221
1222 if (sec_run)
1223 {
1224 char display_run[32] = { 0 };
1225
1226 struct tm tm_run;
1227
1228 struct tm *tmp = NULL;
1229
1230 #ifdef WIN
1231
1232 tmp = _gmtime64 (&sec_run);
1233
1234 #else
1235
1236 tmp = gmtime (&sec_run);
1237
1238 #endif
1239
1240 if (tmp != NULL)
1241 {
1242 memset (&tm_run, 0, sizeof (tm_run));
1243
1244 memcpy (&tm_run, tmp, sizeof (tm_run));
1245
1246 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1247
1248 char *start = ctime (&data.proc_start);
1249
1250 size_t start_len = strlen (start);
1251
1252 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1253 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1254
1255 log_info ("Time.Started...: %s (%s)", start, display_run);
1256 }
1257 }
1258 else
1259 {
1260 log_info ("Time.Started...: 0 secs");
1261 }
1262
1263 /**
1264 * counters
1265 */
1266
1267 u64 progress_total = data.words_cnt * data.salts_cnt;
1268
1269 u64 all_done = 0;
1270 u64 all_rejected = 0;
1271 u64 all_restored = 0;
1272
1273 u64 progress_noneed = 0;
1274
1275 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1276 {
1277 all_done += data.words_progress_done[salt_pos];
1278 all_rejected += data.words_progress_rejected[salt_pos];
1279 all_restored += data.words_progress_restored[salt_pos];
1280
1281 // Important for ETA only
1282
1283 if (data.salts_shown[salt_pos] == 1)
1284 {
1285 const u64 all = data.words_progress_done[salt_pos]
1286 + data.words_progress_rejected[salt_pos]
1287 + data.words_progress_restored[salt_pos];
1288
1289 const u64 left = data.words_cnt - all;
1290
1291 progress_noneed += left;
1292 }
1293 }
1294
1295 u64 progress_cur = all_restored + all_done + all_rejected;
1296 u64 progress_end = progress_total;
1297
1298 u64 progress_skip = 0;
1299
1300 if (data.skip)
1301 {
1302 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1303
1304 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1305 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1306 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1307 }
1308
1309 if (data.limit)
1310 {
1311 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1312
1313 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1314 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1315 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1316 }
1317
1318 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1319 u64 progress_end_relative_skip = progress_end - progress_skip;
1320
1321 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1322 {
1323 if (data.devices_status != STATUS_CRACKED)
1324 {
1325 #ifdef WIN
1326 __time64_t sec_etc = 0;
1327 #else
1328 time_t sec_etc = 0;
1329 #endif
1330
1331 if (hashes_all_ms)
1332 {
1333 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1334
1335 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1336
1337 sec_etc = ms_left / 1000;
1338 }
1339
1340 if (sec_etc == 0)
1341 {
1342 //log_info ("Time.Estimated.: 0 secs");
1343 }
1344 else if ((u64) sec_etc > ETC_MAX)
1345 {
1346 log_info ("Time.Estimated.: > 10 Years");
1347 }
1348 else
1349 {
1350 char display_etc[32] = { 0 };
1351
1352 struct tm tm_etc;
1353
1354 struct tm *tmp = NULL;
1355
1356 #ifdef WIN
1357
1358 tmp = _gmtime64 (&sec_etc);
1359
1360 #else
1361
1362 tmp = gmtime (&sec_etc);
1363
1364 #endif
1365
1366 if (tmp != NULL)
1367 {
1368 memset (&tm_etc, 0, sizeof (tm_etc));
1369
1370 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1371
1372 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1373
1374 time_t now;
1375
1376 time (&now);
1377
1378 now += sec_etc;
1379
1380 char *etc = ctime (&now);
1381
1382 size_t etc_len = strlen (etc);
1383
1384 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1385 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1386
1387 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1388 }
1389 }
1390 }
1391 }
1392
1393 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1394 {
1395 hc_device_param_t *device_param = &data.devices_param[device_id];
1396
1397 if (device_param->skipped) continue;
1398
1399 char display_dev_cur[16] = { 0 };
1400
1401 strncpy (display_dev_cur, "0.00", 4);
1402
1403 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1404
1405 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1406 }
1407
1408 char display_all_cur[16] = { 0 };
1409
1410 strncpy (display_all_cur, "0.00", 4);
1411
1412 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1413
1414 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1415
1416 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1417 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1418
1419 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);
1420
1421 // crack-per-time
1422
1423 if (data.digests_cnt > 100)
1424 {
1425 time_t now = time (NULL);
1426
1427 int cpt_cur_min = 0;
1428 int cpt_cur_hour = 0;
1429 int cpt_cur_day = 0;
1430
1431 for (int i = 0; i < CPT_BUF; i++)
1432 {
1433 const uint cracked = data.cpt_buf[i].cracked;
1434 const time_t timestamp = data.cpt_buf[i].timestamp;
1435
1436 if ((timestamp + 60) > now)
1437 {
1438 cpt_cur_min += cracked;
1439 }
1440
1441 if ((timestamp + 3600) > now)
1442 {
1443 cpt_cur_hour += cracked;
1444 }
1445
1446 if ((timestamp + 86400) > now)
1447 {
1448 cpt_cur_day += cracked;
1449 }
1450 }
1451
1452 double ms_real = ms_running - ms_paused;
1453
1454 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1455 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1456 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1457
1458 if ((data.cpt_start + 86400) < now)
1459 {
1460 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1461 cpt_cur_min,
1462 cpt_cur_hour,
1463 cpt_cur_day,
1464 cpt_avg_min,
1465 cpt_avg_hour,
1466 cpt_avg_day);
1467 }
1468 else if ((data.cpt_start + 3600) < now)
1469 {
1470 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1471 cpt_cur_min,
1472 cpt_cur_hour,
1473 cpt_avg_min,
1474 cpt_avg_hour,
1475 cpt_avg_day);
1476 }
1477 else if ((data.cpt_start + 60) < now)
1478 {
1479 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1480 cpt_cur_min,
1481 cpt_avg_min,
1482 cpt_avg_hour,
1483 cpt_avg_day);
1484 }
1485 else
1486 {
1487 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1488 cpt_avg_min,
1489 cpt_avg_hour,
1490 cpt_avg_day);
1491 }
1492 }
1493
1494 // Restore point
1495
1496 u64 restore_point = get_lowest_words_done ();
1497
1498 u64 restore_total = data.words_base;
1499
1500 float percent_restore = 0;
1501
1502 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1503
1504 if (progress_end_relative_skip)
1505 {
1506 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1507 {
1508 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1509 float percent_rejected = 0.0;
1510
1511 if (progress_cur)
1512 {
1513 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1514 }
1515
1516 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);
1517 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1518
1519 if (data.restore_disable == 0)
1520 {
1521 if (percent_finished != 1)
1522 {
1523 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1524 }
1525 }
1526 }
1527 }
1528 else
1529 {
1530 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1531 {
1532 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1533 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1534
1535 if (data.restore_disable == 0)
1536 {
1537 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1538 }
1539 }
1540 else
1541 {
1542 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1543 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1544
1545 // --restore not allowed if stdin is used -- really? why?
1546
1547 //if (data.restore_disable == 0)
1548 //{
1549 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1550 //}
1551 }
1552 }
1553
1554 #ifdef HAVE_HWMON
1555
1556 if (data.devices_status == STATUS_EXHAUSTED) return;
1557 if (data.devices_status == STATUS_CRACKED) return;
1558 if (data.devices_status == STATUS_ABORTED) return;
1559 if (data.devices_status == STATUS_QUIT) return;
1560
1561 if (data.gpu_temp_disable == 0)
1562 {
1563 hc_thread_mutex_lock (mux_adl);
1564
1565 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1566 {
1567 hc_device_param_t *device_param = &data.devices_param[device_id];
1568
1569 if (device_param->skipped) continue;
1570
1571 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1572 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1573 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1574 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1575 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1576 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1577 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1578
1579 char output_buf[256] = { 0 };
1580
1581 int output_len = 0;
1582
1583 if (num_temperature >= 0)
1584 {
1585 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1586
1587 output_len = strlen (output_buf);
1588 }
1589
1590 if (num_fanspeed >= 0)
1591 {
1592 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1593
1594 output_len = strlen (output_buf);
1595 }
1596
1597 if (num_utilization >= 0)
1598 {
1599 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1600
1601 output_len = strlen (output_buf);
1602 }
1603
1604 if (num_corespeed >= 0)
1605 {
1606 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1607
1608 output_len = strlen (output_buf);
1609 }
1610
1611 if (num_memoryspeed >= 0)
1612 {
1613 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1614
1615 output_len = strlen (output_buf);
1616 }
1617
1618 if (num_buslanes >= 0)
1619 {
1620 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1621
1622 output_len = strlen (output_buf);
1623 }
1624
1625 if (num_throttle == 1)
1626 {
1627 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1628
1629 output_len = strlen (output_buf);
1630 }
1631
1632 if (output_len == 0)
1633 {
1634 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1635
1636 output_len = strlen (output_buf);
1637 }
1638
1639 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1640 }
1641
1642 hc_thread_mutex_unlock (mux_adl);
1643 }
1644
1645 #endif // HAVE_HWMON
1646 }
1647
1648 static void status_benchmark_automate ()
1649 {
1650 u64 speed_cnt[DEVICES_MAX] = { 0 };
1651 double speed_ms[DEVICES_MAX] = { 0 };
1652
1653 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1654 {
1655 hc_device_param_t *device_param = &data.devices_param[device_id];
1656
1657 if (device_param->skipped) continue;
1658
1659 speed_cnt[device_id] = device_param->speed_cnt[0];
1660 speed_ms[device_id] = device_param->speed_ms[0];
1661 }
1662
1663 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1664
1665 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1666 {
1667 hc_device_param_t *device_param = &data.devices_param[device_id];
1668
1669 if (device_param->skipped) continue;
1670
1671 hashes_dev_ms[device_id] = 0;
1672
1673 if (speed_ms[device_id])
1674 {
1675 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1676 }
1677 }
1678
1679 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1680 {
1681 hc_device_param_t *device_param = &data.devices_param[device_id];
1682
1683 if (device_param->skipped) continue;
1684
1685 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1686 }
1687 }
1688
1689 static void status_benchmark ()
1690 {
1691 if (data.devices_status == STATUS_INIT) return;
1692 if (data.devices_status == STATUS_STARTING) return;
1693
1694 if (data.machine_readable == 1)
1695 {
1696 status_benchmark_automate ();
1697
1698 return;
1699 }
1700
1701 u64 speed_cnt[DEVICES_MAX] = { 0 };
1702 double speed_ms[DEVICES_MAX] = { 0 };
1703
1704 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1705 {
1706 hc_device_param_t *device_param = &data.devices_param[device_id];
1707
1708 if (device_param->skipped) continue;
1709
1710 speed_cnt[device_id] = device_param->speed_cnt[0];
1711 speed_ms[device_id] = device_param->speed_ms[0];
1712 }
1713
1714 double hashes_all_ms = 0;
1715
1716 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1717
1718 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1719 {
1720 hc_device_param_t *device_param = &data.devices_param[device_id];
1721
1722 if (device_param->skipped) continue;
1723
1724 hashes_dev_ms[device_id] = 0;
1725
1726 if (speed_ms[device_id])
1727 {
1728 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1729
1730 hashes_all_ms += hashes_dev_ms[device_id];
1731 }
1732 }
1733
1734 /**
1735 * exec time
1736 */
1737
1738 double exec_all_ms[DEVICES_MAX] = { 0 };
1739
1740 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1741 {
1742 hc_device_param_t *device_param = &data.devices_param[device_id];
1743
1744 if (device_param->skipped) continue;
1745
1746 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1747
1748 exec_all_ms[device_id] = exec_ms_avg;
1749 }
1750
1751 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1752 {
1753 hc_device_param_t *device_param = &data.devices_param[device_id];
1754
1755 if (device_param->skipped) continue;
1756
1757 char display_dev_cur[16] = { 0 };
1758
1759 strncpy (display_dev_cur, "0.00", 4);
1760
1761 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1762
1763 if (data.devices_active >= 10)
1764 {
1765 log_info ("Speed.Dev.#%d: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1766 }
1767 else
1768 {
1769 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1770 }
1771 }
1772
1773 char display_all_cur[16] = { 0 };
1774
1775 strncpy (display_all_cur, "0.00", 4);
1776
1777 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1778
1779 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1780 }
1781
1782 /**
1783 * hashcat -only- functions
1784 */
1785
1786 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1787 {
1788 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1789 {
1790 if (attack_kern == ATTACK_KERN_STRAIGHT)
1791 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1792 else if (attack_kern == ATTACK_KERN_COMBI)
1793 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1794 else if (attack_kern == ATTACK_KERN_BF)
1795 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1796 }
1797 else
1798 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1799 }
1800
1801 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)
1802 {
1803 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1804 {
1805 if (attack_kern == ATTACK_KERN_STRAIGHT)
1806 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1807 else if (attack_kern == ATTACK_KERN_COMBI)
1808 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1809 else if (attack_kern == ATTACK_KERN_BF)
1810 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1811 }
1812 else
1813 {
1814 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1815 }
1816 }
1817
1818 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1819 {
1820 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1821 {
1822 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1823 }
1824 else
1825 {
1826 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1827 }
1828 }
1829
1830 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)
1831 {
1832 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1833 {
1834 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1835 }
1836 else
1837 {
1838 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1839 }
1840 }
1841
1842 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1843 {
1844 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1845 }
1846
1847 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1848 {
1849 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1850 }
1851
1852 static char *filename_from_filepath (char *filepath)
1853 {
1854 char *ptr = NULL;
1855
1856 if ((ptr = strrchr (filepath, '/')) != NULL)
1857 {
1858 ptr++;
1859 }
1860 else if ((ptr = strrchr (filepath, '\\')) != NULL)
1861 {
1862 ptr++;
1863 }
1864 else
1865 {
1866 ptr = filepath;
1867 }
1868
1869 return ptr;
1870 }
1871
1872 static uint convert_from_hex (char *line_buf, const uint line_len)
1873 {
1874 if (line_len & 1) return (line_len); // not in hex
1875
1876 if (data.hex_wordlist == 1)
1877 {
1878 uint i;
1879 uint j;
1880
1881 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1882 {
1883 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1884 }
1885
1886 memset (line_buf + i, 0, line_len - i);
1887
1888 return (i);
1889 }
1890 else if (line_len >= 6) // $HEX[] = 6
1891 {
1892 if (line_buf[0] != '$') return (line_len);
1893 if (line_buf[1] != 'H') return (line_len);
1894 if (line_buf[2] != 'E') return (line_len);
1895 if (line_buf[3] != 'X') return (line_len);
1896 if (line_buf[4] != '[') return (line_len);
1897 if (line_buf[line_len - 1] != ']') return (line_len);
1898
1899 uint i;
1900 uint j;
1901
1902 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1903 {
1904 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1905 }
1906
1907 memset (line_buf + i, 0, line_len - i);
1908
1909 return (i);
1910 }
1911
1912 return (line_len);
1913 }
1914
1915 static void clear_prompt ()
1916 {
1917 fputc ('\r', stdout);
1918
1919 for (size_t i = 0; i < strlen (PROMPT); i++)
1920 {
1921 fputc (' ', stdout);
1922 }
1923
1924 fputc ('\r', stdout);
1925
1926 fflush (stdout);
1927 }
1928
1929 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1930 {
1931 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);
1932 }
1933
1934 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1935 {
1936 char *outfile = data.outfile;
1937 uint quiet = data.quiet;
1938 FILE *pot_fp = data.pot_fp;
1939 uint loopback = data.loopback;
1940 uint debug_mode = data.debug_mode;
1941 char *debug_file = data.debug_file;
1942
1943 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1944 int debug_rule_len = 0; // -1 error
1945 uint debug_plain_len = 0;
1946
1947 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1948
1949 // hash
1950
1951 char out_buf[HCBUFSIZ] = { 0 };
1952
1953 const u32 salt_pos = plain->salt_pos;
1954 const u32 digest_pos = plain->digest_pos; // relative
1955 const u32 gidvid = plain->gidvid;
1956 const u32 il_pos = plain->il_pos;
1957
1958 ascii_digest (out_buf, salt_pos, digest_pos);
1959
1960 // plain
1961
1962 u64 crackpos = device_param->words_off;
1963
1964 uint plain_buf[16] = { 0 };
1965
1966 u8 *plain_ptr = (u8 *) plain_buf;
1967
1968 unsigned int plain_len = 0;
1969
1970 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1971 {
1972 pw_t pw;
1973
1974 gidd_to_pw_t (device_param, gidvid, &pw);
1975
1976 for (int i = 0; i < 16; i++)
1977 {
1978 plain_buf[i] = pw.i[i];
1979 }
1980
1981 plain_len = pw.pw_len;
1982
1983 const uint off = device_param->innerloop_pos + il_pos;
1984
1985 if (debug_mode > 0)
1986 {
1987 debug_rule_len = 0;
1988
1989 // save rule
1990 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1991 {
1992 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1993
1994 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1995 }
1996
1997 // save plain
1998 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1999 {
2000 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
2001
2002 memcpy (debug_plain_ptr, plain_ptr, plain_len);
2003
2004 debug_plain_len = plain_len;
2005 }
2006 }
2007
2008 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2009
2010 crackpos += gidvid;
2011 crackpos *= data.kernel_rules_cnt;
2012 crackpos += device_param->innerloop_pos + il_pos;
2013
2014 if (plain_len > data.pw_max) plain_len = data.pw_max;
2015 }
2016 else if (data.attack_mode == ATTACK_MODE_COMBI)
2017 {
2018 pw_t pw;
2019
2020 gidd_to_pw_t (device_param, gidvid, &pw);
2021
2022 for (int i = 0; i < 16; i++)
2023 {
2024 plain_buf[i] = pw.i[i];
2025 }
2026
2027 plain_len = pw.pw_len;
2028
2029 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2030 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2031
2032 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2033 {
2034 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2035 }
2036 else
2037 {
2038 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2039
2040 memcpy (plain_ptr, comb_buf, comb_len);
2041 }
2042
2043 plain_len += comb_len;
2044
2045 crackpos += gidvid;
2046 crackpos *= data.combs_cnt;
2047 crackpos += device_param->innerloop_pos + il_pos;
2048
2049 if (data.pw_max != PW_DICTMAX1)
2050 {
2051 if (plain_len > data.pw_max) plain_len = data.pw_max;
2052 }
2053 }
2054 else if (data.attack_mode == ATTACK_MODE_BF)
2055 {
2056 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2057 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2058
2059 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2060 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2061
2062 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2063 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2064
2065 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2066 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2067
2068 plain_len = data.css_cnt;
2069
2070 crackpos += gidvid;
2071 crackpos *= data.bfs_cnt;
2072 crackpos += device_param->innerloop_pos + il_pos;
2073 }
2074 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2075 {
2076 pw_t pw;
2077
2078 gidd_to_pw_t (device_param, gidvid, &pw);
2079
2080 for (int i = 0; i < 16; i++)
2081 {
2082 plain_buf[i] = pw.i[i];
2083 }
2084
2085 plain_len = pw.pw_len;
2086
2087 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2088
2089 uint start = 0;
2090 uint stop = device_param->kernel_params_mp_buf32[4];
2091
2092 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2093
2094 plain_len += start + stop;
2095
2096 crackpos += gidvid;
2097 crackpos *= data.combs_cnt;
2098 crackpos += device_param->innerloop_pos + il_pos;
2099
2100 if (data.pw_max != PW_DICTMAX1)
2101 {
2102 if (plain_len > data.pw_max) plain_len = data.pw_max;
2103 }
2104 }
2105 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2106 {
2107 pw_t pw;
2108
2109 gidd_to_pw_t (device_param, gidvid, &pw);
2110
2111 for (int i = 0; i < 16; i++)
2112 {
2113 plain_buf[i] = pw.i[i];
2114 }
2115
2116 plain_len = pw.pw_len;
2117
2118 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2119
2120 uint start = 0;
2121 uint stop = device_param->kernel_params_mp_buf32[4];
2122
2123 memmove (plain_ptr + stop, plain_ptr, plain_len);
2124
2125 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2126
2127 plain_len += start + stop;
2128
2129 crackpos += gidvid;
2130 crackpos *= data.combs_cnt;
2131 crackpos += device_param->innerloop_pos + il_pos;
2132
2133 if (data.pw_max != PW_DICTMAX1)
2134 {
2135 if (plain_len > data.pw_max) plain_len = data.pw_max;
2136 }
2137 }
2138
2139 if (data.attack_mode == ATTACK_MODE_BF)
2140 {
2141 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2142 {
2143 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2144 {
2145 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2146 {
2147 plain_len = plain_len - data.salts_buf[0].salt_len;
2148 }
2149 }
2150
2151 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2152 {
2153 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2154 {
2155 plain_ptr[j] = plain_ptr[i];
2156 }
2157
2158 plain_len = plain_len / 2;
2159 }
2160 }
2161 }
2162
2163 // if enabled, update also the potfile
2164
2165 if (pot_fp)
2166 {
2167 lock_file (pot_fp);
2168
2169 fprintf (pot_fp, "%s:", out_buf);
2170
2171 format_plain (pot_fp, plain_ptr, plain_len, 1);
2172
2173 fputc ('\n', pot_fp);
2174
2175 fflush (pot_fp);
2176
2177 unlock_file (pot_fp);
2178 }
2179
2180 // outfile
2181
2182 FILE *out_fp = NULL;
2183
2184 if (outfile != NULL)
2185 {
2186 if ((out_fp = fopen (outfile, "ab")) == NULL)
2187 {
2188 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2189
2190 out_fp = stdout;
2191 }
2192
2193 lock_file (out_fp);
2194 }
2195 else
2196 {
2197 out_fp = stdout;
2198
2199 if (quiet == 0) clear_prompt ();
2200 }
2201
2202 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2203
2204 if (outfile != NULL)
2205 {
2206 if (out_fp != stdout)
2207 {
2208 fclose (out_fp);
2209 }
2210 }
2211 else
2212 {
2213 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2214 {
2215 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2216 {
2217 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2218 if (quiet == 0) fflush (stdout);
2219 }
2220 }
2221 }
2222
2223 // loopback
2224
2225 if (loopback)
2226 {
2227 char *loopback_file = data.loopback_file;
2228
2229 FILE *fb_fp = NULL;
2230
2231 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2232 {
2233 lock_file (fb_fp);
2234
2235 format_plain (fb_fp, plain_ptr, plain_len, 1);
2236
2237 fputc ('\n', fb_fp);
2238
2239 fclose (fb_fp);
2240 }
2241 }
2242
2243 // (rule) debug mode
2244
2245 // the next check implies that:
2246 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2247 // - debug_mode > 0
2248
2249 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2250 {
2251 if (debug_rule_len < 0) debug_rule_len = 0;
2252
2253 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2254
2255 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2256
2257 if ((quiet == 0) && (debug_file == NULL))
2258 {
2259 fprintf (stdout, "%s", PROMPT);
2260
2261 fflush (stdout);
2262 }
2263 }
2264 }
2265
2266 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2267 {
2268 salt_t *salt_buf = &data.salts_buf[salt_pos];
2269
2270 u32 num_cracked;
2271
2272 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2273
2274 if (num_cracked)
2275 {
2276 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2277
2278 log_info_nn ("");
2279
2280 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2281
2282 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);
2283
2284 uint cpt_cracked = 0;
2285
2286 hc_thread_mutex_lock (mux_display);
2287
2288 for (uint i = 0; i < num_cracked; i++)
2289 {
2290 const uint hash_pos = cracked[i].hash_pos;
2291
2292 if (data.digests_shown[hash_pos] == 1) continue;
2293
2294 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2295 {
2296 data.digests_shown[hash_pos] = 1;
2297
2298 data.digests_done++;
2299
2300 cpt_cracked++;
2301
2302 salt_buf->digests_done++;
2303
2304 if (salt_buf->digests_done == salt_buf->digests_cnt)
2305 {
2306 data.salts_shown[salt_pos] = 1;
2307
2308 data.salts_done++;
2309 }
2310 }
2311
2312 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2313
2314 check_hash (device_param, &cracked[i]);
2315 }
2316
2317 hc_thread_mutex_unlock (mux_display);
2318
2319 myfree (cracked);
2320
2321 if (cpt_cracked > 0)
2322 {
2323 hc_thread_mutex_lock (mux_display);
2324
2325 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2326 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2327
2328 data.cpt_pos++;
2329
2330 data.cpt_total += cpt_cracked;
2331
2332 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2333
2334 hc_thread_mutex_unlock (mux_display);
2335 }
2336
2337 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2338 {
2339 // we need to reset cracked state on the device
2340 // otherwise host thinks again and again the hash was cracked
2341 // and returns invalid password each time
2342
2343 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2344
2345 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);
2346 }
2347
2348 num_cracked = 0;
2349
2350 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2351 }
2352 }
2353
2354 // stolen from princeprocessor ;)
2355
2356 typedef struct
2357 {
2358 FILE *fp;
2359
2360 char buf[BUFSIZ];
2361 int len;
2362
2363 } out_t;
2364
2365 static void out_flush (out_t *out)
2366 {
2367 fwrite (out->buf, 1, out->len, out->fp);
2368
2369 out->len = 0;
2370 }
2371
2372 static void out_push (out_t *out, const u8 *pw_buf, const int pw_len)
2373 {
2374 char *ptr = out->buf + out->len;
2375
2376 memcpy (ptr, pw_buf, pw_len);
2377
2378 ptr[pw_len] = '\n';
2379
2380 out->len += pw_len + 1;
2381
2382 if (out->len >= BUFSIZ - 100)
2383 {
2384 out_flush (out);
2385 }
2386 }
2387
2388 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2389 {
2390 out_t out;
2391
2392 out.fp = stdout;
2393 out.len = 0;
2394
2395 uint plain_buf[16] = { 0 };
2396
2397 u8 *plain_ptr = (u8 *) plain_buf;
2398
2399 uint plain_len = 0;
2400
2401 const uint il_cnt = device_param->kernel_params_buf32[27]; // ugly, i know
2402
2403 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2404 {
2405 pw_t pw;
2406
2407 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2408 {
2409 gidd_to_pw_t (device_param, gidvid, &pw);
2410
2411 const uint pos = device_param->innerloop_pos;
2412
2413 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2414 {
2415 for (int i = 0; i < 8; i++)
2416 {
2417 plain_buf[i] = pw.i[i];
2418 }
2419
2420 plain_len = pw.pw_len;
2421
2422 plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2423
2424 if (plain_len > data.pw_max) plain_len = data.pw_max;
2425
2426 out_push (&out, plain_ptr, plain_len);
2427 }
2428 }
2429 }
2430 else if (data.attack_mode == ATTACK_MODE_COMBI)
2431 {
2432 pw_t pw;
2433
2434 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2435 {
2436 gidd_to_pw_t (device_param, gidvid, &pw);
2437
2438 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2439 {
2440 for (int i = 0; i < 8; i++)
2441 {
2442 plain_buf[i] = pw.i[i];
2443 }
2444
2445 plain_len = pw.pw_len;
2446
2447 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2448 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2449
2450 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2451 {
2452 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2453 }
2454 else
2455 {
2456 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2457
2458 memcpy (plain_ptr, comb_buf, comb_len);
2459 }
2460
2461 plain_len += comb_len;
2462
2463 if (data.pw_max != PW_DICTMAX1)
2464 {
2465 if (plain_len > data.pw_max) plain_len = data.pw_max;
2466 }
2467
2468 out_push (&out, plain_ptr, plain_len);
2469 }
2470 }
2471 }
2472 else if (data.attack_mode == ATTACK_MODE_BF)
2473 {
2474 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2475 {
2476 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2477 {
2478 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2479 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2480
2481 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2482 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2483
2484 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2485 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2486
2487 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2488 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2489
2490 plain_len = data.css_cnt;
2491
2492 out_push (&out, plain_ptr, plain_len);
2493 }
2494 }
2495 }
2496 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2497 {
2498 pw_t pw;
2499
2500 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2501 {
2502 gidd_to_pw_t (device_param, gidvid, &pw);
2503
2504 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2505 {
2506 for (int i = 0; i < 8; i++)
2507 {
2508 plain_buf[i] = pw.i[i];
2509 }
2510
2511 plain_len = pw.pw_len;
2512
2513 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2514
2515 uint start = 0;
2516 uint stop = device_param->kernel_params_mp_buf32[4];
2517
2518 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2519
2520 plain_len += start + stop;
2521
2522 out_push (&out, plain_ptr, plain_len);
2523 }
2524 }
2525 }
2526 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2527 {
2528 pw_t pw;
2529
2530 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2531 {
2532 gidd_to_pw_t (device_param, gidvid, &pw);
2533
2534 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2535 {
2536 for (int i = 0; i < 8; i++)
2537 {
2538 plain_buf[i] = pw.i[i];
2539 }
2540
2541 plain_len = pw.pw_len;
2542
2543 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2544
2545 uint start = 0;
2546 uint stop = device_param->kernel_params_mp_buf32[4];
2547
2548 memmove (plain_ptr + stop, plain_ptr, plain_len);
2549
2550 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2551
2552 plain_len += start + stop;
2553
2554 out_push (&out, plain_ptr, plain_len);
2555 }
2556 }
2557 }
2558
2559 out_flush (&out);
2560 }
2561
2562 static void save_hash ()
2563 {
2564 char *hashfile = data.hashfile;
2565
2566 char new_hashfile[256] = { 0 };
2567 char old_hashfile[256] = { 0 };
2568
2569 snprintf (new_hashfile, 255, "%s.new", hashfile);
2570 snprintf (old_hashfile, 255, "%s.old", hashfile);
2571
2572 unlink (new_hashfile);
2573
2574 char separator = data.separator;
2575
2576 FILE *fp = fopen (new_hashfile, "wb");
2577
2578 if (fp == NULL)
2579 {
2580 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2581
2582 exit (-1);
2583 }
2584
2585 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2586 {
2587 if (data.salts_shown[salt_pos] == 1) continue;
2588
2589 salt_t *salt_buf = &data.salts_buf[salt_pos];
2590
2591 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2592 {
2593 uint idx = salt_buf->digests_offset + digest_pos;
2594
2595 if (data.digests_shown[idx] == 1) continue;
2596
2597 if (data.hash_mode != 2500)
2598 {
2599 if (data.username == 1)
2600 {
2601 user_t *user = data.hash_info[idx]->user;
2602
2603 uint i;
2604
2605 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2606
2607 fputc (separator, fp);
2608 }
2609
2610 char out_buf[HCBUFSIZ]; // scratch buffer
2611
2612 out_buf[0] = 0;
2613
2614 ascii_digest (out_buf, salt_pos, digest_pos);
2615
2616 fputs (out_buf, fp);
2617
2618 fputc ('\n', fp);
2619 }
2620 else
2621 {
2622 hccap_t hccap;
2623
2624 to_hccap_t (&hccap, salt_pos, digest_pos);
2625
2626 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2627 }
2628 }
2629 }
2630
2631 fflush (fp);
2632
2633 fclose (fp);
2634
2635 unlink (old_hashfile);
2636
2637 if (rename (hashfile, old_hashfile) != 0)
2638 {
2639 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2640
2641 exit (-1);
2642 }
2643
2644 unlink (hashfile);
2645
2646 if (rename (new_hashfile, hashfile) != 0)
2647 {
2648 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2649
2650 exit (-1);
2651 }
2652
2653 unlink (old_hashfile);
2654 }
2655
2656 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2657 {
2658 uint num_elements = num;
2659
2660 device_param->kernel_params_buf32[30] = data.combs_mode;
2661 device_param->kernel_params_buf32[31] = num;
2662
2663 uint kernel_threads = device_param->kernel_threads;
2664
2665 while (num_elements % kernel_threads) num_elements++;
2666
2667 cl_kernel kernel = NULL;
2668
2669 switch (kern_run)
2670 {
2671 case KERN_RUN_1: kernel = device_param->kernel1; break;
2672 case KERN_RUN_12: kernel = device_param->kernel12; break;
2673 case KERN_RUN_2: kernel = device_param->kernel2; break;
2674 case KERN_RUN_23: kernel = device_param->kernel23; break;
2675 case KERN_RUN_3: kernel = device_param->kernel3; break;
2676 }
2677
2678 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2679 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2680 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2681 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2682 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2683 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2684 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2685 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2686 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2687 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2688 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2689
2690 cl_event event;
2691
2692 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2693 {
2694 const size_t global_work_size[3] = { num_elements, 32, 1 };
2695 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2696
2697 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2698 }
2699 else
2700 {
2701 if (kern_run == KERN_RUN_2)
2702 {
2703 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2704 {
2705 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2706 }
2707 }
2708
2709 while (num_elements % kernel_threads) num_elements++;
2710
2711 const size_t global_work_size[3] = { num_elements, 1, 1 };
2712 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2713
2714 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2715 }
2716
2717 hc_clFlush (data.ocl, device_param->command_queue);
2718
2719 if (device_param->nvidia_spin_damp)
2720 {
2721 if (data.devices_status == STATUS_RUNNING)
2722 {
2723 if (iteration < EXPECTED_ITERATIONS)
2724 {
2725 switch (kern_run)
2726 {
2727 case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration] * device_param->nvidia_spin_damp); break;
2728 case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration] * device_param->nvidia_spin_damp); break;
2729 case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration] * device_param->nvidia_spin_damp); break;
2730 }
2731 }
2732 }
2733 }
2734
2735 hc_clWaitForEvents (data.ocl, 1, &event);
2736
2737 cl_ulong time_start;
2738 cl_ulong time_end;
2739
2740 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2741 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2742
2743 const double exec_us = (double) (time_end - time_start) / 1000;
2744
2745 if (data.devices_status == STATUS_RUNNING)
2746 {
2747 if (iteration < EXPECTED_ITERATIONS)
2748 {
2749 switch (kern_run)
2750 {
2751 case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2752 case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2753 case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2754 }
2755 }
2756 }
2757
2758 if (event_update)
2759 {
2760 uint exec_pos = device_param->exec_pos;
2761
2762 device_param->exec_ms[exec_pos] = exec_us / 1000;
2763
2764 exec_pos++;
2765
2766 if (exec_pos == EXEC_CACHE)
2767 {
2768 exec_pos = 0;
2769 }
2770
2771 device_param->exec_pos = exec_pos;
2772 }
2773
2774 hc_clReleaseEvent (data.ocl, event);
2775
2776 hc_clFinish (data.ocl, device_param->command_queue);
2777 }
2778
2779 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2780 {
2781 uint num_elements = num;
2782
2783 switch (kern_run)
2784 {
2785 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2786 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2787 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2788 }
2789
2790 // causes problems with special threads like in bcrypt
2791 // const uint kernel_threads = device_param->kernel_threads;
2792
2793 uint kernel_threads = device_param->kernel_threads;
2794
2795 while (num_elements % kernel_threads) num_elements++;
2796
2797 cl_kernel kernel = NULL;
2798
2799 switch (kern_run)
2800 {
2801 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2802 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2803 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2804 }
2805
2806 switch (kern_run)
2807 {
2808 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2809 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2810 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2811 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2812 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2813 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2814 break;
2815 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2816 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2817 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2818 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2819 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2820 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2821 break;
2822 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2823 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2824 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2825 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2826 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2827 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2828 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2829 break;
2830 }
2831
2832 const size_t global_work_size[3] = { num_elements, 1, 1 };
2833 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2834
2835 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2836
2837 hc_clFlush (data.ocl, device_param->command_queue);
2838
2839 hc_clFinish (data.ocl, device_param->command_queue);
2840 }
2841
2842 static void run_kernel_tm (hc_device_param_t *device_param)
2843 {
2844 const uint num_elements = 1024; // fixed
2845
2846 uint kernel_threads = 32;
2847
2848 cl_kernel kernel = device_param->kernel_tm;
2849
2850 const size_t global_work_size[3] = { num_elements, 1, 1 };
2851 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2852
2853 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2854
2855 hc_clFlush (data.ocl, device_param->command_queue);
2856
2857 hc_clFinish (data.ocl, device_param->command_queue);
2858 }
2859
2860 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2861 {
2862 uint num_elements = num;
2863
2864 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2865 device_param->kernel_params_amp_buf32[6] = num_elements;
2866
2867 // causes problems with special threads like in bcrypt
2868 // const uint kernel_threads = device_param->kernel_threads;
2869
2870 uint kernel_threads = device_param->kernel_threads;
2871
2872 while (num_elements % kernel_threads) num_elements++;
2873
2874 cl_kernel kernel = device_param->kernel_amp;
2875
2876 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2877 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2878
2879 const size_t global_work_size[3] = { num_elements, 1, 1 };
2880 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2881
2882 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2883
2884 hc_clFlush (data.ocl, device_param->command_queue);
2885
2886 hc_clFinish (data.ocl, device_param->command_queue);
2887 }
2888
2889 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2890 {
2891 const u32 num16d = num / 16;
2892 const u32 num16m = num % 16;
2893
2894 if (num16d)
2895 {
2896 device_param->kernel_params_memset_buf32[1] = value;
2897 device_param->kernel_params_memset_buf32[2] = num16d;
2898
2899 uint kernel_threads = device_param->kernel_threads;
2900
2901 uint num_elements = num16d;
2902
2903 while (num_elements % kernel_threads) num_elements++;
2904
2905 cl_kernel kernel = device_param->kernel_memset;
2906
2907 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2908 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2909 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2910
2911 const size_t global_work_size[3] = { num_elements, 1, 1 };
2912 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2913
2914 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2915
2916 hc_clFlush (data.ocl, device_param->command_queue);
2917
2918 hc_clFinish (data.ocl, device_param->command_queue);
2919 }
2920
2921 if (num16m)
2922 {
2923 u32 tmp[4];
2924
2925 tmp[0] = value;
2926 tmp[1] = value;
2927 tmp[2] = value;
2928 tmp[3] = value;
2929
2930 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2931 }
2932 }
2933
2934 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2935 {
2936 run_kernel_memset (device_param, buf, 0, size);
2937
2938 /*
2939 int rc = -1;
2940
2941 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2942 {
2943 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2944
2945 const cl_uchar zero = 0;
2946
2947 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2948 }
2949
2950 if (rc != 0)
2951 {
2952 // NOTE: clEnqueueFillBuffer () always fails with -59
2953 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2954 // How's that possible, OpenCL 1.2 support is advertised??
2955 // We need to workaround...
2956
2957 #define FILLSZ 0x100000
2958
2959 char *tmp = (char *) mymalloc (FILLSZ);
2960
2961 for (size_t i = 0; i < size; i += FILLSZ)
2962 {
2963 const size_t left = size - i;
2964
2965 const size_t fillsz = MIN (FILLSZ, left);
2966
2967 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2968 }
2969
2970 myfree (tmp);
2971 }
2972 */
2973 }
2974
2975 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)
2976 {
2977 if (data.hash_mode == 2000)
2978 {
2979 process_stdout (device_param, pws_cnt);
2980
2981 return;
2982 }
2983
2984 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2985 {
2986 if (attack_mode == ATTACK_MODE_BF)
2987 {
2988 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2989 {
2990 const uint size_tm = 32 * sizeof (bs_word_t);
2991
2992 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2993
2994 run_kernel_tm (device_param);
2995
2996 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);
2997 }
2998 }
2999
3000 if (highest_pw_len < 16)
3001 {
3002 run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
3003 }
3004 else if (highest_pw_len < 32)
3005 {
3006 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
3007 }
3008 else
3009 {
3010 run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
3011 }
3012 }
3013 else
3014 {
3015 run_kernel_amp (device_param, pws_cnt);
3016
3017 run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
3018
3019 if (opts_type & OPTS_TYPE_HOOK12)
3020 {
3021 run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
3022
3023 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);
3024
3025 // do something with data
3026
3027 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);
3028 }
3029
3030 uint iter = salt_buf->salt_iter;
3031
3032 uint loop_step = device_param->kernel_loops;
3033
3034 for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
3035 {
3036 uint loop_left = iter - loop_pos;
3037
3038 loop_left = MIN (loop_left, loop_step);
3039
3040 device_param->kernel_params_buf32[25] = loop_pos;
3041 device_param->kernel_params_buf32[26] = loop_left;
3042
3043 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
3044
3045 if (data.devices_status == STATUS_CRACKED) break;
3046 if (data.devices_status == STATUS_ABORTED) break;
3047 if (data.devices_status == STATUS_QUIT) break;
3048
3049 /**
3050 * speed
3051 */
3052
3053 const float iter_part = (float) (loop_pos + loop_left) / iter;
3054
3055 const u64 perf_sum_all = pws_cnt * iter_part;
3056
3057 double speed_ms;
3058
3059 hc_timer_get (device_param->timer_speed, speed_ms);
3060
3061 const u32 speed_pos = device_param->speed_pos;
3062
3063 device_param->speed_cnt[speed_pos] = perf_sum_all;
3064
3065 device_param->speed_ms[speed_pos] = speed_ms;
3066
3067 if (data.benchmark == 1)
3068 {
3069 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
3070 }
3071 }
3072
3073 if (opts_type & OPTS_TYPE_HOOK23)
3074 {
3075 run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
3076
3077 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);
3078
3079 // do something with data
3080
3081 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);
3082 }
3083
3084 run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3085 }
3086 }
3087
3088 static int run_rule_engine (const int rule_len, const char *rule_buf)
3089 {
3090 if (rule_len == 0)
3091 {
3092 return 0;
3093 }
3094 else if (rule_len == 1)
3095 {
3096 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3097 }
3098
3099 return 1;
3100 }
3101
3102 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3103 {
3104 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3105 {
3106 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);
3107 }
3108 else if (data.attack_kern == ATTACK_KERN_COMBI)
3109 {
3110 if (data.attack_mode == ATTACK_MODE_COMBI)
3111 {
3112 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3113 {
3114 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3115 {
3116 for (u32 i = 0; i < pws_cnt; i++)
3117 {
3118 const u32 pw_len = device_param->pws_buf[i].pw_len;
3119
3120 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3121
3122 ptr[pw_len] = 0x01;
3123 }
3124 }
3125 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3126 {
3127 for (u32 i = 0; i < pws_cnt; i++)
3128 {
3129 const u32 pw_len = device_param->pws_buf[i].pw_len;
3130
3131 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3132
3133 ptr[pw_len] = 0x80;
3134 }
3135 }
3136 }
3137 }
3138 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3139 {
3140 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3141 {
3142 for (u32 i = 0; i < pws_cnt; i++)
3143 {
3144 const u32 pw_len = device_param->pws_buf[i].pw_len;
3145
3146 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3147
3148 ptr[pw_len] = 0x01;
3149 }
3150 }
3151 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3152 {
3153 for (u32 i = 0; i < pws_cnt; i++)
3154 {
3155 const u32 pw_len = device_param->pws_buf[i].pw_len;
3156
3157 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3158
3159 ptr[pw_len] = 0x80;
3160 }
3161 }
3162 }
3163
3164 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);
3165 }
3166 else if (data.attack_kern == ATTACK_KERN_BF)
3167 {
3168 const u64 off = device_param->words_off;
3169
3170 device_param->kernel_params_mp_l_buf64[3] = off;
3171
3172 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3173 }
3174 }
3175
3176 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3177 {
3178 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3179
3180 device_param->kernel_params_buf32[25] = 0;
3181 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
3182 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3183
3184 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3185 {
3186 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3187 }
3188 else
3189 {
3190 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3191 }
3192
3193 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3194
3195 return exec_ms_prev;
3196 }
3197
3198 static void autotune (hc_device_param_t *device_param)
3199 {
3200 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3201
3202 const u32 kernel_accel_min = device_param->kernel_accel_min;
3203 const u32 kernel_accel_max = device_param->kernel_accel_max;
3204
3205 const u32 kernel_loops_min = device_param->kernel_loops_min;
3206 const u32 kernel_loops_max = device_param->kernel_loops_max;
3207
3208 u32 kernel_accel = kernel_accel_min;
3209 u32 kernel_loops = kernel_loops_min;
3210
3211 // in this case the user specified a fixed -u and -n on the commandline
3212 // no way to tune anything
3213 // but we need to run a few caching rounds
3214
3215 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3216 {
3217 if (data.hash_mode != 2000)
3218 {
3219 try_run (device_param, kernel_accel, kernel_loops);
3220 try_run (device_param, kernel_accel, kernel_loops);
3221 try_run (device_param, kernel_accel, kernel_loops);
3222 try_run (device_param, kernel_accel, kernel_loops);
3223 }
3224
3225 device_param->kernel_accel = kernel_accel;
3226 device_param->kernel_loops = kernel_loops;
3227
3228 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3229
3230 device_param->kernel_power = kernel_power;
3231
3232 return;
3233 }
3234
3235 // from here it's clear we are allowed to autotune
3236 // so let's init some fake words
3237
3238 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3239
3240 if (data.attack_kern == ATTACK_KERN_BF)
3241 {
3242 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3243 }
3244 else
3245 {
3246 for (u32 i = 0; i < kernel_power_max; i++)
3247 {
3248 device_param->pws_buf[i].i[0] = i;
3249 device_param->pws_buf[i].i[1] = 0x01234567;
3250 device_param->pws_buf[i].pw_len = 7 + (i & 7);
3251 }
3252
3253 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);
3254 }
3255
3256 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3257 {
3258 if (data.kernel_rules_cnt > 1)
3259 {
3260 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);
3261 }
3262 }
3263 else
3264 {
3265 run_kernel_amp (device_param, kernel_power_max);
3266 }
3267
3268 #define VERIFIER_CNT 1
3269
3270 // first find out highest kernel-loops that stays below target_ms
3271
3272 if (kernel_loops_min < kernel_loops_max)
3273 {
3274 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3275 {
3276 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3277
3278 for (int i = 0; i < VERIFIER_CNT; i++)
3279 {
3280 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3281
3282 exec_ms = MIN (exec_ms, exec_ms_v);
3283 }
3284
3285 if (exec_ms < target_ms) break;
3286 }
3287 }
3288
3289 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3290
3291 #define STEPS_CNT 10
3292
3293 if (kernel_accel_min < kernel_accel_max)
3294 {
3295 for (int i = 0; i < STEPS_CNT; i++)
3296 {
3297 const u32 kernel_accel_try = 1 << i;
3298
3299 if (kernel_accel_try < kernel_accel_min) continue;
3300 if (kernel_accel_try > kernel_accel_max) break;
3301
3302 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3303
3304 for (int i = 0; i < VERIFIER_CNT; i++)
3305 {
3306 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3307
3308 exec_ms = MIN (exec_ms, exec_ms_v);
3309 }
3310
3311 if (exec_ms > target_ms) break;
3312
3313 kernel_accel = kernel_accel_try;
3314 }
3315 }
3316
3317 // at this point we want to know the actual runtime for the following reason:
3318 // we need a reference for the balancing loop following up, and this
3319 // the balancing loop can have an effect that the creates a new opportunity, for example:
3320 // if the target is 95 ms and the current runtime is 48ms the above loop
3321 // stopped the execution because the previous exec_ms was > 95ms
3322 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3323 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3324
3325 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3326
3327 for (int i = 0; i < VERIFIER_CNT; i++)
3328 {
3329 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3330
3331 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3332 }
3333
3334 u32 diff = kernel_loops - kernel_accel;
3335
3336 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3337 {
3338 u32 kernel_accel_orig = kernel_accel;
3339 u32 kernel_loops_orig = kernel_loops;
3340
3341 for (u32 f = 1; f < 1024; f++)
3342 {
3343 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3344 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3345
3346 if (kernel_accel_try > kernel_accel_max) break;
3347 if (kernel_loops_try < kernel_loops_min) break;
3348
3349 u32 diff_new = kernel_loops_try - kernel_accel_try;
3350
3351 if (diff_new > diff) break;
3352
3353 diff_new = diff;
3354
3355 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3356
3357 for (int i = 0; i < VERIFIER_CNT; i++)
3358 {
3359 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3360
3361 exec_ms = MIN (exec_ms, exec_ms_v);
3362 }
3363
3364 if (exec_ms < exec_ms_pre_final)
3365 {
3366 exec_ms_pre_final = exec_ms;
3367
3368 kernel_accel = kernel_accel_try;
3369 kernel_loops = kernel_loops_try;
3370 }
3371 }
3372 }
3373
3374 const double exec_left = target_ms / exec_ms_pre_final;
3375
3376 const double accel_left = kernel_accel_max / kernel_accel;
3377
3378 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3379
3380 if (exec_accel_min >= 1.0)
3381 {
3382 // this is safe to not overflow kernel_accel_max because of accel_left
3383
3384 kernel_accel = (double) kernel_accel * exec_accel_min;
3385 }
3386
3387 // reset them fake words
3388
3389 /*
3390 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3391
3392 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);
3393 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);
3394 */
3395
3396 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3397
3398 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3399 {
3400 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3401 }
3402
3403 // reset timer
3404
3405 device_param->exec_pos = 0;
3406
3407 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3408
3409 memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3410 memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3411 memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3412
3413 // store
3414
3415 device_param->kernel_accel = kernel_accel;
3416 device_param->kernel_loops = kernel_loops;
3417
3418 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3419
3420 device_param->kernel_power = kernel_power;
3421
3422 #ifdef DEBUG
3423
3424 if (data.quiet == 0)
3425 {
3426 clear_prompt ();
3427
3428 log_info ("- Device #%u: autotuned kernel-accel to %u\n"
3429 "- Device #%u: autotuned kernel-loops to %u\n",
3430 device_param->device_id + 1, kernel_accel,
3431 device_param->device_id + 1, kernel_loops);
3432
3433 fprintf (stdout, "%s", PROMPT);
3434
3435 fflush (stdout);
3436 }
3437
3438 #endif
3439 }
3440
3441 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3442 {
3443 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3444
3445 // init speed timer
3446
3447 uint speed_pos = device_param->speed_pos;
3448
3449 #ifdef _POSIX
3450 if (device_param->timer_speed.tv_sec == 0)
3451 {
3452 hc_timer_set (&device_param->timer_speed);
3453 }
3454 #endif
3455
3456 #ifdef _WIN
3457 if (device_param->timer_speed.QuadPart == 0)
3458 {
3459 hc_timer_set (&device_param->timer_speed);
3460 }
3461 #endif
3462
3463 // find higest password length, this is for optimization stuff
3464
3465 uint highest_pw_len = 0;
3466
3467 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3468 {
3469 }
3470 else if (data.attack_kern == ATTACK_KERN_COMBI)
3471 {
3472 }
3473 else if (data.attack_kern == ATTACK_KERN_BF)
3474 {
3475 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3476 + device_param->kernel_params_mp_l_buf32[5];
3477 }
3478
3479 // iteration type
3480
3481 uint innerloop_step = 0;
3482 uint innerloop_cnt = 0;
3483
3484 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3485 else innerloop_step = 1;
3486
3487 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3488 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3489 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3490
3491 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3492
3493 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3494 {
3495 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3496
3497 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3498
3499 if (data.devices_status == STATUS_CRACKED) break;
3500 if (data.devices_status == STATUS_ABORTED) break;
3501 if (data.devices_status == STATUS_QUIT) break;
3502 if (data.devices_status == STATUS_BYPASS) break;
3503
3504 salt_t *salt_buf = &data.salts_buf[salt_pos];
3505
3506 device_param->kernel_params_buf32[24] = salt_pos;
3507 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3508 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3509
3510 FILE *combs_fp = device_param->combs_fp;
3511
3512 if (data.attack_mode == ATTACK_MODE_COMBI)
3513 {
3514 rewind (combs_fp);
3515 }
3516
3517 // innerloops
3518
3519 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3520 {
3521 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3522
3523 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3524
3525 if (data.devices_status == STATUS_CRACKED) break;
3526 if (data.devices_status == STATUS_ABORTED) break;
3527 if (data.devices_status == STATUS_QUIT) break;
3528 if (data.devices_status == STATUS_BYPASS) break;
3529
3530 uint fast_iteration = 0;
3531
3532 uint innerloop_left = innerloop_cnt - innerloop_pos;
3533
3534 if (innerloop_left > innerloop_step)
3535 {
3536 innerloop_left = innerloop_step;
3537
3538 fast_iteration = 1;
3539 }
3540
3541 device_param->innerloop_pos = innerloop_pos;
3542 device_param->innerloop_left = innerloop_left;
3543
3544 device_param->kernel_params_buf32[27] = innerloop_left;
3545
3546 // i think we can get rid of this
3547 if (innerloop_left == 0)
3548 {
3549 puts ("bug, how should this happen????\n");
3550
3551 continue;
3552 }
3553
3554 if (data.salts_shown[salt_pos] == 1)
3555 {
3556 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3557
3558 continue;
3559 }
3560
3561 // initialize amplifiers
3562
3563 if (data.attack_mode == ATTACK_MODE_COMBI)
3564 {
3565 uint i = 0;
3566
3567 while (i < innerloop_left)
3568 {
3569 if (feof (combs_fp)) break;
3570
3571 int line_len = fgetl (combs_fp, line_buf);
3572
3573 if (line_len >= PW_MAX1) continue;
3574
3575 line_len = convert_from_hex (line_buf, line_len);
3576
3577 char *line_buf_new = line_buf;
3578
3579 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3580 {
3581 char rule_buf_out[BLOCK_SIZE] = { 0 };
3582
3583 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3584
3585 if (rule_len_out < 0)
3586 {
3587 data.words_progress_rejected[salt_pos] += pws_cnt;
3588
3589 continue;
3590 }
3591
3592 line_len = rule_len_out;
3593
3594 line_buf_new = rule_buf_out;
3595 }
3596
3597 line_len = MIN (line_len, PW_DICTMAX);
3598
3599 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3600
3601 memcpy (ptr, line_buf_new, line_len);
3602
3603 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3604
3605 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3606 {
3607 uppercase (ptr, line_len);
3608 }
3609
3610 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3611 {
3612 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3613 {
3614 ptr[line_len] = 0x80;
3615 }
3616
3617 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3618 {
3619 ptr[line_len] = 0x01;
3620 }
3621 }
3622
3623 device_param->combs_buf[i].pw_len = line_len;
3624
3625 i++;
3626 }
3627
3628 for (uint j = i; j < innerloop_left; j++)
3629 {
3630 device_param->combs_buf[j].i[0] = 0;
3631 device_param->combs_buf[j].i[1] = 0;
3632 device_param->combs_buf[j].i[2] = 0;
3633 device_param->combs_buf[j].i[3] = 0;
3634 device_param->combs_buf[j].i[4] = 0;
3635 device_param->combs_buf[j].i[5] = 0;
3636 device_param->combs_buf[j].i[6] = 0;
3637 device_param->combs_buf[j].i[7] = 0;
3638
3639 device_param->combs_buf[j].pw_len = 0;
3640 }
3641
3642 innerloop_left = i;
3643 }
3644 else if (data.attack_mode == ATTACK_MODE_BF)
3645 {
3646 u64 off = innerloop_pos;
3647
3648 device_param->kernel_params_mp_r_buf64[3] = off;
3649
3650 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3651 }
3652 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3653 {
3654 u64 off = innerloop_pos;
3655
3656 device_param->kernel_params_mp_buf64[3] = off;
3657
3658 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3659 }
3660 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3661 {
3662 u64 off = innerloop_pos;
3663
3664 device_param->kernel_params_mp_buf64[3] = off;
3665
3666 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3667 }
3668
3669 // copy amplifiers
3670
3671 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3672 {
3673 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);
3674 }
3675 else if (data.attack_mode == ATTACK_MODE_COMBI)
3676 {
3677 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);
3678 }
3679 else if (data.attack_mode == ATTACK_MODE_BF)
3680 {
3681 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);
3682 }
3683 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3684 {
3685 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);
3686 }
3687 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3688 {
3689 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);
3690 }
3691
3692 if (data.benchmark == 1)
3693 {
3694 hc_timer_set (&device_param->timer_speed);
3695 }
3696
3697 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
3698
3699 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3700
3701 if (data.devices_status == STATUS_CRACKED) break;
3702 if (data.devices_status == STATUS_ABORTED) break;
3703 if (data.devices_status == STATUS_QUIT) break;
3704
3705 /**
3706 * result
3707 */
3708
3709 if (data.benchmark == 0)
3710 {
3711 check_cracked (device_param, salt_pos);
3712 }
3713
3714 /**
3715 * progress
3716 */
3717
3718 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3719
3720 hc_thread_mutex_lock (mux_counter);
3721
3722 data.words_progress_done[salt_pos] += perf_sum_all;
3723
3724 hc_thread_mutex_unlock (mux_counter);
3725
3726 /**
3727 * speed
3728 */
3729
3730 double speed_ms;
3731
3732 hc_timer_get (device_param->timer_speed, speed_ms);
3733
3734 hc_timer_set (&device_param->timer_speed);
3735
3736 // current speed
3737
3738 //hc_thread_mutex_lock (mux_display);
3739
3740 device_param->speed_cnt[speed_pos] = perf_sum_all;
3741
3742 device_param->speed_ms[speed_pos] = speed_ms;
3743
3744 //hc_thread_mutex_unlock (mux_display);
3745
3746 speed_pos++;
3747
3748 if (speed_pos == SPEED_CACHE)
3749 {
3750 speed_pos = 0;
3751 }
3752
3753 /**
3754 * benchmark
3755 */
3756
3757 if (data.benchmark == 1) break;
3758 }
3759 }
3760
3761 device_param->speed_pos = speed_pos;
3762
3763 myfree (line_buf);
3764 }
3765
3766 static void load_segment (wl_data_t *wl_data, FILE *fd)
3767 {
3768 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3769
3770 wl_data->pos = 0;
3771
3772 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3773
3774 wl_data->buf[wl_data->cnt] = 0;
3775
3776 if (wl_data->cnt == 0) return;
3777
3778 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3779
3780 while (!feof (fd))
3781 {
3782 if (wl_data->cnt == wl_data->avail)
3783 {
3784 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3785
3786 wl_data->avail += wl_data->incr;
3787 }
3788
3789 const int c = fgetc (fd);
3790
3791 if (c == EOF) break;
3792
3793 wl_data->buf[wl_data->cnt] = (char) c;
3794
3795 wl_data->cnt++;
3796
3797 if (c == '\n') break;
3798 }
3799
3800 // ensure stream ends with a newline
3801
3802 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3803 {
3804 wl_data->cnt++;
3805
3806 wl_data->buf[wl_data->cnt - 1] = '\n';
3807 }
3808
3809 return;
3810 }
3811
3812 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3813 {
3814 char *ptr = buf;
3815
3816 for (u32 i = 0; i < sz; i++, ptr++)
3817 {
3818 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3819
3820 if (i == 7)
3821 {
3822 *off = i;
3823 *len = i;
3824
3825 return;
3826 }
3827
3828 if (*ptr != '\n') continue;
3829
3830 *off = i + 1;
3831
3832 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3833
3834 *len = i;
3835
3836 return;
3837 }
3838
3839 *off = sz;
3840 *len = sz;
3841 }
3842
3843 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3844 {
3845 char *ptr = buf;
3846
3847 for (u32 i = 0; i < sz; i++, ptr++)
3848 {
3849 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3850
3851 if (*ptr != '\n') continue;
3852
3853 *off = i + 1;
3854
3855 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3856
3857 *len = i;
3858
3859 return;
3860 }
3861
3862 *off = sz;
3863 *len = sz;
3864 }
3865
3866 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3867 {
3868 char *ptr = buf;
3869
3870 for (u32 i = 0; i < sz; i++, ptr++)
3871 {
3872 if (*ptr != '\n') continue;
3873
3874 *off = i + 1;
3875
3876 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3877
3878 *len = i;
3879
3880 return;
3881 }
3882
3883 *off = sz;
3884 *len = sz;
3885 }
3886
3887 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3888 {
3889 while (wl_data->pos < wl_data->cnt)
3890 {
3891 uint off;
3892 uint len;
3893
3894 char *ptr = wl_data->buf + wl_data->pos;
3895
3896 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3897
3898 wl_data->pos += off;
3899
3900 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3901 {
3902 char rule_buf_out[BLOCK_SIZE] = { 0 };
3903
3904 int rule_len_out = -1;
3905
3906 if (len < BLOCK_SIZE)
3907 {
3908 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3909 }
3910
3911 if (rule_len_out < 0)
3912 {
3913 continue;
3914 }
3915
3916 if (rule_len_out > PW_MAX)
3917 {
3918 continue;
3919 }
3920 }
3921 else
3922 {
3923 if (len > PW_MAX)
3924 {
3925 continue;
3926 }
3927 }
3928
3929 *out_buf = ptr;
3930 *out_len = len;
3931
3932 return;
3933 }
3934
3935 if (feof (fd))
3936 {
3937 fprintf (stderr, "BUG feof()!!\n");
3938
3939 return;
3940 }
3941
3942 load_segment (wl_data, fd);
3943
3944 get_next_word (wl_data, fd, out_buf, out_len);
3945 }
3946
3947 #ifdef _POSIX
3948 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3949 #endif
3950
3951 #ifdef _WIN
3952 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3953 #endif
3954 {
3955 hc_signal (NULL);
3956
3957 dictstat_t d;
3958
3959 d.cnt = 0;
3960
3961 #ifdef _POSIX
3962 fstat (fileno (fd), &d.stat);
3963 #endif
3964
3965 #ifdef _WIN
3966 _fstat64 (fileno (fd), &d.stat);
3967 #endif
3968
3969 d.stat.st_mode = 0;
3970 d.stat.st_nlink = 0;
3971 d.stat.st_uid = 0;
3972 d.stat.st_gid = 0;
3973 d.stat.st_rdev = 0;
3974 d.stat.st_atime = 0;
3975
3976 #ifdef _POSIX
3977 d.stat.st_blksize = 0;
3978 d.stat.st_blocks = 0;
3979 #endif
3980
3981 if (d.stat.st_size == 0) return 0;
3982
3983 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3984
3985 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3986 {
3987 if (d_cache)
3988 {
3989 u64 cnt = d_cache->cnt;
3990
3991 u64 keyspace = cnt;
3992
3993 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3994 {
3995 keyspace *= data.kernel_rules_cnt;
3996 }
3997 else if (data.attack_kern == ATTACK_KERN_COMBI)
3998 {
3999 keyspace *= data.combs_cnt;
4000 }
4001
4002 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);
4003 if (data.quiet == 0) log_info ("");
4004
4005 hc_signal (sigHandler_default);
4006
4007 return (keyspace);
4008 }
4009 }
4010
4011 time_t now = 0;
4012 time_t prev = 0;
4013
4014 u64 comp = 0;
4015 u64 cnt = 0;
4016 u64 cnt2 = 0;
4017
4018 while (!feof (fd))
4019 {
4020 load_segment (wl_data, fd);
4021
4022 comp += wl_data->cnt;
4023
4024 u32 i = 0;
4025
4026 while (i < wl_data->cnt)
4027 {
4028 u32 len;
4029 u32 off;
4030
4031 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
4032
4033 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4034 {
4035 char rule_buf_out[BLOCK_SIZE] = { 0 };
4036
4037 int rule_len_out = -1;
4038
4039 if (len < BLOCK_SIZE)
4040 {
4041 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
4042 }
4043
4044 if (rule_len_out < 0)
4045 {
4046 len = PW_MAX1;
4047 }
4048 else
4049 {
4050 len = rule_len_out;
4051 }
4052 }
4053
4054 if (len < PW_MAX1)
4055 {
4056 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4057 {
4058 cnt += data.kernel_rules_cnt;
4059 }
4060 else if (data.attack_kern == ATTACK_KERN_COMBI)
4061 {
4062 cnt += data.combs_cnt;
4063 }
4064
4065 d.cnt++;
4066 }
4067
4068 i += off;
4069
4070 cnt2++;
4071 }
4072
4073 time (&now);
4074
4075 if ((now - prev) == 0) continue;
4076
4077 float percent = (float) comp / (float) d.stat.st_size;
4078
4079 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);
4080
4081 time (&prev);
4082 }
4083
4084 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);
4085 if (data.quiet == 0) log_info ("");
4086
4087 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4088
4089 hc_signal (sigHandler_default);
4090
4091 return (cnt);
4092 }
4093
4094 static void *thread_monitor (void *p)
4095 {
4096 uint runtime_check = 0;
4097 uint remove_check = 0;
4098 uint status_check = 0;
4099 uint restore_check = 0;
4100
4101 uint restore_left = data.restore_timer;
4102 uint remove_left = data.remove_timer;
4103 uint status_left = data.status_timer;
4104
4105 #ifdef HAVE_HWMON
4106 uint hwmon_check = 0;
4107
4108 int slowdown_warnings = 0;
4109
4110 // these variables are mainly used for fan control
4111
4112 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4113
4114 // temperature controller "loopback" values
4115
4116 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4117 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4118
4119 int temp_threshold = 1; // degrees celcius
4120
4121 int fan_speed_min = 15; // in percentage
4122 int fan_speed_max = 100;
4123
4124 time_t last_temp_check_time;
4125 #endif // HAVE_HWMON
4126
4127 uint sleep_time = 1;
4128
4129 if (data.runtime)
4130 {
4131 runtime_check = 1;
4132 }
4133
4134 if (data.restore_timer)
4135 {
4136 restore_check = 1;
4137 }
4138
4139 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4140 {
4141 remove_check = 1;
4142 }
4143
4144 if (data.status == 1)
4145 {
4146 status_check = 1;
4147 }
4148
4149 #ifdef HAVE_HWMON
4150 if (data.gpu_temp_disable == 0)
4151 {
4152 time (&last_temp_check_time);
4153
4154 hwmon_check = 1;
4155 }
4156 #endif
4157
4158 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4159 {
4160 #ifdef HAVE_HWMON
4161 if (hwmon_check == 0)
4162 #endif
4163 return (p);
4164 }
4165
4166 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4167 {
4168 hc_sleep (sleep_time);
4169
4170 if (data.devices_status != STATUS_RUNNING) continue;
4171
4172 #ifdef HAVE_HWMON
4173
4174 if (hwmon_check == 1)
4175 {
4176 hc_thread_mutex_lock (mux_adl);
4177
4178 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4179 {
4180 hc_device_param_t *device_param = &data.devices_param[device_id];
4181
4182 if (device_param->skipped) continue;
4183
4184 if (device_param->device_vendor_id == VENDOR_ID_NV)
4185 {
4186 if (data.hm_nvapi)
4187 {
4188 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
4189 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
4190
4191 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4192 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4193
4194 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4195
4196 perfPolicies_status.info_value = perfPolicies_info.info_value;
4197
4198 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4199
4200 if (perfPolicies_status.throttle & 2)
4201 {
4202 if (slowdown_warnings < 3)
4203 {
4204 if (data.quiet == 0) clear_prompt ();
4205
4206 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4207
4208 if (slowdown_warnings == 2)
4209 {
4210 log_info ("");
4211 }
4212
4213 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4214 if (data.quiet == 0) fflush (stdout);
4215
4216 slowdown_warnings++;
4217 }
4218 }
4219 else
4220 {
4221 slowdown_warnings = 0;
4222 }
4223 }
4224 }
4225 }
4226
4227 hc_thread_mutex_unlock (mux_adl);
4228 }
4229
4230 if (hwmon_check == 1)
4231 {
4232 hc_thread_mutex_lock (mux_adl);
4233
4234 time_t temp_check_time;
4235
4236 time (&temp_check_time);
4237
4238 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4239
4240 if (Ta == 0) Ta = 1;
4241
4242 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4243 {
4244 hc_device_param_t *device_param = &data.devices_param[device_id];
4245
4246 if (device_param->skipped) continue;
4247
4248 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4249
4250 const int temperature = hm_get_temperature_with_device_id (device_id);
4251
4252 if (temperature > (int) data.gpu_temp_abort)
4253 {
4254 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4255
4256 if (data.devices_status != STATUS_QUIT) myabort ();
4257
4258 break;
4259 }
4260
4261 const int gpu_temp_retain = data.gpu_temp_retain;
4262
4263 if (gpu_temp_retain)
4264 {
4265 if (data.hm_device[device_id].fan_set_supported == 1)
4266 {
4267 int temp_cur = temperature;
4268
4269 int temp_diff_new = gpu_temp_retain - temp_cur;
4270
4271 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4272
4273 // calculate Ta value (time difference in seconds between the last check and this check)
4274
4275 last_temp_check_time = temp_check_time;
4276
4277 float Kp = 1.8;
4278 float Ki = 0.005;
4279 float Kd = 6;
4280
4281 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4282
4283 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);
4284
4285 if (abs (fan_diff_required) >= temp_threshold)
4286 {
4287 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4288
4289 int fan_speed_level = fan_speed_cur;
4290
4291 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4292
4293 int fan_speed_new = fan_speed_level - fan_diff_required;
4294
4295 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4296 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4297
4298 if (fan_speed_new != fan_speed_cur)
4299 {
4300 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4301 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4302
4303 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4304 {
4305 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4306 {
4307 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4308 }
4309 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4310 {
4311 #ifdef WIN
4312 hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1);
4313 #endif
4314
4315 #ifdef LINUX
4316 hm_set_fanspeed_with_device_id_xnvctrl (device_id, fan_speed_new);
4317 #endif
4318 }
4319
4320 fan_speed_chgd[device_id] = 1;
4321 }
4322
4323 temp_diff_old[device_id] = temp_diff_new;
4324 }
4325 }
4326 }
4327 }
4328 }
4329
4330 hc_thread_mutex_unlock (mux_adl);
4331 }
4332 #endif // HAVE_HWMON
4333
4334 if (restore_check == 1)
4335 {
4336 restore_left--;
4337
4338 if (restore_left == 0)
4339 {
4340 if (data.restore_disable == 0) cycle_restore ();
4341
4342 restore_left = data.restore_timer;
4343 }
4344 }
4345
4346 if ((runtime_check == 1) && (data.runtime_start > 0))
4347 {
4348 time_t runtime_cur;
4349
4350 time (&runtime_cur);
4351
4352 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4353
4354 if (runtime_left <= 0)
4355 {
4356 if (data.benchmark == 0)
4357 {
4358 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4359 }
4360
4361 if (data.devices_status != STATUS_QUIT) myabort ();
4362 }
4363 }
4364
4365 if (remove_check == 1)
4366 {
4367 remove_left--;
4368
4369 if (remove_left == 0)
4370 {
4371 if (data.digests_saved != data.digests_done)
4372 {
4373 data.digests_saved = data.digests_done;
4374
4375 save_hash ();
4376 }
4377
4378 remove_left = data.remove_timer;
4379 }
4380 }
4381
4382 if (status_check == 1)
4383 {
4384 status_left--;
4385
4386 if (status_left == 0)
4387 {
4388 //hc_thread_mutex_lock (mux_display);
4389
4390 if (data.quiet == 0) clear_prompt ();
4391
4392 if (data.quiet == 0) log_info ("");
4393
4394 status_display ();
4395
4396 if (data.quiet == 0) log_info ("");
4397
4398 //hc_thread_mutex_unlock (mux_display);
4399
4400 status_left = data.status_timer;
4401 }
4402 }
4403 }
4404
4405 #ifdef HAVE_HWMON
4406 myfree (fan_speed_chgd);
4407
4408 myfree (temp_diff_old);
4409 myfree (temp_diff_sum);
4410 #endif
4411
4412 p = NULL;
4413
4414 return (p);
4415 }
4416
4417 static void *thread_outfile_remove (void *p)
4418 {
4419 // some hash-dependent constants
4420 char *outfile_dir = data.outfile_check_directory;
4421 uint dgst_size = data.dgst_size;
4422 uint isSalted = data.isSalted;
4423 uint esalt_size = data.esalt_size;
4424 uint hash_mode = data.hash_mode;
4425
4426 uint outfile_check_timer = data.outfile_check_timer;
4427
4428 char separator = data.separator;
4429
4430 // some hash-dependent functions
4431 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4432 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4433
4434 // buffers
4435 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4436
4437 hash_buf.digest = mymalloc (dgst_size);
4438
4439 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4440
4441 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4442
4443 uint digest_buf[64] = { 0 };
4444
4445 outfile_data_t *out_info = NULL;
4446
4447 char **out_files = NULL;
4448
4449 time_t folder_mtime = 0;
4450
4451 int out_cnt = 0;
4452
4453 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4454
4455 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4456 {
4457 hc_sleep (1);
4458
4459 if (data.devices_status != STATUS_RUNNING) continue;
4460
4461 check_left--;
4462
4463 if (check_left == 0)
4464 {
4465 struct stat outfile_check_stat;
4466
4467 if (stat (outfile_dir, &outfile_check_stat) == 0)
4468 {
4469 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4470
4471 if (is_dir == 1)
4472 {
4473 if (outfile_check_stat.st_mtime > folder_mtime)
4474 {
4475 char **out_files_new = scan_directory (outfile_dir);
4476
4477 int out_cnt_new = count_dictionaries (out_files_new);
4478
4479 outfile_data_t *out_info_new = NULL;
4480
4481 if (out_cnt_new > 0)
4482 {
4483 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4484
4485 for (int i = 0; i < out_cnt_new; i++)
4486 {
4487 out_info_new[i].file_name = out_files_new[i];
4488
4489 // check if there are files that we have seen/checked before (and not changed)
4490
4491 for (int j = 0; j < out_cnt; j++)
4492 {
4493 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4494 {
4495 struct stat outfile_stat;
4496
4497 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4498 {
4499 if (outfile_stat.st_ctime == out_info[j].ctime)
4500 {
4501 out_info_new[i].ctime = out_info[j].ctime;
4502 out_info_new[i].seek = out_info[j].seek;
4503 }
4504 }
4505 }
4506 }
4507 }
4508 }
4509
4510 local_free (out_info);
4511 local_free (out_files);
4512
4513 out_files = out_files_new;
4514 out_cnt = out_cnt_new;
4515 out_info = out_info_new;
4516
4517 folder_mtime = outfile_check_stat.st_mtime;
4518 }
4519
4520 for (int j = 0; j < out_cnt; j++)
4521 {
4522 FILE *fp = fopen (out_info[j].file_name, "rb");
4523
4524 if (fp != NULL)
4525 {
4526 //hc_thread_mutex_lock (mux_display);
4527
4528 #ifdef _POSIX
4529 struct stat outfile_stat;
4530
4531 fstat (fileno (fp), &outfile_stat);
4532 #endif
4533
4534 #ifdef _WIN
4535 struct stat64 outfile_stat;
4536
4537 _fstat64 (fileno (fp), &outfile_stat);
4538 #endif
4539
4540 if (outfile_stat.st_ctime > out_info[j].ctime)
4541 {
4542 out_info[j].ctime = outfile_stat.st_ctime;
4543 out_info[j].seek = 0;
4544 }
4545
4546 fseek (fp, out_info[j].seek, SEEK_SET);
4547
4548 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4549
4550 while (!feof (fp))
4551 {
4552 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4553
4554 if (ptr == NULL) break;
4555
4556 int line_len = strlen (line_buf);
4557
4558 if (line_len <= 0) continue;
4559
4560 int iter = MAX_CUT_TRIES;
4561
4562 for (uint i = line_len - 1; i && iter; i--, line_len--)
4563 {
4564 if (line_buf[i] != separator) continue;
4565
4566 int parser_status = PARSER_OK;
4567
4568 if ((hash_mode != 2500) && (hash_mode != 6800))
4569 {
4570 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4571 }
4572
4573 uint found = 0;
4574
4575 if (parser_status == PARSER_OK)
4576 {
4577 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4578 {
4579 if (data.salts_shown[salt_pos] == 1) continue;
4580
4581 salt_t *salt_buf = &data.salts_buf[salt_pos];
4582
4583 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4584 {
4585 uint idx = salt_buf->digests_offset + digest_pos;
4586
4587 if (data.digests_shown[idx] == 1) continue;
4588
4589 uint cracked = 0;
4590
4591 if (hash_mode == 6800)
4592 {
4593 if (i == salt_buf->salt_len)
4594 {
4595 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4596 }
4597 }
4598 else if (hash_mode == 2500)
4599 {
4600 // BSSID : MAC1 : MAC2 (:plain)
4601 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4602 {
4603 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4604
4605 if (!cracked) continue;
4606
4607 // now compare MAC1 and MAC2 too, since we have this additional info
4608 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4609 char *mac2_pos = mac1_pos + 12 + 1;
4610
4611 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4612 wpa_t *wpa = &wpas[salt_pos];
4613
4614 // compare hex string(s) vs binary MAC address(es)
4615
4616 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4617 {
4618 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4619 {
4620 cracked = 0;
4621
4622 break;
4623 }
4624 }
4625
4626 // early skip ;)
4627 if (!cracked) continue;
4628
4629 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4630 {
4631 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4632 {
4633 cracked = 0;
4634
4635 break;
4636 }
4637 }
4638 }
4639 }
4640 else
4641 {
4642 char *digests_buf_ptr = (char *) data.digests_buf;
4643
4644 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4645
4646 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4647 }
4648
4649 if (cracked == 1)
4650 {
4651 found = 1;
4652
4653 data.digests_shown[idx] = 1;
4654
4655 data.digests_done++;
4656
4657 salt_buf->digests_done++;
4658
4659 if (salt_buf->digests_done == salt_buf->digests_cnt)
4660 {
4661 data.salts_shown[salt_pos] = 1;
4662
4663 data.salts_done++;
4664
4665 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4666 }
4667 }
4668 }
4669
4670 if (data.devices_status == STATUS_CRACKED) break;
4671 }
4672 }
4673
4674 if (found) break;
4675
4676 if (data.devices_status == STATUS_CRACKED) break;
4677
4678 iter--;
4679 }
4680
4681 if (data.devices_status == STATUS_CRACKED) break;
4682 }
4683
4684 myfree (line_buf);
4685
4686 out_info[j].seek = ftell (fp);
4687
4688 //hc_thread_mutex_unlock (mux_display);
4689
4690 fclose (fp);
4691 }
4692 }
4693 }
4694 }
4695
4696 check_left = outfile_check_timer;
4697 }
4698 }
4699
4700 if (esalt_size) local_free (hash_buf.esalt);
4701
4702 if (isSalted) local_free (hash_buf.salt);
4703
4704 local_free (hash_buf.digest);
4705
4706 local_free (out_info);
4707
4708 local_free (out_files);
4709
4710 p = NULL;
4711
4712 return (p);
4713 }
4714
4715 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4716 {
4717 //if (device_param->pws_cnt < device_param->kernel_power)
4718 //{
4719 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4720
4721 u8 *ptr = (u8 *) pw->i;
4722
4723 memcpy (ptr, pw_buf, pw_len);
4724
4725 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4726
4727 pw->pw_len = pw_len;
4728
4729 device_param->pws_cnt++;
4730 //}
4731 //else
4732 //{
4733 // fprintf (stderr, "BUG pw_add()!!\n");
4734 //
4735 // return;
4736 //}
4737 }
4738
4739 static void set_kernel_power_final (const u64 kernel_power_final)
4740 {
4741 if (data.quiet == 0)
4742 {
4743 clear_prompt ();
4744
4745 //log_info ("");
4746
4747 log_info ("INFO: approaching final keyspace, workload adjusted");
4748 log_info ("");
4749
4750 fprintf (stdout, "%s", PROMPT);
4751
4752 fflush (stdout);
4753 }
4754
4755 data.kernel_power_final = kernel_power_final;
4756 }
4757
4758 static u32 get_power (hc_device_param_t *device_param)
4759 {
4760 const u64 kernel_power_final = data.kernel_power_final;
4761
4762 if (kernel_power_final)
4763 {
4764 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4765
4766 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4767
4768 // work should be at least the hardware power available without any accelerator
4769
4770 const u64 work = MAX (words_left_device, device_param->hardware_power);
4771
4772 return work;
4773 }
4774
4775 return device_param->kernel_power;
4776 }
4777
4778 static uint get_work (hc_device_param_t *device_param, const u64 max)
4779 {
4780 hc_thread_mutex_lock (mux_dispatcher);
4781
4782 const u64 words_cur = data.words_cur;
4783 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4784
4785 device_param->words_off = words_cur;
4786
4787 const u64 kernel_power_all = data.kernel_power_all;
4788
4789 const u64 words_left = words_base - words_cur;
4790
4791 if (words_left < kernel_power_all)
4792 {
4793 if (data.kernel_power_final == 0)
4794 {
4795 set_kernel_power_final (words_left);
4796 }
4797 }
4798
4799 const u32 kernel_power = get_power (device_param);
4800
4801 uint work = MIN (words_left, kernel_power);
4802
4803 work = MIN (work, max);
4804
4805 data.words_cur += work;
4806
4807 hc_thread_mutex_unlock (mux_dispatcher);
4808
4809 return work;
4810 }
4811
4812 static void *thread_autotune (void *p)
4813 {
4814 hc_device_param_t *device_param = (hc_device_param_t *) p;
4815
4816 if (device_param->skipped) return NULL;
4817
4818 autotune (device_param);
4819
4820 return NULL;
4821 }
4822
4823 static void *thread_calc_stdin (void *p)
4824 {
4825 hc_device_param_t *device_param = (hc_device_param_t *) p;
4826
4827 if (device_param->skipped) return NULL;
4828
4829 char *buf = (char *) mymalloc (HCBUFSIZ);
4830
4831 const uint attack_kern = data.attack_kern;
4832
4833 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4834 {
4835 hc_thread_mutex_lock (mux_dispatcher);
4836
4837 if (feof (stdin) != 0)
4838 {
4839 hc_thread_mutex_unlock (mux_dispatcher);
4840
4841 break;
4842 }
4843
4844 uint words_cur = 0;
4845
4846 while (words_cur < device_param->kernel_power)
4847 {
4848 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4849
4850 if (line_buf == NULL) break;
4851
4852 uint line_len = in_superchop (line_buf);
4853
4854 line_len = convert_from_hex (line_buf, line_len);
4855
4856 // post-process rule engine
4857
4858 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4859 {
4860 char rule_buf_out[BLOCK_SIZE] = { 0 };
4861
4862 int rule_len_out = -1;
4863
4864 if (line_len < BLOCK_SIZE)
4865 {
4866 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4867 }
4868
4869 if (rule_len_out < 0) continue;
4870
4871 line_buf = rule_buf_out;
4872 line_len = rule_len_out;
4873 }
4874
4875 if (line_len > PW_MAX)
4876 {
4877 continue;
4878 }
4879
4880 // hmm that's always the case, or?
4881
4882 if (attack_kern == ATTACK_KERN_STRAIGHT)
4883 {
4884 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4885 {
4886 hc_thread_mutex_lock (mux_counter);
4887
4888 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4889 {
4890 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4891 }
4892
4893 hc_thread_mutex_unlock (mux_counter);
4894
4895 continue;
4896 }
4897 }
4898
4899 pw_add (device_param, (u8 *) line_buf, line_len);
4900
4901 words_cur++;
4902
4903 if (data.devices_status == STATUS_CRACKED) break;
4904 if (data.devices_status == STATUS_ABORTED) break;
4905 if (data.devices_status == STATUS_QUIT) break;
4906 if (data.devices_status == STATUS_BYPASS) break;
4907 }
4908
4909 hc_thread_mutex_unlock (mux_dispatcher);
4910
4911 if (data.devices_status == STATUS_CRACKED) break;
4912 if (data.devices_status == STATUS_ABORTED) break;
4913 if (data.devices_status == STATUS_QUIT) break;
4914 if (data.devices_status == STATUS_BYPASS) break;
4915
4916 // flush
4917
4918 const uint pws_cnt = device_param->pws_cnt;
4919
4920 if (pws_cnt)
4921 {
4922 run_copy (device_param, pws_cnt);
4923
4924 run_cracker (device_param, pws_cnt);
4925
4926 device_param->pws_cnt = 0;
4927
4928 /*
4929 still required?
4930 if (attack_kern == ATTACK_KERN_STRAIGHT)
4931 {
4932 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4933 }
4934 else if (attack_kern == ATTACK_KERN_COMBI)
4935 {
4936 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4937 }
4938 */
4939 }
4940 }
4941
4942 device_param->kernel_accel = 0;
4943 device_param->kernel_loops = 0;
4944
4945 myfree (buf);
4946
4947 return NULL;
4948 }
4949
4950 static void *thread_calc (void *p)
4951 {
4952 hc_device_param_t *device_param = (hc_device_param_t *) p;
4953
4954 if (device_param->skipped) return NULL;
4955
4956 const uint attack_mode = data.attack_mode;
4957 const uint attack_kern = data.attack_kern;
4958
4959 if (attack_mode == ATTACK_MODE_BF)
4960 {
4961 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4962 {
4963 const uint work = get_work (device_param, -1);
4964
4965 if (work == 0) break;
4966
4967 const u64 words_off = device_param->words_off;
4968 const u64 words_fin = words_off + work;
4969
4970 const uint pws_cnt = work;
4971
4972 device_param->pws_cnt = pws_cnt;
4973
4974 if (pws_cnt)
4975 {
4976 run_copy (device_param, pws_cnt);
4977
4978 run_cracker (device_param, pws_cnt);
4979
4980 device_param->pws_cnt = 0;
4981
4982 /*
4983 still required?
4984 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4985 */
4986 }
4987
4988 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4989
4990 if (data.devices_status == STATUS_CRACKED) break;
4991 if (data.devices_status == STATUS_ABORTED) break;
4992 if (data.devices_status == STATUS_QUIT) break;
4993 if (data.devices_status == STATUS_BYPASS) break;
4994
4995 if (data.benchmark == 1) break;
4996
4997 device_param->words_done = words_fin;
4998 }
4999 }
5000 else
5001 {
5002 const uint segment_size = data.segment_size;
5003
5004 char *dictfile = data.dictfile;
5005
5006 if (attack_mode == ATTACK_MODE_COMBI)
5007 {
5008 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5009 {
5010 dictfile = data.dictfile2;
5011 }
5012 }
5013
5014 FILE *fd = fopen (dictfile, "rb");
5015
5016 if (fd == NULL)
5017 {
5018 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
5019
5020 return NULL;
5021 }
5022
5023 if (attack_mode == ATTACK_MODE_COMBI)
5024 {
5025 const uint combs_mode = data.combs_mode;
5026
5027 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
5028 {
5029 const char *dictfilec = data.dictfile2;
5030
5031 FILE *combs_fp = fopen (dictfilec, "rb");
5032
5033 if (combs_fp == NULL)
5034 {
5035 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5036
5037 fclose (fd);
5038
5039 return NULL;
5040 }
5041
5042 device_param->combs_fp = combs_fp;
5043 }
5044 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5045 {
5046 const char *dictfilec = data.dictfile;
5047
5048 FILE *combs_fp = fopen (dictfilec, "rb");
5049
5050 if (combs_fp == NULL)
5051 {
5052 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5053
5054 fclose (fd);
5055
5056 return NULL;
5057 }
5058
5059 device_param->combs_fp = combs_fp;
5060 }
5061 }
5062
5063 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
5064
5065 wl_data->buf = (char *) mymalloc (segment_size);
5066 wl_data->avail = segment_size;
5067 wl_data->incr = segment_size;
5068 wl_data->cnt = 0;
5069 wl_data->pos = 0;
5070
5071 u64 words_cur = 0;
5072
5073 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5074 {
5075 u64 words_off = 0;
5076 u64 words_fin = 0;
5077
5078 u64 max = -1;
5079
5080 while (max)
5081 {
5082 const uint work = get_work (device_param, max);
5083
5084 if (work == 0) break;
5085
5086 max = 0;
5087
5088 words_off = device_param->words_off;
5089 words_fin = words_off + work;
5090
5091 char *line_buf;
5092 uint line_len;
5093
5094 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5095
5096 for ( ; words_cur < words_fin; words_cur++)
5097 {
5098 get_next_word (wl_data, fd, &line_buf, &line_len);
5099
5100 line_len = convert_from_hex (line_buf, line_len);
5101
5102 // post-process rule engine
5103
5104 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5105 {
5106 char rule_buf_out[BLOCK_SIZE] = { 0 };
5107
5108 int rule_len_out = -1;
5109
5110 if (line_len < BLOCK_SIZE)
5111 {
5112 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5113 }
5114
5115 if (rule_len_out < 0) continue;
5116
5117 line_buf = rule_buf_out;
5118 line_len = rule_len_out;
5119 }
5120
5121 if (attack_kern == ATTACK_KERN_STRAIGHT)
5122 {
5123 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5124 {
5125 max++;
5126
5127 hc_thread_mutex_lock (mux_counter);
5128
5129 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5130 {
5131 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5132 }
5133
5134 hc_thread_mutex_unlock (mux_counter);
5135
5136 continue;
5137 }
5138 }
5139 else if (attack_kern == ATTACK_KERN_COMBI)
5140 {
5141 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5142 // since we still need to combine the plains
5143
5144 if (line_len > data.pw_max)
5145 {
5146 max++;
5147
5148 hc_thread_mutex_lock (mux_counter);
5149
5150 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5151 {
5152 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5153 }
5154
5155 hc_thread_mutex_unlock (mux_counter);
5156
5157 continue;
5158 }
5159 }
5160
5161 pw_add (device_param, (u8 *) line_buf, line_len);
5162
5163 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5164
5165 if (data.devices_status == STATUS_CRACKED) break;
5166 if (data.devices_status == STATUS_ABORTED) break;
5167 if (data.devices_status == STATUS_QUIT) break;
5168 if (data.devices_status == STATUS_BYPASS) break;
5169 }
5170
5171 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5172
5173 if (data.devices_status == STATUS_CRACKED) break;
5174 if (data.devices_status == STATUS_ABORTED) break;
5175 if (data.devices_status == STATUS_QUIT) break;
5176 if (data.devices_status == STATUS_BYPASS) break;
5177 }
5178
5179 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5180
5181 if (data.devices_status == STATUS_CRACKED) break;
5182 if (data.devices_status == STATUS_ABORTED) break;
5183 if (data.devices_status == STATUS_QUIT) break;
5184 if (data.devices_status == STATUS_BYPASS) break;
5185
5186 //
5187 // flush
5188 //
5189
5190 const uint pws_cnt = device_param->pws_cnt;
5191
5192 if (pws_cnt)
5193 {
5194 run_copy (device_param, pws_cnt);
5195
5196 run_cracker (device_param, pws_cnt);
5197
5198 device_param->pws_cnt = 0;
5199
5200 /*
5201 still required?
5202 if (attack_kern == ATTACK_KERN_STRAIGHT)
5203 {
5204 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5205 }
5206 else if (attack_kern == ATTACK_KERN_COMBI)
5207 {
5208 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5209 }
5210 */
5211 }
5212
5213 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5214
5215 if (data.devices_status == STATUS_CRACKED) break;
5216 if (data.devices_status == STATUS_ABORTED) break;
5217 if (data.devices_status == STATUS_QUIT) break;
5218 if (data.devices_status == STATUS_BYPASS) break;
5219
5220 if (words_fin == 0) break;
5221
5222 device_param->words_done = words_fin;
5223 }
5224
5225 if (attack_mode == ATTACK_MODE_COMBI)
5226 {
5227 fclose (device_param->combs_fp);
5228 }
5229
5230 free (wl_data->buf);
5231 free (wl_data);
5232
5233 fclose (fd);
5234 }
5235
5236 device_param->kernel_accel = 0;
5237 device_param->kernel_loops = 0;
5238
5239 return NULL;
5240 }
5241
5242 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5243 {
5244 if (!device_param)
5245 {
5246 log_error ("ERROR: %s : Invalid argument", __func__);
5247
5248 exit (-1);
5249 }
5250
5251 salt_t *salt_buf = &data.salts_buf[salt_pos];
5252
5253 device_param->kernel_params_buf32[24] = salt_pos;
5254 device_param->kernel_params_buf32[27] = 1;
5255 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
5256 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
5257 device_param->kernel_params_buf32[30] = 0;
5258 device_param->kernel_params_buf32[31] = 1;
5259
5260 char *dictfile_old = data.dictfile;
5261
5262 const char *weak_hash_check = "weak-hash-check";
5263
5264 data.dictfile = (char *) weak_hash_check;
5265
5266 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5267
5268 data.kernel_rules_buf[0].cmds[0] = 0;
5269
5270 /**
5271 * run the kernel
5272 */
5273
5274 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5275 {
5276 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5277 }
5278 else
5279 {
5280 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5281
5282 uint loop_step = 16;
5283
5284 const uint iter = salt_buf->salt_iter;
5285
5286 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5287 {
5288 uint loop_left = iter - loop_pos;
5289
5290 loop_left = MIN (loop_left, loop_step);
5291
5292 device_param->kernel_params_buf32[25] = loop_pos;
5293 device_param->kernel_params_buf32[26] = loop_left;
5294
5295 run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5296 }
5297
5298 run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5299 }
5300
5301 /**
5302 * result
5303 */
5304
5305 check_cracked (device_param, salt_pos);
5306
5307 /**
5308 * cleanup
5309 */
5310
5311 device_param->kernel_params_buf32[24] = 0;
5312 device_param->kernel_params_buf32[25] = 0;
5313 device_param->kernel_params_buf32[26] = 0;
5314 device_param->kernel_params_buf32[27] = 0;
5315 device_param->kernel_params_buf32[28] = 0;
5316 device_param->kernel_params_buf32[29] = 0;
5317 device_param->kernel_params_buf32[30] = 0;
5318 device_param->kernel_params_buf32[31] = 0;
5319
5320 data.dictfile = dictfile_old;
5321
5322 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5323 }
5324
5325 // hlfmt hashcat
5326
5327 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5328 {
5329 if (data.username == 0)
5330 {
5331 *hashbuf_pos = line_buf;
5332 *hashbuf_len = line_len;
5333 }
5334 else
5335 {
5336 char *pos = line_buf;
5337 int len = line_len;
5338
5339 for (int i = 0; i < line_len; i++, pos++, len--)
5340 {
5341 if (line_buf[i] == data.separator)
5342 {
5343 pos++;
5344
5345 len--;
5346
5347 break;
5348 }
5349 }
5350
5351 *hashbuf_pos = pos;
5352 *hashbuf_len = len;
5353 }
5354 }
5355
5356 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5357 {
5358 char *pos = NULL;
5359 int len = 0;
5360
5361 int sep_cnt = 0;
5362
5363 for (int i = 0; i < line_len; i++)
5364 {
5365 if (line_buf[i] == data.separator)
5366 {
5367 sep_cnt++;
5368
5369 continue;
5370 }
5371
5372 if (sep_cnt == 0)
5373 {
5374 if (pos == NULL) pos = line_buf + i;
5375
5376 len++;
5377 }
5378 }
5379
5380 *userbuf_pos = pos;
5381 *userbuf_len = len;
5382 }
5383
5384 // hlfmt pwdump
5385
5386 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5387 {
5388 int sep_cnt = 0;
5389
5390 int sep2_len = 0;
5391 int sep3_len = 0;
5392
5393 for (int i = 0; i < line_len; i++)
5394 {
5395 if (line_buf[i] == ':')
5396 {
5397 sep_cnt++;
5398
5399 continue;
5400 }
5401
5402 if (sep_cnt == 2) sep2_len++;
5403 if (sep_cnt == 3) sep3_len++;
5404 }
5405
5406 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5407
5408 return 0;
5409 }
5410
5411 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5412 {
5413 char *pos = NULL;
5414 int len = 0;
5415
5416 int sep_cnt = 0;
5417
5418 for (int i = 0; i < line_len; i++)
5419 {
5420 if (line_buf[i] == ':')
5421 {
5422 sep_cnt++;
5423
5424 continue;
5425 }
5426
5427 if (data.hash_mode == 1000)
5428 {
5429 if (sep_cnt == 3)
5430 {
5431 if (pos == NULL) pos = line_buf + i;
5432
5433 len++;
5434 }
5435 }
5436 else if (data.hash_mode == 3000)
5437 {
5438 if (sep_cnt == 2)
5439 {
5440 if (pos == NULL) pos = line_buf + i;
5441
5442 len++;
5443 }
5444 }
5445 }
5446
5447 *hashbuf_pos = pos;
5448 *hashbuf_len = len;
5449 }
5450
5451 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5452 {
5453 char *pos = NULL;
5454 int len = 0;
5455
5456 int sep_cnt = 0;
5457
5458 for (int i = 0; i < line_len; i++)
5459 {
5460 if (line_buf[i] == ':')
5461 {
5462 sep_cnt++;
5463
5464 continue;
5465 }
5466
5467 if (sep_cnt == 0)
5468 {
5469 if (pos == NULL) pos = line_buf + i;
5470
5471 len++;
5472 }
5473 }
5474
5475 *userbuf_pos = pos;
5476 *userbuf_len = len;
5477 }
5478
5479 // hlfmt passwd
5480
5481 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5482 {
5483 int sep_cnt = 0;
5484
5485 char sep5_first = 0;
5486 char sep6_first = 0;
5487
5488 for (int i = 0; i < line_len; i++)
5489 {
5490 if (line_buf[i] == ':')
5491 {
5492 sep_cnt++;
5493
5494 continue;
5495 }
5496
5497 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5498 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5499 }
5500
5501 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5502
5503 return 0;
5504 }
5505
5506 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5507 {
5508 char *pos = NULL;
5509 int len = 0;
5510
5511 int sep_cnt = 0;
5512
5513 for (int i = 0; i < line_len; i++)
5514 {
5515 if (line_buf[i] == ':')
5516 {
5517 sep_cnt++;
5518
5519 continue;
5520 }
5521
5522 if (sep_cnt == 1)
5523 {
5524 if (pos == NULL) pos = line_buf + i;
5525
5526 len++;
5527 }
5528 }
5529
5530 *hashbuf_pos = pos;
5531 *hashbuf_len = len;
5532 }
5533
5534 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5535 {
5536 char *pos = NULL;
5537 int len = 0;
5538
5539 int sep_cnt = 0;
5540
5541 for (int i = 0; i < line_len; i++)
5542 {
5543 if (line_buf[i] == ':')
5544 {
5545 sep_cnt++;
5546
5547 continue;
5548 }
5549
5550 if (sep_cnt == 0)
5551 {
5552 if (pos == NULL) pos = line_buf + i;
5553
5554 len++;
5555 }
5556 }
5557
5558 *userbuf_pos = pos;
5559 *userbuf_len = len;
5560 }
5561
5562 // hlfmt shadow
5563
5564 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5565 {
5566 int sep_cnt = 0;
5567
5568 for (int i = 0; i < line_len; i++)
5569 {
5570 if (line_buf[i] == ':') sep_cnt++;
5571 }
5572
5573 if (sep_cnt == 8) return 1;
5574
5575 return 0;
5576 }
5577
5578 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5579 {
5580 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5581 }
5582
5583 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5584 {
5585 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5586 }
5587
5588 // hlfmt main
5589
5590 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5591 {
5592 switch (hashfile_format)
5593 {
5594 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5595 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5596 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5597 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5598 }
5599 }
5600
5601 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5602 {
5603 switch (hashfile_format)
5604 {
5605 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5606 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5607 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5608 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5609 }
5610 }
5611
5612 char *strhlfmt (const uint hashfile_format)
5613 {
5614 switch (hashfile_format)
5615 {
5616 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5617 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5618 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5619 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5620 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5621 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5622 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5623 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5624 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5625 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5626 }
5627
5628 return ((char *) "Unknown");
5629 }
5630
5631 static uint hlfmt_detect (FILE *fp, uint max_check)
5632 {
5633 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5634
5635 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5636 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5637
5638 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5639
5640 uint num_check = 0;
5641
5642 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5643
5644 while (!feof (fp))
5645 {
5646 int line_len = fgetl (fp, line_buf);
5647
5648 if (line_len == 0) continue;
5649
5650 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5651 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5652 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5653
5654 if (num_check == max_check) break;
5655
5656 num_check++;
5657 }
5658
5659 myfree (line_buf);
5660
5661 uint hashlist_format = HLFMT_HASHCAT;
5662
5663 for (int i = 1; i < HLFMTS_CNT; i++)
5664 {
5665 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5666
5667 hashlist_format = i;
5668 }
5669
5670 free (formats_cnt);
5671
5672 return hashlist_format;
5673 }
5674
5675 /**
5676 * some further helper function
5677 */
5678
5679 // wrapper around mymalloc for ADL
5680
5681 #if defined(HAVE_HWMON)
5682 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5683 {
5684 return mymalloc (iSize);
5685 }
5686 #endif
5687
5688 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)
5689 {
5690 u64 collisions = 0;
5691
5692 const uint dgst_pos0 = data.dgst_pos0;
5693 const uint dgst_pos1 = data.dgst_pos1;
5694 const uint dgst_pos2 = data.dgst_pos2;
5695 const uint dgst_pos3 = data.dgst_pos3;
5696
5697 memset (bitmap_a, 0, bitmap_size);
5698 memset (bitmap_b, 0, bitmap_size);
5699 memset (bitmap_c, 0, bitmap_size);
5700 memset (bitmap_d, 0, bitmap_size);
5701
5702 for (uint i = 0; i < digests_cnt; i++)
5703 {
5704 uint *digest_ptr = (uint *) digests_buf_ptr;
5705
5706 digests_buf_ptr += dgst_size;
5707
5708 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5709 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5710 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5711 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5712
5713 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5714 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5715 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5716 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5717
5718 if (bitmap_a[idx0] & val0) collisions++;
5719 if (bitmap_b[idx1] & val1) collisions++;
5720 if (bitmap_c[idx2] & val2) collisions++;
5721 if (bitmap_d[idx3] & val3) collisions++;
5722
5723 bitmap_a[idx0] |= val0;
5724 bitmap_b[idx1] |= val1;
5725 bitmap_c[idx2] |= val2;
5726 bitmap_d[idx3] |= val3;
5727
5728 if (collisions >= collisions_max) return 0x7fffffff;
5729 }
5730
5731 return collisions;
5732 }
5733
5734 /**
5735 * main
5736 */
5737
5738 #ifdef WIN
5739 void SetConsoleWindowSize (const int x)
5740 {
5741 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5742
5743 if (h == INVALID_HANDLE_VALUE) return;
5744
5745 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5746
5747 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5748
5749 SMALL_RECT *sr = &bufferInfo.srWindow;
5750
5751 sr->Right = MAX (sr->Right, x - 1);
5752
5753 COORD co;
5754
5755 co.X = sr->Right + 1;
5756 co.Y = 9999;
5757
5758 if (!SetConsoleScreenBufferSize (h, co)) return;
5759
5760 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5761 }
5762 #endif
5763
5764 int main (int argc, char **argv)
5765 {
5766 #ifdef WIN
5767 SetConsoleWindowSize (132);
5768 #endif
5769
5770 /**
5771 * To help users a bit
5772 */
5773
5774 char *compute = getenv ("COMPUTE");
5775
5776 if (compute)
5777 {
5778 static char display[100];
5779
5780 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5781
5782 putenv (display);
5783 }
5784 else
5785 {
5786 if (getenv ("DISPLAY") == NULL)
5787 putenv ((char *) "DISPLAY=:0");
5788 }
5789
5790 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5791 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5792
5793 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5794 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5795
5796 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5797 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5798
5799 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5800 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5801
5802 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5803 putenv ((char *) "POCL_KERNEL_CACHE=0");
5804
5805 umask (077);
5806
5807 /**
5808 * Real init
5809 */
5810
5811 memset (&data, 0, sizeof (hc_global_data_t));
5812
5813 time_t proc_start;
5814
5815 time (&proc_start);
5816
5817 data.proc_start = proc_start;
5818
5819 int myargc = argc;
5820 char **myargv = argv;
5821
5822 hc_thread_mutex_init (mux_dispatcher);
5823 hc_thread_mutex_init (mux_counter);
5824 hc_thread_mutex_init (mux_display);
5825 hc_thread_mutex_init (mux_adl);
5826
5827 /**
5828 * commandline parameters
5829 */
5830
5831 uint usage = USAGE;
5832 uint version = VERSION;
5833 uint quiet = QUIET;
5834 uint benchmark = BENCHMARK;
5835 uint stdout_flag = STDOUT_FLAG;
5836 uint show = SHOW;
5837 uint left = LEFT;
5838 uint username = USERNAME;
5839 uint remove = REMOVE;
5840 uint remove_timer = REMOVE_TIMER;
5841 u64 skip = SKIP;
5842 u64 limit = LIMIT;
5843 uint keyspace = KEYSPACE;
5844 uint potfile_disable = POTFILE_DISABLE;
5845 char *potfile_path = NULL;
5846 uint debug_mode = DEBUG_MODE;
5847 char *debug_file = NULL;
5848 char *induction_dir = NULL;
5849 char *outfile_check_dir = NULL;
5850 uint force = FORCE;
5851 uint runtime = RUNTIME;
5852 uint hash_mode = HASH_MODE;
5853 uint attack_mode = ATTACK_MODE;
5854 uint markov_disable = MARKOV_DISABLE;
5855 uint markov_classic = MARKOV_CLASSIC;
5856 uint markov_threshold = MARKOV_THRESHOLD;
5857 char *markov_hcstat = NULL;
5858 char *outfile = NULL;
5859 uint outfile_format = OUTFILE_FORMAT;
5860 uint outfile_autohex = OUTFILE_AUTOHEX;
5861 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5862 uint restore = RESTORE;
5863 uint restore_timer = RESTORE_TIMER;
5864 uint restore_disable = RESTORE_DISABLE;
5865 uint status = STATUS;
5866 uint status_timer = STATUS_TIMER;
5867 uint machine_readable = MACHINE_READABLE;
5868 uint loopback = LOOPBACK;
5869 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5870 char *session = NULL;
5871 uint hex_charset = HEX_CHARSET;
5872 uint hex_salt = HEX_SALT;
5873 uint hex_wordlist = HEX_WORDLIST;
5874 uint rp_gen = RP_GEN;
5875 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5876 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5877 uint rp_gen_seed = RP_GEN_SEED;
5878 char *rule_buf_l = (char *) RULE_BUF_L;
5879 char *rule_buf_r = (char *) RULE_BUF_R;
5880 uint increment = INCREMENT;
5881 uint increment_min = INCREMENT_MIN;
5882 uint increment_max = INCREMENT_MAX;
5883 char *cpu_affinity = NULL;
5884 OCL_PTR *ocl = NULL;
5885 char *opencl_devices = NULL;
5886 char *opencl_platforms = NULL;
5887 char *opencl_device_types = NULL;
5888 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5889 char *truecrypt_keyfiles = NULL;
5890 char *veracrypt_keyfiles = NULL;
5891 uint veracrypt_pim = 0;
5892 uint workload_profile = WORKLOAD_PROFILE;
5893 uint kernel_accel = KERNEL_ACCEL;
5894 uint kernel_loops = KERNEL_LOOPS;
5895 uint nvidia_spin_damp = NVIDIA_SPIN_DAMP;
5896 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5897 #ifdef HAVE_HWMON
5898 uint gpu_temp_abort = GPU_TEMP_ABORT;
5899 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5900 uint powertune_enable = POWERTUNE_ENABLE;
5901 #endif
5902 uint logfile_disable = LOGFILE_DISABLE;
5903 uint segment_size = SEGMENT_SIZE;
5904 uint scrypt_tmto = SCRYPT_TMTO;
5905 char separator = SEPARATOR;
5906 uint bitmap_min = BITMAP_MIN;
5907 uint bitmap_max = BITMAP_MAX;
5908 char *custom_charset_1 = NULL;
5909 char *custom_charset_2 = NULL;
5910 char *custom_charset_3 = NULL;
5911 char *custom_charset_4 = NULL;
5912
5913 #define IDX_HELP 'h'
5914 #define IDX_VERSION 'V'
5915 #define IDX_VERSION_LOWER 'v'
5916 #define IDX_QUIET 0xff02
5917 #define IDX_SHOW 0xff03
5918 #define IDX_LEFT 0xff04
5919 #define IDX_REMOVE 0xff05
5920 #define IDX_REMOVE_TIMER 0xff37
5921 #define IDX_SKIP 's'
5922 #define IDX_LIMIT 'l'
5923 #define IDX_KEYSPACE 0xff35
5924 #define IDX_POTFILE_DISABLE 0xff06
5925 #define IDX_POTFILE_PATH 0xffe0
5926 #define IDX_DEBUG_MODE 0xff43
5927 #define IDX_DEBUG_FILE 0xff44
5928 #define IDX_INDUCTION_DIR 0xff46
5929 #define IDX_OUTFILE_CHECK_DIR 0xff47
5930 #define IDX_USERNAME 0xff07
5931 #define IDX_FORCE 0xff08
5932 #define IDX_RUNTIME 0xff09
5933 #define IDX_BENCHMARK 'b'
5934 #define IDX_STDOUT_FLAG 0xff77
5935 #define IDX_HASH_MODE 'm'
5936 #define IDX_ATTACK_MODE 'a'
5937 #define IDX_RP_FILE 'r'
5938 #define IDX_RP_GEN 'g'
5939 #define IDX_RP_GEN_FUNC_MIN 0xff10
5940 #define IDX_RP_GEN_FUNC_MAX 0xff11
5941 #define IDX_RP_GEN_SEED 0xff34
5942 #define IDX_RULE_BUF_L 'j'
5943 #define IDX_RULE_BUF_R 'k'
5944 #define IDX_INCREMENT 'i'
5945 #define IDX_INCREMENT_MIN 0xff12
5946 #define IDX_INCREMENT_MAX 0xff13
5947 #define IDX_OUTFILE 'o'
5948 #define IDX_OUTFILE_FORMAT 0xff14
5949 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5950 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5951 #define IDX_RESTORE 0xff15
5952 #define IDX_RESTORE_DISABLE 0xff27
5953 #define IDX_STATUS 0xff17
5954 #define IDX_STATUS_TIMER 0xff18
5955 #define IDX_MACHINE_READABLE 0xff50
5956 #define IDX_LOOPBACK 0xff38
5957 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5958 #define IDX_SESSION 0xff19
5959 #define IDX_HEX_CHARSET 0xff20
5960 #define IDX_HEX_SALT 0xff21
5961 #define IDX_HEX_WORDLIST 0xff40
5962 #define IDX_MARKOV_DISABLE 0xff22
5963 #define IDX_MARKOV_CLASSIC 0xff23
5964 #define IDX_MARKOV_THRESHOLD 't'
5965 #define IDX_MARKOV_HCSTAT 0xff24
5966 #define IDX_CPU_AFFINITY 0xff25
5967 #define IDX_OPENCL_DEVICES 'd'
5968 #define IDX_OPENCL_PLATFORMS 0xff72
5969 #define IDX_OPENCL_DEVICE_TYPES 'D'
5970 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5971 #define IDX_WORKLOAD_PROFILE 'w'
5972 #define IDX_KERNEL_ACCEL 'n'
5973 #define IDX_KERNEL_LOOPS 'u'
5974 #define IDX_NVIDIA_SPIN_DAMP 0xff79
5975 #define IDX_GPU_TEMP_DISABLE 0xff29
5976 #define IDX_GPU_TEMP_ABORT 0xff30
5977 #define IDX_GPU_TEMP_RETAIN 0xff31
5978 #define IDX_POWERTUNE_ENABLE 0xff41
5979 #define IDX_LOGFILE_DISABLE 0xff51
5980 #define IDX_TRUECRYPT_KEYFILES 0xff52
5981 #define IDX_VERACRYPT_KEYFILES 0xff53
5982 #define IDX_VERACRYPT_PIM 0xff54
5983 #define IDX_SCRYPT_TMTO 0xff61
5984 #define IDX_SEGMENT_SIZE 'c'
5985 #define IDX_SEPARATOR 'p'
5986 #define IDX_BITMAP_MIN 0xff70
5987 #define IDX_BITMAP_MAX 0xff71
5988 #define IDX_CUSTOM_CHARSET_1 '1'
5989 #define IDX_CUSTOM_CHARSET_2 '2'
5990 #define IDX_CUSTOM_CHARSET_3 '3'
5991 #define IDX_CUSTOM_CHARSET_4 '4'
5992
5993 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:D:n:u:c:p:s:l:1:2:3:4:ibw:";
5994
5995 struct option long_options[] =
5996 {
5997 {"help", no_argument, 0, IDX_HELP},
5998 {"version", no_argument, 0, IDX_VERSION},
5999 {"quiet", no_argument, 0, IDX_QUIET},
6000 {"show", no_argument, 0, IDX_SHOW},
6001 {"left", no_argument, 0, IDX_LEFT},
6002 {"username", no_argument, 0, IDX_USERNAME},
6003 {"remove", no_argument, 0, IDX_REMOVE},
6004 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
6005 {"skip", required_argument, 0, IDX_SKIP},
6006 {"limit", required_argument, 0, IDX_LIMIT},
6007 {"keyspace", no_argument, 0, IDX_KEYSPACE},
6008 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
6009 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
6010 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
6011 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
6012 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
6013 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
6014 {"force", no_argument, 0, IDX_FORCE},
6015 {"benchmark", no_argument, 0, IDX_BENCHMARK},
6016 {"stdout", no_argument, 0, IDX_STDOUT_FLAG},
6017 {"restore", no_argument, 0, IDX_RESTORE},
6018 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
6019 {"status", no_argument, 0, IDX_STATUS},
6020 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
6021 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
6022 {"loopback", no_argument, 0, IDX_LOOPBACK},
6023 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
6024 {"session", required_argument, 0, IDX_SESSION},
6025 {"runtime", required_argument, 0, IDX_RUNTIME},
6026 {"generate-rules", required_argument, 0, IDX_RP_GEN},
6027 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
6028 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
6029 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
6030 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
6031 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
6032 {"hash-type", required_argument, 0, IDX_HASH_MODE},
6033 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
6034 {"rules-file", required_argument, 0, IDX_RP_FILE},
6035 {"outfile", required_argument, 0, IDX_OUTFILE},
6036 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
6037 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
6038 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
6039 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
6040 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
6041 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
6042 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
6043 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
6044 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
6045 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
6046 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
6047 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
6048 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
6049 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
6050 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
6051 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
6052 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
6053 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
6054 {"nvidia-spin-damp", required_argument, 0, IDX_NVIDIA_SPIN_DAMP},
6055 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
6056 #ifdef HAVE_HWMON
6057 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
6058 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
6059 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
6060 #endif // HAVE_HWMON
6061 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
6062 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
6063 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
6064 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
6065 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
6066 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
6067 {"seperator", required_argument, 0, IDX_SEPARATOR},
6068 {"separator", required_argument, 0, IDX_SEPARATOR},
6069 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
6070 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
6071 {"increment", no_argument, 0, IDX_INCREMENT},
6072 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
6073 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
6074 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
6075 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
6076 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
6077 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
6078 {0, 0, 0, 0}
6079 };
6080
6081 uint rp_files_cnt = 0;
6082
6083 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6084
6085 int option_index = 0;
6086 int c = -1;
6087
6088 optind = 1;
6089 optopt = 0;
6090
6091 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6092 {
6093 switch (c)
6094 {
6095 case IDX_HELP: usage = 1; break;
6096 case IDX_VERSION:
6097 case IDX_VERSION_LOWER: version = 1; break;
6098 case IDX_RESTORE: restore = 1; break;
6099 case IDX_SESSION: session = optarg; break;
6100 case IDX_SHOW: show = 1; break;
6101 case IDX_LEFT: left = 1; break;
6102 case '?': return (-1);
6103 }
6104 }
6105
6106 if (optopt != 0)
6107 {
6108 log_error ("ERROR: Invalid argument specified");
6109
6110 return (-1);
6111 }
6112
6113 /**
6114 * exit functions
6115 */
6116
6117 if (version)
6118 {
6119 log_info ("%s", VERSION_TAG);
6120
6121 return (0);
6122 }
6123
6124 if (usage)
6125 {
6126 usage_big_print (PROGNAME);
6127
6128 return (0);
6129 }
6130
6131 /**
6132 * session needs to be set, always!
6133 */
6134
6135 if (session == NULL) session = (char *) PROGNAME;
6136
6137 /**
6138 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6139 */
6140
6141 char *exec_path = get_exec_path ();
6142
6143 #ifdef LINUX
6144
6145 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6146 char *resolved_exec_path = realpath (exec_path, NULL);
6147
6148 char *install_dir = get_install_dir (resolved_exec_path);
6149 char *profile_dir = NULL;
6150 char *session_dir = NULL;
6151 char *shared_dir = NULL;
6152
6153 if (strcmp (install_dir, resolved_install_folder) == 0)
6154 {
6155 struct passwd *pw = getpwuid (getuid ());
6156
6157 const char *homedir = pw->pw_dir;
6158
6159 profile_dir = get_profile_dir (homedir);
6160 session_dir = get_session_dir (profile_dir);
6161 shared_dir = strdup (SHARED_FOLDER);
6162
6163 mkdir (profile_dir, 0700);
6164 mkdir (session_dir, 0700);
6165 }
6166 else
6167 {
6168 profile_dir = install_dir;
6169 session_dir = install_dir;
6170 shared_dir = install_dir;
6171 }
6172
6173 myfree (resolved_install_folder);
6174 myfree (resolved_exec_path);
6175
6176 #else
6177
6178 char *install_dir = get_install_dir (exec_path);
6179 char *profile_dir = install_dir;
6180 char *session_dir = install_dir;
6181 char *shared_dir = install_dir;
6182
6183 #endif
6184
6185 data.install_dir = install_dir;
6186 data.profile_dir = profile_dir;
6187 data.session_dir = session_dir;
6188 data.shared_dir = shared_dir;
6189
6190 myfree (exec_path);
6191
6192 /**
6193 * kernel cache, we need to make sure folder exist
6194 */
6195
6196 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6197
6198 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6199
6200 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6201
6202 mkdir (kernels_folder, 0700);
6203
6204 myfree (kernels_folder);
6205
6206 /**
6207 * session
6208 */
6209
6210 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6211
6212 data.session = session;
6213
6214 char *eff_restore_file = (char *) mymalloc (session_size);
6215 char *new_restore_file = (char *) mymalloc (session_size);
6216
6217 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
6218 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6219
6220 data.eff_restore_file = eff_restore_file;
6221 data.new_restore_file = new_restore_file;
6222
6223 if (((show == 1) || (left == 1)) && (restore == 1))
6224 {
6225 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6226 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6227
6228 return (-1);
6229 }
6230
6231 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6232 if ((show == 1) || (left == 1))
6233 {
6234 restore_disable = 1;
6235
6236 restore = 0;
6237 }
6238
6239 data.restore_disable = restore_disable;
6240
6241 restore_data_t *rd = init_restore (argc, argv);
6242
6243 data.rd = rd;
6244
6245 /**
6246 * restore file
6247 */
6248
6249 if (restore == 1)
6250 {
6251 read_restore (eff_restore_file, rd);
6252
6253 if (rd->version_bin < RESTORE_MIN)
6254 {
6255 log_error ("ERROR: Incompatible restore-file version");
6256
6257 return (-1);
6258 }
6259
6260 myargc = rd->argc;
6261 myargv = rd->argv;
6262
6263 #ifdef _POSIX
6264 rd->pid = getpid ();
6265 #elif _WIN
6266 rd->pid = GetCurrentProcessId ();
6267 #endif
6268 }
6269
6270 uint hash_mode_chgd = 0;
6271 uint runtime_chgd = 0;
6272 uint kernel_loops_chgd = 0;
6273 uint kernel_accel_chgd = 0;
6274 uint nvidia_spin_damp_chgd = 0;
6275 uint attack_mode_chgd = 0;
6276 uint outfile_format_chgd = 0;
6277 uint rp_gen_seed_chgd = 0;
6278 uint remove_timer_chgd = 0;
6279 uint increment_min_chgd = 0;
6280 uint increment_max_chgd = 0;
6281 uint workload_profile_chgd = 0;
6282 uint opencl_vector_width_chgd = 0;
6283
6284 optind = 1;
6285 optopt = 0;
6286 option_index = 0;
6287
6288 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6289 {
6290 switch (c)
6291 {
6292 //case IDX_HELP: usage = 1; break;
6293 //case IDX_VERSION: version = 1; break;
6294 //case IDX_RESTORE: restore = 1; break;
6295 case IDX_QUIET: quiet = 1; break;
6296 //case IDX_SHOW: show = 1; break;
6297 case IDX_SHOW: break;
6298 //case IDX_LEFT: left = 1; break;
6299 case IDX_LEFT: break;
6300 case IDX_USERNAME: username = 1; break;
6301 case IDX_REMOVE: remove = 1; break;
6302 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6303 remove_timer_chgd = 1; break;
6304 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6305 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6306 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6307 case IDX_DEBUG_FILE: debug_file = optarg; break;
6308 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6309 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6310 case IDX_FORCE: force = 1; break;
6311 case IDX_SKIP: skip = atoll (optarg); break;
6312 case IDX_LIMIT: limit = atoll (optarg); break;
6313 case IDX_KEYSPACE: keyspace = 1; break;
6314 case IDX_BENCHMARK: benchmark = 1; break;
6315 case IDX_STDOUT_FLAG: stdout_flag = 1; break;
6316 case IDX_RESTORE: break;
6317 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6318 case IDX_STATUS: status = 1; break;
6319 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6320 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6321 case IDX_LOOPBACK: loopback = 1; break;
6322 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6323 //case IDX_SESSION: session = optarg; break;
6324 case IDX_SESSION: break;
6325 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6326 hash_mode_chgd = 1; break;
6327 case IDX_RUNTIME: runtime = atoi (optarg);
6328 runtime_chgd = 1; break;
6329 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6330 attack_mode_chgd = 1; break;
6331 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6332 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6333 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6334 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6335 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6336 rp_gen_seed_chgd = 1; break;
6337 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6338 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6339 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6340 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6341 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6342 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6343 case IDX_OUTFILE: outfile = optarg; break;
6344 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6345 outfile_format_chgd = 1; break;
6346 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6347 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6348 case IDX_HEX_CHARSET: hex_charset = 1; break;
6349 case IDX_HEX_SALT: hex_salt = 1; break;
6350 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6351 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6352 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6353 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6354 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6355 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6356 opencl_vector_width_chgd = 1; break;
6357 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6358 workload_profile_chgd = 1; break;
6359 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6360 kernel_accel_chgd = 1; break;
6361 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6362 kernel_loops_chgd = 1; break;
6363 case IDX_NVIDIA_SPIN_DAMP: nvidia_spin_damp = atoi (optarg);
6364 nvidia_spin_damp_chgd = 1; break;
6365 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6366 #ifdef HAVE_HWMON
6367 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6368 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6369 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6370 #endif // HAVE_HWMON
6371 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6372 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6373 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6374 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6375 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6376 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6377 case IDX_SEPARATOR: separator = optarg[0]; break;
6378 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6379 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6380 case IDX_INCREMENT: increment = 1; break;
6381 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6382 increment_min_chgd = 1; break;
6383 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6384 increment_max_chgd = 1; break;
6385 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6386 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6387 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6388 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6389
6390 default:
6391 log_error ("ERROR: Invalid argument specified");
6392 return (-1);
6393 }
6394 }
6395
6396 if (optopt != 0)
6397 {
6398 log_error ("ERROR: Invalid argument specified");
6399
6400 return (-1);
6401 }
6402
6403 /**
6404 * Inform user things getting started,
6405 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6406 * - we do not need to check algorithm_pos
6407 */
6408
6409 if (quiet == 0)
6410 {
6411 if (benchmark == 1)
6412 {
6413 if (machine_readable == 0)
6414 {
6415 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6416 log_info ("");
6417 }
6418 else
6419 {
6420 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6421 }
6422 }
6423 else if (restore == 1)
6424 {
6425 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6426 log_info ("");
6427 }
6428 else if (stdout_flag == 1)
6429 {
6430 // do nothing
6431 }
6432 else if (keyspace == 1)
6433 {
6434 // do nothing
6435 }
6436 else
6437 {
6438 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6439 log_info ("");
6440 }
6441 }
6442
6443 /**
6444 * sanity check
6445 */
6446
6447 if (attack_mode > 7)
6448 {
6449 log_error ("ERROR: Invalid attack-mode specified");
6450
6451 return (-1);
6452 }
6453
6454 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6455 {
6456 log_error ("ERROR: Invalid runtime specified");
6457
6458 return (-1);
6459 }
6460
6461 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6462 {
6463 log_error ("ERROR: Invalid hash-type specified");
6464
6465 return (-1);
6466 }
6467
6468 // renamed hash modes
6469
6470 if (hash_mode_chgd)
6471 {
6472 int n = -1;
6473
6474 switch (hash_mode)
6475 {
6476 case 123: n = 124;
6477 break;
6478 }
6479
6480 if (n >= 0)
6481 {
6482 log_error ("Old -m specified, use -m %d instead", n);
6483
6484 return (-1);
6485 }
6486 }
6487
6488 if (username == 1)
6489 {
6490 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6491 {
6492 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6493
6494 return (-1);
6495 }
6496 }
6497
6498 if (outfile_format > 16)
6499 {
6500 log_error ("ERROR: Invalid outfile-format specified");
6501
6502 return (-1);
6503 }
6504
6505 if (left == 1)
6506 {
6507 if (outfile_format_chgd == 1)
6508 {
6509 if (outfile_format > 1)
6510 {
6511 log_error ("ERROR: Mixing outfile-format > 1 with left parameter is not allowed");
6512
6513 return (-1);
6514 }
6515 }
6516 else
6517 {
6518 outfile_format = OUTFILE_FMT_HASH;
6519 }
6520 }
6521
6522 if (show == 1)
6523 {
6524 if (outfile_format_chgd == 1)
6525 {
6526 if ((outfile_format > 7) && (outfile_format < 16))
6527 {
6528 log_error ("ERROR: Mixing outfile-format > 7 with show parameter is not allowed");
6529
6530 return (-1);
6531 }
6532 }
6533 }
6534
6535 if (increment_min < INCREMENT_MIN)
6536 {
6537 log_error ("ERROR: Invalid increment-min specified");
6538
6539 return (-1);
6540 }
6541
6542 if (increment_max > INCREMENT_MAX)
6543 {
6544 log_error ("ERROR: Invalid increment-max specified");
6545
6546 return (-1);
6547 }
6548
6549 if (increment_min > increment_max)
6550 {
6551 log_error ("ERROR: Invalid increment-min specified");
6552
6553 return (-1);
6554 }
6555
6556 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6557 {
6558 log_error ("ERROR: Increment is not allowed in attack-mode 0");
6559
6560 return (-1);
6561 }
6562
6563 if ((increment == 0) && (increment_min_chgd == 1))
6564 {
6565 log_error ("ERROR: Increment-min is only supported combined with increment switch");
6566
6567 return (-1);
6568 }
6569
6570 if ((increment == 0) && (increment_max_chgd == 1))
6571 {
6572 log_error ("ERROR: Increment-max is only supported combined with increment switch");
6573
6574 return (-1);
6575 }
6576
6577 if (rp_files_cnt && rp_gen)
6578 {
6579 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6580
6581 return (-1);
6582 }
6583
6584 if (rp_files_cnt || rp_gen)
6585 {
6586 if (attack_mode != ATTACK_MODE_STRAIGHT)
6587 {
6588 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6589
6590 return (-1);
6591 }
6592 }
6593
6594 if (rp_gen_func_min > rp_gen_func_max)
6595 {
6596 log_error ("ERROR: Invalid rp-gen-func-min specified");
6597
6598 return (-1);
6599 }
6600
6601 if (kernel_accel_chgd == 1)
6602 {
6603 if (force == 0)
6604 {
6605 log_info ("The manual use of the -n option (or --kernel-accel) is outdated");
6606 log_info ("Please consider using the -w option instead");
6607 log_info ("You can use --force to override this but do not post error reports if you do so");
6608 log_info ("");
6609
6610 return (-1);
6611 }
6612
6613 if (kernel_accel < 1)
6614 {
6615 log_error ("ERROR: Invalid kernel-accel specified");
6616
6617 return (-1);
6618 }
6619
6620 if (kernel_accel > 1024)
6621 {
6622 log_error ("ERROR: Invalid kernel-accel specified");
6623
6624 return (-1);
6625 }
6626 }
6627
6628 if (kernel_loops_chgd == 1)
6629 {
6630 if (force == 0)
6631 {
6632 log_info ("The manual use of the -u option (or --kernel-loops) is outdated");
6633 log_info ("Please consider using the -w option instead");
6634 log_info ("You can use --force to override this but do not post error reports if you do so");
6635 log_info ("");
6636
6637 return (-1);
6638 }
6639
6640 if (kernel_loops < 1)
6641 {
6642 log_error ("ERROR: Invalid kernel-loops specified");
6643
6644 return (-1);
6645 }
6646
6647 if (kernel_loops > 1024)
6648 {
6649 log_error ("ERROR: Invalid kernel-loops specified");
6650
6651 return (-1);
6652 }
6653 }
6654
6655 if ((workload_profile < 1) || (workload_profile > 4))
6656 {
6657 log_error ("ERROR: workload-profile %i not available", workload_profile);
6658
6659 return (-1);
6660 }
6661
6662 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6663 {
6664 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6665
6666 return (-1);
6667 }
6668
6669 if (show == 1 || left == 1)
6670 {
6671 attack_mode = ATTACK_MODE_NONE;
6672
6673 if (remove == 1)
6674 {
6675 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6676
6677 return (-1);
6678 }
6679
6680 if (potfile_disable == 1)
6681 {
6682 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6683
6684 return (-1);
6685 }
6686 }
6687
6688 uint attack_kern = ATTACK_KERN_NONE;
6689
6690 switch (attack_mode)
6691 {
6692 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6693 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6694 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6695 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6696 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6697 }
6698
6699 if (benchmark == 1)
6700 {
6701 if (myargv[optind] != 0)
6702 {
6703 log_error ("ERROR: Invalid argument for benchmark mode specified");
6704
6705 return (-1);
6706 }
6707
6708 if (attack_mode_chgd == 1)
6709 {
6710 if (attack_mode != ATTACK_MODE_BF)
6711 {
6712 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6713
6714 return (-1);
6715 }
6716 }
6717 }
6718 else
6719 {
6720 if (stdout_flag == 1) // no hash here
6721 {
6722 optind--;
6723 }
6724
6725 if (keyspace == 1)
6726 {
6727 int num_additional_params = 1;
6728
6729 if (attack_kern == ATTACK_KERN_COMBI)
6730 {
6731 num_additional_params = 2;
6732 }
6733
6734 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6735
6736 if (keyspace_wordlist_specified == 0) optind--;
6737 }
6738
6739 if (attack_kern == ATTACK_KERN_NONE)
6740 {
6741 if ((optind + 1) != myargc)
6742 {
6743 usage_mini_print (myargv[0]);
6744
6745 return (-1);
6746 }
6747 }
6748 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6749 {
6750 if ((optind + 1) > myargc)
6751 {
6752 usage_mini_print (myargv[0]);
6753
6754 return (-1);
6755 }
6756 }
6757 else if (attack_kern == ATTACK_KERN_COMBI)
6758 {
6759 if ((optind + 3) != myargc)
6760 {
6761 usage_mini_print (myargv[0]);
6762
6763 return (-1);
6764 }
6765 }
6766 else if (attack_kern == ATTACK_KERN_BF)
6767 {
6768 if ((optind + 1) > myargc)
6769 {
6770 usage_mini_print (myargv[0]);
6771
6772 return (-1);
6773 }
6774 }
6775 else
6776 {
6777 usage_mini_print (myargv[0]);
6778
6779 return (-1);
6780 }
6781 }
6782
6783 if (skip != 0 && limit != 0)
6784 {
6785 limit += skip;
6786 }
6787
6788 if (keyspace == 1)
6789 {
6790 if (show == 1)
6791 {
6792 log_error ("ERROR: Combining show parameter with keyspace parameter is not allowed");
6793
6794 return (-1);
6795 }
6796 else if (left == 1)
6797 {
6798 log_error ("ERROR: Combining left parameter with keyspace parameter is not allowed");
6799
6800 return (-1);
6801 }
6802
6803 potfile_disable = 1;
6804
6805 restore_disable = 1;
6806
6807 restore = 0;
6808
6809 weak_hash_threshold = 0;
6810
6811 quiet = 1;
6812 }
6813
6814 if (stdout_flag == 1)
6815 {
6816 status_timer = 0;
6817 restore_timer = 0;
6818 restore_disable = 1;
6819 restore = 0;
6820 potfile_disable = 1;
6821 weak_hash_threshold = 0;
6822 gpu_temp_disable = 1;
6823 hash_mode = 2000;
6824 quiet = 1;
6825 outfile_format = OUTFILE_FMT_PLAIN;
6826 kernel_accel = 1024;
6827 kernel_loops = 1024;
6828 force = 1;
6829 outfile_check_timer = 0;
6830 session = "stdout";
6831 opencl_vector_width = 1;
6832 }
6833
6834 if (remove_timer_chgd == 1)
6835 {
6836 if (remove == 0)
6837 {
6838 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6839
6840 return (-1);
6841 }
6842
6843 if (remove_timer < 1)
6844 {
6845 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6846
6847 return (-1);
6848 }
6849 }
6850
6851 if (loopback == 1)
6852 {
6853 if (attack_mode == ATTACK_MODE_STRAIGHT)
6854 {
6855 if ((rp_files_cnt == 0) && (rp_gen == 0))
6856 {
6857 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6858
6859 return (-1);
6860 }
6861 }
6862 else
6863 {
6864 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6865
6866 return (-1);
6867 }
6868 }
6869
6870 if (debug_mode > 0)
6871 {
6872 if (attack_mode != ATTACK_MODE_STRAIGHT)
6873 {
6874 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6875
6876 return (-1);
6877 }
6878
6879 if ((rp_files_cnt == 0) && (rp_gen == 0))
6880 {
6881 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6882
6883 return (-1);
6884 }
6885 }
6886
6887 if (debug_mode > 4)
6888 {
6889 log_error ("ERROR: Invalid debug-mode specified");
6890
6891 return (-1);
6892 }
6893
6894 if (debug_file != NULL)
6895 {
6896 if (debug_mode < 1)
6897 {
6898 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6899
6900 return (-1);
6901 }
6902 }
6903
6904 if (induction_dir != NULL)
6905 {
6906 if (attack_mode == ATTACK_MODE_BF)
6907 {
6908 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6909
6910 return (-1);
6911 }
6912 }
6913
6914 if (attack_mode != ATTACK_MODE_STRAIGHT)
6915 {
6916 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6917 {
6918 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6919
6920 return (-1);
6921 }
6922
6923 weak_hash_threshold = 0;
6924 }
6925
6926 if (nvidia_spin_damp > 100)
6927 {
6928 log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)");
6929
6930 return (-1);
6931 }
6932
6933
6934 /**
6935 * induction directory
6936 */
6937
6938 char *induction_directory = NULL;
6939
6940 if (attack_mode != ATTACK_MODE_BF)
6941 {
6942 if (induction_dir == NULL)
6943 {
6944 induction_directory = (char *) mymalloc (session_size);
6945
6946 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6947
6948 // create induction folder if it does not already exist
6949
6950 if (keyspace == 0)
6951 {
6952 if (rmdir (induction_directory) == -1)
6953 {
6954 if (errno == ENOENT)
6955 {
6956 // good, we can ignore
6957 }
6958 else if (errno == ENOTEMPTY)
6959 {
6960 char *induction_directory_mv = (char *) mymalloc (session_size);
6961
6962 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6963
6964 if (rename (induction_directory, induction_directory_mv) != 0)
6965 {
6966 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6967
6968 return (-1);
6969 }
6970 }
6971 else
6972 {
6973 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6974
6975 return (-1);
6976 }
6977 }
6978
6979 if (mkdir (induction_directory, 0700) == -1)
6980 {
6981 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6982
6983 return (-1);
6984 }
6985 }
6986 }
6987 else
6988 {
6989 induction_directory = induction_dir;
6990 }
6991 }
6992
6993 data.induction_directory = induction_directory;
6994
6995 /**
6996 * loopback
6997 */
6998
6999 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
7000
7001 char *loopback_file = (char *) mymalloc (loopback_size);
7002
7003 /**
7004 * tuning db
7005 */
7006
7007 char tuning_db_file[256] = { 0 };
7008
7009 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
7010
7011 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
7012
7013 /**
7014 * outfile-check directory
7015 */
7016
7017 char *outfile_check_directory = NULL;
7018
7019 if (outfile_check_dir == NULL)
7020 {
7021 outfile_check_directory = (char *) mymalloc (session_size);
7022
7023 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
7024 }
7025 else
7026 {
7027 outfile_check_directory = outfile_check_dir;
7028 }
7029
7030 data.outfile_check_directory = outfile_check_directory;
7031
7032 if (keyspace == 0)
7033 {
7034 struct stat outfile_check_stat;
7035
7036 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
7037 {
7038 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
7039
7040 if (is_dir == 0)
7041 {
7042 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
7043
7044 return (-1);
7045 }
7046 }
7047 else if (outfile_check_dir == NULL)
7048 {
7049 if (mkdir (outfile_check_directory, 0700) == -1)
7050 {
7051 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
7052
7053 return (-1);
7054 }
7055 }
7056 }
7057
7058 /**
7059 * special other stuff
7060 */
7061
7062 if (hash_mode == 9710)
7063 {
7064 outfile_format = 5;
7065 outfile_format_chgd = 1;
7066 }
7067
7068 if (hash_mode == 9810)
7069 {
7070 outfile_format = 5;
7071 outfile_format_chgd = 1;
7072 }
7073
7074 if (hash_mode == 10410)
7075 {
7076 outfile_format = 5;
7077 outfile_format_chgd = 1;
7078 }
7079
7080 /**
7081 * store stuff
7082 */
7083
7084 data.hash_mode = hash_mode;
7085 data.restore = restore;
7086 data.restore_timer = restore_timer;
7087 data.restore_disable = restore_disable;
7088 data.status = status;
7089 data.status_timer = status_timer;
7090 data.machine_readable = machine_readable;
7091 data.loopback = loopback;
7092 data.runtime = runtime;
7093 data.remove = remove;
7094 data.remove_timer = remove_timer;
7095 data.debug_mode = debug_mode;
7096 data.debug_file = debug_file;
7097 data.username = username;
7098 data.quiet = quiet;
7099 data.outfile = outfile;
7100 data.outfile_format = outfile_format;
7101 data.outfile_autohex = outfile_autohex;
7102 data.hex_charset = hex_charset;
7103 data.hex_salt = hex_salt;
7104 data.hex_wordlist = hex_wordlist;
7105 data.separator = separator;
7106 data.rp_files = rp_files;
7107 data.rp_files_cnt = rp_files_cnt;
7108 data.rp_gen = rp_gen;
7109 data.rp_gen_seed = rp_gen_seed;
7110 data.force = force;
7111 data.benchmark = benchmark;
7112 data.skip = skip;
7113 data.limit = limit;
7114 #ifdef HAVE_HWMON
7115 data.powertune_enable = powertune_enable;
7116 #endif
7117 data.logfile_disable = logfile_disable;
7118 data.truecrypt_keyfiles = truecrypt_keyfiles;
7119 data.veracrypt_keyfiles = veracrypt_keyfiles;
7120 data.veracrypt_pim = veracrypt_pim;
7121 data.scrypt_tmto = scrypt_tmto;
7122 data.workload_profile = workload_profile;
7123
7124 /**
7125 * cpu affinity
7126 */
7127
7128 if (cpu_affinity)
7129 {
7130 set_cpu_affinity (cpu_affinity);
7131 }
7132
7133 if (rp_gen_seed_chgd == 0)
7134 {
7135 srand (proc_start);
7136 }
7137 else
7138 {
7139 srand (rp_gen_seed);
7140 }
7141
7142 /**
7143 * logfile init
7144 */
7145
7146 if (logfile_disable == 0)
7147 {
7148 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7149
7150 char *logfile = (char *) mymalloc (logfile_size);
7151
7152 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7153
7154 data.logfile = logfile;
7155
7156 char *topid = logfile_generate_topid ();
7157
7158 data.topid = topid;
7159 }
7160
7161 // logfile_append() checks for logfile_disable internally to make it easier from here
7162
7163 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7164 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7165 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7166 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7167 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7168 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7169 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7170 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7171 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7172 #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));
7173
7174 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7175 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7176 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7177 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7178 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7179 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7180 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7181 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7182
7183 logfile_top_msg ("START");
7184
7185 logfile_top_uint (attack_mode);
7186 logfile_top_uint (attack_kern);
7187 logfile_top_uint (benchmark);
7188 logfile_top_uint (stdout_flag);
7189 logfile_top_uint (bitmap_min);
7190 logfile_top_uint (bitmap_max);
7191 logfile_top_uint (debug_mode);
7192 logfile_top_uint (force);
7193 logfile_top_uint (kernel_accel);
7194 logfile_top_uint (kernel_loops);
7195 logfile_top_uint (nvidia_spin_damp);
7196 logfile_top_uint (gpu_temp_disable);
7197 #ifdef HAVE_HWMON
7198 logfile_top_uint (gpu_temp_abort);
7199 logfile_top_uint (gpu_temp_retain);
7200 #endif
7201 logfile_top_uint (hash_mode);
7202 logfile_top_uint (hex_charset);
7203 logfile_top_uint (hex_salt);
7204 logfile_top_uint (hex_wordlist);
7205 logfile_top_uint (increment);
7206 logfile_top_uint (increment_max);
7207 logfile_top_uint (increment_min);
7208 logfile_top_uint (keyspace);
7209 logfile_top_uint (left);
7210 logfile_top_uint (logfile_disable);
7211 logfile_top_uint (loopback);
7212 logfile_top_uint (markov_classic);
7213 logfile_top_uint (markov_disable);
7214 logfile_top_uint (markov_threshold);
7215 logfile_top_uint (outfile_autohex);
7216 logfile_top_uint (outfile_check_timer);
7217 logfile_top_uint (outfile_format);
7218 logfile_top_uint (potfile_disable);
7219 logfile_top_string (potfile_path);
7220 #if defined(HAVE_HWMON)
7221 logfile_top_uint (powertune_enable);
7222 #endif
7223 logfile_top_uint (scrypt_tmto);
7224 logfile_top_uint (quiet);
7225 logfile_top_uint (remove);
7226 logfile_top_uint (remove_timer);
7227 logfile_top_uint (restore);
7228 logfile_top_uint (restore_disable);
7229 logfile_top_uint (restore_timer);
7230 logfile_top_uint (rp_gen);
7231 logfile_top_uint (rp_gen_func_max);
7232 logfile_top_uint (rp_gen_func_min);
7233 logfile_top_uint (rp_gen_seed);
7234 logfile_top_uint (runtime);
7235 logfile_top_uint (segment_size);
7236 logfile_top_uint (show);
7237 logfile_top_uint (status);
7238 logfile_top_uint (machine_readable);
7239 logfile_top_uint (status_timer);
7240 logfile_top_uint (usage);
7241 logfile_top_uint (username);
7242 logfile_top_uint (version);
7243 logfile_top_uint (weak_hash_threshold);
7244 logfile_top_uint (workload_profile);
7245 logfile_top_uint64 (limit);
7246 logfile_top_uint64 (skip);
7247 logfile_top_char (separator);
7248 logfile_top_string (cpu_affinity);
7249 logfile_top_string (custom_charset_1);
7250 logfile_top_string (custom_charset_2);
7251 logfile_top_string (custom_charset_3);
7252 logfile_top_string (custom_charset_4);
7253 logfile_top_string (debug_file);
7254 logfile_top_string (opencl_devices);
7255 logfile_top_string (opencl_platforms);
7256 logfile_top_string (opencl_device_types);
7257 logfile_top_uint (opencl_vector_width);
7258 logfile_top_string (induction_dir);
7259 logfile_top_string (markov_hcstat);
7260 logfile_top_string (outfile);
7261 logfile_top_string (outfile_check_dir);
7262 logfile_top_string (rule_buf_l);
7263 logfile_top_string (rule_buf_r);
7264 logfile_top_string (session);
7265 logfile_top_string (truecrypt_keyfiles);
7266 logfile_top_string (veracrypt_keyfiles);
7267 logfile_top_uint (veracrypt_pim);
7268
7269 /**
7270 * Init OpenCL library loader
7271 */
7272
7273 if (keyspace == 0)
7274 {
7275 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7276
7277 ocl_init (ocl);
7278
7279 data.ocl = ocl;
7280 }
7281
7282 /**
7283 * OpenCL platform selection
7284 */
7285
7286 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7287
7288 /**
7289 * OpenCL device selection
7290 */
7291
7292 u32 devices_filter = setup_devices_filter (opencl_devices);
7293
7294 /**
7295 * OpenCL device type selection
7296 */
7297
7298 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7299
7300 /**
7301 * benchmark
7302 */
7303
7304 if (benchmark == 1)
7305 {
7306 /**
7307 * disable useless stuff for benchmark
7308 */
7309
7310 status_timer = 0;
7311 restore_timer = 0;
7312 restore_disable = 1;
7313 potfile_disable = 1;
7314 weak_hash_threshold = 0;
7315 nvidia_spin_damp = 0;
7316 gpu_temp_disable = 1;
7317 outfile_check_timer = 0;
7318
7319 #ifdef HAVE_HWMON
7320 if (powertune_enable == 1)
7321 {
7322 gpu_temp_disable = 0;
7323 }
7324 #endif
7325
7326 data.status_timer = status_timer;
7327 data.restore_timer = restore_timer;
7328 data.restore_disable = restore_disable;
7329 data.outfile_check_timer = outfile_check_timer;
7330
7331 /**
7332 * force attack mode to be bruteforce
7333 */
7334
7335 attack_mode = ATTACK_MODE_BF;
7336 attack_kern = ATTACK_KERN_BF;
7337
7338 if (workload_profile_chgd == 0)
7339 {
7340 workload_profile = 3;
7341
7342 data.workload_profile = workload_profile;
7343 }
7344 }
7345
7346 /**
7347 * status, monitor and outfile remove threads
7348 */
7349
7350 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
7351
7352 data.wordlist_mode = wordlist_mode;
7353
7354 if (wordlist_mode == WL_MODE_STDIN)
7355 {
7356 status = 1;
7357
7358 data.status = status;
7359 }
7360
7361 uint i_threads_cnt = 0;
7362
7363 hc_thread_t *i_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
7364
7365 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
7366 {
7367 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
7368 {
7369 hc_thread_create (i_threads[i_threads_cnt], thread_keypress, NULL);
7370
7371 i_threads_cnt++;
7372 }
7373 }
7374
7375 /**
7376 * config
7377 */
7378
7379 uint hash_type = 0;
7380 uint salt_type = 0;
7381 uint attack_exec = 0;
7382 uint opts_type = 0;
7383 uint kern_type = 0;
7384 uint dgst_size = 0;
7385 uint esalt_size = 0;
7386 uint opti_type = 0;
7387 uint dgst_pos0 = -1;
7388 uint dgst_pos1 = -1;
7389 uint dgst_pos2 = -1;
7390 uint dgst_pos3 = -1;
7391
7392 int (*parse_func) (char *, uint, hash_t *);
7393 int (*sort_by_digest) (const void *, const void *);
7394
7395 uint algorithm_pos = 0;
7396 uint algorithm_max = 1;
7397
7398 uint *algorithms = default_benchmark_algorithms;
7399
7400 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7401
7402 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7403 {
7404 /*
7405 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7406 * the following algos are skipped entirely
7407 */
7408
7409 if (algorithm_pos > 0)
7410 {
7411 local_free (rd);
7412
7413 rd = init_restore (argc, argv);
7414
7415 data.rd = rd;
7416 }
7417
7418 /**
7419 * update hash_mode in case of multihash benchmark
7420 */
7421
7422 if (benchmark == 1)
7423 {
7424 if (hash_mode_chgd == 0)
7425 {
7426 hash_mode = algorithms[algorithm_pos];
7427
7428 data.hash_mode = hash_mode;
7429 }
7430
7431 quiet = 1;
7432
7433 data.quiet = quiet;
7434 }
7435
7436 switch (hash_mode)
7437 {
7438 case 0: hash_type = HASH_TYPE_MD5;
7439 salt_type = SALT_TYPE_NONE;
7440 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7441 opts_type = OPTS_TYPE_PT_GENERATE_LE
7442 | OPTS_TYPE_PT_ADD80
7443 | OPTS_TYPE_PT_ADDBITS14;
7444 kern_type = KERN_TYPE_MD5;
7445 dgst_size = DGST_SIZE_4_4;
7446 parse_func = md5_parse_hash;
7447 sort_by_digest = sort_by_digest_4_4;
7448 opti_type = OPTI_TYPE_ZERO_BYTE
7449 | OPTI_TYPE_PRECOMPUTE_INIT
7450 | OPTI_TYPE_PRECOMPUTE_MERKLE
7451 | OPTI_TYPE_MEET_IN_MIDDLE
7452 | OPTI_TYPE_EARLY_SKIP
7453 | OPTI_TYPE_NOT_ITERATED
7454 | OPTI_TYPE_NOT_SALTED
7455 | OPTI_TYPE_RAW_HASH;
7456 dgst_pos0 = 0;
7457 dgst_pos1 = 3;
7458 dgst_pos2 = 2;
7459 dgst_pos3 = 1;
7460 break;
7461
7462 case 10: hash_type = HASH_TYPE_MD5;
7463 salt_type = SALT_TYPE_INTERN;
7464 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7465 opts_type = OPTS_TYPE_PT_GENERATE_LE
7466 | OPTS_TYPE_ST_ADD80
7467 | OPTS_TYPE_ST_ADDBITS14;
7468 kern_type = KERN_TYPE_MD5_PWSLT;
7469 dgst_size = DGST_SIZE_4_4;
7470 parse_func = md5s_parse_hash;
7471 sort_by_digest = sort_by_digest_4_4;
7472 opti_type = OPTI_TYPE_ZERO_BYTE
7473 | OPTI_TYPE_PRECOMPUTE_INIT
7474 | OPTI_TYPE_PRECOMPUTE_MERKLE
7475 | OPTI_TYPE_MEET_IN_MIDDLE
7476 | OPTI_TYPE_EARLY_SKIP
7477 | OPTI_TYPE_NOT_ITERATED
7478 | OPTI_TYPE_APPENDED_SALT
7479 | OPTI_TYPE_RAW_HASH;
7480 dgst_pos0 = 0;
7481 dgst_pos1 = 3;
7482 dgst_pos2 = 2;
7483 dgst_pos3 = 1;
7484 break;
7485
7486 case 11: hash_type = HASH_TYPE_MD5;
7487 salt_type = SALT_TYPE_INTERN;
7488 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7489 opts_type = OPTS_TYPE_PT_GENERATE_LE
7490 | OPTS_TYPE_ST_ADD80
7491 | OPTS_TYPE_ST_ADDBITS14;
7492 kern_type = KERN_TYPE_MD5_PWSLT;
7493 dgst_size = DGST_SIZE_4_4;
7494 parse_func = joomla_parse_hash;
7495 sort_by_digest = sort_by_digest_4_4;
7496 opti_type = OPTI_TYPE_ZERO_BYTE
7497 | OPTI_TYPE_PRECOMPUTE_INIT
7498 | OPTI_TYPE_PRECOMPUTE_MERKLE
7499 | OPTI_TYPE_MEET_IN_MIDDLE
7500 | OPTI_TYPE_EARLY_SKIP
7501 | OPTI_TYPE_NOT_ITERATED
7502 | OPTI_TYPE_APPENDED_SALT
7503 | OPTI_TYPE_RAW_HASH;
7504 dgst_pos0 = 0;
7505 dgst_pos1 = 3;
7506 dgst_pos2 = 2;
7507 dgst_pos3 = 1;
7508 break;
7509
7510 case 12: hash_type = HASH_TYPE_MD5;
7511 salt_type = SALT_TYPE_INTERN;
7512 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7513 opts_type = OPTS_TYPE_PT_GENERATE_LE
7514 | OPTS_TYPE_ST_ADD80
7515 | OPTS_TYPE_ST_ADDBITS14;
7516 kern_type = KERN_TYPE_MD5_PWSLT;
7517 dgst_size = DGST_SIZE_4_4;
7518 parse_func = postgresql_parse_hash;
7519 sort_by_digest = sort_by_digest_4_4;
7520 opti_type = OPTI_TYPE_ZERO_BYTE
7521 | OPTI_TYPE_PRECOMPUTE_INIT
7522 | OPTI_TYPE_PRECOMPUTE_MERKLE
7523 | OPTI_TYPE_MEET_IN_MIDDLE
7524 | OPTI_TYPE_EARLY_SKIP
7525 | OPTI_TYPE_NOT_ITERATED
7526 | OPTI_TYPE_APPENDED_SALT
7527 | OPTI_TYPE_RAW_HASH;
7528 dgst_pos0 = 0;
7529 dgst_pos1 = 3;
7530 dgst_pos2 = 2;
7531 dgst_pos3 = 1;
7532 break;
7533
7534 case 20: hash_type = HASH_TYPE_MD5;
7535 salt_type = SALT_TYPE_INTERN;
7536 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7537 opts_type = OPTS_TYPE_PT_GENERATE_LE
7538 | OPTS_TYPE_PT_ADD80
7539 | OPTS_TYPE_PT_ADDBITS14;
7540 kern_type = KERN_TYPE_MD5_SLTPW;
7541 dgst_size = DGST_SIZE_4_4;
7542 parse_func = md5s_parse_hash;
7543 sort_by_digest = sort_by_digest_4_4;
7544 opti_type = OPTI_TYPE_ZERO_BYTE
7545 | OPTI_TYPE_PRECOMPUTE_INIT
7546 | OPTI_TYPE_PRECOMPUTE_MERKLE
7547 | OPTI_TYPE_EARLY_SKIP
7548 | OPTI_TYPE_NOT_ITERATED
7549 | OPTI_TYPE_PREPENDED_SALT
7550 | OPTI_TYPE_RAW_HASH;
7551 dgst_pos0 = 0;
7552 dgst_pos1 = 3;
7553 dgst_pos2 = 2;
7554 dgst_pos3 = 1;
7555 break;
7556
7557 case 21: hash_type = HASH_TYPE_MD5;
7558 salt_type = SALT_TYPE_INTERN;
7559 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7560 opts_type = OPTS_TYPE_PT_GENERATE_LE
7561 | OPTS_TYPE_PT_ADD80
7562 | OPTS_TYPE_PT_ADDBITS14;
7563 kern_type = KERN_TYPE_MD5_SLTPW;
7564 dgst_size = DGST_SIZE_4_4;
7565 parse_func = osc_parse_hash;
7566 sort_by_digest = sort_by_digest_4_4;
7567 opti_type = OPTI_TYPE_ZERO_BYTE
7568 | OPTI_TYPE_PRECOMPUTE_INIT
7569 | OPTI_TYPE_PRECOMPUTE_MERKLE
7570 | OPTI_TYPE_EARLY_SKIP
7571 | OPTI_TYPE_NOT_ITERATED
7572 | OPTI_TYPE_PREPENDED_SALT
7573 | OPTI_TYPE_RAW_HASH;
7574 dgst_pos0 = 0;
7575 dgst_pos1 = 3;
7576 dgst_pos2 = 2;
7577 dgst_pos3 = 1;
7578 break;
7579
7580 case 22: hash_type = HASH_TYPE_MD5;
7581 salt_type = SALT_TYPE_EMBEDDED;
7582 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7583 opts_type = OPTS_TYPE_PT_GENERATE_LE
7584 | OPTS_TYPE_PT_ADD80
7585 | OPTS_TYPE_PT_ADDBITS14;
7586 kern_type = KERN_TYPE_MD5_SLTPW;
7587 dgst_size = DGST_SIZE_4_4;
7588 parse_func = netscreen_parse_hash;
7589 sort_by_digest = sort_by_digest_4_4;
7590 opti_type = OPTI_TYPE_ZERO_BYTE
7591 | OPTI_TYPE_PRECOMPUTE_INIT
7592 | OPTI_TYPE_PRECOMPUTE_MERKLE
7593 | OPTI_TYPE_EARLY_SKIP
7594 | OPTI_TYPE_NOT_ITERATED
7595 | OPTI_TYPE_PREPENDED_SALT
7596 | OPTI_TYPE_RAW_HASH;
7597 dgst_pos0 = 0;
7598 dgst_pos1 = 3;
7599 dgst_pos2 = 2;
7600 dgst_pos3 = 1;
7601 break;
7602
7603 case 23: hash_type = HASH_TYPE_MD5;
7604 salt_type = SALT_TYPE_EMBEDDED;
7605 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7606 opts_type = OPTS_TYPE_PT_GENERATE_LE
7607 | OPTS_TYPE_PT_ADD80
7608 | OPTS_TYPE_PT_ADDBITS14;
7609 kern_type = KERN_TYPE_MD5_SLTPW;
7610 dgst_size = DGST_SIZE_4_4;
7611 parse_func = skype_parse_hash;
7612 sort_by_digest = sort_by_digest_4_4;
7613 opti_type = OPTI_TYPE_ZERO_BYTE
7614 | OPTI_TYPE_PRECOMPUTE_INIT
7615 | OPTI_TYPE_PRECOMPUTE_MERKLE
7616 | OPTI_TYPE_EARLY_SKIP
7617 | OPTI_TYPE_NOT_ITERATED
7618 | OPTI_TYPE_PREPENDED_SALT
7619 | OPTI_TYPE_RAW_HASH;
7620 dgst_pos0 = 0;
7621 dgst_pos1 = 3;
7622 dgst_pos2 = 2;
7623 dgst_pos3 = 1;
7624 break;
7625
7626 case 30: hash_type = HASH_TYPE_MD5;
7627 salt_type = SALT_TYPE_INTERN;
7628 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7629 opts_type = OPTS_TYPE_PT_GENERATE_LE
7630 | OPTS_TYPE_PT_UNICODE
7631 | OPTS_TYPE_ST_ADD80
7632 | OPTS_TYPE_ST_ADDBITS14;
7633 kern_type = KERN_TYPE_MD5_PWUSLT;
7634 dgst_size = DGST_SIZE_4_4;
7635 parse_func = md5s_parse_hash;
7636 sort_by_digest = sort_by_digest_4_4;
7637 opti_type = OPTI_TYPE_ZERO_BYTE
7638 | OPTI_TYPE_PRECOMPUTE_INIT
7639 | OPTI_TYPE_PRECOMPUTE_MERKLE
7640 | OPTI_TYPE_MEET_IN_MIDDLE
7641 | OPTI_TYPE_EARLY_SKIP
7642 | OPTI_TYPE_NOT_ITERATED
7643 | OPTI_TYPE_APPENDED_SALT
7644 | OPTI_TYPE_RAW_HASH;
7645 dgst_pos0 = 0;
7646 dgst_pos1 = 3;
7647 dgst_pos2 = 2;
7648 dgst_pos3 = 1;
7649 break;
7650
7651 case 40: hash_type = HASH_TYPE_MD5;
7652 salt_type = SALT_TYPE_INTERN;
7653 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7654 opts_type = OPTS_TYPE_PT_GENERATE_LE
7655 | OPTS_TYPE_PT_ADD80
7656 | OPTS_TYPE_PT_ADDBITS14
7657 | OPTS_TYPE_PT_UNICODE;
7658 kern_type = KERN_TYPE_MD5_SLTPWU;
7659 dgst_size = DGST_SIZE_4_4;
7660 parse_func = md5s_parse_hash;
7661 sort_by_digest = sort_by_digest_4_4;
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_PREPENDED_SALT
7668 | OPTI_TYPE_RAW_HASH;
7669 dgst_pos0 = 0;
7670 dgst_pos1 = 3;
7671 dgst_pos2 = 2;
7672 dgst_pos3 = 1;
7673 break;
7674
7675 case 50: hash_type = HASH_TYPE_MD5;
7676 salt_type = SALT_TYPE_INTERN;
7677 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7678 opts_type = OPTS_TYPE_PT_GENERATE_LE
7679 | OPTS_TYPE_ST_ADD80
7680 | OPTS_TYPE_ST_ADDBITS14;
7681 kern_type = KERN_TYPE_HMACMD5_PW;
7682 dgst_size = DGST_SIZE_4_4;
7683 parse_func = hmacmd5_parse_hash;
7684 sort_by_digest = sort_by_digest_4_4;
7685 opti_type = OPTI_TYPE_ZERO_BYTE
7686 | OPTI_TYPE_NOT_ITERATED;
7687 dgst_pos0 = 0;
7688 dgst_pos1 = 3;
7689 dgst_pos2 = 2;
7690 dgst_pos3 = 1;
7691 break;
7692
7693 case 60: hash_type = HASH_TYPE_MD5;
7694 salt_type = SALT_TYPE_INTERN;
7695 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7696 opts_type = OPTS_TYPE_PT_GENERATE_LE
7697 | OPTS_TYPE_PT_ADD80
7698 | OPTS_TYPE_PT_ADDBITS14;
7699 kern_type = KERN_TYPE_HMACMD5_SLT;
7700 dgst_size = DGST_SIZE_4_4;
7701 parse_func = hmacmd5_parse_hash;
7702 sort_by_digest = sort_by_digest_4_4;
7703 opti_type = OPTI_TYPE_ZERO_BYTE
7704 | OPTI_TYPE_NOT_ITERATED;
7705 dgst_pos0 = 0;
7706 dgst_pos1 = 3;
7707 dgst_pos2 = 2;
7708 dgst_pos3 = 1;
7709 break;
7710
7711 case 100: hash_type = HASH_TYPE_SHA1;
7712 salt_type = SALT_TYPE_NONE;
7713 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7714 opts_type = OPTS_TYPE_PT_GENERATE_BE
7715 | OPTS_TYPE_PT_ADD80
7716 | OPTS_TYPE_PT_ADDBITS15;
7717 kern_type = KERN_TYPE_SHA1;
7718 dgst_size = DGST_SIZE_4_5;
7719 parse_func = sha1_parse_hash;
7720 sort_by_digest = sort_by_digest_4_5;
7721 opti_type = OPTI_TYPE_ZERO_BYTE
7722 | OPTI_TYPE_PRECOMPUTE_INIT
7723 | OPTI_TYPE_PRECOMPUTE_MERKLE
7724 | OPTI_TYPE_EARLY_SKIP
7725 | OPTI_TYPE_NOT_ITERATED
7726 | OPTI_TYPE_NOT_SALTED
7727 | OPTI_TYPE_RAW_HASH;
7728 dgst_pos0 = 3;
7729 dgst_pos1 = 4;
7730 dgst_pos2 = 2;
7731 dgst_pos3 = 1;
7732 break;
7733
7734 case 101: hash_type = HASH_TYPE_SHA1;
7735 salt_type = SALT_TYPE_NONE;
7736 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7737 opts_type = OPTS_TYPE_PT_GENERATE_BE
7738 | OPTS_TYPE_PT_ADD80
7739 | OPTS_TYPE_PT_ADDBITS15;
7740 kern_type = KERN_TYPE_SHA1;
7741 dgst_size = DGST_SIZE_4_5;
7742 parse_func = sha1b64_parse_hash;
7743 sort_by_digest = sort_by_digest_4_5;
7744 opti_type = OPTI_TYPE_ZERO_BYTE
7745 | OPTI_TYPE_PRECOMPUTE_INIT
7746 | OPTI_TYPE_PRECOMPUTE_MERKLE
7747 | OPTI_TYPE_EARLY_SKIP
7748 | OPTI_TYPE_NOT_ITERATED
7749 | OPTI_TYPE_NOT_SALTED
7750 | OPTI_TYPE_RAW_HASH;
7751 dgst_pos0 = 3;
7752 dgst_pos1 = 4;
7753 dgst_pos2 = 2;
7754 dgst_pos3 = 1;
7755 break;
7756
7757 case 110: hash_type = HASH_TYPE_SHA1;
7758 salt_type = SALT_TYPE_INTERN;
7759 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7760 opts_type = OPTS_TYPE_PT_GENERATE_BE
7761 | OPTS_TYPE_ST_ADD80
7762 | OPTS_TYPE_ST_ADDBITS15;
7763 kern_type = KERN_TYPE_SHA1_PWSLT;
7764 dgst_size = DGST_SIZE_4_5;
7765 parse_func = sha1s_parse_hash;
7766 sort_by_digest = sort_by_digest_4_5;
7767 opti_type = OPTI_TYPE_ZERO_BYTE
7768 | OPTI_TYPE_PRECOMPUTE_INIT
7769 | OPTI_TYPE_PRECOMPUTE_MERKLE
7770 | OPTI_TYPE_EARLY_SKIP
7771 | OPTI_TYPE_NOT_ITERATED
7772 | OPTI_TYPE_APPENDED_SALT
7773 | OPTI_TYPE_RAW_HASH;
7774 dgst_pos0 = 3;
7775 dgst_pos1 = 4;
7776 dgst_pos2 = 2;
7777 dgst_pos3 = 1;
7778 break;
7779
7780 case 111: hash_type = HASH_TYPE_SHA1;
7781 salt_type = SALT_TYPE_EMBEDDED;
7782 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7783 opts_type = OPTS_TYPE_PT_GENERATE_BE
7784 | OPTS_TYPE_ST_ADD80
7785 | OPTS_TYPE_ST_ADDBITS15;
7786 kern_type = KERN_TYPE_SHA1_PWSLT;
7787 dgst_size = DGST_SIZE_4_5;
7788 parse_func = sha1b64s_parse_hash;
7789 sort_by_digest = sort_by_digest_4_5;
7790 opti_type = OPTI_TYPE_ZERO_BYTE
7791 | OPTI_TYPE_PRECOMPUTE_INIT
7792 | OPTI_TYPE_PRECOMPUTE_MERKLE
7793 | OPTI_TYPE_EARLY_SKIP
7794 | OPTI_TYPE_NOT_ITERATED
7795 | OPTI_TYPE_APPENDED_SALT
7796 | OPTI_TYPE_RAW_HASH;
7797 dgst_pos0 = 3;
7798 dgst_pos1 = 4;
7799 dgst_pos2 = 2;
7800 dgst_pos3 = 1;
7801 break;
7802
7803 case 112: hash_type = HASH_TYPE_SHA1;
7804 salt_type = SALT_TYPE_INTERN;
7805 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7806 opts_type = OPTS_TYPE_PT_GENERATE_BE
7807 | OPTS_TYPE_ST_ADD80
7808 | OPTS_TYPE_ST_ADDBITS15
7809 | OPTS_TYPE_ST_HEX;
7810 kern_type = KERN_TYPE_SHA1_PWSLT;
7811 dgst_size = DGST_SIZE_4_5;
7812 parse_func = oracles_parse_hash;
7813 sort_by_digest = sort_by_digest_4_5;
7814 opti_type = OPTI_TYPE_ZERO_BYTE
7815 | OPTI_TYPE_PRECOMPUTE_INIT
7816 | OPTI_TYPE_PRECOMPUTE_MERKLE
7817 | OPTI_TYPE_EARLY_SKIP
7818 | OPTI_TYPE_NOT_ITERATED
7819 | OPTI_TYPE_APPENDED_SALT
7820 | OPTI_TYPE_RAW_HASH;
7821 dgst_pos0 = 3;
7822 dgst_pos1 = 4;
7823 dgst_pos2 = 2;
7824 dgst_pos3 = 1;
7825 break;
7826
7827 case 120: hash_type = HASH_TYPE_SHA1;
7828 salt_type = SALT_TYPE_INTERN;
7829 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7830 opts_type = OPTS_TYPE_PT_GENERATE_BE
7831 | OPTS_TYPE_PT_ADD80
7832 | OPTS_TYPE_PT_ADDBITS15;
7833 kern_type = KERN_TYPE_SHA1_SLTPW;
7834 dgst_size = DGST_SIZE_4_5;
7835 parse_func = sha1s_parse_hash;
7836 sort_by_digest = sort_by_digest_4_5;
7837 opti_type = OPTI_TYPE_ZERO_BYTE
7838 | OPTI_TYPE_PRECOMPUTE_INIT
7839 | OPTI_TYPE_PRECOMPUTE_MERKLE
7840 | OPTI_TYPE_EARLY_SKIP
7841 | OPTI_TYPE_NOT_ITERATED
7842 | OPTI_TYPE_PREPENDED_SALT
7843 | OPTI_TYPE_RAW_HASH;
7844 dgst_pos0 = 3;
7845 dgst_pos1 = 4;
7846 dgst_pos2 = 2;
7847 dgst_pos3 = 1;
7848 break;
7849
7850 case 121: hash_type = HASH_TYPE_SHA1;
7851 salt_type = SALT_TYPE_INTERN;
7852 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7853 opts_type = OPTS_TYPE_PT_GENERATE_BE
7854 | OPTS_TYPE_PT_ADD80
7855 | OPTS_TYPE_PT_ADDBITS15
7856 | OPTS_TYPE_ST_LOWER;
7857 kern_type = KERN_TYPE_SHA1_SLTPW;
7858 dgst_size = DGST_SIZE_4_5;
7859 parse_func = smf_parse_hash;
7860 sort_by_digest = sort_by_digest_4_5;
7861 opti_type = OPTI_TYPE_ZERO_BYTE
7862 | OPTI_TYPE_PRECOMPUTE_INIT
7863 | OPTI_TYPE_PRECOMPUTE_MERKLE
7864 | OPTI_TYPE_EARLY_SKIP
7865 | OPTI_TYPE_NOT_ITERATED
7866 | OPTI_TYPE_PREPENDED_SALT
7867 | OPTI_TYPE_RAW_HASH;
7868 dgst_pos0 = 3;
7869 dgst_pos1 = 4;
7870 dgst_pos2 = 2;
7871 dgst_pos3 = 1;
7872 break;
7873
7874 case 122: hash_type = HASH_TYPE_SHA1;
7875 salt_type = SALT_TYPE_EMBEDDED;
7876 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7877 opts_type = OPTS_TYPE_PT_GENERATE_BE
7878 | OPTS_TYPE_PT_ADD80
7879 | OPTS_TYPE_PT_ADDBITS15
7880 | OPTS_TYPE_ST_HEX;
7881 kern_type = KERN_TYPE_SHA1_SLTPW;
7882 dgst_size = DGST_SIZE_4_5;
7883 parse_func = osx1_parse_hash;
7884 sort_by_digest = sort_by_digest_4_5;
7885 opti_type = OPTI_TYPE_ZERO_BYTE
7886 | OPTI_TYPE_PRECOMPUTE_INIT
7887 | OPTI_TYPE_PRECOMPUTE_MERKLE
7888 | OPTI_TYPE_EARLY_SKIP
7889 | OPTI_TYPE_NOT_ITERATED
7890 | OPTI_TYPE_PREPENDED_SALT
7891 | OPTI_TYPE_RAW_HASH;
7892 dgst_pos0 = 3;
7893 dgst_pos1 = 4;
7894 dgst_pos2 = 2;
7895 dgst_pos3 = 1;
7896 break;
7897
7898 case 124: hash_type = HASH_TYPE_SHA1;
7899 salt_type = SALT_TYPE_EMBEDDED;
7900 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7901 opts_type = OPTS_TYPE_PT_GENERATE_BE
7902 | OPTS_TYPE_PT_ADD80
7903 | OPTS_TYPE_PT_ADDBITS15;
7904 kern_type = KERN_TYPE_SHA1_SLTPW;
7905 dgst_size = DGST_SIZE_4_5;
7906 parse_func = djangosha1_parse_hash;
7907 sort_by_digest = sort_by_digest_4_5;
7908 opti_type = OPTI_TYPE_ZERO_BYTE
7909 | OPTI_TYPE_PRECOMPUTE_INIT
7910 | OPTI_TYPE_PRECOMPUTE_MERKLE
7911 | OPTI_TYPE_EARLY_SKIP
7912 | OPTI_TYPE_NOT_ITERATED
7913 | OPTI_TYPE_PREPENDED_SALT
7914 | OPTI_TYPE_RAW_HASH;
7915 dgst_pos0 = 3;
7916 dgst_pos1 = 4;
7917 dgst_pos2 = 2;
7918 dgst_pos3 = 1;
7919 break;
7920
7921 case 125: hash_type = HASH_TYPE_SHA1;
7922 salt_type = SALT_TYPE_EMBEDDED;
7923 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7924 opts_type = OPTS_TYPE_PT_GENERATE_BE
7925 | OPTS_TYPE_PT_ADD80
7926 | OPTS_TYPE_PT_ADDBITS15
7927 | OPTS_TYPE_ST_HEX;
7928 kern_type = KERN_TYPE_SHA1_SLTPW;
7929 dgst_size = DGST_SIZE_4_5;
7930 parse_func = arubaos_parse_hash;
7931 sort_by_digest = sort_by_digest_4_5;
7932 opti_type = OPTI_TYPE_ZERO_BYTE
7933 | OPTI_TYPE_PRECOMPUTE_INIT
7934 | OPTI_TYPE_PRECOMPUTE_MERKLE
7935 | OPTI_TYPE_EARLY_SKIP
7936 | OPTI_TYPE_NOT_ITERATED
7937 | OPTI_TYPE_PREPENDED_SALT
7938 | OPTI_TYPE_RAW_HASH;
7939 dgst_pos0 = 3;
7940 dgst_pos1 = 4;
7941 dgst_pos2 = 2;
7942 dgst_pos3 = 1;
7943 break;
7944
7945 case 130: hash_type = HASH_TYPE_SHA1;
7946 salt_type = SALT_TYPE_INTERN;
7947 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7948 opts_type = OPTS_TYPE_PT_GENERATE_BE
7949 | OPTS_TYPE_PT_UNICODE
7950 | OPTS_TYPE_ST_ADD80
7951 | OPTS_TYPE_ST_ADDBITS15;
7952 kern_type = KERN_TYPE_SHA1_PWUSLT;
7953 dgst_size = DGST_SIZE_4_5;
7954 parse_func = sha1s_parse_hash;
7955 sort_by_digest = sort_by_digest_4_5;
7956 opti_type = OPTI_TYPE_ZERO_BYTE
7957 | OPTI_TYPE_PRECOMPUTE_INIT
7958 | OPTI_TYPE_PRECOMPUTE_MERKLE
7959 | OPTI_TYPE_EARLY_SKIP
7960 | OPTI_TYPE_NOT_ITERATED
7961 | OPTI_TYPE_APPENDED_SALT
7962 | OPTI_TYPE_RAW_HASH;
7963 dgst_pos0 = 3;
7964 dgst_pos1 = 4;
7965 dgst_pos2 = 2;
7966 dgst_pos3 = 1;
7967 break;
7968
7969 case 131: hash_type = HASH_TYPE_SHA1;
7970 salt_type = SALT_TYPE_EMBEDDED;
7971 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7972 opts_type = OPTS_TYPE_PT_GENERATE_BE
7973 | OPTS_TYPE_PT_UNICODE
7974 | OPTS_TYPE_PT_UPPER
7975 | OPTS_TYPE_ST_ADD80
7976 | OPTS_TYPE_ST_ADDBITS15
7977 | OPTS_TYPE_ST_HEX;
7978 kern_type = KERN_TYPE_SHA1_PWUSLT;
7979 dgst_size = DGST_SIZE_4_5;
7980 parse_func = mssql2000_parse_hash;
7981 sort_by_digest = sort_by_digest_4_5;
7982 opti_type = OPTI_TYPE_ZERO_BYTE
7983 | OPTI_TYPE_PRECOMPUTE_INIT
7984 | OPTI_TYPE_PRECOMPUTE_MERKLE
7985 | OPTI_TYPE_EARLY_SKIP
7986 | OPTI_TYPE_NOT_ITERATED
7987 | OPTI_TYPE_APPENDED_SALT
7988 | OPTI_TYPE_RAW_HASH;
7989 dgst_pos0 = 3;
7990 dgst_pos1 = 4;
7991 dgst_pos2 = 2;
7992 dgst_pos3 = 1;
7993 break;
7994
7995 case 132: hash_type = HASH_TYPE_SHA1;
7996 salt_type = SALT_TYPE_EMBEDDED;
7997 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7998 opts_type = OPTS_TYPE_PT_GENERATE_BE
7999 | OPTS_TYPE_PT_UNICODE
8000 | OPTS_TYPE_ST_ADD80
8001 | OPTS_TYPE_ST_ADDBITS15
8002 | OPTS_TYPE_ST_HEX;
8003 kern_type = KERN_TYPE_SHA1_PWUSLT;
8004 dgst_size = DGST_SIZE_4_5;
8005 parse_func = mssql2005_parse_hash;
8006 sort_by_digest = sort_by_digest_4_5;
8007 opti_type = OPTI_TYPE_ZERO_BYTE
8008 | OPTI_TYPE_PRECOMPUTE_INIT
8009 | OPTI_TYPE_PRECOMPUTE_MERKLE
8010 | OPTI_TYPE_EARLY_SKIP
8011 | OPTI_TYPE_NOT_ITERATED
8012 | OPTI_TYPE_APPENDED_SALT
8013 | OPTI_TYPE_RAW_HASH;
8014 dgst_pos0 = 3;
8015 dgst_pos1 = 4;
8016 dgst_pos2 = 2;
8017 dgst_pos3 = 1;
8018 break;
8019
8020 case 133: hash_type = HASH_TYPE_SHA1;
8021 salt_type = SALT_TYPE_EMBEDDED;
8022 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8023 opts_type = OPTS_TYPE_PT_GENERATE_BE
8024 | OPTS_TYPE_PT_UNICODE
8025 | OPTS_TYPE_ST_ADD80
8026 | OPTS_TYPE_ST_ADDBITS15;
8027 kern_type = KERN_TYPE_SHA1_PWUSLT;
8028 dgst_size = DGST_SIZE_4_5;
8029 parse_func = peoplesoft_parse_hash;
8030 sort_by_digest = sort_by_digest_4_5;
8031 opti_type = OPTI_TYPE_ZERO_BYTE
8032 | OPTI_TYPE_PRECOMPUTE_INIT
8033 | OPTI_TYPE_PRECOMPUTE_MERKLE
8034 | OPTI_TYPE_EARLY_SKIP
8035 | OPTI_TYPE_NOT_ITERATED
8036 | OPTI_TYPE_APPENDED_SALT
8037 | OPTI_TYPE_RAW_HASH;
8038 dgst_pos0 = 3;
8039 dgst_pos1 = 4;
8040 dgst_pos2 = 2;
8041 dgst_pos3 = 1;
8042 break;
8043
8044 case 140: hash_type = HASH_TYPE_SHA1;
8045 salt_type = SALT_TYPE_INTERN;
8046 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8047 opts_type = OPTS_TYPE_PT_GENERATE_BE
8048 | OPTS_TYPE_PT_ADD80
8049 | OPTS_TYPE_PT_ADDBITS15
8050 | OPTS_TYPE_PT_UNICODE;
8051 kern_type = KERN_TYPE_SHA1_SLTPWU;
8052 dgst_size = DGST_SIZE_4_5;
8053 parse_func = sha1s_parse_hash;
8054 sort_by_digest = sort_by_digest_4_5;
8055 opti_type = OPTI_TYPE_ZERO_BYTE
8056 | OPTI_TYPE_PRECOMPUTE_INIT
8057 | OPTI_TYPE_PRECOMPUTE_MERKLE
8058 | OPTI_TYPE_EARLY_SKIP
8059 | OPTI_TYPE_NOT_ITERATED
8060 | OPTI_TYPE_PREPENDED_SALT
8061 | OPTI_TYPE_RAW_HASH;
8062 dgst_pos0 = 3;
8063 dgst_pos1 = 4;
8064 dgst_pos2 = 2;
8065 dgst_pos3 = 1;
8066 break;
8067
8068 case 141: hash_type = HASH_TYPE_SHA1;
8069 salt_type = SALT_TYPE_EMBEDDED;
8070 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8071 opts_type = OPTS_TYPE_PT_GENERATE_BE
8072 | OPTS_TYPE_PT_ADD80
8073 | OPTS_TYPE_PT_ADDBITS15
8074 | OPTS_TYPE_PT_UNICODE
8075 | OPTS_TYPE_ST_BASE64;
8076 kern_type = KERN_TYPE_SHA1_SLTPWU;
8077 dgst_size = DGST_SIZE_4_5;
8078 parse_func = episerver_parse_hash;
8079 sort_by_digest = sort_by_digest_4_5;
8080 opti_type = OPTI_TYPE_ZERO_BYTE
8081 | OPTI_TYPE_PRECOMPUTE_INIT
8082 | OPTI_TYPE_PRECOMPUTE_MERKLE
8083 | OPTI_TYPE_EARLY_SKIP
8084 | OPTI_TYPE_NOT_ITERATED
8085 | OPTI_TYPE_PREPENDED_SALT
8086 | OPTI_TYPE_RAW_HASH;
8087 dgst_pos0 = 3;
8088 dgst_pos1 = 4;
8089 dgst_pos2 = 2;
8090 dgst_pos3 = 1;
8091 break;
8092
8093 case 150: hash_type = HASH_TYPE_SHA1;
8094 salt_type = SALT_TYPE_INTERN;
8095 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8096 opts_type = OPTS_TYPE_PT_GENERATE_BE
8097 | OPTS_TYPE_ST_ADD80
8098 | OPTS_TYPE_ST_ADDBITS15;
8099 kern_type = KERN_TYPE_HMACSHA1_PW;
8100 dgst_size = DGST_SIZE_4_5;
8101 parse_func = hmacsha1_parse_hash;
8102 sort_by_digest = sort_by_digest_4_5;
8103 opti_type = OPTI_TYPE_ZERO_BYTE
8104 | OPTI_TYPE_NOT_ITERATED;
8105 dgst_pos0 = 3;
8106 dgst_pos1 = 4;
8107 dgst_pos2 = 2;
8108 dgst_pos3 = 1;
8109 break;
8110
8111 case 160: hash_type = HASH_TYPE_SHA1;
8112 salt_type = SALT_TYPE_INTERN;
8113 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8114 opts_type = OPTS_TYPE_PT_GENERATE_BE
8115 | OPTS_TYPE_PT_ADD80
8116 | OPTS_TYPE_PT_ADDBITS15;
8117 kern_type = KERN_TYPE_HMACSHA1_SLT;
8118 dgst_size = DGST_SIZE_4_5;
8119 parse_func = hmacsha1_parse_hash;
8120 sort_by_digest = sort_by_digest_4_5;
8121 opti_type = OPTI_TYPE_ZERO_BYTE
8122 | OPTI_TYPE_NOT_ITERATED;
8123 dgst_pos0 = 3;
8124 dgst_pos1 = 4;
8125 dgst_pos2 = 2;
8126 dgst_pos3 = 1;
8127 break;
8128
8129 case 200: hash_type = HASH_TYPE_MYSQL;
8130 salt_type = SALT_TYPE_NONE;
8131 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8132 opts_type = 0;
8133 kern_type = KERN_TYPE_MYSQL;
8134 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8135 parse_func = mysql323_parse_hash;
8136 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8137 opti_type = OPTI_TYPE_ZERO_BYTE;
8138 dgst_pos0 = 0;
8139 dgst_pos1 = 1;
8140 dgst_pos2 = 2;
8141 dgst_pos3 = 3;
8142 break;
8143
8144 case 300: hash_type = HASH_TYPE_SHA1;
8145 salt_type = SALT_TYPE_NONE;
8146 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8147 opts_type = OPTS_TYPE_PT_GENERATE_BE
8148 | OPTS_TYPE_PT_ADD80
8149 | OPTS_TYPE_PT_ADDBITS15;
8150 kern_type = KERN_TYPE_MYSQL41;
8151 dgst_size = DGST_SIZE_4_5;
8152 parse_func = sha1_parse_hash;
8153 sort_by_digest = sort_by_digest_4_5;
8154 opti_type = OPTI_TYPE_ZERO_BYTE
8155 | OPTI_TYPE_PRECOMPUTE_INIT
8156 | OPTI_TYPE_PRECOMPUTE_MERKLE
8157 | OPTI_TYPE_EARLY_SKIP
8158 | OPTI_TYPE_NOT_ITERATED
8159 | OPTI_TYPE_NOT_SALTED;
8160 dgst_pos0 = 3;
8161 dgst_pos1 = 4;
8162 dgst_pos2 = 2;
8163 dgst_pos3 = 1;
8164 break;
8165
8166 case 400: hash_type = HASH_TYPE_MD5;
8167 salt_type = SALT_TYPE_EMBEDDED;
8168 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8169 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8170 kern_type = KERN_TYPE_PHPASS;
8171 dgst_size = DGST_SIZE_4_4;
8172 parse_func = phpass_parse_hash;
8173 sort_by_digest = sort_by_digest_4_4;
8174 opti_type = OPTI_TYPE_ZERO_BYTE
8175 | OPTI_TYPE_SLOW_HASH_SIMD;
8176 dgst_pos0 = 0;
8177 dgst_pos1 = 1;
8178 dgst_pos2 = 2;
8179 dgst_pos3 = 3;
8180 break;
8181
8182 case 500: hash_type = HASH_TYPE_MD5;
8183 salt_type = SALT_TYPE_EMBEDDED;
8184 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8185 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8186 kern_type = KERN_TYPE_MD5CRYPT;
8187 dgst_size = DGST_SIZE_4_4;
8188 parse_func = md5crypt_parse_hash;
8189 sort_by_digest = sort_by_digest_4_4;
8190 opti_type = OPTI_TYPE_ZERO_BYTE;
8191 dgst_pos0 = 0;
8192 dgst_pos1 = 1;
8193 dgst_pos2 = 2;
8194 dgst_pos3 = 3;
8195 break;
8196
8197 case 501: hash_type = HASH_TYPE_MD5;
8198 salt_type = SALT_TYPE_EMBEDDED;
8199 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8200 opts_type = OPTS_TYPE_PT_GENERATE_LE
8201 | OPTS_TYPE_HASH_COPY;
8202 kern_type = KERN_TYPE_MD5CRYPT;
8203 dgst_size = DGST_SIZE_4_4;
8204 parse_func = juniper_parse_hash;
8205 sort_by_digest = sort_by_digest_4_4;
8206 opti_type = OPTI_TYPE_ZERO_BYTE;
8207 dgst_pos0 = 0;
8208 dgst_pos1 = 1;
8209 dgst_pos2 = 2;
8210 dgst_pos3 = 3;
8211 break;
8212
8213 case 900: hash_type = HASH_TYPE_MD4;
8214 salt_type = SALT_TYPE_NONE;
8215 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8216 opts_type = OPTS_TYPE_PT_GENERATE_LE
8217 | OPTS_TYPE_PT_ADD80
8218 | OPTS_TYPE_PT_ADDBITS14;
8219 kern_type = KERN_TYPE_MD4;
8220 dgst_size = DGST_SIZE_4_4;
8221 parse_func = md4_parse_hash;
8222 sort_by_digest = sort_by_digest_4_4;
8223 opti_type = OPTI_TYPE_ZERO_BYTE
8224 | OPTI_TYPE_PRECOMPUTE_INIT
8225 | OPTI_TYPE_PRECOMPUTE_MERKLE
8226 | OPTI_TYPE_MEET_IN_MIDDLE
8227 | OPTI_TYPE_EARLY_SKIP
8228 | OPTI_TYPE_NOT_ITERATED
8229 | OPTI_TYPE_NOT_SALTED
8230 | OPTI_TYPE_RAW_HASH;
8231 dgst_pos0 = 0;
8232 dgst_pos1 = 3;
8233 dgst_pos2 = 2;
8234 dgst_pos3 = 1;
8235 break;
8236
8237 case 1000: hash_type = HASH_TYPE_MD4;
8238 salt_type = SALT_TYPE_NONE;
8239 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8240 opts_type = OPTS_TYPE_PT_GENERATE_LE
8241 | OPTS_TYPE_PT_ADD80
8242 | OPTS_TYPE_PT_ADDBITS14
8243 | OPTS_TYPE_PT_UNICODE;
8244 kern_type = KERN_TYPE_MD4_PWU;
8245 dgst_size = DGST_SIZE_4_4;
8246 parse_func = md4_parse_hash;
8247 sort_by_digest = sort_by_digest_4_4;
8248 opti_type = OPTI_TYPE_ZERO_BYTE
8249 | OPTI_TYPE_PRECOMPUTE_INIT
8250 | OPTI_TYPE_PRECOMPUTE_MERKLE
8251 | OPTI_TYPE_MEET_IN_MIDDLE
8252 | OPTI_TYPE_EARLY_SKIP
8253 | OPTI_TYPE_NOT_ITERATED
8254 | OPTI_TYPE_NOT_SALTED
8255 | OPTI_TYPE_RAW_HASH;
8256 dgst_pos0 = 0;
8257 dgst_pos1 = 3;
8258 dgst_pos2 = 2;
8259 dgst_pos3 = 1;
8260 break;
8261
8262 case 1100: hash_type = HASH_TYPE_MD4;
8263 salt_type = SALT_TYPE_INTERN;
8264 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8265 opts_type = OPTS_TYPE_PT_GENERATE_LE
8266 | OPTS_TYPE_PT_ADD80
8267 | OPTS_TYPE_PT_ADDBITS14
8268 | OPTS_TYPE_PT_UNICODE
8269 | OPTS_TYPE_ST_ADD80
8270 | OPTS_TYPE_ST_UNICODE
8271 | OPTS_TYPE_ST_LOWER;
8272 kern_type = KERN_TYPE_MD44_PWUSLT;
8273 dgst_size = DGST_SIZE_4_4;
8274 parse_func = dcc_parse_hash;
8275 sort_by_digest = sort_by_digest_4_4;
8276 opti_type = OPTI_TYPE_ZERO_BYTE
8277 | OPTI_TYPE_PRECOMPUTE_INIT
8278 | OPTI_TYPE_PRECOMPUTE_MERKLE
8279 | OPTI_TYPE_EARLY_SKIP
8280 | OPTI_TYPE_NOT_ITERATED;
8281 dgst_pos0 = 0;
8282 dgst_pos1 = 3;
8283 dgst_pos2 = 2;
8284 dgst_pos3 = 1;
8285 break;
8286
8287 case 1400: hash_type = HASH_TYPE_SHA256;
8288 salt_type = SALT_TYPE_NONE;
8289 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8290 opts_type = OPTS_TYPE_PT_GENERATE_BE
8291 | OPTS_TYPE_PT_ADD80
8292 | OPTS_TYPE_PT_ADDBITS15;
8293 kern_type = KERN_TYPE_SHA256;
8294 dgst_size = DGST_SIZE_4_8;
8295 parse_func = sha256_parse_hash;
8296 sort_by_digest = sort_by_digest_4_8;
8297 opti_type = OPTI_TYPE_ZERO_BYTE
8298 | OPTI_TYPE_PRECOMPUTE_INIT
8299 | OPTI_TYPE_PRECOMPUTE_MERKLE
8300 | OPTI_TYPE_EARLY_SKIP
8301 | OPTI_TYPE_NOT_ITERATED
8302 | OPTI_TYPE_NOT_SALTED
8303 | OPTI_TYPE_RAW_HASH;
8304 dgst_pos0 = 3;
8305 dgst_pos1 = 7;
8306 dgst_pos2 = 2;
8307 dgst_pos3 = 6;
8308 break;
8309
8310 case 1410: hash_type = HASH_TYPE_SHA256;
8311 salt_type = SALT_TYPE_INTERN;
8312 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8313 opts_type = OPTS_TYPE_PT_GENERATE_BE
8314 | OPTS_TYPE_ST_ADD80
8315 | OPTS_TYPE_ST_ADDBITS15;
8316 kern_type = KERN_TYPE_SHA256_PWSLT;
8317 dgst_size = DGST_SIZE_4_8;
8318 parse_func = sha256s_parse_hash;
8319 sort_by_digest = sort_by_digest_4_8;
8320 opti_type = OPTI_TYPE_ZERO_BYTE
8321 | OPTI_TYPE_PRECOMPUTE_INIT
8322 | OPTI_TYPE_PRECOMPUTE_MERKLE
8323 | OPTI_TYPE_EARLY_SKIP
8324 | OPTI_TYPE_NOT_ITERATED
8325 | OPTI_TYPE_APPENDED_SALT
8326 | OPTI_TYPE_RAW_HASH;
8327 dgst_pos0 = 3;
8328 dgst_pos1 = 7;
8329 dgst_pos2 = 2;
8330 dgst_pos3 = 6;
8331 break;
8332
8333 case 1420: hash_type = HASH_TYPE_SHA256;
8334 salt_type = SALT_TYPE_INTERN;
8335 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8336 opts_type = OPTS_TYPE_PT_GENERATE_BE
8337 | OPTS_TYPE_PT_ADD80
8338 | OPTS_TYPE_PT_ADDBITS15;
8339 kern_type = KERN_TYPE_SHA256_SLTPW;
8340 dgst_size = DGST_SIZE_4_8;
8341 parse_func = sha256s_parse_hash;
8342 sort_by_digest = sort_by_digest_4_8;
8343 opti_type = OPTI_TYPE_ZERO_BYTE
8344 | OPTI_TYPE_PRECOMPUTE_INIT
8345 | OPTI_TYPE_PRECOMPUTE_MERKLE
8346 | OPTI_TYPE_EARLY_SKIP
8347 | OPTI_TYPE_NOT_ITERATED
8348 | OPTI_TYPE_PREPENDED_SALT
8349 | OPTI_TYPE_RAW_HASH;
8350 dgst_pos0 = 3;
8351 dgst_pos1 = 7;
8352 dgst_pos2 = 2;
8353 dgst_pos3 = 6;
8354 break;
8355
8356 case 1421: hash_type = HASH_TYPE_SHA256;
8357 salt_type = SALT_TYPE_EMBEDDED;
8358 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8359 opts_type = OPTS_TYPE_PT_GENERATE_BE
8360 | OPTS_TYPE_PT_ADD80
8361 | OPTS_TYPE_PT_ADDBITS15;
8362 kern_type = KERN_TYPE_SHA256_SLTPW;
8363 dgst_size = DGST_SIZE_4_8;
8364 parse_func = hmailserver_parse_hash;
8365 sort_by_digest = sort_by_digest_4_8;
8366 opti_type = OPTI_TYPE_ZERO_BYTE
8367 | OPTI_TYPE_PRECOMPUTE_INIT
8368 | OPTI_TYPE_PRECOMPUTE_MERKLE
8369 | OPTI_TYPE_EARLY_SKIP
8370 | OPTI_TYPE_NOT_ITERATED
8371 | OPTI_TYPE_PREPENDED_SALT
8372 | OPTI_TYPE_RAW_HASH;
8373 dgst_pos0 = 3;
8374 dgst_pos1 = 7;
8375 dgst_pos2 = 2;
8376 dgst_pos3 = 6;
8377 break;
8378
8379 case 1430: hash_type = HASH_TYPE_SHA256;
8380 salt_type = SALT_TYPE_INTERN;
8381 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8382 opts_type = OPTS_TYPE_PT_GENERATE_BE
8383 | OPTS_TYPE_PT_UNICODE
8384 | OPTS_TYPE_ST_ADD80
8385 | OPTS_TYPE_ST_ADDBITS15;
8386 kern_type = KERN_TYPE_SHA256_PWUSLT;
8387 dgst_size = DGST_SIZE_4_8;
8388 parse_func = sha256s_parse_hash;
8389 sort_by_digest = sort_by_digest_4_8;
8390 opti_type = OPTI_TYPE_ZERO_BYTE
8391 | OPTI_TYPE_PRECOMPUTE_INIT
8392 | OPTI_TYPE_PRECOMPUTE_MERKLE
8393 | OPTI_TYPE_EARLY_SKIP
8394 | OPTI_TYPE_NOT_ITERATED
8395 | OPTI_TYPE_APPENDED_SALT
8396 | OPTI_TYPE_RAW_HASH;
8397 dgst_pos0 = 3;
8398 dgst_pos1 = 7;
8399 dgst_pos2 = 2;
8400 dgst_pos3 = 6;
8401 break;
8402
8403 case 1440: hash_type = HASH_TYPE_SHA256;
8404 salt_type = SALT_TYPE_INTERN;
8405 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8406 opts_type = OPTS_TYPE_PT_GENERATE_BE
8407 | OPTS_TYPE_PT_ADD80
8408 | OPTS_TYPE_PT_ADDBITS15
8409 | OPTS_TYPE_PT_UNICODE;
8410 kern_type = KERN_TYPE_SHA256_SLTPWU;
8411 dgst_size = DGST_SIZE_4_8;
8412 parse_func = sha256s_parse_hash;
8413 sort_by_digest = sort_by_digest_4_8;
8414 opti_type = OPTI_TYPE_ZERO_BYTE
8415 | OPTI_TYPE_PRECOMPUTE_INIT
8416 | OPTI_TYPE_PRECOMPUTE_MERKLE
8417 | OPTI_TYPE_EARLY_SKIP
8418 | OPTI_TYPE_NOT_ITERATED
8419 | OPTI_TYPE_PREPENDED_SALT
8420 | OPTI_TYPE_RAW_HASH;
8421 dgst_pos0 = 3;
8422 dgst_pos1 = 7;
8423 dgst_pos2 = 2;
8424 dgst_pos3 = 6;
8425 break;
8426
8427 case 1441: hash_type = HASH_TYPE_SHA256;
8428 salt_type = SALT_TYPE_EMBEDDED;
8429 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8430 opts_type = OPTS_TYPE_PT_GENERATE_BE
8431 | OPTS_TYPE_PT_ADD80
8432 | OPTS_TYPE_PT_ADDBITS15
8433 | OPTS_TYPE_PT_UNICODE
8434 | OPTS_TYPE_ST_BASE64;
8435 kern_type = KERN_TYPE_SHA256_SLTPWU;
8436 dgst_size = DGST_SIZE_4_8;
8437 parse_func = episerver4_parse_hash;
8438 sort_by_digest = sort_by_digest_4_8;
8439 opti_type = OPTI_TYPE_ZERO_BYTE
8440 | OPTI_TYPE_PRECOMPUTE_INIT
8441 | OPTI_TYPE_PRECOMPUTE_MERKLE
8442 | OPTI_TYPE_EARLY_SKIP
8443 | OPTI_TYPE_NOT_ITERATED
8444 | OPTI_TYPE_PREPENDED_SALT
8445 | OPTI_TYPE_RAW_HASH;
8446 dgst_pos0 = 3;
8447 dgst_pos1 = 7;
8448 dgst_pos2 = 2;
8449 dgst_pos3 = 6;
8450 break;
8451
8452 case 1450: hash_type = HASH_TYPE_SHA256;
8453 salt_type = SALT_TYPE_INTERN;
8454 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8455 opts_type = OPTS_TYPE_PT_GENERATE_BE
8456 | OPTS_TYPE_ST_ADD80;
8457 kern_type = KERN_TYPE_HMACSHA256_PW;
8458 dgst_size = DGST_SIZE_4_8;
8459 parse_func = hmacsha256_parse_hash;
8460 sort_by_digest = sort_by_digest_4_8;
8461 opti_type = OPTI_TYPE_ZERO_BYTE
8462 | OPTI_TYPE_NOT_ITERATED;
8463 dgst_pos0 = 3;
8464 dgst_pos1 = 7;
8465 dgst_pos2 = 2;
8466 dgst_pos3 = 6;
8467 break;
8468
8469 case 1460: hash_type = HASH_TYPE_SHA256;
8470 salt_type = SALT_TYPE_INTERN;
8471 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8472 opts_type = OPTS_TYPE_PT_GENERATE_BE
8473 | OPTS_TYPE_PT_ADD80
8474 | OPTS_TYPE_PT_ADDBITS15;
8475 kern_type = KERN_TYPE_HMACSHA256_SLT;
8476 dgst_size = DGST_SIZE_4_8;
8477 parse_func = hmacsha256_parse_hash;
8478 sort_by_digest = sort_by_digest_4_8;
8479 opti_type = OPTI_TYPE_ZERO_BYTE
8480 | OPTI_TYPE_NOT_ITERATED;
8481 dgst_pos0 = 3;
8482 dgst_pos1 = 7;
8483 dgst_pos2 = 2;
8484 dgst_pos3 = 6;
8485 break;
8486
8487 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8488 salt_type = SALT_TYPE_EMBEDDED;
8489 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8490 opts_type = OPTS_TYPE_PT_GENERATE_LE
8491 | OPTS_TYPE_PT_BITSLICE;
8492 kern_type = KERN_TYPE_DESCRYPT;
8493 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8494 parse_func = descrypt_parse_hash;
8495 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8496 opti_type = OPTI_TYPE_ZERO_BYTE
8497 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8498 dgst_pos0 = 0;
8499 dgst_pos1 = 1;
8500 dgst_pos2 = 2;
8501 dgst_pos3 = 3;
8502 break;
8503
8504 case 1600: hash_type = HASH_TYPE_MD5;
8505 salt_type = SALT_TYPE_EMBEDDED;
8506 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8507 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8508 kern_type = KERN_TYPE_APR1CRYPT;
8509 dgst_size = DGST_SIZE_4_4;
8510 parse_func = md5apr1_parse_hash;
8511 sort_by_digest = sort_by_digest_4_4;
8512 opti_type = OPTI_TYPE_ZERO_BYTE;
8513 dgst_pos0 = 0;
8514 dgst_pos1 = 1;
8515 dgst_pos2 = 2;
8516 dgst_pos3 = 3;
8517 break;
8518
8519 case 1700: hash_type = HASH_TYPE_SHA512;
8520 salt_type = SALT_TYPE_NONE;
8521 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8522 opts_type = OPTS_TYPE_PT_GENERATE_BE
8523 | OPTS_TYPE_PT_ADD80
8524 | OPTS_TYPE_PT_ADDBITS15;
8525 kern_type = KERN_TYPE_SHA512;
8526 dgst_size = DGST_SIZE_8_8;
8527 parse_func = sha512_parse_hash;
8528 sort_by_digest = sort_by_digest_8_8;
8529 opti_type = OPTI_TYPE_ZERO_BYTE
8530 | OPTI_TYPE_PRECOMPUTE_INIT
8531 | OPTI_TYPE_PRECOMPUTE_MERKLE
8532 | OPTI_TYPE_EARLY_SKIP
8533 | OPTI_TYPE_NOT_ITERATED
8534 | OPTI_TYPE_NOT_SALTED
8535 | OPTI_TYPE_USES_BITS_64
8536 | OPTI_TYPE_RAW_HASH;
8537 dgst_pos0 = 14;
8538 dgst_pos1 = 15;
8539 dgst_pos2 = 6;
8540 dgst_pos3 = 7;
8541 break;
8542
8543 case 1710: hash_type = HASH_TYPE_SHA512;
8544 salt_type = SALT_TYPE_INTERN;
8545 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8546 opts_type = OPTS_TYPE_PT_GENERATE_BE
8547 | OPTS_TYPE_ST_ADD80
8548 | OPTS_TYPE_ST_ADDBITS15;
8549 kern_type = KERN_TYPE_SHA512_PWSLT;
8550 dgst_size = DGST_SIZE_8_8;
8551 parse_func = sha512s_parse_hash;
8552 sort_by_digest = sort_by_digest_8_8;
8553 opti_type = OPTI_TYPE_ZERO_BYTE
8554 | OPTI_TYPE_PRECOMPUTE_INIT
8555 | OPTI_TYPE_PRECOMPUTE_MERKLE
8556 | OPTI_TYPE_EARLY_SKIP
8557 | OPTI_TYPE_NOT_ITERATED
8558 | OPTI_TYPE_APPENDED_SALT
8559 | OPTI_TYPE_USES_BITS_64
8560 | OPTI_TYPE_RAW_HASH;
8561 dgst_pos0 = 14;
8562 dgst_pos1 = 15;
8563 dgst_pos2 = 6;
8564 dgst_pos3 = 7;
8565 break;
8566
8567 case 1711: hash_type = HASH_TYPE_SHA512;
8568 salt_type = SALT_TYPE_EMBEDDED;
8569 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8570 opts_type = OPTS_TYPE_PT_GENERATE_BE
8571 | OPTS_TYPE_ST_ADD80
8572 | OPTS_TYPE_ST_ADDBITS15;
8573 kern_type = KERN_TYPE_SHA512_PWSLT;
8574 dgst_size = DGST_SIZE_8_8;
8575 parse_func = sha512b64s_parse_hash;
8576 sort_by_digest = sort_by_digest_8_8;
8577 opti_type = OPTI_TYPE_ZERO_BYTE
8578 | OPTI_TYPE_PRECOMPUTE_INIT
8579 | OPTI_TYPE_PRECOMPUTE_MERKLE
8580 | OPTI_TYPE_EARLY_SKIP
8581 | OPTI_TYPE_NOT_ITERATED
8582 | OPTI_TYPE_APPENDED_SALT
8583 | OPTI_TYPE_USES_BITS_64
8584 | OPTI_TYPE_RAW_HASH;
8585 dgst_pos0 = 14;
8586 dgst_pos1 = 15;
8587 dgst_pos2 = 6;
8588 dgst_pos3 = 7;
8589 break;
8590
8591 case 1720: hash_type = HASH_TYPE_SHA512;
8592 salt_type = SALT_TYPE_INTERN;
8593 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8594 opts_type = OPTS_TYPE_PT_GENERATE_BE
8595 | OPTS_TYPE_PT_ADD80
8596 | OPTS_TYPE_PT_ADDBITS15;
8597 kern_type = KERN_TYPE_SHA512_SLTPW;
8598 dgst_size = DGST_SIZE_8_8;
8599 parse_func = sha512s_parse_hash;
8600 sort_by_digest = sort_by_digest_8_8;
8601 opti_type = OPTI_TYPE_ZERO_BYTE
8602 | OPTI_TYPE_PRECOMPUTE_INIT
8603 | OPTI_TYPE_PRECOMPUTE_MERKLE
8604 | OPTI_TYPE_EARLY_SKIP
8605 | OPTI_TYPE_NOT_ITERATED
8606 | OPTI_TYPE_PREPENDED_SALT
8607 | OPTI_TYPE_USES_BITS_64
8608 | OPTI_TYPE_RAW_HASH;
8609 dgst_pos0 = 14;
8610 dgst_pos1 = 15;
8611 dgst_pos2 = 6;
8612 dgst_pos3 = 7;
8613 break;
8614
8615 case 1722: hash_type = HASH_TYPE_SHA512;
8616 salt_type = SALT_TYPE_EMBEDDED;
8617 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8618 opts_type = OPTS_TYPE_PT_GENERATE_BE
8619 | OPTS_TYPE_PT_ADD80
8620 | OPTS_TYPE_PT_ADDBITS15
8621 | OPTS_TYPE_ST_HEX;
8622 kern_type = KERN_TYPE_SHA512_SLTPW;
8623 dgst_size = DGST_SIZE_8_8;
8624 parse_func = osx512_parse_hash;
8625 sort_by_digest = sort_by_digest_8_8;
8626 opti_type = OPTI_TYPE_ZERO_BYTE
8627 | OPTI_TYPE_PRECOMPUTE_INIT
8628 | OPTI_TYPE_PRECOMPUTE_MERKLE
8629 | OPTI_TYPE_EARLY_SKIP
8630 | OPTI_TYPE_NOT_ITERATED
8631 | OPTI_TYPE_PREPENDED_SALT
8632 | OPTI_TYPE_USES_BITS_64
8633 | OPTI_TYPE_RAW_HASH;
8634 dgst_pos0 = 14;
8635 dgst_pos1 = 15;
8636 dgst_pos2 = 6;
8637 dgst_pos3 = 7;
8638 break;
8639
8640 case 1730: hash_type = HASH_TYPE_SHA512;
8641 salt_type = SALT_TYPE_INTERN;
8642 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8643 opts_type = OPTS_TYPE_PT_GENERATE_BE
8644 | OPTS_TYPE_PT_UNICODE
8645 | OPTS_TYPE_ST_ADD80
8646 | OPTS_TYPE_ST_ADDBITS15;
8647 kern_type = KERN_TYPE_SHA512_PWSLTU;
8648 dgst_size = DGST_SIZE_8_8;
8649 parse_func = sha512s_parse_hash;
8650 sort_by_digest = sort_by_digest_8_8;
8651 opti_type = OPTI_TYPE_ZERO_BYTE
8652 | OPTI_TYPE_PRECOMPUTE_INIT
8653 | OPTI_TYPE_PRECOMPUTE_MERKLE
8654 | OPTI_TYPE_EARLY_SKIP
8655 | OPTI_TYPE_NOT_ITERATED
8656 | OPTI_TYPE_APPENDED_SALT
8657 | OPTI_TYPE_USES_BITS_64
8658 | OPTI_TYPE_RAW_HASH;
8659 dgst_pos0 = 14;
8660 dgst_pos1 = 15;
8661 dgst_pos2 = 6;
8662 dgst_pos3 = 7;
8663 break;
8664
8665 case 1731: hash_type = HASH_TYPE_SHA512;
8666 salt_type = SALT_TYPE_EMBEDDED;
8667 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8668 opts_type = OPTS_TYPE_PT_GENERATE_BE
8669 | OPTS_TYPE_PT_UNICODE
8670 | OPTS_TYPE_ST_ADD80
8671 | OPTS_TYPE_ST_ADDBITS15
8672 | OPTS_TYPE_ST_HEX;
8673 kern_type = KERN_TYPE_SHA512_PWSLTU;
8674 dgst_size = DGST_SIZE_8_8;
8675 parse_func = mssql2012_parse_hash;
8676 sort_by_digest = sort_by_digest_8_8;
8677 opti_type = OPTI_TYPE_ZERO_BYTE
8678 | OPTI_TYPE_PRECOMPUTE_INIT
8679 | OPTI_TYPE_PRECOMPUTE_MERKLE
8680 | OPTI_TYPE_EARLY_SKIP
8681 | OPTI_TYPE_NOT_ITERATED
8682 | OPTI_TYPE_APPENDED_SALT
8683 | OPTI_TYPE_USES_BITS_64
8684 | OPTI_TYPE_RAW_HASH;
8685 dgst_pos0 = 14;
8686 dgst_pos1 = 15;
8687 dgst_pos2 = 6;
8688 dgst_pos3 = 7;
8689 break;
8690
8691 case 1740: hash_type = HASH_TYPE_SHA512;
8692 salt_type = SALT_TYPE_INTERN;
8693 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8694 opts_type = OPTS_TYPE_PT_GENERATE_BE
8695 | OPTS_TYPE_PT_ADD80
8696 | OPTS_TYPE_PT_ADDBITS15
8697 | OPTS_TYPE_PT_UNICODE;
8698 kern_type = KERN_TYPE_SHA512_SLTPWU;
8699 dgst_size = DGST_SIZE_8_8;
8700 parse_func = sha512s_parse_hash;
8701 sort_by_digest = sort_by_digest_8_8;
8702 opti_type = OPTI_TYPE_ZERO_BYTE
8703 | OPTI_TYPE_PRECOMPUTE_INIT
8704 | OPTI_TYPE_PRECOMPUTE_MERKLE
8705 | OPTI_TYPE_EARLY_SKIP
8706 | OPTI_TYPE_NOT_ITERATED
8707 | OPTI_TYPE_PREPENDED_SALT
8708 | OPTI_TYPE_USES_BITS_64
8709 | OPTI_TYPE_RAW_HASH;
8710 dgst_pos0 = 14;
8711 dgst_pos1 = 15;
8712 dgst_pos2 = 6;
8713 dgst_pos3 = 7;
8714 break;
8715
8716 case 1750: hash_type = HASH_TYPE_SHA512;
8717 salt_type = SALT_TYPE_INTERN;
8718 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8719 opts_type = OPTS_TYPE_PT_GENERATE_BE
8720 | OPTS_TYPE_ST_ADD80;
8721 kern_type = KERN_TYPE_HMACSHA512_PW;
8722 dgst_size = DGST_SIZE_8_8;
8723 parse_func = hmacsha512_parse_hash;
8724 sort_by_digest = sort_by_digest_8_8;
8725 opti_type = OPTI_TYPE_ZERO_BYTE
8726 | OPTI_TYPE_USES_BITS_64
8727 | OPTI_TYPE_NOT_ITERATED;
8728 dgst_pos0 = 14;
8729 dgst_pos1 = 15;
8730 dgst_pos2 = 6;
8731 dgst_pos3 = 7;
8732 break;
8733
8734 case 1760: hash_type = HASH_TYPE_SHA512;
8735 salt_type = SALT_TYPE_INTERN;
8736 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8737 opts_type = OPTS_TYPE_PT_GENERATE_BE
8738 | OPTS_TYPE_PT_ADD80
8739 | OPTS_TYPE_PT_ADDBITS15;
8740 kern_type = KERN_TYPE_HMACSHA512_SLT;
8741 dgst_size = DGST_SIZE_8_8;
8742 parse_func = hmacsha512_parse_hash;
8743 sort_by_digest = sort_by_digest_8_8;
8744 opti_type = OPTI_TYPE_ZERO_BYTE
8745 | OPTI_TYPE_USES_BITS_64
8746 | OPTI_TYPE_NOT_ITERATED;
8747 dgst_pos0 = 14;
8748 dgst_pos1 = 15;
8749 dgst_pos2 = 6;
8750 dgst_pos3 = 7;
8751 break;
8752
8753 case 1800: hash_type = HASH_TYPE_SHA512;
8754 salt_type = SALT_TYPE_EMBEDDED;
8755 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8756 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8757 kern_type = KERN_TYPE_SHA512CRYPT;
8758 dgst_size = DGST_SIZE_8_8;
8759 parse_func = sha512crypt_parse_hash;
8760 sort_by_digest = sort_by_digest_8_8;
8761 opti_type = OPTI_TYPE_ZERO_BYTE
8762 | OPTI_TYPE_USES_BITS_64;
8763 dgst_pos0 = 0;
8764 dgst_pos1 = 1;
8765 dgst_pos2 = 2;
8766 dgst_pos3 = 3;
8767 break;
8768
8769 case 2000: hash_type = HASH_TYPE_STDOUT;
8770 salt_type = SALT_TYPE_NONE;
8771 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8772 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8773 kern_type = KERN_TYPE_STDOUT;
8774 dgst_size = DGST_SIZE_4_4;
8775 parse_func = NULL;
8776 sort_by_digest = NULL;
8777 opti_type = 0;
8778 dgst_pos0 = 0;
8779 dgst_pos1 = 0;
8780 dgst_pos2 = 0;
8781 dgst_pos3 = 0;
8782 break;
8783
8784 case 2100: hash_type = HASH_TYPE_DCC2;
8785 salt_type = SALT_TYPE_EMBEDDED;
8786 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8787 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8788 | OPTS_TYPE_ST_LOWER
8789 | OPTS_TYPE_ST_UNICODE;
8790 kern_type = KERN_TYPE_DCC2;
8791 dgst_size = DGST_SIZE_4_4;
8792 parse_func = dcc2_parse_hash;
8793 sort_by_digest = sort_by_digest_4_4;
8794 opti_type = OPTI_TYPE_ZERO_BYTE
8795 | OPTI_TYPE_SLOW_HASH_SIMD;
8796 dgst_pos0 = 0;
8797 dgst_pos1 = 1;
8798 dgst_pos2 = 2;
8799 dgst_pos3 = 3;
8800 break;
8801
8802 case 2400: hash_type = HASH_TYPE_MD5;
8803 salt_type = SALT_TYPE_NONE;
8804 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8805 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8806 kern_type = KERN_TYPE_MD5PIX;
8807 dgst_size = DGST_SIZE_4_4;
8808 parse_func = md5pix_parse_hash;
8809 sort_by_digest = sort_by_digest_4_4;
8810 opti_type = OPTI_TYPE_ZERO_BYTE
8811 | OPTI_TYPE_PRECOMPUTE_INIT
8812 | OPTI_TYPE_PRECOMPUTE_MERKLE
8813 | OPTI_TYPE_EARLY_SKIP
8814 | OPTI_TYPE_NOT_ITERATED
8815 | OPTI_TYPE_NOT_SALTED;
8816 dgst_pos0 = 0;
8817 dgst_pos1 = 3;
8818 dgst_pos2 = 2;
8819 dgst_pos3 = 1;
8820 break;
8821
8822 case 2410: hash_type = HASH_TYPE_MD5;
8823 salt_type = SALT_TYPE_INTERN;
8824 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8825 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8826 kern_type = KERN_TYPE_MD5ASA;
8827 dgst_size = DGST_SIZE_4_4;
8828 parse_func = md5asa_parse_hash;
8829 sort_by_digest = sort_by_digest_4_4;
8830 opti_type = OPTI_TYPE_ZERO_BYTE
8831 | OPTI_TYPE_PRECOMPUTE_INIT
8832 | OPTI_TYPE_PRECOMPUTE_MERKLE
8833 | OPTI_TYPE_EARLY_SKIP
8834 | OPTI_TYPE_NOT_ITERATED;
8835 dgst_pos0 = 0;
8836 dgst_pos1 = 3;
8837 dgst_pos2 = 2;
8838 dgst_pos3 = 1;
8839 break;
8840
8841 case 2500: hash_type = HASH_TYPE_WPA;
8842 salt_type = SALT_TYPE_EMBEDDED;
8843 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8844 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8845 kern_type = KERN_TYPE_WPA;
8846 dgst_size = DGST_SIZE_4_4;
8847 parse_func = wpa_parse_hash;
8848 sort_by_digest = sort_by_digest_4_4;
8849 opti_type = OPTI_TYPE_ZERO_BYTE
8850 | OPTI_TYPE_SLOW_HASH_SIMD;
8851 dgst_pos0 = 0;
8852 dgst_pos1 = 1;
8853 dgst_pos2 = 2;
8854 dgst_pos3 = 3;
8855 break;
8856
8857 case 2600: hash_type = HASH_TYPE_MD5;
8858 salt_type = SALT_TYPE_VIRTUAL;
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 | OPTS_TYPE_ST_ADD80;
8864 kern_type = KERN_TYPE_MD55_PWSLT1;
8865 dgst_size = DGST_SIZE_4_4;
8866 parse_func = md5md5_parse_hash;
8867 sort_by_digest = sort_by_digest_4_4;
8868 opti_type = OPTI_TYPE_ZERO_BYTE
8869 | OPTI_TYPE_PRECOMPUTE_INIT
8870 | OPTI_TYPE_PRECOMPUTE_MERKLE
8871 | OPTI_TYPE_EARLY_SKIP;
8872 dgst_pos0 = 0;
8873 dgst_pos1 = 3;
8874 dgst_pos2 = 2;
8875 dgst_pos3 = 1;
8876 break;
8877
8878 case 2611: hash_type = HASH_TYPE_MD5;
8879 salt_type = SALT_TYPE_INTERN;
8880 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8881 opts_type = OPTS_TYPE_PT_GENERATE_LE
8882 | OPTS_TYPE_PT_ADD80
8883 | OPTS_TYPE_PT_ADDBITS14
8884 | OPTS_TYPE_ST_ADD80;
8885 kern_type = KERN_TYPE_MD55_PWSLT1;
8886 dgst_size = DGST_SIZE_4_4;
8887 parse_func = vb3_parse_hash;
8888 sort_by_digest = sort_by_digest_4_4;
8889 opti_type = OPTI_TYPE_ZERO_BYTE
8890 | OPTI_TYPE_PRECOMPUTE_INIT
8891 | OPTI_TYPE_PRECOMPUTE_MERKLE
8892 | OPTI_TYPE_EARLY_SKIP;
8893 dgst_pos0 = 0;
8894 dgst_pos1 = 3;
8895 dgst_pos2 = 2;
8896 dgst_pos3 = 1;
8897 break;
8898
8899 case 2612: hash_type = HASH_TYPE_MD5;
8900 salt_type = SALT_TYPE_EMBEDDED;
8901 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8902 opts_type = OPTS_TYPE_PT_GENERATE_LE
8903 | OPTS_TYPE_PT_ADD80
8904 | OPTS_TYPE_PT_ADDBITS14
8905 | OPTS_TYPE_ST_ADD80
8906 | OPTS_TYPE_ST_HEX;
8907 kern_type = KERN_TYPE_MD55_PWSLT1;
8908 dgst_size = DGST_SIZE_4_4;
8909 parse_func = phps_parse_hash;
8910 sort_by_digest = sort_by_digest_4_4;
8911 opti_type = OPTI_TYPE_ZERO_BYTE
8912 | OPTI_TYPE_PRECOMPUTE_INIT
8913 | OPTI_TYPE_PRECOMPUTE_MERKLE
8914 | OPTI_TYPE_EARLY_SKIP;
8915 dgst_pos0 = 0;
8916 dgst_pos1 = 3;
8917 dgst_pos2 = 2;
8918 dgst_pos3 = 1;
8919 break;
8920
8921 case 2711: hash_type = HASH_TYPE_MD5;
8922 salt_type = SALT_TYPE_INTERN;
8923 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8924 opts_type = OPTS_TYPE_PT_GENERATE_LE
8925 | OPTS_TYPE_PT_ADD80
8926 | OPTS_TYPE_PT_ADDBITS14
8927 | OPTS_TYPE_ST_ADD80;
8928 kern_type = KERN_TYPE_MD55_PWSLT2;
8929 dgst_size = DGST_SIZE_4_4;
8930 parse_func = vb30_parse_hash;
8931 sort_by_digest = sort_by_digest_4_4;
8932 opti_type = OPTI_TYPE_ZERO_BYTE
8933 | OPTI_TYPE_PRECOMPUTE_INIT
8934 | OPTI_TYPE_EARLY_SKIP;
8935 dgst_pos0 = 0;
8936 dgst_pos1 = 3;
8937 dgst_pos2 = 2;
8938 dgst_pos3 = 1;
8939 break;
8940
8941 case 2811: hash_type = HASH_TYPE_MD5;
8942 salt_type = SALT_TYPE_INTERN;
8943 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8944 opts_type = OPTS_TYPE_PT_GENERATE_LE
8945 | OPTS_TYPE_PT_ADD80
8946 | OPTS_TYPE_PT_ADDBITS14;
8947 kern_type = KERN_TYPE_MD55_SLTPW;
8948 dgst_size = DGST_SIZE_4_4;
8949 parse_func = ipb2_parse_hash;
8950 sort_by_digest = sort_by_digest_4_4;
8951 opti_type = OPTI_TYPE_ZERO_BYTE
8952 | OPTI_TYPE_PRECOMPUTE_INIT
8953 | OPTI_TYPE_EARLY_SKIP;
8954 dgst_pos0 = 0;
8955 dgst_pos1 = 3;
8956 dgst_pos2 = 2;
8957 dgst_pos3 = 1;
8958 break;
8959
8960 case 3000: hash_type = HASH_TYPE_LM;
8961 salt_type = SALT_TYPE_NONE;
8962 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8963 opts_type = OPTS_TYPE_PT_GENERATE_LE
8964 | OPTS_TYPE_PT_UPPER
8965 | OPTS_TYPE_PT_BITSLICE;
8966 kern_type = KERN_TYPE_LM;
8967 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8968 parse_func = lm_parse_hash;
8969 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8970 opti_type = OPTI_TYPE_ZERO_BYTE
8971 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8972 dgst_pos0 = 0;
8973 dgst_pos1 = 1;
8974 dgst_pos2 = 2;
8975 dgst_pos3 = 3;
8976 break;
8977
8978 case 3100: hash_type = HASH_TYPE_ORACLEH;
8979 salt_type = SALT_TYPE_INTERN;
8980 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8981 opts_type = OPTS_TYPE_PT_GENERATE_LE
8982 | OPTS_TYPE_PT_UPPER
8983 | OPTS_TYPE_ST_UPPER;
8984 kern_type = KERN_TYPE_ORACLEH;
8985 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8986 parse_func = oracleh_parse_hash;
8987 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8988 opti_type = OPTI_TYPE_ZERO_BYTE;
8989 dgst_pos0 = 0;
8990 dgst_pos1 = 1;
8991 dgst_pos2 = 2;
8992 dgst_pos3 = 3;
8993 break;
8994
8995 case 3200: hash_type = HASH_TYPE_BCRYPT;
8996 salt_type = SALT_TYPE_EMBEDDED;
8997 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8998 opts_type = OPTS_TYPE_PT_GENERATE_LE
8999 | OPTS_TYPE_ST_GENERATE_LE;
9000 kern_type = KERN_TYPE_BCRYPT;
9001 dgst_size = DGST_SIZE_4_6;
9002 parse_func = bcrypt_parse_hash;
9003 sort_by_digest = sort_by_digest_4_6;
9004 opti_type = OPTI_TYPE_ZERO_BYTE;
9005 dgst_pos0 = 0;
9006 dgst_pos1 = 1;
9007 dgst_pos2 = 2;
9008 dgst_pos3 = 3;
9009 break;
9010
9011 case 3710: hash_type = HASH_TYPE_MD5;
9012 salt_type = SALT_TYPE_INTERN;
9013 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9014 opts_type = OPTS_TYPE_PT_GENERATE_LE
9015 | OPTS_TYPE_PT_ADD80
9016 | OPTS_TYPE_PT_ADDBITS14;
9017 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9018 dgst_size = DGST_SIZE_4_4;
9019 parse_func = md5s_parse_hash;
9020 sort_by_digest = sort_by_digest_4_4;
9021 opti_type = OPTI_TYPE_ZERO_BYTE
9022 | OPTI_TYPE_PRECOMPUTE_INIT
9023 | OPTI_TYPE_PRECOMPUTE_MERKLE
9024 | OPTI_TYPE_EARLY_SKIP;
9025 dgst_pos0 = 0;
9026 dgst_pos1 = 3;
9027 dgst_pos2 = 2;
9028 dgst_pos3 = 1;
9029 break;
9030
9031 case 3711: hash_type = HASH_TYPE_MD5;
9032 salt_type = SALT_TYPE_EMBEDDED;
9033 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9034 opts_type = OPTS_TYPE_PT_GENERATE_LE
9035 | OPTS_TYPE_PT_ADD80
9036 | OPTS_TYPE_PT_ADDBITS14;
9037 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9038 dgst_size = DGST_SIZE_4_4;
9039 parse_func = mediawiki_b_parse_hash;
9040 sort_by_digest = sort_by_digest_4_4;
9041 opti_type = OPTI_TYPE_ZERO_BYTE
9042 | OPTI_TYPE_PRECOMPUTE_INIT
9043 | OPTI_TYPE_PRECOMPUTE_MERKLE
9044 | OPTI_TYPE_EARLY_SKIP;
9045 dgst_pos0 = 0;
9046 dgst_pos1 = 3;
9047 dgst_pos2 = 2;
9048 dgst_pos3 = 1;
9049 break;
9050
9051 case 3800: hash_type = HASH_TYPE_MD5;
9052 salt_type = SALT_TYPE_INTERN;
9053 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9054 opts_type = OPTS_TYPE_PT_GENERATE_LE
9055 | OPTS_TYPE_ST_ADDBITS14;
9056 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
9057 dgst_size = DGST_SIZE_4_4;
9058 parse_func = md5s_parse_hash;
9059 sort_by_digest = sort_by_digest_4_4;
9060 opti_type = OPTI_TYPE_ZERO_BYTE
9061 | OPTI_TYPE_PRECOMPUTE_INIT
9062 | OPTI_TYPE_PRECOMPUTE_MERKLE
9063 | OPTI_TYPE_EARLY_SKIP
9064 | OPTI_TYPE_NOT_ITERATED
9065 | OPTI_TYPE_RAW_HASH;
9066 dgst_pos0 = 0;
9067 dgst_pos1 = 3;
9068 dgst_pos2 = 2;
9069 dgst_pos3 = 1;
9070 break;
9071
9072 case 4300: hash_type = HASH_TYPE_MD5;
9073 salt_type = SALT_TYPE_VIRTUAL;
9074 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9075 opts_type = OPTS_TYPE_PT_GENERATE_LE
9076 | OPTS_TYPE_PT_ADD80
9077 | OPTS_TYPE_PT_ADDBITS14
9078 | OPTS_TYPE_ST_ADD80;
9079 kern_type = KERN_TYPE_MD5U5_PWSLT1;
9080 dgst_size = DGST_SIZE_4_4;
9081 parse_func = md5md5_parse_hash;
9082 sort_by_digest = sort_by_digest_4_4;
9083 opti_type = OPTI_TYPE_ZERO_BYTE
9084 | OPTI_TYPE_PRECOMPUTE_INIT
9085 | OPTI_TYPE_PRECOMPUTE_MERKLE
9086 | OPTI_TYPE_EARLY_SKIP;
9087 dgst_pos0 = 0;
9088 dgst_pos1 = 3;
9089 dgst_pos2 = 2;
9090 dgst_pos3 = 1;
9091 break;
9092
9093
9094 case 4400: hash_type = HASH_TYPE_MD5;
9095 salt_type = SALT_TYPE_NONE;
9096 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9097 opts_type = OPTS_TYPE_PT_GENERATE_BE
9098 | OPTS_TYPE_PT_ADD80
9099 | OPTS_TYPE_PT_ADDBITS15;
9100 kern_type = KERN_TYPE_MD5_SHA1;
9101 dgst_size = DGST_SIZE_4_4;
9102 parse_func = md5_parse_hash;
9103 sort_by_digest = sort_by_digest_4_4;
9104 opti_type = OPTI_TYPE_ZERO_BYTE
9105 | OPTI_TYPE_PRECOMPUTE_INIT
9106 | OPTI_TYPE_PRECOMPUTE_MERKLE
9107 | OPTI_TYPE_EARLY_SKIP
9108 | OPTI_TYPE_NOT_ITERATED
9109 | OPTI_TYPE_NOT_SALTED
9110 | OPTI_TYPE_RAW_HASH;
9111 dgst_pos0 = 0;
9112 dgst_pos1 = 3;
9113 dgst_pos2 = 2;
9114 dgst_pos3 = 1;
9115 break;
9116
9117 case 4500: hash_type = HASH_TYPE_SHA1;
9118 salt_type = SALT_TYPE_NONE;
9119 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9120 opts_type = OPTS_TYPE_PT_GENERATE_BE
9121 | OPTS_TYPE_PT_ADD80
9122 | OPTS_TYPE_PT_ADDBITS15;
9123 kern_type = KERN_TYPE_SHA11;
9124 dgst_size = DGST_SIZE_4_5;
9125 parse_func = sha1_parse_hash;
9126 sort_by_digest = sort_by_digest_4_5;
9127 opti_type = OPTI_TYPE_ZERO_BYTE
9128 | OPTI_TYPE_PRECOMPUTE_INIT
9129 | OPTI_TYPE_PRECOMPUTE_MERKLE
9130 | OPTI_TYPE_EARLY_SKIP
9131 | OPTI_TYPE_NOT_SALTED;
9132 dgst_pos0 = 3;
9133 dgst_pos1 = 4;
9134 dgst_pos2 = 2;
9135 dgst_pos3 = 1;
9136 break;
9137
9138 case 4700: hash_type = HASH_TYPE_SHA1;
9139 salt_type = SALT_TYPE_NONE;
9140 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9141 opts_type = OPTS_TYPE_PT_GENERATE_LE
9142 | OPTS_TYPE_PT_ADD80
9143 | OPTS_TYPE_PT_ADDBITS14;
9144 kern_type = KERN_TYPE_SHA1_MD5;
9145 dgst_size = DGST_SIZE_4_5;
9146 parse_func = sha1_parse_hash;
9147 sort_by_digest = sort_by_digest_4_5;
9148 opti_type = OPTI_TYPE_ZERO_BYTE
9149 | OPTI_TYPE_PRECOMPUTE_INIT
9150 | OPTI_TYPE_PRECOMPUTE_MERKLE
9151 | OPTI_TYPE_EARLY_SKIP
9152 | OPTI_TYPE_NOT_ITERATED
9153 | OPTI_TYPE_NOT_SALTED
9154 | OPTI_TYPE_RAW_HASH;
9155 dgst_pos0 = 3;
9156 dgst_pos1 = 4;
9157 dgst_pos2 = 2;
9158 dgst_pos3 = 1;
9159 break;
9160
9161 case 4800: hash_type = HASH_TYPE_MD5;
9162 salt_type = SALT_TYPE_EMBEDDED;
9163 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9164 opts_type = OPTS_TYPE_PT_GENERATE_LE
9165 | OPTS_TYPE_PT_ADDBITS14;
9166 kern_type = KERN_TYPE_MD5_CHAP;
9167 dgst_size = DGST_SIZE_4_4;
9168 parse_func = chap_parse_hash;
9169 sort_by_digest = sort_by_digest_4_4;
9170 opti_type = OPTI_TYPE_ZERO_BYTE
9171 | OPTI_TYPE_PRECOMPUTE_INIT
9172 | OPTI_TYPE_PRECOMPUTE_MERKLE
9173 | OPTI_TYPE_MEET_IN_MIDDLE
9174 | OPTI_TYPE_EARLY_SKIP
9175 | OPTI_TYPE_NOT_ITERATED
9176 | OPTI_TYPE_RAW_HASH;
9177 dgst_pos0 = 0;
9178 dgst_pos1 = 3;
9179 dgst_pos2 = 2;
9180 dgst_pos3 = 1;
9181 break;
9182
9183 case 4900: hash_type = HASH_TYPE_SHA1;
9184 salt_type = SALT_TYPE_INTERN;
9185 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9186 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9187 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9188 dgst_size = DGST_SIZE_4_5;
9189 parse_func = sha1s_parse_hash;
9190 sort_by_digest = sort_by_digest_4_5;
9191 opti_type = OPTI_TYPE_ZERO_BYTE
9192 | OPTI_TYPE_PRECOMPUTE_INIT
9193 | OPTI_TYPE_PRECOMPUTE_MERKLE
9194 | OPTI_TYPE_EARLY_SKIP;
9195 dgst_pos0 = 3;
9196 dgst_pos1 = 4;
9197 dgst_pos2 = 2;
9198 dgst_pos3 = 1;
9199 break;
9200
9201 case 5000: hash_type = HASH_TYPE_KECCAK;
9202 salt_type = SALT_TYPE_EMBEDDED;
9203 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9204 opts_type = OPTS_TYPE_PT_GENERATE_LE
9205 | OPTS_TYPE_PT_ADD01;
9206 kern_type = KERN_TYPE_KECCAK;
9207 dgst_size = DGST_SIZE_8_25;
9208 parse_func = keccak_parse_hash;
9209 sort_by_digest = sort_by_digest_8_25;
9210 opti_type = OPTI_TYPE_ZERO_BYTE
9211 | OPTI_TYPE_USES_BITS_64
9212 | OPTI_TYPE_RAW_HASH;
9213 dgst_pos0 = 2;
9214 dgst_pos1 = 3;
9215 dgst_pos2 = 4;
9216 dgst_pos3 = 5;
9217 break;
9218
9219 case 5100: hash_type = HASH_TYPE_MD5H;
9220 salt_type = SALT_TYPE_NONE;
9221 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9222 opts_type = OPTS_TYPE_PT_GENERATE_LE
9223 | OPTS_TYPE_PT_ADD80
9224 | OPTS_TYPE_PT_ADDBITS14;
9225 kern_type = KERN_TYPE_MD5H;
9226 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9227 parse_func = md5half_parse_hash;
9228 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9229 opti_type = OPTI_TYPE_ZERO_BYTE
9230 | OPTI_TYPE_RAW_HASH;
9231 dgst_pos0 = 0;
9232 dgst_pos1 = 1;
9233 dgst_pos2 = 2;
9234 dgst_pos3 = 3;
9235 break;
9236
9237 case 5200: hash_type = HASH_TYPE_SHA256;
9238 salt_type = SALT_TYPE_EMBEDDED;
9239 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9240 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9241 kern_type = KERN_TYPE_PSAFE3;
9242 dgst_size = DGST_SIZE_4_8;
9243 parse_func = psafe3_parse_hash;
9244 sort_by_digest = sort_by_digest_4_8;
9245 opti_type = OPTI_TYPE_ZERO_BYTE;
9246 dgst_pos0 = 0;
9247 dgst_pos1 = 1;
9248 dgst_pos2 = 2;
9249 dgst_pos3 = 3;
9250 break;
9251
9252 case 5300: hash_type = HASH_TYPE_MD5;
9253 salt_type = SALT_TYPE_EMBEDDED;
9254 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9255 opts_type = OPTS_TYPE_PT_GENERATE_LE
9256 | OPTS_TYPE_ST_ADD80;
9257 kern_type = KERN_TYPE_IKEPSK_MD5;
9258 dgst_size = DGST_SIZE_4_4;
9259 parse_func = ikepsk_md5_parse_hash;
9260 sort_by_digest = sort_by_digest_4_4;
9261 opti_type = OPTI_TYPE_ZERO_BYTE;
9262 dgst_pos0 = 0;
9263 dgst_pos1 = 3;
9264 dgst_pos2 = 2;
9265 dgst_pos3 = 1;
9266 break;
9267
9268 case 5400: hash_type = HASH_TYPE_SHA1;
9269 salt_type = SALT_TYPE_EMBEDDED;
9270 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9271 opts_type = OPTS_TYPE_PT_GENERATE_BE
9272 | OPTS_TYPE_ST_ADD80;
9273 kern_type = KERN_TYPE_IKEPSK_SHA1;
9274 dgst_size = DGST_SIZE_4_5;
9275 parse_func = ikepsk_sha1_parse_hash;
9276 sort_by_digest = sort_by_digest_4_5;
9277 opti_type = OPTI_TYPE_ZERO_BYTE;
9278 dgst_pos0 = 3;
9279 dgst_pos1 = 4;
9280 dgst_pos2 = 2;
9281 dgst_pos3 = 1;
9282 break;
9283
9284 case 5500: hash_type = HASH_TYPE_NETNTLM;
9285 salt_type = SALT_TYPE_EMBEDDED;
9286 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9287 opts_type = OPTS_TYPE_PT_GENERATE_LE
9288 | OPTS_TYPE_PT_ADD80
9289 | OPTS_TYPE_PT_ADDBITS14
9290 | OPTS_TYPE_PT_UNICODE
9291 | OPTS_TYPE_ST_HEX;
9292 kern_type = KERN_TYPE_NETNTLMv1;
9293 dgst_size = DGST_SIZE_4_4;
9294 parse_func = netntlmv1_parse_hash;
9295 sort_by_digest = sort_by_digest_4_4;
9296 opti_type = OPTI_TYPE_ZERO_BYTE
9297 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9298 dgst_pos0 = 0;
9299 dgst_pos1 = 1;
9300 dgst_pos2 = 2;
9301 dgst_pos3 = 3;
9302 break;
9303
9304 case 5600: hash_type = HASH_TYPE_MD5;
9305 salt_type = SALT_TYPE_EMBEDDED;
9306 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9307 opts_type = OPTS_TYPE_PT_GENERATE_LE
9308 | OPTS_TYPE_PT_ADD80
9309 | OPTS_TYPE_PT_ADDBITS14
9310 | OPTS_TYPE_PT_UNICODE;
9311 kern_type = KERN_TYPE_NETNTLMv2;
9312 dgst_size = DGST_SIZE_4_4;
9313 parse_func = netntlmv2_parse_hash;
9314 sort_by_digest = sort_by_digest_4_4;
9315 opti_type = OPTI_TYPE_ZERO_BYTE;
9316 dgst_pos0 = 0;
9317 dgst_pos1 = 3;
9318 dgst_pos2 = 2;
9319 dgst_pos3 = 1;
9320 break;
9321
9322 case 5700: hash_type = HASH_TYPE_SHA256;
9323 salt_type = SALT_TYPE_NONE;
9324 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9325 opts_type = OPTS_TYPE_PT_GENERATE_BE
9326 | OPTS_TYPE_PT_ADD80
9327 | OPTS_TYPE_PT_ADDBITS15;
9328 kern_type = KERN_TYPE_SHA256;
9329 dgst_size = DGST_SIZE_4_8;
9330 parse_func = cisco4_parse_hash;
9331 sort_by_digest = sort_by_digest_4_8;
9332 opti_type = OPTI_TYPE_ZERO_BYTE
9333 | OPTI_TYPE_PRECOMPUTE_INIT
9334 | OPTI_TYPE_PRECOMPUTE_MERKLE
9335 | OPTI_TYPE_EARLY_SKIP
9336 | OPTI_TYPE_NOT_ITERATED
9337 | OPTI_TYPE_NOT_SALTED
9338 | OPTI_TYPE_RAW_HASH;
9339 dgst_pos0 = 3;
9340 dgst_pos1 = 7;
9341 dgst_pos2 = 2;
9342 dgst_pos3 = 6;
9343 break;
9344
9345 case 5800: hash_type = HASH_TYPE_SHA1;
9346 salt_type = SALT_TYPE_INTERN;
9347 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9348 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9349 | OPTS_TYPE_ST_ADD80;
9350 kern_type = KERN_TYPE_ANDROIDPIN;
9351 dgst_size = DGST_SIZE_4_5;
9352 parse_func = androidpin_parse_hash;
9353 sort_by_digest = sort_by_digest_4_5;
9354 opti_type = OPTI_TYPE_ZERO_BYTE;
9355 dgst_pos0 = 0;
9356 dgst_pos1 = 1;
9357 dgst_pos2 = 2;
9358 dgst_pos3 = 3;
9359 break;
9360
9361 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9362 salt_type = SALT_TYPE_NONE;
9363 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9364 opts_type = OPTS_TYPE_PT_GENERATE_LE
9365 | OPTS_TYPE_PT_ADD80;
9366 kern_type = KERN_TYPE_RIPEMD160;
9367 dgst_size = DGST_SIZE_4_5;
9368 parse_func = ripemd160_parse_hash;
9369 sort_by_digest = sort_by_digest_4_5;
9370 opti_type = OPTI_TYPE_ZERO_BYTE;
9371 dgst_pos0 = 0;
9372 dgst_pos1 = 1;
9373 dgst_pos2 = 2;
9374 dgst_pos3 = 3;
9375 break;
9376
9377 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9378 salt_type = SALT_TYPE_NONE;
9379 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9380 opts_type = OPTS_TYPE_PT_GENERATE_BE
9381 | OPTS_TYPE_PT_ADD80;
9382 kern_type = KERN_TYPE_WHIRLPOOL;
9383 dgst_size = DGST_SIZE_4_16;
9384 parse_func = whirlpool_parse_hash;
9385 sort_by_digest = sort_by_digest_4_16;
9386 opti_type = OPTI_TYPE_ZERO_BYTE;
9387 dgst_pos0 = 0;
9388 dgst_pos1 = 1;
9389 dgst_pos2 = 2;
9390 dgst_pos3 = 3;
9391 break;
9392
9393 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9394 salt_type = SALT_TYPE_EMBEDDED;
9395 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9396 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9397 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9398 dgst_size = DGST_SIZE_4_5;
9399 parse_func = truecrypt_parse_hash_2k;
9400 sort_by_digest = sort_by_digest_4_5;
9401 opti_type = OPTI_TYPE_ZERO_BYTE;
9402 dgst_pos0 = 0;
9403 dgst_pos1 = 1;
9404 dgst_pos2 = 2;
9405 dgst_pos3 = 3;
9406 break;
9407
9408 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9409 salt_type = SALT_TYPE_EMBEDDED;
9410 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9411 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9412 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9413 dgst_size = DGST_SIZE_4_5;
9414 parse_func = truecrypt_parse_hash_2k;
9415 sort_by_digest = sort_by_digest_4_5;
9416 opti_type = OPTI_TYPE_ZERO_BYTE;
9417 dgst_pos0 = 0;
9418 dgst_pos1 = 1;
9419 dgst_pos2 = 2;
9420 dgst_pos3 = 3;
9421 break;
9422
9423 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9424 salt_type = SALT_TYPE_EMBEDDED;
9425 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9426 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9427 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9428 dgst_size = DGST_SIZE_4_5;
9429 parse_func = truecrypt_parse_hash_2k;
9430 sort_by_digest = sort_by_digest_4_5;
9431 opti_type = OPTI_TYPE_ZERO_BYTE;
9432 dgst_pos0 = 0;
9433 dgst_pos1 = 1;
9434 dgst_pos2 = 2;
9435 dgst_pos3 = 3;
9436 break;
9437
9438 case 6221: hash_type = HASH_TYPE_SHA512;
9439 salt_type = SALT_TYPE_EMBEDDED;
9440 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9441 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9442 kern_type = KERN_TYPE_TCSHA512_XTS512;
9443 dgst_size = DGST_SIZE_8_8;
9444 parse_func = truecrypt_parse_hash_1k;
9445 sort_by_digest = sort_by_digest_8_8;
9446 opti_type = OPTI_TYPE_ZERO_BYTE
9447 | OPTI_TYPE_USES_BITS_64;
9448 dgst_pos0 = 0;
9449 dgst_pos1 = 1;
9450 dgst_pos2 = 2;
9451 dgst_pos3 = 3;
9452 break;
9453
9454 case 6222: hash_type = HASH_TYPE_SHA512;
9455 salt_type = SALT_TYPE_EMBEDDED;
9456 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9457 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9458 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9459 dgst_size = DGST_SIZE_8_8;
9460 parse_func = truecrypt_parse_hash_1k;
9461 sort_by_digest = sort_by_digest_8_8;
9462 opti_type = OPTI_TYPE_ZERO_BYTE
9463 | OPTI_TYPE_USES_BITS_64;
9464 dgst_pos0 = 0;
9465 dgst_pos1 = 1;
9466 dgst_pos2 = 2;
9467 dgst_pos3 = 3;
9468 break;
9469
9470 case 6223: hash_type = HASH_TYPE_SHA512;
9471 salt_type = SALT_TYPE_EMBEDDED;
9472 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9473 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9474 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9475 dgst_size = DGST_SIZE_8_8;
9476 parse_func = truecrypt_parse_hash_1k;
9477 sort_by_digest = sort_by_digest_8_8;
9478 opti_type = OPTI_TYPE_ZERO_BYTE
9479 | OPTI_TYPE_USES_BITS_64;
9480 dgst_pos0 = 0;
9481 dgst_pos1 = 1;
9482 dgst_pos2 = 2;
9483 dgst_pos3 = 3;
9484 break;
9485
9486 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9487 salt_type = SALT_TYPE_EMBEDDED;
9488 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9489 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9490 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9491 dgst_size = DGST_SIZE_4_8;
9492 parse_func = truecrypt_parse_hash_1k;
9493 sort_by_digest = sort_by_digest_4_8;
9494 opti_type = OPTI_TYPE_ZERO_BYTE;
9495 dgst_pos0 = 0;
9496 dgst_pos1 = 1;
9497 dgst_pos2 = 2;
9498 dgst_pos3 = 3;
9499 break;
9500
9501 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9502 salt_type = SALT_TYPE_EMBEDDED;
9503 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9504 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9505 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9506 dgst_size = DGST_SIZE_4_8;
9507 parse_func = truecrypt_parse_hash_1k;
9508 sort_by_digest = sort_by_digest_4_8;
9509 opti_type = OPTI_TYPE_ZERO_BYTE;
9510 dgst_pos0 = 0;
9511 dgst_pos1 = 1;
9512 dgst_pos2 = 2;
9513 dgst_pos3 = 3;
9514 break;
9515
9516 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9517 salt_type = SALT_TYPE_EMBEDDED;
9518 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9519 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9520 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9521 dgst_size = DGST_SIZE_4_8;
9522 parse_func = truecrypt_parse_hash_1k;
9523 sort_by_digest = sort_by_digest_4_8;
9524 opti_type = OPTI_TYPE_ZERO_BYTE;
9525 dgst_pos0 = 0;
9526 dgst_pos1 = 1;
9527 dgst_pos2 = 2;
9528 dgst_pos3 = 3;
9529 break;
9530
9531 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9532 salt_type = SALT_TYPE_EMBEDDED;
9533 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9534 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9535 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9536 dgst_size = DGST_SIZE_4_5;
9537 parse_func = truecrypt_parse_hash_1k;
9538 sort_by_digest = sort_by_digest_4_5;
9539 opti_type = OPTI_TYPE_ZERO_BYTE;
9540 dgst_pos0 = 0;
9541 dgst_pos1 = 1;
9542 dgst_pos2 = 2;
9543 dgst_pos3 = 3;
9544 break;
9545
9546 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9547 salt_type = SALT_TYPE_EMBEDDED;
9548 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9549 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9550 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9551 dgst_size = DGST_SIZE_4_5;
9552 parse_func = truecrypt_parse_hash_1k;
9553 sort_by_digest = sort_by_digest_4_5;
9554 opti_type = OPTI_TYPE_ZERO_BYTE;
9555 dgst_pos0 = 0;
9556 dgst_pos1 = 1;
9557 dgst_pos2 = 2;
9558 dgst_pos3 = 3;
9559 break;
9560
9561 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9562 salt_type = SALT_TYPE_EMBEDDED;
9563 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9564 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9565 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9566 dgst_size = DGST_SIZE_4_5;
9567 parse_func = truecrypt_parse_hash_1k;
9568 sort_by_digest = sort_by_digest_4_5;
9569 opti_type = OPTI_TYPE_ZERO_BYTE;
9570 dgst_pos0 = 0;
9571 dgst_pos1 = 1;
9572 dgst_pos2 = 2;
9573 dgst_pos3 = 3;
9574 break;
9575
9576 case 6300: hash_type = HASH_TYPE_MD5;
9577 salt_type = SALT_TYPE_EMBEDDED;
9578 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9579 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9580 kern_type = KERN_TYPE_MD5AIX;
9581 dgst_size = DGST_SIZE_4_4;
9582 parse_func = md5aix_parse_hash;
9583 sort_by_digest = sort_by_digest_4_4;
9584 opti_type = OPTI_TYPE_ZERO_BYTE;
9585 dgst_pos0 = 0;
9586 dgst_pos1 = 1;
9587 dgst_pos2 = 2;
9588 dgst_pos3 = 3;
9589 break;
9590
9591 case 6400: hash_type = HASH_TYPE_SHA256;
9592 salt_type = SALT_TYPE_EMBEDDED;
9593 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9594 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9595 kern_type = KERN_TYPE_SHA256AIX;
9596 dgst_size = DGST_SIZE_4_8;
9597 parse_func = sha256aix_parse_hash;
9598 sort_by_digest = sort_by_digest_4_8;
9599 opti_type = OPTI_TYPE_ZERO_BYTE;
9600 dgst_pos0 = 0;
9601 dgst_pos1 = 1;
9602 dgst_pos2 = 2;
9603 dgst_pos3 = 3;
9604 break;
9605
9606 case 6500: hash_type = HASH_TYPE_SHA512;
9607 salt_type = SALT_TYPE_EMBEDDED;
9608 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9609 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9610 kern_type = KERN_TYPE_SHA512AIX;
9611 dgst_size = DGST_SIZE_8_8;
9612 parse_func = sha512aix_parse_hash;
9613 sort_by_digest = sort_by_digest_8_8;
9614 opti_type = OPTI_TYPE_ZERO_BYTE
9615 | OPTI_TYPE_USES_BITS_64;
9616 dgst_pos0 = 0;
9617 dgst_pos1 = 1;
9618 dgst_pos2 = 2;
9619 dgst_pos3 = 3;
9620 break;
9621
9622 case 6600: hash_type = HASH_TYPE_AES;
9623 salt_type = SALT_TYPE_EMBEDDED;
9624 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9625 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9626 kern_type = KERN_TYPE_AGILEKEY;
9627 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9628 parse_func = agilekey_parse_hash;
9629 sort_by_digest = sort_by_digest_4_5;
9630 opti_type = OPTI_TYPE_ZERO_BYTE;
9631 dgst_pos0 = 0;
9632 dgst_pos1 = 1;
9633 dgst_pos2 = 2;
9634 dgst_pos3 = 3;
9635 break;
9636
9637 case 6700: hash_type = HASH_TYPE_SHA1;
9638 salt_type = SALT_TYPE_EMBEDDED;
9639 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9640 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9641 kern_type = KERN_TYPE_SHA1AIX;
9642 dgst_size = DGST_SIZE_4_5;
9643 parse_func = sha1aix_parse_hash;
9644 sort_by_digest = sort_by_digest_4_5;
9645 opti_type = OPTI_TYPE_ZERO_BYTE;
9646 dgst_pos0 = 0;
9647 dgst_pos1 = 1;
9648 dgst_pos2 = 2;
9649 dgst_pos3 = 3;
9650 break;
9651
9652 case 6800: hash_type = HASH_TYPE_AES;
9653 salt_type = SALT_TYPE_EMBEDDED;
9654 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9655 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9656 kern_type = KERN_TYPE_LASTPASS;
9657 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9658 parse_func = lastpass_parse_hash;
9659 sort_by_digest = sort_by_digest_4_8;
9660 opti_type = OPTI_TYPE_ZERO_BYTE;
9661 dgst_pos0 = 0;
9662 dgst_pos1 = 1;
9663 dgst_pos2 = 2;
9664 dgst_pos3 = 3;
9665 break;
9666
9667 case 6900: hash_type = HASH_TYPE_GOST;
9668 salt_type = SALT_TYPE_NONE;
9669 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9670 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9671 kern_type = KERN_TYPE_GOST;
9672 dgst_size = DGST_SIZE_4_8;
9673 parse_func = gost_parse_hash;
9674 sort_by_digest = sort_by_digest_4_8;
9675 opti_type = OPTI_TYPE_ZERO_BYTE;
9676 dgst_pos0 = 0;
9677 dgst_pos1 = 1;
9678 dgst_pos2 = 2;
9679 dgst_pos3 = 3;
9680 break;
9681
9682 case 7100: hash_type = HASH_TYPE_SHA512;
9683 salt_type = SALT_TYPE_EMBEDDED;
9684 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9685 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9686 kern_type = KERN_TYPE_PBKDF2_SHA512;
9687 dgst_size = DGST_SIZE_8_16;
9688 parse_func = sha512osx_parse_hash;
9689 sort_by_digest = sort_by_digest_8_16;
9690 opti_type = OPTI_TYPE_ZERO_BYTE
9691 | OPTI_TYPE_USES_BITS_64
9692 | OPTI_TYPE_SLOW_HASH_SIMD;
9693 dgst_pos0 = 0;
9694 dgst_pos1 = 1;
9695 dgst_pos2 = 2;
9696 dgst_pos3 = 3;
9697 break;
9698
9699 case 7200: hash_type = HASH_TYPE_SHA512;
9700 salt_type = SALT_TYPE_EMBEDDED;
9701 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9702 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9703 kern_type = KERN_TYPE_PBKDF2_SHA512;
9704 dgst_size = DGST_SIZE_8_16;
9705 parse_func = sha512grub_parse_hash;
9706 sort_by_digest = sort_by_digest_8_16;
9707 opti_type = OPTI_TYPE_ZERO_BYTE
9708 | OPTI_TYPE_USES_BITS_64
9709 | OPTI_TYPE_SLOW_HASH_SIMD;
9710 dgst_pos0 = 0;
9711 dgst_pos1 = 1;
9712 dgst_pos2 = 2;
9713 dgst_pos3 = 3;
9714 break;
9715
9716 case 7300: hash_type = HASH_TYPE_SHA1;
9717 salt_type = SALT_TYPE_EMBEDDED;
9718 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9719 opts_type = OPTS_TYPE_PT_GENERATE_BE
9720 | OPTS_TYPE_ST_ADD80
9721 | OPTS_TYPE_ST_ADDBITS15;
9722 kern_type = KERN_TYPE_RAKP;
9723 dgst_size = DGST_SIZE_4_5;
9724 parse_func = rakp_parse_hash;
9725 sort_by_digest = sort_by_digest_4_5;
9726 opti_type = OPTI_TYPE_ZERO_BYTE
9727 | OPTI_TYPE_NOT_ITERATED;
9728 dgst_pos0 = 3;
9729 dgst_pos1 = 4;
9730 dgst_pos2 = 2;
9731 dgst_pos3 = 1;
9732 break;
9733
9734 case 7400: hash_type = HASH_TYPE_SHA256;
9735 salt_type = SALT_TYPE_EMBEDDED;
9736 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9737 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9738 kern_type = KERN_TYPE_SHA256CRYPT;
9739 dgst_size = DGST_SIZE_4_8;
9740 parse_func = sha256crypt_parse_hash;
9741 sort_by_digest = sort_by_digest_4_8;
9742 opti_type = OPTI_TYPE_ZERO_BYTE;
9743 dgst_pos0 = 0;
9744 dgst_pos1 = 1;
9745 dgst_pos2 = 2;
9746 dgst_pos3 = 3;
9747 break;
9748
9749 case 7500: hash_type = HASH_TYPE_KRB5PA;
9750 salt_type = SALT_TYPE_EMBEDDED;
9751 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9752 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9753 kern_type = KERN_TYPE_KRB5PA;
9754 dgst_size = DGST_SIZE_4_4;
9755 parse_func = krb5pa_parse_hash;
9756 sort_by_digest = sort_by_digest_4_4;
9757 opti_type = OPTI_TYPE_ZERO_BYTE
9758 | OPTI_TYPE_NOT_ITERATED;
9759 dgst_pos0 = 0;
9760 dgst_pos1 = 1;
9761 dgst_pos2 = 2;
9762 dgst_pos3 = 3;
9763 break;
9764
9765 case 7600: hash_type = HASH_TYPE_SHA1;
9766 salt_type = SALT_TYPE_INTERN;
9767 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9768 opts_type = OPTS_TYPE_PT_GENERATE_BE
9769 | OPTS_TYPE_PT_ADD80
9770 | OPTS_TYPE_PT_ADDBITS15;
9771 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9772 dgst_size = DGST_SIZE_4_5;
9773 parse_func = redmine_parse_hash;
9774 sort_by_digest = sort_by_digest_4_5;
9775 opti_type = OPTI_TYPE_ZERO_BYTE
9776 | OPTI_TYPE_PRECOMPUTE_INIT
9777 | OPTI_TYPE_EARLY_SKIP
9778 | OPTI_TYPE_NOT_ITERATED
9779 | OPTI_TYPE_PREPENDED_SALT;
9780 dgst_pos0 = 3;
9781 dgst_pos1 = 4;
9782 dgst_pos2 = 2;
9783 dgst_pos3 = 1;
9784 break;
9785
9786 case 7700: hash_type = HASH_TYPE_SAPB;
9787 salt_type = SALT_TYPE_EMBEDDED;
9788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9789 opts_type = OPTS_TYPE_PT_GENERATE_LE
9790 | OPTS_TYPE_PT_UPPER
9791 | OPTS_TYPE_ST_UPPER;
9792 kern_type = KERN_TYPE_SAPB;
9793 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9794 parse_func = sapb_parse_hash;
9795 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9796 opti_type = OPTI_TYPE_ZERO_BYTE
9797 | OPTI_TYPE_PRECOMPUTE_INIT
9798 | OPTI_TYPE_NOT_ITERATED;
9799 dgst_pos0 = 0;
9800 dgst_pos1 = 1;
9801 dgst_pos2 = 2;
9802 dgst_pos3 = 3;
9803 break;
9804
9805 case 7800: hash_type = HASH_TYPE_SAPG;
9806 salt_type = SALT_TYPE_EMBEDDED;
9807 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9808 opts_type = OPTS_TYPE_PT_GENERATE_BE
9809 | OPTS_TYPE_ST_ADD80
9810 | OPTS_TYPE_ST_UPPER;
9811 kern_type = KERN_TYPE_SAPG;
9812 dgst_size = DGST_SIZE_4_5;
9813 parse_func = sapg_parse_hash;
9814 sort_by_digest = sort_by_digest_4_5;
9815 opti_type = OPTI_TYPE_ZERO_BYTE
9816 | OPTI_TYPE_PRECOMPUTE_INIT
9817 | OPTI_TYPE_NOT_ITERATED;
9818 dgst_pos0 = 3;
9819 dgst_pos1 = 4;
9820 dgst_pos2 = 2;
9821 dgst_pos3 = 1;
9822 break;
9823
9824 case 7900: hash_type = HASH_TYPE_SHA512;
9825 salt_type = SALT_TYPE_EMBEDDED;
9826 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9827 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9828 kern_type = KERN_TYPE_DRUPAL7;
9829 dgst_size = DGST_SIZE_8_8;
9830 parse_func = drupal7_parse_hash;
9831 sort_by_digest = sort_by_digest_8_8;
9832 opti_type = OPTI_TYPE_ZERO_BYTE
9833 | OPTI_TYPE_USES_BITS_64;
9834 dgst_pos0 = 0;
9835 dgst_pos1 = 1;
9836 dgst_pos2 = 2;
9837 dgst_pos3 = 3;
9838 break;
9839
9840 case 8000: hash_type = HASH_TYPE_SHA256;
9841 salt_type = SALT_TYPE_EMBEDDED;
9842 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9843 opts_type = OPTS_TYPE_PT_GENERATE_BE
9844 | OPTS_TYPE_PT_UNICODE
9845 | OPTS_TYPE_ST_ADD80
9846 | OPTS_TYPE_ST_HEX;
9847 kern_type = KERN_TYPE_SYBASEASE;
9848 dgst_size = DGST_SIZE_4_8;
9849 parse_func = sybasease_parse_hash;
9850 sort_by_digest = sort_by_digest_4_8;
9851 opti_type = OPTI_TYPE_ZERO_BYTE
9852 | OPTI_TYPE_PRECOMPUTE_INIT
9853 | OPTI_TYPE_EARLY_SKIP
9854 | OPTI_TYPE_NOT_ITERATED
9855 | OPTI_TYPE_RAW_HASH;
9856 dgst_pos0 = 3;
9857 dgst_pos1 = 7;
9858 dgst_pos2 = 2;
9859 dgst_pos3 = 6;
9860 break;
9861
9862 case 8100: hash_type = HASH_TYPE_SHA1;
9863 salt_type = SALT_TYPE_EMBEDDED;
9864 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9865 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9866 kern_type = KERN_TYPE_NETSCALER;
9867 dgst_size = DGST_SIZE_4_5;
9868 parse_func = netscaler_parse_hash;
9869 sort_by_digest = sort_by_digest_4_5;
9870 opti_type = OPTI_TYPE_ZERO_BYTE
9871 | OPTI_TYPE_PRECOMPUTE_INIT
9872 | OPTI_TYPE_PRECOMPUTE_MERKLE
9873 | OPTI_TYPE_EARLY_SKIP
9874 | OPTI_TYPE_NOT_ITERATED
9875 | OPTI_TYPE_PREPENDED_SALT
9876 | OPTI_TYPE_RAW_HASH;
9877 dgst_pos0 = 3;
9878 dgst_pos1 = 4;
9879 dgst_pos2 = 2;
9880 dgst_pos3 = 1;
9881 break;
9882
9883 case 8200: hash_type = HASH_TYPE_SHA256;
9884 salt_type = SALT_TYPE_EMBEDDED;
9885 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9886 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9887 kern_type = KERN_TYPE_CLOUDKEY;
9888 dgst_size = DGST_SIZE_4_8;
9889 parse_func = cloudkey_parse_hash;
9890 sort_by_digest = sort_by_digest_4_8;
9891 opti_type = OPTI_TYPE_ZERO_BYTE;
9892 dgst_pos0 = 0;
9893 dgst_pos1 = 1;
9894 dgst_pos2 = 2;
9895 dgst_pos3 = 3;
9896 break;
9897
9898 case 8300: hash_type = HASH_TYPE_SHA1;
9899 salt_type = SALT_TYPE_EMBEDDED;
9900 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9901 opts_type = OPTS_TYPE_PT_GENERATE_BE
9902 | OPTS_TYPE_ST_HEX
9903 | OPTS_TYPE_ST_ADD80;
9904 kern_type = KERN_TYPE_NSEC3;
9905 dgst_size = DGST_SIZE_4_5;
9906 parse_func = nsec3_parse_hash;
9907 sort_by_digest = sort_by_digest_4_5;
9908 opti_type = OPTI_TYPE_ZERO_BYTE;
9909 dgst_pos0 = 3;
9910 dgst_pos1 = 4;
9911 dgst_pos2 = 2;
9912 dgst_pos3 = 1;
9913 break;
9914
9915 case 8400: hash_type = HASH_TYPE_SHA1;
9916 salt_type = SALT_TYPE_INTERN;
9917 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9918 opts_type = OPTS_TYPE_PT_GENERATE_BE
9919 | OPTS_TYPE_PT_ADD80
9920 | OPTS_TYPE_PT_ADDBITS15;
9921 kern_type = KERN_TYPE_WBB3;
9922 dgst_size = DGST_SIZE_4_5;
9923 parse_func = wbb3_parse_hash;
9924 sort_by_digest = sort_by_digest_4_5;
9925 opti_type = OPTI_TYPE_ZERO_BYTE
9926 | OPTI_TYPE_PRECOMPUTE_INIT
9927 | OPTI_TYPE_NOT_ITERATED;
9928 dgst_pos0 = 3;
9929 dgst_pos1 = 4;
9930 dgst_pos2 = 2;
9931 dgst_pos3 = 1;
9932 break;
9933
9934 case 8500: hash_type = HASH_TYPE_DESRACF;
9935 salt_type = SALT_TYPE_EMBEDDED;
9936 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9937 opts_type = OPTS_TYPE_PT_GENERATE_LE
9938 | OPTS_TYPE_ST_UPPER;
9939 kern_type = KERN_TYPE_RACF;
9940 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9941 parse_func = racf_parse_hash;
9942 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9943 opti_type = OPTI_TYPE_ZERO_BYTE
9944 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9945 dgst_pos0 = 0;
9946 dgst_pos1 = 1;
9947 dgst_pos2 = 2;
9948 dgst_pos3 = 3;
9949 break;
9950
9951 case 8600: hash_type = HASH_TYPE_LOTUS5;
9952 salt_type = SALT_TYPE_NONE;
9953 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9954 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9955 kern_type = KERN_TYPE_LOTUS5;
9956 dgst_size = DGST_SIZE_4_4;
9957 parse_func = lotus5_parse_hash;
9958 sort_by_digest = sort_by_digest_4_4;
9959 opti_type = OPTI_TYPE_EARLY_SKIP
9960 | OPTI_TYPE_NOT_ITERATED
9961 | OPTI_TYPE_NOT_SALTED
9962 | OPTI_TYPE_RAW_HASH;
9963 dgst_pos0 = 0;
9964 dgst_pos1 = 1;
9965 dgst_pos2 = 2;
9966 dgst_pos3 = 3;
9967 break;
9968
9969 case 8700: hash_type = HASH_TYPE_LOTUS6;
9970 salt_type = SALT_TYPE_EMBEDDED;
9971 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9972 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9973 kern_type = KERN_TYPE_LOTUS6;
9974 dgst_size = DGST_SIZE_4_4;
9975 parse_func = lotus6_parse_hash;
9976 sort_by_digest = sort_by_digest_4_4;
9977 opti_type = OPTI_TYPE_EARLY_SKIP
9978 | OPTI_TYPE_NOT_ITERATED
9979 | OPTI_TYPE_RAW_HASH;
9980 dgst_pos0 = 0;
9981 dgst_pos1 = 1;
9982 dgst_pos2 = 2;
9983 dgst_pos3 = 3;
9984 break;
9985
9986 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9987 salt_type = SALT_TYPE_EMBEDDED;
9988 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9989 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9990 kern_type = KERN_TYPE_ANDROIDFDE;
9991 dgst_size = DGST_SIZE_4_4;
9992 parse_func = androidfde_parse_hash;
9993 sort_by_digest = sort_by_digest_4_4;
9994 opti_type = OPTI_TYPE_ZERO_BYTE;
9995 dgst_pos0 = 0;
9996 dgst_pos1 = 1;
9997 dgst_pos2 = 2;
9998 dgst_pos3 = 3;
9999 break;
10000
10001 case 8900: hash_type = HASH_TYPE_SCRYPT;
10002 salt_type = SALT_TYPE_EMBEDDED;
10003 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10004 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10005 kern_type = KERN_TYPE_SCRYPT;
10006 dgst_size = DGST_SIZE_4_8;
10007 parse_func = scrypt_parse_hash;
10008 sort_by_digest = sort_by_digest_4_8;
10009 opti_type = OPTI_TYPE_ZERO_BYTE;
10010 dgst_pos0 = 0;
10011 dgst_pos1 = 1;
10012 dgst_pos2 = 2;
10013 dgst_pos3 = 3;
10014 break;
10015
10016 case 9000: hash_type = HASH_TYPE_SHA1;
10017 salt_type = SALT_TYPE_EMBEDDED;
10018 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10019 opts_type = OPTS_TYPE_PT_GENERATE_LE
10020 | OPTS_TYPE_ST_GENERATE_LE;
10021 kern_type = KERN_TYPE_PSAFE2;
10022 dgst_size = DGST_SIZE_4_5;
10023 parse_func = psafe2_parse_hash;
10024 sort_by_digest = sort_by_digest_4_5;
10025 opti_type = OPTI_TYPE_ZERO_BYTE;
10026 dgst_pos0 = 0;
10027 dgst_pos1 = 1;
10028 dgst_pos2 = 2;
10029 dgst_pos3 = 3;
10030 break;
10031
10032 case 9100: hash_type = HASH_TYPE_LOTUS8;
10033 salt_type = SALT_TYPE_EMBEDDED;
10034 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10035 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10036 kern_type = KERN_TYPE_LOTUS8;
10037 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10038 parse_func = lotus8_parse_hash;
10039 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10040 opti_type = OPTI_TYPE_ZERO_BYTE;
10041 dgst_pos0 = 0;
10042 dgst_pos1 = 1;
10043 dgst_pos2 = 2;
10044 dgst_pos3 = 3;
10045 break;
10046
10047 case 9200: hash_type = HASH_TYPE_SHA256;
10048 salt_type = SALT_TYPE_EMBEDDED;
10049 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10050 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10051 kern_type = KERN_TYPE_PBKDF2_SHA256;
10052 dgst_size = DGST_SIZE_4_32;
10053 parse_func = cisco8_parse_hash;
10054 sort_by_digest = sort_by_digest_4_32;
10055 opti_type = OPTI_TYPE_ZERO_BYTE
10056 | OPTI_TYPE_SLOW_HASH_SIMD;
10057 dgst_pos0 = 0;
10058 dgst_pos1 = 1;
10059 dgst_pos2 = 2;
10060 dgst_pos3 = 3;
10061 break;
10062
10063 case 9300: hash_type = HASH_TYPE_SCRYPT;
10064 salt_type = SALT_TYPE_EMBEDDED;
10065 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10066 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10067 kern_type = KERN_TYPE_SCRYPT;
10068 dgst_size = DGST_SIZE_4_8;
10069 parse_func = cisco9_parse_hash;
10070 sort_by_digest = sort_by_digest_4_8;
10071 opti_type = OPTI_TYPE_ZERO_BYTE;
10072 dgst_pos0 = 0;
10073 dgst_pos1 = 1;
10074 dgst_pos2 = 2;
10075 dgst_pos3 = 3;
10076 break;
10077
10078 case 9400: hash_type = HASH_TYPE_OFFICE2007;
10079 salt_type = SALT_TYPE_EMBEDDED;
10080 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10081 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10082 kern_type = KERN_TYPE_OFFICE2007;
10083 dgst_size = DGST_SIZE_4_4;
10084 parse_func = office2007_parse_hash;
10085 sort_by_digest = sort_by_digest_4_4;
10086 opti_type = OPTI_TYPE_ZERO_BYTE;
10087 dgst_pos0 = 0;
10088 dgst_pos1 = 1;
10089 dgst_pos2 = 2;
10090 dgst_pos3 = 3;
10091 break;
10092
10093 case 9500: hash_type = HASH_TYPE_OFFICE2010;
10094 salt_type = SALT_TYPE_EMBEDDED;
10095 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10096 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10097 kern_type = KERN_TYPE_OFFICE2010;
10098 dgst_size = DGST_SIZE_4_4;
10099 parse_func = office2010_parse_hash;
10100 sort_by_digest = sort_by_digest_4_4;
10101 opti_type = OPTI_TYPE_ZERO_BYTE;
10102 dgst_pos0 = 0;
10103 dgst_pos1 = 1;
10104 dgst_pos2 = 2;
10105 dgst_pos3 = 3;
10106 break;
10107
10108 case 9600: hash_type = HASH_TYPE_OFFICE2013;
10109 salt_type = SALT_TYPE_EMBEDDED;
10110 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10111 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10112 kern_type = KERN_TYPE_OFFICE2013;
10113 dgst_size = DGST_SIZE_4_4;
10114 parse_func = office2013_parse_hash;
10115 sort_by_digest = sort_by_digest_4_4;
10116 opti_type = OPTI_TYPE_ZERO_BYTE;
10117 dgst_pos0 = 0;
10118 dgst_pos1 = 1;
10119 dgst_pos2 = 2;
10120 dgst_pos3 = 3;
10121 break;
10122
10123 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
10124 salt_type = SALT_TYPE_EMBEDDED;
10125 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10126 opts_type = OPTS_TYPE_PT_GENERATE_LE
10127 | OPTS_TYPE_PT_ADD80
10128 | OPTS_TYPE_PT_UNICODE;
10129 kern_type = KERN_TYPE_OLDOFFICE01;
10130 dgst_size = DGST_SIZE_4_4;
10131 parse_func = oldoffice01_parse_hash;
10132 sort_by_digest = sort_by_digest_4_4;
10133 opti_type = OPTI_TYPE_ZERO_BYTE
10134 | OPTI_TYPE_PRECOMPUTE_INIT
10135 | OPTI_TYPE_NOT_ITERATED;
10136 dgst_pos0 = 0;
10137 dgst_pos1 = 1;
10138 dgst_pos2 = 2;
10139 dgst_pos3 = 3;
10140 break;
10141
10142 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
10143 salt_type = SALT_TYPE_EMBEDDED;
10144 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10145 opts_type = OPTS_TYPE_PT_GENERATE_LE
10146 | OPTS_TYPE_PT_ADD80;
10147 kern_type = KERN_TYPE_OLDOFFICE01CM1;
10148 dgst_size = DGST_SIZE_4_4;
10149 parse_func = oldoffice01cm1_parse_hash;
10150 sort_by_digest = sort_by_digest_4_4;
10151 opti_type = OPTI_TYPE_ZERO_BYTE
10152 | OPTI_TYPE_PRECOMPUTE_INIT
10153 | OPTI_TYPE_NOT_ITERATED;
10154 dgst_pos0 = 0;
10155 dgst_pos1 = 1;
10156 dgst_pos2 = 2;
10157 dgst_pos3 = 3;
10158 break;
10159
10160 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
10161 salt_type = SALT_TYPE_EMBEDDED;
10162 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10163 opts_type = OPTS_TYPE_PT_GENERATE_LE
10164 | OPTS_TYPE_PT_ADD80
10165 | OPTS_TYPE_PT_UNICODE
10166 | OPTS_TYPE_PT_NEVERCRACK;
10167 kern_type = KERN_TYPE_OLDOFFICE01CM2;
10168 dgst_size = DGST_SIZE_4_4;
10169 parse_func = oldoffice01cm2_parse_hash;
10170 sort_by_digest = sort_by_digest_4_4;
10171 opti_type = OPTI_TYPE_ZERO_BYTE
10172 | OPTI_TYPE_PRECOMPUTE_INIT
10173 | OPTI_TYPE_NOT_ITERATED;
10174 dgst_pos0 = 0;
10175 dgst_pos1 = 1;
10176 dgst_pos2 = 2;
10177 dgst_pos3 = 3;
10178 break;
10179
10180 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
10181 salt_type = SALT_TYPE_EMBEDDED;
10182 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10183 opts_type = OPTS_TYPE_PT_GENERATE_BE
10184 | OPTS_TYPE_PT_ADD80
10185 | OPTS_TYPE_PT_UNICODE;
10186 kern_type = KERN_TYPE_OLDOFFICE34;
10187 dgst_size = DGST_SIZE_4_4;
10188 parse_func = oldoffice34_parse_hash;
10189 sort_by_digest = sort_by_digest_4_4;
10190 opti_type = OPTI_TYPE_ZERO_BYTE
10191 | OPTI_TYPE_PRECOMPUTE_INIT
10192 | OPTI_TYPE_NOT_ITERATED;
10193 dgst_pos0 = 0;
10194 dgst_pos1 = 1;
10195 dgst_pos2 = 2;
10196 dgst_pos3 = 3;
10197 break;
10198
10199 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10200 salt_type = SALT_TYPE_EMBEDDED;
10201 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10202 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10203 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10204 dgst_size = DGST_SIZE_4_4;
10205 parse_func = oldoffice34cm1_parse_hash;
10206 sort_by_digest = sort_by_digest_4_4;
10207 opti_type = OPTI_TYPE_ZERO_BYTE
10208 | OPTI_TYPE_PRECOMPUTE_INIT
10209 | OPTI_TYPE_NOT_ITERATED;
10210 dgst_pos0 = 0;
10211 dgst_pos1 = 1;
10212 dgst_pos2 = 2;
10213 dgst_pos3 = 3;
10214 break;
10215
10216 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10217 salt_type = SALT_TYPE_EMBEDDED;
10218 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10219 opts_type = OPTS_TYPE_PT_GENERATE_BE
10220 | OPTS_TYPE_PT_ADD80
10221 | OPTS_TYPE_PT_UNICODE
10222 | OPTS_TYPE_PT_NEVERCRACK;
10223 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10224 dgst_size = DGST_SIZE_4_4;
10225 parse_func = oldoffice34cm2_parse_hash;
10226 sort_by_digest = sort_by_digest_4_4;
10227 opti_type = OPTI_TYPE_ZERO_BYTE
10228 | OPTI_TYPE_PRECOMPUTE_INIT
10229 | OPTI_TYPE_NOT_ITERATED;
10230 dgst_pos0 = 0;
10231 dgst_pos1 = 1;
10232 dgst_pos2 = 2;
10233 dgst_pos3 = 3;
10234 break;
10235
10236 case 9900: hash_type = HASH_TYPE_MD5;
10237 salt_type = SALT_TYPE_NONE;
10238 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10239 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10240 kern_type = KERN_TYPE_RADMIN2;
10241 dgst_size = DGST_SIZE_4_4;
10242 parse_func = radmin2_parse_hash;
10243 sort_by_digest = sort_by_digest_4_4;
10244 opti_type = OPTI_TYPE_ZERO_BYTE
10245 | OPTI_TYPE_PRECOMPUTE_INIT
10246 | OPTI_TYPE_EARLY_SKIP
10247 | OPTI_TYPE_NOT_ITERATED
10248 | OPTI_TYPE_NOT_SALTED;
10249 dgst_pos0 = 0;
10250 dgst_pos1 = 3;
10251 dgst_pos2 = 2;
10252 dgst_pos3 = 1;
10253 break;
10254
10255 case 10000: hash_type = HASH_TYPE_SHA256;
10256 salt_type = SALT_TYPE_EMBEDDED;
10257 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10258 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10259 kern_type = KERN_TYPE_PBKDF2_SHA256;
10260 dgst_size = DGST_SIZE_4_32;
10261 parse_func = djangopbkdf2_parse_hash;
10262 sort_by_digest = sort_by_digest_4_32;
10263 opti_type = OPTI_TYPE_ZERO_BYTE
10264 | OPTI_TYPE_SLOW_HASH_SIMD;
10265 dgst_pos0 = 0;
10266 dgst_pos1 = 1;
10267 dgst_pos2 = 2;
10268 dgst_pos3 = 3;
10269 break;
10270
10271 case 10100: hash_type = HASH_TYPE_SIPHASH;
10272 salt_type = SALT_TYPE_EMBEDDED;
10273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10274 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10275 kern_type = KERN_TYPE_SIPHASH;
10276 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10277 parse_func = siphash_parse_hash;
10278 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10279 opti_type = OPTI_TYPE_ZERO_BYTE
10280 | OPTI_TYPE_NOT_ITERATED
10281 | OPTI_TYPE_RAW_HASH;
10282 dgst_pos0 = 0;
10283 dgst_pos1 = 1;
10284 dgst_pos2 = 2;
10285 dgst_pos3 = 3;
10286 break;
10287
10288 case 10200: hash_type = HASH_TYPE_MD5;
10289 salt_type = SALT_TYPE_EMBEDDED;
10290 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10291 opts_type = OPTS_TYPE_PT_GENERATE_LE
10292 | OPTS_TYPE_ST_ADD80
10293 | OPTS_TYPE_ST_ADDBITS14;
10294 kern_type = KERN_TYPE_HMACMD5_PW;
10295 dgst_size = DGST_SIZE_4_4;
10296 parse_func = crammd5_parse_hash;
10297 sort_by_digest = sort_by_digest_4_4;
10298 opti_type = OPTI_TYPE_ZERO_BYTE
10299 | OPTI_TYPE_NOT_ITERATED;
10300 dgst_pos0 = 0;
10301 dgst_pos1 = 3;
10302 dgst_pos2 = 2;
10303 dgst_pos3 = 1;
10304 break;
10305
10306 case 10300: hash_type = HASH_TYPE_SHA1;
10307 salt_type = SALT_TYPE_EMBEDDED;
10308 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10309 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10310 kern_type = KERN_TYPE_SAPH_SHA1;
10311 dgst_size = DGST_SIZE_4_5;
10312 parse_func = saph_sha1_parse_hash;
10313 sort_by_digest = sort_by_digest_4_5;
10314 opti_type = OPTI_TYPE_ZERO_BYTE;
10315 dgst_pos0 = 0;
10316 dgst_pos1 = 1;
10317 dgst_pos2 = 2;
10318 dgst_pos3 = 3;
10319 break;
10320
10321 case 10400: hash_type = HASH_TYPE_PDFU16;
10322 salt_type = SALT_TYPE_EMBEDDED;
10323 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10324 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10325 kern_type = KERN_TYPE_PDF11;
10326 dgst_size = DGST_SIZE_4_4;
10327 parse_func = pdf11_parse_hash;
10328 sort_by_digest = sort_by_digest_4_4;
10329 opti_type = OPTI_TYPE_ZERO_BYTE
10330 | OPTI_TYPE_NOT_ITERATED;
10331 dgst_pos0 = 0;
10332 dgst_pos1 = 1;
10333 dgst_pos2 = 2;
10334 dgst_pos3 = 3;
10335 break;
10336
10337 case 10410: hash_type = HASH_TYPE_PDFU16;
10338 salt_type = SALT_TYPE_EMBEDDED;
10339 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10340 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10341 kern_type = KERN_TYPE_PDF11CM1;
10342 dgst_size = DGST_SIZE_4_4;
10343 parse_func = pdf11cm1_parse_hash;
10344 sort_by_digest = sort_by_digest_4_4;
10345 opti_type = OPTI_TYPE_ZERO_BYTE
10346 | OPTI_TYPE_NOT_ITERATED;
10347 dgst_pos0 = 0;
10348 dgst_pos1 = 1;
10349 dgst_pos2 = 2;
10350 dgst_pos3 = 3;
10351 break;
10352
10353 case 10420: hash_type = HASH_TYPE_PDFU16;
10354 salt_type = SALT_TYPE_EMBEDDED;
10355 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10356 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10357 kern_type = KERN_TYPE_PDF11CM2;
10358 dgst_size = DGST_SIZE_4_4;
10359 parse_func = pdf11cm2_parse_hash;
10360 sort_by_digest = sort_by_digest_4_4;
10361 opti_type = OPTI_TYPE_ZERO_BYTE
10362 | OPTI_TYPE_NOT_ITERATED;
10363 dgst_pos0 = 0;
10364 dgst_pos1 = 1;
10365 dgst_pos2 = 2;
10366 dgst_pos3 = 3;
10367 break;
10368
10369 case 10500: hash_type = HASH_TYPE_PDFU16;
10370 salt_type = SALT_TYPE_EMBEDDED;
10371 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10372 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10373 kern_type = KERN_TYPE_PDF14;
10374 dgst_size = DGST_SIZE_4_4;
10375 parse_func = pdf14_parse_hash;
10376 sort_by_digest = sort_by_digest_4_4;
10377 opti_type = OPTI_TYPE_ZERO_BYTE
10378 | OPTI_TYPE_NOT_ITERATED;
10379 dgst_pos0 = 0;
10380 dgst_pos1 = 1;
10381 dgst_pos2 = 2;
10382 dgst_pos3 = 3;
10383 break;
10384
10385 case 10600: hash_type = HASH_TYPE_SHA256;
10386 salt_type = SALT_TYPE_EMBEDDED;
10387 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10388 opts_type = OPTS_TYPE_PT_GENERATE_BE
10389 | OPTS_TYPE_ST_ADD80
10390 | OPTS_TYPE_ST_ADDBITS15
10391 | OPTS_TYPE_HASH_COPY;
10392 kern_type = KERN_TYPE_SHA256_PWSLT;
10393 dgst_size = DGST_SIZE_4_8;
10394 parse_func = pdf17l3_parse_hash;
10395 sort_by_digest = sort_by_digest_4_8;
10396 opti_type = OPTI_TYPE_ZERO_BYTE
10397 | OPTI_TYPE_PRECOMPUTE_INIT
10398 | OPTI_TYPE_PRECOMPUTE_MERKLE
10399 | OPTI_TYPE_EARLY_SKIP
10400 | OPTI_TYPE_NOT_ITERATED
10401 | OPTI_TYPE_APPENDED_SALT
10402 | OPTI_TYPE_RAW_HASH;
10403 dgst_pos0 = 3;
10404 dgst_pos1 = 7;
10405 dgst_pos2 = 2;
10406 dgst_pos3 = 6;
10407 break;
10408
10409 case 10700: hash_type = HASH_TYPE_PDFU32;
10410 salt_type = SALT_TYPE_EMBEDDED;
10411 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10412 opts_type = OPTS_TYPE_PT_GENERATE_LE
10413 | OPTS_TYPE_HASH_COPY;
10414 kern_type = KERN_TYPE_PDF17L8;
10415 dgst_size = DGST_SIZE_4_8;
10416 parse_func = pdf17l8_parse_hash;
10417 sort_by_digest = sort_by_digest_4_8;
10418 opti_type = OPTI_TYPE_ZERO_BYTE
10419 | OPTI_TYPE_NOT_ITERATED;
10420 dgst_pos0 = 0;
10421 dgst_pos1 = 1;
10422 dgst_pos2 = 2;
10423 dgst_pos3 = 3;
10424 break;
10425
10426 case 10800: hash_type = HASH_TYPE_SHA384;
10427 salt_type = SALT_TYPE_NONE;
10428 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10429 opts_type = OPTS_TYPE_PT_GENERATE_BE
10430 | OPTS_TYPE_PT_ADD80
10431 | OPTS_TYPE_PT_ADDBITS15;
10432 kern_type = KERN_TYPE_SHA384;
10433 dgst_size = DGST_SIZE_8_8;
10434 parse_func = sha384_parse_hash;
10435 sort_by_digest = sort_by_digest_8_8;
10436 opti_type = OPTI_TYPE_ZERO_BYTE
10437 | OPTI_TYPE_PRECOMPUTE_INIT
10438 | OPTI_TYPE_PRECOMPUTE_MERKLE
10439 | OPTI_TYPE_EARLY_SKIP
10440 | OPTI_TYPE_NOT_ITERATED
10441 | OPTI_TYPE_NOT_SALTED
10442 | OPTI_TYPE_USES_BITS_64
10443 | OPTI_TYPE_RAW_HASH;
10444 dgst_pos0 = 6;
10445 dgst_pos1 = 7;
10446 dgst_pos2 = 4;
10447 dgst_pos3 = 5;
10448 break;
10449
10450 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10451 salt_type = SALT_TYPE_EMBEDDED;
10452 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10453 opts_type = OPTS_TYPE_PT_GENERATE_LE
10454 | OPTS_TYPE_ST_BASE64
10455 | OPTS_TYPE_HASH_COPY;
10456 kern_type = KERN_TYPE_PBKDF2_SHA256;
10457 dgst_size = DGST_SIZE_4_32;
10458 parse_func = pbkdf2_sha256_parse_hash;
10459 sort_by_digest = sort_by_digest_4_32;
10460 opti_type = OPTI_TYPE_ZERO_BYTE
10461 | OPTI_TYPE_SLOW_HASH_SIMD;
10462 dgst_pos0 = 0;
10463 dgst_pos1 = 1;
10464 dgst_pos2 = 2;
10465 dgst_pos3 = 3;
10466 break;
10467
10468 case 11000: hash_type = HASH_TYPE_MD5;
10469 salt_type = SALT_TYPE_INTERN;
10470 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10471 opts_type = OPTS_TYPE_PT_GENERATE_LE
10472 | OPTS_TYPE_PT_ADD80;
10473 kern_type = KERN_TYPE_PRESTASHOP;
10474 dgst_size = DGST_SIZE_4_4;
10475 parse_func = prestashop_parse_hash;
10476 sort_by_digest = sort_by_digest_4_4;
10477 opti_type = OPTI_TYPE_ZERO_BYTE
10478 | OPTI_TYPE_PRECOMPUTE_INIT
10479 | OPTI_TYPE_NOT_ITERATED
10480 | OPTI_TYPE_PREPENDED_SALT;
10481 dgst_pos0 = 0;
10482 dgst_pos1 = 3;
10483 dgst_pos2 = 2;
10484 dgst_pos3 = 1;
10485 break;
10486
10487 case 11100: hash_type = HASH_TYPE_MD5;
10488 salt_type = SALT_TYPE_EMBEDDED;
10489 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10490 opts_type = OPTS_TYPE_PT_GENERATE_LE
10491 | OPTS_TYPE_ST_ADD80;
10492 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10493 dgst_size = DGST_SIZE_4_4;
10494 parse_func = postgresql_auth_parse_hash;
10495 sort_by_digest = sort_by_digest_4_4;
10496 opti_type = OPTI_TYPE_ZERO_BYTE
10497 | OPTI_TYPE_PRECOMPUTE_INIT
10498 | OPTI_TYPE_PRECOMPUTE_MERKLE
10499 | OPTI_TYPE_EARLY_SKIP;
10500 dgst_pos0 = 0;
10501 dgst_pos1 = 3;
10502 dgst_pos2 = 2;
10503 dgst_pos3 = 1;
10504 break;
10505
10506 case 11200: hash_type = HASH_TYPE_SHA1;
10507 salt_type = SALT_TYPE_EMBEDDED;
10508 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10509 opts_type = OPTS_TYPE_PT_GENERATE_BE
10510 | OPTS_TYPE_PT_ADD80
10511 | OPTS_TYPE_ST_HEX;
10512 kern_type = KERN_TYPE_MYSQL_AUTH;
10513 dgst_size = DGST_SIZE_4_5;
10514 parse_func = mysql_auth_parse_hash;
10515 sort_by_digest = sort_by_digest_4_5;
10516 opti_type = OPTI_TYPE_ZERO_BYTE
10517 | OPTI_TYPE_EARLY_SKIP;
10518 dgst_pos0 = 3;
10519 dgst_pos1 = 4;
10520 dgst_pos2 = 2;
10521 dgst_pos3 = 1;
10522 break;
10523
10524 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10525 salt_type = SALT_TYPE_EMBEDDED;
10526 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10527 opts_type = OPTS_TYPE_PT_GENERATE_LE
10528 | OPTS_TYPE_ST_HEX
10529 | OPTS_TYPE_ST_ADD80;
10530 kern_type = KERN_TYPE_BITCOIN_WALLET;
10531 dgst_size = DGST_SIZE_4_4;
10532 parse_func = bitcoin_wallet_parse_hash;
10533 sort_by_digest = sort_by_digest_4_4;
10534 opti_type = OPTI_TYPE_ZERO_BYTE;
10535 dgst_pos0 = 0;
10536 dgst_pos1 = 1;
10537 dgst_pos2 = 2;
10538 dgst_pos3 = 3;
10539 break;
10540
10541 case 11400: hash_type = HASH_TYPE_MD5;
10542 salt_type = SALT_TYPE_EMBEDDED;
10543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10544 opts_type = OPTS_TYPE_PT_GENERATE_LE
10545 | OPTS_TYPE_PT_ADD80
10546 | OPTS_TYPE_HASH_COPY;
10547 kern_type = KERN_TYPE_SIP_AUTH;
10548 dgst_size = DGST_SIZE_4_4;
10549 parse_func = sip_auth_parse_hash;
10550 sort_by_digest = sort_by_digest_4_4;
10551 opti_type = OPTI_TYPE_ZERO_BYTE;
10552 dgst_pos0 = 0;
10553 dgst_pos1 = 3;
10554 dgst_pos2 = 2;
10555 dgst_pos3 = 1;
10556 break;
10557
10558 case 11500: hash_type = HASH_TYPE_CRC32;
10559 salt_type = SALT_TYPE_INTERN;
10560 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10561 opts_type = OPTS_TYPE_PT_GENERATE_LE
10562 | OPTS_TYPE_ST_GENERATE_LE
10563 | OPTS_TYPE_ST_HEX;
10564 kern_type = KERN_TYPE_CRC32;
10565 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10566 parse_func = crc32_parse_hash;
10567 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10568 opti_type = OPTI_TYPE_ZERO_BYTE;
10569 dgst_pos0 = 0;
10570 dgst_pos1 = 1;
10571 dgst_pos2 = 2;
10572 dgst_pos3 = 3;
10573 break;
10574
10575 case 11600: hash_type = HASH_TYPE_AES;
10576 salt_type = SALT_TYPE_EMBEDDED;
10577 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10578 opts_type = OPTS_TYPE_PT_GENERATE_LE
10579 | OPTS_TYPE_PT_NEVERCRACK;
10580 kern_type = KERN_TYPE_SEVEN_ZIP;
10581 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10582 parse_func = seven_zip_parse_hash;
10583 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10584 opti_type = OPTI_TYPE_ZERO_BYTE;
10585 dgst_pos0 = 0;
10586 dgst_pos1 = 1;
10587 dgst_pos2 = 2;
10588 dgst_pos3 = 3;
10589 break;
10590
10591 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10592 salt_type = SALT_TYPE_NONE;
10593 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10594 opts_type = OPTS_TYPE_PT_GENERATE_LE
10595 | OPTS_TYPE_PT_ADD01;
10596 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10597 dgst_size = DGST_SIZE_4_8;
10598 parse_func = gost2012sbog_256_parse_hash;
10599 sort_by_digest = sort_by_digest_4_8;
10600 opti_type = OPTI_TYPE_ZERO_BYTE;
10601 dgst_pos0 = 0;
10602 dgst_pos1 = 1;
10603 dgst_pos2 = 2;
10604 dgst_pos3 = 3;
10605 break;
10606
10607 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10608 salt_type = SALT_TYPE_NONE;
10609 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10610 opts_type = OPTS_TYPE_PT_GENERATE_LE
10611 | OPTS_TYPE_PT_ADD01;
10612 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10613 dgst_size = DGST_SIZE_4_16;
10614 parse_func = gost2012sbog_512_parse_hash;
10615 sort_by_digest = sort_by_digest_4_16;
10616 opti_type = OPTI_TYPE_ZERO_BYTE;
10617 dgst_pos0 = 0;
10618 dgst_pos1 = 1;
10619 dgst_pos2 = 2;
10620 dgst_pos3 = 3;
10621 break;
10622
10623 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10624 salt_type = SALT_TYPE_EMBEDDED;
10625 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10626 opts_type = OPTS_TYPE_PT_GENERATE_LE
10627 | OPTS_TYPE_ST_BASE64
10628 | OPTS_TYPE_HASH_COPY;
10629 kern_type = KERN_TYPE_PBKDF2_MD5;
10630 dgst_size = DGST_SIZE_4_32;
10631 parse_func = pbkdf2_md5_parse_hash;
10632 sort_by_digest = sort_by_digest_4_32;
10633 opti_type = OPTI_TYPE_ZERO_BYTE
10634 | OPTI_TYPE_SLOW_HASH_SIMD;
10635 dgst_pos0 = 0;
10636 dgst_pos1 = 1;
10637 dgst_pos2 = 2;
10638 dgst_pos3 = 3;
10639 break;
10640
10641 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10642 salt_type = SALT_TYPE_EMBEDDED;
10643 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10644 opts_type = OPTS_TYPE_PT_GENERATE_LE
10645 | OPTS_TYPE_ST_BASE64
10646 | OPTS_TYPE_HASH_COPY;
10647 kern_type = KERN_TYPE_PBKDF2_SHA1;
10648 dgst_size = DGST_SIZE_4_32;
10649 parse_func = pbkdf2_sha1_parse_hash;
10650 sort_by_digest = sort_by_digest_4_32;
10651 opti_type = OPTI_TYPE_ZERO_BYTE
10652 | OPTI_TYPE_SLOW_HASH_SIMD;
10653 dgst_pos0 = 0;
10654 dgst_pos1 = 1;
10655 dgst_pos2 = 2;
10656 dgst_pos3 = 3;
10657 break;
10658
10659 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10660 salt_type = SALT_TYPE_EMBEDDED;
10661 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10662 opts_type = OPTS_TYPE_PT_GENERATE_LE
10663 | OPTS_TYPE_ST_BASE64
10664 | OPTS_TYPE_HASH_COPY;
10665 kern_type = KERN_TYPE_PBKDF2_SHA512;
10666 dgst_size = DGST_SIZE_8_16;
10667 parse_func = pbkdf2_sha512_parse_hash;
10668 sort_by_digest = sort_by_digest_8_16;
10669 opti_type = OPTI_TYPE_ZERO_BYTE
10670 | OPTI_TYPE_USES_BITS_64
10671 | OPTI_TYPE_SLOW_HASH_SIMD;
10672 dgst_pos0 = 0;
10673 dgst_pos1 = 1;
10674 dgst_pos2 = 2;
10675 dgst_pos3 = 3;
10676 break;
10677
10678 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10679 salt_type = SALT_TYPE_EMBEDDED;
10680 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10681 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10682 kern_type = KERN_TYPE_ECRYPTFS;
10683 dgst_size = DGST_SIZE_8_8;
10684 parse_func = ecryptfs_parse_hash;
10685 sort_by_digest = sort_by_digest_8_8;
10686 opti_type = OPTI_TYPE_ZERO_BYTE
10687 | OPTI_TYPE_USES_BITS_64;
10688 dgst_pos0 = 0;
10689 dgst_pos1 = 1;
10690 dgst_pos2 = 2;
10691 dgst_pos3 = 3;
10692 break;
10693
10694 case 12300: hash_type = HASH_TYPE_ORACLET;
10695 salt_type = SALT_TYPE_EMBEDDED;
10696 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10697 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10698 kern_type = KERN_TYPE_ORACLET;
10699 dgst_size = DGST_SIZE_8_16;
10700 parse_func = oraclet_parse_hash;
10701 sort_by_digest = sort_by_digest_8_16;
10702 opti_type = OPTI_TYPE_ZERO_BYTE
10703 | OPTI_TYPE_USES_BITS_64;
10704 dgst_pos0 = 0;
10705 dgst_pos1 = 1;
10706 dgst_pos2 = 2;
10707 dgst_pos3 = 3;
10708 break;
10709
10710 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10711 salt_type = SALT_TYPE_EMBEDDED;
10712 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10713 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10714 kern_type = KERN_TYPE_BSDICRYPT;
10715 dgst_size = DGST_SIZE_4_4;
10716 parse_func = bsdicrypt_parse_hash;
10717 sort_by_digest = sort_by_digest_4_4;
10718 opti_type = OPTI_TYPE_ZERO_BYTE
10719 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10720 dgst_pos0 = 0;
10721 dgst_pos1 = 1;
10722 dgst_pos2 = 2;
10723 dgst_pos3 = 3;
10724 break;
10725
10726 case 12500: hash_type = HASH_TYPE_RAR3HP;
10727 salt_type = SALT_TYPE_EMBEDDED;
10728 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10729 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10730 kern_type = KERN_TYPE_RAR3;
10731 dgst_size = DGST_SIZE_4_4;
10732 parse_func = rar3hp_parse_hash;
10733 sort_by_digest = sort_by_digest_4_4;
10734 opti_type = OPTI_TYPE_ZERO_BYTE;
10735 dgst_pos0 = 0;
10736 dgst_pos1 = 1;
10737 dgst_pos2 = 2;
10738 dgst_pos3 = 3;
10739 break;
10740
10741 case 12600: hash_type = HASH_TYPE_SHA256;
10742 salt_type = SALT_TYPE_INTERN;
10743 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10744 opts_type = OPTS_TYPE_PT_GENERATE_BE
10745 | OPTS_TYPE_PT_ADD80;
10746 kern_type = KERN_TYPE_CF10;
10747 dgst_size = DGST_SIZE_4_8;
10748 parse_func = cf10_parse_hash;
10749 sort_by_digest = sort_by_digest_4_8;
10750 opti_type = OPTI_TYPE_ZERO_BYTE
10751 | OPTI_TYPE_PRECOMPUTE_INIT
10752 | OPTI_TYPE_EARLY_SKIP
10753 | OPTI_TYPE_NOT_ITERATED;
10754 dgst_pos0 = 3;
10755 dgst_pos1 = 7;
10756 dgst_pos2 = 2;
10757 dgst_pos3 = 6;
10758 break;
10759
10760 case 12700: hash_type = HASH_TYPE_AES;
10761 salt_type = SALT_TYPE_EMBEDDED;
10762 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10763 opts_type = OPTS_TYPE_PT_GENERATE_LE
10764 | OPTS_TYPE_HASH_COPY;
10765 kern_type = KERN_TYPE_MYWALLET;
10766 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10767 parse_func = mywallet_parse_hash;
10768 sort_by_digest = sort_by_digest_4_5;
10769 opti_type = OPTI_TYPE_ZERO_BYTE;
10770 dgst_pos0 = 0;
10771 dgst_pos1 = 1;
10772 dgst_pos2 = 2;
10773 dgst_pos3 = 3;
10774 break;
10775
10776 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10777 salt_type = SALT_TYPE_EMBEDDED;
10778 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10779 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10780 kern_type = KERN_TYPE_MS_DRSR;
10781 dgst_size = DGST_SIZE_4_8;
10782 parse_func = ms_drsr_parse_hash;
10783 sort_by_digest = sort_by_digest_4_8;
10784 opti_type = OPTI_TYPE_ZERO_BYTE;
10785 dgst_pos0 = 0;
10786 dgst_pos1 = 1;
10787 dgst_pos2 = 2;
10788 dgst_pos3 = 3;
10789 break;
10790
10791 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10792 salt_type = SALT_TYPE_EMBEDDED;
10793 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10794 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10795 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10796 dgst_size = DGST_SIZE_4_8;
10797 parse_func = androidfde_samsung_parse_hash;
10798 sort_by_digest = sort_by_digest_4_8;
10799 opti_type = OPTI_TYPE_ZERO_BYTE;
10800 dgst_pos0 = 0;
10801 dgst_pos1 = 1;
10802 dgst_pos2 = 2;
10803 dgst_pos3 = 3;
10804 break;
10805
10806 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10807 salt_type = SALT_TYPE_EMBEDDED;
10808 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10809 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10810 kern_type = KERN_TYPE_RAR5;
10811 dgst_size = DGST_SIZE_4_4;
10812 parse_func = rar5_parse_hash;
10813 sort_by_digest = sort_by_digest_4_4;
10814 opti_type = OPTI_TYPE_ZERO_BYTE;
10815 dgst_pos0 = 0;
10816 dgst_pos1 = 1;
10817 dgst_pos2 = 2;
10818 dgst_pos3 = 3;
10819 break;
10820
10821 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10822 salt_type = SALT_TYPE_EMBEDDED;
10823 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10824 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10825 kern_type = KERN_TYPE_KRB5TGS;
10826 dgst_size = DGST_SIZE_4_4;
10827 parse_func = krb5tgs_parse_hash;
10828 sort_by_digest = sort_by_digest_4_4;
10829 opti_type = OPTI_TYPE_ZERO_BYTE
10830 | OPTI_TYPE_NOT_ITERATED;
10831 dgst_pos0 = 0;
10832 dgst_pos1 = 1;
10833 dgst_pos2 = 2;
10834 dgst_pos3 = 3;
10835 break;
10836
10837 case 13200: hash_type = HASH_TYPE_AES;
10838 salt_type = SALT_TYPE_EMBEDDED;
10839 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10840 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10841 kern_type = KERN_TYPE_AXCRYPT;
10842 dgst_size = DGST_SIZE_4_4;
10843 parse_func = axcrypt_parse_hash;
10844 sort_by_digest = sort_by_digest_4_4;
10845 opti_type = OPTI_TYPE_ZERO_BYTE;
10846 dgst_pos0 = 0;
10847 dgst_pos1 = 1;
10848 dgst_pos2 = 2;
10849 dgst_pos3 = 3;
10850 break;
10851
10852 case 13300: hash_type = HASH_TYPE_SHA1;
10853 salt_type = SALT_TYPE_NONE;
10854 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10855 opts_type = OPTS_TYPE_PT_GENERATE_BE
10856 | OPTS_TYPE_PT_ADD80
10857 | OPTS_TYPE_PT_ADDBITS15;
10858 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10859 dgst_size = DGST_SIZE_4_5;
10860 parse_func = sha1axcrypt_parse_hash;
10861 sort_by_digest = sort_by_digest_4_5;
10862 opti_type = OPTI_TYPE_ZERO_BYTE
10863 | OPTI_TYPE_PRECOMPUTE_INIT
10864 | OPTI_TYPE_EARLY_SKIP
10865 | OPTI_TYPE_NOT_ITERATED
10866 | OPTI_TYPE_NOT_SALTED;
10867 dgst_pos0 = 0;
10868 dgst_pos1 = 4;
10869 dgst_pos2 = 3;
10870 dgst_pos3 = 2;
10871 break;
10872
10873 case 13400: hash_type = HASH_TYPE_AES;
10874 salt_type = SALT_TYPE_EMBEDDED;
10875 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10876 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10877 kern_type = KERN_TYPE_KEEPASS;
10878 dgst_size = DGST_SIZE_4_4;
10879 parse_func = keepass_parse_hash;
10880 sort_by_digest = sort_by_digest_4_4;
10881 opti_type = OPTI_TYPE_ZERO_BYTE;
10882 dgst_pos0 = 0;
10883 dgst_pos1 = 1;
10884 dgst_pos2 = 2;
10885 dgst_pos3 = 3;
10886 break;
10887
10888 case 13500: hash_type = HASH_TYPE_SHA1;
10889 salt_type = SALT_TYPE_EMBEDDED;
10890 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10891 opts_type = OPTS_TYPE_PT_GENERATE_BE
10892 | OPTS_TYPE_PT_UNICODE
10893 | OPTS_TYPE_PT_ADD80;
10894 kern_type = KERN_TYPE_PSTOKEN;
10895 dgst_size = DGST_SIZE_4_5;
10896 parse_func = pstoken_parse_hash;
10897 sort_by_digest = sort_by_digest_4_5;
10898 opti_type = OPTI_TYPE_ZERO_BYTE
10899 | OPTI_TYPE_PRECOMPUTE_INIT
10900 | OPTI_TYPE_EARLY_SKIP
10901 | OPTI_TYPE_NOT_ITERATED
10902 | OPTI_TYPE_PREPENDED_SALT
10903 | OPTI_TYPE_RAW_HASH;
10904 dgst_pos0 = 3;
10905 dgst_pos1 = 4;
10906 dgst_pos2 = 2;
10907 dgst_pos3 = 1;
10908 break;
10909
10910 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10911 salt_type = SALT_TYPE_EMBEDDED;
10912 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10913 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10914 kern_type = KERN_TYPE_ZIP2;
10915 dgst_size = DGST_SIZE_4_4;
10916 parse_func = zip2_parse_hash;
10917 sort_by_digest = sort_by_digest_4_4;
10918 opti_type = OPTI_TYPE_ZERO_BYTE;
10919 dgst_pos0 = 0;
10920 dgst_pos1 = 1;
10921 dgst_pos2 = 2;
10922 dgst_pos3 = 3;
10923 break;
10924
10925 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10926 salt_type = SALT_TYPE_EMBEDDED;
10927 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10928 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10929 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10930 dgst_size = DGST_SIZE_4_5;
10931 parse_func = veracrypt_parse_hash_655331;
10932 sort_by_digest = sort_by_digest_4_5;
10933 opti_type = OPTI_TYPE_ZERO_BYTE;
10934 dgst_pos0 = 0;
10935 dgst_pos1 = 1;
10936 dgst_pos2 = 2;
10937 dgst_pos3 = 3;
10938 break;
10939
10940 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10941 salt_type = SALT_TYPE_EMBEDDED;
10942 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10943 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10944 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10945 dgst_size = DGST_SIZE_4_5;
10946 parse_func = veracrypt_parse_hash_655331;
10947 sort_by_digest = sort_by_digest_4_5;
10948 opti_type = OPTI_TYPE_ZERO_BYTE;
10949 dgst_pos0 = 0;
10950 dgst_pos1 = 1;
10951 dgst_pos2 = 2;
10952 dgst_pos3 = 3;
10953 break;
10954
10955 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10956 salt_type = SALT_TYPE_EMBEDDED;
10957 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10958 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10959 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10960 dgst_size = DGST_SIZE_4_5;
10961 parse_func = veracrypt_parse_hash_655331;
10962 sort_by_digest = sort_by_digest_4_5;
10963 opti_type = OPTI_TYPE_ZERO_BYTE;
10964 dgst_pos0 = 0;
10965 dgst_pos1 = 1;
10966 dgst_pos2 = 2;
10967 dgst_pos3 = 3;
10968 break;
10969
10970 case 13721: hash_type = HASH_TYPE_SHA512;
10971 salt_type = SALT_TYPE_EMBEDDED;
10972 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10973 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10974 kern_type = KERN_TYPE_TCSHA512_XTS512;
10975 dgst_size = DGST_SIZE_8_8;
10976 parse_func = veracrypt_parse_hash_500000;
10977 sort_by_digest = sort_by_digest_8_8;
10978 opti_type = OPTI_TYPE_ZERO_BYTE
10979 | OPTI_TYPE_USES_BITS_64;
10980 dgst_pos0 = 0;
10981 dgst_pos1 = 1;
10982 dgst_pos2 = 2;
10983 dgst_pos3 = 3;
10984 break;
10985
10986 case 13722: hash_type = HASH_TYPE_SHA512;
10987 salt_type = SALT_TYPE_EMBEDDED;
10988 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10989 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10990 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10991 dgst_size = DGST_SIZE_8_8;
10992 parse_func = veracrypt_parse_hash_500000;
10993 sort_by_digest = sort_by_digest_8_8;
10994 opti_type = OPTI_TYPE_ZERO_BYTE
10995 | OPTI_TYPE_USES_BITS_64;
10996 dgst_pos0 = 0;
10997 dgst_pos1 = 1;
10998 dgst_pos2 = 2;
10999 dgst_pos3 = 3;
11000 break;
11001
11002 case 13723: hash_type = HASH_TYPE_SHA512;
11003 salt_type = SALT_TYPE_EMBEDDED;
11004 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11005 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11006 kern_type = KERN_TYPE_TCSHA512_XTS1536;
11007 dgst_size = DGST_SIZE_8_8;
11008 parse_func = veracrypt_parse_hash_500000;
11009 sort_by_digest = sort_by_digest_8_8;
11010 opti_type = OPTI_TYPE_ZERO_BYTE
11011 | OPTI_TYPE_USES_BITS_64;
11012 dgst_pos0 = 0;
11013 dgst_pos1 = 1;
11014 dgst_pos2 = 2;
11015 dgst_pos3 = 3;
11016 break;
11017
11018 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
11019 salt_type = SALT_TYPE_EMBEDDED;
11020 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11021 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11022 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
11023 dgst_size = DGST_SIZE_4_8;
11024 parse_func = veracrypt_parse_hash_500000;
11025 sort_by_digest = sort_by_digest_4_8;
11026 opti_type = OPTI_TYPE_ZERO_BYTE;
11027 dgst_pos0 = 0;
11028 dgst_pos1 = 1;
11029 dgst_pos2 = 2;
11030 dgst_pos3 = 3;
11031 break;
11032
11033 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
11034 salt_type = SALT_TYPE_EMBEDDED;
11035 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11036 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11037 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
11038 dgst_size = DGST_SIZE_4_8;
11039 parse_func = veracrypt_parse_hash_500000;
11040 sort_by_digest = sort_by_digest_4_8;
11041 opti_type = OPTI_TYPE_ZERO_BYTE;
11042 dgst_pos0 = 0;
11043 dgst_pos1 = 1;
11044 dgst_pos2 = 2;
11045 dgst_pos3 = 3;
11046 break;
11047
11048 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
11049 salt_type = SALT_TYPE_EMBEDDED;
11050 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11051 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11052 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
11053 dgst_size = DGST_SIZE_4_8;
11054 parse_func = veracrypt_parse_hash_500000;
11055 sort_by_digest = sort_by_digest_4_8;
11056 opti_type = OPTI_TYPE_ZERO_BYTE;
11057 dgst_pos0 = 0;
11058 dgst_pos1 = 1;
11059 dgst_pos2 = 2;
11060 dgst_pos3 = 3;
11061 break;
11062
11063 case 13741: hash_type = HASH_TYPE_RIPEMD160;
11064 salt_type = SALT_TYPE_EMBEDDED;
11065 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11066 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11067 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
11068 dgst_size = DGST_SIZE_4_5;
11069 parse_func = veracrypt_parse_hash_327661;
11070 sort_by_digest = sort_by_digest_4_5;
11071 opti_type = OPTI_TYPE_ZERO_BYTE;
11072 dgst_pos0 = 0;
11073 dgst_pos1 = 1;
11074 dgst_pos2 = 2;
11075 dgst_pos3 = 3;
11076 break;
11077
11078 case 13742: hash_type = HASH_TYPE_RIPEMD160;
11079 salt_type = SALT_TYPE_EMBEDDED;
11080 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11081 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11082 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
11083 dgst_size = DGST_SIZE_4_5;
11084 parse_func = veracrypt_parse_hash_327661;
11085 sort_by_digest = sort_by_digest_4_5;
11086 opti_type = OPTI_TYPE_ZERO_BYTE;
11087 dgst_pos0 = 0;
11088 dgst_pos1 = 1;
11089 dgst_pos2 = 2;
11090 dgst_pos3 = 3;
11091 break;
11092
11093 case 13743: hash_type = HASH_TYPE_RIPEMD160;
11094 salt_type = SALT_TYPE_EMBEDDED;
11095 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11096 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11097 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11098 dgst_size = DGST_SIZE_4_5;
11099 parse_func = veracrypt_parse_hash_327661;
11100 sort_by_digest = sort_by_digest_4_5;
11101 opti_type = OPTI_TYPE_ZERO_BYTE;
11102 dgst_pos0 = 0;
11103 dgst_pos1 = 1;
11104 dgst_pos2 = 2;
11105 dgst_pos3 = 3;
11106 break;
11107
11108 case 13751: hash_type = HASH_TYPE_SHA256;
11109 salt_type = SALT_TYPE_EMBEDDED;
11110 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11111 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11112 kern_type = KERN_TYPE_VCSHA256_XTS512;
11113 dgst_size = DGST_SIZE_4_8;
11114 parse_func = veracrypt_parse_hash_500000;
11115 sort_by_digest = sort_by_digest_4_8;
11116 opti_type = OPTI_TYPE_ZERO_BYTE;
11117 dgst_pos0 = 0;
11118 dgst_pos1 = 1;
11119 dgst_pos2 = 2;
11120 dgst_pos3 = 3;
11121 break;
11122
11123 case 13752: hash_type = HASH_TYPE_SHA256;
11124 salt_type = SALT_TYPE_EMBEDDED;
11125 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11126 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11127 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11128 dgst_size = DGST_SIZE_4_8;
11129 parse_func = veracrypt_parse_hash_500000;
11130 sort_by_digest = sort_by_digest_4_8;
11131 opti_type = OPTI_TYPE_ZERO_BYTE;
11132 dgst_pos0 = 0;
11133 dgst_pos1 = 1;
11134 dgst_pos2 = 2;
11135 dgst_pos3 = 3;
11136 break;
11137
11138 case 13753: hash_type = HASH_TYPE_SHA256;
11139 salt_type = SALT_TYPE_EMBEDDED;
11140 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11141 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11142 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11143 dgst_size = DGST_SIZE_4_8;
11144 parse_func = veracrypt_parse_hash_500000;
11145 sort_by_digest = sort_by_digest_4_8;
11146 opti_type = OPTI_TYPE_ZERO_BYTE;
11147 dgst_pos0 = 0;
11148 dgst_pos1 = 1;
11149 dgst_pos2 = 2;
11150 dgst_pos3 = 3;
11151 break;
11152
11153 case 13761: hash_type = HASH_TYPE_SHA256;
11154 salt_type = SALT_TYPE_EMBEDDED;
11155 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11156 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11157 kern_type = KERN_TYPE_VCSHA256_XTS512;
11158 dgst_size = DGST_SIZE_4_8;
11159 parse_func = veracrypt_parse_hash_200000;
11160 sort_by_digest = sort_by_digest_4_8;
11161 opti_type = OPTI_TYPE_ZERO_BYTE;
11162 dgst_pos0 = 0;
11163 dgst_pos1 = 1;
11164 dgst_pos2 = 2;
11165 dgst_pos3 = 3;
11166 break;
11167
11168 case 13762: hash_type = HASH_TYPE_SHA256;
11169 salt_type = SALT_TYPE_EMBEDDED;
11170 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11171 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11172 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11173 dgst_size = DGST_SIZE_4_8;
11174 parse_func = veracrypt_parse_hash_200000;
11175 sort_by_digest = sort_by_digest_4_8;
11176 opti_type = OPTI_TYPE_ZERO_BYTE;
11177 dgst_pos0 = 0;
11178 dgst_pos1 = 1;
11179 dgst_pos2 = 2;
11180 dgst_pos3 = 3;
11181 break;
11182
11183 case 13763: hash_type = HASH_TYPE_SHA256;
11184 salt_type = SALT_TYPE_EMBEDDED;
11185 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11186 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11187 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11188 dgst_size = DGST_SIZE_4_8;
11189 parse_func = veracrypt_parse_hash_200000;
11190 sort_by_digest = sort_by_digest_4_8;
11191 opti_type = OPTI_TYPE_ZERO_BYTE;
11192 dgst_pos0 = 0;
11193 dgst_pos1 = 1;
11194 dgst_pos2 = 2;
11195 dgst_pos3 = 3;
11196 break;
11197
11198 case 13800: hash_type = HASH_TYPE_SHA256;
11199 salt_type = SALT_TYPE_EMBEDDED;
11200 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11201 opts_type = OPTS_TYPE_PT_GENERATE_BE
11202 | OPTS_TYPE_PT_UNICODE;
11203 kern_type = KERN_TYPE_WIN8PHONE;
11204 dgst_size = DGST_SIZE_4_8;
11205 parse_func = win8phone_parse_hash;
11206 sort_by_digest = sort_by_digest_4_8;
11207 opti_type = OPTI_TYPE_ZERO_BYTE
11208 | OPTI_TYPE_PRECOMPUTE_INIT
11209 | OPTI_TYPE_EARLY_SKIP
11210 | OPTI_TYPE_NOT_ITERATED
11211 | OPTI_TYPE_RAW_HASH;
11212 dgst_pos0 = 3;
11213 dgst_pos1 = 7;
11214 dgst_pos2 = 2;
11215 dgst_pos3 = 6;
11216 break;
11217
11218 default: usage_mini_print (PROGNAME); return (-1);
11219 }
11220
11221 /**
11222 * parser
11223 */
11224
11225 data.parse_func = parse_func;
11226
11227 /**
11228 * misc stuff
11229 */
11230
11231 if (hex_salt)
11232 {
11233 if (salt_type == SALT_TYPE_INTERN)
11234 {
11235 opts_type |= OPTS_TYPE_ST_HEX;
11236 }
11237 else
11238 {
11239 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11240
11241 return (-1);
11242 }
11243 }
11244
11245 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11246 | (salt_type == SALT_TYPE_EXTERN)
11247 | (salt_type == SALT_TYPE_EMBEDDED)
11248 | (salt_type == SALT_TYPE_VIRTUAL));
11249
11250 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
11251
11252 data.hash_type = hash_type;
11253 data.attack_mode = attack_mode;
11254 data.attack_kern = attack_kern;
11255 data.attack_exec = attack_exec;
11256 data.kern_type = kern_type;
11257 data.opts_type = opts_type;
11258 data.dgst_size = dgst_size;
11259 data.salt_type = salt_type;
11260 data.isSalted = isSalted;
11261 data.sort_by_digest = sort_by_digest;
11262 data.dgst_pos0 = dgst_pos0;
11263 data.dgst_pos1 = dgst_pos1;
11264 data.dgst_pos2 = dgst_pos2;
11265 data.dgst_pos3 = dgst_pos3;
11266
11267 esalt_size = 0;
11268
11269 switch (hash_mode)
11270 {
11271 case 2500: esalt_size = sizeof (wpa_t); break;
11272 case 5300: esalt_size = sizeof (ikepsk_t); break;
11273 case 5400: esalt_size = sizeof (ikepsk_t); break;
11274 case 5500: esalt_size = sizeof (netntlm_t); break;
11275 case 5600: esalt_size = sizeof (netntlm_t); break;
11276 case 6211: esalt_size = sizeof (tc_t); break;
11277 case 6212: esalt_size = sizeof (tc_t); break;
11278 case 6213: esalt_size = sizeof (tc_t); break;
11279 case 6221: esalt_size = sizeof (tc_t); break;
11280 case 6222: esalt_size = sizeof (tc_t); break;
11281 case 6223: esalt_size = sizeof (tc_t); break;
11282 case 6231: esalt_size = sizeof (tc_t); break;
11283 case 6232: esalt_size = sizeof (tc_t); break;
11284 case 6233: esalt_size = sizeof (tc_t); break;
11285 case 6241: esalt_size = sizeof (tc_t); break;
11286 case 6242: esalt_size = sizeof (tc_t); break;
11287 case 6243: esalt_size = sizeof (tc_t); break;
11288 case 6600: esalt_size = sizeof (agilekey_t); break;
11289 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11290 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
11291 case 7300: esalt_size = sizeof (rakp_t); break;
11292 case 7500: esalt_size = sizeof (krb5pa_t); break;
11293 case 8200: esalt_size = sizeof (cloudkey_t); break;
11294 case 8800: esalt_size = sizeof (androidfde_t); break;
11295 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
11296 case 9400: esalt_size = sizeof (office2007_t); break;
11297 case 9500: esalt_size = sizeof (office2010_t); break;
11298 case 9600: esalt_size = sizeof (office2013_t); break;
11299 case 9700: esalt_size = sizeof (oldoffice01_t); break;
11300 case 9710: esalt_size = sizeof (oldoffice01_t); break;
11301 case 9720: esalt_size = sizeof (oldoffice01_t); break;
11302 case 9800: esalt_size = sizeof (oldoffice34_t); break;
11303 case 9810: esalt_size = sizeof (oldoffice34_t); break;
11304 case 9820: esalt_size = sizeof (oldoffice34_t); break;
11305 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
11306 case 10200: esalt_size = sizeof (cram_md5_t); break;
11307 case 10400: esalt_size = sizeof (pdf_t); break;
11308 case 10410: esalt_size = sizeof (pdf_t); break;
11309 case 10420: esalt_size = sizeof (pdf_t); break;
11310 case 10500: esalt_size = sizeof (pdf_t); break;
11311 case 10600: esalt_size = sizeof (pdf_t); break;
11312 case 10700: esalt_size = sizeof (pdf_t); break;
11313 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
11314 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
11315 case 11400: esalt_size = sizeof (sip_t); break;
11316 case 11600: esalt_size = sizeof (seven_zip_t); break;
11317 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
11318 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
11319 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11320 case 13000: esalt_size = sizeof (rar5_t); break;
11321 case 13100: esalt_size = sizeof (krb5tgs_t); break;
11322 case 13400: esalt_size = sizeof (keepass_t); break;
11323 case 13500: esalt_size = sizeof (pstoken_t); break;
11324 case 13600: esalt_size = sizeof (zip2_t); break;
11325 case 13711: esalt_size = sizeof (tc_t); break;
11326 case 13712: esalt_size = sizeof (tc_t); break;
11327 case 13713: esalt_size = sizeof (tc_t); break;
11328 case 13721: esalt_size = sizeof (tc_t); break;
11329 case 13722: esalt_size = sizeof (tc_t); break;
11330 case 13723: esalt_size = sizeof (tc_t); break;
11331 case 13731: esalt_size = sizeof (tc_t); break;
11332 case 13732: esalt_size = sizeof (tc_t); break;
11333 case 13733: esalt_size = sizeof (tc_t); break;
11334 case 13741: esalt_size = sizeof (tc_t); break;
11335 case 13742: esalt_size = sizeof (tc_t); break;
11336 case 13743: esalt_size = sizeof (tc_t); break;
11337 case 13751: esalt_size = sizeof (tc_t); break;
11338 case 13752: esalt_size = sizeof (tc_t); break;
11339 case 13753: esalt_size = sizeof (tc_t); break;
11340 case 13761: esalt_size = sizeof (tc_t); break;
11341 case 13762: esalt_size = sizeof (tc_t); break;
11342 case 13763: esalt_size = sizeof (tc_t); break;
11343 case 13800: esalt_size = sizeof (win8phone_t); break;
11344 }
11345
11346 data.esalt_size = esalt_size;
11347
11348 /**
11349 * choose dictionary parser
11350 */
11351
11352 if (hash_type == HASH_TYPE_LM)
11353 {
11354 get_next_word_func = get_next_word_lm;
11355 }
11356 else if (opts_type & OPTS_TYPE_PT_UPPER)
11357 {
11358 get_next_word_func = get_next_word_uc;
11359 }
11360 else
11361 {
11362 get_next_word_func = get_next_word_std;
11363 }
11364
11365 /**
11366 * dictstat
11367 */
11368
11369 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11370
11371 #ifdef _POSIX
11372 size_t dictstat_nmemb = 0;
11373 #endif
11374
11375 #ifdef _WIN
11376 uint dictstat_nmemb = 0;
11377 #endif
11378
11379 char dictstat[256] = { 0 };
11380
11381 FILE *dictstat_fp = NULL;
11382
11383 if (keyspace == 0)
11384 {
11385 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11386
11387 dictstat_fp = fopen (dictstat, "rb");
11388
11389 if (dictstat_fp)
11390 {
11391 #ifdef _POSIX
11392 struct stat tmpstat;
11393
11394 fstat (fileno (dictstat_fp), &tmpstat);
11395 #endif
11396
11397 #ifdef _WIN
11398 struct stat64 tmpstat;
11399
11400 _fstat64 (fileno (dictstat_fp), &tmpstat);
11401 #endif
11402
11403 if (tmpstat.st_mtime < COMPTIME)
11404 {
11405 /* with v0.15 the format changed so we have to ensure user is using a good version
11406 since there is no version-header in the dictstat file */
11407
11408 fclose (dictstat_fp);
11409
11410 unlink (dictstat);
11411 }
11412 else
11413 {
11414 while (!feof (dictstat_fp))
11415 {
11416 dictstat_t d;
11417
11418 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11419
11420 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11421
11422 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11423 {
11424 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11425
11426 return -1;
11427 }
11428 }
11429
11430 fclose (dictstat_fp);
11431 }
11432 }
11433 }
11434
11435 /**
11436 * potfile
11437 */
11438
11439 char potfile[256] = { 0 };
11440
11441 if (potfile_path == NULL)
11442 {
11443 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11444 }
11445 else
11446 {
11447 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11448 }
11449
11450 data.pot_fp = NULL;
11451
11452 FILE *out_fp = NULL;
11453 FILE *pot_fp = NULL;
11454
11455 if (show == 1 || left == 1)
11456 {
11457 pot_fp = fopen (potfile, "rb");
11458
11459 if (pot_fp == NULL)
11460 {
11461 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11462
11463 return (-1);
11464 }
11465
11466 if (outfile != NULL)
11467 {
11468 if ((out_fp = fopen (outfile, "ab")) == NULL)
11469 {
11470 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11471
11472 fclose (pot_fp);
11473
11474 return (-1);
11475 }
11476 }
11477 else
11478 {
11479 out_fp = stdout;
11480 }
11481 }
11482 else
11483 {
11484 if (potfile_disable == 0)
11485 {
11486 pot_fp = fopen (potfile, "ab");
11487
11488 if (pot_fp == NULL)
11489 {
11490 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11491
11492 return (-1);
11493 }
11494
11495 data.pot_fp = pot_fp;
11496 }
11497 }
11498
11499 pot_t *pot = NULL;
11500
11501 uint pot_cnt = 0;
11502 uint pot_avail = 0;
11503
11504 if (show == 1 || left == 1)
11505 {
11506 SUPPRESS_OUTPUT = 1;
11507
11508 pot_avail = count_lines (pot_fp);
11509
11510 rewind (pot_fp);
11511
11512 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11513
11514 uint pot_hashes_avail = 0;
11515
11516 uint line_num = 0;
11517
11518 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11519
11520 while (!feof (pot_fp))
11521 {
11522 line_num++;
11523
11524 int line_len = fgetl (pot_fp, line_buf);
11525
11526 if (line_len == 0) continue;
11527
11528 char *plain_buf = line_buf + line_len;
11529
11530 pot_t *pot_ptr = &pot[pot_cnt];
11531
11532 hash_t *hashes_buf = &pot_ptr->hash;
11533
11534 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11535 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11536
11537 if (pot_cnt == pot_hashes_avail)
11538 {
11539 uint pos = 0;
11540
11541 for (pos = 0; pos < INCR_POT; pos++)
11542 {
11543 if ((pot_cnt + pos) >= pot_avail) break;
11544
11545 pot_t *tmp_pot = &pot[pot_cnt + pos];
11546
11547 hash_t *tmp_hash = &tmp_pot->hash;
11548
11549 tmp_hash->digest = mymalloc (dgst_size);
11550
11551 if (isSalted)
11552 {
11553 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11554 }
11555
11556 if (esalt_size)
11557 {
11558 tmp_hash->esalt = mymalloc (esalt_size);
11559 }
11560
11561 pot_hashes_avail++;
11562 }
11563 }
11564
11565 int plain_len = 0;
11566
11567 int parser_status;
11568
11569 int iter = MAX_CUT_TRIES;
11570
11571 do
11572 {
11573 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11574 {
11575 if (line_buf[i] == ':')
11576 {
11577 line_len--;
11578
11579 break;
11580 }
11581 }
11582
11583 if (data.hash_mode != 2500)
11584 {
11585 parser_status = parse_func (line_buf, line_len, hashes_buf);
11586 }
11587 else
11588 {
11589 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11590
11591 if (line_len > max_salt_size)
11592 {
11593 parser_status = PARSER_GLOBAL_LENGTH;
11594 }
11595 else
11596 {
11597 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11598
11599 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11600
11601 hashes_buf->salt->salt_len = line_len;
11602
11603 parser_status = PARSER_OK;
11604 }
11605 }
11606
11607 // if NOT parsed without error, we add the ":" to the plain
11608
11609 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11610 {
11611 plain_len++;
11612 plain_buf--;
11613 }
11614
11615 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11616
11617 if (parser_status < PARSER_GLOBAL_ZERO)
11618 {
11619 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11620
11621 continue;
11622 }
11623
11624 if (plain_len >= 255) continue;
11625
11626 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11627
11628 pot_ptr->plain_len = plain_len;
11629
11630 pot_cnt++;
11631 }
11632
11633 myfree (line_buf);
11634
11635 fclose (pot_fp);
11636
11637 SUPPRESS_OUTPUT = 0;
11638
11639 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11640 }
11641
11642 /**
11643 * word len
11644 */
11645
11646 uint pw_min = PW_MIN;
11647 uint pw_max = PW_MAX;
11648
11649 switch (hash_mode)
11650 {
11651 case 125: if (pw_max > 32) pw_max = 32;
11652 break;
11653 case 400: if (pw_max > 40) pw_max = 40;
11654 break;
11655 case 500: if (pw_max > 16) pw_max = 16;
11656 break;
11657 case 1500: if (pw_max > 8) pw_max = 8;
11658 break;
11659 case 1600: if (pw_max > 16) pw_max = 16;
11660 break;
11661 case 1800: if (pw_max > 16) pw_max = 16;
11662 break;
11663 case 2100: if (pw_max > 16) pw_max = 16;
11664 break;
11665 case 2500: if (pw_min < 8) pw_min = 8;
11666 break;
11667 case 3000: if (pw_max > 7) pw_max = 7;
11668 break;
11669 case 5200: if (pw_max > 24) pw_max = 24;
11670 break;
11671 case 5800: if (pw_max > 16) pw_max = 16;
11672 break;
11673 case 6300: if (pw_max > 16) pw_max = 16;
11674 break;
11675 case 7400: if (pw_max > 16) pw_max = 16;
11676 break;
11677 case 7700: if (pw_max > 8) pw_max = 8;
11678 break;
11679 case 7900: if (pw_max > 48) pw_max = 48;
11680 break;
11681 case 8500: if (pw_max > 8) pw_max = 8;
11682 break;
11683 case 8600: if (pw_max > 16) pw_max = 16;
11684 break;
11685 case 9710: pw_min = 5;
11686 pw_max = 5;
11687 break;
11688 case 9810: pw_min = 5;
11689 pw_max = 5;
11690 break;
11691 case 10410: pw_min = 5;
11692 pw_max = 5;
11693 break;
11694 case 10300: if (pw_max < 3) pw_min = 3;
11695 if (pw_max > 40) pw_max = 40;
11696 break;
11697 case 10500: if (pw_max < 3) pw_min = 3;
11698 if (pw_max > 40) pw_max = 40;
11699 break;
11700 case 10700: if (pw_max > 16) pw_max = 16;
11701 break;
11702 case 11300: if (pw_max > 40) pw_max = 40;
11703 break;
11704 case 11600: if (pw_max > 32) pw_max = 32;
11705 break;
11706 case 12500: if (pw_max > 20) pw_max = 20;
11707 break;
11708 case 12800: if (pw_max > 24) pw_max = 24;
11709 break;
11710 }
11711
11712 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11713 {
11714 switch (attack_kern)
11715 {
11716 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11717 break;
11718 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11719 break;
11720 }
11721 }
11722
11723 /**
11724 * charsets : keep them together for more easy maintainnce
11725 */
11726
11727 cs_t mp_sys[6] = { { { 0 }, 0 } };
11728 cs_t mp_usr[4] = { { { 0 }, 0 } };
11729
11730 mp_setup_sys (mp_sys);
11731
11732 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11733 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11734 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11735 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11736
11737 /**
11738 * load hashes, part I: find input mode, count hashes
11739 */
11740
11741 uint hashlist_mode = 0;
11742 uint hashlist_format = HLFMT_HASHCAT;
11743
11744 uint hashes_avail = 0;
11745
11746 if ((benchmark == 0) && (stdout_flag == 0))
11747 {
11748 struct stat f;
11749
11750 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11751
11752 if ((hash_mode == 2500) ||
11753 (hash_mode == 5200) ||
11754 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11755 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11756 (hash_mode == 9000))
11757 {
11758 hashlist_mode = HL_MODE_ARG;
11759
11760 char *hashfile = myargv[optind];
11761
11762 data.hashfile = hashfile;
11763
11764 logfile_top_var_string ("target", hashfile);
11765 }
11766
11767 if (hashlist_mode == HL_MODE_ARG)
11768 {
11769 if (hash_mode == 2500)
11770 {
11771 struct stat st;
11772
11773 if (stat (data.hashfile, &st) == -1)
11774 {
11775 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11776
11777 return (-1);
11778 }
11779
11780 hashes_avail = st.st_size / sizeof (hccap_t);
11781 }
11782 else
11783 {
11784 hashes_avail = 1;
11785 }
11786 }
11787 else if (hashlist_mode == HL_MODE_FILE)
11788 {
11789 char *hashfile = myargv[optind];
11790
11791 data.hashfile = hashfile;
11792
11793 logfile_top_var_string ("target", hashfile);
11794
11795 FILE *fp = NULL;
11796
11797 if ((fp = fopen (hashfile, "rb")) == NULL)
11798 {
11799 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11800
11801 return (-1);
11802 }
11803
11804 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11805
11806 hashes_avail = count_lines (fp);
11807
11808 rewind (fp);
11809
11810 if (hashes_avail == 0)
11811 {
11812 log_error ("ERROR: hashfile is empty or corrupt");
11813
11814 fclose (fp);
11815
11816 return (-1);
11817 }
11818
11819 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11820
11821 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11822 {
11823 log_error ("ERROR: remove not supported in native hashfile-format mode");
11824
11825 fclose (fp);
11826
11827 return (-1);
11828 }
11829
11830 fclose (fp);
11831 }
11832 }
11833 else
11834 {
11835 hashlist_mode = HL_MODE_ARG;
11836
11837 hashes_avail = 1;
11838 }
11839
11840 if (hash_mode == 3000) hashes_avail *= 2;
11841
11842 data.hashlist_mode = hashlist_mode;
11843 data.hashlist_format = hashlist_format;
11844
11845 logfile_top_uint (hashlist_mode);
11846 logfile_top_uint (hashlist_format);
11847
11848 /**
11849 * load hashes, part II: allocate required memory, set pointers
11850 */
11851
11852 hash_t *hashes_buf = NULL;
11853 void *digests_buf = NULL;
11854 salt_t *salts_buf = NULL;
11855 void *esalts_buf = NULL;
11856
11857 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11858
11859 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11860
11861 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11862 {
11863 u32 hash_pos;
11864
11865 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11866 {
11867 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11868
11869 hashes_buf[hash_pos].hash_info = hash_info;
11870
11871 if (username && (remove || show || left))
11872 {
11873 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11874 }
11875
11876 if (benchmark)
11877 {
11878 hash_info->orighash = (char *) mymalloc (256);
11879 }
11880 }
11881 }
11882
11883 if (isSalted)
11884 {
11885 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11886
11887 if (esalt_size)
11888 {
11889 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11890 }
11891 }
11892 else
11893 {
11894 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11895 }
11896
11897 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11898 {
11899 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11900
11901 if (isSalted)
11902 {
11903 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11904
11905 if (esalt_size)
11906 {
11907 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11908 }
11909 }
11910 else
11911 {
11912 hashes_buf[hash_pos].salt = &salts_buf[0];
11913 }
11914 }
11915
11916 /**
11917 * load hashes, part III: parse hashes or generate them if benchmark
11918 */
11919
11920 uint hashes_cnt = 0;
11921
11922 if (benchmark == 0)
11923 {
11924 if (keyspace == 1)
11925 {
11926 // useless to read hash file for keyspace, cheat a little bit w/ optind
11927 }
11928 else if (stdout_flag == 1)
11929 {
11930 // useless to read hash file for stdout, cheat a little bit w/ optind
11931 }
11932 else if (hashes_avail == 0)
11933 {
11934 }
11935 else if (hashlist_mode == HL_MODE_ARG)
11936 {
11937 char *input_buf = myargv[optind];
11938
11939 uint input_len = strlen (input_buf);
11940
11941 logfile_top_var_string ("target", input_buf);
11942
11943 char *hash_buf = NULL;
11944 int hash_len = 0;
11945
11946 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11947
11948 bool hash_fmt_error = 0;
11949
11950 if (hash_len < 1) hash_fmt_error = 1;
11951 if (hash_buf == NULL) hash_fmt_error = 1;
11952
11953 if (hash_fmt_error)
11954 {
11955 log_info ("WARNING: Failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11956 }
11957 else
11958 {
11959 if (opts_type & OPTS_TYPE_HASH_COPY)
11960 {
11961 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11962
11963 hash_info_tmp->orighash = mystrdup (hash_buf);
11964 }
11965
11966 if (isSalted)
11967 {
11968 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11969 }
11970
11971 int parser_status = PARSER_OK;
11972
11973 if (hash_mode == 2500)
11974 {
11975 if (hash_len == 0)
11976 {
11977 log_error ("ERROR: hccap file not specified");
11978
11979 return (-1);
11980 }
11981
11982 hashlist_mode = HL_MODE_FILE;
11983
11984 data.hashlist_mode = hashlist_mode;
11985
11986 FILE *fp = fopen (hash_buf, "rb");
11987
11988 if (fp == NULL)
11989 {
11990 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11991
11992 return (-1);
11993 }
11994
11995 if (hashes_avail < 1)
11996 {
11997 log_error ("ERROR: hccap file is empty or corrupt");
11998
11999 fclose (fp);
12000
12001 return (-1);
12002 }
12003
12004 uint hccap_size = sizeof (hccap_t);
12005
12006 char *in = (char *) mymalloc (hccap_size);
12007
12008 while (!feof (fp))
12009 {
12010 int n = fread (in, hccap_size, 1, fp);
12011
12012 if (n != 1)
12013 {
12014 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
12015
12016 break;
12017 }
12018
12019 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
12020
12021 if (parser_status != PARSER_OK)
12022 {
12023 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
12024
12025 continue;
12026 }
12027
12028 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
12029
12030 if ((show == 1) || (left == 1))
12031 {
12032 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
12033
12034 char *salt_ptr = (char *) tmp_salt->salt_buf;
12035
12036 int cur_pos = tmp_salt->salt_len;
12037 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12038
12039 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
12040
12041 // do the appending task
12042
12043 snprintf (salt_ptr + cur_pos,
12044 rem_len,
12045 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
12046 wpa->orig_mac1[0],
12047 wpa->orig_mac1[1],
12048 wpa->orig_mac1[2],
12049 wpa->orig_mac1[3],
12050 wpa->orig_mac1[4],
12051 wpa->orig_mac1[5],
12052 wpa->orig_mac2[0],
12053 wpa->orig_mac2[1],
12054 wpa->orig_mac2[2],
12055 wpa->orig_mac2[3],
12056 wpa->orig_mac2[4],
12057 wpa->orig_mac2[5]);
12058
12059 // memset () the remaining part of the salt
12060
12061 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
12062 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12063
12064 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
12065
12066 tmp_salt->salt_len += 1 + 12 + 1 + 12;
12067 }
12068
12069 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);
12070 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);
12071
12072 hashes_cnt++;
12073 }
12074
12075 fclose (fp);
12076
12077 myfree (in);
12078 }
12079 else if (hash_mode == 3000)
12080 {
12081 if (hash_len == 32)
12082 {
12083 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12084
12085 hash_t *lm_hash_left = NULL;
12086
12087 if (parser_status == PARSER_OK)
12088 {
12089 lm_hash_left = &hashes_buf[hashes_cnt];
12090
12091 hashes_cnt++;
12092 }
12093 else
12094 {
12095 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12096 }
12097
12098 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12099
12100 hash_t *lm_hash_right = NULL;
12101
12102 if (parser_status == PARSER_OK)
12103 {
12104 lm_hash_right = &hashes_buf[hashes_cnt];
12105
12106 hashes_cnt++;
12107 }
12108 else
12109 {
12110 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12111 }
12112
12113 // show / left
12114
12115 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12116 {
12117 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);
12118 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);
12119 }
12120 }
12121 else
12122 {
12123 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12124
12125 if (parser_status == PARSER_OK)
12126 {
12127 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12128 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12129 }
12130
12131 if (parser_status == PARSER_OK)
12132 {
12133 hashes_cnt++;
12134 }
12135 else
12136 {
12137 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12138 }
12139 }
12140 }
12141 else
12142 {
12143 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12144
12145 if (parser_status == PARSER_OK)
12146 {
12147 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12148 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12149 }
12150
12151 if (parser_status == PARSER_OK)
12152 {
12153 hashes_cnt++;
12154 }
12155 else
12156 {
12157 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12158 }
12159 }
12160 }
12161 }
12162 else if (hashlist_mode == HL_MODE_FILE)
12163 {
12164 char *hashfile = data.hashfile;
12165
12166 FILE *fp;
12167
12168 if ((fp = fopen (hashfile, "rb")) == NULL)
12169 {
12170 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12171
12172 return (-1);
12173 }
12174
12175 uint line_num = 0;
12176
12177 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12178
12179 while (!feof (fp))
12180 {
12181 line_num++;
12182
12183 int line_len = fgetl (fp, line_buf);
12184
12185 if (line_len == 0) continue;
12186
12187 char *hash_buf = NULL;
12188 int hash_len = 0;
12189
12190 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12191
12192 bool hash_fmt_error = 0;
12193
12194 if (hash_len < 1) hash_fmt_error = 1;
12195 if (hash_buf == NULL) hash_fmt_error = 1;
12196
12197 if (hash_fmt_error)
12198 {
12199 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12200
12201 continue;
12202 }
12203
12204 if (username)
12205 {
12206 char *user_buf = NULL;
12207 int user_len = 0;
12208
12209 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12210
12211 if (remove || show)
12212 {
12213 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12214
12215 *user = (user_t *) mymalloc (sizeof (user_t));
12216
12217 user_t *user_ptr = *user;
12218
12219 if (user_buf != NULL)
12220 {
12221 user_ptr->user_name = mystrdup (user_buf);
12222 }
12223 else
12224 {
12225 user_ptr->user_name = mystrdup ("");
12226 }
12227
12228 user_ptr->user_len = user_len;
12229 }
12230 }
12231
12232 if (opts_type & OPTS_TYPE_HASH_COPY)
12233 {
12234 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12235
12236 hash_info_tmp->orighash = mystrdup (hash_buf);
12237 }
12238
12239 if (isSalted)
12240 {
12241 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12242 }
12243
12244 if (hash_mode == 3000)
12245 {
12246 if (hash_len == 32)
12247 {
12248 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12249
12250 if (parser_status < PARSER_GLOBAL_ZERO)
12251 {
12252 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12253
12254 continue;
12255 }
12256
12257 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12258
12259 hashes_cnt++;
12260
12261 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12262
12263 if (parser_status < PARSER_GLOBAL_ZERO)
12264 {
12265 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12266
12267 continue;
12268 }
12269
12270 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12271
12272 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);
12273
12274 hashes_cnt++;
12275
12276 // show / left
12277
12278 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);
12279 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);
12280 }
12281 else
12282 {
12283 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12284
12285 if (parser_status < PARSER_GLOBAL_ZERO)
12286 {
12287 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12288
12289 continue;
12290 }
12291
12292 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);
12293
12294 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12295 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12296
12297 hashes_cnt++;
12298 }
12299 }
12300 else
12301 {
12302 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12303
12304 if (parser_status < PARSER_GLOBAL_ZERO)
12305 {
12306 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12307
12308 continue;
12309 }
12310
12311 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);
12312
12313 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12314 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12315
12316 hashes_cnt++;
12317 }
12318 }
12319
12320 myfree (line_buf);
12321
12322 fclose (fp);
12323
12324 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12325
12326 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12327 }
12328 }
12329 else
12330 {
12331 if (isSalted)
12332 {
12333 hashes_buf[0].salt->salt_len = 8;
12334
12335 // special salt handling
12336
12337 switch (hash_mode)
12338 {
12339 case 1500: hashes_buf[0].salt->salt_len = 2;
12340 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12341 break;
12342 case 1731: hashes_buf[0].salt->salt_len = 4;
12343 break;
12344 case 2410: hashes_buf[0].salt->salt_len = 4;
12345 break;
12346 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12347 break;
12348 case 3100: hashes_buf[0].salt->salt_len = 1;
12349 break;
12350 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
12351 break;
12352 case 5800: hashes_buf[0].salt->salt_len = 16;
12353 break;
12354 case 6800: hashes_buf[0].salt->salt_len = 32;
12355 break;
12356 case 8400: hashes_buf[0].salt->salt_len = 40;
12357 break;
12358 case 8800: hashes_buf[0].salt->salt_len = 16;
12359 break;
12360 case 8900: hashes_buf[0].salt->salt_len = 16;
12361 hashes_buf[0].salt->scrypt_N = 1024;
12362 hashes_buf[0].salt->scrypt_r = 1;
12363 hashes_buf[0].salt->scrypt_p = 1;
12364 break;
12365 case 9100: hashes_buf[0].salt->salt_len = 16;
12366 break;
12367 case 9300: hashes_buf[0].salt->salt_len = 14;
12368 hashes_buf[0].salt->scrypt_N = 16384;
12369 hashes_buf[0].salt->scrypt_r = 1;
12370 hashes_buf[0].salt->scrypt_p = 1;
12371 break;
12372 case 9400: hashes_buf[0].salt->salt_len = 16;
12373 break;
12374 case 9500: hashes_buf[0].salt->salt_len = 16;
12375 break;
12376 case 9600: hashes_buf[0].salt->salt_len = 16;
12377 break;
12378 case 9700: hashes_buf[0].salt->salt_len = 16;
12379 break;
12380 case 9710: hashes_buf[0].salt->salt_len = 16;
12381 break;
12382 case 9720: hashes_buf[0].salt->salt_len = 16;
12383 break;
12384 case 9800: hashes_buf[0].salt->salt_len = 16;
12385 break;
12386 case 9810: hashes_buf[0].salt->salt_len = 16;
12387 break;
12388 case 9820: hashes_buf[0].salt->salt_len = 16;
12389 break;
12390 case 10300: hashes_buf[0].salt->salt_len = 12;
12391 break;
12392 case 11500: hashes_buf[0].salt->salt_len = 4;
12393 break;
12394 case 11600: hashes_buf[0].salt->salt_len = 4;
12395 break;
12396 case 12400: hashes_buf[0].salt->salt_len = 4;
12397 break;
12398 case 12500: hashes_buf[0].salt->salt_len = 8;
12399 break;
12400 case 12600: hashes_buf[0].salt->salt_len = 64;
12401 break;
12402 }
12403
12404 // special esalt handling
12405
12406 switch (hash_mode)
12407 {
12408 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12409 break;
12410 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12411 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12412 break;
12413 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12414 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12415 break;
12416 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12417 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12418 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12419 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12420 break;
12421 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12422 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12423 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12424 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12425 break;
12426 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12427 break;
12428 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12429 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12430 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12431 break;
12432 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12433 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12434 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12435 break;
12436 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12437 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12438 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12439 break;
12440 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12441 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12442 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12443 break;
12444 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12445 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12446 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12447 break;
12448 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12449 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12450 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12451 break;
12452 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12453 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12454 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12455 break;
12456 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12457 break;
12458 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12459 break;
12460 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12461 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12462 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12463 break;
12464 }
12465 }
12466
12467 // set hashfile
12468
12469 switch (hash_mode)
12470 {
12471 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12472 break;
12473 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12474 break;
12475 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12476 break;
12477 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12478 break;
12479 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12480 break;
12481 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12482 break;
12483 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12484 break;
12485 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12486 break;
12487 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12488 break;
12489 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12490 break;
12491 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12492 break;
12493 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12494 break;
12495 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12496 break;
12497 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12498 break;
12499 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12500 break;
12501 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12502 break;
12503 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12504 break;
12505 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12506 break;
12507 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12508 break;
12509 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12510 break;
12511 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12512 break;
12513 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12514 break;
12515 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12516 break;
12517 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12518 break;
12519 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12520 break;
12521 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12522 break;
12523 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12524 break;
12525 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12526 break;
12527 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12528 break;
12529 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12530 break;
12531 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12532 break;
12533 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12534 break;
12535 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12536 break;
12537 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12538 break;
12539 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12540 break;
12541 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12542 break;
12543 }
12544
12545 // set default iterations
12546
12547 switch (hash_mode)
12548 {
12549 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12550 break;
12551 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12552 break;
12553 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12554 break;
12555 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12556 break;
12557 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12558 break;
12559 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12560 break;
12561 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12562 break;
12563 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12564 break;
12565 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12566 break;
12567 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12568 break;
12569 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12570 break;
12571 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12572 break;
12573 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12574 break;
12575 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12576 break;
12577 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12578 break;
12579 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12580 break;
12581 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12582 break;
12583 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12584 break;
12585 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12586 break;
12587 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12588 break;
12589 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12590 break;
12591 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12592 break;
12593 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12594 break;
12595 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12596 break;
12597 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12598 break;
12599 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12600 break;
12601 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12602 break;
12603 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12604 break;
12605 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12606 break;
12607 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12608 break;
12609 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12610 break;
12611 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12612 break;
12613 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12614 break;
12615 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12616 break;
12617 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12618 break;
12619 case 8900: hashes_buf[0].salt->salt_iter = 1;
12620 break;
12621 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12622 break;
12623 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12624 break;
12625 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12626 break;
12627 case 9300: hashes_buf[0].salt->salt_iter = 1;
12628 break;
12629 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12630 break;
12631 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12632 break;
12633 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12634 break;
12635 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12636 break;
12637 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12638 break;
12639 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12640 break;
12641 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12642 break;
12643 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12644 break;
12645 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12646 break;
12647 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12648 break;
12649 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12650 break;
12651 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12652 break;
12653 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12654 break;
12655 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12656 break;
12657 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12658 break;
12659 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12660 break;
12661 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12662 break;
12663 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12664 break;
12665 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12666 break;
12667 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12668 break;
12669 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12670 break;
12671 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12672 break;
12673 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12674 break;
12675 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12676 break;
12677 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12678 break;
12679 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12680 break;
12681 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12682 break;
12683 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12684 break;
12685 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12686 break;
12687 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12688 break;
12689 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12690 break;
12691 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12692 break;
12693 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12694 break;
12695 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12696 break;
12697 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12698 break;
12699 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12700 break;
12701 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12702 break;
12703 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12704 break;
12705 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12706 break;
12707 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12708 break;
12709 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12710 break;
12711 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12712 break;
12713 }
12714
12715 hashes_cnt = 1;
12716 }
12717
12718 if (show == 1 || left == 1)
12719 {
12720 for (uint i = 0; i < pot_cnt; i++)
12721 {
12722 pot_t *pot_ptr = &pot[i];
12723
12724 hash_t *hashes_buf = &pot_ptr->hash;
12725
12726 local_free (hashes_buf->digest);
12727
12728 if (isSalted)
12729 {
12730 local_free (hashes_buf->salt);
12731 }
12732 }
12733
12734 local_free (pot);
12735
12736 if (data.quiet == 0) log_info_nn ("");
12737
12738 return (0);
12739 }
12740
12741 if ((keyspace == 0) && (stdout_flag == 0))
12742 {
12743 if (hashes_cnt == 0)
12744 {
12745 log_error ("ERROR: No hashes loaded");
12746
12747 return (-1);
12748 }
12749 }
12750
12751 /**
12752 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12753 */
12754
12755 if (data.outfile != NULL)
12756 {
12757 if (data.hashfile != NULL)
12758 {
12759 #ifdef _POSIX
12760 struct stat tmpstat_outfile;
12761 struct stat tmpstat_hashfile;
12762 #endif
12763
12764 #ifdef _WIN
12765 struct stat64 tmpstat_outfile;
12766 struct stat64 tmpstat_hashfile;
12767 #endif
12768
12769 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12770
12771 if (tmp_outfile_fp)
12772 {
12773 #ifdef _POSIX
12774 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12775 #endif
12776
12777 #ifdef _WIN
12778 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12779 #endif
12780
12781 fclose (tmp_outfile_fp);
12782 }
12783
12784 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12785
12786 if (tmp_hashfile_fp)
12787 {
12788 #ifdef _POSIX
12789 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12790 #endif
12791
12792 #ifdef _WIN
12793 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12794 #endif
12795
12796 fclose (tmp_hashfile_fp);
12797 }
12798
12799 if (tmp_outfile_fp && tmp_outfile_fp)
12800 {
12801 tmpstat_outfile.st_mode = 0;
12802 tmpstat_outfile.st_nlink = 0;
12803 tmpstat_outfile.st_uid = 0;
12804 tmpstat_outfile.st_gid = 0;
12805 tmpstat_outfile.st_rdev = 0;
12806 tmpstat_outfile.st_atime = 0;
12807
12808 tmpstat_hashfile.st_mode = 0;
12809 tmpstat_hashfile.st_nlink = 0;
12810 tmpstat_hashfile.st_uid = 0;
12811 tmpstat_hashfile.st_gid = 0;
12812 tmpstat_hashfile.st_rdev = 0;
12813 tmpstat_hashfile.st_atime = 0;
12814
12815 #ifdef _POSIX
12816 tmpstat_outfile.st_blksize = 0;
12817 tmpstat_outfile.st_blocks = 0;
12818
12819 tmpstat_hashfile.st_blksize = 0;
12820 tmpstat_hashfile.st_blocks = 0;
12821 #endif
12822
12823 #ifdef _POSIX
12824 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12825 {
12826 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12827
12828 return (-1);
12829 }
12830 #endif
12831
12832 #ifdef _WIN
12833 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12834 {
12835 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12836
12837 return (-1);
12838 }
12839 #endif
12840 }
12841 }
12842 }
12843
12844 /**
12845 * Remove duplicates
12846 */
12847
12848 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12849
12850 if (isSalted)
12851 {
12852 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12853 }
12854 else
12855 {
12856 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12857 }
12858
12859 uint hashes_cnt_orig = hashes_cnt;
12860
12861 hashes_cnt = 1;
12862
12863 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12864 {
12865 if (isSalted)
12866 {
12867 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12868 {
12869 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12870 }
12871 }
12872 else
12873 {
12874 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12875 }
12876
12877 if (hashes_pos > hashes_cnt)
12878 {
12879 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12880 }
12881
12882 hashes_cnt++;
12883 }
12884
12885 /**
12886 * Potfile removes
12887 */
12888
12889 uint potfile_remove_cracks = 0;
12890
12891 if (potfile_disable == 0)
12892 {
12893 hash_t hash_buf;
12894
12895 hash_buf.digest = mymalloc (dgst_size);
12896 hash_buf.salt = NULL;
12897 hash_buf.esalt = NULL;
12898 hash_buf.hash_info = NULL;
12899 hash_buf.cracked = 0;
12900
12901 if (isSalted)
12902 {
12903 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12904 }
12905
12906 if (esalt_size)
12907 {
12908 hash_buf.esalt = mymalloc (esalt_size);
12909 }
12910
12911 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12912
12913 // no solution for these special hash types (for instane because they use hashfile in output etc)
12914 if ((hash_mode != 5200) &&
12915 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12916 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12917 (hash_mode != 9000))
12918 {
12919 FILE *fp = fopen (potfile, "rb");
12920
12921 if (fp != NULL)
12922 {
12923 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12924
12925 // to be safe work with a copy (because of line_len loop, i etc)
12926 // moved up here because it's easier to handle continue case
12927 // it's just 64kb
12928
12929 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12930
12931 while (!feof (fp))
12932 {
12933 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12934
12935 if (ptr == NULL) break;
12936
12937 int line_len = strlen (line_buf);
12938
12939 if (line_len == 0) continue;
12940
12941 int iter = MAX_CUT_TRIES;
12942
12943 for (int i = line_len - 1; i && iter; i--, line_len--)
12944 {
12945 if (line_buf[i] != ':') continue;
12946
12947 if (isSalted)
12948 {
12949 memset (hash_buf.salt, 0, sizeof (salt_t));
12950 }
12951
12952 hash_t *found = NULL;
12953
12954 if (hash_mode == 6800)
12955 {
12956 if (i < 64) // 64 = 16 * uint in salt_buf[]
12957 {
12958 // manipulate salt_buf
12959 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12960
12961 hash_buf.salt->salt_len = i;
12962
12963 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12964 }
12965 }
12966 else if (hash_mode == 2500)
12967 {
12968 if (i < 64) // 64 = 16 * uint in salt_buf[]
12969 {
12970 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12971 // manipulate salt_buf
12972
12973 memcpy (line_buf_cpy, line_buf, i);
12974
12975 char *mac2_pos = strrchr (line_buf_cpy, ':');
12976
12977 if (mac2_pos == NULL) continue;
12978
12979 mac2_pos[0] = 0;
12980 mac2_pos++;
12981
12982 if (strlen (mac2_pos) != 12) continue;
12983
12984 char *mac1_pos = strrchr (line_buf_cpy, ':');
12985
12986 if (mac1_pos == NULL) continue;
12987
12988 mac1_pos[0] = 0;
12989 mac1_pos++;
12990
12991 if (strlen (mac1_pos) != 12) continue;
12992
12993 uint essid_length = mac1_pos - line_buf_cpy - 1;
12994
12995 // here we need the ESSID
12996 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12997
12998 hash_buf.salt->salt_len = essid_length;
12999
13000 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
13001
13002 if (found)
13003 {
13004 wpa_t *wpa = (wpa_t *) found->esalt;
13005
13006 // compare hex string(s) vs binary MAC address(es)
13007
13008 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13009 {
13010 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
13011 {
13012 found = NULL;
13013
13014 break;
13015 }
13016 }
13017
13018 // early skip ;)
13019 if (!found) continue;
13020
13021 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13022 {
13023 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
13024 {
13025 found = NULL;
13026
13027 break;
13028 }
13029 }
13030 }
13031 }
13032 }
13033 else
13034 {
13035 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
13036
13037 if (parser_status == PARSER_OK)
13038 {
13039 if (isSalted)
13040 {
13041 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
13042 }
13043 else
13044 {
13045 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
13046 }
13047 }
13048 }
13049
13050 if (found == NULL) continue;
13051
13052 if (!found->cracked) potfile_remove_cracks++;
13053
13054 found->cracked = 1;
13055
13056 if (found) break;
13057
13058 iter--;
13059 }
13060 }
13061
13062 myfree (line_buf_cpy);
13063
13064 myfree (line_buf);
13065
13066 fclose (fp);
13067 }
13068 }
13069
13070 if (esalt_size)
13071 {
13072 local_free (hash_buf.esalt);
13073 }
13074
13075 if (isSalted)
13076 {
13077 local_free (hash_buf.salt);
13078 }
13079
13080 local_free (hash_buf.digest);
13081 }
13082
13083 /**
13084 * Now generate all the buffers required for later
13085 */
13086
13087 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
13088
13089 salt_t *salts_buf_new = NULL;
13090 void *esalts_buf_new = NULL;
13091
13092 if (isSalted)
13093 {
13094 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
13095
13096 if (esalt_size)
13097 {
13098 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
13099 }
13100 }
13101 else
13102 {
13103 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13104 }
13105
13106 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13107
13108 uint digests_cnt = hashes_cnt;
13109 uint digests_done = 0;
13110
13111 size_t size_digests = digests_cnt * dgst_size;
13112 size_t size_shown = digests_cnt * sizeof (uint);
13113
13114 uint *digests_shown = (uint *) mymalloc (size_shown);
13115 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13116
13117 uint salts_cnt = 0;
13118 uint salts_done = 0;
13119
13120 hashinfo_t **hash_info = NULL;
13121
13122 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13123 {
13124 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13125
13126 if (username && (remove || show))
13127 {
13128 uint user_pos;
13129
13130 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13131 {
13132 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13133
13134 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13135 }
13136 }
13137 }
13138
13139 uint *salts_shown = (uint *) mymalloc (size_shown);
13140
13141 salt_t *salt_buf;
13142
13143 {
13144 // copied from inner loop
13145
13146 salt_buf = &salts_buf_new[salts_cnt];
13147
13148 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13149
13150 if (esalt_size)
13151 {
13152 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13153 }
13154
13155 salt_buf->digests_cnt = 0;
13156 salt_buf->digests_done = 0;
13157 salt_buf->digests_offset = 0;
13158
13159 salts_cnt++;
13160 }
13161
13162 if (hashes_buf[0].cracked == 1)
13163 {
13164 digests_shown[0] = 1;
13165
13166 digests_done++;
13167
13168 salt_buf->digests_done++;
13169 }
13170
13171 salt_buf->digests_cnt++;
13172
13173 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13174
13175 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13176 {
13177 hash_info[0] = hashes_buf[0].hash_info;
13178 }
13179
13180 // copy from inner loop
13181
13182 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13183 {
13184 if (isSalted)
13185 {
13186 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13187 {
13188 salt_buf = &salts_buf_new[salts_cnt];
13189
13190 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13191
13192 if (esalt_size)
13193 {
13194 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13195 }
13196
13197 salt_buf->digests_cnt = 0;
13198 salt_buf->digests_done = 0;
13199 salt_buf->digests_offset = hashes_pos;
13200
13201 salts_cnt++;
13202 }
13203 }
13204
13205 if (hashes_buf[hashes_pos].cracked == 1)
13206 {
13207 digests_shown[hashes_pos] = 1;
13208
13209 digests_done++;
13210
13211 salt_buf->digests_done++;
13212 }
13213
13214 salt_buf->digests_cnt++;
13215
13216 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13217
13218 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13219 {
13220 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13221 }
13222 }
13223
13224 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13225 {
13226 salt_t *salt_buf = &salts_buf_new[salt_pos];
13227
13228 if (salt_buf->digests_done == salt_buf->digests_cnt)
13229 {
13230 salts_shown[salt_pos] = 1;
13231
13232 salts_done++;
13233 }
13234
13235 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13236 }
13237
13238 local_free (digests_buf);
13239 local_free (salts_buf);
13240 local_free (esalts_buf);
13241
13242 digests_buf = digests_buf_new;
13243 salts_buf = salts_buf_new;
13244 esalts_buf = esalts_buf_new;
13245
13246 local_free (hashes_buf);
13247
13248 /**
13249 * special modification not set from parser
13250 */
13251
13252 switch (hash_mode)
13253 {
13254 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13255 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13256 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13257 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13258 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13259 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13260 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13261 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13262 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13263 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13264 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13265 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13266 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13267 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13268 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13269 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13270 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13271 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13272 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13273 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13274 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13275 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13276 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13277 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13278 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13279 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13280 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13281 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13282 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13283 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13284 }
13285
13286 if (truecrypt_keyfiles)
13287 {
13288 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13289
13290 char *keyfiles = strdup (truecrypt_keyfiles);
13291
13292 char *keyfile = strtok (keyfiles, ",");
13293
13294 do
13295 {
13296 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13297
13298 } while ((keyfile = strtok (NULL, ",")) != NULL);
13299
13300 free (keyfiles);
13301 }
13302
13303 if (veracrypt_keyfiles)
13304 {
13305 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13306
13307 char *keyfiles = strdup (veracrypt_keyfiles);
13308
13309 char *keyfile = strtok (keyfiles, ",");
13310
13311 do
13312 {
13313 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13314
13315 } while ((keyfile = strtok (NULL, ",")) != NULL);
13316
13317 free (keyfiles);
13318 }
13319
13320 data.digests_cnt = digests_cnt;
13321 data.digests_done = digests_done;
13322 data.digests_buf = digests_buf;
13323 data.digests_shown = digests_shown;
13324 data.digests_shown_tmp = digests_shown_tmp;
13325
13326 data.salts_cnt = salts_cnt;
13327 data.salts_done = salts_done;
13328 data.salts_buf = salts_buf;
13329 data.salts_shown = salts_shown;
13330
13331 data.esalts_buf = esalts_buf;
13332 data.hash_info = hash_info;
13333
13334 /**
13335 * Automatic Optimizers
13336 */
13337
13338 if (salts_cnt == 1)
13339 opti_type |= OPTI_TYPE_SINGLE_SALT;
13340
13341 if (digests_cnt == 1)
13342 opti_type |= OPTI_TYPE_SINGLE_HASH;
13343
13344 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13345 opti_type |= OPTI_TYPE_NOT_ITERATED;
13346
13347 if (attack_mode == ATTACK_MODE_BF)
13348 opti_type |= OPTI_TYPE_BRUTE_FORCE;
13349
13350 data.opti_type = opti_type;
13351
13352 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13353 {
13354 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13355 {
13356 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13357 {
13358 if (opts_type & OPTS_TYPE_ST_ADD80)
13359 {
13360 opts_type &= ~OPTS_TYPE_ST_ADD80;
13361 opts_type |= OPTS_TYPE_PT_ADD80;
13362 }
13363
13364 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13365 {
13366 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13367 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13368 }
13369
13370 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13371 {
13372 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13373 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13374 }
13375 }
13376 }
13377 }
13378
13379 /**
13380 * Some algorithm, like descrypt, can benefit from JIT compilation
13381 */
13382
13383 int force_jit_compilation = -1;
13384
13385 if (hash_mode == 8900)
13386 {
13387 force_jit_compilation = 8900;
13388 }
13389 else if (hash_mode == 9300)
13390 {
13391 force_jit_compilation = 8900;
13392 }
13393 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13394 {
13395 force_jit_compilation = 1500;
13396 }
13397
13398 /**
13399 * generate bitmap tables
13400 */
13401
13402 const uint bitmap_shift1 = 5;
13403 const uint bitmap_shift2 = 13;
13404
13405 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13406
13407 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13408 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13409 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13410 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13411 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13412 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13413 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13414 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13415
13416 uint bitmap_bits;
13417 uint bitmap_nums;
13418 uint bitmap_mask;
13419 uint bitmap_size;
13420
13421 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13422 {
13423 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13424
13425 bitmap_nums = 1 << bitmap_bits;
13426
13427 bitmap_mask = bitmap_nums - 1;
13428
13429 bitmap_size = bitmap_nums * sizeof (uint);
13430
13431 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13432
13433 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;
13434 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;
13435
13436 break;
13437 }
13438
13439 bitmap_nums = 1 << bitmap_bits;
13440
13441 bitmap_mask = bitmap_nums - 1;
13442
13443 bitmap_size = bitmap_nums * sizeof (uint);
13444
13445 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);
13446 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);
13447
13448 /**
13449 * prepare quick rule
13450 */
13451
13452 data.rule_buf_l = rule_buf_l;
13453 data.rule_buf_r = rule_buf_r;
13454
13455 int rule_len_l = (int) strlen (rule_buf_l);
13456 int rule_len_r = (int) strlen (rule_buf_r);
13457
13458 data.rule_len_l = rule_len_l;
13459 data.rule_len_r = rule_len_r;
13460
13461 /**
13462 * load rules
13463 */
13464
13465 uint *all_kernel_rules_cnt = NULL;
13466
13467 kernel_rule_t **all_kernel_rules_buf = NULL;
13468
13469 if (rp_files_cnt)
13470 {
13471 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13472
13473 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13474 }
13475
13476 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13477
13478 int rule_len = 0;
13479
13480 for (uint i = 0; i < rp_files_cnt; i++)
13481 {
13482 uint kernel_rules_avail = 0;
13483
13484 uint kernel_rules_cnt = 0;
13485
13486 kernel_rule_t *kernel_rules_buf = NULL;
13487
13488 char *rp_file = rp_files[i];
13489
13490 char in[BLOCK_SIZE] = { 0 };
13491 char out[BLOCK_SIZE] = { 0 };
13492
13493 FILE *fp = NULL;
13494
13495 uint rule_line = 0;
13496
13497 if ((fp = fopen (rp_file, "rb")) == NULL)
13498 {
13499 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13500
13501 return (-1);
13502 }
13503
13504 while (!feof (fp))
13505 {
13506 memset (rule_buf, 0, HCBUFSIZ);
13507
13508 rule_len = fgetl (fp, rule_buf);
13509
13510 rule_line++;
13511
13512 if (rule_len == 0) continue;
13513
13514 if (rule_buf[0] == '#') continue;
13515
13516 if (kernel_rules_avail == kernel_rules_cnt)
13517 {
13518 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13519
13520 kernel_rules_avail += INCR_RULES;
13521 }
13522
13523 memset (in, 0, BLOCK_SIZE);
13524 memset (out, 0, BLOCK_SIZE);
13525
13526 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13527
13528 if (result == -1)
13529 {
13530 log_info ("WARNING: Skipping invalid or unsupported rule in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13531
13532 continue;
13533 }
13534
13535 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13536 {
13537 log_info ("WARNING: Cannot convert rule for use on device in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13538
13539 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13540
13541 continue;
13542 }
13543
13544 /* its so slow
13545 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13546 {
13547 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13548
13549 continue;
13550 }
13551 */
13552
13553 kernel_rules_cnt++;
13554 }
13555
13556 fclose (fp);
13557
13558 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13559
13560 all_kernel_rules_buf[i] = kernel_rules_buf;
13561 }
13562
13563 /**
13564 * merge rules or automatic rule generator
13565 */
13566
13567 uint kernel_rules_cnt = 0;
13568
13569 kernel_rule_t *kernel_rules_buf = NULL;
13570
13571 if (attack_mode == ATTACK_MODE_STRAIGHT)
13572 {
13573 if (rp_files_cnt)
13574 {
13575 kernel_rules_cnt = 1;
13576
13577 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13578
13579 repeats[0] = kernel_rules_cnt;
13580
13581 for (uint i = 0; i < rp_files_cnt; i++)
13582 {
13583 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13584
13585 repeats[i + 1] = kernel_rules_cnt;
13586 }
13587
13588 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13589
13590 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13591
13592 for (uint i = 0; i < kernel_rules_cnt; i++)
13593 {
13594 uint out_pos = 0;
13595
13596 kernel_rule_t *out = &kernel_rules_buf[i];
13597
13598 for (uint j = 0; j < rp_files_cnt; j++)
13599 {
13600 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13601 uint in_pos;
13602
13603 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13604
13605 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13606 {
13607 if (out_pos == RULES_MAX - 1)
13608 {
13609 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13610
13611 break;
13612 }
13613
13614 out->cmds[out_pos] = in->cmds[in_pos];
13615 }
13616 }
13617 }
13618
13619 local_free (repeats);
13620 }
13621 else if (rp_gen)
13622 {
13623 uint kernel_rules_avail = 0;
13624
13625 while (kernel_rules_cnt < rp_gen)
13626 {
13627 if (kernel_rules_avail == kernel_rules_cnt)
13628 {
13629 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13630
13631 kernel_rules_avail += INCR_RULES;
13632 }
13633
13634 memset (rule_buf, 0, HCBUFSIZ);
13635
13636 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13637
13638 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13639
13640 kernel_rules_cnt++;
13641 }
13642 }
13643 }
13644
13645 myfree (rule_buf);
13646
13647 /**
13648 * generate NOP rules
13649 */
13650
13651 if (kernel_rules_cnt == 0)
13652 {
13653 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13654
13655 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13656
13657 kernel_rules_cnt++;
13658 }
13659
13660 data.kernel_rules_cnt = kernel_rules_cnt;
13661 data.kernel_rules_buf = kernel_rules_buf;
13662
13663 /**
13664 * OpenCL platforms: detect
13665 */
13666
13667 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13668 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13669
13670 cl_uint platforms_cnt = 0;
13671 cl_uint platform_devices_cnt = 0;
13672
13673 if (keyspace == 0)
13674 {
13675 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13676
13677 if (platforms_cnt == 0)
13678 {
13679 log_info ("");
13680 log_info ("ATTENTION! No OpenCL compatible platform found");
13681 log_info ("");
13682 log_info ("You're probably missing the OpenCL runtime installation");
13683 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13684 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13685 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13686 log_info ("");
13687
13688 return (-1);
13689 }
13690
13691 if (opencl_platforms_filter != (uint) -1)
13692 {
13693 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13694
13695 if (opencl_platforms_filter > platform_cnt_mask)
13696 {
13697 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13698
13699 return (-1);
13700 }
13701 }
13702 }
13703
13704 if (opencl_device_types == NULL)
13705 {
13706 /**
13707 * OpenCL device types:
13708 * 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.
13709 */
13710
13711 cl_device_type device_types_all = 0;
13712
13713 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13714 {
13715 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13716
13717 cl_platform_id platform = platforms[platform_id];
13718
13719 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13720
13721 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13722 {
13723 cl_device_id device = platform_devices[platform_devices_id];
13724
13725 cl_device_type device_type;
13726
13727 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13728
13729 device_types_all |= device_type;
13730 }
13731 }
13732
13733 // In such a case, automatically enable CPU device type support, since it's disabled by default.
13734
13735 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13736 {
13737 device_types_filter |= CL_DEVICE_TYPE_CPU;
13738 }
13739
13740 // In another case, when the user uses --stdout, using CPU devices is much faster to setup
13741 // If we have a CPU device, force it to be used
13742
13743 if (stdout_flag == 1)
13744 {
13745 if (device_types_all & CL_DEVICE_TYPE_CPU)
13746 {
13747 device_types_filter = CL_DEVICE_TYPE_CPU;
13748 }
13749 }
13750 }
13751
13752 /**
13753 * OpenCL devices: simply push all devices from all platforms into the same device array
13754 */
13755
13756 int need_adl = 0;
13757 int need_nvapi = 0;
13758 int need_nvml = 0;
13759 int need_xnvctrl = 0;
13760
13761 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13762
13763 data.devices_param = devices_param;
13764
13765 uint devices_cnt = 0;
13766
13767 uint devices_active = 0;
13768
13769 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13770 {
13771 cl_platform_id platform = platforms[platform_id];
13772
13773 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13774
13775 char platform_vendor[INFOSZ] = { 0 };
13776
13777 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13778
13779 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13780 // this causes trouble with vendor id based macros
13781 // we'll assign generic to those without special optimization available
13782
13783 cl_uint platform_vendor_id = 0;
13784
13785 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13786 {
13787 platform_vendor_id = VENDOR_ID_AMD;
13788 }
13789 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13790 {
13791 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13792 }
13793 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13794 {
13795 platform_vendor_id = VENDOR_ID_APPLE;
13796 }
13797 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13798 {
13799 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13800 }
13801 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13802 {
13803 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13804 }
13805 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13806 {
13807 platform_vendor_id = VENDOR_ID_MESA;
13808 }
13809 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13810 {
13811 platform_vendor_id = VENDOR_ID_NV;
13812 }
13813 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13814 {
13815 platform_vendor_id = VENDOR_ID_POCL;
13816 }
13817 else
13818 {
13819 platform_vendor_id = VENDOR_ID_GENERIC;
13820 }
13821
13822 const uint platform_skipped = ((opencl_platforms_filter & (1 << platform_id)) == 0);
13823
13824 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13825 {
13826 if (machine_readable == 0)
13827 {
13828 if (platform_skipped == 0)
13829 {
13830 const int len = log_info ("OpenCL Platform #%u: %s", platform_id + 1, platform_vendor);
13831
13832 char line[256] = { 0 };
13833
13834 for (int i = 0; i < len; i++) line[i] = '=';
13835
13836 log_info (line);
13837 }
13838 else
13839 {
13840 log_info ("OpenCL Platform #%u: %s, skipped", platform_id + 1, platform_vendor);
13841 log_info ("");
13842 }
13843 }
13844 }
13845
13846 if (platform_skipped == 1) continue;
13847
13848 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13849 {
13850 size_t param_value_size = 0;
13851
13852 const uint device_id = devices_cnt;
13853
13854 hc_device_param_t *device_param = &data.devices_param[device_id];
13855
13856 device_param->platform_vendor_id = platform_vendor_id;
13857
13858 device_param->device = platform_devices[platform_devices_id];
13859
13860 device_param->device_id = device_id;
13861
13862 device_param->platform_devices_id = platform_devices_id;
13863
13864 // device_type
13865
13866 cl_device_type device_type;
13867
13868 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13869
13870 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13871
13872 device_param->device_type = device_type;
13873
13874 // device_name
13875
13876 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13877
13878 char *device_name = (char *) mymalloc (param_value_size);
13879
13880 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13881
13882 device_param->device_name = device_name;
13883
13884 // device_vendor
13885
13886 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13887
13888 char *device_vendor = (char *) mymalloc (param_value_size);
13889
13890 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13891
13892 device_param->device_vendor = device_vendor;
13893
13894 cl_uint device_vendor_id = 0;
13895
13896 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13897 {
13898 device_vendor_id = VENDOR_ID_AMD;
13899 }
13900 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13901 {
13902 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13903 }
13904 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13905 {
13906 device_vendor_id = VENDOR_ID_APPLE;
13907 }
13908 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13909 {
13910 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13911 }
13912 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13913 {
13914 device_vendor_id = VENDOR_ID_INTEL_SDK;
13915 }
13916 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13917 {
13918 device_vendor_id = VENDOR_ID_MESA;
13919 }
13920 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13921 {
13922 device_vendor_id = VENDOR_ID_NV;
13923 }
13924 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13925 {
13926 device_vendor_id = VENDOR_ID_POCL;
13927 }
13928 else
13929 {
13930 device_vendor_id = VENDOR_ID_GENERIC;
13931 }
13932
13933 device_param->device_vendor_id = device_vendor_id;
13934
13935 // tuning db
13936
13937 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13938
13939 // device_version
13940
13941 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13942
13943 char *device_version = (char *) mymalloc (param_value_size);
13944
13945 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13946
13947 device_param->device_version = device_version;
13948
13949 // device_opencl_version
13950
13951 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13952
13953 char *device_opencl_version = (char *) mymalloc (param_value_size);
13954
13955 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13956
13957 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13958
13959 myfree (device_opencl_version);
13960
13961 // vector_width
13962
13963 cl_uint vector_width;
13964
13965 if (opencl_vector_width_chgd == 0)
13966 {
13967 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13968 {
13969 if (opti_type & OPTI_TYPE_USES_BITS_64)
13970 {
13971 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13972 }
13973 else
13974 {
13975 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13976 }
13977 }
13978 else
13979 {
13980 vector_width = (cl_uint) tuningdb_entry->vector_width;
13981 }
13982 }
13983 else
13984 {
13985 vector_width = opencl_vector_width;
13986 }
13987
13988 if (vector_width > 16) vector_width = 16;
13989
13990 device_param->vector_width = vector_width;
13991
13992 // max_compute_units
13993
13994 cl_uint device_processors;
13995
13996 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13997
13998 device_param->device_processors = device_processors;
13999
14000 // device_maxmem_alloc
14001 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
14002
14003 cl_ulong device_maxmem_alloc;
14004
14005 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
14006
14007 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
14008
14009 // device_global_mem
14010
14011 cl_ulong device_global_mem;
14012
14013 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
14014
14015 device_param->device_global_mem = device_global_mem;
14016
14017 // max_work_group_size
14018
14019 size_t device_maxworkgroup_size;
14020
14021 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
14022
14023 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
14024
14025 // max_clock_frequency
14026
14027 cl_uint device_maxclock_frequency;
14028
14029 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
14030
14031 device_param->device_maxclock_frequency = device_maxclock_frequency;
14032
14033 // device_endian_little
14034
14035 cl_bool device_endian_little;
14036
14037 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
14038
14039 if (device_endian_little == CL_FALSE)
14040 {
14041 log_info ("- Device #%u: WARNING: Not a little endian device", device_id + 1);
14042
14043 device_param->skipped = 1;
14044 }
14045
14046 // device_available
14047
14048 cl_bool device_available;
14049
14050 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
14051
14052 if (device_available == CL_FALSE)
14053 {
14054 log_info ("- Device #%u: WARNING: Device not available", device_id + 1);
14055
14056 device_param->skipped = 1;
14057 }
14058
14059 // device_compiler_available
14060
14061 cl_bool device_compiler_available;
14062
14063 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
14064
14065 if (device_compiler_available == CL_FALSE)
14066 {
14067 log_info ("- Device #%u: WARNING: No compiler available for device", device_id + 1);
14068
14069 device_param->skipped = 1;
14070 }
14071
14072 // device_execution_capabilities
14073
14074 cl_device_exec_capabilities device_execution_capabilities;
14075
14076 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
14077
14078 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
14079 {
14080 log_info ("- Device #%u: WARNING: Device does not support executing kernels", device_id + 1);
14081
14082 device_param->skipped = 1;
14083 }
14084
14085 // device_extensions
14086
14087 size_t device_extensions_size;
14088
14089 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
14090
14091 char *device_extensions = mymalloc (device_extensions_size + 1);
14092
14093 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
14094
14095 if (strstr (device_extensions, "base_atomics") == 0)
14096 {
14097 log_info ("- Device #%u: WARNING: Device does not support base atomics", device_id + 1);
14098
14099 device_param->skipped = 1;
14100 }
14101
14102 if (strstr (device_extensions, "byte_addressable_store") == 0)
14103 {
14104 log_info ("- Device #%u: WARNING: Device does not support byte addressable store", device_id + 1);
14105
14106 device_param->skipped = 1;
14107 }
14108
14109 myfree (device_extensions);
14110
14111 // device_local_mem_size
14112
14113 cl_ulong device_local_mem_size;
14114
14115 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
14116
14117 if (device_local_mem_size < 32768)
14118 {
14119 log_info ("- Device #%u: WARNING: Device local mem size is too small", device_id + 1);
14120
14121 device_param->skipped = 1;
14122 }
14123
14124 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
14125 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
14126 // This results in both utilizing it for 50%
14127 // However, Intel has much better SIMD control over their own hardware
14128 // It makes sense to give them full control over their own hardware
14129
14130 if (device_type & CL_DEVICE_TYPE_CPU)
14131 {
14132 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14133 {
14134 if (data.force == 0)
14135 {
14136 if (algorithm_pos == 0)
14137 {
14138 log_info ("- Device #%u: WARNING: Not a native Intel OpenCL runtime, expect massive speed loss", device_id + 1);
14139 log_info (" You can use --force to override this but do not post error reports if you do so");
14140 }
14141
14142 device_param->skipped = 1;
14143 }
14144 }
14145 }
14146
14147 // skipped
14148
14149 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14150 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14151
14152 // driver_version
14153
14154 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14155
14156 char *driver_version = (char *) mymalloc (param_value_size);
14157
14158 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14159
14160 device_param->driver_version = driver_version;
14161
14162 // device_name_chksum
14163
14164 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14165
14166 #if __x86_64__
14167 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);
14168 #else
14169 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);
14170 #endif
14171
14172 uint device_name_digest[4] = { 0 };
14173
14174 md5_64 ((uint *) device_name_chksum, device_name_digest);
14175
14176 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14177
14178 device_param->device_name_chksum = device_name_chksum;
14179
14180 // device_processor_cores
14181
14182 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14183 {
14184 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14185 {
14186 need_adl = 1;
14187 }
14188
14189 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14190 {
14191 need_nvml = 1;
14192
14193 #ifdef LINUX
14194 need_xnvctrl = 1;
14195 #endif
14196
14197 #ifdef WIN
14198 need_nvapi = 1;
14199 #endif
14200 }
14201 }
14202
14203 // device_processor_cores
14204
14205 if (device_type & CL_DEVICE_TYPE_CPU)
14206 {
14207 cl_uint device_processor_cores = 1;
14208
14209 device_param->device_processor_cores = device_processor_cores;
14210 }
14211
14212 if (device_type & CL_DEVICE_TYPE_GPU)
14213 {
14214 if (device_vendor_id == VENDOR_ID_AMD)
14215 {
14216 cl_uint device_processor_cores = 0;
14217
14218 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
14219
14220 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
14221
14222 device_param->device_processor_cores = device_processor_cores;
14223 }
14224 else if (device_vendor_id == VENDOR_ID_NV)
14225 {
14226 cl_uint kernel_exec_timeout = 0;
14227
14228 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14229
14230 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14231
14232 device_param->kernel_exec_timeout = kernel_exec_timeout;
14233
14234 cl_uint device_processor_cores = 0;
14235
14236 #define CL_DEVICE_WARP_SIZE_NV 0x4003
14237
14238 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
14239
14240 device_param->device_processor_cores = device_processor_cores;
14241
14242 cl_uint sm_minor = 0;
14243 cl_uint sm_major = 0;
14244
14245 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14246 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14247
14248 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14249 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14250
14251 device_param->sm_minor = sm_minor;
14252 device_param->sm_major = sm_major;
14253
14254 // CPU burning loop damper
14255 // Value is given as number between 0-100
14256 // By default 100%
14257
14258 device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14259
14260 if (nvidia_spin_damp_chgd == 0)
14261 {
14262 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14263 {
14264 /**
14265 * the workaround is not a friend of rule based attacks
14266 * the words from the wordlist combined with fast and slow rules cause
14267 * fluctuations which cause inaccurate wait time estimations
14268 * using a reduced damping percentage almost compensates this
14269 */
14270
14271 device_param->nvidia_spin_damp = 64;
14272 }
14273 }
14274
14275 device_param->nvidia_spin_damp /= 100;
14276 }
14277 else
14278 {
14279 cl_uint device_processor_cores = 1;
14280
14281 device_param->device_processor_cores = device_processor_cores;
14282 }
14283 }
14284
14285 // display results
14286
14287 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14288 {
14289 if (machine_readable == 0)
14290 {
14291 if (device_param->skipped == 0)
14292 {
14293 log_info ("- Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14294 device_id + 1,
14295 device_name,
14296 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14297 (unsigned int) (device_global_mem / 1024 / 1024),
14298 (unsigned int) device_processors);
14299 }
14300 else
14301 {
14302 log_info ("- Device #%u: %s, skipped",
14303 device_id + 1,
14304 device_name);
14305 }
14306 }
14307 }
14308
14309 // common driver check
14310
14311 if (device_param->skipped == 0)
14312 {
14313 if (device_type & CL_DEVICE_TYPE_GPU)
14314 {
14315 if (platform_vendor_id == VENDOR_ID_AMD)
14316 {
14317 int catalyst_check = (force == 1) ? 0 : 1;
14318
14319 int catalyst_warn = 0;
14320
14321 int catalyst_broken = 0;
14322
14323 if (catalyst_check == 1)
14324 {
14325 catalyst_warn = 1;
14326
14327 // v14.9 and higher
14328 if (atoi (device_param->driver_version) >= 1573)
14329 {
14330 catalyst_warn = 0;
14331 }
14332
14333 catalyst_check = 0;
14334 }
14335
14336 if (catalyst_broken == 1)
14337 {
14338 log_info ("");
14339 log_info ("ATTENTION! The Catalyst driver installed on your system is known to be broken!");
14340 log_info ("It passes over cracked hashes and will not report them as cracked");
14341 log_info ("You are STRONGLY encouraged not to use it");
14342 log_info ("You can use --force to override this but do not post error reports if you do so");
14343 log_info ("");
14344
14345 return (-1);
14346 }
14347
14348 if (catalyst_warn == 1)
14349 {
14350 log_info ("");
14351 log_info ("ATTENTION! Unsupported or incorrectly installed Catalyst driver detected!");
14352 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver");
14353 log_info ("See hashcat's homepage for official supported catalyst drivers");
14354 #ifdef _WIN
14355 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14356 #endif
14357 log_info ("You can use --force to override this but do not post error reports if you do so");
14358 log_info ("");
14359
14360 return (-1);
14361 }
14362 }
14363 else if (platform_vendor_id == VENDOR_ID_NV)
14364 {
14365 if (device_param->kernel_exec_timeout != 0)
14366 {
14367 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);
14368 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14369 }
14370 }
14371 }
14372
14373 /* turns out pocl still creates segfaults (because of llvm)
14374 if (device_type & CL_DEVICE_TYPE_CPU)
14375 {
14376 if (platform_vendor_id == VENDOR_ID_AMD)
14377 {
14378 if (force == 0)
14379 {
14380 log_info ("");
14381 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14382 log_info ("You are STRONGLY encouraged not to use it");
14383 log_info ("You can use --force to override this but do not post error reports if you do so");
14384 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14385 log_info ("");
14386
14387 return (-1);
14388 }
14389 }
14390 }
14391 */
14392
14393 /**
14394 * kernel accel and loops tuning db adjustment
14395 */
14396
14397 device_param->kernel_accel_min = 1;
14398 device_param->kernel_accel_max = 1024;
14399
14400 device_param->kernel_loops_min = 1;
14401 device_param->kernel_loops_max = 1024;
14402
14403 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14404
14405 if (tuningdb_entry)
14406 {
14407 u32 _kernel_accel = tuningdb_entry->kernel_accel;
14408 u32 _kernel_loops = tuningdb_entry->kernel_loops;
14409
14410 if (_kernel_accel)
14411 {
14412 device_param->kernel_accel_min = _kernel_accel;
14413 device_param->kernel_accel_max = _kernel_accel;
14414 }
14415
14416 if (_kernel_loops)
14417 {
14418 if (workload_profile == 1)
14419 {
14420 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14421 }
14422 else if (workload_profile == 2)
14423 {
14424 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14425 }
14426
14427 device_param->kernel_loops_min = _kernel_loops;
14428 device_param->kernel_loops_max = _kernel_loops;
14429 }
14430 }
14431
14432 // commandline parameters overwrite tuningdb entries
14433
14434 if (kernel_accel)
14435 {
14436 device_param->kernel_accel_min = kernel_accel;
14437 device_param->kernel_accel_max = kernel_accel;
14438 }
14439
14440 if (kernel_loops)
14441 {
14442 device_param->kernel_loops_min = kernel_loops;
14443 device_param->kernel_loops_max = kernel_loops;
14444 }
14445
14446 /**
14447 * activate device
14448 */
14449
14450 devices_active++;
14451 }
14452
14453 // next please
14454
14455 devices_cnt++;
14456 }
14457
14458 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14459 {
14460 if (machine_readable == 0)
14461 {
14462 log_info ("");
14463 }
14464 }
14465 }
14466
14467 if (keyspace == 0 && devices_active == 0)
14468 {
14469 log_error ("ERROR: No devices found/left");
14470
14471 return (-1);
14472 }
14473
14474 // 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)
14475
14476 if (devices_filter != (uint) -1)
14477 {
14478 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14479
14480 if (devices_filter > devices_cnt_mask)
14481 {
14482 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14483
14484 return (-1);
14485 }
14486 }
14487
14488 data.devices_cnt = devices_cnt;
14489
14490 data.devices_active = devices_active;
14491
14492 /**
14493 * HM devices: init
14494 */
14495
14496 #ifdef HAVE_HWMON
14497 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14498 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14499 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14500 hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX] = { { 0 } };
14501
14502 if (gpu_temp_disable == 0)
14503 {
14504 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14505 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14506 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14507 XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));
14508
14509 data.hm_adl = NULL;
14510 data.hm_nvapi = NULL;
14511 data.hm_nvml = NULL;
14512 data.hm_xnvctrl = NULL;
14513
14514 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14515 {
14516 data.hm_nvml = nvml;
14517 }
14518
14519 if (data.hm_nvml)
14520 {
14521 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14522 {
14523 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14524
14525 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14526
14527 int tmp_out = 0;
14528
14529 for (int i = 0; i < tmp_in; i++)
14530 {
14531 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14532 }
14533
14534 for (int i = 0; i < tmp_out; i++)
14535 {
14536 unsigned int speed;
14537
14538 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14539
14540 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14541
14542 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14543 }
14544 }
14545 }
14546
14547 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14548 {
14549 data.hm_nvapi = nvapi;
14550 }
14551
14552 if (data.hm_nvapi)
14553 {
14554 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14555 {
14556 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14557
14558 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14559
14560 int tmp_out = 0;
14561
14562 for (int i = 0; i < tmp_in; i++)
14563 {
14564 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14565 }
14566 }
14567 }
14568
14569 if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0))
14570 {
14571 data.hm_xnvctrl = xnvctrl;
14572 }
14573
14574 if (data.hm_xnvctrl)
14575 {
14576 if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
14577 {
14578 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14579 {
14580 hc_device_param_t *device_param = &data.devices_param[device_id];
14581
14582 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14583
14584 hm_adapters_xnvctrl[device_id].xnvctrl = device_id;
14585
14586 int speed = 0;
14587
14588 if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
14589 }
14590 }
14591 }
14592
14593 if ((need_adl == 1) && (adl_init (adl) == 0))
14594 {
14595 data.hm_adl = adl;
14596 }
14597
14598 if (data.hm_adl)
14599 {
14600 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14601 {
14602 // total number of adapters
14603
14604 int hm_adapters_num;
14605
14606 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14607
14608 // adapter info
14609
14610 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14611
14612 if (lpAdapterInfo == NULL) return (-1);
14613
14614 // get a list (of ids of) valid/usable adapters
14615
14616 int num_adl_adapters = 0;
14617
14618 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14619
14620 if (num_adl_adapters > 0)
14621 {
14622 hc_thread_mutex_lock (mux_adl);
14623
14624 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14625
14626 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14627
14628 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14629 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14630
14631 hc_thread_mutex_unlock (mux_adl);
14632 }
14633
14634 myfree (valid_adl_device_list);
14635 myfree (lpAdapterInfo);
14636 }
14637 }
14638
14639 if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14640 {
14641 gpu_temp_disable = 1;
14642 }
14643 }
14644
14645 /**
14646 * OpenCL devices: allocate buffer for device specific information
14647 */
14648
14649 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14650 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14651
14652 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14653
14654 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14655
14656 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14657
14658 /**
14659 * User-defined GPU temp handling
14660 */
14661
14662 if (gpu_temp_disable == 1)
14663 {
14664 gpu_temp_abort = 0;
14665 gpu_temp_retain = 0;
14666 }
14667
14668 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14669 {
14670 if (gpu_temp_abort < gpu_temp_retain)
14671 {
14672 log_error ("ERROR: Invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14673
14674 return (-1);
14675 }
14676 }
14677
14678 data.gpu_temp_disable = gpu_temp_disable;
14679 data.gpu_temp_abort = gpu_temp_abort;
14680 data.gpu_temp_retain = gpu_temp_retain;
14681 #endif
14682
14683 /**
14684 * enable custom signal handler(s)
14685 */
14686
14687 if (benchmark == 0)
14688 {
14689 hc_signal (sigHandler_default);
14690 }
14691 else
14692 {
14693 hc_signal (sigHandler_benchmark);
14694 }
14695
14696 /**
14697 * inform the user
14698 */
14699
14700 if (data.quiet == 0)
14701 {
14702 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14703
14704 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);
14705
14706 if (attack_mode == ATTACK_MODE_STRAIGHT)
14707 {
14708 log_info ("Rules: %u", kernel_rules_cnt);
14709 }
14710
14711 if (opti_type)
14712 {
14713 log_info ("Applicable Optimizers:");
14714
14715 for (uint i = 0; i < 32; i++)
14716 {
14717 const uint opti_bit = 1u << i;
14718
14719 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14720 }
14721 }
14722
14723 /**
14724 * Watchdog and Temperature balance
14725 */
14726
14727 #ifdef HAVE_HWMON
14728 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14729 {
14730 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14731 }
14732
14733 if (gpu_temp_abort == 0)
14734 {
14735 log_info ("Watchdog: Temperature abort trigger disabled");
14736 }
14737 else
14738 {
14739 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14740 }
14741
14742 if (gpu_temp_retain == 0)
14743 {
14744 log_info ("Watchdog: Temperature retain trigger disabled");
14745 }
14746 else
14747 {
14748 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14749 }
14750
14751 if (data.quiet == 0) log_info ("");
14752 #endif
14753 }
14754
14755 #ifdef HAVE_HWMON
14756
14757 /**
14758 * HM devices: copy
14759 */
14760
14761 if (gpu_temp_disable == 0)
14762 {
14763 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14764 {
14765 hc_device_param_t *device_param = &data.devices_param[device_id];
14766
14767 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14768
14769 if (device_param->skipped) continue;
14770
14771 const uint platform_devices_id = device_param->platform_devices_id;
14772
14773 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14774 {
14775 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14776 data.hm_device[device_id].nvapi = 0;
14777 data.hm_device[device_id].nvml = 0;
14778 data.hm_device[device_id].xnvctrl = 0;
14779 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14780 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14781 data.hm_device[device_id].fan_set_supported = 0;
14782 }
14783
14784 if (device_param->device_vendor_id == VENDOR_ID_NV)
14785 {
14786 data.hm_device[device_id].adl = 0;
14787 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14788 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14789 data.hm_device[device_id].xnvctrl = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
14790 data.hm_device[device_id].od_version = 0;
14791 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14792 data.hm_device[device_id].fan_set_supported = 0;
14793 }
14794 }
14795 }
14796
14797 /**
14798 * powertune on user request
14799 */
14800
14801 if (powertune_enable == 1)
14802 {
14803 hc_thread_mutex_lock (mux_adl);
14804
14805 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14806 {
14807 hc_device_param_t *device_param = &data.devices_param[device_id];
14808
14809 if (device_param->skipped) continue;
14810
14811 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14812 {
14813 /**
14814 * Temporary fix:
14815 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14816 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14817 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14818 * Driver / ADL bug?
14819 */
14820
14821 if (data.hm_device[device_id].od_version == 6)
14822 {
14823 int ADL_rc;
14824
14825 // check powertune capabilities first, if not available then skip device
14826
14827 int powertune_supported = 0;
14828
14829 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14830 {
14831 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14832
14833 return (-1);
14834 }
14835
14836 // first backup current value, we will restore it later
14837
14838 if (powertune_supported != 0)
14839 {
14840 // powercontrol settings
14841
14842 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14843
14844 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14845 {
14846 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14847 }
14848
14849 if (ADL_rc != ADL_OK)
14850 {
14851 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14852
14853 return (-1);
14854 }
14855
14856 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14857 {
14858 log_error ("ERROR: Failed to set new ADL PowerControl values");
14859
14860 return (-1);
14861 }
14862
14863 // clocks
14864
14865 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14866
14867 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14868
14869 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)
14870 {
14871 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14872
14873 return (-1);
14874 }
14875
14876 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14877
14878 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14879
14880 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14881 {
14882 log_error ("ERROR: Failed to get ADL device capabilities");
14883
14884 return (-1);
14885 }
14886
14887 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14888 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14889
14890 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14891 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14892
14893 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14894 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14895
14896 // warning if profile has too low max values
14897
14898 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14899 {
14900 log_info ("WARN: The custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14901 }
14902
14903 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14904 {
14905 log_info ("WARN: The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14906 }
14907
14908 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14909
14910 performance_state->iNumberOfPerformanceLevels = 2;
14911
14912 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14913 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14914 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14915 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14916
14917 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)
14918 {
14919 log_info ("ERROR: Failed to set ADL performance state");
14920
14921 return (-1);
14922 }
14923
14924 local_free (performance_state);
14925 }
14926
14927 // set powertune value only
14928
14929 if (powertune_supported != 0)
14930 {
14931 // powertune set
14932 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14933
14934 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14935 {
14936 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14937
14938 return (-1);
14939 }
14940
14941 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14942 {
14943 log_error ("ERROR: Failed to set new ADL PowerControl values");
14944
14945 return (-1);
14946 }
14947 }
14948 }
14949 }
14950
14951 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14952 {
14953 // first backup current value, we will restore it later
14954
14955 unsigned int limit;
14956
14957 int powertune_supported = 0;
14958
14959 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14960 {
14961 powertune_supported = 1;
14962 }
14963
14964 // if backup worked, activate the maximum allowed
14965
14966 if (powertune_supported != 0)
14967 {
14968 unsigned int minLimit;
14969 unsigned int maxLimit;
14970
14971 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14972 {
14973 if (maxLimit > 0)
14974 {
14975 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14976 {
14977 // now we can be sure we need to reset later
14978
14979 nvml_power_limit[device_id] = limit;
14980 }
14981 }
14982 }
14983 }
14984 }
14985 }
14986
14987 hc_thread_mutex_unlock (mux_adl);
14988 }
14989
14990 #endif // HAVE_HWMON
14991
14992 #ifdef DEBUG
14993 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14994 #endif
14995
14996 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14997
14998 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14999 {
15000 /**
15001 * host buffer
15002 */
15003
15004 hc_device_param_t *device_param = &data.devices_param[device_id];
15005
15006 if (device_param->skipped) continue;
15007
15008 /**
15009 * device properties
15010 */
15011
15012 const char *device_name_chksum = device_param->device_name_chksum;
15013 const u32 device_processors = device_param->device_processors;
15014 const u32 device_processor_cores = device_param->device_processor_cores;
15015
15016 /**
15017 * create context for each device
15018 */
15019
15020 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
15021
15022 /**
15023 * create command-queue
15024 */
15025
15026 // not supported with NV
15027 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
15028
15029 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
15030
15031 /**
15032 * kernel threads: some algorithms need a fixed kernel-threads count
15033 * because of shared memory usage or bitslice
15034 * there needs to be some upper limit, otherwise there's too much overhead
15035 */
15036
15037 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
15038
15039 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
15040 {
15041 kernel_threads = KERNEL_THREADS_MAX_CPU;
15042 }
15043
15044 if (hash_mode == 1500) kernel_threads = 64; // DES
15045 if (hash_mode == 3000) kernel_threads = 64; // DES
15046 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
15047 if (hash_mode == 7500) kernel_threads = 64; // RC4
15048 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
15049 if (hash_mode == 9700) kernel_threads = 64; // RC4
15050 if (hash_mode == 9710) kernel_threads = 64; // RC4
15051 if (hash_mode == 9800) kernel_threads = 64; // RC4
15052 if (hash_mode == 9810) kernel_threads = 64; // RC4
15053 if (hash_mode == 10400) kernel_threads = 64; // RC4
15054 if (hash_mode == 10410) kernel_threads = 64; // RC4
15055 if (hash_mode == 10500) kernel_threads = 64; // RC4
15056 if (hash_mode == 13100) kernel_threads = 64; // RC4
15057
15058 device_param->kernel_threads = kernel_threads;
15059
15060 device_param->hardware_power = device_processors * kernel_threads;
15061
15062 /**
15063 * create input buffers on device : calculate size of fixed memory buffers
15064 */
15065
15066 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
15067 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
15068
15069 device_param->size_root_css = size_root_css;
15070 device_param->size_markov_css = size_markov_css;
15071
15072 size_t size_results = sizeof (uint);
15073
15074 device_param->size_results = size_results;
15075
15076 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
15077 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
15078
15079 size_t size_plains = digests_cnt * sizeof (plain_t);
15080 size_t size_salts = salts_cnt * sizeof (salt_t);
15081 size_t size_esalts = salts_cnt * esalt_size;
15082
15083 device_param->size_plains = size_plains;
15084 device_param->size_digests = size_digests;
15085 device_param->size_shown = size_shown;
15086 device_param->size_salts = size_salts;
15087
15088 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
15089 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
15090 size_t size_tm = 32 * sizeof (bs_word_t);
15091
15092 // scryptV stuff
15093
15094 size_t size_scryptV = 1;
15095
15096 if ((hash_mode == 8900) || (hash_mode == 9300))
15097 {
15098 uint tmto_start = 0;
15099 uint tmto_stop = 10;
15100
15101 if (scrypt_tmto)
15102 {
15103 tmto_start = scrypt_tmto;
15104 }
15105 else
15106 {
15107 // in case the user did not specify the tmto manually
15108 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
15109 // but set the lower end only in case the user has a device with too less memory
15110
15111 if (hash_mode == 8900)
15112 {
15113 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15114 {
15115 tmto_start = 1;
15116 }
15117 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15118 {
15119 tmto_start = 2;
15120 }
15121 }
15122 else if (hash_mode == 9300)
15123 {
15124 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15125 {
15126 tmto_start = 2;
15127 }
15128 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15129 {
15130 tmto_start = 2;
15131 }
15132 }
15133 }
15134
15135 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
15136 {
15137 // TODO: in theory the following calculation needs to be done per salt, not global
15138 // we assume all hashes have the same scrypt settings
15139
15140 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
15141
15142 size_scryptV /= 1 << tmto;
15143
15144 size_scryptV *= device_processors * device_processor_cores;
15145
15146 if (size_scryptV > device_param->device_maxmem_alloc)
15147 {
15148 if (quiet == 0) log_info ("WARNING: Not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15149
15150 continue;
15151 }
15152
15153 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
15154 {
15155 data.salts_buf[salts_pos].scrypt_tmto = tmto;
15156 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
15157 }
15158
15159 break;
15160 }
15161
15162 if (data.salts_buf[0].scrypt_phy == 0)
15163 {
15164 log_error ("ERROR: Can't allocate enough device memory");
15165
15166 return -1;
15167 }
15168
15169 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
15170 }
15171
15172 /**
15173 * some algorithms need a fixed kernel-loops count
15174 */
15175
15176 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15177 {
15178 const u32 kernel_loops_fixed = 1024;
15179
15180 device_param->kernel_loops_min = kernel_loops_fixed;
15181 device_param->kernel_loops_max = kernel_loops_fixed;
15182 }
15183
15184 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15185 {
15186 const u32 kernel_loops_fixed = 1024;
15187
15188 device_param->kernel_loops_min = kernel_loops_fixed;
15189 device_param->kernel_loops_max = kernel_loops_fixed;
15190 }
15191
15192 if (hash_mode == 8900)
15193 {
15194 const u32 kernel_loops_fixed = 1;
15195
15196 device_param->kernel_loops_min = kernel_loops_fixed;
15197 device_param->kernel_loops_max = kernel_loops_fixed;
15198 }
15199
15200 if (hash_mode == 9300)
15201 {
15202 const u32 kernel_loops_fixed = 1;
15203
15204 device_param->kernel_loops_min = kernel_loops_fixed;
15205 device_param->kernel_loops_max = kernel_loops_fixed;
15206 }
15207
15208 if (hash_mode == 12500)
15209 {
15210 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15211
15212 device_param->kernel_loops_min = kernel_loops_fixed;
15213 device_param->kernel_loops_max = kernel_loops_fixed;
15214 }
15215
15216 /**
15217 * some algorithms have a maximum kernel-loops count
15218 */
15219
15220 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15221 {
15222 u32 innerloop_cnt = 0;
15223
15224 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15225 {
15226 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15227 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15228 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15229 }
15230 else
15231 {
15232 innerloop_cnt = data.salts_buf[0].salt_iter;
15233 }
15234
15235 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15236 (innerloop_cnt <= device_param->kernel_loops_max))
15237 {
15238 device_param->kernel_loops_max = innerloop_cnt;
15239 }
15240 }
15241
15242 u32 kernel_accel_min = device_param->kernel_accel_min;
15243 u32 kernel_accel_max = device_param->kernel_accel_max;
15244
15245 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15246
15247 size_t size_pws = 4;
15248 size_t size_tmps = 4;
15249 size_t size_hooks = 4;
15250
15251 while (kernel_accel_max >= kernel_accel_min)
15252 {
15253 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15254
15255 // size_pws
15256
15257 size_pws = kernel_power_max * sizeof (pw_t);
15258
15259 // size_tmps
15260
15261 switch (hash_mode)
15262 {
15263 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15264 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15265 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15266 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15267 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15268 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15269 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15270 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15271 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15272 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15273 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15274 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15275 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15276 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15277 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15278 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15279 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15280 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15281 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15282 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15283 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15284 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15285 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15286 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
15287 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
15288 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
15289 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
15290 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
15291 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15292 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15293 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
15294 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
15295 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15296 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
15297 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15298 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
15299 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
15300 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15301 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15302 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
15303 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
15304 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
15305 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15306 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
15307 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
15308 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
15309 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
15310 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15311 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
15312 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
15313 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
15314 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15315 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15316 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
15317 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
15318 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
15319 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
15320 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
15321 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15322 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15323 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15324 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
15325 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
15326 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15327 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15328 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15329 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15330 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15331 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15332 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15333 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15334 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15335 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15336 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15337 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15338 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15339 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15340 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15341 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15342 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15343 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15344 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15345 };
15346
15347 // size_hooks
15348
15349 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15350 {
15351 switch (hash_mode)
15352 {
15353 }
15354 }
15355
15356 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15357 // if not, decrease amplifier and try again
15358
15359 int memory_limit_hit = 0;
15360
15361 if (size_pws > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15362 if (size_tmps > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15363 if (size_hooks > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15364
15365 const u64 size_total
15366 = bitmap_size
15367 + bitmap_size
15368 + bitmap_size
15369 + bitmap_size
15370 + bitmap_size
15371 + bitmap_size
15372 + bitmap_size
15373 + bitmap_size
15374 + size_bfs
15375 + size_combs
15376 + size_digests
15377 + size_esalts
15378 + size_hooks
15379 + size_markov_css
15380 + size_plains
15381 + size_pws
15382 + size_pws // not a bug
15383 + size_results
15384 + size_root_css
15385 + size_rules
15386 + size_rules_c
15387 + size_salts
15388 + size_scryptV
15389 + size_shown
15390 + size_tm
15391 + size_tmps;
15392
15393 if (size_total > device_param->device_global_mem) memory_limit_hit = 1;
15394
15395 if (memory_limit_hit == 1)
15396 {
15397 kernel_accel_max--;
15398
15399 continue;
15400 }
15401
15402 break;
15403 }
15404
15405 if (kernel_accel_max < kernel_accel_min)
15406 {
15407 log_error ("- Device #%u: Device does not provide enough allocatable device-memory to handle this attack", device_id + 1);
15408
15409 return -1;
15410 }
15411
15412 device_param->kernel_accel_min = kernel_accel_min;
15413 device_param->kernel_accel_max = kernel_accel_max;
15414
15415 /*
15416 if (kernel_accel_max < kernel_accel)
15417 {
15418 if (quiet == 0) log_info ("- Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
15419
15420 device_param->kernel_accel = kernel_accel_max;
15421 }
15422 */
15423
15424 device_param->size_bfs = size_bfs;
15425 device_param->size_combs = size_combs;
15426 device_param->size_rules = size_rules;
15427 device_param->size_rules_c = size_rules_c;
15428 device_param->size_pws = size_pws;
15429 device_param->size_tmps = size_tmps;
15430 device_param->size_hooks = size_hooks;
15431
15432 /**
15433 * default building options
15434 */
15435
15436 char cpath[1024] = { 0 };
15437
15438 char build_opts[1024] = { 0 };
15439
15440 #if _WIN
15441
15442 snprintf (cpath, sizeof (cpath) - 1, "%s\\OpenCL\\", shared_dir);
15443
15444 char *cpath_real = mymalloc (MAX_PATH);
15445
15446 if (GetFullPathName (cpath, MAX_PATH, cpath_real, NULL) == 0)
15447 {
15448 log_error ("ERROR: %s: %s", cpath, "GetFullPathName()");
15449
15450 return -1;
15451 }
15452
15453 naive_replace (cpath_real, '\\', '/');
15454
15455 // not escaping here, windows has quotes
15456
15457 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\"", cpath_real);
15458
15459 myfree (cpath_real);
15460
15461 #else
15462
15463 snprintf (cpath, sizeof (cpath) - 1, "%s/OpenCL/", shared_dir);
15464
15465 char *cpath_real = mymalloc (PATH_MAX);
15466
15467 if (realpath (cpath, cpath_real) == NULL)
15468 {
15469 log_error ("ERROR: %s: %s", cpath, strerror (errno));
15470
15471 return -1;
15472 }
15473
15474 naive_escape (cpath_real, PATH_MAX, ' ', '\\');
15475
15476 snprintf (build_opts, sizeof (build_opts) - 1, "-I %s", cpath_real);
15477
15478 myfree (cpath_real);
15479
15480 #endif
15481
15482 // we don't have sm_* on vendors not NV but it doesn't matter
15483
15484 char build_opts_new[1024] = { 0 };
15485
15486 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -D VENDOR_ID=%u -D CUDA_ARCH=%d -D VECT_SIZE=%u -D DEVICE_TYPE=%u -D KERN_TYPE=%u -D _unroll -cl-std=CL1.1", build_opts, device_param->device_vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type);
15487
15488 strncpy (build_opts, build_opts_new, sizeof (build_opts));
15489
15490 #ifdef DEBUG
15491 log_info ("- Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15492 #endif
15493
15494 /**
15495 * main kernel
15496 */
15497
15498 {
15499 /**
15500 * kernel source filename
15501 */
15502
15503 char source_file[256] = { 0 };
15504
15505 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15506
15507 struct stat sst;
15508
15509 if (stat (source_file, &sst) == -1)
15510 {
15511 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15512
15513 return -1;
15514 }
15515
15516 /**
15517 * kernel cached filename
15518 */
15519
15520 char cached_file[256] = { 0 };
15521
15522 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15523
15524 int cached = 1;
15525
15526 struct stat cst;
15527
15528 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15529 {
15530 cached = 0;
15531 }
15532
15533 /**
15534 * kernel compile or load
15535 */
15536
15537 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15538
15539 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15540
15541 if (force_jit_compilation == -1)
15542 {
15543 if (cached == 0)
15544 {
15545 if (quiet == 0) log_info ("- Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, filename_from_filepath (cached_file));
15546
15547 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15548
15549 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15550
15551 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15552
15553 #ifdef DEBUG
15554 size_t build_log_size = 0;
15555
15556 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15557
15558 if (build_log_size > 1)
15559 {
15560 char *build_log = (char *) malloc (build_log_size + 1);
15561
15562 memset (build_log, 0, build_log_size + 1);
15563
15564 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15565
15566 puts (build_log);
15567
15568 free (build_log);
15569 }
15570 #endif
15571
15572 if (rc != 0)
15573 {
15574 device_param->skipped = true;
15575
15576 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15577
15578 continue;
15579 }
15580
15581 size_t binary_size;
15582
15583 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15584
15585 u8 *binary = (u8 *) mymalloc (binary_size);
15586
15587 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15588
15589 writeProgramBin (cached_file, binary, binary_size);
15590
15591 local_free (binary);
15592 }
15593 else
15594 {
15595 #ifdef DEBUG
15596 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15597 #endif
15598
15599 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15600
15601 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15602
15603 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15604 }
15605 }
15606 else
15607 {
15608 #ifdef DEBUG
15609 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15610 #endif
15611
15612 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15613
15614 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15615
15616 char build_opts_update[1024] = { 0 };
15617
15618 if (force_jit_compilation == 1500)
15619 {
15620 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15621 }
15622 else if (force_jit_compilation == 8900)
15623 {
15624 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);
15625 }
15626 else
15627 {
15628 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15629 }
15630
15631 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15632
15633 #ifdef DEBUG
15634 size_t build_log_size = 0;
15635
15636 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15637
15638 if (build_log_size > 1)
15639 {
15640 char *build_log = (char *) malloc (build_log_size + 1);
15641
15642 memset (build_log, 0, build_log_size + 1);
15643
15644 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15645
15646 puts (build_log);
15647
15648 free (build_log);
15649 }
15650 #endif
15651
15652 if (rc != 0)
15653 {
15654 device_param->skipped = true;
15655
15656 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15657 }
15658 }
15659
15660 local_free (kernel_lengths);
15661 local_free (kernel_sources[0]);
15662 local_free (kernel_sources);
15663 }
15664
15665 /**
15666 * word generator kernel
15667 */
15668
15669 if (attack_mode != ATTACK_MODE_STRAIGHT)
15670 {
15671 /**
15672 * kernel mp source filename
15673 */
15674
15675 char source_file[256] = { 0 };
15676
15677 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15678
15679 struct stat sst;
15680
15681 if (stat (source_file, &sst) == -1)
15682 {
15683 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15684
15685 return -1;
15686 }
15687
15688 /**
15689 * kernel mp cached filename
15690 */
15691
15692 char cached_file[256] = { 0 };
15693
15694 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15695
15696 int cached = 1;
15697
15698 struct stat cst;
15699
15700 if (stat (cached_file, &cst) == -1)
15701 {
15702 cached = 0;
15703 }
15704
15705 /**
15706 * kernel compile or load
15707 */
15708
15709 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15710
15711 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15712
15713 if (cached == 0)
15714 {
15715 if (quiet == 0) log_info ("- Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, filename_from_filepath (cached_file));
15716 if (quiet == 0) log_info ("");
15717
15718 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15719
15720 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15721
15722 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15723
15724 if (rc != 0)
15725 {
15726 device_param->skipped = true;
15727
15728 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15729
15730 continue;
15731 }
15732
15733 size_t binary_size;
15734
15735 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15736
15737 u8 *binary = (u8 *) mymalloc (binary_size);
15738
15739 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15740
15741 writeProgramBin (cached_file, binary, binary_size);
15742
15743 local_free (binary);
15744 }
15745 else
15746 {
15747 #ifdef DEBUG
15748 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15749 #endif
15750
15751 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15752
15753 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15754
15755 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15756 }
15757
15758 local_free (kernel_lengths);
15759 local_free (kernel_sources[0]);
15760 local_free (kernel_sources);
15761 }
15762
15763 /**
15764 * amplifier kernel
15765 */
15766
15767 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15768 {
15769
15770 }
15771 else
15772 {
15773 /**
15774 * kernel amp source filename
15775 */
15776
15777 char source_file[256] = { 0 };
15778
15779 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15780
15781 struct stat sst;
15782
15783 if (stat (source_file, &sst) == -1)
15784 {
15785 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15786
15787 return -1;
15788 }
15789
15790 /**
15791 * kernel amp cached filename
15792 */
15793
15794 char cached_file[256] = { 0 };
15795
15796 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15797
15798 int cached = 1;
15799
15800 struct stat cst;
15801
15802 if (stat (cached_file, &cst) == -1)
15803 {
15804 cached = 0;
15805 }
15806
15807 /**
15808 * kernel compile or load
15809 */
15810
15811 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15812
15813 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15814
15815 if (cached == 0)
15816 {
15817 if (quiet == 0) log_info ("- Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, filename_from_filepath (cached_file));
15818 if (quiet == 0) log_info ("");
15819
15820 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15821
15822 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15823
15824 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15825
15826 if (rc != 0)
15827 {
15828 device_param->skipped = true;
15829
15830 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15831
15832 continue;
15833 }
15834
15835 size_t binary_size;
15836
15837 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15838
15839 u8 *binary = (u8 *) mymalloc (binary_size);
15840
15841 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15842
15843 writeProgramBin (cached_file, binary, binary_size);
15844
15845 local_free (binary);
15846 }
15847 else
15848 {
15849 #ifdef DEBUG
15850 if (quiet == 0) log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15851 #endif
15852
15853 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15854
15855 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15856
15857 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15858 }
15859
15860 local_free (kernel_lengths);
15861 local_free (kernel_sources[0]);
15862 local_free (kernel_sources);
15863 }
15864
15865 // some algorithm collide too fast, make that impossible
15866
15867 if (benchmark == 1)
15868 {
15869 ((uint *) digests_buf)[0] = -1;
15870 ((uint *) digests_buf)[1] = -1;
15871 ((uint *) digests_buf)[2] = -1;
15872 ((uint *) digests_buf)[3] = -1;
15873 }
15874
15875 /**
15876 * global buffers
15877 */
15878
15879 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15880 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15881 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15882 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15883 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15884 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15885 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15886 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15887 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15888 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15889 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15890 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15891 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15892 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15893 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15894 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15895 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15896 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15897
15898 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);
15899 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);
15900 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);
15901 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);
15902 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);
15903 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);
15904 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);
15905 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);
15906 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15907 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15908 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15909
15910 /**
15911 * special buffers
15912 */
15913
15914 if (attack_kern == ATTACK_KERN_STRAIGHT)
15915 {
15916 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15917 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15918
15919 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15920 }
15921 else if (attack_kern == ATTACK_KERN_COMBI)
15922 {
15923 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15924 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15925 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15926 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15927 }
15928 else if (attack_kern == ATTACK_KERN_BF)
15929 {
15930 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15931 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15932 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15933 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15934 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15935 }
15936
15937 if (size_esalts)
15938 {
15939 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15940
15941 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15942 }
15943
15944 /**
15945 * main host data
15946 */
15947
15948 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15949
15950 device_param->pws_buf = pws_buf;
15951
15952 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15953
15954 device_param->combs_buf = combs_buf;
15955
15956 void *hooks_buf = mymalloc (size_hooks);
15957
15958 device_param->hooks_buf = hooks_buf;
15959
15960 /**
15961 * kernel args
15962 */
15963
15964 device_param->kernel_params_buf32[21] = bitmap_mask;
15965 device_param->kernel_params_buf32[22] = bitmap_shift1;
15966 device_param->kernel_params_buf32[23] = bitmap_shift2;
15967 device_param->kernel_params_buf32[24] = 0; // salt_pos
15968 device_param->kernel_params_buf32[25] = 0; // loop_pos
15969 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15970 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15971 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15972 device_param->kernel_params_buf32[29] = 0; // digests_offset
15973 device_param->kernel_params_buf32[30] = 0; // combs_mode
15974 device_param->kernel_params_buf32[31] = 0; // gid_max
15975
15976 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15977 ? &device_param->d_pws_buf
15978 : &device_param->d_pws_amp_buf;
15979 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15980 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15981 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15982 device_param->kernel_params[ 4] = &device_param->d_tmps;
15983 device_param->kernel_params[ 5] = &device_param->d_hooks;
15984 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15985 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15986 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15987 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15988 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15989 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15990 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15991 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15992 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15993 device_param->kernel_params[15] = &device_param->d_digests_buf;
15994 device_param->kernel_params[16] = &device_param->d_digests_shown;
15995 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15996 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15997 device_param->kernel_params[19] = &device_param->d_result;
15998 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15999 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
16000 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
16001 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
16002 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
16003 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
16004 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
16005 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
16006 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
16007 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
16008 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
16009 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
16010
16011 device_param->kernel_params_mp_buf64[3] = 0;
16012 device_param->kernel_params_mp_buf32[4] = 0;
16013 device_param->kernel_params_mp_buf32[5] = 0;
16014 device_param->kernel_params_mp_buf32[6] = 0;
16015 device_param->kernel_params_mp_buf32[7] = 0;
16016 device_param->kernel_params_mp_buf32[8] = 0;
16017
16018 device_param->kernel_params_mp[0] = NULL;
16019 device_param->kernel_params_mp[1] = NULL;
16020 device_param->kernel_params_mp[2] = NULL;
16021 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
16022 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
16023 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
16024 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
16025 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
16026 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
16027
16028 device_param->kernel_params_mp_l_buf64[3] = 0;
16029 device_param->kernel_params_mp_l_buf32[4] = 0;
16030 device_param->kernel_params_mp_l_buf32[5] = 0;
16031 device_param->kernel_params_mp_l_buf32[6] = 0;
16032 device_param->kernel_params_mp_l_buf32[7] = 0;
16033 device_param->kernel_params_mp_l_buf32[8] = 0;
16034 device_param->kernel_params_mp_l_buf32[9] = 0;
16035
16036 device_param->kernel_params_mp_l[0] = NULL;
16037 device_param->kernel_params_mp_l[1] = NULL;
16038 device_param->kernel_params_mp_l[2] = NULL;
16039 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
16040 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
16041 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
16042 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
16043 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
16044 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
16045 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
16046
16047 device_param->kernel_params_mp_r_buf64[3] = 0;
16048 device_param->kernel_params_mp_r_buf32[4] = 0;
16049 device_param->kernel_params_mp_r_buf32[5] = 0;
16050 device_param->kernel_params_mp_r_buf32[6] = 0;
16051 device_param->kernel_params_mp_r_buf32[7] = 0;
16052 device_param->kernel_params_mp_r_buf32[8] = 0;
16053
16054 device_param->kernel_params_mp_r[0] = NULL;
16055 device_param->kernel_params_mp_r[1] = NULL;
16056 device_param->kernel_params_mp_r[2] = NULL;
16057 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
16058 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
16059 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
16060 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
16061 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
16062 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
16063
16064 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
16065 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
16066
16067 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
16068 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
16069 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
16070 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
16071 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
16072 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
16073 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
16074
16075 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
16076 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
16077
16078 device_param->kernel_params_memset_buf32[1] = 0; // value
16079 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
16080
16081 device_param->kernel_params_memset[0] = NULL;
16082 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
16083 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
16084
16085 /**
16086 * kernel name
16087 */
16088
16089 size_t kernel_wgs_tmp;
16090
16091 char kernel_name[64] = { 0 };
16092
16093 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16094 {
16095 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16096 {
16097 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
16098
16099 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16100
16101 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
16102
16103 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16104
16105 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
16106
16107 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16108 }
16109 else
16110 {
16111 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
16112
16113 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16114
16115 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
16116
16117 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16118
16119 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
16120
16121 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16122 }
16123
16124 if (data.attack_mode == ATTACK_MODE_BF)
16125 {
16126 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16127 {
16128 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
16129
16130 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16131
16132 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);
16133 }
16134 }
16135 }
16136 else
16137 {
16138 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
16139
16140 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16141
16142 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
16143
16144 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16145
16146 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
16147
16148 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16149
16150 if (opts_type & OPTS_TYPE_HOOK12)
16151 {
16152 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
16153
16154 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16155
16156 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);
16157 }
16158
16159 if (opts_type & OPTS_TYPE_HOOK23)
16160 {
16161 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
16162
16163 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16164
16165 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);
16166 }
16167 }
16168
16169 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);
16170 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);
16171 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);
16172
16173 for (uint i = 0; i <= 20; i++)
16174 {
16175 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
16176 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
16177 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
16178
16179 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
16180 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
16181 }
16182
16183 for (uint i = 21; i <= 31; i++)
16184 {
16185 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
16186 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
16187 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
16188
16189 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
16190 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
16191 }
16192
16193 // GPU memset
16194
16195 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
16196
16197 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);
16198
16199 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
16200 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
16201 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
16202
16203 // MP start
16204
16205 if (attack_mode == ATTACK_MODE_BF)
16206 {
16207 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
16208 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
16209
16210 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);
16211 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);
16212
16213 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16214 {
16215 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
16216 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
16217 }
16218 }
16219 else if (attack_mode == ATTACK_MODE_HYBRID1)
16220 {
16221 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16222
16223 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);
16224 }
16225 else if (attack_mode == ATTACK_MODE_HYBRID2)
16226 {
16227 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16228
16229 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);
16230 }
16231
16232 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16233 {
16234 // nothing to do
16235 }
16236 else
16237 {
16238 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
16239
16240 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);
16241 }
16242
16243 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16244 {
16245 // nothing to do
16246 }
16247 else
16248 {
16249 for (uint i = 0; i < 5; i++)
16250 {
16251 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
16252 }
16253
16254 for (uint i = 5; i < 7; i++)
16255 {
16256 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
16257 }
16258 }
16259
16260 // maybe this has been updated by clGetKernelWorkGroupInfo()
16261 // value can only be decreased, so we don't need to reallocate buffers
16262
16263 device_param->kernel_threads = kernel_threads;
16264
16265 // zero some data buffers
16266
16267 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
16268 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
16269 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
16270 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
16271 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
16272 run_kernel_bzero (device_param, device_param->d_result, size_results);
16273
16274 /**
16275 * special buffers
16276 */
16277
16278 if (attack_kern == ATTACK_KERN_STRAIGHT)
16279 {
16280 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
16281 }
16282 else if (attack_kern == ATTACK_KERN_COMBI)
16283 {
16284 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
16285 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
16286 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16287 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16288 }
16289 else if (attack_kern == ATTACK_KERN_BF)
16290 {
16291 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
16292 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
16293 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
16294 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16295 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16296 }
16297
16298 #if defined(HAVE_HWMON)
16299
16300 /**
16301 * Store initial fanspeed if gpu_temp_retain is enabled
16302 */
16303
16304 if (gpu_temp_disable == 0)
16305 {
16306 if (gpu_temp_retain != 0)
16307 {
16308 hc_thread_mutex_lock (mux_adl);
16309
16310 if (data.hm_device[device_id].fan_get_supported == 1)
16311 {
16312 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
16313 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
16314
16315 temp_retain_fanspeed_value[device_id] = fanspeed;
16316 temp_retain_fanpolicy_value[device_id] = fanpolicy;
16317
16318 // we also set it to tell the OS we take control over the fan and it's automatic controller
16319 // if it was set to automatic. we do not control user-defined fanspeeds.
16320
16321 if (fanpolicy == 1)
16322 {
16323 data.hm_device[device_id].fan_set_supported = 1;
16324
16325 int rc = -1;
16326
16327 if (device_param->device_vendor_id == VENDOR_ID_AMD)
16328 {
16329 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
16330 }
16331 else if (device_param->device_vendor_id == VENDOR_ID_NV)
16332 {
16333 #ifdef LINUX
16334 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE);
16335 #endif
16336
16337 #ifdef WIN
16338 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
16339 #endif
16340 }
16341
16342 if (rc == 0)
16343 {
16344 data.hm_device[device_id].fan_set_supported = 1;
16345 }
16346 else
16347 {
16348 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
16349
16350 data.hm_device[device_id].fan_set_supported = 0;
16351 }
16352 }
16353 else
16354 {
16355 data.hm_device[device_id].fan_set_supported = 0;
16356 }
16357 }
16358
16359 hc_thread_mutex_unlock (mux_adl);
16360 }
16361 }
16362
16363 #endif // HAVE_HWMON
16364 }
16365
16366 if (data.quiet == 0) log_info_nn ("");
16367
16368 /**
16369 * In benchmark-mode, inform user which algorithm is checked
16370 */
16371
16372 if (benchmark == 1)
16373 {
16374 if (machine_readable == 0)
16375 {
16376 quiet = 0;
16377
16378 data.quiet = quiet;
16379
16380 char *hash_type = strhashtype (data.hash_mode); // not a bug
16381
16382 log_info ("Hashtype: %s", hash_type);
16383 log_info ("");
16384 }
16385 }
16386
16387 /**
16388 * keep track of the progress
16389 */
16390
16391 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16392 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16393 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16394
16395 /**
16396 * open filehandles
16397 */
16398
16399 #if _WIN
16400 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
16401 {
16402 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
16403
16404 return (-1);
16405 }
16406
16407 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
16408 {
16409 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
16410
16411 return (-1);
16412 }
16413
16414 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
16415 {
16416 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
16417
16418 return (-1);
16419 }
16420 #endif
16421
16422 /**
16423 * dictionary pad
16424 */
16425
16426 segment_size *= (1024 * 1024);
16427
16428 data.segment_size = segment_size;
16429
16430 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
16431
16432 wl_data->buf = (char *) mymalloc (segment_size);
16433 wl_data->avail = segment_size;
16434 wl_data->incr = segment_size;
16435 wl_data->cnt = 0;
16436 wl_data->pos = 0;
16437
16438 cs_t *css_buf = NULL;
16439 uint css_cnt = 0;
16440 uint dictcnt = 0;
16441 uint maskcnt = 1;
16442 char **masks = NULL;
16443 char **dictfiles = NULL;
16444
16445 uint mask_from_file = 0;
16446
16447 if (attack_mode == ATTACK_MODE_STRAIGHT)
16448 {
16449 if (wordlist_mode == WL_MODE_FILE)
16450 {
16451 int wls_left = myargc - (optind + 1);
16452
16453 for (int i = 0; i < wls_left; i++)
16454 {
16455 char *l0_filename = myargv[optind + 1 + i];
16456
16457 struct stat l0_stat;
16458
16459 if (stat (l0_filename, &l0_stat) == -1)
16460 {
16461 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
16462
16463 return (-1);
16464 }
16465
16466 uint is_dir = S_ISDIR (l0_stat.st_mode);
16467
16468 if (is_dir == 0)
16469 {
16470 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16471
16472 dictcnt++;
16473
16474 dictfiles[dictcnt - 1] = l0_filename;
16475 }
16476 else
16477 {
16478 // do not allow --keyspace w/ a directory
16479
16480 if (keyspace == 1)
16481 {
16482 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16483
16484 return (-1);
16485 }
16486
16487 char **dictionary_files = NULL;
16488
16489 dictionary_files = scan_directory (l0_filename);
16490
16491 if (dictionary_files != NULL)
16492 {
16493 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16494
16495 for (int d = 0; dictionary_files[d] != NULL; d++)
16496 {
16497 char *l1_filename = dictionary_files[d];
16498
16499 struct stat l1_stat;
16500
16501 if (stat (l1_filename, &l1_stat) == -1)
16502 {
16503 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16504
16505 return (-1);
16506 }
16507
16508 if (S_ISREG (l1_stat.st_mode))
16509 {
16510 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16511
16512 dictcnt++;
16513
16514 dictfiles[dictcnt - 1] = strdup (l1_filename);
16515 }
16516 }
16517 }
16518
16519 local_free (dictionary_files);
16520 }
16521 }
16522
16523 if (dictcnt < 1)
16524 {
16525 log_error ("ERROR: No usable dictionary file found.");
16526
16527 return (-1);
16528 }
16529 }
16530 else if (wordlist_mode == WL_MODE_STDIN)
16531 {
16532 dictcnt = 1;
16533 }
16534 }
16535 else if (attack_mode == ATTACK_MODE_COMBI)
16536 {
16537 // display
16538
16539 char *dictfile1 = myargv[optind + 1 + 0];
16540 char *dictfile2 = myargv[optind + 1 + 1];
16541
16542 // find the bigger dictionary and use as base
16543
16544 FILE *fp1 = NULL;
16545 FILE *fp2 = NULL;
16546
16547 struct stat tmp_stat;
16548
16549 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16550 {
16551 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16552
16553 return (-1);
16554 }
16555
16556 if (stat (dictfile1, &tmp_stat) == -1)
16557 {
16558 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16559
16560 fclose (fp1);
16561
16562 return (-1);
16563 }
16564
16565 if (S_ISDIR (tmp_stat.st_mode))
16566 {
16567 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16568
16569 fclose (fp1);
16570
16571 return (-1);
16572 }
16573
16574 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16575 {
16576 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16577
16578 fclose (fp1);
16579
16580 return (-1);
16581 }
16582
16583 if (stat (dictfile2, &tmp_stat) == -1)
16584 {
16585 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16586
16587 fclose (fp1);
16588 fclose (fp2);
16589
16590 return (-1);
16591 }
16592
16593 if (S_ISDIR (tmp_stat.st_mode))
16594 {
16595 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16596
16597 fclose (fp1);
16598 fclose (fp2);
16599
16600 return (-1);
16601 }
16602
16603 data.combs_cnt = 1;
16604
16605 data.quiet = 1;
16606
16607 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16608
16609 data.quiet = quiet;
16610
16611 if (words1_cnt == 0)
16612 {
16613 log_error ("ERROR: %s: empty file", dictfile1);
16614
16615 fclose (fp1);
16616 fclose (fp2);
16617
16618 return (-1);
16619 }
16620
16621 data.combs_cnt = 1;
16622
16623 data.quiet = 1;
16624
16625 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16626
16627 data.quiet = quiet;
16628
16629 if (words2_cnt == 0)
16630 {
16631 log_error ("ERROR: %s: empty file", dictfile2);
16632
16633 fclose (fp1);
16634 fclose (fp2);
16635
16636 return (-1);
16637 }
16638
16639 fclose (fp1);
16640 fclose (fp2);
16641
16642 data.dictfile = dictfile1;
16643 data.dictfile2 = dictfile2;
16644
16645 if (words1_cnt >= words2_cnt)
16646 {
16647 data.combs_cnt = words2_cnt;
16648 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16649
16650 dictfiles = &data.dictfile;
16651
16652 dictcnt = 1;
16653 }
16654 else
16655 {
16656 data.combs_cnt = words1_cnt;
16657 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16658
16659 dictfiles = &data.dictfile2;
16660
16661 dictcnt = 1;
16662
16663 // we also have to switch wordlist related rules!
16664
16665 char *tmpc = data.rule_buf_l;
16666
16667 data.rule_buf_l = data.rule_buf_r;
16668 data.rule_buf_r = tmpc;
16669
16670 int tmpi = data.rule_len_l;
16671
16672 data.rule_len_l = data.rule_len_r;
16673 data.rule_len_r = tmpi;
16674 }
16675 }
16676 else if (attack_mode == ATTACK_MODE_BF)
16677 {
16678 char *mask = NULL;
16679
16680 maskcnt = 0;
16681
16682 if (benchmark == 0)
16683 {
16684 mask = myargv[optind + 1];
16685
16686 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16687
16688 if ((optind + 2) <= myargc)
16689 {
16690 struct stat file_stat;
16691
16692 if (stat (mask, &file_stat) == -1)
16693 {
16694 maskcnt = 1;
16695
16696 masks[maskcnt - 1] = mystrdup (mask);
16697 }
16698 else
16699 {
16700 int wls_left = myargc - (optind + 1);
16701
16702 uint masks_avail = INCR_MASKS;
16703
16704 for (int i = 0; i < wls_left; i++)
16705 {
16706 if (i != 0)
16707 {
16708 mask = myargv[optind + 1 + i];
16709
16710 if (stat (mask, &file_stat) == -1)
16711 {
16712 log_error ("ERROR: %s: %s", mask, strerror (errno));
16713
16714 return (-1);
16715 }
16716 }
16717
16718 uint is_file = S_ISREG (file_stat.st_mode);
16719
16720 if (is_file == 1)
16721 {
16722 FILE *mask_fp;
16723
16724 if ((mask_fp = fopen (mask, "r")) == NULL)
16725 {
16726 log_error ("ERROR: %s: %s", mask, strerror (errno));
16727
16728 return (-1);
16729 }
16730
16731 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16732
16733 while (!feof (mask_fp))
16734 {
16735 memset (line_buf, 0, HCBUFSIZ);
16736
16737 int line_len = fgetl (mask_fp, line_buf);
16738
16739 if (line_len == 0) continue;
16740
16741 if (line_buf[0] == '#') continue;
16742
16743 if (masks_avail == maskcnt)
16744 {
16745 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16746
16747 masks_avail += INCR_MASKS;
16748 }
16749
16750 masks[maskcnt] = mystrdup (line_buf);
16751
16752 maskcnt++;
16753 }
16754
16755 myfree (line_buf);
16756
16757 fclose (mask_fp);
16758 }
16759 else
16760 {
16761 log_error ("ERROR: %s: unsupported file-type", mask);
16762
16763 return (-1);
16764 }
16765 }
16766
16767 mask_from_file = 1;
16768 }
16769 }
16770 else
16771 {
16772 custom_charset_1 = (char *) "?l?d?u";
16773 custom_charset_2 = (char *) "?l?d";
16774 custom_charset_3 = (char *) "?l?d*!$@_";
16775
16776 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16777 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16778 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16779
16780 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16781
16782 wordlist_mode = WL_MODE_MASK;
16783
16784 data.wordlist_mode = wordlist_mode;
16785
16786 increment = 1;
16787
16788 maskcnt = 1;
16789 }
16790 }
16791 else
16792 {
16793 /**
16794 * generate full masks and charsets
16795 */
16796
16797 masks = (char **) mymalloc (sizeof (char *));
16798
16799 switch (hash_mode)
16800 {
16801 case 1731: pw_min = 5;
16802 pw_max = 5;
16803 mask = mystrdup ("?b?b?b?b?b");
16804 break;
16805 case 12500: pw_min = 5;
16806 pw_max = 5;
16807 mask = mystrdup ("?b?b?b?b?b");
16808 break;
16809 default: pw_min = 7;
16810 pw_max = 7;
16811 mask = mystrdup ("?b?b?b?b?b?b?b");
16812 break;
16813 }
16814
16815 maskcnt = 1;
16816
16817 masks[maskcnt - 1] = mystrdup (mask);
16818
16819 wordlist_mode = WL_MODE_MASK;
16820
16821 data.wordlist_mode = wordlist_mode;
16822
16823 increment = 1;
16824 }
16825
16826 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16827
16828 if (increment)
16829 {
16830 if (increment_min > pw_min) pw_min = increment_min;
16831
16832 if (increment_max < pw_max) pw_max = increment_max;
16833 }
16834 }
16835 else if (attack_mode == ATTACK_MODE_HYBRID1)
16836 {
16837 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16838
16839 // display
16840
16841 char *mask = myargv[myargc - 1];
16842
16843 maskcnt = 0;
16844
16845 masks = (char **) mymalloc (1 * sizeof (char *));
16846
16847 // mod
16848
16849 struct stat file_stat;
16850
16851 if (stat (mask, &file_stat) == -1)
16852 {
16853 maskcnt = 1;
16854
16855 masks[maskcnt - 1] = mystrdup (mask);
16856 }
16857 else
16858 {
16859 uint is_file = S_ISREG (file_stat.st_mode);
16860
16861 if (is_file == 1)
16862 {
16863 FILE *mask_fp;
16864
16865 if ((mask_fp = fopen (mask, "r")) == NULL)
16866 {
16867 log_error ("ERROR: %s: %s", mask, strerror (errno));
16868
16869 return (-1);
16870 }
16871
16872 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16873
16874 uint masks_avail = 1;
16875
16876 while (!feof (mask_fp))
16877 {
16878 memset (line_buf, 0, HCBUFSIZ);
16879
16880 int line_len = fgetl (mask_fp, line_buf);
16881
16882 if (line_len == 0) continue;
16883
16884 if (line_buf[0] == '#') continue;
16885
16886 if (masks_avail == maskcnt)
16887 {
16888 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16889
16890 masks_avail += INCR_MASKS;
16891 }
16892
16893 masks[maskcnt] = mystrdup (line_buf);
16894
16895 maskcnt++;
16896 }
16897
16898 myfree (line_buf);
16899
16900 fclose (mask_fp);
16901
16902 mask_from_file = 1;
16903 }
16904 else
16905 {
16906 maskcnt = 1;
16907
16908 masks[maskcnt - 1] = mystrdup (mask);
16909 }
16910 }
16911
16912 // base
16913
16914 int wls_left = myargc - (optind + 2);
16915
16916 for (int i = 0; i < wls_left; i++)
16917 {
16918 char *filename = myargv[optind + 1 + i];
16919
16920 struct stat file_stat;
16921
16922 if (stat (filename, &file_stat) == -1)
16923 {
16924 log_error ("ERROR: %s: %s", filename, strerror (errno));
16925
16926 return (-1);
16927 }
16928
16929 uint is_dir = S_ISDIR (file_stat.st_mode);
16930
16931 if (is_dir == 0)
16932 {
16933 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16934
16935 dictcnt++;
16936
16937 dictfiles[dictcnt - 1] = filename;
16938 }
16939 else
16940 {
16941 // do not allow --keyspace w/ a directory
16942
16943 if (keyspace == 1)
16944 {
16945 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16946
16947 return (-1);
16948 }
16949
16950 char **dictionary_files = NULL;
16951
16952 dictionary_files = scan_directory (filename);
16953
16954 if (dictionary_files != NULL)
16955 {
16956 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16957
16958 for (int d = 0; dictionary_files[d] != NULL; d++)
16959 {
16960 char *l1_filename = dictionary_files[d];
16961
16962 struct stat l1_stat;
16963
16964 if (stat (l1_filename, &l1_stat) == -1)
16965 {
16966 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16967
16968 return (-1);
16969 }
16970
16971 if (S_ISREG (l1_stat.st_mode))
16972 {
16973 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16974
16975 dictcnt++;
16976
16977 dictfiles[dictcnt - 1] = strdup (l1_filename);
16978 }
16979 }
16980 }
16981
16982 local_free (dictionary_files);
16983 }
16984 }
16985
16986 if (dictcnt < 1)
16987 {
16988 log_error ("ERROR: No usable dictionary file found.");
16989
16990 return (-1);
16991 }
16992
16993 if (increment)
16994 {
16995 maskcnt = 0;
16996
16997 uint mask_min = increment_min; // we can't reject smaller masks here
16998 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16999
17000 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17001 {
17002 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17003
17004 if (cur_mask == NULL) break;
17005
17006 masks[maskcnt] = cur_mask;
17007
17008 maskcnt++;
17009
17010 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17011 }
17012 }
17013 }
17014 else if (attack_mode == ATTACK_MODE_HYBRID2)
17015 {
17016 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
17017
17018 // display
17019
17020 char *mask = myargv[optind + 1 + 0];
17021
17022 maskcnt = 0;
17023
17024 masks = (char **) mymalloc (1 * sizeof (char *));
17025
17026 // mod
17027
17028 struct stat file_stat;
17029
17030 if (stat (mask, &file_stat) == -1)
17031 {
17032 maskcnt = 1;
17033
17034 masks[maskcnt - 1] = mystrdup (mask);
17035 }
17036 else
17037 {
17038 uint is_file = S_ISREG (file_stat.st_mode);
17039
17040 if (is_file == 1)
17041 {
17042 FILE *mask_fp;
17043
17044 if ((mask_fp = fopen (mask, "r")) == NULL)
17045 {
17046 log_error ("ERROR: %s: %s", mask, strerror (errno));
17047
17048 return (-1);
17049 }
17050
17051 char *line_buf = (char *) mymalloc (HCBUFSIZ);
17052
17053 uint masks_avail = 1;
17054
17055 while (!feof (mask_fp))
17056 {
17057 memset (line_buf, 0, HCBUFSIZ);
17058
17059 int line_len = fgetl (mask_fp, line_buf);
17060
17061 if (line_len == 0) continue;
17062
17063 if (line_buf[0] == '#') continue;
17064
17065 if (masks_avail == maskcnt)
17066 {
17067 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
17068
17069 masks_avail += INCR_MASKS;
17070 }
17071
17072 masks[maskcnt] = mystrdup (line_buf);
17073
17074 maskcnt++;
17075 }
17076
17077 myfree (line_buf);
17078
17079 fclose (mask_fp);
17080
17081 mask_from_file = 1;
17082 }
17083 else
17084 {
17085 maskcnt = 1;
17086
17087 masks[maskcnt - 1] = mystrdup (mask);
17088 }
17089 }
17090
17091 // base
17092
17093 int wls_left = myargc - (optind + 2);
17094
17095 for (int i = 0; i < wls_left; i++)
17096 {
17097 char *filename = myargv[optind + 2 + i];
17098
17099 struct stat file_stat;
17100
17101 if (stat (filename, &file_stat) == -1)
17102 {
17103 log_error ("ERROR: %s: %s", filename, strerror (errno));
17104
17105 return (-1);
17106 }
17107
17108 uint is_dir = S_ISDIR (file_stat.st_mode);
17109
17110 if (is_dir == 0)
17111 {
17112 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17113
17114 dictcnt++;
17115
17116 dictfiles[dictcnt - 1] = filename;
17117 }
17118 else
17119 {
17120 // do not allow --keyspace w/ a directory
17121
17122 if (keyspace == 1)
17123 {
17124 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17125
17126 return (-1);
17127 }
17128
17129 char **dictionary_files = NULL;
17130
17131 dictionary_files = scan_directory (filename);
17132
17133 if (dictionary_files != NULL)
17134 {
17135 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17136
17137 for (int d = 0; dictionary_files[d] != NULL; d++)
17138 {
17139 char *l1_filename = dictionary_files[d];
17140
17141 struct stat l1_stat;
17142
17143 if (stat (l1_filename, &l1_stat) == -1)
17144 {
17145 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17146
17147 return (-1);
17148 }
17149
17150 if (S_ISREG (l1_stat.st_mode))
17151 {
17152 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17153
17154 dictcnt++;
17155
17156 dictfiles[dictcnt - 1] = strdup (l1_filename);
17157 }
17158 }
17159 }
17160
17161 local_free (dictionary_files);
17162 }
17163 }
17164
17165 if (dictcnt < 1)
17166 {
17167 log_error ("ERROR: No usable dictionary file found.");
17168
17169 return (-1);
17170 }
17171
17172 if (increment)
17173 {
17174 maskcnt = 0;
17175
17176 uint mask_min = increment_min; // we can't reject smaller masks here
17177 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17178
17179 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17180 {
17181 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17182
17183 if (cur_mask == NULL) break;
17184
17185 masks[maskcnt] = cur_mask;
17186
17187 maskcnt++;
17188
17189 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17190 }
17191 }
17192 }
17193
17194 data.pw_min = pw_min;
17195 data.pw_max = pw_max;
17196
17197 /**
17198 * weak hash check
17199 */
17200
17201 if (weak_hash_threshold >= salts_cnt)
17202 {
17203 hc_device_param_t *device_param = NULL;
17204
17205 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17206 {
17207 device_param = &data.devices_param[device_id];
17208
17209 if (device_param->skipped) continue;
17210
17211 break;
17212 }
17213
17214 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
17215
17216 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
17217 {
17218 weak_hash_check (device_param, salt_pos);
17219 }
17220
17221 // Display hack, guarantee that there is at least one \r before real start
17222
17223 //if (data.quiet == 0) log_info ("");
17224 }
17225
17226 /**
17227 * status and monitor threads
17228 */
17229
17230 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17231 {
17232 data.devices_status = STATUS_STARTING;
17233 }
17234
17235 uint ni_threads_cnt = 0;
17236
17237 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17238
17239 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
17240 {
17241 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
17242
17243 ni_threads_cnt++;
17244 }
17245
17246 /**
17247 * Outfile remove
17248 */
17249
17250 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
17251 {
17252 if (outfile_check_timer != 0)
17253 {
17254 if (data.outfile_check_directory != NULL)
17255 {
17256 if ((hash_mode != 5200) &&
17257 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
17258 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
17259 (hash_mode != 9000))
17260 {
17261 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
17262
17263 ni_threads_cnt++;
17264 }
17265 else
17266 {
17267 outfile_check_timer = 0;
17268 }
17269 }
17270 else
17271 {
17272 outfile_check_timer = 0;
17273 }
17274 }
17275 }
17276
17277 /**
17278 * Inform the user if we got some hashes remove because of the pot file remove feature
17279 */
17280
17281 if (data.quiet == 0)
17282 {
17283 if (potfile_remove_cracks > 0)
17284 {
17285 if (potfile_remove_cracks == 1) log_info ("INFO: Removed 1 hash found in pot file\n");
17286 else log_info ("INFO: Removed %u hashes found in pot file\n", potfile_remove_cracks);
17287 }
17288 }
17289
17290 data.outfile_check_timer = outfile_check_timer;
17291
17292 /**
17293 * main loop
17294 */
17295
17296 char **induction_dictionaries = NULL;
17297
17298 int induction_dictionaries_cnt = 0;
17299
17300 hcstat_table_t *root_table_buf = NULL;
17301 hcstat_table_t *markov_table_buf = NULL;
17302
17303 uint initial_restore_done = 0;
17304
17305 data.maskcnt = maskcnt;
17306
17307 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
17308 {
17309 if (data.devices_status == STATUS_CRACKED) continue;
17310 if (data.devices_status == STATUS_ABORTED) continue;
17311 if (data.devices_status == STATUS_QUIT) continue;
17312
17313 if (maskpos > rd->maskpos)
17314 {
17315 rd->dictpos = 0;
17316 }
17317
17318 rd->maskpos = maskpos;
17319 data.maskpos = maskpos;
17320
17321 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
17322 {
17323 char *mask = masks[maskpos];
17324
17325 if (mask_from_file == 1)
17326 {
17327 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
17328
17329 char *str_ptr;
17330 uint str_pos;
17331
17332 uint mask_offset = 0;
17333
17334 uint separator_cnt;
17335
17336 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
17337 {
17338 str_ptr = strstr (mask + mask_offset, ",");
17339
17340 if (str_ptr == NULL) break;
17341
17342 str_pos = str_ptr - mask;
17343
17344 // escaped separator, i.e. "\,"
17345
17346 if (str_pos > 0)
17347 {
17348 if (mask[str_pos - 1] == '\\')
17349 {
17350 separator_cnt --;
17351
17352 mask_offset = str_pos + 1;
17353
17354 continue;
17355 }
17356 }
17357
17358 // reset the offset
17359
17360 mask_offset = 0;
17361
17362 mask[str_pos] = '\0';
17363
17364 switch (separator_cnt)
17365 {
17366 case 0:
17367 mp_reset_usr (mp_usr, 0);
17368
17369 custom_charset_1 = mask;
17370 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17371 break;
17372
17373 case 1:
17374 mp_reset_usr (mp_usr, 1);
17375
17376 custom_charset_2 = mask;
17377 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17378 break;
17379
17380 case 2:
17381 mp_reset_usr (mp_usr, 2);
17382
17383 custom_charset_3 = mask;
17384 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17385 break;
17386
17387 case 3:
17388 mp_reset_usr (mp_usr, 3);
17389
17390 custom_charset_4 = mask;
17391 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
17392 break;
17393 }
17394
17395 mask = mask + str_pos + 1;
17396 }
17397 }
17398
17399 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17400 {
17401 if (maskpos > 0)
17402 {
17403 local_free (css_buf);
17404 local_free (data.root_css_buf);
17405 local_free (data.markov_css_buf);
17406
17407 local_free (masks[maskpos - 1]);
17408 }
17409
17410 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17411
17412 data.mask = mask;
17413 data.css_cnt = css_cnt;
17414 data.css_buf = css_buf;
17415
17416 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17417
17418 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17419
17420 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17421 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17422
17423 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17424
17425 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17426
17427 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17428 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17429
17430 data.root_css_buf = root_css_buf;
17431 data.markov_css_buf = markov_css_buf;
17432
17433 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17434
17435 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17436
17437 local_free (root_table_buf);
17438 local_free (markov_table_buf);
17439
17440 // args
17441
17442 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17443 {
17444 hc_device_param_t *device_param = &data.devices_param[device_id];
17445
17446 if (device_param->skipped) continue;
17447
17448 device_param->kernel_params_mp[0] = &device_param->d_combs;
17449 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
17450 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
17451
17452 device_param->kernel_params_mp_buf64[3] = 0;
17453 device_param->kernel_params_mp_buf32[4] = css_cnt;
17454 device_param->kernel_params_mp_buf32[5] = 0;
17455 device_param->kernel_params_mp_buf32[6] = 0;
17456 device_param->kernel_params_mp_buf32[7] = 0;
17457
17458 if (attack_mode == ATTACK_MODE_HYBRID1)
17459 {
17460 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
17461 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
17462 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
17463 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
17464 }
17465 else if (attack_mode == ATTACK_MODE_HYBRID2)
17466 {
17467 device_param->kernel_params_mp_buf32[5] = 0;
17468 device_param->kernel_params_mp_buf32[6] = 0;
17469 device_param->kernel_params_mp_buf32[7] = 0;
17470 }
17471
17472 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]);
17473 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]);
17474 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]);
17475
17476 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);
17477 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);
17478 }
17479 }
17480 else if (attack_mode == ATTACK_MODE_BF)
17481 {
17482 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
17483
17484 if (increment)
17485 {
17486 for (uint i = 0; i < dictcnt; i++)
17487 {
17488 local_free (dictfiles[i]);
17489 }
17490
17491 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17492 {
17493 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17494
17495 if (l1_filename == NULL) break;
17496
17497 dictcnt++;
17498
17499 dictfiles[dictcnt - 1] = l1_filename;
17500 }
17501 }
17502 else
17503 {
17504 dictcnt++;
17505
17506 dictfiles[dictcnt - 1] = mask;
17507 }
17508
17509 if (dictcnt == 0)
17510 {
17511 log_error ("ERROR: Mask is too small");
17512
17513 return (-1);
17514 }
17515 }
17516 }
17517
17518 free (induction_dictionaries);
17519
17520 // induction_dictionaries_cnt = 0; // implied
17521
17522 if (attack_mode != ATTACK_MODE_BF)
17523 {
17524 if (keyspace == 0)
17525 {
17526 induction_dictionaries = scan_directory (induction_directory);
17527
17528 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17529 }
17530 }
17531
17532 if (induction_dictionaries_cnt)
17533 {
17534 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17535 }
17536
17537 /**
17538 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17539 */
17540 if (keyspace == 1)
17541 {
17542 if ((maskcnt > 1) || (dictcnt > 1))
17543 {
17544 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17545
17546 return (-1);
17547 }
17548 }
17549
17550 for (uint dictpos = rd->dictpos; dictpos < dictcnt; dictpos++)
17551 {
17552 if (data.devices_status == STATUS_CRACKED) continue;
17553 if (data.devices_status == STATUS_ABORTED) continue;
17554 if (data.devices_status == STATUS_QUIT) continue;
17555
17556 rd->dictpos = dictpos;
17557
17558 char *subid = logfile_generate_subid ();
17559
17560 data.subid = subid;
17561
17562 logfile_sub_msg ("START");
17563
17564 data.devices_status = STATUS_INIT;
17565
17566 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17567 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17568 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17569
17570 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17571
17572 data.cpt_pos = 0;
17573
17574 data.cpt_start = time (NULL);
17575
17576 data.cpt_total = 0;
17577
17578 if (data.restore == 0)
17579 {
17580 rd->words_cur = skip;
17581
17582 skip = 0;
17583
17584 data.skip = 0;
17585 }
17586
17587 data.ms_paused = 0;
17588
17589 data.kernel_power_final = 0;
17590
17591 data.words_cur = rd->words_cur;
17592
17593 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17594 {
17595 hc_device_param_t *device_param = &data.devices_param[device_id];
17596
17597 if (device_param->skipped) continue;
17598
17599 device_param->speed_pos = 0;
17600
17601 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17602 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17603
17604 device_param->exec_pos = 0;
17605
17606 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17607
17608 device_param->outerloop_pos = 0;
17609 device_param->outerloop_left = 0;
17610 device_param->innerloop_pos = 0;
17611 device_param->innerloop_left = 0;
17612
17613 // some more resets:
17614
17615 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17616
17617 device_param->pws_cnt = 0;
17618
17619 device_param->words_off = 0;
17620 device_param->words_done = 0;
17621 }
17622
17623 // figure out some workload
17624
17625 if (attack_mode == ATTACK_MODE_STRAIGHT)
17626 {
17627 if (data.wordlist_mode == WL_MODE_FILE)
17628 {
17629 char *dictfile = NULL;
17630
17631 if (induction_dictionaries_cnt)
17632 {
17633 dictfile = induction_dictionaries[0];
17634 }
17635 else
17636 {
17637 dictfile = dictfiles[dictpos];
17638 }
17639
17640 data.dictfile = dictfile;
17641
17642 logfile_sub_string (dictfile);
17643
17644 for (uint i = 0; i < rp_files_cnt; i++)
17645 {
17646 logfile_sub_var_string ("rulefile", rp_files[i]);
17647 }
17648
17649 FILE *fd2 = fopen (dictfile, "rb");
17650
17651 if (fd2 == NULL)
17652 {
17653 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17654
17655 return (-1);
17656 }
17657
17658 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17659
17660 fclose (fd2);
17661
17662 if (data.words_cnt == 0)
17663 {
17664 logfile_sub_msg ("STOP");
17665
17666 continue;
17667 }
17668 }
17669 }
17670 else if (attack_mode == ATTACK_MODE_COMBI)
17671 {
17672 char *dictfile = data.dictfile;
17673 char *dictfile2 = data.dictfile2;
17674
17675 logfile_sub_string (dictfile);
17676 logfile_sub_string (dictfile2);
17677
17678 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17679 {
17680 FILE *fd2 = fopen (dictfile, "rb");
17681
17682 if (fd2 == NULL)
17683 {
17684 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17685
17686 return (-1);
17687 }
17688
17689 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17690
17691 fclose (fd2);
17692 }
17693 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17694 {
17695 FILE *fd2 = fopen (dictfile2, "rb");
17696
17697 if (fd2 == NULL)
17698 {
17699 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17700
17701 return (-1);
17702 }
17703
17704 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17705
17706 fclose (fd2);
17707 }
17708
17709 if (data.words_cnt == 0)
17710 {
17711 logfile_sub_msg ("STOP");
17712
17713 continue;
17714 }
17715 }
17716 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17717 {
17718 char *dictfile = NULL;
17719
17720 if (induction_dictionaries_cnt)
17721 {
17722 dictfile = induction_dictionaries[0];
17723 }
17724 else
17725 {
17726 dictfile = dictfiles[dictpos];
17727 }
17728
17729 data.dictfile = dictfile;
17730
17731 char *mask = data.mask;
17732
17733 logfile_sub_string (dictfile);
17734 logfile_sub_string (mask);
17735
17736 FILE *fd2 = fopen (dictfile, "rb");
17737
17738 if (fd2 == NULL)
17739 {
17740 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17741
17742 return (-1);
17743 }
17744
17745 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17746
17747 fclose (fd2);
17748
17749 if (data.words_cnt == 0)
17750 {
17751 logfile_sub_msg ("STOP");
17752
17753 continue;
17754 }
17755 }
17756 else if (attack_mode == ATTACK_MODE_BF)
17757 {
17758 local_free (css_buf);
17759 local_free (data.root_css_buf);
17760 local_free (data.markov_css_buf);
17761
17762 char *mask = dictfiles[dictpos];
17763
17764 logfile_sub_string (mask);
17765
17766 // base
17767
17768 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17769
17770 if (opts_type & OPTS_TYPE_PT_UNICODE)
17771 {
17772 uint css_cnt_unicode = css_cnt * 2;
17773
17774 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17775
17776 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17777 {
17778 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17779
17780 css_buf_unicode[j + 1].cs_buf[0] = 0;
17781 css_buf_unicode[j + 1].cs_len = 1;
17782 }
17783
17784 free (css_buf);
17785
17786 css_buf = css_buf_unicode;
17787 css_cnt = css_cnt_unicode;
17788 }
17789
17790 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17791
17792 uint mask_min = pw_min;
17793 uint mask_max = pw_max;
17794
17795 if (opts_type & OPTS_TYPE_PT_UNICODE)
17796 {
17797 mask_min *= 2;
17798 mask_max *= 2;
17799 }
17800
17801 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17802 {
17803 if (css_cnt < mask_min)
17804 {
17805 log_info ("WARNING: Skipping mask '%s' because it is smaller than the minimum password length", mask);
17806 }
17807
17808 if (css_cnt > mask_max)
17809 {
17810 log_info ("WARNING: Skipping mask '%s' because it is larger than the maximum password length", mask);
17811 }
17812
17813 // skip to next mask
17814
17815 logfile_sub_msg ("STOP");
17816
17817 continue;
17818 }
17819
17820 uint save_css_cnt = css_cnt;
17821
17822 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17823 {
17824 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17825 {
17826 uint salt_len = (uint) data.salts_buf[0].salt_len;
17827 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17828
17829 uint css_cnt_salt = css_cnt + salt_len;
17830
17831 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17832
17833 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17834
17835 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17836 {
17837 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17838 css_buf_salt[j].cs_len = 1;
17839 }
17840
17841 free (css_buf);
17842
17843 css_buf = css_buf_salt;
17844 css_cnt = css_cnt_salt;
17845 }
17846 }
17847
17848 data.mask = mask;
17849 data.css_cnt = css_cnt;
17850 data.css_buf = css_buf;
17851
17852 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17853
17854 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17855
17856 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17857
17858 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17859 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17860
17861 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17862
17863 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17864
17865 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17866 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17867
17868 data.root_css_buf = root_css_buf;
17869 data.markov_css_buf = markov_css_buf;
17870
17871 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17872
17873 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17874
17875 local_free (root_table_buf);
17876 local_free (markov_table_buf);
17877
17878 // copy + args
17879
17880 uint css_cnt_l = css_cnt;
17881 uint css_cnt_r;
17882
17883 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17884 {
17885 if (save_css_cnt < 6)
17886 {
17887 css_cnt_r = 1;
17888 }
17889 else if (save_css_cnt == 6)
17890 {
17891 css_cnt_r = 2;
17892 }
17893 else
17894 {
17895 if (opts_type & OPTS_TYPE_PT_UNICODE)
17896 {
17897 if (save_css_cnt == 8 || save_css_cnt == 10)
17898 {
17899 css_cnt_r = 2;
17900 }
17901 else
17902 {
17903 css_cnt_r = 4;
17904 }
17905 }
17906 else
17907 {
17908 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17909 {
17910 css_cnt_r = 3;
17911 }
17912 else
17913 {
17914 css_cnt_r = 4;
17915 }
17916 }
17917 }
17918 }
17919 else
17920 {
17921 css_cnt_r = 1;
17922
17923 /* unfinished code?
17924 int sum = css_buf[css_cnt_r - 1].cs_len;
17925
17926 for (uint i = 1; i < 4 && i < css_cnt; i++)
17927 {
17928 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17929
17930 css_cnt_r++;
17931
17932 sum *= css_buf[css_cnt_r - 1].cs_len;
17933 }
17934 */
17935 }
17936
17937 css_cnt_l -= css_cnt_r;
17938
17939 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17940
17941 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17942 {
17943 hc_device_param_t *device_param = &data.devices_param[device_id];
17944
17945 if (device_param->skipped) continue;
17946
17947 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17948 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17949 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17950
17951 device_param->kernel_params_mp_l_buf64[3] = 0;
17952 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17953 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17954 device_param->kernel_params_mp_l_buf32[6] = 0;
17955 device_param->kernel_params_mp_l_buf32[7] = 0;
17956 device_param->kernel_params_mp_l_buf32[8] = 0;
17957
17958 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17959 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17960 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17961 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17962
17963 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17964 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17965 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17966
17967 device_param->kernel_params_mp_r_buf64[3] = 0;
17968 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17969 device_param->kernel_params_mp_r_buf32[5] = 0;
17970 device_param->kernel_params_mp_r_buf32[6] = 0;
17971 device_param->kernel_params_mp_r_buf32[7] = 0;
17972
17973 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]);
17974 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]);
17975 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]);
17976
17977 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]);
17978 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]);
17979 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]);
17980
17981 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);
17982 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);
17983 }
17984 }
17985
17986 u64 words_base = data.words_cnt;
17987
17988 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17989 {
17990 if (data.kernel_rules_cnt)
17991 {
17992 words_base /= data.kernel_rules_cnt;
17993 }
17994 }
17995 else if (data.attack_kern == ATTACK_KERN_COMBI)
17996 {
17997 if (data.combs_cnt)
17998 {
17999 words_base /= data.combs_cnt;
18000 }
18001 }
18002 else if (data.attack_kern == ATTACK_KERN_BF)
18003 {
18004 if (data.bfs_cnt)
18005 {
18006 words_base /= data.bfs_cnt;
18007 }
18008 }
18009
18010 data.words_base = words_base;
18011
18012 if (keyspace == 1)
18013 {
18014 log_info ("%llu", (unsigned long long int) words_base);
18015
18016 return (0);
18017 }
18018
18019 if (data.words_cur > data.words_base)
18020 {
18021 log_error ("ERROR: Restore value greater keyspace");
18022
18023 return (-1);
18024 }
18025
18026 if (data.words_cur)
18027 {
18028 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18029 {
18030 for (uint i = 0; i < data.salts_cnt; i++)
18031 {
18032 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
18033 }
18034 }
18035 else if (data.attack_kern == ATTACK_KERN_COMBI)
18036 {
18037 for (uint i = 0; i < data.salts_cnt; i++)
18038 {
18039 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
18040 }
18041 }
18042 else if (data.attack_kern == ATTACK_KERN_BF)
18043 {
18044 for (uint i = 0; i < data.salts_cnt; i++)
18045 {
18046 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
18047 }
18048 }
18049 }
18050
18051 /*
18052 * Update loopback file
18053 */
18054
18055 if (loopback == 1)
18056 {
18057 time_t now;
18058
18059 time (&now);
18060
18061 uint random_num = get_random_num (0, 9999);
18062
18063 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
18064
18065 data.loopback_file = loopback_file;
18066 }
18067
18068 /*
18069 * Update dictionary statistic
18070 */
18071
18072 if (keyspace == 0)
18073 {
18074 dictstat_fp = fopen (dictstat, "wb");
18075
18076 if (dictstat_fp)
18077 {
18078 lock_file (dictstat_fp);
18079
18080 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
18081
18082 fclose (dictstat_fp);
18083 }
18084 }
18085
18086 /**
18087 * create autotune threads
18088 */
18089
18090 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
18091
18092 data.devices_status = STATUS_AUTOTUNE;
18093
18094 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18095 {
18096 hc_device_param_t *device_param = &devices_param[device_id];
18097
18098 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
18099 }
18100
18101 hc_thread_wait (data.devices_cnt, c_threads);
18102
18103 /*
18104 * Inform user about possible slow speeds
18105 */
18106
18107 uint hardware_power_all = 0;
18108
18109 uint kernel_power_all = 0;
18110
18111 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18112 {
18113 hc_device_param_t *device_param = &devices_param[device_id];
18114
18115 hardware_power_all += device_param->hardware_power;
18116
18117 kernel_power_all += device_param->kernel_power;
18118 }
18119
18120 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
18121
18122 data.kernel_power_all = kernel_power_all;
18123
18124 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18125 {
18126 if (data.words_base < kernel_power_all)
18127 {
18128 if (quiet == 0)
18129 {
18130 clear_prompt ();
18131
18132 log_info ("ATTENTION!");
18133 log_info (" The wordlist or mask you are using is too small.");
18134 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
18135 log_info (" The cracking speed will drop.");
18136 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
18137 log_info ("");
18138 }
18139 }
18140 }
18141
18142 /**
18143 * create cracker threads
18144 */
18145
18146 data.devices_status = STATUS_RUNNING;
18147
18148 if (initial_restore_done == 0)
18149 {
18150 if (data.restore_disable == 0) cycle_restore ();
18151
18152 initial_restore_done = 1;
18153 }
18154
18155 hc_timer_set (&data.timer_running);
18156
18157 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18158 {
18159 if ((quiet == 0) && (status == 0) && (benchmark == 0))
18160 {
18161 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
18162 if (quiet == 0) fflush (stdout);
18163 }
18164 }
18165 else if (wordlist_mode == WL_MODE_STDIN)
18166 {
18167 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
18168 if (data.quiet == 0) log_info ("");
18169 }
18170
18171 time_t runtime_start;
18172
18173 time (&runtime_start);
18174
18175 data.runtime_start = runtime_start;
18176
18177 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18178 {
18179 hc_device_param_t *device_param = &devices_param[device_id];
18180
18181 if (wordlist_mode == WL_MODE_STDIN)
18182 {
18183 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
18184 }
18185 else
18186 {
18187 hc_thread_create (c_threads[device_id], thread_calc, device_param);
18188 }
18189 }
18190
18191 hc_thread_wait (data.devices_cnt, c_threads);
18192
18193 local_free (c_threads);
18194
18195 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT) && (data.devices_status != STATUS_BYPASS))
18196 {
18197 data.devices_status = STATUS_EXHAUSTED;
18198 }
18199
18200 logfile_sub_var_uint ("status-after-work", data.devices_status);
18201
18202 data.restore = 0;
18203
18204 if (induction_dictionaries_cnt)
18205 {
18206 unlink (induction_dictionaries[0]);
18207 }
18208
18209 free (induction_dictionaries);
18210
18211 if (attack_mode != ATTACK_MODE_BF)
18212 {
18213 induction_dictionaries = scan_directory (induction_directory);
18214
18215 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18216 }
18217
18218 if (benchmark == 1)
18219 {
18220 status_benchmark ();
18221
18222 if (machine_readable == 0)
18223 {
18224 log_info ("");
18225 }
18226 }
18227 else
18228 {
18229 if (quiet == 0)
18230 {
18231 clear_prompt ();
18232
18233 log_info ("");
18234
18235 if (stdout_flag == 0) status_display ();
18236
18237 log_info ("");
18238 }
18239 }
18240
18241 if (induction_dictionaries_cnt)
18242 {
18243 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18244 }
18245
18246 time_t runtime_stop;
18247
18248 time (&runtime_stop);
18249
18250 data.runtime_stop = runtime_stop;
18251
18252 logfile_sub_uint (runtime_start);
18253 logfile_sub_uint (runtime_stop);
18254
18255 logfile_sub_msg ("STOP");
18256
18257 global_free (subid);
18258
18259 // from this point we handle bypass as exhausted
18260
18261 if (data.devices_status == STATUS_BYPASS)
18262 {
18263 data.devices_status = STATUS_EXHAUSTED;
18264 }
18265
18266 // finalize task
18267
18268 if (data.devices_status == STATUS_CRACKED) break;
18269 if (data.devices_status == STATUS_ABORTED) break;
18270 if (data.devices_status == STATUS_QUIT) break;
18271 }
18272
18273 if (data.devices_status == STATUS_CRACKED) break;
18274 if (data.devices_status == STATUS_ABORTED) break;
18275 if (data.devices_status == STATUS_QUIT) break;
18276 }
18277
18278 // 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
18279 if (attack_mode == ATTACK_MODE_STRAIGHT)
18280 {
18281 if (data.wordlist_mode == WL_MODE_FILE)
18282 {
18283 if (data.dictfile == NULL)
18284 {
18285 if (dictfiles != NULL)
18286 {
18287 data.dictfile = dictfiles[0];
18288
18289 hc_timer_set (&data.timer_running);
18290 }
18291 }
18292 }
18293 }
18294 // NOTE: combi is okay because it is already set beforehand
18295 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
18296 {
18297 if (data.dictfile == NULL)
18298 {
18299 if (dictfiles != NULL)
18300 {
18301 hc_timer_set (&data.timer_running);
18302
18303 data.dictfile = dictfiles[0];
18304 }
18305 }
18306 }
18307 else if (attack_mode == ATTACK_MODE_BF)
18308 {
18309 if (data.mask == NULL)
18310 {
18311 hc_timer_set (&data.timer_running);
18312
18313 data.mask = masks[0];
18314 }
18315 }
18316
18317 // if cracked / aborted remove last induction dictionary
18318
18319 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
18320 {
18321 struct stat induct_stat;
18322
18323 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
18324 {
18325 unlink (induction_dictionaries[file_pos]);
18326 }
18327 }
18328
18329 // wait for non-interactive threads
18330
18331 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
18332 {
18333 hc_thread_wait (1, &ni_threads[thread_idx]);
18334 }
18335
18336 local_free (ni_threads);
18337
18338 // we dont need restore file anymore
18339 if (data.restore_disable == 0)
18340 {
18341 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
18342 {
18343 unlink (eff_restore_file);
18344 unlink (new_restore_file);
18345 }
18346 else
18347 {
18348 cycle_restore ();
18349 }
18350 }
18351
18352 // finally save left hashes
18353
18354 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
18355 {
18356 save_hash ();
18357 }
18358
18359 /**
18360 * Clean up
18361 */
18362
18363 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18364 {
18365 hc_device_param_t *device_param = &data.devices_param[device_id];
18366
18367 if (device_param->skipped) continue;
18368
18369 local_free (device_param->combs_buf);
18370 local_free (device_param->hooks_buf);
18371 local_free (device_param->device_name);
18372 local_free (device_param->device_name_chksum);
18373 local_free (device_param->device_version);
18374 local_free (device_param->driver_version);
18375
18376 if (device_param->pws_buf) myfree (device_param->pws_buf);
18377 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
18378 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
18379 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
18380 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
18381 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
18382 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
18383 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
18384 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
18385 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
18386 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
18387 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
18388 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
18389 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
18390 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
18391 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
18392 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
18393 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
18394 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
18395 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
18396 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
18397 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
18398 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
18399 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
18400 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
18401 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
18402 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
18403 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
18404 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
18405
18406 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
18407 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
18408 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
18409 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
18410 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
18411 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
18412 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
18413 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
18414 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
18415 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
18416 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
18417
18418 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
18419 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
18420 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
18421
18422 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
18423 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
18424 }
18425
18426 // reset default fan speed
18427
18428 #ifdef HAVE_HWMON
18429 if (gpu_temp_disable == 0)
18430 {
18431 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
18432 {
18433 hc_thread_mutex_lock (mux_adl);
18434
18435 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18436 {
18437 hc_device_param_t *device_param = &data.devices_param[device_id];
18438
18439 if (device_param->skipped) continue;
18440
18441 if (data.hm_device[device_id].fan_set_supported == 1)
18442 {
18443 int fanspeed = temp_retain_fanspeed_value[device_id];
18444 int fanpolicy = temp_retain_fanpolicy_value[device_id];
18445
18446 if (fanpolicy == 1)
18447 {
18448 int rc = -1;
18449
18450 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18451 {
18452 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
18453 }
18454 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18455 {
18456 #ifdef LINUX
18457 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE);
18458 #endif
18459
18460 #ifdef WIN
18461 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, fanpolicy);
18462 #endif
18463 }
18464
18465 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18466 }
18467 }
18468 }
18469
18470 hc_thread_mutex_unlock (mux_adl);
18471 }
18472 }
18473
18474 // reset power tuning
18475
18476 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
18477 {
18478 hc_thread_mutex_lock (mux_adl);
18479
18480 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18481 {
18482 hc_device_param_t *device_param = &data.devices_param[device_id];
18483
18484 if (device_param->skipped) continue;
18485
18486 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18487 {
18488 if (data.hm_device[device_id].od_version == 6)
18489 {
18490 // check powertune capabilities first, if not available then skip device
18491
18492 int powertune_supported = 0;
18493
18494 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18495 {
18496 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18497
18498 return (-1);
18499 }
18500
18501 if (powertune_supported != 0)
18502 {
18503 // powercontrol settings
18504
18505 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18506 {
18507 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18508
18509 return (-1);
18510 }
18511
18512 // clocks
18513
18514 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18515
18516 performance_state->iNumberOfPerformanceLevels = 2;
18517
18518 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18519 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18520 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18521 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18522
18523 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18524 {
18525 log_info ("ERROR: Failed to restore ADL performance state");
18526
18527 return (-1);
18528 }
18529
18530 local_free (performance_state);
18531 }
18532 }
18533 }
18534
18535 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18536 {
18537 unsigned int limit = nvml_power_limit[device_id];
18538
18539 if (limit > 0)
18540 {
18541 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18542 }
18543 }
18544 }
18545
18546 hc_thread_mutex_unlock (mux_adl);
18547 }
18548
18549 if (gpu_temp_disable == 0)
18550 {
18551 if (data.hm_nvml)
18552 {
18553 hm_NVML_nvmlShutdown (data.hm_nvml);
18554
18555 nvml_close (data.hm_nvml);
18556
18557 data.hm_nvml = NULL;
18558 }
18559
18560 if (data.hm_nvapi)
18561 {
18562 hm_NvAPI_Unload (data.hm_nvapi);
18563
18564 nvapi_close (data.hm_nvapi);
18565
18566 data.hm_nvapi = NULL;
18567 }
18568
18569 if (data.hm_xnvctrl)
18570 {
18571 hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);
18572
18573 xnvctrl_close (data.hm_xnvctrl);
18574
18575 data.hm_xnvctrl = NULL;
18576 }
18577
18578 if (data.hm_adl)
18579 {
18580 hm_ADL_Main_Control_Destroy (data.hm_adl);
18581
18582 adl_close (data.hm_adl);
18583
18584 data.hm_adl = NULL;
18585 }
18586 }
18587 #endif // HAVE_HWMON
18588
18589 // free memory
18590
18591 local_free (masks);
18592
18593 local_free (dictstat_base);
18594
18595 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18596 {
18597 pot_t *pot_ptr = &pot[pot_pos];
18598
18599 hash_t *hash = &pot_ptr->hash;
18600
18601 local_free (hash->digest);
18602
18603 if (isSalted)
18604 {
18605 local_free (hash->salt);
18606 }
18607 }
18608
18609 local_free (pot);
18610
18611 local_free (all_kernel_rules_cnt);
18612 local_free (all_kernel_rules_buf);
18613
18614 local_free (wl_data->buf);
18615 local_free (wl_data);
18616
18617 local_free (bitmap_s1_a);
18618 local_free (bitmap_s1_b);
18619 local_free (bitmap_s1_c);
18620 local_free (bitmap_s1_d);
18621 local_free (bitmap_s2_a);
18622 local_free (bitmap_s2_b);
18623 local_free (bitmap_s2_c);
18624 local_free (bitmap_s2_d);
18625
18626 #ifdef HAVE_HWMON
18627 local_free (temp_retain_fanspeed_value);
18628 local_free (od_clock_mem_status);
18629 local_free (od_power_control_status);
18630 local_free (nvml_power_limit);
18631 #endif
18632
18633 global_free (devices_param);
18634
18635 global_free (kernel_rules_buf);
18636
18637 global_free (root_css_buf);
18638 global_free (markov_css_buf);
18639
18640 global_free (digests_buf);
18641 global_free (digests_shown);
18642 global_free (digests_shown_tmp);
18643
18644 global_free (salts_buf);
18645 global_free (salts_shown);
18646
18647 global_free (esalts_buf);
18648
18649 global_free (words_progress_done);
18650 global_free (words_progress_rejected);
18651 global_free (words_progress_restored);
18652
18653 if (pot_fp) fclose (pot_fp);
18654
18655 if (data.devices_status == STATUS_QUIT) break;
18656 }
18657
18658 // wait for interactive threads
18659
18660 for (uint thread_idx = 0; thread_idx < i_threads_cnt; thread_idx++)
18661 {
18662 hc_thread_wait (1, &i_threads[thread_idx]);
18663 }
18664
18665 local_free (i_threads);
18666
18667 // destroy others mutex
18668
18669 hc_thread_mutex_delete (mux_dispatcher);
18670 hc_thread_mutex_delete (mux_counter);
18671 hc_thread_mutex_delete (mux_display);
18672 hc_thread_mutex_delete (mux_adl);
18673
18674 // free memory
18675
18676 local_free (eff_restore_file);
18677 local_free (new_restore_file);
18678
18679 local_free (rd);
18680
18681 // tuning db
18682
18683 tuning_db_destroy (tuning_db);
18684
18685 // loopback
18686
18687 local_free (loopback_file);
18688
18689 if (loopback == 1) unlink (loopback_file);
18690
18691 // induction directory
18692
18693 if (induction_dir == NULL)
18694 {
18695 if (attack_mode != ATTACK_MODE_BF)
18696 {
18697 if (rmdir (induction_directory) == -1)
18698 {
18699 if (errno == ENOENT)
18700 {
18701 // good, we can ignore
18702 }
18703 else if (errno == ENOTEMPTY)
18704 {
18705 // good, we can ignore
18706 }
18707 else
18708 {
18709 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18710
18711 return (-1);
18712 }
18713 }
18714
18715 local_free (induction_directory);
18716 }
18717 }
18718
18719 // outfile-check directory
18720
18721 if (outfile_check_dir == NULL)
18722 {
18723 if (rmdir (outfile_check_directory) == -1)
18724 {
18725 if (errno == ENOENT)
18726 {
18727 // good, we can ignore
18728 }
18729 else if (errno == ENOTEMPTY)
18730 {
18731 // good, we can ignore
18732 }
18733 else
18734 {
18735 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18736
18737 return (-1);
18738 }
18739 }
18740
18741 local_free (outfile_check_directory);
18742 }
18743
18744 time_t proc_stop;
18745
18746 time (&proc_stop);
18747
18748 logfile_top_uint (proc_start);
18749 logfile_top_uint (proc_stop);
18750
18751 logfile_top_msg ("STOP");
18752
18753 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18754 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18755
18756 if (data.ocl) ocl_close (data.ocl);
18757
18758 if (data.devices_status == STATUS_ABORTED) return 2;
18759 if (data.devices_status == STATUS_QUIT) return 2;
18760 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18761 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18762 if (data.devices_status == STATUS_CRACKED) return 0;
18763
18764 return -1;
18765 }
Hashcat additions to support pwdhash