projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Some optical change on startup
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define STDOUT_FLAG 0
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define MACHINE_READABLE 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define NVIDIA_SPIN_DAMP 100
79 #define GPU_TEMP_DISABLE 0
80 #define GPU_TEMP_ABORT 90
81 #define GPU_TEMP_RETAIN 65
82 #define WORKLOAD_PROFILE 2
83 #define KERNEL_ACCEL 0
84 #define KERNEL_LOOPS 0
85 #define KERNEL_RULES 1024
86 #define KERNEL_COMBS 1024
87 #define KERNEL_BFS 1024
88 #define KERNEL_THREADS_MAX 256
89 #define KERNEL_THREADS_MAX_CPU 16
90 #define POWERTUNE_ENABLE 0
91 #define LOGFILE_DISABLE 0
92 #define SCRYPT_TMTO 0
93 #define OPENCL_VECTOR_WIDTH 0
94
95 #define WL_MODE_STDIN 1
96 #define WL_MODE_FILE 2
97 #define WL_MODE_MASK 3
98
99 #define HL_MODE_FILE 4
100 #define HL_MODE_ARG 5
101
102 #define HLFMTS_CNT 11
103 #define HLFMT_HASHCAT 0
104 #define HLFMT_PWDUMP 1
105 #define HLFMT_PASSWD 2
106 #define HLFMT_SHADOW 3
107 #define HLFMT_DCC 4
108 #define HLFMT_DCC2 5
109 #define HLFMT_NETNTLM1 7
110 #define HLFMT_NETNTLM2 8
111 #define HLFMT_NSLDAP 9
112 #define HLFMT_NSLDAPS 10
113
114 #define HLFMT_TEXT_HASHCAT "native hashcat"
115 #define HLFMT_TEXT_PWDUMP "pwdump"
116 #define HLFMT_TEXT_PASSWD "passwd"
117 #define HLFMT_TEXT_SHADOW "shadow"
118 #define HLFMT_TEXT_DCC "DCC"
119 #define HLFMT_TEXT_DCC2 "DCC 2"
120 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
121 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
122 #define HLFMT_TEXT_NSLDAP "nsldap"
123 #define HLFMT_TEXT_NSLDAPS "nsldaps"
124
125 #define ATTACK_MODE_STRAIGHT 0
126 #define ATTACK_MODE_COMBI 1
127 #define ATTACK_MODE_TOGGLE 2
128 #define ATTACK_MODE_BF 3
129 #define ATTACK_MODE_PERM 4
130 #define ATTACK_MODE_TABLE 5
131 #define ATTACK_MODE_HYBRID1 6
132 #define ATTACK_MODE_HYBRID2 7
133 #define ATTACK_MODE_NONE 100
134
135 #define ATTACK_KERN_STRAIGHT 0
136 #define ATTACK_KERN_COMBI 1
137 #define ATTACK_KERN_BF 3
138 #define ATTACK_KERN_NONE 100
139
140 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
141 #define ATTACK_EXEC_INSIDE_KERNEL 11
142
143 #define COMBINATOR_MODE_BASE_LEFT 10001
144 #define COMBINATOR_MODE_BASE_RIGHT 10002
145
146 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
147 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
148
149 #define MAX_CUT_TRIES 4
150
151 #define MAX_DICTSTAT 10000
152
153 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
154
155 #define NVIDIA_100PERCENTCPU_WORKAROUND 100
156
157 #define global_free(attr) \
158 { \
159 myfree ((void *) data.attr); \
160 \
161 data.attr = NULL; \
162 }
163
164 #define local_free(attr) \
165 { \
166 myfree ((void *) attr); \
167 \
168 attr = NULL; \
169 }
170
171 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
172 #define HC_API_CALL __stdcall
173 #else
174 #define HC_API_CALL
175 #endif
176
177 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
178 {
179 900,
180 0,
181 5100,
182 100,
183 1400,
184 10800,
185 1700,
186 5000,
187 10100,
188 6000,
189 6100,
190 6900,
191 11700,
192 11800,
193 400,
194 8900,
195 11900,
196 12000,
197 10900,
198 12100,
199 23,
200 2500,
201 5300,
202 5400,
203 5500,
204 5600,
205 7300,
206 7500,
207 13100,
208 8300,
209 11100,
210 11200,
211 11400,
212 121,
213 2611,
214 2711,
215 2811,
216 8400,
217 11,
218 2612,
219 7900,
220 21,
221 11000,
222 124,
223 10000,
224 3711,
225 7600,
226 12,
227 131,
228 132,
229 1731,
230 200,
231 300,
232 3100,
233 112,
234 12300,
235 8000,
236 141,
237 1441,
238 1600,
239 12600,
240 1421,
241 101,
242 111,
243 1711,
244 3000,
245 1000,
246 1100,
247 2100,
248 12800,
249 1500,
250 12400,
251 500,
252 3200,
253 7400,
254 1800,
255 122,
256 1722,
257 7100,
258 6300,
259 6700,
260 6400,
261 6500,
262 2400,
263 2410,
264 5700,
265 9200,
266 9300,
267 22,
268 501,
269 5800,
270 8100,
271 8500,
272 7200,
273 9900,
274 7700,
275 7800,
276 10300,
277 8600,
278 8700,
279 9100,
280 133,
281 13500,
282 11600,
283 13600,
284 12500,
285 13000,
286 13200,
287 13300,
288 6211,
289 6221,
290 6231,
291 6241,
292 13711,
293 13721,
294 13731,
295 13741,
296 13751,
297 13761,
298 8800,
299 12900,
300 12200,
301 9700,
302 9710,
303 9800,
304 9810,
305 9400,
306 9500,
307 9600,
308 10400,
309 10410,
310 10500,
311 10600,
312 10700,
313 9000,
314 5200,
315 6800,
316 6600,
317 8200,
318 11300,
319 12700,
320 13400,
321 125
322 };
323
324 /**
325 * types
326 */
327
328 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
329
330 /**
331 * globals
332 */
333
334 static unsigned int full01 = 0x01010101;
335 static unsigned int full80 = 0x80808080;
336
337 int SUPPRESS_OUTPUT = 0;
338
339 hc_thread_mutex_t mux_adl;
340 hc_thread_mutex_t mux_counter;
341 hc_thread_mutex_t mux_dispatcher;
342 hc_thread_mutex_t mux_display;
343
344 hc_global_data_t data;
345
346 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
347
348 const char *USAGE_MINI[] =
349 {
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "Try --help for more help.",
353 NULL
354 };
355
356 const char *USAGE_BIG[] =
357 {
358 "%s, advanced password recovery",
359 "",
360 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
361 "",
362 "- [ Options ] -",
363 "",
364 " Options Short / Long | Type | Description | Example",
365 "===============================|======|======================================================|=======================",
366 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
367 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
368 " -V, --version | | Print version |",
369 " -h, --help | | Print help |",
370 " --quiet | | Suppress output |",
371 " --hex-charset | | Assume charset is given in hex |",
372 " --hex-salt | | Assume salt is given in hex |",
373 " --hex-wordlist | | Assume words in wordlist is given in hex |",
374 " --force | | Ignore warnings |",
375 " --status | | Enable automatic update of the status-screen |",
376 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
377 " --machine-readable | | Display the status view in a machine readable format |",
378 " --loopback | | Add new plains to induct directory |",
379 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
380 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
381 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
382 " --markov-classic | | Enables classic markov-chains, no per-position |",
383 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
384 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
385 " --session | Str | Define specific session name | --session=mysession",
386 " --restore | | Restore session from --session |",
387 " --restore-disable | | Do not write restore file |",
388 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
389 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
390 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
391 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
392 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
393 " --stdout | | Do not crack a hash, instead print candidates only |",
394 " --show | | Show cracked passwords only |",
395 " --left | | Show un-cracked passwords only |",
396 " --username | | Enable ignoring of usernames in hashfile |",
397 " --remove | | Enable remove of hash once it is cracked |",
398 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
399 " --potfile-disable | | Do not write potfile |",
400 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
401 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
402 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
403 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
404 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
405 " --logfile-disable | | Disable the logfile |",
406 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
407 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
408 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
409 " -b, --benchmark | | Run benchmark |",
410 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
411 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
412 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
413 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
414 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
415 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
416 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=1",
417 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
418 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
419 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
420 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
421 " --nvidia-spin-damp | Num | Workaround NVidias CPU burning loop bug, in percent | --nvidia-spin-damp=50",
422 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
423 #ifdef HAVE_HWMON
424 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
425 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
426 " --powertune-enable | | Enable power tuning, restores settings when finished |",
427 #endif
428 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
429 " -s, --skip | Num | Skip X words from the start | -s 1000000",
430 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
431 " --keyspace | | Show keyspace base:mod values and quit |",
432 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
433 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
434 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
435 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
436 " --generate-rules-func-min | Num | Force min X funcs per rule |",
437 " --generate-rules-func-max | Num | Force max X funcs per rule |",
438 " --generate-rules-seed | Num | Force RNG seed set to X |",
439 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
440 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
441 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
442 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
443 " -i, --increment | | Enable mask increment mode |",
444 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
445 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
446 "",
447 "- [ Hash modes ] -",
448 "",
449 " # | Name | Category",
450 " ======+==================================================+======================================",
451 " 900 | MD4 | Raw Hash",
452 " 0 | MD5 | Raw Hash",
453 " 5100 | Half MD5 | Raw Hash",
454 " 100 | SHA1 | Raw Hash",
455 " 10800 | SHA-384 | Raw Hash",
456 " 1400 | SHA-256 | Raw Hash",
457 " 1700 | SHA-512 | Raw Hash",
458 " 5000 | SHA-3(Keccak) | Raw Hash",
459 " 10100 | SipHash | Raw Hash",
460 " 6000 | RipeMD160 | Raw Hash",
461 " 6100 | Whirlpool | Raw Hash",
462 " 6900 | GOST R 34.11-94 | Raw Hash",
463 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
464 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
465 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
466 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
467 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
468 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
469 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
470 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
471 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
472 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
473 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
474 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
475 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
476 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
477 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
478 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
479 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
480 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
481 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
482 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
483 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
484 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
485 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
486 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
487 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
488 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
489 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
490 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
491 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
492 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
493 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
494 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
495 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
496 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
497 " 400 | phpass | Generic KDF",
498 " 8900 | scrypt | Generic KDF",
499 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
500 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
501 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
502 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
503 " 23 | Skype | Network protocols",
504 " 2500 | WPA/WPA2 | Network protocols",
505 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
506 " 5300 | IKE-PSK MD5 | Network protocols",
507 " 5400 | IKE-PSK SHA1 | Network protocols",
508 " 5500 | NetNTLMv1 | Network protocols",
509 " 5500 | NetNTLMv1 + ESS | Network protocols",
510 " 5600 | NetNTLMv2 | Network protocols",
511 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
512 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
513 " 8300 | DNSSEC (NSEC3) | Network protocols",
514 " 10200 | Cram MD5 | Network protocols",
515 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
516 " 11200 | MySQL CRAM (SHA1) | Network protocols",
517 " 11400 | SIP digest authentication (MD5) | Network protocols",
518 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
519 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
520 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
521 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
522 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
523 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
524 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
525 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
526 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
527 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
528 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
529 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
530 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
531 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
532 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
533 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
534 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
535 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
536 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
537 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
538 " 12 | PostgreSQL | Database Server",
539 " 131 | MSSQL(2000) | Database Server",
540 " 132 | MSSQL(2005) | Database Server",
541 " 1731 | MSSQL(2012) | Database Server",
542 " 1731 | MSSQL(2014) | Database Server",
543 " 200 | MySQL323 | Database Server",
544 " 300 | MySQL4.1/MySQL5 | Database Server",
545 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
546 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
547 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
548 " 8000 | Sybase ASE | Database Server",
549 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
550 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
551 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
552 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
553 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
554 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
555 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
556 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
557 " 11500 | CRC32 | Checksums",
558 " 3000 | LM | Operating-Systems",
559 " 1000 | NTLM | Operating-Systems",
560 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
561 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
562 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
563 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
564 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
565 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
566 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
567 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
568 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
569 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
570 " 1722 | OSX v10.7 | Operating-Systems",
571 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
572 " 6300 | AIX {smd5} | Operating-Systems",
573 " 6700 | AIX {ssha1} | Operating-Systems",
574 " 6400 | AIX {ssha256} | Operating-Systems",
575 " 6500 | AIX {ssha512} | Operating-Systems",
576 " 2400 | Cisco-PIX | Operating-Systems",
577 " 2410 | Cisco-ASA | Operating-Systems",
578 " 500 | Cisco-IOS $1$ | Operating-Systems",
579 " 5700 | Cisco-IOS $4$ | Operating-Systems",
580 " 9200 | Cisco-IOS $8$ | Operating-Systems",
581 " 9300 | Cisco-IOS $9$ | Operating-Systems",
582 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
583 " 501 | Juniper IVE | Operating-Systems",
584 " 5800 | Android PIN | Operating-Systems",
585 " 13800 | Windows 8+ phone PIN/Password | Operating-Systems",
586 " 8100 | Citrix Netscaler | Operating-Systems",
587 " 8500 | RACF | Operating-Systems",
588 " 7200 | GRUB 2 | Operating-Systems",
589 " 9900 | Radmin2 | Operating-Systems",
590 " 125 | ArubaOS | Operating-Systems",
591 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
592 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
593 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
594 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
595 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
596 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
597 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
598 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
599 " 11600 | 7-Zip | Archives",
600 " 12500 | RAR3-hp | Archives",
601 " 13000 | RAR5 | Archives",
602 " 13200 | AxCrypt | Archives",
603 " 13300 | AxCrypt in memory SHA1 | Archives",
604 " 13600 | WinZip | Archives",
605 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
606 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
607 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
608 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
609 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
610 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
611 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
612 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
613 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
614 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
615 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
616 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
617 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
618 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
619 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
620 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
621 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
622 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
623 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
624 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
625 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
626 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
627 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
628 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
629 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
630 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
631 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
632 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
633 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
634 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
635 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
636 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
637 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
638 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
639 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
640 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
641 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
642 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
643 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
644 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
645 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
646 " 9400 | MS Office 2007 | Documents",
647 " 9500 | MS Office 2010 | Documents",
648 " 9600 | MS Office 2013 | Documents",
649 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
650 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
651 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
652 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
653 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
654 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
655 " 9000 | Password Safe v2 | Password Managers",
656 " 5200 | Password Safe v3 | Password Managers",
657 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
658 " 6600 | 1Password, agilekeychain | Password Managers",
659 " 8200 | 1Password, cloudkeychain | Password Managers",
660 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
661 " 12700 | Blockchain, My Wallet | Password Managers",
662 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
663 "",
664 "- [ Outfile Formats ] -",
665 "",
666 " # | Format",
667 " ===+========",
668 " 1 | hash[:salt]",
669 " 2 | plain",
670 " 3 | hash[:salt]:plain",
671 " 4 | hex_plain",
672 " 5 | hash[:salt]:hex_plain",
673 " 6 | plain:hex_plain",
674 " 7 | hash[:salt]:plain:hex_plain",
675 " 8 | crackpos",
676 " 9 | hash[:salt]:crack_pos",
677 " 10 | plain:crack_pos",
678 " 11 | hash[:salt]:plain:crack_pos",
679 " 12 | hex_plain:crack_pos",
680 " 13 | hash[:salt]:hex_plain:crack_pos",
681 " 14 | plain:hex_plain:crack_pos",
682 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
683 "",
684 "- [ Rule Debugging Modes ] -",
685 "",
686 " # | Format",
687 " ===+========",
688 " 1 | Finding-Rule",
689 " 2 | Original-Word",
690 " 3 | Original-Word:Finding-Rule",
691 " 4 | Original-Word:Finding-Rule:Processed-Word",
692 "",
693 "- [ Attack Modes ] -",
694 "",
695 " # | Mode",
696 " ===+======",
697 " 0 | Straight",
698 " 1 | Combination",
699 " 3 | Brute-force",
700 " 6 | Hybrid Wordlist + Mask",
701 " 7 | Hybrid Mask + Wordlist",
702 "",
703 "- [ Built-in Charsets ] -",
704 "",
705 " ? | Charset",
706 " ===+=========",
707 " l | abcdefghijklmnopqrstuvwxyz",
708 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
709 " d | 0123456789",
710 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
711 " a | ?l?u?d?s",
712 " b | 0x00 - 0xff",
713 "",
714 "- [ OpenCL Device Types ] -",
715 "",
716 " # | Device Type",
717 " ===+=============",
718 " 1 | CPU",
719 " 2 | GPU",
720 " 3 | FPGA, DSP, Co-Processor",
721 "",
722 "- [ Workload Profiles ] -",
723 "",
724 " # | Performance | Runtime | Power Consumption | Desktop Impact",
725 " ===+=============+=========+===================+=================",
726 " 1 | Low | 2 ms | Low | Minimal",
727 " 2 | Default | 12 ms | Economic | Noticeable",
728 " 3 | High | 96 ms | High | Unresponsive",
729 " 4 | Nightmare | 480 ms | Insane | Headless",
730 "",
731 "If you have no idea what just happened then visit the following pages:",
732 "",
733 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
734 "* https://hashcat.net/wiki/#frequently_asked_questions",
735 "",
736 NULL
737 };
738
739 /**
740 * hashcat specific functions
741 */
742
743 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
744 {
745 int exec_pos = (int) device_param->exec_pos - last_num_entries;
746
747 if (exec_pos < 0) exec_pos += EXEC_CACHE;
748
749 double exec_ms_sum = 0;
750
751 int exec_ms_cnt = 0;
752
753 for (int i = 0; i < last_num_entries; i++)
754 {
755 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
756
757 if (exec_ms)
758 {
759 exec_ms_sum += exec_ms;
760
761 exec_ms_cnt++;
762 }
763 }
764
765 if (exec_ms_cnt == 0) return 0;
766
767 return exec_ms_sum / exec_ms_cnt;
768 }
769
770 void status_display_machine_readable ()
771 {
772 FILE *out = stdout;
773
774 fprintf (out, "STATUS\t%u\t", data.devices_status);
775
776 /**
777 * speed new
778 */
779
780 fprintf (out, "SPEED\t");
781
782 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
783 {
784 hc_device_param_t *device_param = &data.devices_param[device_id];
785
786 if (device_param->skipped) continue;
787
788 u64 speed_cnt = 0;
789 double speed_ms = 0;
790
791 for (int i = 0; i < SPEED_CACHE; i++)
792 {
793 speed_cnt += device_param->speed_cnt[i];
794 speed_ms += device_param->speed_ms[i];
795 }
796
797 speed_cnt /= SPEED_CACHE;
798 speed_ms /= SPEED_CACHE;
799
800 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
801 }
802
803 /**
804 * exec time
805 */
806
807 fprintf (out, "EXEC_RUNTIME\t");
808
809 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
810 {
811 hc_device_param_t *device_param = &data.devices_param[device_id];
812
813 if (device_param->skipped) continue;
814
815 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
816
817 fprintf (out, "%f\t", exec_ms_avg);
818 }
819
820 /**
821 * words_cur
822 */
823
824 u64 words_cur = get_lowest_words_done ();
825
826 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
827
828 /**
829 * counter
830 */
831
832 u64 progress_total = data.words_cnt * data.salts_cnt;
833
834 u64 all_done = 0;
835 u64 all_rejected = 0;
836 u64 all_restored = 0;
837
838 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
839 {
840 all_done += data.words_progress_done[salt_pos];
841 all_rejected += data.words_progress_rejected[salt_pos];
842 all_restored += data.words_progress_restored[salt_pos];
843 }
844
845 u64 progress_cur = all_restored + all_done + all_rejected;
846 u64 progress_end = progress_total;
847
848 u64 progress_skip = 0;
849
850 if (data.skip)
851 {
852 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
853
854 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
855 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
856 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
857 }
858
859 if (data.limit)
860 {
861 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
862
863 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
864 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
865 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
866 }
867
868 u64 progress_cur_relative_skip = progress_cur - progress_skip;
869 u64 progress_end_relative_skip = progress_end - progress_skip;
870
871 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
872
873 /**
874 * cracks
875 */
876
877 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
878 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
879
880 /**
881 * temperature
882 */
883
884 #ifdef HAVE_HWMON
885 if (data.gpu_temp_disable == 0)
886 {
887 fprintf (out, "TEMP\t");
888
889 hc_thread_mutex_lock (mux_adl);
890
891 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
892 {
893 hc_device_param_t *device_param = &data.devices_param[device_id];
894
895 if (device_param->skipped) continue;
896
897 int temp = hm_get_temperature_with_device_id (device_id);
898
899 fprintf (out, "%d\t", temp);
900 }
901
902 hc_thread_mutex_unlock (mux_adl);
903 }
904 #endif // HAVE_HWMON
905
906 /**
907 * flush
908 */
909
910 #ifdef _WIN
911 fputc ('\r', out);
912 fputc ('\n', out);
913 #endif
914
915 #ifdef _POSIX
916 fputc ('\n', out);
917 #endif
918
919 fflush (out);
920 }
921
922 void status_display ()
923 {
924 if (data.devices_status == STATUS_INIT) return;
925 if (data.devices_status == STATUS_STARTING) return;
926 if (data.devices_status == STATUS_BYPASS) return;
927
928 if (data.machine_readable == 1)
929 {
930 status_display_machine_readable ();
931
932 return;
933 }
934
935 char tmp_buf[1000] = { 0 };
936
937 uint tmp_len = 0;
938
939 log_info ("Session.Name...: %s", data.session);
940
941 char *status_type = strstatus (data.devices_status);
942
943 uint hash_mode = data.hash_mode;
944
945 char *hash_type = strhashtype (hash_mode); // not a bug
946
947 log_info ("Status.........: %s", status_type);
948
949 /**
950 * show rules
951 */
952
953 if (data.rp_files_cnt)
954 {
955 uint i;
956
957 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
958 {
959 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
960 }
961
962 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
963
964 log_info ("Rules.Type.....: %s", tmp_buf);
965
966 tmp_len = 0;
967 }
968
969 if (data.rp_gen)
970 {
971 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
972
973 if (data.rp_gen_seed)
974 {
975 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
976 }
977 }
978
979 /**
980 * show input
981 */
982
983 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
984 {
985 if (data.wordlist_mode == WL_MODE_FILE)
986 {
987 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
988 }
989 else if (data.wordlist_mode == WL_MODE_STDIN)
990 {
991 log_info ("Input.Mode.....: Pipe");
992 }
993 }
994 else if (data.attack_mode == ATTACK_MODE_COMBI)
995 {
996 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
997 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
998 }
999 else if (data.attack_mode == ATTACK_MODE_BF)
1000 {
1001 char *mask = data.mask;
1002
1003 if (mask != NULL)
1004 {
1005 uint mask_len = data.css_cnt;
1006
1007 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1008
1009 if (mask_len > 0)
1010 {
1011 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1012 {
1013 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1014 {
1015 mask_len -= data.salts_buf[0].salt_len;
1016 }
1017 }
1018
1019 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1020
1021 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1022 }
1023
1024 if (data.maskcnt > 1)
1025 {
1026 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1027
1028 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1029 }
1030
1031 log_info ("Input.Mode.....: %s", tmp_buf);
1032 }
1033
1034 tmp_len = 0;
1035 }
1036 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1037 {
1038 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1039 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1040 }
1041 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1042 {
1043 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1044 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1045 }
1046
1047 if (data.digests_cnt == 1)
1048 {
1049 if (data.hash_mode == 2500)
1050 {
1051 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1052
1053 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1054 (char *) data.salts_buf[0].salt_buf,
1055 wpa->orig_mac1[0],
1056 wpa->orig_mac1[1],
1057 wpa->orig_mac1[2],
1058 wpa->orig_mac1[3],
1059 wpa->orig_mac1[4],
1060 wpa->orig_mac1[5],
1061 wpa->orig_mac2[0],
1062 wpa->orig_mac2[1],
1063 wpa->orig_mac2[2],
1064 wpa->orig_mac2[3],
1065 wpa->orig_mac2[4],
1066 wpa->orig_mac2[5]);
1067 }
1068 else if (data.hash_mode == 5200)
1069 {
1070 log_info ("Hash.Target....: File (%s)", data.hashfile);
1071 }
1072 else if (data.hash_mode == 9000)
1073 {
1074 log_info ("Hash.Target....: File (%s)", data.hashfile);
1075 }
1076 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1077 {
1078 log_info ("Hash.Target....: File (%s)", data.hashfile);
1079 }
1080 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1081 {
1082 log_info ("Hash.Target....: File (%s)", data.hashfile);
1083 }
1084 else
1085 {
1086 char out_buf[HCBUFSIZ] = { 0 };
1087
1088 ascii_digest (out_buf, 0, 0);
1089
1090 // limit length
1091 if (strlen (out_buf) > 40)
1092 {
1093 out_buf[41] = '.';
1094 out_buf[42] = '.';
1095 out_buf[43] = '.';
1096 out_buf[44] = 0;
1097 }
1098
1099 log_info ("Hash.Target....: %s", out_buf);
1100 }
1101 }
1102 else
1103 {
1104 if (data.hash_mode == 3000)
1105 {
1106 char out_buf1[32] = { 0 };
1107 char out_buf2[32] = { 0 };
1108
1109 ascii_digest (out_buf1, 0, 0);
1110 ascii_digest (out_buf2, 0, 1);
1111
1112 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1113 }
1114 else
1115 {
1116 log_info ("Hash.Target....: File (%s)", data.hashfile);
1117 }
1118 }
1119
1120 log_info ("Hash.Type......: %s", hash_type);
1121
1122 /**
1123 * speed new
1124 */
1125
1126 u64 speed_cnt[DEVICES_MAX] = { 0 };
1127 double speed_ms[DEVICES_MAX] = { 0 };
1128
1129 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1130 {
1131 hc_device_param_t *device_param = &data.devices_param[device_id];
1132
1133 if (device_param->skipped) continue;
1134
1135 speed_cnt[device_id] = 0;
1136 speed_ms[device_id] = 0;
1137
1138 for (int i = 0; i < SPEED_CACHE; i++)
1139 {
1140 speed_cnt[device_id] += device_param->speed_cnt[i];
1141 speed_ms[device_id] += device_param->speed_ms[i];
1142 }
1143
1144 speed_cnt[device_id] /= SPEED_CACHE;
1145 speed_ms[device_id] /= SPEED_CACHE;
1146 }
1147
1148 double hashes_all_ms = 0;
1149
1150 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1151
1152 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1153 {
1154 hc_device_param_t *device_param = &data.devices_param[device_id];
1155
1156 if (device_param->skipped) continue;
1157
1158 hashes_dev_ms[device_id] = 0;
1159
1160 if (speed_ms[device_id])
1161 {
1162 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1163
1164 hashes_all_ms += hashes_dev_ms[device_id];
1165 }
1166 }
1167
1168 /**
1169 * exec time
1170 */
1171
1172 double exec_all_ms[DEVICES_MAX] = { 0 };
1173
1174 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1175 {
1176 hc_device_param_t *device_param = &data.devices_param[device_id];
1177
1178 if (device_param->skipped) continue;
1179
1180 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1181
1182 exec_all_ms[device_id] = exec_ms_avg;
1183 }
1184
1185 /**
1186 * timers
1187 */
1188
1189 double ms_running = 0;
1190
1191 hc_timer_get (data.timer_running, ms_running);
1192
1193 double ms_paused = data.ms_paused;
1194
1195 if (data.devices_status == STATUS_PAUSED)
1196 {
1197 double ms_paused_tmp = 0;
1198
1199 hc_timer_get (data.timer_paused, ms_paused_tmp);
1200
1201 ms_paused += ms_paused_tmp;
1202 }
1203
1204 #ifdef WIN
1205
1206 __time64_t sec_run = ms_running / 1000;
1207
1208 #else
1209
1210 time_t sec_run = ms_running / 1000;
1211
1212 #endif
1213
1214 if (sec_run)
1215 {
1216 char display_run[32] = { 0 };
1217
1218 struct tm tm_run;
1219
1220 struct tm *tmp = NULL;
1221
1222 #ifdef WIN
1223
1224 tmp = _gmtime64 (&sec_run);
1225
1226 #else
1227
1228 tmp = gmtime (&sec_run);
1229
1230 #endif
1231
1232 if (tmp != NULL)
1233 {
1234 memset (&tm_run, 0, sizeof (tm_run));
1235
1236 memcpy (&tm_run, tmp, sizeof (tm_run));
1237
1238 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1239
1240 char *start = ctime (&data.proc_start);
1241
1242 size_t start_len = strlen (start);
1243
1244 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1245 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1246
1247 log_info ("Time.Started...: %s (%s)", start, display_run);
1248 }
1249 }
1250 else
1251 {
1252 log_info ("Time.Started...: 0 secs");
1253 }
1254
1255 /**
1256 * counters
1257 */
1258
1259 u64 progress_total = data.words_cnt * data.salts_cnt;
1260
1261 u64 all_done = 0;
1262 u64 all_rejected = 0;
1263 u64 all_restored = 0;
1264
1265 u64 progress_noneed = 0;
1266
1267 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1268 {
1269 all_done += data.words_progress_done[salt_pos];
1270 all_rejected += data.words_progress_rejected[salt_pos];
1271 all_restored += data.words_progress_restored[salt_pos];
1272
1273 // Important for ETA only
1274
1275 if (data.salts_shown[salt_pos] == 1)
1276 {
1277 const u64 all = data.words_progress_done[salt_pos]
1278 + data.words_progress_rejected[salt_pos]
1279 + data.words_progress_restored[salt_pos];
1280
1281 const u64 left = data.words_cnt - all;
1282
1283 progress_noneed += left;
1284 }
1285 }
1286
1287 u64 progress_cur = all_restored + all_done + all_rejected;
1288 u64 progress_end = progress_total;
1289
1290 u64 progress_skip = 0;
1291
1292 if (data.skip)
1293 {
1294 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1295
1296 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1297 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1298 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1299 }
1300
1301 if (data.limit)
1302 {
1303 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1304
1305 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1306 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1307 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1308 }
1309
1310 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1311 u64 progress_end_relative_skip = progress_end - progress_skip;
1312
1313 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1314 {
1315 if (data.devices_status != STATUS_CRACKED)
1316 {
1317 #ifdef WIN
1318 __time64_t sec_etc = 0;
1319 #else
1320 time_t sec_etc = 0;
1321 #endif
1322
1323 if (hashes_all_ms)
1324 {
1325 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1326
1327 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1328
1329 sec_etc = ms_left / 1000;
1330 }
1331
1332 if (sec_etc == 0)
1333 {
1334 //log_info ("Time.Estimated.: 0 secs");
1335 }
1336 else if ((u64) sec_etc > ETC_MAX)
1337 {
1338 log_info ("Time.Estimated.: > 10 Years");
1339 }
1340 else
1341 {
1342 char display_etc[32] = { 0 };
1343
1344 struct tm tm_etc;
1345
1346 struct tm *tmp = NULL;
1347
1348 #ifdef WIN
1349
1350 tmp = _gmtime64 (&sec_etc);
1351
1352 #else
1353
1354 tmp = gmtime (&sec_etc);
1355
1356 #endif
1357
1358 if (tmp != NULL)
1359 {
1360 memset (&tm_etc, 0, sizeof (tm_etc));
1361
1362 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1363
1364 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1365
1366 time_t now;
1367
1368 time (&now);
1369
1370 now += sec_etc;
1371
1372 char *etc = ctime (&now);
1373
1374 size_t etc_len = strlen (etc);
1375
1376 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1377 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1378
1379 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1380 }
1381 }
1382 }
1383 }
1384
1385 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1386 {
1387 hc_device_param_t *device_param = &data.devices_param[device_id];
1388
1389 if (device_param->skipped) continue;
1390
1391 char display_dev_cur[16] = { 0 };
1392
1393 strncpy (display_dev_cur, "0.00", 4);
1394
1395 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1396
1397 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1398 }
1399
1400 char display_all_cur[16] = { 0 };
1401
1402 strncpy (display_all_cur, "0.00", 4);
1403
1404 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1405
1406 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1407
1408 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1409 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1410
1411 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1412
1413 // crack-per-time
1414
1415 if (data.digests_cnt > 100)
1416 {
1417 time_t now = time (NULL);
1418
1419 int cpt_cur_min = 0;
1420 int cpt_cur_hour = 0;
1421 int cpt_cur_day = 0;
1422
1423 for (int i = 0; i < CPT_BUF; i++)
1424 {
1425 const uint cracked = data.cpt_buf[i].cracked;
1426 const time_t timestamp = data.cpt_buf[i].timestamp;
1427
1428 if ((timestamp + 60) > now)
1429 {
1430 cpt_cur_min += cracked;
1431 }
1432
1433 if ((timestamp + 3600) > now)
1434 {
1435 cpt_cur_hour += cracked;
1436 }
1437
1438 if ((timestamp + 86400) > now)
1439 {
1440 cpt_cur_day += cracked;
1441 }
1442 }
1443
1444 double ms_real = ms_running - ms_paused;
1445
1446 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1447 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1448 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1449
1450 if ((data.cpt_start + 86400) < now)
1451 {
1452 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1453 cpt_cur_min,
1454 cpt_cur_hour,
1455 cpt_cur_day,
1456 cpt_avg_min,
1457 cpt_avg_hour,
1458 cpt_avg_day);
1459 }
1460 else if ((data.cpt_start + 3600) < now)
1461 {
1462 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1463 cpt_cur_min,
1464 cpt_cur_hour,
1465 cpt_avg_min,
1466 cpt_avg_hour,
1467 cpt_avg_day);
1468 }
1469 else if ((data.cpt_start + 60) < now)
1470 {
1471 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1472 cpt_cur_min,
1473 cpt_avg_min,
1474 cpt_avg_hour,
1475 cpt_avg_day);
1476 }
1477 else
1478 {
1479 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1480 cpt_avg_min,
1481 cpt_avg_hour,
1482 cpt_avg_day);
1483 }
1484 }
1485
1486 // Restore point
1487
1488 u64 restore_point = get_lowest_words_done ();
1489
1490 u64 restore_total = data.words_base;
1491
1492 float percent_restore = 0;
1493
1494 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1495
1496 if (progress_end_relative_skip)
1497 {
1498 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1499 {
1500 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1501 float percent_rejected = 0.0;
1502
1503 if (progress_cur)
1504 {
1505 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1506 }
1507
1508 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1509 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1510
1511 if (data.restore_disable == 0)
1512 {
1513 if (percent_finished != 1)
1514 {
1515 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1516 }
1517 }
1518 }
1519 }
1520 else
1521 {
1522 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1523 {
1524 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1525 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1526
1527 if (data.restore_disable == 0)
1528 {
1529 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1530 }
1531 }
1532 else
1533 {
1534 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1535 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1536
1537 // --restore not allowed if stdin is used -- really? why?
1538
1539 //if (data.restore_disable == 0)
1540 //{
1541 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1542 //}
1543 }
1544 }
1545
1546 #ifdef HAVE_HWMON
1547
1548 if (data.devices_status == STATUS_EXHAUSTED) return;
1549 if (data.devices_status == STATUS_CRACKED) return;
1550 if (data.devices_status == STATUS_ABORTED) return;
1551 if (data.devices_status == STATUS_QUIT) return;
1552
1553 if (data.gpu_temp_disable == 0)
1554 {
1555 hc_thread_mutex_lock (mux_adl);
1556
1557 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1558 {
1559 hc_device_param_t *device_param = &data.devices_param[device_id];
1560
1561 if (device_param->skipped) continue;
1562
1563 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1564 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1565 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1566 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1567 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1568 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1569 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1570
1571 char output_buf[256] = { 0 };
1572
1573 int output_len = 0;
1574
1575 if (num_temperature >= 0)
1576 {
1577 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1578
1579 output_len = strlen (output_buf);
1580 }
1581
1582 if (num_fanspeed >= 0)
1583 {
1584 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1585
1586 output_len = strlen (output_buf);
1587 }
1588
1589 if (num_utilization >= 0)
1590 {
1591 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1592
1593 output_len = strlen (output_buf);
1594 }
1595
1596 if (num_corespeed >= 0)
1597 {
1598 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1599
1600 output_len = strlen (output_buf);
1601 }
1602
1603 if (num_memoryspeed >= 0)
1604 {
1605 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1606
1607 output_len = strlen (output_buf);
1608 }
1609
1610 if (num_buslanes >= 0)
1611 {
1612 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1613
1614 output_len = strlen (output_buf);
1615 }
1616
1617 if (num_throttle == 1)
1618 {
1619 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1620
1621 output_len = strlen (output_buf);
1622 }
1623
1624 if (output_len == 0)
1625 {
1626 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1627
1628 output_len = strlen (output_buf);
1629 }
1630
1631 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1632 }
1633
1634 hc_thread_mutex_unlock (mux_adl);
1635 }
1636
1637 #endif // HAVE_HWMON
1638 }
1639
1640 static void status_benchmark_automate ()
1641 {
1642 u64 speed_cnt[DEVICES_MAX] = { 0 };
1643 double speed_ms[DEVICES_MAX] = { 0 };
1644
1645 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1646 {
1647 hc_device_param_t *device_param = &data.devices_param[device_id];
1648
1649 if (device_param->skipped) continue;
1650
1651 speed_cnt[device_id] = device_param->speed_cnt[0];
1652 speed_ms[device_id] = device_param->speed_ms[0];
1653 }
1654
1655 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1656
1657 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1658 {
1659 hc_device_param_t *device_param = &data.devices_param[device_id];
1660
1661 if (device_param->skipped) continue;
1662
1663 hashes_dev_ms[device_id] = 0;
1664
1665 if (speed_ms[device_id])
1666 {
1667 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1668 }
1669 }
1670
1671 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1672 {
1673 hc_device_param_t *device_param = &data.devices_param[device_id];
1674
1675 if (device_param->skipped) continue;
1676
1677 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1678 }
1679 }
1680
1681 static void status_benchmark ()
1682 {
1683 if (data.devices_status == STATUS_INIT) return;
1684 if (data.devices_status == STATUS_STARTING) return;
1685 if (data.devices_status == STATUS_BYPASS) return;
1686
1687 if (data.machine_readable == 1)
1688 {
1689 status_benchmark_automate ();
1690
1691 return;
1692 }
1693
1694 u64 speed_cnt[DEVICES_MAX] = { 0 };
1695 double speed_ms[DEVICES_MAX] = { 0 };
1696
1697 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1698 {
1699 hc_device_param_t *device_param = &data.devices_param[device_id];
1700
1701 if (device_param->skipped) continue;
1702
1703 speed_cnt[device_id] = device_param->speed_cnt[0];
1704 speed_ms[device_id] = device_param->speed_ms[0];
1705 }
1706
1707 double hashes_all_ms = 0;
1708
1709 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1710
1711 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1712 {
1713 hc_device_param_t *device_param = &data.devices_param[device_id];
1714
1715 if (device_param->skipped) continue;
1716
1717 hashes_dev_ms[device_id] = 0;
1718
1719 if (speed_ms[device_id])
1720 {
1721 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1722
1723 hashes_all_ms += hashes_dev_ms[device_id];
1724 }
1725 }
1726
1727 /**
1728 * exec time
1729 */
1730
1731 double exec_all_ms[DEVICES_MAX] = { 0 };
1732
1733 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1734 {
1735 hc_device_param_t *device_param = &data.devices_param[device_id];
1736
1737 if (device_param->skipped) continue;
1738
1739 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1740
1741 exec_all_ms[device_id] = exec_ms_avg;
1742 }
1743
1744 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1745 {
1746 hc_device_param_t *device_param = &data.devices_param[device_id];
1747
1748 if (device_param->skipped) continue;
1749
1750 char display_dev_cur[16] = { 0 };
1751
1752 strncpy (display_dev_cur, "0.00", 4);
1753
1754 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1755
1756 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1757 }
1758
1759 char display_all_cur[16] = { 0 };
1760
1761 strncpy (display_all_cur, "0.00", 4);
1762
1763 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1764
1765 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1766 }
1767
1768 /**
1769 * hashcat -only- functions
1770 */
1771
1772 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1773 {
1774 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1775 {
1776 if (attack_kern == ATTACK_KERN_STRAIGHT)
1777 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1778 else if (attack_kern == ATTACK_KERN_COMBI)
1779 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1780 else if (attack_kern == ATTACK_KERN_BF)
1781 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1782 }
1783 else
1784 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1785 }
1786
1787 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1788 {
1789 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1790 {
1791 if (attack_kern == ATTACK_KERN_STRAIGHT)
1792 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1793 else if (attack_kern == ATTACK_KERN_COMBI)
1794 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1795 else if (attack_kern == ATTACK_KERN_BF)
1796 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1797 }
1798 else
1799 {
1800 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1801 }
1802 }
1803
1804 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1805 {
1806 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1807 {
1808 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1809 }
1810 else
1811 {
1812 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1813 }
1814 }
1815
1816 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1817 {
1818 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1819 {
1820 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1821 }
1822 else
1823 {
1824 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1825 }
1826 }
1827
1828 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1829 {
1830 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1831 }
1832
1833 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1834 {
1835 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1836 }
1837
1838 static char *filename_from_filepath (char *filepath)
1839 {
1840 char *ptr = NULL;
1841
1842 if ((ptr = strrchr (filepath, '/')) != NULL)
1843 {
1844 ptr++;
1845 }
1846 else if ((ptr = strrchr (filepath, '\\')) != NULL)
1847 {
1848 ptr++;
1849 }
1850 else
1851 {
1852 ptr = filepath;
1853 }
1854
1855 return ptr;
1856 }
1857
1858 static uint convert_from_hex (char *line_buf, const uint line_len)
1859 {
1860 if (line_len & 1) return (line_len); // not in hex
1861
1862 if (data.hex_wordlist == 1)
1863 {
1864 uint i;
1865 uint j;
1866
1867 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1868 {
1869 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1870 }
1871
1872 memset (line_buf + i, 0, line_len - i);
1873
1874 return (i);
1875 }
1876 else if (line_len >= 6) // $HEX[] = 6
1877 {
1878 if (line_buf[0] != '$') return (line_len);
1879 if (line_buf[1] != 'H') return (line_len);
1880 if (line_buf[2] != 'E') return (line_len);
1881 if (line_buf[3] != 'X') return (line_len);
1882 if (line_buf[4] != '[') return (line_len);
1883 if (line_buf[line_len - 1] != ']') return (line_len);
1884
1885 uint i;
1886 uint j;
1887
1888 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1889 {
1890 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1891 }
1892
1893 memset (line_buf + i, 0, line_len - i);
1894
1895 return (i);
1896 }
1897
1898 return (line_len);
1899 }
1900
1901 static void clear_prompt ()
1902 {
1903 fputc ('\r', stdout);
1904
1905 for (size_t i = 0; i < strlen (PROMPT); i++)
1906 {
1907 fputc (' ', stdout);
1908 }
1909
1910 fputc ('\r', stdout);
1911
1912 fflush (stdout);
1913 }
1914
1915 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1916 {
1917 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);
1918 }
1919
1920 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1921 {
1922 char *outfile = data.outfile;
1923 uint quiet = data.quiet;
1924 FILE *pot_fp = data.pot_fp;
1925 uint loopback = data.loopback;
1926 uint debug_mode = data.debug_mode;
1927 char *debug_file = data.debug_file;
1928
1929 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1930 int debug_rule_len = 0; // -1 error
1931 uint debug_plain_len = 0;
1932
1933 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1934
1935 // hash
1936
1937 char out_buf[HCBUFSIZ] = { 0 };
1938
1939 const u32 salt_pos = plain->salt_pos;
1940 const u32 digest_pos = plain->digest_pos; // relative
1941 const u32 gidvid = plain->gidvid;
1942 const u32 il_pos = plain->il_pos;
1943
1944 ascii_digest (out_buf, salt_pos, digest_pos);
1945
1946 // plain
1947
1948 u64 crackpos = device_param->words_off;
1949
1950 uint plain_buf[16] = { 0 };
1951
1952 u8 *plain_ptr = (u8 *) plain_buf;
1953
1954 unsigned int plain_len = 0;
1955
1956 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1957 {
1958 pw_t pw;
1959
1960 gidd_to_pw_t (device_param, gidvid, &pw);
1961
1962 for (int i = 0; i < 16; i++)
1963 {
1964 plain_buf[i] = pw.i[i];
1965 }
1966
1967 plain_len = pw.pw_len;
1968
1969 const uint off = device_param->innerloop_pos + il_pos;
1970
1971 if (debug_mode > 0)
1972 {
1973 debug_rule_len = 0;
1974
1975 // save rule
1976 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1977 {
1978 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1979
1980 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1981 }
1982
1983 // save plain
1984 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1985 {
1986 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1987
1988 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1989
1990 debug_plain_len = plain_len;
1991 }
1992 }
1993
1994 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1995
1996 crackpos += gidvid;
1997 crackpos *= data.kernel_rules_cnt;
1998 crackpos += device_param->innerloop_pos + il_pos;
1999
2000 if (plain_len > data.pw_max) plain_len = data.pw_max;
2001 }
2002 else if (data.attack_mode == ATTACK_MODE_COMBI)
2003 {
2004 pw_t pw;
2005
2006 gidd_to_pw_t (device_param, gidvid, &pw);
2007
2008 for (int i = 0; i < 16; i++)
2009 {
2010 plain_buf[i] = pw.i[i];
2011 }
2012
2013 plain_len = pw.pw_len;
2014
2015 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2016 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2017
2018 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2019 {
2020 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2021 }
2022 else
2023 {
2024 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2025
2026 memcpy (plain_ptr, comb_buf, comb_len);
2027 }
2028
2029 plain_len += comb_len;
2030
2031 crackpos += gidvid;
2032 crackpos *= data.combs_cnt;
2033 crackpos += device_param->innerloop_pos + il_pos;
2034
2035 if (data.pw_max != PW_DICTMAX1)
2036 {
2037 if (plain_len > data.pw_max) plain_len = data.pw_max;
2038 }
2039 }
2040 else if (data.attack_mode == ATTACK_MODE_BF)
2041 {
2042 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2043 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2044
2045 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2046 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2047
2048 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2049 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2050
2051 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2052 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2053
2054 plain_len = data.css_cnt;
2055
2056 crackpos += gidvid;
2057 crackpos *= data.bfs_cnt;
2058 crackpos += device_param->innerloop_pos + il_pos;
2059 }
2060 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2061 {
2062 pw_t pw;
2063
2064 gidd_to_pw_t (device_param, gidvid, &pw);
2065
2066 for (int i = 0; i < 16; i++)
2067 {
2068 plain_buf[i] = pw.i[i];
2069 }
2070
2071 plain_len = pw.pw_len;
2072
2073 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2074
2075 uint start = 0;
2076 uint stop = device_param->kernel_params_mp_buf32[4];
2077
2078 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2079
2080 plain_len += start + stop;
2081
2082 crackpos += gidvid;
2083 crackpos *= data.combs_cnt;
2084 crackpos += device_param->innerloop_pos + il_pos;
2085
2086 if (data.pw_max != PW_DICTMAX1)
2087 {
2088 if (plain_len > data.pw_max) plain_len = data.pw_max;
2089 }
2090 }
2091 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2092 {
2093 pw_t pw;
2094
2095 gidd_to_pw_t (device_param, gidvid, &pw);
2096
2097 for (int i = 0; i < 16; i++)
2098 {
2099 plain_buf[i] = pw.i[i];
2100 }
2101
2102 plain_len = pw.pw_len;
2103
2104 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2105
2106 uint start = 0;
2107 uint stop = device_param->kernel_params_mp_buf32[4];
2108
2109 memmove (plain_ptr + stop, plain_ptr, plain_len);
2110
2111 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2112
2113 plain_len += start + stop;
2114
2115 crackpos += gidvid;
2116 crackpos *= data.combs_cnt;
2117 crackpos += device_param->innerloop_pos + il_pos;
2118
2119 if (data.pw_max != PW_DICTMAX1)
2120 {
2121 if (plain_len > data.pw_max) plain_len = data.pw_max;
2122 }
2123 }
2124
2125 if (data.attack_mode == ATTACK_MODE_BF)
2126 {
2127 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2128 {
2129 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2130 {
2131 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2132 {
2133 plain_len = plain_len - data.salts_buf[0].salt_len;
2134 }
2135 }
2136
2137 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2138 {
2139 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2140 {
2141 plain_ptr[j] = plain_ptr[i];
2142 }
2143
2144 plain_len = plain_len / 2;
2145 }
2146 }
2147 }
2148
2149 // if enabled, update also the potfile
2150
2151 if (pot_fp)
2152 {
2153 lock_file (pot_fp);
2154
2155 fprintf (pot_fp, "%s:", out_buf);
2156
2157 format_plain (pot_fp, plain_ptr, plain_len, 1);
2158
2159 fputc ('\n', pot_fp);
2160
2161 fflush (pot_fp);
2162
2163 unlock_file (pot_fp);
2164 }
2165
2166 // outfile
2167
2168 FILE *out_fp = NULL;
2169
2170 if (outfile != NULL)
2171 {
2172 if ((out_fp = fopen (outfile, "ab")) == NULL)
2173 {
2174 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2175
2176 out_fp = stdout;
2177 }
2178
2179 lock_file (out_fp);
2180 }
2181 else
2182 {
2183 out_fp = stdout;
2184
2185 if (quiet == 0) clear_prompt ();
2186 }
2187
2188 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2189
2190 if (outfile != NULL)
2191 {
2192 if (out_fp != stdout)
2193 {
2194 fclose (out_fp);
2195 }
2196 }
2197 else
2198 {
2199 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2200 {
2201 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2202 {
2203 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2204 if (quiet == 0) fflush (stdout);
2205 }
2206 }
2207 }
2208
2209 // loopback
2210
2211 if (loopback)
2212 {
2213 char *loopback_file = data.loopback_file;
2214
2215 FILE *fb_fp = NULL;
2216
2217 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2218 {
2219 lock_file (fb_fp);
2220
2221 format_plain (fb_fp, plain_ptr, plain_len, 1);
2222
2223 fputc ('\n', fb_fp);
2224
2225 fclose (fb_fp);
2226 }
2227 }
2228
2229 // (rule) debug mode
2230
2231 // the next check implies that:
2232 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2233 // - debug_mode > 0
2234
2235 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2236 {
2237 if (debug_rule_len < 0) debug_rule_len = 0;
2238
2239 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2240
2241 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2242
2243 if ((quiet == 0) && (debug_file == NULL))
2244 {
2245 fprintf (stdout, "%s", PROMPT);
2246
2247 fflush (stdout);
2248 }
2249 }
2250 }
2251
2252 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2253 {
2254 salt_t *salt_buf = &data.salts_buf[salt_pos];
2255
2256 u32 num_cracked;
2257
2258 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2259
2260 if (num_cracked)
2261 {
2262 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2263
2264 log_info_nn ("");
2265
2266 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2267
2268 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);
2269
2270 uint cpt_cracked = 0;
2271
2272 for (uint i = 0; i < num_cracked; i++)
2273 {
2274 const uint hash_pos = cracked[i].hash_pos;
2275
2276 if (data.digests_shown[hash_pos] == 1) continue;
2277
2278 hc_thread_mutex_lock (mux_display);
2279
2280 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2281 {
2282 data.digests_shown[hash_pos] = 1;
2283
2284 data.digests_done++;
2285
2286 cpt_cracked++;
2287
2288 salt_buf->digests_done++;
2289
2290 if (salt_buf->digests_done == salt_buf->digests_cnt)
2291 {
2292 data.salts_shown[salt_pos] = 1;
2293
2294 data.salts_done++;
2295 }
2296 }
2297
2298 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2299
2300 hc_thread_mutex_unlock (mux_display);
2301
2302 check_hash (device_param, &cracked[i]);
2303 }
2304
2305 myfree (cracked);
2306
2307 if (cpt_cracked > 0)
2308 {
2309 hc_thread_mutex_lock (mux_display);
2310
2311 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2312 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2313
2314 data.cpt_pos++;
2315
2316 data.cpt_total += cpt_cracked;
2317
2318 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2319
2320 hc_thread_mutex_unlock (mux_display);
2321 }
2322
2323 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2324 {
2325 // we need to reset cracked state on the device
2326 // otherwise host thinks again and again the hash was cracked
2327 // and returns invalid password each time
2328
2329 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2330
2331 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);
2332 }
2333
2334 num_cracked = 0;
2335
2336 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2337 }
2338 }
2339
2340 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2341 {
2342 char out_buf[HCBUFSIZ] = { 0 };
2343
2344 uint plain_buf[16] = { 0 };
2345
2346 u8 *plain_ptr = (u8 *) plain_buf;
2347
2348 uint plain_len = 0;
2349
2350 const uint il_cnt = device_param->kernel_params_buf32[27]; // ugly, i know
2351
2352 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2353 {
2354 pw_t pw;
2355
2356 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2357 {
2358 gidd_to_pw_t (device_param, gidvid, &pw);
2359
2360 const uint pos = device_param->innerloop_pos;
2361
2362 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2363 {
2364 for (int i = 0; i < 8; i++)
2365 {
2366 plain_buf[i] = pw.i[i];
2367 }
2368
2369 plain_len = pw.pw_len;
2370
2371 plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2372
2373 if (plain_len > data.pw_max) plain_len = data.pw_max;
2374
2375 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2376 }
2377 }
2378 }
2379 else if (data.attack_mode == ATTACK_MODE_COMBI)
2380 {
2381 pw_t pw;
2382
2383 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2384 {
2385 gidd_to_pw_t (device_param, gidvid, &pw);
2386
2387 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2388 {
2389 for (int i = 0; i < 8; i++)
2390 {
2391 plain_buf[i] = pw.i[i];
2392 }
2393
2394 plain_len = pw.pw_len;
2395
2396 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2397 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2398
2399 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2400 {
2401 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2402 }
2403 else
2404 {
2405 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2406
2407 memcpy (plain_ptr, comb_buf, comb_len);
2408 }
2409
2410 plain_len += comb_len;
2411
2412 if (data.pw_max != PW_DICTMAX1)
2413 {
2414 if (plain_len > data.pw_max) plain_len = data.pw_max;
2415 }
2416
2417 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2418 }
2419 }
2420 }
2421 else if (data.attack_mode == ATTACK_MODE_BF)
2422 {
2423 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2424 {
2425 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2426 {
2427 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2428 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2429
2430 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2431 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2432
2433 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2434 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2435
2436 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2437 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2438
2439 plain_len = data.css_cnt;
2440
2441 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2442 }
2443 }
2444 }
2445 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2446 {
2447 pw_t pw;
2448
2449 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2450 {
2451 gidd_to_pw_t (device_param, gidvid, &pw);
2452
2453 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2454 {
2455 for (int i = 0; i < 8; i++)
2456 {
2457 plain_buf[i] = pw.i[i];
2458 }
2459
2460 plain_len = pw.pw_len;
2461
2462 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2463
2464 uint start = 0;
2465 uint stop = device_param->kernel_params_mp_buf32[4];
2466
2467 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2468
2469 plain_len += start + stop;
2470
2471 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2472 }
2473 }
2474 }
2475 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2476 {
2477 pw_t pw;
2478
2479 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2480 {
2481 gidd_to_pw_t (device_param, gidvid, &pw);
2482
2483 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2484 {
2485 for (int i = 0; i < 8; i++)
2486 {
2487 plain_buf[i] = pw.i[i];
2488 }
2489
2490 plain_len = pw.pw_len;
2491
2492 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2493
2494 uint start = 0;
2495 uint stop = device_param->kernel_params_mp_buf32[4];
2496
2497 memmove (plain_ptr + stop, plain_ptr, plain_len);
2498
2499 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2500
2501 plain_len += start + stop;
2502
2503 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2504 }
2505 }
2506 }
2507 }
2508
2509 static void save_hash ()
2510 {
2511 char *hashfile = data.hashfile;
2512
2513 char new_hashfile[256] = { 0 };
2514 char old_hashfile[256] = { 0 };
2515
2516 snprintf (new_hashfile, 255, "%s.new", hashfile);
2517 snprintf (old_hashfile, 255, "%s.old", hashfile);
2518
2519 unlink (new_hashfile);
2520
2521 char separator = data.separator;
2522
2523 FILE *fp = fopen (new_hashfile, "wb");
2524
2525 if (fp == NULL)
2526 {
2527 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2528
2529 exit (-1);
2530 }
2531
2532 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2533 {
2534 if (data.salts_shown[salt_pos] == 1) continue;
2535
2536 salt_t *salt_buf = &data.salts_buf[salt_pos];
2537
2538 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2539 {
2540 uint idx = salt_buf->digests_offset + digest_pos;
2541
2542 if (data.digests_shown[idx] == 1) continue;
2543
2544 if (data.hash_mode != 2500)
2545 {
2546 if (data.username == 1)
2547 {
2548 user_t *user = data.hash_info[idx]->user;
2549
2550 uint i;
2551
2552 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2553
2554 fputc (separator, fp);
2555 }
2556
2557 char out_buf[HCBUFSIZ]; // scratch buffer
2558
2559 out_buf[0] = 0;
2560
2561 ascii_digest (out_buf, salt_pos, digest_pos);
2562
2563 fputs (out_buf, fp);
2564
2565 fputc ('\n', fp);
2566 }
2567 else
2568 {
2569 hccap_t hccap;
2570
2571 to_hccap_t (&hccap, salt_pos, digest_pos);
2572
2573 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2574 }
2575 }
2576 }
2577
2578 fflush (fp);
2579
2580 fclose (fp);
2581
2582 unlink (old_hashfile);
2583
2584 if (rename (hashfile, old_hashfile) != 0)
2585 {
2586 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2587
2588 exit (-1);
2589 }
2590
2591 unlink (hashfile);
2592
2593 if (rename (new_hashfile, hashfile) != 0)
2594 {
2595 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2596
2597 exit (-1);
2598 }
2599
2600 unlink (old_hashfile);
2601 }
2602
2603 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2604 {
2605 uint num_elements = num;
2606
2607 device_param->kernel_params_buf32[30] = data.combs_mode;
2608 device_param->kernel_params_buf32[31] = num;
2609
2610 uint kernel_threads = device_param->kernel_threads;
2611
2612 while (num_elements % kernel_threads) num_elements++;
2613
2614 cl_kernel kernel = NULL;
2615
2616 switch (kern_run)
2617 {
2618 case KERN_RUN_1: kernel = device_param->kernel1; break;
2619 case KERN_RUN_12: kernel = device_param->kernel12; break;
2620 case KERN_RUN_2: kernel = device_param->kernel2; break;
2621 case KERN_RUN_23: kernel = device_param->kernel23; break;
2622 case KERN_RUN_3: kernel = device_param->kernel3; break;
2623 }
2624
2625 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2626 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2627 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2628 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2629 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2630 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2631 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2632 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2633 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2634 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2635 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2636
2637 cl_event event;
2638
2639 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2640 {
2641 const size_t global_work_size[3] = { num_elements, 32, 1 };
2642 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2643
2644 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2645 }
2646 else
2647 {
2648 if (kern_run == KERN_RUN_2)
2649 {
2650 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2651 {
2652 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2653 }
2654 }
2655
2656 while (num_elements % kernel_threads) num_elements++;
2657
2658 const size_t global_work_size[3] = { num_elements, 1, 1 };
2659 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2660
2661 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2662 }
2663
2664 hc_clFlush (data.ocl, device_param->command_queue);
2665
2666 if (device_param->nvidia_spin_damp)
2667 {
2668 if (data.devices_status == STATUS_RUNNING)
2669 {
2670 if (iteration < EXPECTED_ITERATIONS)
2671 {
2672 switch (kern_run)
2673 {
2674 case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration] * device_param->nvidia_spin_damp); break;
2675 case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration] * device_param->nvidia_spin_damp); break;
2676 case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration] * device_param->nvidia_spin_damp); break;
2677 }
2678 }
2679 }
2680 }
2681
2682 hc_clWaitForEvents (data.ocl, 1, &event);
2683
2684 cl_ulong time_start;
2685 cl_ulong time_end;
2686
2687 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2688 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2689
2690 const double exec_us = (double) (time_end - time_start) / 1000;
2691
2692 if (data.devices_status == STATUS_RUNNING)
2693 {
2694 if (iteration < EXPECTED_ITERATIONS)
2695 {
2696 switch (kern_run)
2697 {
2698 case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2699 case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2700 case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2701 }
2702 }
2703 }
2704
2705 if (event_update)
2706 {
2707 uint exec_pos = device_param->exec_pos;
2708
2709 device_param->exec_ms[exec_pos] = exec_us / 1000;
2710
2711 exec_pos++;
2712
2713 if (exec_pos == EXEC_CACHE)
2714 {
2715 exec_pos = 0;
2716 }
2717
2718 device_param->exec_pos = exec_pos;
2719 }
2720
2721 hc_clReleaseEvent (data.ocl, event);
2722
2723 hc_clFinish (data.ocl, device_param->command_queue);
2724 }
2725
2726 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2727 {
2728 uint num_elements = num;
2729
2730 switch (kern_run)
2731 {
2732 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2733 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2734 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2735 }
2736
2737 // causes problems with special threads like in bcrypt
2738 // const uint kernel_threads = device_param->kernel_threads;
2739
2740 uint kernel_threads = device_param->kernel_threads;
2741
2742 while (num_elements % kernel_threads) num_elements++;
2743
2744 cl_kernel kernel = NULL;
2745
2746 switch (kern_run)
2747 {
2748 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2749 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2750 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2751 }
2752
2753 switch (kern_run)
2754 {
2755 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2756 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2757 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2758 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2759 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2760 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2761 break;
2762 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2763 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2764 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2765 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2766 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2767 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2768 break;
2769 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2770 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2771 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2772 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2773 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2774 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2775 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2776 break;
2777 }
2778
2779 const size_t global_work_size[3] = { num_elements, 1, 1 };
2780 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2781
2782 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2783
2784 hc_clFlush (data.ocl, device_param->command_queue);
2785
2786 hc_clFinish (data.ocl, device_param->command_queue);
2787 }
2788
2789 static void run_kernel_tm (hc_device_param_t *device_param)
2790 {
2791 const uint num_elements = 1024; // fixed
2792
2793 uint kernel_threads = 32;
2794
2795 cl_kernel kernel = device_param->kernel_tm;
2796
2797 const size_t global_work_size[3] = { num_elements, 1, 1 };
2798 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2799
2800 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2801
2802 hc_clFlush (data.ocl, device_param->command_queue);
2803
2804 hc_clFinish (data.ocl, device_param->command_queue);
2805 }
2806
2807 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2808 {
2809 uint num_elements = num;
2810
2811 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2812 device_param->kernel_params_amp_buf32[6] = num_elements;
2813
2814 // causes problems with special threads like in bcrypt
2815 // const uint kernel_threads = device_param->kernel_threads;
2816
2817 uint kernel_threads = device_param->kernel_threads;
2818
2819 while (num_elements % kernel_threads) num_elements++;
2820
2821 cl_kernel kernel = device_param->kernel_amp;
2822
2823 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2824 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2825
2826 const size_t global_work_size[3] = { num_elements, 1, 1 };
2827 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2828
2829 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2830
2831 hc_clFlush (data.ocl, device_param->command_queue);
2832
2833 hc_clFinish (data.ocl, device_param->command_queue);
2834 }
2835
2836 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2837 {
2838 const u32 num16d = num / 16;
2839 const u32 num16m = num % 16;
2840
2841 if (num16d)
2842 {
2843 device_param->kernel_params_memset_buf32[1] = value;
2844 device_param->kernel_params_memset_buf32[2] = num16d;
2845
2846 uint kernel_threads = device_param->kernel_threads;
2847
2848 uint num_elements = num16d;
2849
2850 while (num_elements % kernel_threads) num_elements++;
2851
2852 cl_kernel kernel = device_param->kernel_memset;
2853
2854 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2855 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2856 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2857
2858 const size_t global_work_size[3] = { num_elements, 1, 1 };
2859 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2860
2861 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2862
2863 hc_clFlush (data.ocl, device_param->command_queue);
2864
2865 hc_clFinish (data.ocl, device_param->command_queue);
2866 }
2867
2868 if (num16m)
2869 {
2870 u32 tmp[4];
2871
2872 tmp[0] = value;
2873 tmp[1] = value;
2874 tmp[2] = value;
2875 tmp[3] = value;
2876
2877 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2878 }
2879 }
2880
2881 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2882 {
2883 run_kernel_memset (device_param, buf, 0, size);
2884
2885 /*
2886 int rc = -1;
2887
2888 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2889 {
2890 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2891
2892 const cl_uchar zero = 0;
2893
2894 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2895 }
2896
2897 if (rc != 0)
2898 {
2899 // NOTE: clEnqueueFillBuffer () always fails with -59
2900 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2901 // How's that possible, OpenCL 1.2 support is advertised??
2902 // We need to workaround...
2903
2904 #define FILLSZ 0x100000
2905
2906 char *tmp = (char *) mymalloc (FILLSZ);
2907
2908 for (size_t i = 0; i < size; i += FILLSZ)
2909 {
2910 const size_t left = size - i;
2911
2912 const size_t fillsz = MIN (FILLSZ, left);
2913
2914 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2915 }
2916
2917 myfree (tmp);
2918 }
2919 */
2920 }
2921
2922 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)
2923 {
2924 if (data.hash_mode == 2000)
2925 {
2926 process_stdout (device_param, pws_cnt);
2927
2928 return;
2929 }
2930
2931 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2932 {
2933 if (attack_mode == ATTACK_MODE_BF)
2934 {
2935 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2936 {
2937 const uint size_tm = 32 * sizeof (bs_word_t);
2938
2939 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2940
2941 run_kernel_tm (device_param);
2942
2943 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);
2944 }
2945 }
2946
2947 if (highest_pw_len < 16)
2948 {
2949 run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
2950 }
2951 else if (highest_pw_len < 32)
2952 {
2953 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
2954 }
2955 else
2956 {
2957 run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
2958 }
2959 }
2960 else
2961 {
2962 run_kernel_amp (device_param, pws_cnt);
2963
2964 run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
2965
2966 if (opts_type & OPTS_TYPE_HOOK12)
2967 {
2968 run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
2969
2970 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);
2971
2972 // do something with data
2973
2974 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);
2975 }
2976
2977 uint iter = salt_buf->salt_iter;
2978
2979 uint loop_step = device_param->kernel_loops;
2980
2981 for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
2982 {
2983 uint loop_left = iter - loop_pos;
2984
2985 loop_left = MIN (loop_left, loop_step);
2986
2987 device_param->kernel_params_buf32[25] = loop_pos;
2988 device_param->kernel_params_buf32[26] = loop_left;
2989
2990 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
2991
2992 if (data.devices_status == STATUS_CRACKED) break;
2993 if (data.devices_status == STATUS_ABORTED) break;
2994 if (data.devices_status == STATUS_QUIT) break;
2995
2996 /**
2997 * speed
2998 */
2999
3000 const float iter_part = (float) (loop_pos + loop_left) / iter;
3001
3002 const u64 perf_sum_all = pws_cnt * iter_part;
3003
3004 double speed_ms;
3005
3006 hc_timer_get (device_param->timer_speed, speed_ms);
3007
3008 const u32 speed_pos = device_param->speed_pos;
3009
3010 device_param->speed_cnt[speed_pos] = perf_sum_all;
3011
3012 device_param->speed_ms[speed_pos] = speed_ms;
3013
3014 if (data.benchmark == 1)
3015 {
3016 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
3017 }
3018 }
3019
3020 if (opts_type & OPTS_TYPE_HOOK23)
3021 {
3022 run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
3023
3024 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);
3025
3026 // do something with data
3027
3028 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);
3029 }
3030
3031 run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3032 }
3033 }
3034
3035 static int run_rule_engine (const int rule_len, const char *rule_buf)
3036 {
3037 if (rule_len == 0)
3038 {
3039 return 0;
3040 }
3041 else if (rule_len == 1)
3042 {
3043 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3044 }
3045
3046 return 1;
3047 }
3048
3049 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3050 {
3051 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3052 {
3053 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);
3054 }
3055 else if (data.attack_kern == ATTACK_KERN_COMBI)
3056 {
3057 if (data.attack_mode == ATTACK_MODE_COMBI)
3058 {
3059 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3060 {
3061 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3062 {
3063 for (u32 i = 0; i < pws_cnt; i++)
3064 {
3065 const u32 pw_len = device_param->pws_buf[i].pw_len;
3066
3067 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3068
3069 ptr[pw_len] = 0x01;
3070 }
3071 }
3072 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3073 {
3074 for (u32 i = 0; i < pws_cnt; i++)
3075 {
3076 const u32 pw_len = device_param->pws_buf[i].pw_len;
3077
3078 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3079
3080 ptr[pw_len] = 0x80;
3081 }
3082 }
3083 }
3084 }
3085 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3086 {
3087 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3088 {
3089 for (u32 i = 0; i < pws_cnt; i++)
3090 {
3091 const u32 pw_len = device_param->pws_buf[i].pw_len;
3092
3093 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3094
3095 ptr[pw_len] = 0x01;
3096 }
3097 }
3098 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3099 {
3100 for (u32 i = 0; i < pws_cnt; i++)
3101 {
3102 const u32 pw_len = device_param->pws_buf[i].pw_len;
3103
3104 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3105
3106 ptr[pw_len] = 0x80;
3107 }
3108 }
3109 }
3110
3111 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);
3112 }
3113 else if (data.attack_kern == ATTACK_KERN_BF)
3114 {
3115 const u64 off = device_param->words_off;
3116
3117 device_param->kernel_params_mp_l_buf64[3] = off;
3118
3119 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3120 }
3121 }
3122
3123 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3124 {
3125 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3126
3127 device_param->kernel_params_buf32[25] = 0;
3128 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
3129 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3130
3131 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3132 {
3133 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3134 }
3135 else
3136 {
3137 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3138 }
3139
3140 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3141
3142 return exec_ms_prev;
3143 }
3144
3145 static void autotune (hc_device_param_t *device_param)
3146 {
3147 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3148
3149 const u32 kernel_accel_min = device_param->kernel_accel_min;
3150 const u32 kernel_accel_max = device_param->kernel_accel_max;
3151
3152 const u32 kernel_loops_min = device_param->kernel_loops_min;
3153 const u32 kernel_loops_max = device_param->kernel_loops_max;
3154
3155 u32 kernel_accel = kernel_accel_min;
3156 u32 kernel_loops = kernel_loops_min;
3157
3158 // in this case the user specified a fixed -u and -n on the commandline
3159 // no way to tune anything
3160 // but we need to run a few caching rounds
3161
3162 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3163 {
3164 if (data.hash_mode != 2000)
3165 {
3166 try_run (device_param, kernel_accel, kernel_loops);
3167 try_run (device_param, kernel_accel, kernel_loops);
3168 try_run (device_param, kernel_accel, kernel_loops);
3169 try_run (device_param, kernel_accel, kernel_loops);
3170 }
3171
3172 device_param->kernel_accel = kernel_accel;
3173 device_param->kernel_loops = kernel_loops;
3174
3175 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3176
3177 device_param->kernel_power = kernel_power;
3178
3179 return;
3180 }
3181
3182 // from here it's clear we are allowed to autotune
3183 // so let's init some fake words
3184
3185 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3186
3187 if (data.attack_kern == ATTACK_KERN_BF)
3188 {
3189 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3190 }
3191 else
3192 {
3193 for (u32 i = 0; i < kernel_power_max; i++)
3194 {
3195 device_param->pws_buf[i].i[0] = i;
3196 device_param->pws_buf[i].i[1] = 0x01234567;
3197 device_param->pws_buf[i].pw_len = 7 + (i & 7);
3198 }
3199
3200 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);
3201 }
3202
3203 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3204 {
3205 if (data.kernel_rules_cnt > 1)
3206 {
3207 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);
3208 }
3209 }
3210 else
3211 {
3212 run_kernel_amp (device_param, kernel_power_max);
3213 }
3214
3215 #define VERIFIER_CNT 1
3216
3217 // first find out highest kernel-loops that stays below target_ms
3218
3219 if (kernel_loops_min < kernel_loops_max)
3220 {
3221 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3222 {
3223 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3224
3225 for (int i = 0; i < VERIFIER_CNT; i++)
3226 {
3227 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3228
3229 exec_ms = MIN (exec_ms, exec_ms_v);
3230 }
3231
3232 if (exec_ms < target_ms) break;
3233 }
3234 }
3235
3236 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3237
3238 #define STEPS_CNT 10
3239
3240 if (kernel_accel_min < kernel_accel_max)
3241 {
3242 for (int i = 0; i < STEPS_CNT; i++)
3243 {
3244 const u32 kernel_accel_try = 1 << i;
3245
3246 if (kernel_accel_try < kernel_accel_min) continue;
3247 if (kernel_accel_try > kernel_accel_max) break;
3248
3249 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3250
3251 for (int i = 0; i < VERIFIER_CNT; i++)
3252 {
3253 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3254
3255 exec_ms = MIN (exec_ms, exec_ms_v);
3256 }
3257
3258 if (exec_ms > target_ms) break;
3259
3260 kernel_accel = kernel_accel_try;
3261 }
3262 }
3263
3264 // at this point we want to know the actual runtime for the following reason:
3265 // we need a reference for the balancing loop following up, and this
3266 // the balancing loop can have an effect that the creates a new opportunity, for example:
3267 // if the target is 95 ms and the current runtime is 48ms the above loop
3268 // stopped the execution because the previous exec_ms was > 95ms
3269 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3270 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3271
3272 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3273
3274 for (int i = 0; i < VERIFIER_CNT; i++)
3275 {
3276 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3277
3278 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3279 }
3280
3281 u32 diff = kernel_loops - kernel_accel;
3282
3283 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3284 {
3285 u32 kernel_accel_orig = kernel_accel;
3286 u32 kernel_loops_orig = kernel_loops;
3287
3288 for (u32 f = 1; f < 1024; f++)
3289 {
3290 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3291 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3292
3293 if (kernel_accel_try > kernel_accel_max) break;
3294 if (kernel_loops_try < kernel_loops_min) break;
3295
3296 u32 diff_new = kernel_loops_try - kernel_accel_try;
3297
3298 if (diff_new > diff) break;
3299
3300 diff_new = diff;
3301
3302 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
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_try);
3307
3308 exec_ms = MIN (exec_ms, exec_ms_v);
3309 }
3310
3311 if (exec_ms < exec_ms_pre_final)
3312 {
3313 exec_ms_pre_final = exec_ms;
3314
3315 kernel_accel = kernel_accel_try;
3316 kernel_loops = kernel_loops_try;
3317 }
3318 }
3319 }
3320
3321 const double exec_left = target_ms / exec_ms_pre_final;
3322
3323 const double accel_left = kernel_accel_max / kernel_accel;
3324
3325 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3326
3327 if (exec_accel_min >= 1.0)
3328 {
3329 // this is safe to not overflow kernel_accel_max because of accel_left
3330
3331 kernel_accel = (double) kernel_accel * exec_accel_min;
3332 }
3333
3334 // reset them fake words
3335
3336 /*
3337 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3338
3339 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);
3340 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);
3341 */
3342
3343 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3344
3345 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3346 {
3347 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3348 }
3349
3350 // reset timer
3351
3352 device_param->exec_pos = 0;
3353
3354 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3355
3356 memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3357 memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3358 memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3359
3360 // store
3361
3362 device_param->kernel_accel = kernel_accel;
3363 device_param->kernel_loops = kernel_loops;
3364
3365 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3366
3367 device_param->kernel_power = kernel_power;
3368
3369 #ifdef DEBUG
3370
3371 if (data.quiet == 0)
3372 {
3373 clear_prompt ();
3374
3375 log_info ("- Device #%u: autotuned kernel-accel to %u\n"
3376 "- Device #%u: autotuned kernel-loops to %u\n",
3377 device_param->device_id + 1, kernel_accel,
3378 device_param->device_id + 1, kernel_loops);
3379
3380 fprintf (stdout, "%s", PROMPT);
3381
3382 fflush (stdout);
3383 }
3384
3385 #endif
3386 }
3387
3388 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3389 {
3390 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3391
3392 // init speed timer
3393
3394 uint speed_pos = device_param->speed_pos;
3395
3396 #ifdef _POSIX
3397 if (device_param->timer_speed.tv_sec == 0)
3398 {
3399 hc_timer_set (&device_param->timer_speed);
3400 }
3401 #endif
3402
3403 #ifdef _WIN
3404 if (device_param->timer_speed.QuadPart == 0)
3405 {
3406 hc_timer_set (&device_param->timer_speed);
3407 }
3408 #endif
3409
3410 // find higest password length, this is for optimization stuff
3411
3412 uint highest_pw_len = 0;
3413
3414 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3415 {
3416 }
3417 else if (data.attack_kern == ATTACK_KERN_COMBI)
3418 {
3419 }
3420 else if (data.attack_kern == ATTACK_KERN_BF)
3421 {
3422 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3423 + device_param->kernel_params_mp_l_buf32[5];
3424 }
3425
3426 // iteration type
3427
3428 uint innerloop_step = 0;
3429 uint innerloop_cnt = 0;
3430
3431 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3432 else innerloop_step = 1;
3433
3434 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3435 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3436 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3437
3438 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3439
3440 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3441 {
3442 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3443
3444 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3445
3446 if (data.devices_status == STATUS_CRACKED) break;
3447 if (data.devices_status == STATUS_ABORTED) break;
3448 if (data.devices_status == STATUS_QUIT) break;
3449 if (data.devices_status == STATUS_BYPASS) break;
3450
3451 salt_t *salt_buf = &data.salts_buf[salt_pos];
3452
3453 device_param->kernel_params_buf32[24] = salt_pos;
3454 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3455 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3456
3457 FILE *combs_fp = device_param->combs_fp;
3458
3459 if (data.attack_mode == ATTACK_MODE_COMBI)
3460 {
3461 rewind (combs_fp);
3462 }
3463
3464 // innerloops
3465
3466 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3467 {
3468 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3469
3470 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3471
3472 if (data.devices_status == STATUS_CRACKED) break;
3473 if (data.devices_status == STATUS_ABORTED) break;
3474 if (data.devices_status == STATUS_QUIT) break;
3475 if (data.devices_status == STATUS_BYPASS) break;
3476
3477 uint fast_iteration = 0;
3478
3479 uint innerloop_left = innerloop_cnt - innerloop_pos;
3480
3481 if (innerloop_left > innerloop_step)
3482 {
3483 innerloop_left = innerloop_step;
3484
3485 fast_iteration = 1;
3486 }
3487
3488 device_param->innerloop_pos = innerloop_pos;
3489 device_param->innerloop_left = innerloop_left;
3490
3491 device_param->kernel_params_buf32[27] = innerloop_left;
3492
3493 // i think we can get rid of this
3494 if (innerloop_left == 0)
3495 {
3496 puts ("bug, how should this happen????\n");
3497
3498 continue;
3499 }
3500
3501 if (data.salts_shown[salt_pos] == 1)
3502 {
3503 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3504
3505 continue;
3506 }
3507
3508 // initialize amplifiers
3509
3510 if (data.attack_mode == ATTACK_MODE_COMBI)
3511 {
3512 uint i = 0;
3513
3514 while (i < innerloop_left)
3515 {
3516 if (feof (combs_fp)) break;
3517
3518 int line_len = fgetl (combs_fp, line_buf);
3519
3520 if (line_len >= PW_MAX1) continue;
3521
3522 line_len = convert_from_hex (line_buf, line_len);
3523
3524 char *line_buf_new = line_buf;
3525
3526 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3527 {
3528 char rule_buf_out[BLOCK_SIZE] = { 0 };
3529
3530 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3531
3532 if (rule_len_out < 0)
3533 {
3534 data.words_progress_rejected[salt_pos] += pws_cnt;
3535
3536 continue;
3537 }
3538
3539 line_len = rule_len_out;
3540
3541 line_buf_new = rule_buf_out;
3542 }
3543
3544 line_len = MIN (line_len, PW_DICTMAX);
3545
3546 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3547
3548 memcpy (ptr, line_buf_new, line_len);
3549
3550 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3551
3552 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3553 {
3554 uppercase (ptr, line_len);
3555 }
3556
3557 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3558 {
3559 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3560 {
3561 ptr[line_len] = 0x80;
3562 }
3563
3564 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3565 {
3566 ptr[line_len] = 0x01;
3567 }
3568 }
3569
3570 device_param->combs_buf[i].pw_len = line_len;
3571
3572 i++;
3573 }
3574
3575 for (uint j = i; j < innerloop_left; j++)
3576 {
3577 device_param->combs_buf[j].i[0] = 0;
3578 device_param->combs_buf[j].i[1] = 0;
3579 device_param->combs_buf[j].i[2] = 0;
3580 device_param->combs_buf[j].i[3] = 0;
3581 device_param->combs_buf[j].i[4] = 0;
3582 device_param->combs_buf[j].i[5] = 0;
3583 device_param->combs_buf[j].i[6] = 0;
3584 device_param->combs_buf[j].i[7] = 0;
3585
3586 device_param->combs_buf[j].pw_len = 0;
3587 }
3588
3589 innerloop_left = i;
3590 }
3591 else if (data.attack_mode == ATTACK_MODE_BF)
3592 {
3593 u64 off = innerloop_pos;
3594
3595 device_param->kernel_params_mp_r_buf64[3] = off;
3596
3597 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3598 }
3599 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3600 {
3601 u64 off = innerloop_pos;
3602
3603 device_param->kernel_params_mp_buf64[3] = off;
3604
3605 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3606 }
3607 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3608 {
3609 u64 off = innerloop_pos;
3610
3611 device_param->kernel_params_mp_buf64[3] = off;
3612
3613 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3614 }
3615
3616 // copy amplifiers
3617
3618 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3619 {
3620 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);
3621 }
3622 else if (data.attack_mode == ATTACK_MODE_COMBI)
3623 {
3624 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);
3625 }
3626 else if (data.attack_mode == ATTACK_MODE_BF)
3627 {
3628 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);
3629 }
3630 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3631 {
3632 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);
3633 }
3634 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3635 {
3636 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);
3637 }
3638
3639 if (data.benchmark == 1)
3640 {
3641 hc_timer_set (&device_param->timer_speed);
3642 }
3643
3644 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
3645
3646 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3647
3648 if (data.devices_status == STATUS_CRACKED) break;
3649 if (data.devices_status == STATUS_ABORTED) break;
3650 if (data.devices_status == STATUS_QUIT) break;
3651
3652 /**
3653 * result
3654 */
3655
3656 if (data.benchmark == 0)
3657 {
3658 check_cracked (device_param, salt_pos);
3659 }
3660
3661 /**
3662 * progress
3663 */
3664
3665 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3666
3667 hc_thread_mutex_lock (mux_counter);
3668
3669 data.words_progress_done[salt_pos] += perf_sum_all;
3670
3671 hc_thread_mutex_unlock (mux_counter);
3672
3673 /**
3674 * speed
3675 */
3676
3677 double speed_ms;
3678
3679 hc_timer_get (device_param->timer_speed, speed_ms);
3680
3681 hc_timer_set (&device_param->timer_speed);
3682
3683 // current speed
3684
3685 //hc_thread_mutex_lock (mux_display);
3686
3687 device_param->speed_cnt[speed_pos] = perf_sum_all;
3688
3689 device_param->speed_ms[speed_pos] = speed_ms;
3690
3691 //hc_thread_mutex_unlock (mux_display);
3692
3693 speed_pos++;
3694
3695 if (speed_pos == SPEED_CACHE)
3696 {
3697 speed_pos = 0;
3698 }
3699
3700 /**
3701 * benchmark
3702 */
3703
3704 if (data.benchmark == 1) break;
3705 }
3706 }
3707
3708 device_param->speed_pos = speed_pos;
3709
3710 myfree (line_buf);
3711 }
3712
3713 static void load_segment (wl_data_t *wl_data, FILE *fd)
3714 {
3715 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3716
3717 wl_data->pos = 0;
3718
3719 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3720
3721 wl_data->buf[wl_data->cnt] = 0;
3722
3723 if (wl_data->cnt == 0) return;
3724
3725 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3726
3727 while (!feof (fd))
3728 {
3729 if (wl_data->cnt == wl_data->avail)
3730 {
3731 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3732
3733 wl_data->avail += wl_data->incr;
3734 }
3735
3736 const int c = fgetc (fd);
3737
3738 if (c == EOF) break;
3739
3740 wl_data->buf[wl_data->cnt] = (char) c;
3741
3742 wl_data->cnt++;
3743
3744 if (c == '\n') break;
3745 }
3746
3747 // ensure stream ends with a newline
3748
3749 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3750 {
3751 wl_data->cnt++;
3752
3753 wl_data->buf[wl_data->cnt - 1] = '\n';
3754 }
3755
3756 return;
3757 }
3758
3759 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3760 {
3761 char *ptr = buf;
3762
3763 for (u32 i = 0; i < sz; i++, ptr++)
3764 {
3765 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3766
3767 if (i == 7)
3768 {
3769 *off = i;
3770 *len = i;
3771
3772 return;
3773 }
3774
3775 if (*ptr != '\n') continue;
3776
3777 *off = i + 1;
3778
3779 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3780
3781 *len = i;
3782
3783 return;
3784 }
3785
3786 *off = sz;
3787 *len = sz;
3788 }
3789
3790 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3791 {
3792 char *ptr = buf;
3793
3794 for (u32 i = 0; i < sz; i++, ptr++)
3795 {
3796 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3797
3798 if (*ptr != '\n') continue;
3799
3800 *off = i + 1;
3801
3802 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3803
3804 *len = i;
3805
3806 return;
3807 }
3808
3809 *off = sz;
3810 *len = sz;
3811 }
3812
3813 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3814 {
3815 char *ptr = buf;
3816
3817 for (u32 i = 0; i < sz; i++, ptr++)
3818 {
3819 if (*ptr != '\n') continue;
3820
3821 *off = i + 1;
3822
3823 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3824
3825 *len = i;
3826
3827 return;
3828 }
3829
3830 *off = sz;
3831 *len = sz;
3832 }
3833
3834 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3835 {
3836 while (wl_data->pos < wl_data->cnt)
3837 {
3838 uint off;
3839 uint len;
3840
3841 char *ptr = wl_data->buf + wl_data->pos;
3842
3843 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3844
3845 wl_data->pos += off;
3846
3847 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3848 {
3849 char rule_buf_out[BLOCK_SIZE] = { 0 };
3850
3851 int rule_len_out = -1;
3852
3853 if (len < BLOCK_SIZE)
3854 {
3855 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3856 }
3857
3858 if (rule_len_out < 0)
3859 {
3860 continue;
3861 }
3862
3863 if (rule_len_out > PW_MAX)
3864 {
3865 continue;
3866 }
3867 }
3868 else
3869 {
3870 if (len > PW_MAX)
3871 {
3872 continue;
3873 }
3874 }
3875
3876 *out_buf = ptr;
3877 *out_len = len;
3878
3879 return;
3880 }
3881
3882 if (feof (fd))
3883 {
3884 fprintf (stderr, "BUG feof()!!\n");
3885
3886 return;
3887 }
3888
3889 load_segment (wl_data, fd);
3890
3891 get_next_word (wl_data, fd, out_buf, out_len);
3892 }
3893
3894 #ifdef _POSIX
3895 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3896 #endif
3897
3898 #ifdef _WIN
3899 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3900 #endif
3901 {
3902 hc_signal (NULL);
3903
3904 dictstat_t d;
3905
3906 d.cnt = 0;
3907
3908 #ifdef _POSIX
3909 fstat (fileno (fd), &d.stat);
3910 #endif
3911
3912 #ifdef _WIN
3913 _fstat64 (fileno (fd), &d.stat);
3914 #endif
3915
3916 d.stat.st_mode = 0;
3917 d.stat.st_nlink = 0;
3918 d.stat.st_uid = 0;
3919 d.stat.st_gid = 0;
3920 d.stat.st_rdev = 0;
3921 d.stat.st_atime = 0;
3922
3923 #ifdef _POSIX
3924 d.stat.st_blksize = 0;
3925 d.stat.st_blocks = 0;
3926 #endif
3927
3928 if (d.stat.st_size == 0) return 0;
3929
3930 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3931
3932 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3933 {
3934 if (d_cache)
3935 {
3936 u64 cnt = d_cache->cnt;
3937
3938 u64 keyspace = cnt;
3939
3940 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3941 {
3942 keyspace *= data.kernel_rules_cnt;
3943 }
3944 else if (data.attack_kern == ATTACK_KERN_COMBI)
3945 {
3946 keyspace *= data.combs_cnt;
3947 }
3948
3949 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);
3950 if (data.quiet == 0) log_info ("");
3951
3952 hc_signal (sigHandler_default);
3953
3954 return (keyspace);
3955 }
3956 }
3957
3958 time_t now = 0;
3959 time_t prev = 0;
3960
3961 u64 comp = 0;
3962 u64 cnt = 0;
3963 u64 cnt2 = 0;
3964
3965 while (!feof (fd))
3966 {
3967 load_segment (wl_data, fd);
3968
3969 comp += wl_data->cnt;
3970
3971 u32 i = 0;
3972
3973 while (i < wl_data->cnt)
3974 {
3975 u32 len;
3976 u32 off;
3977
3978 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3979
3980 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3981 {
3982 char rule_buf_out[BLOCK_SIZE] = { 0 };
3983
3984 int rule_len_out = -1;
3985
3986 if (len < BLOCK_SIZE)
3987 {
3988 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3989 }
3990
3991 if (rule_len_out < 0)
3992 {
3993 len = PW_MAX1;
3994 }
3995 else
3996 {
3997 len = rule_len_out;
3998 }
3999 }
4000
4001 if (len < PW_MAX1)
4002 {
4003 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4004 {
4005 cnt += data.kernel_rules_cnt;
4006 }
4007 else if (data.attack_kern == ATTACK_KERN_COMBI)
4008 {
4009 cnt += data.combs_cnt;
4010 }
4011
4012 d.cnt++;
4013 }
4014
4015 i += off;
4016
4017 cnt2++;
4018 }
4019
4020 time (&now);
4021
4022 if ((now - prev) == 0) continue;
4023
4024 float percent = (float) comp / (float) d.stat.st_size;
4025
4026 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);
4027
4028 time (&prev);
4029 }
4030
4031 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);
4032 if (data.quiet == 0) log_info ("");
4033
4034 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4035
4036 hc_signal (sigHandler_default);
4037
4038 return (cnt);
4039 }
4040
4041 static void *thread_monitor (void *p)
4042 {
4043 uint runtime_check = 0;
4044 uint remove_check = 0;
4045 uint status_check = 0;
4046 uint restore_check = 0;
4047
4048 uint restore_left = data.restore_timer;
4049 uint remove_left = data.remove_timer;
4050 uint status_left = data.status_timer;
4051
4052 #ifdef HAVE_HWMON
4053 uint hwmon_check = 0;
4054
4055 int slowdown_warnings = 0;
4056
4057 // these variables are mainly used for fan control
4058
4059 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4060
4061 // temperature controller "loopback" values
4062
4063 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4064 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4065
4066 int temp_threshold = 1; // degrees celcius
4067
4068 int fan_speed_min = 15; // in percentage
4069 int fan_speed_max = 100;
4070
4071 time_t last_temp_check_time;
4072 #endif // HAVE_HWMON
4073
4074 uint sleep_time = 1;
4075
4076 if (data.runtime)
4077 {
4078 runtime_check = 1;
4079 }
4080
4081 if (data.restore_timer)
4082 {
4083 restore_check = 1;
4084 }
4085
4086 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4087 {
4088 remove_check = 1;
4089 }
4090
4091 if (data.status == 1)
4092 {
4093 status_check = 1;
4094 }
4095
4096 #ifdef HAVE_HWMON
4097 if (data.gpu_temp_disable == 0)
4098 {
4099 time (&last_temp_check_time);
4100
4101 hwmon_check = 1;
4102 }
4103 #endif
4104
4105 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4106 {
4107 #ifdef HAVE_HWMON
4108 if (hwmon_check == 0)
4109 #endif
4110 return (p);
4111 }
4112
4113 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4114 {
4115 hc_sleep (sleep_time);
4116
4117 if (data.devices_status != STATUS_RUNNING) continue;
4118
4119 #ifdef HAVE_HWMON
4120
4121 if (hwmon_check == 1)
4122 {
4123 hc_thread_mutex_lock (mux_adl);
4124
4125 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4126 {
4127 hc_device_param_t *device_param = &data.devices_param[device_id];
4128
4129 if (device_param->skipped) continue;
4130
4131 if (device_param->device_vendor_id == VENDOR_ID_NV)
4132 {
4133 if (data.hm_nvapi)
4134 {
4135 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
4136 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
4137
4138 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4139 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4140
4141 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4142
4143 perfPolicies_status.info_value = perfPolicies_info.info_value;
4144
4145 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4146
4147 if (perfPolicies_status.throttle & 2)
4148 {
4149 if (slowdown_warnings < 3)
4150 {
4151 if (data.quiet == 0) clear_prompt ();
4152
4153 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4154
4155 if (slowdown_warnings == 2)
4156 {
4157 log_info ("");
4158 }
4159
4160 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4161 if (data.quiet == 0) fflush (stdout);
4162
4163 slowdown_warnings++;
4164 }
4165 }
4166 else
4167 {
4168 slowdown_warnings = 0;
4169 }
4170 }
4171 }
4172 }
4173
4174 hc_thread_mutex_unlock (mux_adl);
4175 }
4176
4177 if (hwmon_check == 1)
4178 {
4179 hc_thread_mutex_lock (mux_adl);
4180
4181 time_t temp_check_time;
4182
4183 time (&temp_check_time);
4184
4185 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4186
4187 if (Ta == 0) Ta = 1;
4188
4189 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4190 {
4191 hc_device_param_t *device_param = &data.devices_param[device_id];
4192
4193 if (device_param->skipped) continue;
4194
4195 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4196
4197 const int temperature = hm_get_temperature_with_device_id (device_id);
4198
4199 if (temperature > (int) data.gpu_temp_abort)
4200 {
4201 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4202
4203 if (data.devices_status != STATUS_QUIT) myabort ();
4204
4205 break;
4206 }
4207
4208 const int gpu_temp_retain = data.gpu_temp_retain;
4209
4210 if (gpu_temp_retain)
4211 {
4212 if (data.hm_device[device_id].fan_set_supported == 1)
4213 {
4214 int temp_cur = temperature;
4215
4216 int temp_diff_new = gpu_temp_retain - temp_cur;
4217
4218 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4219
4220 // calculate Ta value (time difference in seconds between the last check and this check)
4221
4222 last_temp_check_time = temp_check_time;
4223
4224 float Kp = 1.8;
4225 float Ki = 0.005;
4226 float Kd = 6;
4227
4228 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4229
4230 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);
4231
4232 if (abs (fan_diff_required) >= temp_threshold)
4233 {
4234 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4235
4236 int fan_speed_level = fan_speed_cur;
4237
4238 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4239
4240 int fan_speed_new = fan_speed_level - fan_diff_required;
4241
4242 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4243 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4244
4245 if (fan_speed_new != fan_speed_cur)
4246 {
4247 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4248 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4249
4250 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4251 {
4252 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4253 {
4254 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4255 }
4256 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4257 {
4258 #ifdef WIN
4259 hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1);
4260 #endif
4261
4262 #ifdef LINUX
4263 hm_set_fanspeed_with_device_id_xnvctrl (device_id, fan_speed_new);
4264 #endif
4265 }
4266
4267 fan_speed_chgd[device_id] = 1;
4268 }
4269
4270 temp_diff_old[device_id] = temp_diff_new;
4271 }
4272 }
4273 }
4274 }
4275 }
4276
4277 hc_thread_mutex_unlock (mux_adl);
4278 }
4279 #endif // HAVE_HWMON
4280
4281 if (restore_check == 1)
4282 {
4283 restore_left--;
4284
4285 if (restore_left == 0)
4286 {
4287 if (data.restore_disable == 0) cycle_restore ();
4288
4289 restore_left = data.restore_timer;
4290 }
4291 }
4292
4293 if ((runtime_check == 1) && (data.runtime_start > 0))
4294 {
4295 time_t runtime_cur;
4296
4297 time (&runtime_cur);
4298
4299 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4300
4301 if (runtime_left <= 0)
4302 {
4303 if (data.benchmark == 0)
4304 {
4305 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4306 }
4307
4308 if (data.devices_status != STATUS_QUIT) myabort ();
4309 }
4310 }
4311
4312 if (remove_check == 1)
4313 {
4314 remove_left--;
4315
4316 if (remove_left == 0)
4317 {
4318 if (data.digests_saved != data.digests_done)
4319 {
4320 data.digests_saved = data.digests_done;
4321
4322 save_hash ();
4323 }
4324
4325 remove_left = data.remove_timer;
4326 }
4327 }
4328
4329 if (status_check == 1)
4330 {
4331 status_left--;
4332
4333 if (status_left == 0)
4334 {
4335 //hc_thread_mutex_lock (mux_display);
4336
4337 if (data.quiet == 0) clear_prompt ();
4338
4339 if (data.quiet == 0) log_info ("");
4340
4341 status_display ();
4342
4343 if (data.quiet == 0) log_info ("");
4344
4345 //hc_thread_mutex_unlock (mux_display);
4346
4347 status_left = data.status_timer;
4348 }
4349 }
4350 }
4351
4352 #ifdef HAVE_HWMON
4353 myfree (fan_speed_chgd);
4354
4355 myfree (temp_diff_old);
4356 myfree (temp_diff_sum);
4357 #endif
4358
4359 p = NULL;
4360
4361 return (p);
4362 }
4363
4364 static void *thread_outfile_remove (void *p)
4365 {
4366 // some hash-dependent constants
4367 char *outfile_dir = data.outfile_check_directory;
4368 uint dgst_size = data.dgst_size;
4369 uint isSalted = data.isSalted;
4370 uint esalt_size = data.esalt_size;
4371 uint hash_mode = data.hash_mode;
4372
4373 uint outfile_check_timer = data.outfile_check_timer;
4374
4375 char separator = data.separator;
4376
4377 // some hash-dependent functions
4378 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4379 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4380
4381 // buffers
4382 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4383
4384 hash_buf.digest = mymalloc (dgst_size);
4385
4386 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4387
4388 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4389
4390 uint digest_buf[64] = { 0 };
4391
4392 outfile_data_t *out_info = NULL;
4393
4394 char **out_files = NULL;
4395
4396 time_t folder_mtime = 0;
4397
4398 int out_cnt = 0;
4399
4400 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4401
4402 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4403 {
4404 hc_sleep (1);
4405
4406 if (data.devices_status != STATUS_RUNNING) continue;
4407
4408 check_left--;
4409
4410 if (check_left == 0)
4411 {
4412 struct stat outfile_check_stat;
4413
4414 if (stat (outfile_dir, &outfile_check_stat) == 0)
4415 {
4416 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4417
4418 if (is_dir == 1)
4419 {
4420 if (outfile_check_stat.st_mtime > folder_mtime)
4421 {
4422 char **out_files_new = scan_directory (outfile_dir);
4423
4424 int out_cnt_new = count_dictionaries (out_files_new);
4425
4426 outfile_data_t *out_info_new = NULL;
4427
4428 if (out_cnt_new > 0)
4429 {
4430 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4431
4432 for (int i = 0; i < out_cnt_new; i++)
4433 {
4434 out_info_new[i].file_name = out_files_new[i];
4435
4436 // check if there are files that we have seen/checked before (and not changed)
4437
4438 for (int j = 0; j < out_cnt; j++)
4439 {
4440 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4441 {
4442 struct stat outfile_stat;
4443
4444 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4445 {
4446 if (outfile_stat.st_ctime == out_info[j].ctime)
4447 {
4448 out_info_new[i].ctime = out_info[j].ctime;
4449 out_info_new[i].seek = out_info[j].seek;
4450 }
4451 }
4452 }
4453 }
4454 }
4455 }
4456
4457 local_free (out_info);
4458 local_free (out_files);
4459
4460 out_files = out_files_new;
4461 out_cnt = out_cnt_new;
4462 out_info = out_info_new;
4463
4464 folder_mtime = outfile_check_stat.st_mtime;
4465 }
4466
4467 for (int j = 0; j < out_cnt; j++)
4468 {
4469 FILE *fp = fopen (out_info[j].file_name, "rb");
4470
4471 if (fp != NULL)
4472 {
4473 //hc_thread_mutex_lock (mux_display);
4474
4475 #ifdef _POSIX
4476 struct stat outfile_stat;
4477
4478 fstat (fileno (fp), &outfile_stat);
4479 #endif
4480
4481 #ifdef _WIN
4482 struct stat64 outfile_stat;
4483
4484 _fstat64 (fileno (fp), &outfile_stat);
4485 #endif
4486
4487 if (outfile_stat.st_ctime > out_info[j].ctime)
4488 {
4489 out_info[j].ctime = outfile_stat.st_ctime;
4490 out_info[j].seek = 0;
4491 }
4492
4493 fseek (fp, out_info[j].seek, SEEK_SET);
4494
4495 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4496
4497 while (!feof (fp))
4498 {
4499 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4500
4501 if (ptr == NULL) break;
4502
4503 int line_len = strlen (line_buf);
4504
4505 if (line_len <= 0) continue;
4506
4507 int iter = MAX_CUT_TRIES;
4508
4509 for (uint i = line_len - 1; i && iter; i--, line_len--)
4510 {
4511 if (line_buf[i] != separator) continue;
4512
4513 int parser_status = PARSER_OK;
4514
4515 if ((hash_mode != 2500) && (hash_mode != 6800))
4516 {
4517 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4518 }
4519
4520 uint found = 0;
4521
4522 if (parser_status == PARSER_OK)
4523 {
4524 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4525 {
4526 if (data.salts_shown[salt_pos] == 1) continue;
4527
4528 salt_t *salt_buf = &data.salts_buf[salt_pos];
4529
4530 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4531 {
4532 uint idx = salt_buf->digests_offset + digest_pos;
4533
4534 if (data.digests_shown[idx] == 1) continue;
4535
4536 uint cracked = 0;
4537
4538 if (hash_mode == 6800)
4539 {
4540 if (i == salt_buf->salt_len)
4541 {
4542 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4543 }
4544 }
4545 else if (hash_mode == 2500)
4546 {
4547 // BSSID : MAC1 : MAC2 (:plain)
4548 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4549 {
4550 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4551
4552 if (!cracked) continue;
4553
4554 // now compare MAC1 and MAC2 too, since we have this additional info
4555 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4556 char *mac2_pos = mac1_pos + 12 + 1;
4557
4558 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4559 wpa_t *wpa = &wpas[salt_pos];
4560
4561 // compare hex string(s) vs binary MAC address(es)
4562
4563 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4564 {
4565 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4566 {
4567 cracked = 0;
4568
4569 break;
4570 }
4571 }
4572
4573 // early skip ;)
4574 if (!cracked) continue;
4575
4576 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4577 {
4578 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4579 {
4580 cracked = 0;
4581
4582 break;
4583 }
4584 }
4585 }
4586 }
4587 else
4588 {
4589 char *digests_buf_ptr = (char *) data.digests_buf;
4590
4591 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4592
4593 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4594 }
4595
4596 if (cracked == 1)
4597 {
4598 found = 1;
4599
4600 data.digests_shown[idx] = 1;
4601
4602 data.digests_done++;
4603
4604 salt_buf->digests_done++;
4605
4606 if (salt_buf->digests_done == salt_buf->digests_cnt)
4607 {
4608 data.salts_shown[salt_pos] = 1;
4609
4610 data.salts_done++;
4611
4612 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4613 }
4614 }
4615 }
4616
4617 if (data.devices_status == STATUS_CRACKED) break;
4618 }
4619 }
4620
4621 if (found) break;
4622
4623 if (data.devices_status == STATUS_CRACKED) break;
4624
4625 iter--;
4626 }
4627
4628 if (data.devices_status == STATUS_CRACKED) break;
4629 }
4630
4631 myfree (line_buf);
4632
4633 out_info[j].seek = ftell (fp);
4634
4635 //hc_thread_mutex_unlock (mux_display);
4636
4637 fclose (fp);
4638 }
4639 }
4640 }
4641 }
4642
4643 check_left = outfile_check_timer;
4644 }
4645 }
4646
4647 if (esalt_size) local_free (hash_buf.esalt);
4648
4649 if (isSalted) local_free (hash_buf.salt);
4650
4651 local_free (hash_buf.digest);
4652
4653 local_free (out_info);
4654
4655 local_free (out_files);
4656
4657 p = NULL;
4658
4659 return (p);
4660 }
4661
4662 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4663 {
4664 //if (device_param->pws_cnt < device_param->kernel_power)
4665 //{
4666 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4667
4668 u8 *ptr = (u8 *) pw->i;
4669
4670 memcpy (ptr, pw_buf, pw_len);
4671
4672 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4673
4674 pw->pw_len = pw_len;
4675
4676 device_param->pws_cnt++;
4677 //}
4678 //else
4679 //{
4680 // fprintf (stderr, "BUG pw_add()!!\n");
4681 //
4682 // return;
4683 //}
4684 }
4685
4686 static void set_kernel_power_final (const u64 kernel_power_final)
4687 {
4688 if (data.quiet == 0)
4689 {
4690 clear_prompt ();
4691
4692 //log_info ("");
4693
4694 log_info ("INFO: approaching final keyspace, workload adjusted");
4695 log_info ("");
4696
4697 fprintf (stdout, "%s", PROMPT);
4698
4699 fflush (stdout);
4700 }
4701
4702 data.kernel_power_final = kernel_power_final;
4703 }
4704
4705 static u32 get_power (hc_device_param_t *device_param)
4706 {
4707 const u64 kernel_power_final = data.kernel_power_final;
4708
4709 if (kernel_power_final)
4710 {
4711 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4712
4713 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4714
4715 // work should be at least the hardware power available without any accelerator
4716
4717 const u64 work = MAX (words_left_device, device_param->hardware_power);
4718
4719 return work;
4720 }
4721
4722 return device_param->kernel_power;
4723 }
4724
4725 static uint get_work (hc_device_param_t *device_param, const u64 max)
4726 {
4727 hc_thread_mutex_lock (mux_dispatcher);
4728
4729 const u64 words_cur = data.words_cur;
4730 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4731
4732 device_param->words_off = words_cur;
4733
4734 const u64 kernel_power_all = data.kernel_power_all;
4735
4736 const u64 words_left = words_base - words_cur;
4737
4738 if (words_left < kernel_power_all)
4739 {
4740 if (data.kernel_power_final == 0)
4741 {
4742 set_kernel_power_final (words_left);
4743 }
4744 }
4745
4746 const u32 kernel_power = get_power (device_param);
4747
4748 uint work = MIN (words_left, kernel_power);
4749
4750 work = MIN (work, max);
4751
4752 data.words_cur += work;
4753
4754 hc_thread_mutex_unlock (mux_dispatcher);
4755
4756 return work;
4757 }
4758
4759 static void *thread_autotune (void *p)
4760 {
4761 hc_device_param_t *device_param = (hc_device_param_t *) p;
4762
4763 if (device_param->skipped) return NULL;
4764
4765 autotune (device_param);
4766
4767 return NULL;
4768 }
4769
4770 static void *thread_calc_stdin (void *p)
4771 {
4772 hc_device_param_t *device_param = (hc_device_param_t *) p;
4773
4774 if (device_param->skipped) return NULL;
4775
4776 char *buf = (char *) mymalloc (HCBUFSIZ);
4777
4778 const uint attack_kern = data.attack_kern;
4779
4780 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4781 {
4782 hc_thread_mutex_lock (mux_dispatcher);
4783
4784 if (feof (stdin) != 0)
4785 {
4786 hc_thread_mutex_unlock (mux_dispatcher);
4787
4788 break;
4789 }
4790
4791 uint words_cur = 0;
4792
4793 while (words_cur < device_param->kernel_power)
4794 {
4795 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4796
4797 if (line_buf == NULL) break;
4798
4799 uint line_len = in_superchop (line_buf);
4800
4801 line_len = convert_from_hex (line_buf, line_len);
4802
4803 // post-process rule engine
4804
4805 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4806 {
4807 char rule_buf_out[BLOCK_SIZE] = { 0 };
4808
4809 int rule_len_out = -1;
4810
4811 if (line_len < BLOCK_SIZE)
4812 {
4813 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4814 }
4815
4816 if (rule_len_out < 0) continue;
4817
4818 line_buf = rule_buf_out;
4819 line_len = rule_len_out;
4820 }
4821
4822 if (line_len > PW_MAX)
4823 {
4824 continue;
4825 }
4826
4827 // hmm that's always the case, or?
4828
4829 if (attack_kern == ATTACK_KERN_STRAIGHT)
4830 {
4831 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4832 {
4833 hc_thread_mutex_lock (mux_counter);
4834
4835 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4836 {
4837 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4838 }
4839
4840 hc_thread_mutex_unlock (mux_counter);
4841
4842 continue;
4843 }
4844 }
4845
4846 pw_add (device_param, (u8 *) line_buf, line_len);
4847
4848 words_cur++;
4849
4850 if (data.devices_status == STATUS_CRACKED) break;
4851 if (data.devices_status == STATUS_ABORTED) break;
4852 if (data.devices_status == STATUS_QUIT) break;
4853 if (data.devices_status == STATUS_BYPASS) break;
4854 }
4855
4856 hc_thread_mutex_unlock (mux_dispatcher);
4857
4858 if (data.devices_status == STATUS_CRACKED) break;
4859 if (data.devices_status == STATUS_ABORTED) break;
4860 if (data.devices_status == STATUS_QUIT) break;
4861 if (data.devices_status == STATUS_BYPASS) break;
4862
4863 // flush
4864
4865 const uint pws_cnt = device_param->pws_cnt;
4866
4867 if (pws_cnt)
4868 {
4869 run_copy (device_param, pws_cnt);
4870
4871 run_cracker (device_param, pws_cnt);
4872
4873 device_param->pws_cnt = 0;
4874
4875 /*
4876 still required?
4877 if (attack_kern == ATTACK_KERN_STRAIGHT)
4878 {
4879 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4880 }
4881 else if (attack_kern == ATTACK_KERN_COMBI)
4882 {
4883 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4884 }
4885 */
4886 }
4887 }
4888
4889 device_param->kernel_accel = 0;
4890 device_param->kernel_loops = 0;
4891
4892 myfree (buf);
4893
4894 return NULL;
4895 }
4896
4897 static void *thread_calc (void *p)
4898 {
4899 hc_device_param_t *device_param = (hc_device_param_t *) p;
4900
4901 if (device_param->skipped) return NULL;
4902
4903 const uint attack_mode = data.attack_mode;
4904 const uint attack_kern = data.attack_kern;
4905
4906 if (attack_mode == ATTACK_MODE_BF)
4907 {
4908 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4909 {
4910 const uint work = get_work (device_param, -1);
4911
4912 if (work == 0) break;
4913
4914 const u64 words_off = device_param->words_off;
4915 const u64 words_fin = words_off + work;
4916
4917 const uint pws_cnt = work;
4918
4919 device_param->pws_cnt = pws_cnt;
4920
4921 if (pws_cnt)
4922 {
4923 run_copy (device_param, pws_cnt);
4924
4925 run_cracker (device_param, pws_cnt);
4926
4927 device_param->pws_cnt = 0;
4928
4929 /*
4930 still required?
4931 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4932 */
4933 }
4934
4935 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4936
4937 if (data.devices_status == STATUS_CRACKED) break;
4938 if (data.devices_status == STATUS_ABORTED) break;
4939 if (data.devices_status == STATUS_QUIT) break;
4940 if (data.devices_status == STATUS_BYPASS) break;
4941
4942 if (data.benchmark == 1) break;
4943
4944 device_param->words_done = words_fin;
4945 }
4946 }
4947 else
4948 {
4949 const uint segment_size = data.segment_size;
4950
4951 char *dictfile = data.dictfile;
4952
4953 if (attack_mode == ATTACK_MODE_COMBI)
4954 {
4955 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4956 {
4957 dictfile = data.dictfile2;
4958 }
4959 }
4960
4961 FILE *fd = fopen (dictfile, "rb");
4962
4963 if (fd == NULL)
4964 {
4965 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4966
4967 return NULL;
4968 }
4969
4970 if (attack_mode == ATTACK_MODE_COMBI)
4971 {
4972 const uint combs_mode = data.combs_mode;
4973
4974 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4975 {
4976 const char *dictfilec = data.dictfile2;
4977
4978 FILE *combs_fp = fopen (dictfilec, "rb");
4979
4980 if (combs_fp == NULL)
4981 {
4982 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4983
4984 fclose (fd);
4985
4986 return NULL;
4987 }
4988
4989 device_param->combs_fp = combs_fp;
4990 }
4991 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4992 {
4993 const char *dictfilec = data.dictfile;
4994
4995 FILE *combs_fp = fopen (dictfilec, "rb");
4996
4997 if (combs_fp == NULL)
4998 {
4999 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5000
5001 fclose (fd);
5002
5003 return NULL;
5004 }
5005
5006 device_param->combs_fp = combs_fp;
5007 }
5008 }
5009
5010 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
5011
5012 wl_data->buf = (char *) mymalloc (segment_size);
5013 wl_data->avail = segment_size;
5014 wl_data->incr = segment_size;
5015 wl_data->cnt = 0;
5016 wl_data->pos = 0;
5017
5018 u64 words_cur = 0;
5019
5020 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5021 {
5022 u64 words_off = 0;
5023 u64 words_fin = 0;
5024
5025 u64 max = -1;
5026
5027 while (max)
5028 {
5029 const uint work = get_work (device_param, max);
5030
5031 if (work == 0) break;
5032
5033 max = 0;
5034
5035 words_off = device_param->words_off;
5036 words_fin = words_off + work;
5037
5038 char *line_buf;
5039 uint line_len;
5040
5041 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5042
5043 for ( ; words_cur < words_fin; words_cur++)
5044 {
5045 get_next_word (wl_data, fd, &line_buf, &line_len);
5046
5047 line_len = convert_from_hex (line_buf, line_len);
5048
5049 // post-process rule engine
5050
5051 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5052 {
5053 char rule_buf_out[BLOCK_SIZE] = { 0 };
5054
5055 int rule_len_out = -1;
5056
5057 if (line_len < BLOCK_SIZE)
5058 {
5059 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5060 }
5061
5062 if (rule_len_out < 0) continue;
5063
5064 line_buf = rule_buf_out;
5065 line_len = rule_len_out;
5066 }
5067
5068 if (attack_kern == ATTACK_KERN_STRAIGHT)
5069 {
5070 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5071 {
5072 max++;
5073
5074 hc_thread_mutex_lock (mux_counter);
5075
5076 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5077 {
5078 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5079 }
5080
5081 hc_thread_mutex_unlock (mux_counter);
5082
5083 continue;
5084 }
5085 }
5086 else if (attack_kern == ATTACK_KERN_COMBI)
5087 {
5088 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5089 // since we still need to combine the plains
5090
5091 if (line_len > data.pw_max)
5092 {
5093 max++;
5094
5095 hc_thread_mutex_lock (mux_counter);
5096
5097 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5098 {
5099 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5100 }
5101
5102 hc_thread_mutex_unlock (mux_counter);
5103
5104 continue;
5105 }
5106 }
5107
5108 pw_add (device_param, (u8 *) line_buf, line_len);
5109
5110 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5111
5112 if (data.devices_status == STATUS_CRACKED) break;
5113 if (data.devices_status == STATUS_ABORTED) break;
5114 if (data.devices_status == STATUS_QUIT) break;
5115 if (data.devices_status == STATUS_BYPASS) break;
5116 }
5117
5118 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5119
5120 if (data.devices_status == STATUS_CRACKED) break;
5121 if (data.devices_status == STATUS_ABORTED) break;
5122 if (data.devices_status == STATUS_QUIT) break;
5123 if (data.devices_status == STATUS_BYPASS) break;
5124 }
5125
5126 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5127
5128 if (data.devices_status == STATUS_CRACKED) break;
5129 if (data.devices_status == STATUS_ABORTED) break;
5130 if (data.devices_status == STATUS_QUIT) break;
5131 if (data.devices_status == STATUS_BYPASS) break;
5132
5133 //
5134 // flush
5135 //
5136
5137 const uint pws_cnt = device_param->pws_cnt;
5138
5139 if (pws_cnt)
5140 {
5141 run_copy (device_param, pws_cnt);
5142
5143 run_cracker (device_param, pws_cnt);
5144
5145 device_param->pws_cnt = 0;
5146
5147 /*
5148 still required?
5149 if (attack_kern == ATTACK_KERN_STRAIGHT)
5150 {
5151 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5152 }
5153 else if (attack_kern == ATTACK_KERN_COMBI)
5154 {
5155 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5156 }
5157 */
5158 }
5159
5160 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5161
5162 if (data.devices_status == STATUS_CRACKED) break;
5163 if (data.devices_status == STATUS_ABORTED) break;
5164 if (data.devices_status == STATUS_QUIT) break;
5165 if (data.devices_status == STATUS_BYPASS) break;
5166
5167 if (words_fin == 0) break;
5168
5169 device_param->words_done = words_fin;
5170 }
5171
5172 if (attack_mode == ATTACK_MODE_COMBI)
5173 {
5174 fclose (device_param->combs_fp);
5175 }
5176
5177 free (wl_data->buf);
5178 free (wl_data);
5179
5180 fclose (fd);
5181 }
5182
5183 device_param->kernel_accel = 0;
5184 device_param->kernel_loops = 0;
5185
5186 return NULL;
5187 }
5188
5189 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5190 {
5191 if (!device_param)
5192 {
5193 log_error ("ERROR: %s : Invalid argument", __func__);
5194
5195 exit (-1);
5196 }
5197
5198 salt_t *salt_buf = &data.salts_buf[salt_pos];
5199
5200 device_param->kernel_params_buf32[24] = salt_pos;
5201 device_param->kernel_params_buf32[27] = 1;
5202 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
5203 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
5204 device_param->kernel_params_buf32[30] = 0;
5205 device_param->kernel_params_buf32[31] = 1;
5206
5207 char *dictfile_old = data.dictfile;
5208
5209 const char *weak_hash_check = "weak-hash-check";
5210
5211 data.dictfile = (char *) weak_hash_check;
5212
5213 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5214
5215 data.kernel_rules_buf[0].cmds[0] = 0;
5216
5217 /**
5218 * run the kernel
5219 */
5220
5221 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5222 {
5223 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5224 }
5225 else
5226 {
5227 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5228
5229 uint loop_step = 16;
5230
5231 const uint iter = salt_buf->salt_iter;
5232
5233 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5234 {
5235 uint loop_left = iter - loop_pos;
5236
5237 loop_left = MIN (loop_left, loop_step);
5238
5239 device_param->kernel_params_buf32[25] = loop_pos;
5240 device_param->kernel_params_buf32[26] = loop_left;
5241
5242 run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5243 }
5244
5245 run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5246 }
5247
5248 /**
5249 * result
5250 */
5251
5252 check_cracked (device_param, salt_pos);
5253
5254 /**
5255 * cleanup
5256 */
5257
5258 device_param->kernel_params_buf32[24] = 0;
5259 device_param->kernel_params_buf32[25] = 0;
5260 device_param->kernel_params_buf32[26] = 0;
5261 device_param->kernel_params_buf32[27] = 0;
5262 device_param->kernel_params_buf32[28] = 0;
5263 device_param->kernel_params_buf32[29] = 0;
5264 device_param->kernel_params_buf32[30] = 0;
5265 device_param->kernel_params_buf32[31] = 0;
5266
5267 data.dictfile = dictfile_old;
5268
5269 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5270 }
5271
5272 // hlfmt hashcat
5273
5274 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5275 {
5276 if (data.username == 0)
5277 {
5278 *hashbuf_pos = line_buf;
5279 *hashbuf_len = line_len;
5280 }
5281 else
5282 {
5283 char *pos = line_buf;
5284 int len = line_len;
5285
5286 for (int i = 0; i < line_len; i++, pos++, len--)
5287 {
5288 if (line_buf[i] == data.separator)
5289 {
5290 pos++;
5291
5292 len--;
5293
5294 break;
5295 }
5296 }
5297
5298 *hashbuf_pos = pos;
5299 *hashbuf_len = len;
5300 }
5301 }
5302
5303 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5304 {
5305 char *pos = NULL;
5306 int len = 0;
5307
5308 int sep_cnt = 0;
5309
5310 for (int i = 0; i < line_len; i++)
5311 {
5312 if (line_buf[i] == data.separator)
5313 {
5314 sep_cnt++;
5315
5316 continue;
5317 }
5318
5319 if (sep_cnt == 0)
5320 {
5321 if (pos == NULL) pos = line_buf + i;
5322
5323 len++;
5324 }
5325 }
5326
5327 *userbuf_pos = pos;
5328 *userbuf_len = len;
5329 }
5330
5331 // hlfmt pwdump
5332
5333 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5334 {
5335 int sep_cnt = 0;
5336
5337 int sep2_len = 0;
5338 int sep3_len = 0;
5339
5340 for (int i = 0; i < line_len; i++)
5341 {
5342 if (line_buf[i] == ':')
5343 {
5344 sep_cnt++;
5345
5346 continue;
5347 }
5348
5349 if (sep_cnt == 2) sep2_len++;
5350 if (sep_cnt == 3) sep3_len++;
5351 }
5352
5353 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5354
5355 return 0;
5356 }
5357
5358 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5359 {
5360 char *pos = NULL;
5361 int len = 0;
5362
5363 int sep_cnt = 0;
5364
5365 for (int i = 0; i < line_len; i++)
5366 {
5367 if (line_buf[i] == ':')
5368 {
5369 sep_cnt++;
5370
5371 continue;
5372 }
5373
5374 if (data.hash_mode == 1000)
5375 {
5376 if (sep_cnt == 3)
5377 {
5378 if (pos == NULL) pos = line_buf + i;
5379
5380 len++;
5381 }
5382 }
5383 else if (data.hash_mode == 3000)
5384 {
5385 if (sep_cnt == 2)
5386 {
5387 if (pos == NULL) pos = line_buf + i;
5388
5389 len++;
5390 }
5391 }
5392 }
5393
5394 *hashbuf_pos = pos;
5395 *hashbuf_len = len;
5396 }
5397
5398 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5399 {
5400 char *pos = NULL;
5401 int len = 0;
5402
5403 int sep_cnt = 0;
5404
5405 for (int i = 0; i < line_len; i++)
5406 {
5407 if (line_buf[i] == ':')
5408 {
5409 sep_cnt++;
5410
5411 continue;
5412 }
5413
5414 if (sep_cnt == 0)
5415 {
5416 if (pos == NULL) pos = line_buf + i;
5417
5418 len++;
5419 }
5420 }
5421
5422 *userbuf_pos = pos;
5423 *userbuf_len = len;
5424 }
5425
5426 // hlfmt passwd
5427
5428 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5429 {
5430 int sep_cnt = 0;
5431
5432 char sep5_first = 0;
5433 char sep6_first = 0;
5434
5435 for (int i = 0; i < line_len; i++)
5436 {
5437 if (line_buf[i] == ':')
5438 {
5439 sep_cnt++;
5440
5441 continue;
5442 }
5443
5444 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5445 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5446 }
5447
5448 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5449
5450 return 0;
5451 }
5452
5453 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5454 {
5455 char *pos = NULL;
5456 int len = 0;
5457
5458 int sep_cnt = 0;
5459
5460 for (int i = 0; i < line_len; i++)
5461 {
5462 if (line_buf[i] == ':')
5463 {
5464 sep_cnt++;
5465
5466 continue;
5467 }
5468
5469 if (sep_cnt == 1)
5470 {
5471 if (pos == NULL) pos = line_buf + i;
5472
5473 len++;
5474 }
5475 }
5476
5477 *hashbuf_pos = pos;
5478 *hashbuf_len = len;
5479 }
5480
5481 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5482 {
5483 char *pos = NULL;
5484 int len = 0;
5485
5486 int sep_cnt = 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 == 0)
5498 {
5499 if (pos == NULL) pos = line_buf + i;
5500
5501 len++;
5502 }
5503 }
5504
5505 *userbuf_pos = pos;
5506 *userbuf_len = len;
5507 }
5508
5509 // hlfmt shadow
5510
5511 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5512 {
5513 int sep_cnt = 0;
5514
5515 for (int i = 0; i < line_len; i++)
5516 {
5517 if (line_buf[i] == ':') sep_cnt++;
5518 }
5519
5520 if (sep_cnt == 8) return 1;
5521
5522 return 0;
5523 }
5524
5525 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5526 {
5527 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5528 }
5529
5530 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5531 {
5532 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5533 }
5534
5535 // hlfmt main
5536
5537 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5538 {
5539 switch (hashfile_format)
5540 {
5541 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5542 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5543 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5544 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5545 }
5546 }
5547
5548 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5549 {
5550 switch (hashfile_format)
5551 {
5552 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5553 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5554 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5555 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5556 }
5557 }
5558
5559 char *strhlfmt (const uint hashfile_format)
5560 {
5561 switch (hashfile_format)
5562 {
5563 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5564 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5565 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5566 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5567 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5568 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5569 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5570 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5571 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5572 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5573 }
5574
5575 return ((char *) "Unknown");
5576 }
5577
5578 static uint hlfmt_detect (FILE *fp, uint max_check)
5579 {
5580 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5581
5582 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5583 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5584
5585 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5586
5587 uint num_check = 0;
5588
5589 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5590
5591 while (!feof (fp))
5592 {
5593 int line_len = fgetl (fp, line_buf);
5594
5595 if (line_len == 0) continue;
5596
5597 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5598 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5599 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5600
5601 if (num_check == max_check) break;
5602
5603 num_check++;
5604 }
5605
5606 myfree (line_buf);
5607
5608 uint hashlist_format = HLFMT_HASHCAT;
5609
5610 for (int i = 1; i < HLFMTS_CNT; i++)
5611 {
5612 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5613
5614 hashlist_format = i;
5615 }
5616
5617 free (formats_cnt);
5618
5619 return hashlist_format;
5620 }
5621
5622 /**
5623 * some further helper function
5624 */
5625
5626 // wrapper around mymalloc for ADL
5627
5628 #if defined(HAVE_HWMON)
5629 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5630 {
5631 return mymalloc (iSize);
5632 }
5633 #endif
5634
5635 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)
5636 {
5637 u64 collisions = 0;
5638
5639 const uint dgst_pos0 = data.dgst_pos0;
5640 const uint dgst_pos1 = data.dgst_pos1;
5641 const uint dgst_pos2 = data.dgst_pos2;
5642 const uint dgst_pos3 = data.dgst_pos3;
5643
5644 memset (bitmap_a, 0, bitmap_size);
5645 memset (bitmap_b, 0, bitmap_size);
5646 memset (bitmap_c, 0, bitmap_size);
5647 memset (bitmap_d, 0, bitmap_size);
5648
5649 for (uint i = 0; i < digests_cnt; i++)
5650 {
5651 uint *digest_ptr = (uint *) digests_buf_ptr;
5652
5653 digests_buf_ptr += dgst_size;
5654
5655 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5656 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5657 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5658 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5659
5660 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5661 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5662 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5663 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5664
5665 if (bitmap_a[idx0] & val0) collisions++;
5666 if (bitmap_b[idx1] & val1) collisions++;
5667 if (bitmap_c[idx2] & val2) collisions++;
5668 if (bitmap_d[idx3] & val3) collisions++;
5669
5670 bitmap_a[idx0] |= val0;
5671 bitmap_b[idx1] |= val1;
5672 bitmap_c[idx2] |= val2;
5673 bitmap_d[idx3] |= val3;
5674
5675 if (collisions >= collisions_max) return 0x7fffffff;
5676 }
5677
5678 return collisions;
5679 }
5680
5681 /**
5682 * main
5683 */
5684
5685 #ifdef WIN
5686 void SetConsoleWindowSize (const int x)
5687 {
5688 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5689
5690 if (h == INVALID_HANDLE_VALUE) return;
5691
5692 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5693
5694 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5695
5696 SMALL_RECT *sr = &bufferInfo.srWindow;
5697
5698 sr->Right = MAX (sr->Right, x - 1);
5699
5700 COORD co;
5701
5702 co.X = sr->Right + 1;
5703 co.Y = 9999;
5704
5705 if (!SetConsoleScreenBufferSize (h, co)) return;
5706
5707 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5708 }
5709 #endif
5710
5711 int main (int argc, char **argv)
5712 {
5713 #ifdef WIN
5714 SetConsoleWindowSize (132);
5715 #endif
5716
5717 /**
5718 * To help users a bit
5719 */
5720
5721 char *compute = getenv ("COMPUTE");
5722
5723 if (compute)
5724 {
5725 static char display[100];
5726
5727 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5728
5729 putenv (display);
5730 }
5731 else
5732 {
5733 if (getenv ("DISPLAY") == NULL)
5734 putenv ((char *) "DISPLAY=:0");
5735 }
5736
5737 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5738 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5739
5740 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5741 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5742
5743 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5744 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5745
5746 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5747 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5748
5749 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5750 putenv ((char *) "POCL_KERNEL_CACHE=0");
5751
5752 umask (077);
5753
5754 /**
5755 * Real init
5756 */
5757
5758 memset (&data, 0, sizeof (hc_global_data_t));
5759
5760 time_t proc_start;
5761
5762 time (&proc_start);
5763
5764 data.proc_start = proc_start;
5765
5766 int myargc = argc;
5767 char **myargv = argv;
5768
5769 hc_thread_mutex_init (mux_dispatcher);
5770 hc_thread_mutex_init (mux_counter);
5771 hc_thread_mutex_init (mux_display);
5772 hc_thread_mutex_init (mux_adl);
5773
5774 /**
5775 * commandline parameters
5776 */
5777
5778 uint usage = USAGE;
5779 uint version = VERSION;
5780 uint quiet = QUIET;
5781 uint benchmark = BENCHMARK;
5782 uint stdout_flag = STDOUT_FLAG;
5783 uint show = SHOW;
5784 uint left = LEFT;
5785 uint username = USERNAME;
5786 uint remove = REMOVE;
5787 uint remove_timer = REMOVE_TIMER;
5788 u64 skip = SKIP;
5789 u64 limit = LIMIT;
5790 uint keyspace = KEYSPACE;
5791 uint potfile_disable = POTFILE_DISABLE;
5792 char *potfile_path = NULL;
5793 uint debug_mode = DEBUG_MODE;
5794 char *debug_file = NULL;
5795 char *induction_dir = NULL;
5796 char *outfile_check_dir = NULL;
5797 uint force = FORCE;
5798 uint runtime = RUNTIME;
5799 uint hash_mode = HASH_MODE;
5800 uint attack_mode = ATTACK_MODE;
5801 uint markov_disable = MARKOV_DISABLE;
5802 uint markov_classic = MARKOV_CLASSIC;
5803 uint markov_threshold = MARKOV_THRESHOLD;
5804 char *markov_hcstat = NULL;
5805 char *outfile = NULL;
5806 uint outfile_format = OUTFILE_FORMAT;
5807 uint outfile_autohex = OUTFILE_AUTOHEX;
5808 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5809 uint restore = RESTORE;
5810 uint restore_timer = RESTORE_TIMER;
5811 uint restore_disable = RESTORE_DISABLE;
5812 uint status = STATUS;
5813 uint status_timer = STATUS_TIMER;
5814 uint machine_readable = MACHINE_READABLE;
5815 uint loopback = LOOPBACK;
5816 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5817 char *session = NULL;
5818 uint hex_charset = HEX_CHARSET;
5819 uint hex_salt = HEX_SALT;
5820 uint hex_wordlist = HEX_WORDLIST;
5821 uint rp_gen = RP_GEN;
5822 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5823 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5824 uint rp_gen_seed = RP_GEN_SEED;
5825 char *rule_buf_l = (char *) RULE_BUF_L;
5826 char *rule_buf_r = (char *) RULE_BUF_R;
5827 uint increment = INCREMENT;
5828 uint increment_min = INCREMENT_MIN;
5829 uint increment_max = INCREMENT_MAX;
5830 char *cpu_affinity = NULL;
5831 OCL_PTR *ocl = NULL;
5832 char *opencl_devices = NULL;
5833 char *opencl_platforms = NULL;
5834 char *opencl_device_types = NULL;
5835 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5836 char *truecrypt_keyfiles = NULL;
5837 char *veracrypt_keyfiles = NULL;
5838 uint veracrypt_pim = 0;
5839 uint workload_profile = WORKLOAD_PROFILE;
5840 uint kernel_accel = KERNEL_ACCEL;
5841 uint kernel_loops = KERNEL_LOOPS;
5842 uint nvidia_spin_damp = NVIDIA_SPIN_DAMP;
5843 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5844 #ifdef HAVE_HWMON
5845 uint gpu_temp_abort = GPU_TEMP_ABORT;
5846 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5847 uint powertune_enable = POWERTUNE_ENABLE;
5848 #endif
5849 uint logfile_disable = LOGFILE_DISABLE;
5850 uint segment_size = SEGMENT_SIZE;
5851 uint scrypt_tmto = SCRYPT_TMTO;
5852 char separator = SEPARATOR;
5853 uint bitmap_min = BITMAP_MIN;
5854 uint bitmap_max = BITMAP_MAX;
5855 char *custom_charset_1 = NULL;
5856 char *custom_charset_2 = NULL;
5857 char *custom_charset_3 = NULL;
5858 char *custom_charset_4 = NULL;
5859
5860 #define IDX_HELP 'h'
5861 #define IDX_VERSION 'V'
5862 #define IDX_VERSION_LOWER 'v'
5863 #define IDX_QUIET 0xff02
5864 #define IDX_SHOW 0xff03
5865 #define IDX_LEFT 0xff04
5866 #define IDX_REMOVE 0xff05
5867 #define IDX_REMOVE_TIMER 0xff37
5868 #define IDX_SKIP 's'
5869 #define IDX_LIMIT 'l'
5870 #define IDX_KEYSPACE 0xff35
5871 #define IDX_POTFILE_DISABLE 0xff06
5872 #define IDX_POTFILE_PATH 0xffe0
5873 #define IDX_DEBUG_MODE 0xff43
5874 #define IDX_DEBUG_FILE 0xff44
5875 #define IDX_INDUCTION_DIR 0xff46
5876 #define IDX_OUTFILE_CHECK_DIR 0xff47
5877 #define IDX_USERNAME 0xff07
5878 #define IDX_FORCE 0xff08
5879 #define IDX_RUNTIME 0xff09
5880 #define IDX_BENCHMARK 'b'
5881 #define IDX_STDOUT_FLAG 0xff77
5882 #define IDX_HASH_MODE 'm'
5883 #define IDX_ATTACK_MODE 'a'
5884 #define IDX_RP_FILE 'r'
5885 #define IDX_RP_GEN 'g'
5886 #define IDX_RP_GEN_FUNC_MIN 0xff10
5887 #define IDX_RP_GEN_FUNC_MAX 0xff11
5888 #define IDX_RP_GEN_SEED 0xff34
5889 #define IDX_RULE_BUF_L 'j'
5890 #define IDX_RULE_BUF_R 'k'
5891 #define IDX_INCREMENT 'i'
5892 #define IDX_INCREMENT_MIN 0xff12
5893 #define IDX_INCREMENT_MAX 0xff13
5894 #define IDX_OUTFILE 'o'
5895 #define IDX_OUTFILE_FORMAT 0xff14
5896 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5897 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5898 #define IDX_RESTORE 0xff15
5899 #define IDX_RESTORE_DISABLE 0xff27
5900 #define IDX_STATUS 0xff17
5901 #define IDX_STATUS_TIMER 0xff18
5902 #define IDX_MACHINE_READABLE 0xff50
5903 #define IDX_LOOPBACK 0xff38
5904 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5905 #define IDX_SESSION 0xff19
5906 #define IDX_HEX_CHARSET 0xff20
5907 #define IDX_HEX_SALT 0xff21
5908 #define IDX_HEX_WORDLIST 0xff40
5909 #define IDX_MARKOV_DISABLE 0xff22
5910 #define IDX_MARKOV_CLASSIC 0xff23
5911 #define IDX_MARKOV_THRESHOLD 't'
5912 #define IDX_MARKOV_HCSTAT 0xff24
5913 #define IDX_CPU_AFFINITY 0xff25
5914 #define IDX_OPENCL_DEVICES 'd'
5915 #define IDX_OPENCL_PLATFORMS 0xff72
5916 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5917 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5918 #define IDX_WORKLOAD_PROFILE 'w'
5919 #define IDX_KERNEL_ACCEL 'n'
5920 #define IDX_KERNEL_LOOPS 'u'
5921 #define IDX_NVIDIA_SPIN_DAMP 0xff79
5922 #define IDX_GPU_TEMP_DISABLE 0xff29
5923 #define IDX_GPU_TEMP_ABORT 0xff30
5924 #define IDX_GPU_TEMP_RETAIN 0xff31
5925 #define IDX_POWERTUNE_ENABLE 0xff41
5926 #define IDX_LOGFILE_DISABLE 0xff51
5927 #define IDX_TRUECRYPT_KEYFILES 0xff52
5928 #define IDX_VERACRYPT_KEYFILES 0xff53
5929 #define IDX_VERACRYPT_PIM 0xff54
5930 #define IDX_SCRYPT_TMTO 0xff61
5931 #define IDX_SEGMENT_SIZE 'c'
5932 #define IDX_SEPARATOR 'p'
5933 #define IDX_BITMAP_MIN 0xff70
5934 #define IDX_BITMAP_MAX 0xff71
5935 #define IDX_CUSTOM_CHARSET_1 '1'
5936 #define IDX_CUSTOM_CHARSET_2 '2'
5937 #define IDX_CUSTOM_CHARSET_3 '3'
5938 #define IDX_CUSTOM_CHARSET_4 '4'
5939
5940 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5941
5942 struct option long_options[] =
5943 {
5944 {"help", no_argument, 0, IDX_HELP},
5945 {"version", no_argument, 0, IDX_VERSION},
5946 {"quiet", no_argument, 0, IDX_QUIET},
5947 {"show", no_argument, 0, IDX_SHOW},
5948 {"left", no_argument, 0, IDX_LEFT},
5949 {"username", no_argument, 0, IDX_USERNAME},
5950 {"remove", no_argument, 0, IDX_REMOVE},
5951 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5952 {"skip", required_argument, 0, IDX_SKIP},
5953 {"limit", required_argument, 0, IDX_LIMIT},
5954 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5955 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5956 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5957 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5958 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5959 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5960 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5961 {"force", no_argument, 0, IDX_FORCE},
5962 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5963 {"stdout", no_argument, 0, IDX_STDOUT_FLAG},
5964 {"restore", no_argument, 0, IDX_RESTORE},
5965 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5966 {"status", no_argument, 0, IDX_STATUS},
5967 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5968 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5969 {"loopback", no_argument, 0, IDX_LOOPBACK},
5970 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5971 {"session", required_argument, 0, IDX_SESSION},
5972 {"runtime", required_argument, 0, IDX_RUNTIME},
5973 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5974 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5975 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5976 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5977 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5978 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5979 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5980 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5981 {"rules-file", required_argument, 0, IDX_RP_FILE},
5982 {"outfile", required_argument, 0, IDX_OUTFILE},
5983 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5984 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5985 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5986 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5987 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5988 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5989 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5990 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5991 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5992 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5993 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5994 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5995 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5996 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5997 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5998 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5999 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
6000 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
6001 {"nvidia-spin-damp", required_argument, 0, IDX_NVIDIA_SPIN_DAMP},
6002 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
6003 #ifdef HAVE_HWMON
6004 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
6005 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
6006 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
6007 #endif // HAVE_HWMON
6008 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
6009 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
6010 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
6011 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
6012 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
6013 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
6014 {"seperator", required_argument, 0, IDX_SEPARATOR},
6015 {"separator", required_argument, 0, IDX_SEPARATOR},
6016 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
6017 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
6018 {"increment", no_argument, 0, IDX_INCREMENT},
6019 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
6020 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
6021 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
6022 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
6023 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
6024 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
6025 {0, 0, 0, 0}
6026 };
6027
6028 uint rp_files_cnt = 0;
6029
6030 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6031
6032 int option_index = 0;
6033 int c = -1;
6034
6035 optind = 1;
6036 optopt = 0;
6037
6038 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6039 {
6040 switch (c)
6041 {
6042 case IDX_HELP: usage = 1; break;
6043 case IDX_VERSION:
6044 case IDX_VERSION_LOWER: version = 1; break;
6045 case IDX_RESTORE: restore = 1; break;
6046 case IDX_SESSION: session = optarg; break;
6047 case IDX_SHOW: show = 1; break;
6048 case IDX_LEFT: left = 1; break;
6049 case '?': return (-1);
6050 }
6051 }
6052
6053 if (optopt != 0)
6054 {
6055 log_error ("ERROR: Invalid argument specified");
6056
6057 return (-1);
6058 }
6059
6060 /**
6061 * exit functions
6062 */
6063
6064 if (version)
6065 {
6066 log_info ("%s", VERSION_TAG);
6067
6068 return (0);
6069 }
6070
6071 if (usage)
6072 {
6073 usage_big_print (PROGNAME);
6074
6075 return (0);
6076 }
6077
6078 /**
6079 * session needs to be set, always!
6080 */
6081
6082 if (session == NULL) session = (char *) PROGNAME;
6083
6084 /**
6085 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6086 */
6087
6088 char *exec_path = get_exec_path ();
6089
6090 #ifdef LINUX
6091
6092 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6093 char *resolved_exec_path = realpath (exec_path, NULL);
6094
6095 char *install_dir = get_install_dir (resolved_exec_path);
6096 char *profile_dir = NULL;
6097 char *session_dir = NULL;
6098 char *shared_dir = NULL;
6099
6100 if (strcmp (install_dir, resolved_install_folder) == 0)
6101 {
6102 struct passwd *pw = getpwuid (getuid ());
6103
6104 const char *homedir = pw->pw_dir;
6105
6106 profile_dir = get_profile_dir (homedir);
6107 session_dir = get_session_dir (profile_dir);
6108 shared_dir = strdup (SHARED_FOLDER);
6109
6110 mkdir (profile_dir, 0700);
6111 mkdir (session_dir, 0700);
6112 }
6113 else
6114 {
6115 profile_dir = install_dir;
6116 session_dir = install_dir;
6117 shared_dir = install_dir;
6118 }
6119
6120 myfree (resolved_install_folder);
6121 myfree (resolved_exec_path);
6122
6123 #else
6124
6125 char *install_dir = get_install_dir (exec_path);
6126 char *profile_dir = install_dir;
6127 char *session_dir = install_dir;
6128 char *shared_dir = install_dir;
6129
6130 #endif
6131
6132 data.install_dir = install_dir;
6133 data.profile_dir = profile_dir;
6134 data.session_dir = session_dir;
6135 data.shared_dir = shared_dir;
6136
6137 myfree (exec_path);
6138
6139 /**
6140 * kernel cache, we need to make sure folder exist
6141 */
6142
6143 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6144
6145 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6146
6147 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6148
6149 mkdir (kernels_folder, 0700);
6150
6151 myfree (kernels_folder);
6152
6153 /**
6154 * session
6155 */
6156
6157 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6158
6159 data.session = session;
6160
6161 char *eff_restore_file = (char *) mymalloc (session_size);
6162 char *new_restore_file = (char *) mymalloc (session_size);
6163
6164 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
6165 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6166
6167 data.eff_restore_file = eff_restore_file;
6168 data.new_restore_file = new_restore_file;
6169
6170 if (((show == 1) || (left == 1)) && (restore == 1))
6171 {
6172 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6173 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6174
6175 return (-1);
6176 }
6177
6178 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6179 if ((show == 1) || (left == 1))
6180 {
6181 restore_disable = 1;
6182
6183 restore = 0;
6184 }
6185
6186 data.restore_disable = restore_disable;
6187
6188 restore_data_t *rd = init_restore (argc, argv);
6189
6190 data.rd = rd;
6191
6192 /**
6193 * restore file
6194 */
6195
6196 if (restore == 1)
6197 {
6198 read_restore (eff_restore_file, rd);
6199
6200 if (rd->version_bin < RESTORE_MIN)
6201 {
6202 log_error ("ERROR: Incompatible restore-file version");
6203
6204 return (-1);
6205 }
6206
6207 myargc = rd->argc;
6208 myargv = rd->argv;
6209
6210 #ifdef _POSIX
6211 rd->pid = getpid ();
6212 #elif _WIN
6213 rd->pid = GetCurrentProcessId ();
6214 #endif
6215 }
6216
6217 uint hash_mode_chgd = 0;
6218 uint runtime_chgd = 0;
6219 uint kernel_loops_chgd = 0;
6220 uint kernel_accel_chgd = 0;
6221 uint nvidia_spin_damp_chgd = 0;
6222 uint attack_mode_chgd = 0;
6223 uint outfile_format_chgd = 0;
6224 uint rp_gen_seed_chgd = 0;
6225 uint remove_timer_chgd = 0;
6226 uint increment_min_chgd = 0;
6227 uint increment_max_chgd = 0;
6228 uint workload_profile_chgd = 0;
6229 uint opencl_vector_width_chgd = 0;
6230
6231 optind = 1;
6232 optopt = 0;
6233 option_index = 0;
6234
6235 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6236 {
6237 switch (c)
6238 {
6239 //case IDX_HELP: usage = 1; break;
6240 //case IDX_VERSION: version = 1; break;
6241 //case IDX_RESTORE: restore = 1; break;
6242 case IDX_QUIET: quiet = 1; break;
6243 //case IDX_SHOW: show = 1; break;
6244 case IDX_SHOW: break;
6245 //case IDX_LEFT: left = 1; break;
6246 case IDX_LEFT: break;
6247 case IDX_USERNAME: username = 1; break;
6248 case IDX_REMOVE: remove = 1; break;
6249 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6250 remove_timer_chgd = 1; break;
6251 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6252 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6253 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6254 case IDX_DEBUG_FILE: debug_file = optarg; break;
6255 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6256 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6257 case IDX_FORCE: force = 1; break;
6258 case IDX_SKIP: skip = atoll (optarg); break;
6259 case IDX_LIMIT: limit = atoll (optarg); break;
6260 case IDX_KEYSPACE: keyspace = 1; break;
6261 case IDX_BENCHMARK: benchmark = 1; break;
6262 case IDX_STDOUT_FLAG: stdout_flag = 1; break;
6263 case IDX_RESTORE: break;
6264 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6265 case IDX_STATUS: status = 1; break;
6266 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6267 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6268 case IDX_LOOPBACK: loopback = 1; break;
6269 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6270 //case IDX_SESSION: session = optarg; break;
6271 case IDX_SESSION: break;
6272 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6273 hash_mode_chgd = 1; break;
6274 case IDX_RUNTIME: runtime = atoi (optarg);
6275 runtime_chgd = 1; break;
6276 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6277 attack_mode_chgd = 1; break;
6278 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6279 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6280 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6281 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6282 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6283 rp_gen_seed_chgd = 1; break;
6284 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6285 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6286 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6287 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6288 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6289 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6290 case IDX_OUTFILE: outfile = optarg; break;
6291 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6292 outfile_format_chgd = 1; break;
6293 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6294 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6295 case IDX_HEX_CHARSET: hex_charset = 1; break;
6296 case IDX_HEX_SALT: hex_salt = 1; break;
6297 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6298 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6299 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6300 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6301 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6302 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6303 opencl_vector_width_chgd = 1; break;
6304 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6305 workload_profile_chgd = 1; break;
6306 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6307 kernel_accel_chgd = 1; break;
6308 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6309 kernel_loops_chgd = 1; break;
6310 case IDX_NVIDIA_SPIN_DAMP: nvidia_spin_damp = atoi (optarg);
6311 nvidia_spin_damp_chgd = 1; break;
6312 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6313 #ifdef HAVE_HWMON
6314 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6315 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6316 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6317 #endif // HAVE_HWMON
6318 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6319 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6320 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6321 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6322 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6323 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6324 case IDX_SEPARATOR: separator = optarg[0]; break;
6325 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6326 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6327 case IDX_INCREMENT: increment = 1; break;
6328 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6329 increment_min_chgd = 1; break;
6330 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6331 increment_max_chgd = 1; break;
6332 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6333 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6334 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6335 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6336
6337 default:
6338 log_error ("ERROR: Invalid argument specified");
6339 return (-1);
6340 }
6341 }
6342
6343 if (optopt != 0)
6344 {
6345 log_error ("ERROR: Invalid argument specified");
6346
6347 return (-1);
6348 }
6349
6350 /**
6351 * Inform user things getting started,
6352 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6353 * - we do not need to check algorithm_pos
6354 */
6355
6356 if (quiet == 0)
6357 {
6358 if (benchmark == 1)
6359 {
6360 if (machine_readable == 0)
6361 {
6362 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6363 log_info ("");
6364 log_info ("Note: Reported benchmark cracking speed = real cracking speed");
6365 log_info ("To verify, run hashcat like this: only_one_hash.txt -a 3 -w 3 ?b?b?b?b?b?b?b");
6366 log_info ("");
6367 }
6368 else
6369 {
6370 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6371 }
6372 }
6373 else if (restore == 1)
6374 {
6375 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6376 log_info ("");
6377 }
6378 else if (stdout_flag == 1)
6379 {
6380 // do nothing
6381 }
6382 else
6383 {
6384 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6385 log_info ("");
6386 }
6387 }
6388
6389 /**
6390 * sanity check
6391 */
6392
6393 if (attack_mode > 7)
6394 {
6395 log_error ("ERROR: Invalid attack-mode specified");
6396
6397 return (-1);
6398 }
6399
6400 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6401 {
6402 log_error ("ERROR: Invalid runtime specified");
6403
6404 return (-1);
6405 }
6406
6407 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6408 {
6409 log_error ("ERROR: Invalid hash-type specified");
6410
6411 return (-1);
6412 }
6413
6414 // renamed hash modes
6415
6416 if (hash_mode_chgd)
6417 {
6418 int n = -1;
6419
6420 switch (hash_mode)
6421 {
6422 case 123: n = 124;
6423 break;
6424 }
6425
6426 if (n >= 0)
6427 {
6428 log_error ("Old -m specified, use -m %d instead", n);
6429
6430 return (-1);
6431 }
6432 }
6433
6434 if (username == 1)
6435 {
6436 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6437 {
6438 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6439
6440 return (-1);
6441 }
6442 }
6443
6444 if (outfile_format > 16)
6445 {
6446 log_error ("ERROR: Invalid outfile-format specified");
6447
6448 return (-1);
6449 }
6450
6451 if (left == 1)
6452 {
6453 if (outfile_format_chgd == 1)
6454 {
6455 if (outfile_format > 1)
6456 {
6457 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6458
6459 return (-1);
6460 }
6461 }
6462 else
6463 {
6464 outfile_format = OUTFILE_FMT_HASH;
6465 }
6466 }
6467
6468 if (show == 1)
6469 {
6470 if (outfile_format_chgd == 1)
6471 {
6472 if ((outfile_format > 7) && (outfile_format < 16))
6473 {
6474 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6475
6476 return (-1);
6477 }
6478 }
6479 }
6480
6481 if (increment_min < INCREMENT_MIN)
6482 {
6483 log_error ("ERROR: Invalid increment-min specified");
6484
6485 return (-1);
6486 }
6487
6488 if (increment_max > INCREMENT_MAX)
6489 {
6490 log_error ("ERROR: Invalid increment-max specified");
6491
6492 return (-1);
6493 }
6494
6495 if (increment_min > increment_max)
6496 {
6497 log_error ("ERROR: Invalid increment-min specified");
6498
6499 return (-1);
6500 }
6501
6502 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6503 {
6504 log_error ("ERROR: increment is not allowed in attack-mode 0");
6505
6506 return (-1);
6507 }
6508
6509 if ((increment == 0) && (increment_min_chgd == 1))
6510 {
6511 log_error ("ERROR: increment-min is only supported together with increment switch");
6512
6513 return (-1);
6514 }
6515
6516 if ((increment == 0) && (increment_max_chgd == 1))
6517 {
6518 log_error ("ERROR: increment-max is only supported together with increment switch");
6519
6520 return (-1);
6521 }
6522
6523 if (rp_files_cnt && rp_gen)
6524 {
6525 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6526
6527 return (-1);
6528 }
6529
6530 if (rp_files_cnt || rp_gen)
6531 {
6532 if (attack_mode != ATTACK_MODE_STRAIGHT)
6533 {
6534 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6535
6536 return (-1);
6537 }
6538 }
6539
6540 if (rp_gen_func_min > rp_gen_func_max)
6541 {
6542 log_error ("ERROR: Invalid rp-gen-func-min specified");
6543
6544 return (-1);
6545 }
6546
6547 if (kernel_accel_chgd == 1)
6548 {
6549 if (force == 0)
6550 {
6551 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6552 log_info ("Please consider using the option -w instead");
6553 log_info ("You can use --force to override this but do not post error reports if you do so");
6554 log_info ("");
6555
6556 return (-1);
6557 }
6558
6559 if (kernel_accel < 1)
6560 {
6561 log_error ("ERROR: Invalid kernel-accel specified");
6562
6563 return (-1);
6564 }
6565
6566 if (kernel_accel > 1024)
6567 {
6568 log_error ("ERROR: Invalid kernel-accel specified");
6569
6570 return (-1);
6571 }
6572 }
6573
6574 if (kernel_loops_chgd == 1)
6575 {
6576 if (force == 0)
6577 {
6578 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6579 log_info ("Please consider using the option -w instead");
6580 log_info ("You can use --force to override this but do not post error reports if you do so");
6581 log_info ("");
6582
6583 return (-1);
6584 }
6585
6586 if (kernel_loops < 1)
6587 {
6588 log_error ("ERROR: Invalid kernel-loops specified");
6589
6590 return (-1);
6591 }
6592
6593 if (kernel_loops > 1024)
6594 {
6595 log_error ("ERROR: Invalid kernel-loops specified");
6596
6597 return (-1);
6598 }
6599 }
6600
6601 if ((workload_profile < 1) || (workload_profile > 4))
6602 {
6603 log_error ("ERROR: workload-profile %i not available", workload_profile);
6604
6605 return (-1);
6606 }
6607
6608 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6609 {
6610 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6611
6612 return (-1);
6613 }
6614
6615 if (show == 1 || left == 1)
6616 {
6617 attack_mode = ATTACK_MODE_NONE;
6618
6619 if (remove == 1)
6620 {
6621 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6622
6623 return (-1);
6624 }
6625
6626 if (potfile_disable == 1)
6627 {
6628 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6629
6630 return (-1);
6631 }
6632 }
6633
6634 uint attack_kern = ATTACK_KERN_NONE;
6635
6636 switch (attack_mode)
6637 {
6638 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6639 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6640 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6641 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6642 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6643 }
6644
6645 if (benchmark == 1)
6646 {
6647 if (myargv[optind] != 0)
6648 {
6649 log_error ("ERROR: Invalid argument for benchmark mode specified");
6650
6651 return (-1);
6652 }
6653
6654 if (attack_mode_chgd == 1)
6655 {
6656 if (attack_mode != ATTACK_MODE_BF)
6657 {
6658 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6659
6660 return (-1);
6661 }
6662 }
6663 }
6664 else
6665 {
6666 if (stdout_flag == 1) // no hash here
6667 {
6668 optind--;
6669 }
6670
6671 if (keyspace == 1)
6672 {
6673 int num_additional_params = 1;
6674
6675 if (attack_kern == ATTACK_KERN_COMBI)
6676 {
6677 num_additional_params = 2;
6678 }
6679
6680 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6681
6682 if (keyspace_wordlist_specified == 0) optind--;
6683 }
6684
6685 if (attack_kern == ATTACK_KERN_NONE)
6686 {
6687 if ((optind + 1) != myargc)
6688 {
6689 usage_mini_print (myargv[0]);
6690
6691 return (-1);
6692 }
6693 }
6694 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6695 {
6696 if ((optind + 1) > myargc)
6697 {
6698 usage_mini_print (myargv[0]);
6699
6700 return (-1);
6701 }
6702 }
6703 else if (attack_kern == ATTACK_KERN_COMBI)
6704 {
6705 if ((optind + 3) != myargc)
6706 {
6707 usage_mini_print (myargv[0]);
6708
6709 return (-1);
6710 }
6711 }
6712 else if (attack_kern == ATTACK_KERN_BF)
6713 {
6714 if ((optind + 1) > myargc)
6715 {
6716 usage_mini_print (myargv[0]);
6717
6718 return (-1);
6719 }
6720 }
6721 else
6722 {
6723 usage_mini_print (myargv[0]);
6724
6725 return (-1);
6726 }
6727 }
6728
6729 if (skip != 0 && limit != 0)
6730 {
6731 limit += skip;
6732 }
6733
6734 if (keyspace == 1)
6735 {
6736 if (show == 1)
6737 {
6738 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6739
6740 return (-1);
6741 }
6742 else if (left == 1)
6743 {
6744 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6745
6746 return (-1);
6747 }
6748
6749 potfile_disable = 1;
6750
6751 restore_disable = 1;
6752
6753 restore = 0;
6754
6755 weak_hash_threshold = 0;
6756
6757 quiet = 1;
6758 }
6759
6760 if (stdout_flag == 1)
6761 {
6762 status_timer = 0;
6763 restore_timer = 0;
6764 restore_disable = 1;
6765 restore = 0;
6766 potfile_disable = 1;
6767 weak_hash_threshold = 0;
6768 gpu_temp_disable = 1;
6769 hash_mode = 2000;
6770 quiet = 1;
6771 outfile_format = OUTFILE_FMT_PLAIN;
6772 kernel_accel = 1024;
6773 kernel_loops = 1024;
6774 force = 1;
6775 outfile_check_timer = 0;
6776 }
6777
6778 if (remove_timer_chgd == 1)
6779 {
6780 if (remove == 0)
6781 {
6782 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6783
6784 return (-1);
6785 }
6786
6787 if (remove_timer < 1)
6788 {
6789 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6790
6791 return (-1);
6792 }
6793 }
6794
6795 if (loopback == 1)
6796 {
6797 if (attack_mode == ATTACK_MODE_STRAIGHT)
6798 {
6799 if ((rp_files_cnt == 0) && (rp_gen == 0))
6800 {
6801 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6802
6803 return (-1);
6804 }
6805 }
6806 else
6807 {
6808 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6809
6810 return (-1);
6811 }
6812 }
6813
6814 if (debug_mode > 0)
6815 {
6816 if (attack_mode != ATTACK_MODE_STRAIGHT)
6817 {
6818 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6819
6820 return (-1);
6821 }
6822
6823 if ((rp_files_cnt == 0) && (rp_gen == 0))
6824 {
6825 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6826
6827 return (-1);
6828 }
6829 }
6830
6831 if (debug_mode > 4)
6832 {
6833 log_error ("ERROR: Invalid debug-mode specified");
6834
6835 return (-1);
6836 }
6837
6838 if (debug_file != NULL)
6839 {
6840 if (debug_mode < 1)
6841 {
6842 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6843
6844 return (-1);
6845 }
6846 }
6847
6848 if (induction_dir != NULL)
6849 {
6850 if (attack_mode == ATTACK_MODE_BF)
6851 {
6852 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6853
6854 return (-1);
6855 }
6856 }
6857
6858 if (attack_mode != ATTACK_MODE_STRAIGHT)
6859 {
6860 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6861 {
6862 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6863
6864 return (-1);
6865 }
6866
6867 weak_hash_threshold = 0;
6868 }
6869
6870 if (nvidia_spin_damp > 100)
6871 {
6872 log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)");
6873
6874 return (-1);
6875 }
6876
6877
6878 /**
6879 * induction directory
6880 */
6881
6882 char *induction_directory = NULL;
6883
6884 if (attack_mode != ATTACK_MODE_BF)
6885 {
6886 if (induction_dir == NULL)
6887 {
6888 induction_directory = (char *) mymalloc (session_size);
6889
6890 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6891
6892 // create induction folder if it does not already exist
6893
6894 if (keyspace == 0)
6895 {
6896 if (rmdir (induction_directory) == -1)
6897 {
6898 if (errno == ENOENT)
6899 {
6900 // good, we can ignore
6901 }
6902 else if (errno == ENOTEMPTY)
6903 {
6904 char *induction_directory_mv = (char *) mymalloc (session_size);
6905
6906 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6907
6908 if (rename (induction_directory, induction_directory_mv) != 0)
6909 {
6910 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6911
6912 return (-1);
6913 }
6914 }
6915 else
6916 {
6917 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6918
6919 return (-1);
6920 }
6921 }
6922
6923 if (mkdir (induction_directory, 0700) == -1)
6924 {
6925 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6926
6927 return (-1);
6928 }
6929 }
6930 }
6931 else
6932 {
6933 induction_directory = induction_dir;
6934 }
6935 }
6936
6937 data.induction_directory = induction_directory;
6938
6939 /**
6940 * loopback
6941 */
6942
6943 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6944
6945 char *loopback_file = (char *) mymalloc (loopback_size);
6946
6947 /**
6948 * tuning db
6949 */
6950
6951 char tuning_db_file[256] = { 0 };
6952
6953 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6954
6955 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6956
6957 /**
6958 * outfile-check directory
6959 */
6960
6961 char *outfile_check_directory = NULL;
6962
6963 if (outfile_check_dir == NULL)
6964 {
6965 outfile_check_directory = (char *) mymalloc (session_size);
6966
6967 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6968 }
6969 else
6970 {
6971 outfile_check_directory = outfile_check_dir;
6972 }
6973
6974 data.outfile_check_directory = outfile_check_directory;
6975
6976 if (keyspace == 0)
6977 {
6978 struct stat outfile_check_stat;
6979
6980 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6981 {
6982 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6983
6984 if (is_dir == 0)
6985 {
6986 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6987
6988 return (-1);
6989 }
6990 }
6991 else if (outfile_check_dir == NULL)
6992 {
6993 if (mkdir (outfile_check_directory, 0700) == -1)
6994 {
6995 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6996
6997 return (-1);
6998 }
6999 }
7000 }
7001
7002 /**
7003 * special other stuff
7004 */
7005
7006 if (hash_mode == 9710)
7007 {
7008 outfile_format = 5;
7009 outfile_format_chgd = 1;
7010 }
7011
7012 if (hash_mode == 9810)
7013 {
7014 outfile_format = 5;
7015 outfile_format_chgd = 1;
7016 }
7017
7018 if (hash_mode == 10410)
7019 {
7020 outfile_format = 5;
7021 outfile_format_chgd = 1;
7022 }
7023
7024 /**
7025 * store stuff
7026 */
7027
7028 data.hash_mode = hash_mode;
7029 data.restore = restore;
7030 data.restore_timer = restore_timer;
7031 data.restore_disable = restore_disable;
7032 data.status = status;
7033 data.status_timer = status_timer;
7034 data.machine_readable = machine_readable;
7035 data.loopback = loopback;
7036 data.runtime = runtime;
7037 data.remove = remove;
7038 data.remove_timer = remove_timer;
7039 data.debug_mode = debug_mode;
7040 data.debug_file = debug_file;
7041 data.username = username;
7042 data.quiet = quiet;
7043 data.outfile = outfile;
7044 data.outfile_format = outfile_format;
7045 data.outfile_autohex = outfile_autohex;
7046 data.hex_charset = hex_charset;
7047 data.hex_salt = hex_salt;
7048 data.hex_wordlist = hex_wordlist;
7049 data.separator = separator;
7050 data.rp_files = rp_files;
7051 data.rp_files_cnt = rp_files_cnt;
7052 data.rp_gen = rp_gen;
7053 data.rp_gen_seed = rp_gen_seed;
7054 data.force = force;
7055 data.benchmark = benchmark;
7056 data.skip = skip;
7057 data.limit = limit;
7058 #ifdef HAVE_HWMON
7059 data.powertune_enable = powertune_enable;
7060 #endif
7061 data.logfile_disable = logfile_disable;
7062 data.truecrypt_keyfiles = truecrypt_keyfiles;
7063 data.veracrypt_keyfiles = veracrypt_keyfiles;
7064 data.veracrypt_pim = veracrypt_pim;
7065 data.scrypt_tmto = scrypt_tmto;
7066 data.workload_profile = workload_profile;
7067
7068 /**
7069 * cpu affinity
7070 */
7071
7072 if (cpu_affinity)
7073 {
7074 set_cpu_affinity (cpu_affinity);
7075 }
7076
7077 if (rp_gen_seed_chgd == 0)
7078 {
7079 srand (proc_start);
7080 }
7081 else
7082 {
7083 srand (rp_gen_seed);
7084 }
7085
7086 /**
7087 * logfile init
7088 */
7089
7090 if (logfile_disable == 0)
7091 {
7092 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7093
7094 char *logfile = (char *) mymalloc (logfile_size);
7095
7096 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7097
7098 data.logfile = logfile;
7099
7100 char *topid = logfile_generate_topid ();
7101
7102 data.topid = topid;
7103 }
7104
7105 // logfile_append() checks for logfile_disable internally to make it easier from here
7106
7107 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7108 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7109 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7110 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7111 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7112 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7113 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7114 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7115 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7116 #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));
7117
7118 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7119 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7120 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7121 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7122 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7123 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7124 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7125 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7126
7127 logfile_top_msg ("START");
7128
7129 logfile_top_uint (attack_mode);
7130 logfile_top_uint (attack_kern);
7131 logfile_top_uint (benchmark);
7132 logfile_top_uint (stdout_flag);
7133 logfile_top_uint (bitmap_min);
7134 logfile_top_uint (bitmap_max);
7135 logfile_top_uint (debug_mode);
7136 logfile_top_uint (force);
7137 logfile_top_uint (kernel_accel);
7138 logfile_top_uint (kernel_loops);
7139 logfile_top_uint (nvidia_spin_damp);
7140 logfile_top_uint (gpu_temp_disable);
7141 #ifdef HAVE_HWMON
7142 logfile_top_uint (gpu_temp_abort);
7143 logfile_top_uint (gpu_temp_retain);
7144 #endif
7145 logfile_top_uint (hash_mode);
7146 logfile_top_uint (hex_charset);
7147 logfile_top_uint (hex_salt);
7148 logfile_top_uint (hex_wordlist);
7149 logfile_top_uint (increment);
7150 logfile_top_uint (increment_max);
7151 logfile_top_uint (increment_min);
7152 logfile_top_uint (keyspace);
7153 logfile_top_uint (left);
7154 logfile_top_uint (logfile_disable);
7155 logfile_top_uint (loopback);
7156 logfile_top_uint (markov_classic);
7157 logfile_top_uint (markov_disable);
7158 logfile_top_uint (markov_threshold);
7159 logfile_top_uint (outfile_autohex);
7160 logfile_top_uint (outfile_check_timer);
7161 logfile_top_uint (outfile_format);
7162 logfile_top_uint (potfile_disable);
7163 logfile_top_string (potfile_path);
7164 #if defined(HAVE_HWMON)
7165 logfile_top_uint (powertune_enable);
7166 #endif
7167 logfile_top_uint (scrypt_tmto);
7168 logfile_top_uint (quiet);
7169 logfile_top_uint (remove);
7170 logfile_top_uint (remove_timer);
7171 logfile_top_uint (restore);
7172 logfile_top_uint (restore_disable);
7173 logfile_top_uint (restore_timer);
7174 logfile_top_uint (rp_gen);
7175 logfile_top_uint (rp_gen_func_max);
7176 logfile_top_uint (rp_gen_func_min);
7177 logfile_top_uint (rp_gen_seed);
7178 logfile_top_uint (runtime);
7179 logfile_top_uint (segment_size);
7180 logfile_top_uint (show);
7181 logfile_top_uint (status);
7182 logfile_top_uint (machine_readable);
7183 logfile_top_uint (status_timer);
7184 logfile_top_uint (usage);
7185 logfile_top_uint (username);
7186 logfile_top_uint (version);
7187 logfile_top_uint (weak_hash_threshold);
7188 logfile_top_uint (workload_profile);
7189 logfile_top_uint64 (limit);
7190 logfile_top_uint64 (skip);
7191 logfile_top_char (separator);
7192 logfile_top_string (cpu_affinity);
7193 logfile_top_string (custom_charset_1);
7194 logfile_top_string (custom_charset_2);
7195 logfile_top_string (custom_charset_3);
7196 logfile_top_string (custom_charset_4);
7197 logfile_top_string (debug_file);
7198 logfile_top_string (opencl_devices);
7199 logfile_top_string (opencl_platforms);
7200 logfile_top_string (opencl_device_types);
7201 logfile_top_uint (opencl_vector_width);
7202 logfile_top_string (induction_dir);
7203 logfile_top_string (markov_hcstat);
7204 logfile_top_string (outfile);
7205 logfile_top_string (outfile_check_dir);
7206 logfile_top_string (rule_buf_l);
7207 logfile_top_string (rule_buf_r);
7208 logfile_top_string (session);
7209 logfile_top_string (truecrypt_keyfiles);
7210 logfile_top_string (veracrypt_keyfiles);
7211 logfile_top_uint (veracrypt_pim);
7212
7213 /**
7214 * Init OpenCL library loader
7215 */
7216
7217 if (keyspace == 0)
7218 {
7219 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7220
7221 ocl_init (ocl);
7222
7223 data.ocl = ocl;
7224 }
7225
7226 /**
7227 * OpenCL platform selection
7228 */
7229
7230 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7231
7232 /**
7233 * OpenCL device selection
7234 */
7235
7236 u32 devices_filter = setup_devices_filter (opencl_devices);
7237
7238 /**
7239 * OpenCL device type selection
7240 */
7241
7242 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7243
7244 /**
7245 * benchmark
7246 */
7247
7248 if (benchmark == 1)
7249 {
7250 /**
7251 * disable useless stuff for benchmark
7252 */
7253
7254 status_timer = 0;
7255 restore_timer = 0;
7256 restore_disable = 1;
7257 potfile_disable = 1;
7258 weak_hash_threshold = 0;
7259 nvidia_spin_damp = 0;
7260 gpu_temp_disable = 1;
7261 outfile_check_timer = 0;
7262
7263 #ifdef HAVE_HWMON
7264 if (powertune_enable == 1)
7265 {
7266 gpu_temp_disable = 0;
7267 }
7268 #endif
7269
7270 data.status_timer = status_timer;
7271 data.restore_timer = restore_timer;
7272 data.restore_disable = restore_disable;
7273 data.outfile_check_timer = outfile_check_timer;
7274
7275 /**
7276 * force attack mode to be bruteforce
7277 */
7278
7279 attack_mode = ATTACK_MODE_BF;
7280 attack_kern = ATTACK_KERN_BF;
7281
7282 if (workload_profile_chgd == 0)
7283 {
7284 workload_profile = 3;
7285
7286 data.workload_profile = workload_profile;
7287 }
7288 }
7289
7290 /**
7291 * config
7292 */
7293
7294 uint hash_type = 0;
7295 uint salt_type = 0;
7296 uint attack_exec = 0;
7297 uint opts_type = 0;
7298 uint kern_type = 0;
7299 uint dgst_size = 0;
7300 uint esalt_size = 0;
7301 uint opti_type = 0;
7302 uint dgst_pos0 = -1;
7303 uint dgst_pos1 = -1;
7304 uint dgst_pos2 = -1;
7305 uint dgst_pos3 = -1;
7306
7307 int (*parse_func) (char *, uint, hash_t *);
7308 int (*sort_by_digest) (const void *, const void *);
7309
7310 uint algorithm_pos = 0;
7311 uint algorithm_max = 1;
7312
7313 uint *algorithms = default_benchmark_algorithms;
7314
7315 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7316
7317 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7318 {
7319 /*
7320 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7321 * the following algos are skipped entirely
7322 */
7323
7324 if (algorithm_pos > 0)
7325 {
7326 local_free (rd);
7327
7328 rd = init_restore (argc, argv);
7329
7330 data.rd = rd;
7331 }
7332
7333 /**
7334 * update hash_mode in case of multihash benchmark
7335 */
7336
7337 if (benchmark == 1)
7338 {
7339 if (hash_mode_chgd == 0)
7340 {
7341 hash_mode = algorithms[algorithm_pos];
7342
7343 data.hash_mode = hash_mode;
7344 }
7345
7346 quiet = 1;
7347
7348 data.quiet = quiet;
7349 }
7350
7351 switch (hash_mode)
7352 {
7353 case 0: hash_type = HASH_TYPE_MD5;
7354 salt_type = SALT_TYPE_NONE;
7355 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7356 opts_type = OPTS_TYPE_PT_GENERATE_LE
7357 | OPTS_TYPE_PT_ADD80
7358 | OPTS_TYPE_PT_ADDBITS14;
7359 kern_type = KERN_TYPE_MD5;
7360 dgst_size = DGST_SIZE_4_4;
7361 parse_func = md5_parse_hash;
7362 sort_by_digest = sort_by_digest_4_4;
7363 opti_type = OPTI_TYPE_ZERO_BYTE
7364 | OPTI_TYPE_PRECOMPUTE_INIT
7365 | OPTI_TYPE_PRECOMPUTE_MERKLE
7366 | OPTI_TYPE_MEET_IN_MIDDLE
7367 | OPTI_TYPE_EARLY_SKIP
7368 | OPTI_TYPE_NOT_ITERATED
7369 | OPTI_TYPE_NOT_SALTED
7370 | OPTI_TYPE_RAW_HASH;
7371 dgst_pos0 = 0;
7372 dgst_pos1 = 3;
7373 dgst_pos2 = 2;
7374 dgst_pos3 = 1;
7375 break;
7376
7377 case 10: hash_type = HASH_TYPE_MD5;
7378 salt_type = SALT_TYPE_INTERN;
7379 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7380 opts_type = OPTS_TYPE_PT_GENERATE_LE
7381 | OPTS_TYPE_ST_ADD80
7382 | OPTS_TYPE_ST_ADDBITS14;
7383 kern_type = KERN_TYPE_MD5_PWSLT;
7384 dgst_size = DGST_SIZE_4_4;
7385 parse_func = md5s_parse_hash;
7386 sort_by_digest = sort_by_digest_4_4;
7387 opti_type = OPTI_TYPE_ZERO_BYTE
7388 | OPTI_TYPE_PRECOMPUTE_INIT
7389 | OPTI_TYPE_PRECOMPUTE_MERKLE
7390 | OPTI_TYPE_MEET_IN_MIDDLE
7391 | OPTI_TYPE_EARLY_SKIP
7392 | OPTI_TYPE_NOT_ITERATED
7393 | OPTI_TYPE_APPENDED_SALT
7394 | OPTI_TYPE_RAW_HASH;
7395 dgst_pos0 = 0;
7396 dgst_pos1 = 3;
7397 dgst_pos2 = 2;
7398 dgst_pos3 = 1;
7399 break;
7400
7401 case 11: hash_type = HASH_TYPE_MD5;
7402 salt_type = SALT_TYPE_INTERN;
7403 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7404 opts_type = OPTS_TYPE_PT_GENERATE_LE
7405 | OPTS_TYPE_ST_ADD80
7406 | OPTS_TYPE_ST_ADDBITS14;
7407 kern_type = KERN_TYPE_MD5_PWSLT;
7408 dgst_size = DGST_SIZE_4_4;
7409 parse_func = joomla_parse_hash;
7410 sort_by_digest = sort_by_digest_4_4;
7411 opti_type = OPTI_TYPE_ZERO_BYTE
7412 | OPTI_TYPE_PRECOMPUTE_INIT
7413 | OPTI_TYPE_PRECOMPUTE_MERKLE
7414 | OPTI_TYPE_MEET_IN_MIDDLE
7415 | OPTI_TYPE_EARLY_SKIP
7416 | OPTI_TYPE_NOT_ITERATED
7417 | OPTI_TYPE_APPENDED_SALT
7418 | OPTI_TYPE_RAW_HASH;
7419 dgst_pos0 = 0;
7420 dgst_pos1 = 3;
7421 dgst_pos2 = 2;
7422 dgst_pos3 = 1;
7423 break;
7424
7425 case 12: hash_type = HASH_TYPE_MD5;
7426 salt_type = SALT_TYPE_INTERN;
7427 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7428 opts_type = OPTS_TYPE_PT_GENERATE_LE
7429 | OPTS_TYPE_ST_ADD80
7430 | OPTS_TYPE_ST_ADDBITS14;
7431 kern_type = KERN_TYPE_MD5_PWSLT;
7432 dgst_size = DGST_SIZE_4_4;
7433 parse_func = postgresql_parse_hash;
7434 sort_by_digest = sort_by_digest_4_4;
7435 opti_type = OPTI_TYPE_ZERO_BYTE
7436 | OPTI_TYPE_PRECOMPUTE_INIT
7437 | OPTI_TYPE_PRECOMPUTE_MERKLE
7438 | OPTI_TYPE_MEET_IN_MIDDLE
7439 | OPTI_TYPE_EARLY_SKIP
7440 | OPTI_TYPE_NOT_ITERATED
7441 | OPTI_TYPE_APPENDED_SALT
7442 | OPTI_TYPE_RAW_HASH;
7443 dgst_pos0 = 0;
7444 dgst_pos1 = 3;
7445 dgst_pos2 = 2;
7446 dgst_pos3 = 1;
7447 break;
7448
7449 case 20: hash_type = HASH_TYPE_MD5;
7450 salt_type = SALT_TYPE_INTERN;
7451 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7452 opts_type = OPTS_TYPE_PT_GENERATE_LE
7453 | OPTS_TYPE_PT_ADD80
7454 | OPTS_TYPE_PT_ADDBITS14;
7455 kern_type = KERN_TYPE_MD5_SLTPW;
7456 dgst_size = DGST_SIZE_4_4;
7457 parse_func = md5s_parse_hash;
7458 sort_by_digest = sort_by_digest_4_4;
7459 opti_type = OPTI_TYPE_ZERO_BYTE
7460 | OPTI_TYPE_PRECOMPUTE_INIT
7461 | OPTI_TYPE_PRECOMPUTE_MERKLE
7462 | OPTI_TYPE_EARLY_SKIP
7463 | OPTI_TYPE_NOT_ITERATED
7464 | OPTI_TYPE_PREPENDED_SALT
7465 | OPTI_TYPE_RAW_HASH;
7466 dgst_pos0 = 0;
7467 dgst_pos1 = 3;
7468 dgst_pos2 = 2;
7469 dgst_pos3 = 1;
7470 break;
7471
7472 case 21: hash_type = HASH_TYPE_MD5;
7473 salt_type = SALT_TYPE_INTERN;
7474 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7475 opts_type = OPTS_TYPE_PT_GENERATE_LE
7476 | OPTS_TYPE_PT_ADD80
7477 | OPTS_TYPE_PT_ADDBITS14;
7478 kern_type = KERN_TYPE_MD5_SLTPW;
7479 dgst_size = DGST_SIZE_4_4;
7480 parse_func = osc_parse_hash;
7481 sort_by_digest = sort_by_digest_4_4;
7482 opti_type = OPTI_TYPE_ZERO_BYTE
7483 | OPTI_TYPE_PRECOMPUTE_INIT
7484 | OPTI_TYPE_PRECOMPUTE_MERKLE
7485 | OPTI_TYPE_EARLY_SKIP
7486 | OPTI_TYPE_NOT_ITERATED
7487 | OPTI_TYPE_PREPENDED_SALT
7488 | OPTI_TYPE_RAW_HASH;
7489 dgst_pos0 = 0;
7490 dgst_pos1 = 3;
7491 dgst_pos2 = 2;
7492 dgst_pos3 = 1;
7493 break;
7494
7495 case 22: hash_type = HASH_TYPE_MD5;
7496 salt_type = SALT_TYPE_EMBEDDED;
7497 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7498 opts_type = OPTS_TYPE_PT_GENERATE_LE
7499 | OPTS_TYPE_PT_ADD80
7500 | OPTS_TYPE_PT_ADDBITS14;
7501 kern_type = KERN_TYPE_MD5_SLTPW;
7502 dgst_size = DGST_SIZE_4_4;
7503 parse_func = netscreen_parse_hash;
7504 sort_by_digest = sort_by_digest_4_4;
7505 opti_type = OPTI_TYPE_ZERO_BYTE
7506 | OPTI_TYPE_PRECOMPUTE_INIT
7507 | OPTI_TYPE_PRECOMPUTE_MERKLE
7508 | OPTI_TYPE_EARLY_SKIP
7509 | OPTI_TYPE_NOT_ITERATED
7510 | OPTI_TYPE_PREPENDED_SALT
7511 | OPTI_TYPE_RAW_HASH;
7512 dgst_pos0 = 0;
7513 dgst_pos1 = 3;
7514 dgst_pos2 = 2;
7515 dgst_pos3 = 1;
7516 break;
7517
7518 case 23: hash_type = HASH_TYPE_MD5;
7519 salt_type = SALT_TYPE_EMBEDDED;
7520 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7521 opts_type = OPTS_TYPE_PT_GENERATE_LE
7522 | OPTS_TYPE_PT_ADD80
7523 | OPTS_TYPE_PT_ADDBITS14;
7524 kern_type = KERN_TYPE_MD5_SLTPW;
7525 dgst_size = DGST_SIZE_4_4;
7526 parse_func = skype_parse_hash;
7527 sort_by_digest = sort_by_digest_4_4;
7528 opti_type = OPTI_TYPE_ZERO_BYTE
7529 | OPTI_TYPE_PRECOMPUTE_INIT
7530 | OPTI_TYPE_PRECOMPUTE_MERKLE
7531 | OPTI_TYPE_EARLY_SKIP
7532 | OPTI_TYPE_NOT_ITERATED
7533 | OPTI_TYPE_PREPENDED_SALT
7534 | OPTI_TYPE_RAW_HASH;
7535 dgst_pos0 = 0;
7536 dgst_pos1 = 3;
7537 dgst_pos2 = 2;
7538 dgst_pos3 = 1;
7539 break;
7540
7541 case 30: hash_type = HASH_TYPE_MD5;
7542 salt_type = SALT_TYPE_INTERN;
7543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7544 opts_type = OPTS_TYPE_PT_GENERATE_LE
7545 | OPTS_TYPE_PT_UNICODE
7546 | OPTS_TYPE_ST_ADD80
7547 | OPTS_TYPE_ST_ADDBITS14;
7548 kern_type = KERN_TYPE_MD5_PWUSLT;
7549 dgst_size = DGST_SIZE_4_4;
7550 parse_func = md5s_parse_hash;
7551 sort_by_digest = sort_by_digest_4_4;
7552 opti_type = OPTI_TYPE_ZERO_BYTE
7553 | OPTI_TYPE_PRECOMPUTE_INIT
7554 | OPTI_TYPE_PRECOMPUTE_MERKLE
7555 | OPTI_TYPE_MEET_IN_MIDDLE
7556 | OPTI_TYPE_EARLY_SKIP
7557 | OPTI_TYPE_NOT_ITERATED
7558 | OPTI_TYPE_APPENDED_SALT
7559 | OPTI_TYPE_RAW_HASH;
7560 dgst_pos0 = 0;
7561 dgst_pos1 = 3;
7562 dgst_pos2 = 2;
7563 dgst_pos3 = 1;
7564 break;
7565
7566 case 40: hash_type = HASH_TYPE_MD5;
7567 salt_type = SALT_TYPE_INTERN;
7568 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7569 opts_type = OPTS_TYPE_PT_GENERATE_LE
7570 | OPTS_TYPE_PT_ADD80
7571 | OPTS_TYPE_PT_ADDBITS14
7572 | OPTS_TYPE_PT_UNICODE;
7573 kern_type = KERN_TYPE_MD5_SLTPWU;
7574 dgst_size = DGST_SIZE_4_4;
7575 parse_func = md5s_parse_hash;
7576 sort_by_digest = sort_by_digest_4_4;
7577 opti_type = OPTI_TYPE_ZERO_BYTE
7578 | OPTI_TYPE_PRECOMPUTE_INIT
7579 | OPTI_TYPE_PRECOMPUTE_MERKLE
7580 | OPTI_TYPE_EARLY_SKIP
7581 | OPTI_TYPE_NOT_ITERATED
7582 | OPTI_TYPE_PREPENDED_SALT
7583 | OPTI_TYPE_RAW_HASH;
7584 dgst_pos0 = 0;
7585 dgst_pos1 = 3;
7586 dgst_pos2 = 2;
7587 dgst_pos3 = 1;
7588 break;
7589
7590 case 50: hash_type = HASH_TYPE_MD5;
7591 salt_type = SALT_TYPE_INTERN;
7592 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7593 opts_type = OPTS_TYPE_PT_GENERATE_LE
7594 | OPTS_TYPE_ST_ADD80
7595 | OPTS_TYPE_ST_ADDBITS14;
7596 kern_type = KERN_TYPE_HMACMD5_PW;
7597 dgst_size = DGST_SIZE_4_4;
7598 parse_func = hmacmd5_parse_hash;
7599 sort_by_digest = sort_by_digest_4_4;
7600 opti_type = OPTI_TYPE_ZERO_BYTE
7601 | OPTI_TYPE_NOT_ITERATED;
7602 dgst_pos0 = 0;
7603 dgst_pos1 = 3;
7604 dgst_pos2 = 2;
7605 dgst_pos3 = 1;
7606 break;
7607
7608 case 60: hash_type = HASH_TYPE_MD5;
7609 salt_type = SALT_TYPE_INTERN;
7610 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7611 opts_type = OPTS_TYPE_PT_GENERATE_LE
7612 | OPTS_TYPE_PT_ADD80
7613 | OPTS_TYPE_PT_ADDBITS14;
7614 kern_type = KERN_TYPE_HMACMD5_SLT;
7615 dgst_size = DGST_SIZE_4_4;
7616 parse_func = hmacmd5_parse_hash;
7617 sort_by_digest = sort_by_digest_4_4;
7618 opti_type = OPTI_TYPE_ZERO_BYTE
7619 | OPTI_TYPE_NOT_ITERATED;
7620 dgst_pos0 = 0;
7621 dgst_pos1 = 3;
7622 dgst_pos2 = 2;
7623 dgst_pos3 = 1;
7624 break;
7625
7626 case 100: hash_type = HASH_TYPE_SHA1;
7627 salt_type = SALT_TYPE_NONE;
7628 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7629 opts_type = OPTS_TYPE_PT_GENERATE_BE
7630 | OPTS_TYPE_PT_ADD80
7631 | OPTS_TYPE_PT_ADDBITS15;
7632 kern_type = KERN_TYPE_SHA1;
7633 dgst_size = DGST_SIZE_4_5;
7634 parse_func = sha1_parse_hash;
7635 sort_by_digest = sort_by_digest_4_5;
7636 opti_type = OPTI_TYPE_ZERO_BYTE
7637 | OPTI_TYPE_PRECOMPUTE_INIT
7638 | OPTI_TYPE_PRECOMPUTE_MERKLE
7639 | OPTI_TYPE_EARLY_SKIP
7640 | OPTI_TYPE_NOT_ITERATED
7641 | OPTI_TYPE_NOT_SALTED
7642 | OPTI_TYPE_RAW_HASH;
7643 dgst_pos0 = 3;
7644 dgst_pos1 = 4;
7645 dgst_pos2 = 2;
7646 dgst_pos3 = 1;
7647 break;
7648
7649 case 101: hash_type = HASH_TYPE_SHA1;
7650 salt_type = SALT_TYPE_NONE;
7651 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7652 opts_type = OPTS_TYPE_PT_GENERATE_BE
7653 | OPTS_TYPE_PT_ADD80
7654 | OPTS_TYPE_PT_ADDBITS15;
7655 kern_type = KERN_TYPE_SHA1;
7656 dgst_size = DGST_SIZE_4_5;
7657 parse_func = sha1b64_parse_hash;
7658 sort_by_digest = sort_by_digest_4_5;
7659 opti_type = OPTI_TYPE_ZERO_BYTE
7660 | OPTI_TYPE_PRECOMPUTE_INIT
7661 | OPTI_TYPE_PRECOMPUTE_MERKLE
7662 | OPTI_TYPE_EARLY_SKIP
7663 | OPTI_TYPE_NOT_ITERATED
7664 | OPTI_TYPE_NOT_SALTED
7665 | OPTI_TYPE_RAW_HASH;
7666 dgst_pos0 = 3;
7667 dgst_pos1 = 4;
7668 dgst_pos2 = 2;
7669 dgst_pos3 = 1;
7670 break;
7671
7672 case 110: hash_type = HASH_TYPE_SHA1;
7673 salt_type = SALT_TYPE_INTERN;
7674 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7675 opts_type = OPTS_TYPE_PT_GENERATE_BE
7676 | OPTS_TYPE_ST_ADD80
7677 | OPTS_TYPE_ST_ADDBITS15;
7678 kern_type = KERN_TYPE_SHA1_PWSLT;
7679 dgst_size = DGST_SIZE_4_5;
7680 parse_func = sha1s_parse_hash;
7681 sort_by_digest = sort_by_digest_4_5;
7682 opti_type = OPTI_TYPE_ZERO_BYTE
7683 | OPTI_TYPE_PRECOMPUTE_INIT
7684 | OPTI_TYPE_PRECOMPUTE_MERKLE
7685 | OPTI_TYPE_EARLY_SKIP
7686 | OPTI_TYPE_NOT_ITERATED
7687 | OPTI_TYPE_APPENDED_SALT
7688 | OPTI_TYPE_RAW_HASH;
7689 dgst_pos0 = 3;
7690 dgst_pos1 = 4;
7691 dgst_pos2 = 2;
7692 dgst_pos3 = 1;
7693 break;
7694
7695 case 111: hash_type = HASH_TYPE_SHA1;
7696 salt_type = SALT_TYPE_EMBEDDED;
7697 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7698 opts_type = OPTS_TYPE_PT_GENERATE_BE
7699 | OPTS_TYPE_ST_ADD80
7700 | OPTS_TYPE_ST_ADDBITS15;
7701 kern_type = KERN_TYPE_SHA1_PWSLT;
7702 dgst_size = DGST_SIZE_4_5;
7703 parse_func = sha1b64s_parse_hash;
7704 sort_by_digest = sort_by_digest_4_5;
7705 opti_type = OPTI_TYPE_ZERO_BYTE
7706 | OPTI_TYPE_PRECOMPUTE_INIT
7707 | OPTI_TYPE_PRECOMPUTE_MERKLE
7708 | OPTI_TYPE_EARLY_SKIP
7709 | OPTI_TYPE_NOT_ITERATED
7710 | OPTI_TYPE_APPENDED_SALT
7711 | OPTI_TYPE_RAW_HASH;
7712 dgst_pos0 = 3;
7713 dgst_pos1 = 4;
7714 dgst_pos2 = 2;
7715 dgst_pos3 = 1;
7716 break;
7717
7718 case 112: hash_type = HASH_TYPE_SHA1;
7719 salt_type = SALT_TYPE_INTERN;
7720 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7721 opts_type = OPTS_TYPE_PT_GENERATE_BE
7722 | OPTS_TYPE_ST_ADD80
7723 | OPTS_TYPE_ST_ADDBITS15
7724 | OPTS_TYPE_ST_HEX;
7725 kern_type = KERN_TYPE_SHA1_PWSLT;
7726 dgst_size = DGST_SIZE_4_5;
7727 parse_func = oracles_parse_hash;
7728 sort_by_digest = sort_by_digest_4_5;
7729 opti_type = OPTI_TYPE_ZERO_BYTE
7730 | OPTI_TYPE_PRECOMPUTE_INIT
7731 | OPTI_TYPE_PRECOMPUTE_MERKLE
7732 | OPTI_TYPE_EARLY_SKIP
7733 | OPTI_TYPE_NOT_ITERATED
7734 | OPTI_TYPE_APPENDED_SALT
7735 | OPTI_TYPE_RAW_HASH;
7736 dgst_pos0 = 3;
7737 dgst_pos1 = 4;
7738 dgst_pos2 = 2;
7739 dgst_pos3 = 1;
7740 break;
7741
7742 case 120: hash_type = HASH_TYPE_SHA1;
7743 salt_type = SALT_TYPE_INTERN;
7744 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7745 opts_type = OPTS_TYPE_PT_GENERATE_BE
7746 | OPTS_TYPE_PT_ADD80
7747 | OPTS_TYPE_PT_ADDBITS15;
7748 kern_type = KERN_TYPE_SHA1_SLTPW;
7749 dgst_size = DGST_SIZE_4_5;
7750 parse_func = sha1s_parse_hash;
7751 sort_by_digest = sort_by_digest_4_5;
7752 opti_type = OPTI_TYPE_ZERO_BYTE
7753 | OPTI_TYPE_PRECOMPUTE_INIT
7754 | OPTI_TYPE_PRECOMPUTE_MERKLE
7755 | OPTI_TYPE_EARLY_SKIP
7756 | OPTI_TYPE_NOT_ITERATED
7757 | OPTI_TYPE_PREPENDED_SALT
7758 | OPTI_TYPE_RAW_HASH;
7759 dgst_pos0 = 3;
7760 dgst_pos1 = 4;
7761 dgst_pos2 = 2;
7762 dgst_pos3 = 1;
7763 break;
7764
7765 case 121: hash_type = HASH_TYPE_SHA1;
7766 salt_type = SALT_TYPE_INTERN;
7767 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7768 opts_type = OPTS_TYPE_PT_GENERATE_BE
7769 | OPTS_TYPE_PT_ADD80
7770 | OPTS_TYPE_PT_ADDBITS15
7771 | OPTS_TYPE_ST_LOWER;
7772 kern_type = KERN_TYPE_SHA1_SLTPW;
7773 dgst_size = DGST_SIZE_4_5;
7774 parse_func = smf_parse_hash;
7775 sort_by_digest = sort_by_digest_4_5;
7776 opti_type = OPTI_TYPE_ZERO_BYTE
7777 | OPTI_TYPE_PRECOMPUTE_INIT
7778 | OPTI_TYPE_PRECOMPUTE_MERKLE
7779 | OPTI_TYPE_EARLY_SKIP
7780 | OPTI_TYPE_NOT_ITERATED
7781 | OPTI_TYPE_PREPENDED_SALT
7782 | OPTI_TYPE_RAW_HASH;
7783 dgst_pos0 = 3;
7784 dgst_pos1 = 4;
7785 dgst_pos2 = 2;
7786 dgst_pos3 = 1;
7787 break;
7788
7789 case 122: hash_type = HASH_TYPE_SHA1;
7790 salt_type = SALT_TYPE_EMBEDDED;
7791 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7792 opts_type = OPTS_TYPE_PT_GENERATE_BE
7793 | OPTS_TYPE_PT_ADD80
7794 | OPTS_TYPE_PT_ADDBITS15
7795 | OPTS_TYPE_ST_HEX;
7796 kern_type = KERN_TYPE_SHA1_SLTPW;
7797 dgst_size = DGST_SIZE_4_5;
7798 parse_func = osx1_parse_hash;
7799 sort_by_digest = sort_by_digest_4_5;
7800 opti_type = OPTI_TYPE_ZERO_BYTE
7801 | OPTI_TYPE_PRECOMPUTE_INIT
7802 | OPTI_TYPE_PRECOMPUTE_MERKLE
7803 | OPTI_TYPE_EARLY_SKIP
7804 | OPTI_TYPE_NOT_ITERATED
7805 | OPTI_TYPE_PREPENDED_SALT
7806 | OPTI_TYPE_RAW_HASH;
7807 dgst_pos0 = 3;
7808 dgst_pos1 = 4;
7809 dgst_pos2 = 2;
7810 dgst_pos3 = 1;
7811 break;
7812
7813 case 124: hash_type = HASH_TYPE_SHA1;
7814 salt_type = SALT_TYPE_EMBEDDED;
7815 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7816 opts_type = OPTS_TYPE_PT_GENERATE_BE
7817 | OPTS_TYPE_PT_ADD80
7818 | OPTS_TYPE_PT_ADDBITS15;
7819 kern_type = KERN_TYPE_SHA1_SLTPW;
7820 dgst_size = DGST_SIZE_4_5;
7821 parse_func = djangosha1_parse_hash;
7822 sort_by_digest = sort_by_digest_4_5;
7823 opti_type = OPTI_TYPE_ZERO_BYTE
7824 | OPTI_TYPE_PRECOMPUTE_INIT
7825 | OPTI_TYPE_PRECOMPUTE_MERKLE
7826 | OPTI_TYPE_EARLY_SKIP
7827 | OPTI_TYPE_NOT_ITERATED
7828 | OPTI_TYPE_PREPENDED_SALT
7829 | OPTI_TYPE_RAW_HASH;
7830 dgst_pos0 = 3;
7831 dgst_pos1 = 4;
7832 dgst_pos2 = 2;
7833 dgst_pos3 = 1;
7834 break;
7835
7836 case 125: hash_type = HASH_TYPE_SHA1;
7837 salt_type = SALT_TYPE_EMBEDDED;
7838 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7839 opts_type = OPTS_TYPE_PT_GENERATE_BE
7840 | OPTS_TYPE_PT_ADD80
7841 | OPTS_TYPE_PT_ADDBITS15
7842 | OPTS_TYPE_ST_HEX;
7843 kern_type = KERN_TYPE_SHA1_SLTPW;
7844 dgst_size = DGST_SIZE_4_5;
7845 parse_func = arubaos_parse_hash;
7846 sort_by_digest = sort_by_digest_4_5;
7847 opti_type = OPTI_TYPE_ZERO_BYTE
7848 | OPTI_TYPE_PRECOMPUTE_INIT
7849 | OPTI_TYPE_PRECOMPUTE_MERKLE
7850 | OPTI_TYPE_EARLY_SKIP
7851 | OPTI_TYPE_NOT_ITERATED
7852 | OPTI_TYPE_PREPENDED_SALT
7853 | OPTI_TYPE_RAW_HASH;
7854 dgst_pos0 = 3;
7855 dgst_pos1 = 4;
7856 dgst_pos2 = 2;
7857 dgst_pos3 = 1;
7858 break;
7859
7860 case 130: hash_type = HASH_TYPE_SHA1;
7861 salt_type = SALT_TYPE_INTERN;
7862 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7863 opts_type = OPTS_TYPE_PT_GENERATE_BE
7864 | OPTS_TYPE_PT_UNICODE
7865 | OPTS_TYPE_ST_ADD80
7866 | OPTS_TYPE_ST_ADDBITS15;
7867 kern_type = KERN_TYPE_SHA1_PWUSLT;
7868 dgst_size = DGST_SIZE_4_5;
7869 parse_func = sha1s_parse_hash;
7870 sort_by_digest = sort_by_digest_4_5;
7871 opti_type = OPTI_TYPE_ZERO_BYTE
7872 | OPTI_TYPE_PRECOMPUTE_INIT
7873 | OPTI_TYPE_PRECOMPUTE_MERKLE
7874 | OPTI_TYPE_EARLY_SKIP
7875 | OPTI_TYPE_NOT_ITERATED
7876 | OPTI_TYPE_APPENDED_SALT
7877 | OPTI_TYPE_RAW_HASH;
7878 dgst_pos0 = 3;
7879 dgst_pos1 = 4;
7880 dgst_pos2 = 2;
7881 dgst_pos3 = 1;
7882 break;
7883
7884 case 131: hash_type = HASH_TYPE_SHA1;
7885 salt_type = SALT_TYPE_EMBEDDED;
7886 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7887 opts_type = OPTS_TYPE_PT_GENERATE_BE
7888 | OPTS_TYPE_PT_UNICODE
7889 | OPTS_TYPE_PT_UPPER
7890 | OPTS_TYPE_ST_ADD80
7891 | OPTS_TYPE_ST_ADDBITS15
7892 | OPTS_TYPE_ST_HEX;
7893 kern_type = KERN_TYPE_SHA1_PWUSLT;
7894 dgst_size = DGST_SIZE_4_5;
7895 parse_func = mssql2000_parse_hash;
7896 sort_by_digest = sort_by_digest_4_5;
7897 opti_type = OPTI_TYPE_ZERO_BYTE
7898 | OPTI_TYPE_PRECOMPUTE_INIT
7899 | OPTI_TYPE_PRECOMPUTE_MERKLE
7900 | OPTI_TYPE_EARLY_SKIP
7901 | OPTI_TYPE_NOT_ITERATED
7902 | OPTI_TYPE_APPENDED_SALT
7903 | OPTI_TYPE_RAW_HASH;
7904 dgst_pos0 = 3;
7905 dgst_pos1 = 4;
7906 dgst_pos2 = 2;
7907 dgst_pos3 = 1;
7908 break;
7909
7910 case 132: hash_type = HASH_TYPE_SHA1;
7911 salt_type = SALT_TYPE_EMBEDDED;
7912 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7913 opts_type = OPTS_TYPE_PT_GENERATE_BE
7914 | OPTS_TYPE_PT_UNICODE
7915 | OPTS_TYPE_ST_ADD80
7916 | OPTS_TYPE_ST_ADDBITS15
7917 | OPTS_TYPE_ST_HEX;
7918 kern_type = KERN_TYPE_SHA1_PWUSLT;
7919 dgst_size = DGST_SIZE_4_5;
7920 parse_func = mssql2005_parse_hash;
7921 sort_by_digest = sort_by_digest_4_5;
7922 opti_type = OPTI_TYPE_ZERO_BYTE
7923 | OPTI_TYPE_PRECOMPUTE_INIT
7924 | OPTI_TYPE_PRECOMPUTE_MERKLE
7925 | OPTI_TYPE_EARLY_SKIP
7926 | OPTI_TYPE_NOT_ITERATED
7927 | OPTI_TYPE_APPENDED_SALT
7928 | OPTI_TYPE_RAW_HASH;
7929 dgst_pos0 = 3;
7930 dgst_pos1 = 4;
7931 dgst_pos2 = 2;
7932 dgst_pos3 = 1;
7933 break;
7934
7935 case 133: hash_type = HASH_TYPE_SHA1;
7936 salt_type = SALT_TYPE_EMBEDDED;
7937 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7938 opts_type = OPTS_TYPE_PT_GENERATE_BE
7939 | OPTS_TYPE_PT_UNICODE
7940 | OPTS_TYPE_ST_ADD80
7941 | OPTS_TYPE_ST_ADDBITS15;
7942 kern_type = KERN_TYPE_SHA1_PWUSLT;
7943 dgst_size = DGST_SIZE_4_5;
7944 parse_func = peoplesoft_parse_hash;
7945 sort_by_digest = sort_by_digest_4_5;
7946 opti_type = OPTI_TYPE_ZERO_BYTE
7947 | OPTI_TYPE_PRECOMPUTE_INIT
7948 | OPTI_TYPE_PRECOMPUTE_MERKLE
7949 | OPTI_TYPE_EARLY_SKIP
7950 | OPTI_TYPE_NOT_ITERATED
7951 | OPTI_TYPE_APPENDED_SALT
7952 | OPTI_TYPE_RAW_HASH;
7953 dgst_pos0 = 3;
7954 dgst_pos1 = 4;
7955 dgst_pos2 = 2;
7956 dgst_pos3 = 1;
7957 break;
7958
7959 case 140: hash_type = HASH_TYPE_SHA1;
7960 salt_type = SALT_TYPE_INTERN;
7961 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7962 opts_type = OPTS_TYPE_PT_GENERATE_BE
7963 | OPTS_TYPE_PT_ADD80
7964 | OPTS_TYPE_PT_ADDBITS15
7965 | OPTS_TYPE_PT_UNICODE;
7966 kern_type = KERN_TYPE_SHA1_SLTPWU;
7967 dgst_size = DGST_SIZE_4_5;
7968 parse_func = sha1s_parse_hash;
7969 sort_by_digest = sort_by_digest_4_5;
7970 opti_type = OPTI_TYPE_ZERO_BYTE
7971 | OPTI_TYPE_PRECOMPUTE_INIT
7972 | OPTI_TYPE_PRECOMPUTE_MERKLE
7973 | OPTI_TYPE_EARLY_SKIP
7974 | OPTI_TYPE_NOT_ITERATED
7975 | OPTI_TYPE_PREPENDED_SALT
7976 | OPTI_TYPE_RAW_HASH;
7977 dgst_pos0 = 3;
7978 dgst_pos1 = 4;
7979 dgst_pos2 = 2;
7980 dgst_pos3 = 1;
7981 break;
7982
7983 case 141: hash_type = HASH_TYPE_SHA1;
7984 salt_type = SALT_TYPE_EMBEDDED;
7985 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7986 opts_type = OPTS_TYPE_PT_GENERATE_BE
7987 | OPTS_TYPE_PT_ADD80
7988 | OPTS_TYPE_PT_ADDBITS15
7989 | OPTS_TYPE_PT_UNICODE
7990 | OPTS_TYPE_ST_BASE64;
7991 kern_type = KERN_TYPE_SHA1_SLTPWU;
7992 dgst_size = DGST_SIZE_4_5;
7993 parse_func = episerver_parse_hash;
7994 sort_by_digest = sort_by_digest_4_5;
7995 opti_type = OPTI_TYPE_ZERO_BYTE
7996 | OPTI_TYPE_PRECOMPUTE_INIT
7997 | OPTI_TYPE_PRECOMPUTE_MERKLE
7998 | OPTI_TYPE_EARLY_SKIP
7999 | OPTI_TYPE_NOT_ITERATED
8000 | OPTI_TYPE_PREPENDED_SALT
8001 | OPTI_TYPE_RAW_HASH;
8002 dgst_pos0 = 3;
8003 dgst_pos1 = 4;
8004 dgst_pos2 = 2;
8005 dgst_pos3 = 1;
8006 break;
8007
8008 case 150: hash_type = HASH_TYPE_SHA1;
8009 salt_type = SALT_TYPE_INTERN;
8010 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8011 opts_type = OPTS_TYPE_PT_GENERATE_BE
8012 | OPTS_TYPE_ST_ADD80
8013 | OPTS_TYPE_ST_ADDBITS15;
8014 kern_type = KERN_TYPE_HMACSHA1_PW;
8015 dgst_size = DGST_SIZE_4_5;
8016 parse_func = hmacsha1_parse_hash;
8017 sort_by_digest = sort_by_digest_4_5;
8018 opti_type = OPTI_TYPE_ZERO_BYTE
8019 | OPTI_TYPE_NOT_ITERATED;
8020 dgst_pos0 = 3;
8021 dgst_pos1 = 4;
8022 dgst_pos2 = 2;
8023 dgst_pos3 = 1;
8024 break;
8025
8026 case 160: hash_type = HASH_TYPE_SHA1;
8027 salt_type = SALT_TYPE_INTERN;
8028 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8029 opts_type = OPTS_TYPE_PT_GENERATE_BE
8030 | OPTS_TYPE_PT_ADD80
8031 | OPTS_TYPE_PT_ADDBITS15;
8032 kern_type = KERN_TYPE_HMACSHA1_SLT;
8033 dgst_size = DGST_SIZE_4_5;
8034 parse_func = hmacsha1_parse_hash;
8035 sort_by_digest = sort_by_digest_4_5;
8036 opti_type = OPTI_TYPE_ZERO_BYTE
8037 | OPTI_TYPE_NOT_ITERATED;
8038 dgst_pos0 = 3;
8039 dgst_pos1 = 4;
8040 dgst_pos2 = 2;
8041 dgst_pos3 = 1;
8042 break;
8043
8044 case 190: hash_type = HASH_TYPE_SHA1;
8045 salt_type = SALT_TYPE_NONE;
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 kern_type = KERN_TYPE_SHA1_LINKEDIN;
8051 dgst_size = DGST_SIZE_4_5;
8052 parse_func = sha1linkedin_parse_hash;
8053 sort_by_digest = sort_by_digest_4_5;
8054 opti_type = OPTI_TYPE_ZERO_BYTE
8055 | OPTI_TYPE_PRECOMPUTE_INIT
8056 | OPTI_TYPE_EARLY_SKIP
8057 | OPTI_TYPE_NOT_ITERATED
8058 | OPTI_TYPE_NOT_SALTED;
8059 dgst_pos0 = 0;
8060 dgst_pos1 = 4;
8061 dgst_pos2 = 3;
8062 dgst_pos3 = 2;
8063 break;
8064
8065 case 200: hash_type = HASH_TYPE_MYSQL;
8066 salt_type = SALT_TYPE_NONE;
8067 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8068 opts_type = 0;
8069 kern_type = KERN_TYPE_MYSQL;
8070 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8071 parse_func = mysql323_parse_hash;
8072 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8073 opti_type = OPTI_TYPE_ZERO_BYTE;
8074 dgst_pos0 = 0;
8075 dgst_pos1 = 1;
8076 dgst_pos2 = 2;
8077 dgst_pos3 = 3;
8078 break;
8079
8080 case 300: hash_type = HASH_TYPE_SHA1;
8081 salt_type = SALT_TYPE_NONE;
8082 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8083 opts_type = OPTS_TYPE_PT_GENERATE_BE
8084 | OPTS_TYPE_PT_ADD80
8085 | OPTS_TYPE_PT_ADDBITS15;
8086 kern_type = KERN_TYPE_MYSQL41;
8087 dgst_size = DGST_SIZE_4_5;
8088 parse_func = sha1_parse_hash;
8089 sort_by_digest = sort_by_digest_4_5;
8090 opti_type = OPTI_TYPE_ZERO_BYTE
8091 | OPTI_TYPE_PRECOMPUTE_INIT
8092 | OPTI_TYPE_PRECOMPUTE_MERKLE
8093 | OPTI_TYPE_EARLY_SKIP
8094 | OPTI_TYPE_NOT_ITERATED
8095 | OPTI_TYPE_NOT_SALTED;
8096 dgst_pos0 = 3;
8097 dgst_pos1 = 4;
8098 dgst_pos2 = 2;
8099 dgst_pos3 = 1;
8100 break;
8101
8102 case 400: hash_type = HASH_TYPE_MD5;
8103 salt_type = SALT_TYPE_EMBEDDED;
8104 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8105 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8106 kern_type = KERN_TYPE_PHPASS;
8107 dgst_size = DGST_SIZE_4_4;
8108 parse_func = phpass_parse_hash;
8109 sort_by_digest = sort_by_digest_4_4;
8110 opti_type = OPTI_TYPE_ZERO_BYTE
8111 | OPTI_TYPE_SLOW_HASH_SIMD;
8112 dgst_pos0 = 0;
8113 dgst_pos1 = 1;
8114 dgst_pos2 = 2;
8115 dgst_pos3 = 3;
8116 break;
8117
8118 case 500: hash_type = HASH_TYPE_MD5;
8119 salt_type = SALT_TYPE_EMBEDDED;
8120 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8121 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8122 kern_type = KERN_TYPE_MD5CRYPT;
8123 dgst_size = DGST_SIZE_4_4;
8124 parse_func = md5crypt_parse_hash;
8125 sort_by_digest = sort_by_digest_4_4;
8126 opti_type = OPTI_TYPE_ZERO_BYTE;
8127 dgst_pos0 = 0;
8128 dgst_pos1 = 1;
8129 dgst_pos2 = 2;
8130 dgst_pos3 = 3;
8131 break;
8132
8133 case 501: hash_type = HASH_TYPE_MD5;
8134 salt_type = SALT_TYPE_EMBEDDED;
8135 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8136 opts_type = OPTS_TYPE_PT_GENERATE_LE
8137 | OPTS_TYPE_HASH_COPY;
8138 kern_type = KERN_TYPE_MD5CRYPT;
8139 dgst_size = DGST_SIZE_4_4;
8140 parse_func = juniper_parse_hash;
8141 sort_by_digest = sort_by_digest_4_4;
8142 opti_type = OPTI_TYPE_ZERO_BYTE;
8143 dgst_pos0 = 0;
8144 dgst_pos1 = 1;
8145 dgst_pos2 = 2;
8146 dgst_pos3 = 3;
8147 break;
8148
8149 case 900: hash_type = HASH_TYPE_MD4;
8150 salt_type = SALT_TYPE_NONE;
8151 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8152 opts_type = OPTS_TYPE_PT_GENERATE_LE
8153 | OPTS_TYPE_PT_ADD80
8154 | OPTS_TYPE_PT_ADDBITS14;
8155 kern_type = KERN_TYPE_MD4;
8156 dgst_size = DGST_SIZE_4_4;
8157 parse_func = md4_parse_hash;
8158 sort_by_digest = sort_by_digest_4_4;
8159 opti_type = OPTI_TYPE_ZERO_BYTE
8160 | OPTI_TYPE_PRECOMPUTE_INIT
8161 | OPTI_TYPE_PRECOMPUTE_MERKLE
8162 | OPTI_TYPE_MEET_IN_MIDDLE
8163 | OPTI_TYPE_EARLY_SKIP
8164 | OPTI_TYPE_NOT_ITERATED
8165 | OPTI_TYPE_NOT_SALTED
8166 | OPTI_TYPE_RAW_HASH;
8167 dgst_pos0 = 0;
8168 dgst_pos1 = 3;
8169 dgst_pos2 = 2;
8170 dgst_pos3 = 1;
8171 break;
8172
8173 case 1000: hash_type = HASH_TYPE_MD4;
8174 salt_type = SALT_TYPE_NONE;
8175 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8176 opts_type = OPTS_TYPE_PT_GENERATE_LE
8177 | OPTS_TYPE_PT_ADD80
8178 | OPTS_TYPE_PT_ADDBITS14
8179 | OPTS_TYPE_PT_UNICODE;
8180 kern_type = KERN_TYPE_MD4_PWU;
8181 dgst_size = DGST_SIZE_4_4;
8182 parse_func = md4_parse_hash;
8183 sort_by_digest = sort_by_digest_4_4;
8184 opti_type = OPTI_TYPE_ZERO_BYTE
8185 | OPTI_TYPE_PRECOMPUTE_INIT
8186 | OPTI_TYPE_PRECOMPUTE_MERKLE
8187 | OPTI_TYPE_MEET_IN_MIDDLE
8188 | OPTI_TYPE_EARLY_SKIP
8189 | OPTI_TYPE_NOT_ITERATED
8190 | OPTI_TYPE_NOT_SALTED
8191 | OPTI_TYPE_RAW_HASH;
8192 dgst_pos0 = 0;
8193 dgst_pos1 = 3;
8194 dgst_pos2 = 2;
8195 dgst_pos3 = 1;
8196 break;
8197
8198 case 1100: hash_type = HASH_TYPE_MD4;
8199 salt_type = SALT_TYPE_INTERN;
8200 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8201 opts_type = OPTS_TYPE_PT_GENERATE_LE
8202 | OPTS_TYPE_PT_ADD80
8203 | OPTS_TYPE_PT_ADDBITS14
8204 | OPTS_TYPE_PT_UNICODE
8205 | OPTS_TYPE_ST_ADD80
8206 | OPTS_TYPE_ST_UNICODE
8207 | OPTS_TYPE_ST_LOWER;
8208 kern_type = KERN_TYPE_MD44_PWUSLT;
8209 dgst_size = DGST_SIZE_4_4;
8210 parse_func = dcc_parse_hash;
8211 sort_by_digest = sort_by_digest_4_4;
8212 opti_type = OPTI_TYPE_ZERO_BYTE
8213 | OPTI_TYPE_PRECOMPUTE_INIT
8214 | OPTI_TYPE_PRECOMPUTE_MERKLE
8215 | OPTI_TYPE_EARLY_SKIP
8216 | OPTI_TYPE_NOT_ITERATED;
8217 dgst_pos0 = 0;
8218 dgst_pos1 = 3;
8219 dgst_pos2 = 2;
8220 dgst_pos3 = 1;
8221 break;
8222
8223 case 1400: hash_type = HASH_TYPE_SHA256;
8224 salt_type = SALT_TYPE_NONE;
8225 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8226 opts_type = OPTS_TYPE_PT_GENERATE_BE
8227 | OPTS_TYPE_PT_ADD80
8228 | OPTS_TYPE_PT_ADDBITS15;
8229 kern_type = KERN_TYPE_SHA256;
8230 dgst_size = DGST_SIZE_4_8;
8231 parse_func = sha256_parse_hash;
8232 sort_by_digest = sort_by_digest_4_8;
8233 opti_type = OPTI_TYPE_ZERO_BYTE
8234 | OPTI_TYPE_PRECOMPUTE_INIT
8235 | OPTI_TYPE_PRECOMPUTE_MERKLE
8236 | OPTI_TYPE_EARLY_SKIP
8237 | OPTI_TYPE_NOT_ITERATED
8238 | OPTI_TYPE_NOT_SALTED
8239 | OPTI_TYPE_RAW_HASH;
8240 dgst_pos0 = 3;
8241 dgst_pos1 = 7;
8242 dgst_pos2 = 2;
8243 dgst_pos3 = 6;
8244 break;
8245
8246 case 1410: hash_type = HASH_TYPE_SHA256;
8247 salt_type = SALT_TYPE_INTERN;
8248 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8249 opts_type = OPTS_TYPE_PT_GENERATE_BE
8250 | OPTS_TYPE_ST_ADD80
8251 | OPTS_TYPE_ST_ADDBITS15;
8252 kern_type = KERN_TYPE_SHA256_PWSLT;
8253 dgst_size = DGST_SIZE_4_8;
8254 parse_func = sha256s_parse_hash;
8255 sort_by_digest = sort_by_digest_4_8;
8256 opti_type = OPTI_TYPE_ZERO_BYTE
8257 | OPTI_TYPE_PRECOMPUTE_INIT
8258 | OPTI_TYPE_PRECOMPUTE_MERKLE
8259 | OPTI_TYPE_EARLY_SKIP
8260 | OPTI_TYPE_NOT_ITERATED
8261 | OPTI_TYPE_APPENDED_SALT
8262 | OPTI_TYPE_RAW_HASH;
8263 dgst_pos0 = 3;
8264 dgst_pos1 = 7;
8265 dgst_pos2 = 2;
8266 dgst_pos3 = 6;
8267 break;
8268
8269 case 1420: hash_type = HASH_TYPE_SHA256;
8270 salt_type = SALT_TYPE_INTERN;
8271 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8272 opts_type = OPTS_TYPE_PT_GENERATE_BE
8273 | OPTS_TYPE_PT_ADD80
8274 | OPTS_TYPE_PT_ADDBITS15;
8275 kern_type = KERN_TYPE_SHA256_SLTPW;
8276 dgst_size = DGST_SIZE_4_8;
8277 parse_func = sha256s_parse_hash;
8278 sort_by_digest = sort_by_digest_4_8;
8279 opti_type = OPTI_TYPE_ZERO_BYTE
8280 | OPTI_TYPE_PRECOMPUTE_INIT
8281 | OPTI_TYPE_PRECOMPUTE_MERKLE
8282 | OPTI_TYPE_EARLY_SKIP
8283 | OPTI_TYPE_NOT_ITERATED
8284 | OPTI_TYPE_PREPENDED_SALT
8285 | OPTI_TYPE_RAW_HASH;
8286 dgst_pos0 = 3;
8287 dgst_pos1 = 7;
8288 dgst_pos2 = 2;
8289 dgst_pos3 = 6;
8290 break;
8291
8292 case 1421: hash_type = HASH_TYPE_SHA256;
8293 salt_type = SALT_TYPE_EMBEDDED;
8294 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8295 opts_type = OPTS_TYPE_PT_GENERATE_BE
8296 | OPTS_TYPE_PT_ADD80
8297 | OPTS_TYPE_PT_ADDBITS15;
8298 kern_type = KERN_TYPE_SHA256_SLTPW;
8299 dgst_size = DGST_SIZE_4_8;
8300 parse_func = hmailserver_parse_hash;
8301 sort_by_digest = sort_by_digest_4_8;
8302 opti_type = OPTI_TYPE_ZERO_BYTE
8303 | OPTI_TYPE_PRECOMPUTE_INIT
8304 | OPTI_TYPE_PRECOMPUTE_MERKLE
8305 | OPTI_TYPE_EARLY_SKIP
8306 | OPTI_TYPE_NOT_ITERATED
8307 | OPTI_TYPE_PREPENDED_SALT
8308 | OPTI_TYPE_RAW_HASH;
8309 dgst_pos0 = 3;
8310 dgst_pos1 = 7;
8311 dgst_pos2 = 2;
8312 dgst_pos3 = 6;
8313 break;
8314
8315 case 1430: hash_type = HASH_TYPE_SHA256;
8316 salt_type = SALT_TYPE_INTERN;
8317 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8318 opts_type = OPTS_TYPE_PT_GENERATE_BE
8319 | OPTS_TYPE_PT_UNICODE
8320 | OPTS_TYPE_ST_ADD80
8321 | OPTS_TYPE_ST_ADDBITS15;
8322 kern_type = KERN_TYPE_SHA256_PWUSLT;
8323 dgst_size = DGST_SIZE_4_8;
8324 parse_func = sha256s_parse_hash;
8325 sort_by_digest = sort_by_digest_4_8;
8326 opti_type = OPTI_TYPE_ZERO_BYTE
8327 | OPTI_TYPE_PRECOMPUTE_INIT
8328 | OPTI_TYPE_PRECOMPUTE_MERKLE
8329 | OPTI_TYPE_EARLY_SKIP
8330 | OPTI_TYPE_NOT_ITERATED
8331 | OPTI_TYPE_APPENDED_SALT
8332 | OPTI_TYPE_RAW_HASH;
8333 dgst_pos0 = 3;
8334 dgst_pos1 = 7;
8335 dgst_pos2 = 2;
8336 dgst_pos3 = 6;
8337 break;
8338
8339 case 1440: hash_type = HASH_TYPE_SHA256;
8340 salt_type = SALT_TYPE_INTERN;
8341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8342 opts_type = OPTS_TYPE_PT_GENERATE_BE
8343 | OPTS_TYPE_PT_ADD80
8344 | OPTS_TYPE_PT_ADDBITS15
8345 | OPTS_TYPE_PT_UNICODE;
8346 kern_type = KERN_TYPE_SHA256_SLTPWU;
8347 dgst_size = DGST_SIZE_4_8;
8348 parse_func = sha256s_parse_hash;
8349 sort_by_digest = sort_by_digest_4_8;
8350 opti_type = OPTI_TYPE_ZERO_BYTE
8351 | OPTI_TYPE_PRECOMPUTE_INIT
8352 | OPTI_TYPE_PRECOMPUTE_MERKLE
8353 | OPTI_TYPE_EARLY_SKIP
8354 | OPTI_TYPE_NOT_ITERATED
8355 | OPTI_TYPE_PREPENDED_SALT
8356 | OPTI_TYPE_RAW_HASH;
8357 dgst_pos0 = 3;
8358 dgst_pos1 = 7;
8359 dgst_pos2 = 2;
8360 dgst_pos3 = 6;
8361 break;
8362
8363 case 1441: hash_type = HASH_TYPE_SHA256;
8364 salt_type = SALT_TYPE_EMBEDDED;
8365 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8366 opts_type = OPTS_TYPE_PT_GENERATE_BE
8367 | OPTS_TYPE_PT_ADD80
8368 | OPTS_TYPE_PT_ADDBITS15
8369 | OPTS_TYPE_PT_UNICODE
8370 | OPTS_TYPE_ST_BASE64;
8371 kern_type = KERN_TYPE_SHA256_SLTPWU;
8372 dgst_size = DGST_SIZE_4_8;
8373 parse_func = episerver4_parse_hash;
8374 sort_by_digest = sort_by_digest_4_8;
8375 opti_type = OPTI_TYPE_ZERO_BYTE
8376 | OPTI_TYPE_PRECOMPUTE_INIT
8377 | OPTI_TYPE_PRECOMPUTE_MERKLE
8378 | OPTI_TYPE_EARLY_SKIP
8379 | OPTI_TYPE_NOT_ITERATED
8380 | OPTI_TYPE_PREPENDED_SALT
8381 | OPTI_TYPE_RAW_HASH;
8382 dgst_pos0 = 3;
8383 dgst_pos1 = 7;
8384 dgst_pos2 = 2;
8385 dgst_pos3 = 6;
8386 break;
8387
8388 case 1450: hash_type = HASH_TYPE_SHA256;
8389 salt_type = SALT_TYPE_INTERN;
8390 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8391 opts_type = OPTS_TYPE_PT_GENERATE_BE
8392 | OPTS_TYPE_ST_ADD80;
8393 kern_type = KERN_TYPE_HMACSHA256_PW;
8394 dgst_size = DGST_SIZE_4_8;
8395 parse_func = hmacsha256_parse_hash;
8396 sort_by_digest = sort_by_digest_4_8;
8397 opti_type = OPTI_TYPE_ZERO_BYTE
8398 | OPTI_TYPE_NOT_ITERATED;
8399 dgst_pos0 = 3;
8400 dgst_pos1 = 7;
8401 dgst_pos2 = 2;
8402 dgst_pos3 = 6;
8403 break;
8404
8405 case 1460: hash_type = HASH_TYPE_SHA256;
8406 salt_type = SALT_TYPE_INTERN;
8407 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8408 opts_type = OPTS_TYPE_PT_GENERATE_BE
8409 | OPTS_TYPE_PT_ADD80
8410 | OPTS_TYPE_PT_ADDBITS15;
8411 kern_type = KERN_TYPE_HMACSHA256_SLT;
8412 dgst_size = DGST_SIZE_4_8;
8413 parse_func = hmacsha256_parse_hash;
8414 sort_by_digest = sort_by_digest_4_8;
8415 opti_type = OPTI_TYPE_ZERO_BYTE
8416 | OPTI_TYPE_NOT_ITERATED;
8417 dgst_pos0 = 3;
8418 dgst_pos1 = 7;
8419 dgst_pos2 = 2;
8420 dgst_pos3 = 6;
8421 break;
8422
8423 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8424 salt_type = SALT_TYPE_EMBEDDED;
8425 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8426 opts_type = OPTS_TYPE_PT_GENERATE_LE
8427 | OPTS_TYPE_PT_BITSLICE;
8428 kern_type = KERN_TYPE_DESCRYPT;
8429 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8430 parse_func = descrypt_parse_hash;
8431 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8432 opti_type = OPTI_TYPE_ZERO_BYTE
8433 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8434 dgst_pos0 = 0;
8435 dgst_pos1 = 1;
8436 dgst_pos2 = 2;
8437 dgst_pos3 = 3;
8438 break;
8439
8440 case 1600: hash_type = HASH_TYPE_MD5;
8441 salt_type = SALT_TYPE_EMBEDDED;
8442 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8443 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8444 kern_type = KERN_TYPE_APR1CRYPT;
8445 dgst_size = DGST_SIZE_4_4;
8446 parse_func = md5apr1_parse_hash;
8447 sort_by_digest = sort_by_digest_4_4;
8448 opti_type = OPTI_TYPE_ZERO_BYTE;
8449 dgst_pos0 = 0;
8450 dgst_pos1 = 1;
8451 dgst_pos2 = 2;
8452 dgst_pos3 = 3;
8453 break;
8454
8455 case 1700: hash_type = HASH_TYPE_SHA512;
8456 salt_type = SALT_TYPE_NONE;
8457 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8458 opts_type = OPTS_TYPE_PT_GENERATE_BE
8459 | OPTS_TYPE_PT_ADD80
8460 | OPTS_TYPE_PT_ADDBITS15;
8461 kern_type = KERN_TYPE_SHA512;
8462 dgst_size = DGST_SIZE_8_8;
8463 parse_func = sha512_parse_hash;
8464 sort_by_digest = sort_by_digest_8_8;
8465 opti_type = OPTI_TYPE_ZERO_BYTE
8466 | OPTI_TYPE_PRECOMPUTE_INIT
8467 | OPTI_TYPE_PRECOMPUTE_MERKLE
8468 | OPTI_TYPE_EARLY_SKIP
8469 | OPTI_TYPE_NOT_ITERATED
8470 | OPTI_TYPE_NOT_SALTED
8471 | OPTI_TYPE_USES_BITS_64
8472 | OPTI_TYPE_RAW_HASH;
8473 dgst_pos0 = 14;
8474 dgst_pos1 = 15;
8475 dgst_pos2 = 6;
8476 dgst_pos3 = 7;
8477 break;
8478
8479 case 1710: hash_type = HASH_TYPE_SHA512;
8480 salt_type = SALT_TYPE_INTERN;
8481 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8482 opts_type = OPTS_TYPE_PT_GENERATE_BE
8483 | OPTS_TYPE_ST_ADD80
8484 | OPTS_TYPE_ST_ADDBITS15;
8485 kern_type = KERN_TYPE_SHA512_PWSLT;
8486 dgst_size = DGST_SIZE_8_8;
8487 parse_func = sha512s_parse_hash;
8488 sort_by_digest = sort_by_digest_8_8;
8489 opti_type = OPTI_TYPE_ZERO_BYTE
8490 | OPTI_TYPE_PRECOMPUTE_INIT
8491 | OPTI_TYPE_PRECOMPUTE_MERKLE
8492 | OPTI_TYPE_EARLY_SKIP
8493 | OPTI_TYPE_NOT_ITERATED
8494 | OPTI_TYPE_APPENDED_SALT
8495 | OPTI_TYPE_USES_BITS_64
8496 | OPTI_TYPE_RAW_HASH;
8497 dgst_pos0 = 14;
8498 dgst_pos1 = 15;
8499 dgst_pos2 = 6;
8500 dgst_pos3 = 7;
8501 break;
8502
8503 case 1711: hash_type = HASH_TYPE_SHA512;
8504 salt_type = SALT_TYPE_EMBEDDED;
8505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8506 opts_type = OPTS_TYPE_PT_GENERATE_BE
8507 | OPTS_TYPE_ST_ADD80
8508 | OPTS_TYPE_ST_ADDBITS15;
8509 kern_type = KERN_TYPE_SHA512_PWSLT;
8510 dgst_size = DGST_SIZE_8_8;
8511 parse_func = sha512b64s_parse_hash;
8512 sort_by_digest = sort_by_digest_8_8;
8513 opti_type = OPTI_TYPE_ZERO_BYTE
8514 | OPTI_TYPE_PRECOMPUTE_INIT
8515 | OPTI_TYPE_PRECOMPUTE_MERKLE
8516 | OPTI_TYPE_EARLY_SKIP
8517 | OPTI_TYPE_NOT_ITERATED
8518 | OPTI_TYPE_APPENDED_SALT
8519 | OPTI_TYPE_USES_BITS_64
8520 | OPTI_TYPE_RAW_HASH;
8521 dgst_pos0 = 14;
8522 dgst_pos1 = 15;
8523 dgst_pos2 = 6;
8524 dgst_pos3 = 7;
8525 break;
8526
8527 case 1720: hash_type = HASH_TYPE_SHA512;
8528 salt_type = SALT_TYPE_INTERN;
8529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8530 opts_type = OPTS_TYPE_PT_GENERATE_BE
8531 | OPTS_TYPE_PT_ADD80
8532 | OPTS_TYPE_PT_ADDBITS15;
8533 kern_type = KERN_TYPE_SHA512_SLTPW;
8534 dgst_size = DGST_SIZE_8_8;
8535 parse_func = sha512s_parse_hash;
8536 sort_by_digest = sort_by_digest_8_8;
8537 opti_type = OPTI_TYPE_ZERO_BYTE
8538 | OPTI_TYPE_PRECOMPUTE_INIT
8539 | OPTI_TYPE_PRECOMPUTE_MERKLE
8540 | OPTI_TYPE_EARLY_SKIP
8541 | OPTI_TYPE_NOT_ITERATED
8542 | OPTI_TYPE_PREPENDED_SALT
8543 | OPTI_TYPE_USES_BITS_64
8544 | OPTI_TYPE_RAW_HASH;
8545 dgst_pos0 = 14;
8546 dgst_pos1 = 15;
8547 dgst_pos2 = 6;
8548 dgst_pos3 = 7;
8549 break;
8550
8551 case 1722: hash_type = HASH_TYPE_SHA512;
8552 salt_type = SALT_TYPE_EMBEDDED;
8553 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8554 opts_type = OPTS_TYPE_PT_GENERATE_BE
8555 | OPTS_TYPE_PT_ADD80
8556 | OPTS_TYPE_PT_ADDBITS15
8557 | OPTS_TYPE_ST_HEX;
8558 kern_type = KERN_TYPE_SHA512_SLTPW;
8559 dgst_size = DGST_SIZE_8_8;
8560 parse_func = osx512_parse_hash;
8561 sort_by_digest = sort_by_digest_8_8;
8562 opti_type = OPTI_TYPE_ZERO_BYTE
8563 | OPTI_TYPE_PRECOMPUTE_INIT
8564 | OPTI_TYPE_PRECOMPUTE_MERKLE
8565 | OPTI_TYPE_EARLY_SKIP
8566 | OPTI_TYPE_NOT_ITERATED
8567 | OPTI_TYPE_PREPENDED_SALT
8568 | OPTI_TYPE_USES_BITS_64
8569 | OPTI_TYPE_RAW_HASH;
8570 dgst_pos0 = 14;
8571 dgst_pos1 = 15;
8572 dgst_pos2 = 6;
8573 dgst_pos3 = 7;
8574 break;
8575
8576 case 1730: hash_type = HASH_TYPE_SHA512;
8577 salt_type = SALT_TYPE_INTERN;
8578 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8579 opts_type = OPTS_TYPE_PT_GENERATE_BE
8580 | OPTS_TYPE_PT_UNICODE
8581 | OPTS_TYPE_ST_ADD80
8582 | OPTS_TYPE_ST_ADDBITS15;
8583 kern_type = KERN_TYPE_SHA512_PWSLTU;
8584 dgst_size = DGST_SIZE_8_8;
8585 parse_func = sha512s_parse_hash;
8586 sort_by_digest = sort_by_digest_8_8;
8587 opti_type = OPTI_TYPE_ZERO_BYTE
8588 | OPTI_TYPE_PRECOMPUTE_INIT
8589 | OPTI_TYPE_PRECOMPUTE_MERKLE
8590 | OPTI_TYPE_EARLY_SKIP
8591 | OPTI_TYPE_NOT_ITERATED
8592 | OPTI_TYPE_APPENDED_SALT
8593 | OPTI_TYPE_USES_BITS_64
8594 | OPTI_TYPE_RAW_HASH;
8595 dgst_pos0 = 14;
8596 dgst_pos1 = 15;
8597 dgst_pos2 = 6;
8598 dgst_pos3 = 7;
8599 break;
8600
8601 case 1731: hash_type = HASH_TYPE_SHA512;
8602 salt_type = SALT_TYPE_EMBEDDED;
8603 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8604 opts_type = OPTS_TYPE_PT_GENERATE_BE
8605 | OPTS_TYPE_PT_UNICODE
8606 | OPTS_TYPE_ST_ADD80
8607 | OPTS_TYPE_ST_ADDBITS15
8608 | OPTS_TYPE_ST_HEX;
8609 kern_type = KERN_TYPE_SHA512_PWSLTU;
8610 dgst_size = DGST_SIZE_8_8;
8611 parse_func = mssql2012_parse_hash;
8612 sort_by_digest = sort_by_digest_8_8;
8613 opti_type = OPTI_TYPE_ZERO_BYTE
8614 | OPTI_TYPE_PRECOMPUTE_INIT
8615 | OPTI_TYPE_PRECOMPUTE_MERKLE
8616 | OPTI_TYPE_EARLY_SKIP
8617 | OPTI_TYPE_NOT_ITERATED
8618 | OPTI_TYPE_APPENDED_SALT
8619 | OPTI_TYPE_USES_BITS_64
8620 | OPTI_TYPE_RAW_HASH;
8621 dgst_pos0 = 14;
8622 dgst_pos1 = 15;
8623 dgst_pos2 = 6;
8624 dgst_pos3 = 7;
8625 break;
8626
8627 case 1740: hash_type = HASH_TYPE_SHA512;
8628 salt_type = SALT_TYPE_INTERN;
8629 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8630 opts_type = OPTS_TYPE_PT_GENERATE_BE
8631 | OPTS_TYPE_PT_ADD80
8632 | OPTS_TYPE_PT_ADDBITS15
8633 | OPTS_TYPE_PT_UNICODE;
8634 kern_type = KERN_TYPE_SHA512_SLTPWU;
8635 dgst_size = DGST_SIZE_8_8;
8636 parse_func = sha512s_parse_hash;
8637 sort_by_digest = sort_by_digest_8_8;
8638 opti_type = OPTI_TYPE_ZERO_BYTE
8639 | OPTI_TYPE_PRECOMPUTE_INIT
8640 | OPTI_TYPE_PRECOMPUTE_MERKLE
8641 | OPTI_TYPE_EARLY_SKIP
8642 | OPTI_TYPE_NOT_ITERATED
8643 | OPTI_TYPE_PREPENDED_SALT
8644 | OPTI_TYPE_USES_BITS_64
8645 | OPTI_TYPE_RAW_HASH;
8646 dgst_pos0 = 14;
8647 dgst_pos1 = 15;
8648 dgst_pos2 = 6;
8649 dgst_pos3 = 7;
8650 break;
8651
8652 case 1750: hash_type = HASH_TYPE_SHA512;
8653 salt_type = SALT_TYPE_INTERN;
8654 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8655 opts_type = OPTS_TYPE_PT_GENERATE_BE
8656 | OPTS_TYPE_ST_ADD80;
8657 kern_type = KERN_TYPE_HMACSHA512_PW;
8658 dgst_size = DGST_SIZE_8_8;
8659 parse_func = hmacsha512_parse_hash;
8660 sort_by_digest = sort_by_digest_8_8;
8661 opti_type = OPTI_TYPE_ZERO_BYTE
8662 | OPTI_TYPE_USES_BITS_64
8663 | OPTI_TYPE_NOT_ITERATED;
8664 dgst_pos0 = 14;
8665 dgst_pos1 = 15;
8666 dgst_pos2 = 6;
8667 dgst_pos3 = 7;
8668 break;
8669
8670 case 1760: hash_type = HASH_TYPE_SHA512;
8671 salt_type = SALT_TYPE_INTERN;
8672 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8673 opts_type = OPTS_TYPE_PT_GENERATE_BE
8674 | OPTS_TYPE_PT_ADD80
8675 | OPTS_TYPE_PT_ADDBITS15;
8676 kern_type = KERN_TYPE_HMACSHA512_SLT;
8677 dgst_size = DGST_SIZE_8_8;
8678 parse_func = hmacsha512_parse_hash;
8679 sort_by_digest = sort_by_digest_8_8;
8680 opti_type = OPTI_TYPE_ZERO_BYTE
8681 | OPTI_TYPE_USES_BITS_64
8682 | OPTI_TYPE_NOT_ITERATED;
8683 dgst_pos0 = 14;
8684 dgst_pos1 = 15;
8685 dgst_pos2 = 6;
8686 dgst_pos3 = 7;
8687 break;
8688
8689 case 1800: hash_type = HASH_TYPE_SHA512;
8690 salt_type = SALT_TYPE_EMBEDDED;
8691 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8692 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8693 kern_type = KERN_TYPE_SHA512CRYPT;
8694 dgst_size = DGST_SIZE_8_8;
8695 parse_func = sha512crypt_parse_hash;
8696 sort_by_digest = sort_by_digest_8_8;
8697 opti_type = OPTI_TYPE_ZERO_BYTE
8698 | OPTI_TYPE_USES_BITS_64;
8699 dgst_pos0 = 0;
8700 dgst_pos1 = 1;
8701 dgst_pos2 = 2;
8702 dgst_pos3 = 3;
8703 break;
8704
8705 case 2000: hash_type = HASH_TYPE_STDOUT;
8706 salt_type = SALT_TYPE_NONE;
8707 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8708 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8709 kern_type = 0;
8710 dgst_size = DGST_SIZE_4_4;
8711 parse_func = NULL;
8712 sort_by_digest = NULL;
8713 opti_type = 0;
8714 dgst_pos0 = 0;
8715 dgst_pos1 = 0;
8716 dgst_pos2 = 0;
8717 dgst_pos3 = 0;
8718 break;
8719
8720 case 2100: hash_type = HASH_TYPE_DCC2;
8721 salt_type = SALT_TYPE_EMBEDDED;
8722 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8723 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8724 | OPTS_TYPE_ST_LOWER
8725 | OPTS_TYPE_ST_UNICODE;
8726 kern_type = KERN_TYPE_DCC2;
8727 dgst_size = DGST_SIZE_4_4;
8728 parse_func = dcc2_parse_hash;
8729 sort_by_digest = sort_by_digest_4_4;
8730 opti_type = OPTI_TYPE_ZERO_BYTE
8731 | OPTI_TYPE_SLOW_HASH_SIMD;
8732 dgst_pos0 = 0;
8733 dgst_pos1 = 1;
8734 dgst_pos2 = 2;
8735 dgst_pos3 = 3;
8736 break;
8737
8738 case 2400: hash_type = HASH_TYPE_MD5;
8739 salt_type = SALT_TYPE_NONE;
8740 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8741 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8742 kern_type = KERN_TYPE_MD5PIX;
8743 dgst_size = DGST_SIZE_4_4;
8744 parse_func = md5pix_parse_hash;
8745 sort_by_digest = sort_by_digest_4_4;
8746 opti_type = OPTI_TYPE_ZERO_BYTE
8747 | OPTI_TYPE_PRECOMPUTE_INIT
8748 | OPTI_TYPE_PRECOMPUTE_MERKLE
8749 | OPTI_TYPE_EARLY_SKIP
8750 | OPTI_TYPE_NOT_ITERATED
8751 | OPTI_TYPE_NOT_SALTED;
8752 dgst_pos0 = 0;
8753 dgst_pos1 = 3;
8754 dgst_pos2 = 2;
8755 dgst_pos3 = 1;
8756 break;
8757
8758 case 2410: hash_type = HASH_TYPE_MD5;
8759 salt_type = SALT_TYPE_INTERN;
8760 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8761 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8762 kern_type = KERN_TYPE_MD5ASA;
8763 dgst_size = DGST_SIZE_4_4;
8764 parse_func = md5asa_parse_hash;
8765 sort_by_digest = sort_by_digest_4_4;
8766 opti_type = OPTI_TYPE_ZERO_BYTE
8767 | OPTI_TYPE_PRECOMPUTE_INIT
8768 | OPTI_TYPE_PRECOMPUTE_MERKLE
8769 | OPTI_TYPE_EARLY_SKIP
8770 | OPTI_TYPE_NOT_ITERATED;
8771 dgst_pos0 = 0;
8772 dgst_pos1 = 3;
8773 dgst_pos2 = 2;
8774 dgst_pos3 = 1;
8775 break;
8776
8777 case 2500: hash_type = HASH_TYPE_WPA;
8778 salt_type = SALT_TYPE_EMBEDDED;
8779 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8780 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8781 kern_type = KERN_TYPE_WPA;
8782 dgst_size = DGST_SIZE_4_4;
8783 parse_func = wpa_parse_hash;
8784 sort_by_digest = sort_by_digest_4_4;
8785 opti_type = OPTI_TYPE_ZERO_BYTE
8786 | OPTI_TYPE_SLOW_HASH_SIMD;
8787 dgst_pos0 = 0;
8788 dgst_pos1 = 1;
8789 dgst_pos2 = 2;
8790 dgst_pos3 = 3;
8791 break;
8792
8793 case 2600: hash_type = HASH_TYPE_MD5;
8794 salt_type = SALT_TYPE_VIRTUAL;
8795 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8796 opts_type = OPTS_TYPE_PT_GENERATE_LE
8797 | OPTS_TYPE_PT_ADD80
8798 | OPTS_TYPE_PT_ADDBITS14
8799 | OPTS_TYPE_ST_ADD80;
8800 kern_type = KERN_TYPE_MD55_PWSLT1;
8801 dgst_size = DGST_SIZE_4_4;
8802 parse_func = md5md5_parse_hash;
8803 sort_by_digest = sort_by_digest_4_4;
8804 opti_type = OPTI_TYPE_ZERO_BYTE
8805 | OPTI_TYPE_PRECOMPUTE_INIT
8806 | OPTI_TYPE_PRECOMPUTE_MERKLE
8807 | OPTI_TYPE_EARLY_SKIP;
8808 dgst_pos0 = 0;
8809 dgst_pos1 = 3;
8810 dgst_pos2 = 2;
8811 dgst_pos3 = 1;
8812 break;
8813
8814 case 2611: hash_type = HASH_TYPE_MD5;
8815 salt_type = SALT_TYPE_INTERN;
8816 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8817 opts_type = OPTS_TYPE_PT_GENERATE_LE
8818 | OPTS_TYPE_PT_ADD80
8819 | OPTS_TYPE_PT_ADDBITS14
8820 | OPTS_TYPE_ST_ADD80;
8821 kern_type = KERN_TYPE_MD55_PWSLT1;
8822 dgst_size = DGST_SIZE_4_4;
8823 parse_func = vb3_parse_hash;
8824 sort_by_digest = sort_by_digest_4_4;
8825 opti_type = OPTI_TYPE_ZERO_BYTE
8826 | OPTI_TYPE_PRECOMPUTE_INIT
8827 | OPTI_TYPE_PRECOMPUTE_MERKLE
8828 | OPTI_TYPE_EARLY_SKIP;
8829 dgst_pos0 = 0;
8830 dgst_pos1 = 3;
8831 dgst_pos2 = 2;
8832 dgst_pos3 = 1;
8833 break;
8834
8835 case 2612: hash_type = HASH_TYPE_MD5;
8836 salt_type = SALT_TYPE_EMBEDDED;
8837 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8838 opts_type = OPTS_TYPE_PT_GENERATE_LE
8839 | OPTS_TYPE_PT_ADD80
8840 | OPTS_TYPE_PT_ADDBITS14
8841 | OPTS_TYPE_ST_ADD80
8842 | OPTS_TYPE_ST_HEX;
8843 kern_type = KERN_TYPE_MD55_PWSLT1;
8844 dgst_size = DGST_SIZE_4_4;
8845 parse_func = phps_parse_hash;
8846 sort_by_digest = sort_by_digest_4_4;
8847 opti_type = OPTI_TYPE_ZERO_BYTE
8848 | OPTI_TYPE_PRECOMPUTE_INIT
8849 | OPTI_TYPE_PRECOMPUTE_MERKLE
8850 | OPTI_TYPE_EARLY_SKIP;
8851 dgst_pos0 = 0;
8852 dgst_pos1 = 3;
8853 dgst_pos2 = 2;
8854 dgst_pos3 = 1;
8855 break;
8856
8857 case 2711: hash_type = HASH_TYPE_MD5;
8858 salt_type = SALT_TYPE_INTERN;
8859 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8860 opts_type = OPTS_TYPE_PT_GENERATE_LE
8861 | OPTS_TYPE_PT_ADD80
8862 | OPTS_TYPE_PT_ADDBITS14
8863 | OPTS_TYPE_ST_ADD80;
8864 kern_type = KERN_TYPE_MD55_PWSLT2;
8865 dgst_size = DGST_SIZE_4_4;
8866 parse_func = vb30_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_EARLY_SKIP;
8871 dgst_pos0 = 0;
8872 dgst_pos1 = 3;
8873 dgst_pos2 = 2;
8874 dgst_pos3 = 1;
8875 break;
8876
8877 case 2811: hash_type = HASH_TYPE_MD5;
8878 salt_type = SALT_TYPE_INTERN;
8879 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8880 opts_type = OPTS_TYPE_PT_GENERATE_LE
8881 | OPTS_TYPE_PT_ADD80
8882 | OPTS_TYPE_PT_ADDBITS14;
8883 kern_type = KERN_TYPE_MD55_SLTPW;
8884 dgst_size = DGST_SIZE_4_4;
8885 parse_func = ipb2_parse_hash;
8886 sort_by_digest = sort_by_digest_4_4;
8887 opti_type = OPTI_TYPE_ZERO_BYTE
8888 | OPTI_TYPE_PRECOMPUTE_INIT
8889 | OPTI_TYPE_EARLY_SKIP;
8890 dgst_pos0 = 0;
8891 dgst_pos1 = 3;
8892 dgst_pos2 = 2;
8893 dgst_pos3 = 1;
8894 break;
8895
8896 case 3000: hash_type = HASH_TYPE_LM;
8897 salt_type = SALT_TYPE_NONE;
8898 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8899 opts_type = OPTS_TYPE_PT_GENERATE_LE
8900 | OPTS_TYPE_PT_UPPER
8901 | OPTS_TYPE_PT_BITSLICE;
8902 kern_type = KERN_TYPE_LM;
8903 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8904 parse_func = lm_parse_hash;
8905 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8906 opti_type = OPTI_TYPE_ZERO_BYTE
8907 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8908 dgst_pos0 = 0;
8909 dgst_pos1 = 1;
8910 dgst_pos2 = 2;
8911 dgst_pos3 = 3;
8912 break;
8913
8914 case 3100: hash_type = HASH_TYPE_ORACLEH;
8915 salt_type = SALT_TYPE_INTERN;
8916 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8917 opts_type = OPTS_TYPE_PT_GENERATE_LE
8918 | OPTS_TYPE_PT_UPPER
8919 | OPTS_TYPE_ST_UPPER;
8920 kern_type = KERN_TYPE_ORACLEH;
8921 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8922 parse_func = oracleh_parse_hash;
8923 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8924 opti_type = OPTI_TYPE_ZERO_BYTE;
8925 dgst_pos0 = 0;
8926 dgst_pos1 = 1;
8927 dgst_pos2 = 2;
8928 dgst_pos3 = 3;
8929 break;
8930
8931 case 3200: hash_type = HASH_TYPE_BCRYPT;
8932 salt_type = SALT_TYPE_EMBEDDED;
8933 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8934 opts_type = OPTS_TYPE_PT_GENERATE_LE
8935 | OPTS_TYPE_ST_GENERATE_LE;
8936 kern_type = KERN_TYPE_BCRYPT;
8937 dgst_size = DGST_SIZE_4_6;
8938 parse_func = bcrypt_parse_hash;
8939 sort_by_digest = sort_by_digest_4_6;
8940 opti_type = OPTI_TYPE_ZERO_BYTE;
8941 dgst_pos0 = 0;
8942 dgst_pos1 = 1;
8943 dgst_pos2 = 2;
8944 dgst_pos3 = 3;
8945 break;
8946
8947 case 3710: hash_type = HASH_TYPE_MD5;
8948 salt_type = SALT_TYPE_INTERN;
8949 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8950 opts_type = OPTS_TYPE_PT_GENERATE_LE
8951 | OPTS_TYPE_PT_ADD80
8952 | OPTS_TYPE_PT_ADDBITS14;
8953 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8954 dgst_size = DGST_SIZE_4_4;
8955 parse_func = md5s_parse_hash;
8956 sort_by_digest = sort_by_digest_4_4;
8957 opti_type = OPTI_TYPE_ZERO_BYTE
8958 | OPTI_TYPE_PRECOMPUTE_INIT
8959 | OPTI_TYPE_PRECOMPUTE_MERKLE
8960 | OPTI_TYPE_EARLY_SKIP;
8961 dgst_pos0 = 0;
8962 dgst_pos1 = 3;
8963 dgst_pos2 = 2;
8964 dgst_pos3 = 1;
8965 break;
8966
8967 case 3711: hash_type = HASH_TYPE_MD5;
8968 salt_type = SALT_TYPE_EMBEDDED;
8969 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8970 opts_type = OPTS_TYPE_PT_GENERATE_LE
8971 | OPTS_TYPE_PT_ADD80
8972 | OPTS_TYPE_PT_ADDBITS14;
8973 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8974 dgst_size = DGST_SIZE_4_4;
8975 parse_func = mediawiki_b_parse_hash;
8976 sort_by_digest = sort_by_digest_4_4;
8977 opti_type = OPTI_TYPE_ZERO_BYTE
8978 | OPTI_TYPE_PRECOMPUTE_INIT
8979 | OPTI_TYPE_PRECOMPUTE_MERKLE
8980 | OPTI_TYPE_EARLY_SKIP;
8981 dgst_pos0 = 0;
8982 dgst_pos1 = 3;
8983 dgst_pos2 = 2;
8984 dgst_pos3 = 1;
8985 break;
8986
8987 case 3800: hash_type = HASH_TYPE_MD5;
8988 salt_type = SALT_TYPE_INTERN;
8989 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8990 opts_type = OPTS_TYPE_PT_GENERATE_LE
8991 | OPTS_TYPE_ST_ADDBITS14;
8992 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8993 dgst_size = DGST_SIZE_4_4;
8994 parse_func = md5s_parse_hash;
8995 sort_by_digest = sort_by_digest_4_4;
8996 opti_type = OPTI_TYPE_ZERO_BYTE
8997 | OPTI_TYPE_PRECOMPUTE_INIT
8998 | OPTI_TYPE_PRECOMPUTE_MERKLE
8999 | OPTI_TYPE_EARLY_SKIP
9000 | OPTI_TYPE_NOT_ITERATED
9001 | OPTI_TYPE_RAW_HASH;
9002 dgst_pos0 = 0;
9003 dgst_pos1 = 3;
9004 dgst_pos2 = 2;
9005 dgst_pos3 = 1;
9006 break;
9007
9008 case 4300: hash_type = HASH_TYPE_MD5;
9009 salt_type = SALT_TYPE_VIRTUAL;
9010 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9011 opts_type = OPTS_TYPE_PT_GENERATE_LE
9012 | OPTS_TYPE_PT_ADD80
9013 | OPTS_TYPE_PT_ADDBITS14
9014 | OPTS_TYPE_ST_ADD80;
9015 kern_type = KERN_TYPE_MD5U5_PWSLT1;
9016 dgst_size = DGST_SIZE_4_4;
9017 parse_func = md5md5_parse_hash;
9018 sort_by_digest = sort_by_digest_4_4;
9019 opti_type = OPTI_TYPE_ZERO_BYTE
9020 | OPTI_TYPE_PRECOMPUTE_INIT
9021 | OPTI_TYPE_PRECOMPUTE_MERKLE
9022 | OPTI_TYPE_EARLY_SKIP;
9023 dgst_pos0 = 0;
9024 dgst_pos1 = 3;
9025 dgst_pos2 = 2;
9026 dgst_pos3 = 1;
9027 break;
9028
9029
9030 case 4400: hash_type = HASH_TYPE_MD5;
9031 salt_type = SALT_TYPE_NONE;
9032 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9033 opts_type = OPTS_TYPE_PT_GENERATE_BE
9034 | OPTS_TYPE_PT_ADD80
9035 | OPTS_TYPE_PT_ADDBITS15;
9036 kern_type = KERN_TYPE_MD5_SHA1;
9037 dgst_size = DGST_SIZE_4_4;
9038 parse_func = md5_parse_hash;
9039 sort_by_digest = sort_by_digest_4_4;
9040 opti_type = OPTI_TYPE_ZERO_BYTE
9041 | OPTI_TYPE_PRECOMPUTE_INIT
9042 | OPTI_TYPE_PRECOMPUTE_MERKLE
9043 | OPTI_TYPE_EARLY_SKIP
9044 | OPTI_TYPE_NOT_ITERATED
9045 | OPTI_TYPE_NOT_SALTED
9046 | OPTI_TYPE_RAW_HASH;
9047 dgst_pos0 = 0;
9048 dgst_pos1 = 3;
9049 dgst_pos2 = 2;
9050 dgst_pos3 = 1;
9051 break;
9052
9053 case 4500: hash_type = HASH_TYPE_SHA1;
9054 salt_type = SALT_TYPE_NONE;
9055 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9056 opts_type = OPTS_TYPE_PT_GENERATE_BE
9057 | OPTS_TYPE_PT_ADD80
9058 | OPTS_TYPE_PT_ADDBITS15;
9059 kern_type = KERN_TYPE_SHA11;
9060 dgst_size = DGST_SIZE_4_5;
9061 parse_func = sha1_parse_hash;
9062 sort_by_digest = sort_by_digest_4_5;
9063 opti_type = OPTI_TYPE_ZERO_BYTE
9064 | OPTI_TYPE_PRECOMPUTE_INIT
9065 | OPTI_TYPE_PRECOMPUTE_MERKLE
9066 | OPTI_TYPE_EARLY_SKIP
9067 | OPTI_TYPE_NOT_SALTED;
9068 dgst_pos0 = 3;
9069 dgst_pos1 = 4;
9070 dgst_pos2 = 2;
9071 dgst_pos3 = 1;
9072 break;
9073
9074 case 4700: hash_type = HASH_TYPE_SHA1;
9075 salt_type = SALT_TYPE_NONE;
9076 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9077 opts_type = OPTS_TYPE_PT_GENERATE_LE
9078 | OPTS_TYPE_PT_ADD80
9079 | OPTS_TYPE_PT_ADDBITS14;
9080 kern_type = KERN_TYPE_SHA1_MD5;
9081 dgst_size = DGST_SIZE_4_5;
9082 parse_func = sha1_parse_hash;
9083 sort_by_digest = sort_by_digest_4_5;
9084 opti_type = OPTI_TYPE_ZERO_BYTE
9085 | OPTI_TYPE_PRECOMPUTE_INIT
9086 | OPTI_TYPE_PRECOMPUTE_MERKLE
9087 | OPTI_TYPE_EARLY_SKIP
9088 | OPTI_TYPE_NOT_ITERATED
9089 | OPTI_TYPE_NOT_SALTED
9090 | OPTI_TYPE_RAW_HASH;
9091 dgst_pos0 = 3;
9092 dgst_pos1 = 4;
9093 dgst_pos2 = 2;
9094 dgst_pos3 = 1;
9095 break;
9096
9097 case 4800: hash_type = HASH_TYPE_MD5;
9098 salt_type = SALT_TYPE_EMBEDDED;
9099 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9100 opts_type = OPTS_TYPE_PT_GENERATE_LE
9101 | OPTS_TYPE_PT_ADDBITS14;
9102 kern_type = KERN_TYPE_MD5_CHAP;
9103 dgst_size = DGST_SIZE_4_4;
9104 parse_func = chap_parse_hash;
9105 sort_by_digest = sort_by_digest_4_4;
9106 opti_type = OPTI_TYPE_ZERO_BYTE
9107 | OPTI_TYPE_PRECOMPUTE_INIT
9108 | OPTI_TYPE_PRECOMPUTE_MERKLE
9109 | OPTI_TYPE_MEET_IN_MIDDLE
9110 | OPTI_TYPE_EARLY_SKIP
9111 | OPTI_TYPE_NOT_ITERATED
9112 | OPTI_TYPE_RAW_HASH;
9113 dgst_pos0 = 0;
9114 dgst_pos1 = 3;
9115 dgst_pos2 = 2;
9116 dgst_pos3 = 1;
9117 break;
9118
9119 case 4900: hash_type = HASH_TYPE_SHA1;
9120 salt_type = SALT_TYPE_INTERN;
9121 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9122 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9123 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9124 dgst_size = DGST_SIZE_4_5;
9125 parse_func = sha1s_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 dgst_pos0 = 3;
9132 dgst_pos1 = 4;
9133 dgst_pos2 = 2;
9134 dgst_pos3 = 1;
9135 break;
9136
9137 case 5000: hash_type = HASH_TYPE_KECCAK;
9138 salt_type = SALT_TYPE_EMBEDDED;
9139 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9140 opts_type = OPTS_TYPE_PT_GENERATE_LE
9141 | OPTS_TYPE_PT_ADD01;
9142 kern_type = KERN_TYPE_KECCAK;
9143 dgst_size = DGST_SIZE_8_25;
9144 parse_func = keccak_parse_hash;
9145 sort_by_digest = sort_by_digest_8_25;
9146 opti_type = OPTI_TYPE_ZERO_BYTE
9147 | OPTI_TYPE_USES_BITS_64
9148 | OPTI_TYPE_RAW_HASH;
9149 dgst_pos0 = 2;
9150 dgst_pos1 = 3;
9151 dgst_pos2 = 4;
9152 dgst_pos3 = 5;
9153 break;
9154
9155 case 5100: hash_type = HASH_TYPE_MD5H;
9156 salt_type = SALT_TYPE_NONE;
9157 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9158 opts_type = OPTS_TYPE_PT_GENERATE_LE
9159 | OPTS_TYPE_PT_ADD80
9160 | OPTS_TYPE_PT_ADDBITS14;
9161 kern_type = KERN_TYPE_MD5H;
9162 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9163 parse_func = md5half_parse_hash;
9164 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9165 opti_type = OPTI_TYPE_ZERO_BYTE
9166 | OPTI_TYPE_RAW_HASH;
9167 dgst_pos0 = 0;
9168 dgst_pos1 = 1;
9169 dgst_pos2 = 2;
9170 dgst_pos3 = 3;
9171 break;
9172
9173 case 5200: hash_type = HASH_TYPE_SHA256;
9174 salt_type = SALT_TYPE_EMBEDDED;
9175 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9176 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9177 kern_type = KERN_TYPE_PSAFE3;
9178 dgst_size = DGST_SIZE_4_8;
9179 parse_func = psafe3_parse_hash;
9180 sort_by_digest = sort_by_digest_4_8;
9181 opti_type = OPTI_TYPE_ZERO_BYTE;
9182 dgst_pos0 = 0;
9183 dgst_pos1 = 1;
9184 dgst_pos2 = 2;
9185 dgst_pos3 = 3;
9186 break;
9187
9188 case 5300: hash_type = HASH_TYPE_MD5;
9189 salt_type = SALT_TYPE_EMBEDDED;
9190 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9191 opts_type = OPTS_TYPE_PT_GENERATE_LE
9192 | OPTS_TYPE_ST_ADD80;
9193 kern_type = KERN_TYPE_IKEPSK_MD5;
9194 dgst_size = DGST_SIZE_4_4;
9195 parse_func = ikepsk_md5_parse_hash;
9196 sort_by_digest = sort_by_digest_4_4;
9197 opti_type = OPTI_TYPE_ZERO_BYTE;
9198 dgst_pos0 = 0;
9199 dgst_pos1 = 3;
9200 dgst_pos2 = 2;
9201 dgst_pos3 = 1;
9202 break;
9203
9204 case 5400: hash_type = HASH_TYPE_SHA1;
9205 salt_type = SALT_TYPE_EMBEDDED;
9206 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9207 opts_type = OPTS_TYPE_PT_GENERATE_BE
9208 | OPTS_TYPE_ST_ADD80;
9209 kern_type = KERN_TYPE_IKEPSK_SHA1;
9210 dgst_size = DGST_SIZE_4_5;
9211 parse_func = ikepsk_sha1_parse_hash;
9212 sort_by_digest = sort_by_digest_4_5;
9213 opti_type = OPTI_TYPE_ZERO_BYTE;
9214 dgst_pos0 = 3;
9215 dgst_pos1 = 4;
9216 dgst_pos2 = 2;
9217 dgst_pos3 = 1;
9218 break;
9219
9220 case 5500: hash_type = HASH_TYPE_NETNTLM;
9221 salt_type = SALT_TYPE_EMBEDDED;
9222 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9223 opts_type = OPTS_TYPE_PT_GENERATE_LE
9224 | OPTS_TYPE_PT_ADD80
9225 | OPTS_TYPE_PT_ADDBITS14
9226 | OPTS_TYPE_PT_UNICODE
9227 | OPTS_TYPE_ST_HEX;
9228 kern_type = KERN_TYPE_NETNTLMv1;
9229 dgst_size = DGST_SIZE_4_4;
9230 parse_func = netntlmv1_parse_hash;
9231 sort_by_digest = sort_by_digest_4_4;
9232 opti_type = OPTI_TYPE_ZERO_BYTE
9233 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9234 dgst_pos0 = 0;
9235 dgst_pos1 = 1;
9236 dgst_pos2 = 2;
9237 dgst_pos3 = 3;
9238 break;
9239
9240 case 5600: hash_type = HASH_TYPE_MD5;
9241 salt_type = SALT_TYPE_EMBEDDED;
9242 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9243 opts_type = OPTS_TYPE_PT_GENERATE_LE
9244 | OPTS_TYPE_PT_ADD80
9245 | OPTS_TYPE_PT_ADDBITS14
9246 | OPTS_TYPE_PT_UNICODE;
9247 kern_type = KERN_TYPE_NETNTLMv2;
9248 dgst_size = DGST_SIZE_4_4;
9249 parse_func = netntlmv2_parse_hash;
9250 sort_by_digest = sort_by_digest_4_4;
9251 opti_type = OPTI_TYPE_ZERO_BYTE;
9252 dgst_pos0 = 0;
9253 dgst_pos1 = 3;
9254 dgst_pos2 = 2;
9255 dgst_pos3 = 1;
9256 break;
9257
9258 case 5700: hash_type = HASH_TYPE_SHA256;
9259 salt_type = SALT_TYPE_NONE;
9260 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9261 opts_type = OPTS_TYPE_PT_GENERATE_BE
9262 | OPTS_TYPE_PT_ADD80
9263 | OPTS_TYPE_PT_ADDBITS15;
9264 kern_type = KERN_TYPE_SHA256;
9265 dgst_size = DGST_SIZE_4_8;
9266 parse_func = cisco4_parse_hash;
9267 sort_by_digest = sort_by_digest_4_8;
9268 opti_type = OPTI_TYPE_ZERO_BYTE
9269 | OPTI_TYPE_PRECOMPUTE_INIT
9270 | OPTI_TYPE_PRECOMPUTE_MERKLE
9271 | OPTI_TYPE_EARLY_SKIP
9272 | OPTI_TYPE_NOT_ITERATED
9273 | OPTI_TYPE_NOT_SALTED
9274 | OPTI_TYPE_RAW_HASH;
9275 dgst_pos0 = 3;
9276 dgst_pos1 = 7;
9277 dgst_pos2 = 2;
9278 dgst_pos3 = 6;
9279 break;
9280
9281 case 5800: hash_type = HASH_TYPE_SHA1;
9282 salt_type = SALT_TYPE_INTERN;
9283 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9284 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9285 | OPTS_TYPE_ST_ADD80;
9286 kern_type = KERN_TYPE_ANDROIDPIN;
9287 dgst_size = DGST_SIZE_4_5;
9288 parse_func = androidpin_parse_hash;
9289 sort_by_digest = sort_by_digest_4_5;
9290 opti_type = OPTI_TYPE_ZERO_BYTE;
9291 dgst_pos0 = 0;
9292 dgst_pos1 = 1;
9293 dgst_pos2 = 2;
9294 dgst_pos3 = 3;
9295 break;
9296
9297 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9298 salt_type = SALT_TYPE_NONE;
9299 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9300 opts_type = OPTS_TYPE_PT_GENERATE_LE
9301 | OPTS_TYPE_PT_ADD80;
9302 kern_type = KERN_TYPE_RIPEMD160;
9303 dgst_size = DGST_SIZE_4_5;
9304 parse_func = ripemd160_parse_hash;
9305 sort_by_digest = sort_by_digest_4_5;
9306 opti_type = OPTI_TYPE_ZERO_BYTE;
9307 dgst_pos0 = 0;
9308 dgst_pos1 = 1;
9309 dgst_pos2 = 2;
9310 dgst_pos3 = 3;
9311 break;
9312
9313 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9314 salt_type = SALT_TYPE_NONE;
9315 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9316 opts_type = OPTS_TYPE_PT_GENERATE_BE
9317 | OPTS_TYPE_PT_ADD80;
9318 kern_type = KERN_TYPE_WHIRLPOOL;
9319 dgst_size = DGST_SIZE_4_16;
9320 parse_func = whirlpool_parse_hash;
9321 sort_by_digest = sort_by_digest_4_16;
9322 opti_type = OPTI_TYPE_ZERO_BYTE;
9323 dgst_pos0 = 0;
9324 dgst_pos1 = 1;
9325 dgst_pos2 = 2;
9326 dgst_pos3 = 3;
9327 break;
9328
9329 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9330 salt_type = SALT_TYPE_EMBEDDED;
9331 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9332 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9333 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9334 dgst_size = DGST_SIZE_4_5;
9335 parse_func = truecrypt_parse_hash_2k;
9336 sort_by_digest = sort_by_digest_4_5;
9337 opti_type = OPTI_TYPE_ZERO_BYTE;
9338 dgst_pos0 = 0;
9339 dgst_pos1 = 1;
9340 dgst_pos2 = 2;
9341 dgst_pos3 = 3;
9342 break;
9343
9344 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9345 salt_type = SALT_TYPE_EMBEDDED;
9346 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9347 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9348 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9349 dgst_size = DGST_SIZE_4_5;
9350 parse_func = truecrypt_parse_hash_2k;
9351 sort_by_digest = sort_by_digest_4_5;
9352 opti_type = OPTI_TYPE_ZERO_BYTE;
9353 dgst_pos0 = 0;
9354 dgst_pos1 = 1;
9355 dgst_pos2 = 2;
9356 dgst_pos3 = 3;
9357 break;
9358
9359 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9360 salt_type = SALT_TYPE_EMBEDDED;
9361 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9362 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9363 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9364 dgst_size = DGST_SIZE_4_5;
9365 parse_func = truecrypt_parse_hash_2k;
9366 sort_by_digest = sort_by_digest_4_5;
9367 opti_type = OPTI_TYPE_ZERO_BYTE;
9368 dgst_pos0 = 0;
9369 dgst_pos1 = 1;
9370 dgst_pos2 = 2;
9371 dgst_pos3 = 3;
9372 break;
9373
9374 case 6221: hash_type = HASH_TYPE_SHA512;
9375 salt_type = SALT_TYPE_EMBEDDED;
9376 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9377 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9378 kern_type = KERN_TYPE_TCSHA512_XTS512;
9379 dgst_size = DGST_SIZE_8_8;
9380 parse_func = truecrypt_parse_hash_1k;
9381 sort_by_digest = sort_by_digest_8_8;
9382 opti_type = OPTI_TYPE_ZERO_BYTE
9383 | OPTI_TYPE_USES_BITS_64;
9384 dgst_pos0 = 0;
9385 dgst_pos1 = 1;
9386 dgst_pos2 = 2;
9387 dgst_pos3 = 3;
9388 break;
9389
9390 case 6222: hash_type = HASH_TYPE_SHA512;
9391 salt_type = SALT_TYPE_EMBEDDED;
9392 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9393 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9394 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9395 dgst_size = DGST_SIZE_8_8;
9396 parse_func = truecrypt_parse_hash_1k;
9397 sort_by_digest = sort_by_digest_8_8;
9398 opti_type = OPTI_TYPE_ZERO_BYTE
9399 | OPTI_TYPE_USES_BITS_64;
9400 dgst_pos0 = 0;
9401 dgst_pos1 = 1;
9402 dgst_pos2 = 2;
9403 dgst_pos3 = 3;
9404 break;
9405
9406 case 6223: hash_type = HASH_TYPE_SHA512;
9407 salt_type = SALT_TYPE_EMBEDDED;
9408 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9409 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9410 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9411 dgst_size = DGST_SIZE_8_8;
9412 parse_func = truecrypt_parse_hash_1k;
9413 sort_by_digest = sort_by_digest_8_8;
9414 opti_type = OPTI_TYPE_ZERO_BYTE
9415 | OPTI_TYPE_USES_BITS_64;
9416 dgst_pos0 = 0;
9417 dgst_pos1 = 1;
9418 dgst_pos2 = 2;
9419 dgst_pos3 = 3;
9420 break;
9421
9422 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9423 salt_type = SALT_TYPE_EMBEDDED;
9424 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9425 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9426 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9427 dgst_size = DGST_SIZE_4_8;
9428 parse_func = truecrypt_parse_hash_1k;
9429 sort_by_digest = sort_by_digest_4_8;
9430 opti_type = OPTI_TYPE_ZERO_BYTE;
9431 dgst_pos0 = 0;
9432 dgst_pos1 = 1;
9433 dgst_pos2 = 2;
9434 dgst_pos3 = 3;
9435 break;
9436
9437 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9438 salt_type = SALT_TYPE_EMBEDDED;
9439 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9440 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9441 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9442 dgst_size = DGST_SIZE_4_8;
9443 parse_func = truecrypt_parse_hash_1k;
9444 sort_by_digest = sort_by_digest_4_8;
9445 opti_type = OPTI_TYPE_ZERO_BYTE;
9446 dgst_pos0 = 0;
9447 dgst_pos1 = 1;
9448 dgst_pos2 = 2;
9449 dgst_pos3 = 3;
9450 break;
9451
9452 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9453 salt_type = SALT_TYPE_EMBEDDED;
9454 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9455 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9456 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9457 dgst_size = DGST_SIZE_4_8;
9458 parse_func = truecrypt_parse_hash_1k;
9459 sort_by_digest = sort_by_digest_4_8;
9460 opti_type = OPTI_TYPE_ZERO_BYTE;
9461 dgst_pos0 = 0;
9462 dgst_pos1 = 1;
9463 dgst_pos2 = 2;
9464 dgst_pos3 = 3;
9465 break;
9466
9467 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9468 salt_type = SALT_TYPE_EMBEDDED;
9469 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9470 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9471 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9472 dgst_size = DGST_SIZE_4_5;
9473 parse_func = truecrypt_parse_hash_1k;
9474 sort_by_digest = sort_by_digest_4_5;
9475 opti_type = OPTI_TYPE_ZERO_BYTE;
9476 dgst_pos0 = 0;
9477 dgst_pos1 = 1;
9478 dgst_pos2 = 2;
9479 dgst_pos3 = 3;
9480 break;
9481
9482 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9483 salt_type = SALT_TYPE_EMBEDDED;
9484 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9485 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9486 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9487 dgst_size = DGST_SIZE_4_5;
9488 parse_func = truecrypt_parse_hash_1k;
9489 sort_by_digest = sort_by_digest_4_5;
9490 opti_type = OPTI_TYPE_ZERO_BYTE;
9491 dgst_pos0 = 0;
9492 dgst_pos1 = 1;
9493 dgst_pos2 = 2;
9494 dgst_pos3 = 3;
9495 break;
9496
9497 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9498 salt_type = SALT_TYPE_EMBEDDED;
9499 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9500 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9501 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9502 dgst_size = DGST_SIZE_4_5;
9503 parse_func = truecrypt_parse_hash_1k;
9504 sort_by_digest = sort_by_digest_4_5;
9505 opti_type = OPTI_TYPE_ZERO_BYTE;
9506 dgst_pos0 = 0;
9507 dgst_pos1 = 1;
9508 dgst_pos2 = 2;
9509 dgst_pos3 = 3;
9510 break;
9511
9512 case 6300: hash_type = HASH_TYPE_MD5;
9513 salt_type = SALT_TYPE_EMBEDDED;
9514 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9515 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9516 kern_type = KERN_TYPE_MD5AIX;
9517 dgst_size = DGST_SIZE_4_4;
9518 parse_func = md5aix_parse_hash;
9519 sort_by_digest = sort_by_digest_4_4;
9520 opti_type = OPTI_TYPE_ZERO_BYTE;
9521 dgst_pos0 = 0;
9522 dgst_pos1 = 1;
9523 dgst_pos2 = 2;
9524 dgst_pos3 = 3;
9525 break;
9526
9527 case 6400: hash_type = HASH_TYPE_SHA256;
9528 salt_type = SALT_TYPE_EMBEDDED;
9529 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9530 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9531 kern_type = KERN_TYPE_SHA256AIX;
9532 dgst_size = DGST_SIZE_4_8;
9533 parse_func = sha256aix_parse_hash;
9534 sort_by_digest = sort_by_digest_4_8;
9535 opti_type = OPTI_TYPE_ZERO_BYTE;
9536 dgst_pos0 = 0;
9537 dgst_pos1 = 1;
9538 dgst_pos2 = 2;
9539 dgst_pos3 = 3;
9540 break;
9541
9542 case 6500: hash_type = HASH_TYPE_SHA512;
9543 salt_type = SALT_TYPE_EMBEDDED;
9544 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9545 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9546 kern_type = KERN_TYPE_SHA512AIX;
9547 dgst_size = DGST_SIZE_8_8;
9548 parse_func = sha512aix_parse_hash;
9549 sort_by_digest = sort_by_digest_8_8;
9550 opti_type = OPTI_TYPE_ZERO_BYTE
9551 | OPTI_TYPE_USES_BITS_64;
9552 dgst_pos0 = 0;
9553 dgst_pos1 = 1;
9554 dgst_pos2 = 2;
9555 dgst_pos3 = 3;
9556 break;
9557
9558 case 6600: hash_type = HASH_TYPE_AES;
9559 salt_type = SALT_TYPE_EMBEDDED;
9560 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9561 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9562 kern_type = KERN_TYPE_AGILEKEY;
9563 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9564 parse_func = agilekey_parse_hash;
9565 sort_by_digest = sort_by_digest_4_5;
9566 opti_type = OPTI_TYPE_ZERO_BYTE;
9567 dgst_pos0 = 0;
9568 dgst_pos1 = 1;
9569 dgst_pos2 = 2;
9570 dgst_pos3 = 3;
9571 break;
9572
9573 case 6700: hash_type = HASH_TYPE_SHA1;
9574 salt_type = SALT_TYPE_EMBEDDED;
9575 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9576 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9577 kern_type = KERN_TYPE_SHA1AIX;
9578 dgst_size = DGST_SIZE_4_5;
9579 parse_func = sha1aix_parse_hash;
9580 sort_by_digest = sort_by_digest_4_5;
9581 opti_type = OPTI_TYPE_ZERO_BYTE;
9582 dgst_pos0 = 0;
9583 dgst_pos1 = 1;
9584 dgst_pos2 = 2;
9585 dgst_pos3 = 3;
9586 break;
9587
9588 case 6800: hash_type = HASH_TYPE_AES;
9589 salt_type = SALT_TYPE_EMBEDDED;
9590 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9591 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9592 kern_type = KERN_TYPE_LASTPASS;
9593 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9594 parse_func = lastpass_parse_hash;
9595 sort_by_digest = sort_by_digest_4_8;
9596 opti_type = OPTI_TYPE_ZERO_BYTE;
9597 dgst_pos0 = 0;
9598 dgst_pos1 = 1;
9599 dgst_pos2 = 2;
9600 dgst_pos3 = 3;
9601 break;
9602
9603 case 6900: hash_type = HASH_TYPE_GOST;
9604 salt_type = SALT_TYPE_NONE;
9605 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9606 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9607 kern_type = KERN_TYPE_GOST;
9608 dgst_size = DGST_SIZE_4_8;
9609 parse_func = gost_parse_hash;
9610 sort_by_digest = sort_by_digest_4_8;
9611 opti_type = OPTI_TYPE_ZERO_BYTE;
9612 dgst_pos0 = 0;
9613 dgst_pos1 = 1;
9614 dgst_pos2 = 2;
9615 dgst_pos3 = 3;
9616 break;
9617
9618 case 7100: hash_type = HASH_TYPE_SHA512;
9619 salt_type = SALT_TYPE_EMBEDDED;
9620 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9621 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9622 kern_type = KERN_TYPE_PBKDF2_SHA512;
9623 dgst_size = DGST_SIZE_8_16;
9624 parse_func = sha512osx_parse_hash;
9625 sort_by_digest = sort_by_digest_8_16;
9626 opti_type = OPTI_TYPE_ZERO_BYTE
9627 | OPTI_TYPE_USES_BITS_64
9628 | OPTI_TYPE_SLOW_HASH_SIMD;
9629 dgst_pos0 = 0;
9630 dgst_pos1 = 1;
9631 dgst_pos2 = 2;
9632 dgst_pos3 = 3;
9633 break;
9634
9635 case 7200: hash_type = HASH_TYPE_SHA512;
9636 salt_type = SALT_TYPE_EMBEDDED;
9637 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9638 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9639 kern_type = KERN_TYPE_PBKDF2_SHA512;
9640 dgst_size = DGST_SIZE_8_16;
9641 parse_func = sha512grub_parse_hash;
9642 sort_by_digest = sort_by_digest_8_16;
9643 opti_type = OPTI_TYPE_ZERO_BYTE
9644 | OPTI_TYPE_USES_BITS_64
9645 | OPTI_TYPE_SLOW_HASH_SIMD;
9646 dgst_pos0 = 0;
9647 dgst_pos1 = 1;
9648 dgst_pos2 = 2;
9649 dgst_pos3 = 3;
9650 break;
9651
9652 case 7300: hash_type = HASH_TYPE_SHA1;
9653 salt_type = SALT_TYPE_EMBEDDED;
9654 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9655 opts_type = OPTS_TYPE_PT_GENERATE_BE
9656 | OPTS_TYPE_ST_ADD80
9657 | OPTS_TYPE_ST_ADDBITS15;
9658 kern_type = KERN_TYPE_RAKP;
9659 dgst_size = DGST_SIZE_4_5;
9660 parse_func = rakp_parse_hash;
9661 sort_by_digest = sort_by_digest_4_5;
9662 opti_type = OPTI_TYPE_ZERO_BYTE
9663 | OPTI_TYPE_NOT_ITERATED;
9664 dgst_pos0 = 3;
9665 dgst_pos1 = 4;
9666 dgst_pos2 = 2;
9667 dgst_pos3 = 1;
9668 break;
9669
9670 case 7400: hash_type = HASH_TYPE_SHA256;
9671 salt_type = SALT_TYPE_EMBEDDED;
9672 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9673 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9674 kern_type = KERN_TYPE_SHA256CRYPT;
9675 dgst_size = DGST_SIZE_4_8;
9676 parse_func = sha256crypt_parse_hash;
9677 sort_by_digest = sort_by_digest_4_8;
9678 opti_type = OPTI_TYPE_ZERO_BYTE;
9679 dgst_pos0 = 0;
9680 dgst_pos1 = 1;
9681 dgst_pos2 = 2;
9682 dgst_pos3 = 3;
9683 break;
9684
9685 case 7500: hash_type = HASH_TYPE_KRB5PA;
9686 salt_type = SALT_TYPE_EMBEDDED;
9687 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9688 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9689 kern_type = KERN_TYPE_KRB5PA;
9690 dgst_size = DGST_SIZE_4_4;
9691 parse_func = krb5pa_parse_hash;
9692 sort_by_digest = sort_by_digest_4_4;
9693 opti_type = OPTI_TYPE_ZERO_BYTE
9694 | OPTI_TYPE_NOT_ITERATED;
9695 dgst_pos0 = 0;
9696 dgst_pos1 = 1;
9697 dgst_pos2 = 2;
9698 dgst_pos3 = 3;
9699 break;
9700
9701 case 7600: hash_type = HASH_TYPE_SHA1;
9702 salt_type = SALT_TYPE_INTERN;
9703 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9704 opts_type = OPTS_TYPE_PT_GENERATE_BE
9705 | OPTS_TYPE_PT_ADD80
9706 | OPTS_TYPE_PT_ADDBITS15;
9707 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9708 dgst_size = DGST_SIZE_4_5;
9709 parse_func = redmine_parse_hash;
9710 sort_by_digest = sort_by_digest_4_5;
9711 opti_type = OPTI_TYPE_ZERO_BYTE
9712 | OPTI_TYPE_PRECOMPUTE_INIT
9713 | OPTI_TYPE_EARLY_SKIP
9714 | OPTI_TYPE_NOT_ITERATED
9715 | OPTI_TYPE_PREPENDED_SALT;
9716 dgst_pos0 = 3;
9717 dgst_pos1 = 4;
9718 dgst_pos2 = 2;
9719 dgst_pos3 = 1;
9720 break;
9721
9722 case 7700: hash_type = HASH_TYPE_SAPB;
9723 salt_type = SALT_TYPE_EMBEDDED;
9724 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9725 opts_type = OPTS_TYPE_PT_GENERATE_LE
9726 | OPTS_TYPE_PT_UPPER
9727 | OPTS_TYPE_ST_UPPER;
9728 kern_type = KERN_TYPE_SAPB;
9729 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9730 parse_func = sapb_parse_hash;
9731 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9732 opti_type = OPTI_TYPE_ZERO_BYTE
9733 | OPTI_TYPE_PRECOMPUTE_INIT
9734 | OPTI_TYPE_NOT_ITERATED;
9735 dgst_pos0 = 0;
9736 dgst_pos1 = 1;
9737 dgst_pos2 = 2;
9738 dgst_pos3 = 3;
9739 break;
9740
9741 case 7800: hash_type = HASH_TYPE_SAPG;
9742 salt_type = SALT_TYPE_EMBEDDED;
9743 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9744 opts_type = OPTS_TYPE_PT_GENERATE_BE
9745 | OPTS_TYPE_ST_ADD80
9746 | OPTS_TYPE_ST_UPPER;
9747 kern_type = KERN_TYPE_SAPG;
9748 dgst_size = DGST_SIZE_4_5;
9749 parse_func = sapg_parse_hash;
9750 sort_by_digest = sort_by_digest_4_5;
9751 opti_type = OPTI_TYPE_ZERO_BYTE
9752 | OPTI_TYPE_PRECOMPUTE_INIT
9753 | OPTI_TYPE_NOT_ITERATED;
9754 dgst_pos0 = 3;
9755 dgst_pos1 = 4;
9756 dgst_pos2 = 2;
9757 dgst_pos3 = 1;
9758 break;
9759
9760 case 7900: hash_type = HASH_TYPE_SHA512;
9761 salt_type = SALT_TYPE_EMBEDDED;
9762 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9763 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9764 kern_type = KERN_TYPE_DRUPAL7;
9765 dgst_size = DGST_SIZE_8_8;
9766 parse_func = drupal7_parse_hash;
9767 sort_by_digest = sort_by_digest_8_8;
9768 opti_type = OPTI_TYPE_ZERO_BYTE
9769 | OPTI_TYPE_USES_BITS_64;
9770 dgst_pos0 = 0;
9771 dgst_pos1 = 1;
9772 dgst_pos2 = 2;
9773 dgst_pos3 = 3;
9774 break;
9775
9776 case 8000: hash_type = HASH_TYPE_SHA256;
9777 salt_type = SALT_TYPE_EMBEDDED;
9778 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9779 opts_type = OPTS_TYPE_PT_GENERATE_BE
9780 | OPTS_TYPE_PT_UNICODE
9781 | OPTS_TYPE_ST_ADD80
9782 | OPTS_TYPE_ST_HEX;
9783 kern_type = KERN_TYPE_SYBASEASE;
9784 dgst_size = DGST_SIZE_4_8;
9785 parse_func = sybasease_parse_hash;
9786 sort_by_digest = sort_by_digest_4_8;
9787 opti_type = OPTI_TYPE_ZERO_BYTE
9788 | OPTI_TYPE_PRECOMPUTE_INIT
9789 | OPTI_TYPE_EARLY_SKIP
9790 | OPTI_TYPE_NOT_ITERATED
9791 | OPTI_TYPE_RAW_HASH;
9792 dgst_pos0 = 3;
9793 dgst_pos1 = 7;
9794 dgst_pos2 = 2;
9795 dgst_pos3 = 6;
9796 break;
9797
9798 case 8100: hash_type = HASH_TYPE_SHA1;
9799 salt_type = SALT_TYPE_EMBEDDED;
9800 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9801 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9802 kern_type = KERN_TYPE_NETSCALER;
9803 dgst_size = DGST_SIZE_4_5;
9804 parse_func = netscaler_parse_hash;
9805 sort_by_digest = sort_by_digest_4_5;
9806 opti_type = OPTI_TYPE_ZERO_BYTE
9807 | OPTI_TYPE_PRECOMPUTE_INIT
9808 | OPTI_TYPE_PRECOMPUTE_MERKLE
9809 | OPTI_TYPE_EARLY_SKIP
9810 | OPTI_TYPE_NOT_ITERATED
9811 | OPTI_TYPE_PREPENDED_SALT
9812 | OPTI_TYPE_RAW_HASH;
9813 dgst_pos0 = 3;
9814 dgst_pos1 = 4;
9815 dgst_pos2 = 2;
9816 dgst_pos3 = 1;
9817 break;
9818
9819 case 8200: hash_type = HASH_TYPE_SHA256;
9820 salt_type = SALT_TYPE_EMBEDDED;
9821 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9822 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9823 kern_type = KERN_TYPE_CLOUDKEY;
9824 dgst_size = DGST_SIZE_4_8;
9825 parse_func = cloudkey_parse_hash;
9826 sort_by_digest = sort_by_digest_4_8;
9827 opti_type = OPTI_TYPE_ZERO_BYTE;
9828 dgst_pos0 = 0;
9829 dgst_pos1 = 1;
9830 dgst_pos2 = 2;
9831 dgst_pos3 = 3;
9832 break;
9833
9834 case 8300: hash_type = HASH_TYPE_SHA1;
9835 salt_type = SALT_TYPE_EMBEDDED;
9836 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9837 opts_type = OPTS_TYPE_PT_GENERATE_BE
9838 | OPTS_TYPE_ST_HEX
9839 | OPTS_TYPE_ST_ADD80;
9840 kern_type = KERN_TYPE_NSEC3;
9841 dgst_size = DGST_SIZE_4_5;
9842 parse_func = nsec3_parse_hash;
9843 sort_by_digest = sort_by_digest_4_5;
9844 opti_type = OPTI_TYPE_ZERO_BYTE;
9845 dgst_pos0 = 3;
9846 dgst_pos1 = 4;
9847 dgst_pos2 = 2;
9848 dgst_pos3 = 1;
9849 break;
9850
9851 case 8400: hash_type = HASH_TYPE_SHA1;
9852 salt_type = SALT_TYPE_INTERN;
9853 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9854 opts_type = OPTS_TYPE_PT_GENERATE_BE
9855 | OPTS_TYPE_PT_ADD80
9856 | OPTS_TYPE_PT_ADDBITS15;
9857 kern_type = KERN_TYPE_WBB3;
9858 dgst_size = DGST_SIZE_4_5;
9859 parse_func = wbb3_parse_hash;
9860 sort_by_digest = sort_by_digest_4_5;
9861 opti_type = OPTI_TYPE_ZERO_BYTE
9862 | OPTI_TYPE_PRECOMPUTE_INIT
9863 | OPTI_TYPE_NOT_ITERATED;
9864 dgst_pos0 = 3;
9865 dgst_pos1 = 4;
9866 dgst_pos2 = 2;
9867 dgst_pos3 = 1;
9868 break;
9869
9870 case 8500: hash_type = HASH_TYPE_DESRACF;
9871 salt_type = SALT_TYPE_EMBEDDED;
9872 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9873 opts_type = OPTS_TYPE_PT_GENERATE_LE
9874 | OPTS_TYPE_ST_UPPER;
9875 kern_type = KERN_TYPE_RACF;
9876 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9877 parse_func = racf_parse_hash;
9878 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9879 opti_type = OPTI_TYPE_ZERO_BYTE
9880 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9881 dgst_pos0 = 0;
9882 dgst_pos1 = 1;
9883 dgst_pos2 = 2;
9884 dgst_pos3 = 3;
9885 break;
9886
9887 case 8600: hash_type = HASH_TYPE_LOTUS5;
9888 salt_type = SALT_TYPE_NONE;
9889 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9890 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9891 kern_type = KERN_TYPE_LOTUS5;
9892 dgst_size = DGST_SIZE_4_4;
9893 parse_func = lotus5_parse_hash;
9894 sort_by_digest = sort_by_digest_4_4;
9895 opti_type = OPTI_TYPE_EARLY_SKIP
9896 | OPTI_TYPE_NOT_ITERATED
9897 | OPTI_TYPE_NOT_SALTED
9898 | OPTI_TYPE_RAW_HASH;
9899 dgst_pos0 = 0;
9900 dgst_pos1 = 1;
9901 dgst_pos2 = 2;
9902 dgst_pos3 = 3;
9903 break;
9904
9905 case 8700: hash_type = HASH_TYPE_LOTUS6;
9906 salt_type = SALT_TYPE_EMBEDDED;
9907 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9908 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9909 kern_type = KERN_TYPE_LOTUS6;
9910 dgst_size = DGST_SIZE_4_4;
9911 parse_func = lotus6_parse_hash;
9912 sort_by_digest = sort_by_digest_4_4;
9913 opti_type = OPTI_TYPE_EARLY_SKIP
9914 | OPTI_TYPE_NOT_ITERATED
9915 | OPTI_TYPE_RAW_HASH;
9916 dgst_pos0 = 0;
9917 dgst_pos1 = 1;
9918 dgst_pos2 = 2;
9919 dgst_pos3 = 3;
9920 break;
9921
9922 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9923 salt_type = SALT_TYPE_EMBEDDED;
9924 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9925 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9926 kern_type = KERN_TYPE_ANDROIDFDE;
9927 dgst_size = DGST_SIZE_4_4;
9928 parse_func = androidfde_parse_hash;
9929 sort_by_digest = sort_by_digest_4_4;
9930 opti_type = OPTI_TYPE_ZERO_BYTE;
9931 dgst_pos0 = 0;
9932 dgst_pos1 = 1;
9933 dgst_pos2 = 2;
9934 dgst_pos3 = 3;
9935 break;
9936
9937 case 8900: hash_type = HASH_TYPE_SCRYPT;
9938 salt_type = SALT_TYPE_EMBEDDED;
9939 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9940 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9941 kern_type = KERN_TYPE_SCRYPT;
9942 dgst_size = DGST_SIZE_4_8;
9943 parse_func = scrypt_parse_hash;
9944 sort_by_digest = sort_by_digest_4_8;
9945 opti_type = OPTI_TYPE_ZERO_BYTE;
9946 dgst_pos0 = 0;
9947 dgst_pos1 = 1;
9948 dgst_pos2 = 2;
9949 dgst_pos3 = 3;
9950 break;
9951
9952 case 9000: hash_type = HASH_TYPE_SHA1;
9953 salt_type = SALT_TYPE_EMBEDDED;
9954 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9955 opts_type = OPTS_TYPE_PT_GENERATE_LE
9956 | OPTS_TYPE_ST_GENERATE_LE;
9957 kern_type = KERN_TYPE_PSAFE2;
9958 dgst_size = DGST_SIZE_4_5;
9959 parse_func = psafe2_parse_hash;
9960 sort_by_digest = sort_by_digest_4_5;
9961 opti_type = OPTI_TYPE_ZERO_BYTE;
9962 dgst_pos0 = 0;
9963 dgst_pos1 = 1;
9964 dgst_pos2 = 2;
9965 dgst_pos3 = 3;
9966 break;
9967
9968 case 9100: hash_type = HASH_TYPE_LOTUS8;
9969 salt_type = SALT_TYPE_EMBEDDED;
9970 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9971 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9972 kern_type = KERN_TYPE_LOTUS8;
9973 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9974 parse_func = lotus8_parse_hash;
9975 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9976 opti_type = OPTI_TYPE_ZERO_BYTE;
9977 dgst_pos0 = 0;
9978 dgst_pos1 = 1;
9979 dgst_pos2 = 2;
9980 dgst_pos3 = 3;
9981 break;
9982
9983 case 9200: hash_type = HASH_TYPE_SHA256;
9984 salt_type = SALT_TYPE_EMBEDDED;
9985 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9986 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9987 kern_type = KERN_TYPE_PBKDF2_SHA256;
9988 dgst_size = DGST_SIZE_4_32;
9989 parse_func = cisco8_parse_hash;
9990 sort_by_digest = sort_by_digest_4_32;
9991 opti_type = OPTI_TYPE_ZERO_BYTE
9992 | OPTI_TYPE_SLOW_HASH_SIMD;
9993 dgst_pos0 = 0;
9994 dgst_pos1 = 1;
9995 dgst_pos2 = 2;
9996 dgst_pos3 = 3;
9997 break;
9998
9999 case 9300: hash_type = HASH_TYPE_SCRYPT;
10000 salt_type = SALT_TYPE_EMBEDDED;
10001 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10002 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10003 kern_type = KERN_TYPE_SCRYPT;
10004 dgst_size = DGST_SIZE_4_8;
10005 parse_func = cisco9_parse_hash;
10006 sort_by_digest = sort_by_digest_4_8;
10007 opti_type = OPTI_TYPE_ZERO_BYTE;
10008 dgst_pos0 = 0;
10009 dgst_pos1 = 1;
10010 dgst_pos2 = 2;
10011 dgst_pos3 = 3;
10012 break;
10013
10014 case 9400: hash_type = HASH_TYPE_OFFICE2007;
10015 salt_type = SALT_TYPE_EMBEDDED;
10016 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10017 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10018 kern_type = KERN_TYPE_OFFICE2007;
10019 dgst_size = DGST_SIZE_4_4;
10020 parse_func = office2007_parse_hash;
10021 sort_by_digest = sort_by_digest_4_4;
10022 opti_type = OPTI_TYPE_ZERO_BYTE;
10023 dgst_pos0 = 0;
10024 dgst_pos1 = 1;
10025 dgst_pos2 = 2;
10026 dgst_pos3 = 3;
10027 break;
10028
10029 case 9500: hash_type = HASH_TYPE_OFFICE2010;
10030 salt_type = SALT_TYPE_EMBEDDED;
10031 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10032 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10033 kern_type = KERN_TYPE_OFFICE2010;
10034 dgst_size = DGST_SIZE_4_4;
10035 parse_func = office2010_parse_hash;
10036 sort_by_digest = sort_by_digest_4_4;
10037 opti_type = OPTI_TYPE_ZERO_BYTE;
10038 dgst_pos0 = 0;
10039 dgst_pos1 = 1;
10040 dgst_pos2 = 2;
10041 dgst_pos3 = 3;
10042 break;
10043
10044 case 9600: hash_type = HASH_TYPE_OFFICE2013;
10045 salt_type = SALT_TYPE_EMBEDDED;
10046 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10047 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10048 kern_type = KERN_TYPE_OFFICE2013;
10049 dgst_size = DGST_SIZE_4_4;
10050 parse_func = office2013_parse_hash;
10051 sort_by_digest = sort_by_digest_4_4;
10052 opti_type = OPTI_TYPE_ZERO_BYTE;
10053 dgst_pos0 = 0;
10054 dgst_pos1 = 1;
10055 dgst_pos2 = 2;
10056 dgst_pos3 = 3;
10057 break;
10058
10059 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
10060 salt_type = SALT_TYPE_EMBEDDED;
10061 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10062 opts_type = OPTS_TYPE_PT_GENERATE_LE
10063 | OPTS_TYPE_PT_ADD80
10064 | OPTS_TYPE_PT_UNICODE;
10065 kern_type = KERN_TYPE_OLDOFFICE01;
10066 dgst_size = DGST_SIZE_4_4;
10067 parse_func = oldoffice01_parse_hash;
10068 sort_by_digest = sort_by_digest_4_4;
10069 opti_type = OPTI_TYPE_ZERO_BYTE
10070 | OPTI_TYPE_PRECOMPUTE_INIT
10071 | OPTI_TYPE_NOT_ITERATED;
10072 dgst_pos0 = 0;
10073 dgst_pos1 = 1;
10074 dgst_pos2 = 2;
10075 dgst_pos3 = 3;
10076 break;
10077
10078 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
10079 salt_type = SALT_TYPE_EMBEDDED;
10080 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10081 opts_type = OPTS_TYPE_PT_GENERATE_LE
10082 | OPTS_TYPE_PT_ADD80;
10083 kern_type = KERN_TYPE_OLDOFFICE01CM1;
10084 dgst_size = DGST_SIZE_4_4;
10085 parse_func = oldoffice01cm1_parse_hash;
10086 sort_by_digest = sort_by_digest_4_4;
10087 opti_type = OPTI_TYPE_ZERO_BYTE
10088 | OPTI_TYPE_PRECOMPUTE_INIT
10089 | OPTI_TYPE_NOT_ITERATED;
10090 dgst_pos0 = 0;
10091 dgst_pos1 = 1;
10092 dgst_pos2 = 2;
10093 dgst_pos3 = 3;
10094 break;
10095
10096 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
10097 salt_type = SALT_TYPE_EMBEDDED;
10098 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10099 opts_type = OPTS_TYPE_PT_GENERATE_LE
10100 | OPTS_TYPE_PT_ADD80
10101 | OPTS_TYPE_PT_UNICODE
10102 | OPTS_TYPE_PT_NEVERCRACK;
10103 kern_type = KERN_TYPE_OLDOFFICE01CM2;
10104 dgst_size = DGST_SIZE_4_4;
10105 parse_func = oldoffice01cm2_parse_hash;
10106 sort_by_digest = sort_by_digest_4_4;
10107 opti_type = OPTI_TYPE_ZERO_BYTE
10108 | OPTI_TYPE_PRECOMPUTE_INIT
10109 | OPTI_TYPE_NOT_ITERATED;
10110 dgst_pos0 = 0;
10111 dgst_pos1 = 1;
10112 dgst_pos2 = 2;
10113 dgst_pos3 = 3;
10114 break;
10115
10116 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
10117 salt_type = SALT_TYPE_EMBEDDED;
10118 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10119 opts_type = OPTS_TYPE_PT_GENERATE_BE
10120 | OPTS_TYPE_PT_ADD80
10121 | OPTS_TYPE_PT_UNICODE;
10122 kern_type = KERN_TYPE_OLDOFFICE34;
10123 dgst_size = DGST_SIZE_4_4;
10124 parse_func = oldoffice34_parse_hash;
10125 sort_by_digest = sort_by_digest_4_4;
10126 opti_type = OPTI_TYPE_ZERO_BYTE
10127 | OPTI_TYPE_PRECOMPUTE_INIT
10128 | OPTI_TYPE_NOT_ITERATED;
10129 dgst_pos0 = 0;
10130 dgst_pos1 = 1;
10131 dgst_pos2 = 2;
10132 dgst_pos3 = 3;
10133 break;
10134
10135 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10136 salt_type = SALT_TYPE_EMBEDDED;
10137 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10138 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10139 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10140 dgst_size = DGST_SIZE_4_4;
10141 parse_func = oldoffice34cm1_parse_hash;
10142 sort_by_digest = sort_by_digest_4_4;
10143 opti_type = OPTI_TYPE_ZERO_BYTE
10144 | OPTI_TYPE_PRECOMPUTE_INIT
10145 | OPTI_TYPE_NOT_ITERATED;
10146 dgst_pos0 = 0;
10147 dgst_pos1 = 1;
10148 dgst_pos2 = 2;
10149 dgst_pos3 = 3;
10150 break;
10151
10152 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10153 salt_type = SALT_TYPE_EMBEDDED;
10154 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10155 opts_type = OPTS_TYPE_PT_GENERATE_BE
10156 | OPTS_TYPE_PT_ADD80
10157 | OPTS_TYPE_PT_UNICODE
10158 | OPTS_TYPE_PT_NEVERCRACK;
10159 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10160 dgst_size = DGST_SIZE_4_4;
10161 parse_func = oldoffice34cm2_parse_hash;
10162 sort_by_digest = sort_by_digest_4_4;
10163 opti_type = OPTI_TYPE_ZERO_BYTE
10164 | OPTI_TYPE_PRECOMPUTE_INIT
10165 | OPTI_TYPE_NOT_ITERATED;
10166 dgst_pos0 = 0;
10167 dgst_pos1 = 1;
10168 dgst_pos2 = 2;
10169 dgst_pos3 = 3;
10170 break;
10171
10172 case 9900: hash_type = HASH_TYPE_MD5;
10173 salt_type = SALT_TYPE_NONE;
10174 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10175 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10176 kern_type = KERN_TYPE_RADMIN2;
10177 dgst_size = DGST_SIZE_4_4;
10178 parse_func = radmin2_parse_hash;
10179 sort_by_digest = sort_by_digest_4_4;
10180 opti_type = OPTI_TYPE_ZERO_BYTE
10181 | OPTI_TYPE_PRECOMPUTE_INIT
10182 | OPTI_TYPE_EARLY_SKIP
10183 | OPTI_TYPE_NOT_ITERATED
10184 | OPTI_TYPE_NOT_SALTED;
10185 dgst_pos0 = 0;
10186 dgst_pos1 = 3;
10187 dgst_pos2 = 2;
10188 dgst_pos3 = 1;
10189 break;
10190
10191 case 10000: hash_type = HASH_TYPE_SHA256;
10192 salt_type = SALT_TYPE_EMBEDDED;
10193 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10194 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10195 kern_type = KERN_TYPE_PBKDF2_SHA256;
10196 dgst_size = DGST_SIZE_4_32;
10197 parse_func = djangopbkdf2_parse_hash;
10198 sort_by_digest = sort_by_digest_4_32;
10199 opti_type = OPTI_TYPE_ZERO_BYTE
10200 | OPTI_TYPE_SLOW_HASH_SIMD;
10201 dgst_pos0 = 0;
10202 dgst_pos1 = 1;
10203 dgst_pos2 = 2;
10204 dgst_pos3 = 3;
10205 break;
10206
10207 case 10100: hash_type = HASH_TYPE_SIPHASH;
10208 salt_type = SALT_TYPE_EMBEDDED;
10209 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10210 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10211 kern_type = KERN_TYPE_SIPHASH;
10212 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10213 parse_func = siphash_parse_hash;
10214 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10215 opti_type = OPTI_TYPE_ZERO_BYTE
10216 | OPTI_TYPE_NOT_ITERATED
10217 | OPTI_TYPE_RAW_HASH;
10218 dgst_pos0 = 0;
10219 dgst_pos1 = 1;
10220 dgst_pos2 = 2;
10221 dgst_pos3 = 3;
10222 break;
10223
10224 case 10200: hash_type = HASH_TYPE_MD5;
10225 salt_type = SALT_TYPE_EMBEDDED;
10226 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10227 opts_type = OPTS_TYPE_PT_GENERATE_LE
10228 | OPTS_TYPE_ST_ADD80
10229 | OPTS_TYPE_ST_ADDBITS14;
10230 kern_type = KERN_TYPE_HMACMD5_PW;
10231 dgst_size = DGST_SIZE_4_4;
10232 parse_func = crammd5_parse_hash;
10233 sort_by_digest = sort_by_digest_4_4;
10234 opti_type = OPTI_TYPE_ZERO_BYTE
10235 | OPTI_TYPE_NOT_ITERATED;
10236 dgst_pos0 = 0;
10237 dgst_pos1 = 3;
10238 dgst_pos2 = 2;
10239 dgst_pos3 = 1;
10240 break;
10241
10242 case 10300: hash_type = HASH_TYPE_SHA1;
10243 salt_type = SALT_TYPE_EMBEDDED;
10244 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10245 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10246 kern_type = KERN_TYPE_SAPH_SHA1;
10247 dgst_size = DGST_SIZE_4_5;
10248 parse_func = saph_sha1_parse_hash;
10249 sort_by_digest = sort_by_digest_4_5;
10250 opti_type = OPTI_TYPE_ZERO_BYTE;
10251 dgst_pos0 = 0;
10252 dgst_pos1 = 1;
10253 dgst_pos2 = 2;
10254 dgst_pos3 = 3;
10255 break;
10256
10257 case 10400: hash_type = HASH_TYPE_PDFU16;
10258 salt_type = SALT_TYPE_EMBEDDED;
10259 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10260 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10261 kern_type = KERN_TYPE_PDF11;
10262 dgst_size = DGST_SIZE_4_4;
10263 parse_func = pdf11_parse_hash;
10264 sort_by_digest = sort_by_digest_4_4;
10265 opti_type = OPTI_TYPE_ZERO_BYTE
10266 | OPTI_TYPE_NOT_ITERATED;
10267 dgst_pos0 = 0;
10268 dgst_pos1 = 1;
10269 dgst_pos2 = 2;
10270 dgst_pos3 = 3;
10271 break;
10272
10273 case 10410: hash_type = HASH_TYPE_PDFU16;
10274 salt_type = SALT_TYPE_EMBEDDED;
10275 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10276 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10277 kern_type = KERN_TYPE_PDF11CM1;
10278 dgst_size = DGST_SIZE_4_4;
10279 parse_func = pdf11cm1_parse_hash;
10280 sort_by_digest = sort_by_digest_4_4;
10281 opti_type = OPTI_TYPE_ZERO_BYTE
10282 | OPTI_TYPE_NOT_ITERATED;
10283 dgst_pos0 = 0;
10284 dgst_pos1 = 1;
10285 dgst_pos2 = 2;
10286 dgst_pos3 = 3;
10287 break;
10288
10289 case 10420: hash_type = HASH_TYPE_PDFU16;
10290 salt_type = SALT_TYPE_EMBEDDED;
10291 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10292 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10293 kern_type = KERN_TYPE_PDF11CM2;
10294 dgst_size = DGST_SIZE_4_4;
10295 parse_func = pdf11cm2_parse_hash;
10296 sort_by_digest = sort_by_digest_4_4;
10297 opti_type = OPTI_TYPE_ZERO_BYTE
10298 | OPTI_TYPE_NOT_ITERATED;
10299 dgst_pos0 = 0;
10300 dgst_pos1 = 1;
10301 dgst_pos2 = 2;
10302 dgst_pos3 = 3;
10303 break;
10304
10305 case 10500: hash_type = HASH_TYPE_PDFU16;
10306 salt_type = SALT_TYPE_EMBEDDED;
10307 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10308 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10309 kern_type = KERN_TYPE_PDF14;
10310 dgst_size = DGST_SIZE_4_4;
10311 parse_func = pdf14_parse_hash;
10312 sort_by_digest = sort_by_digest_4_4;
10313 opti_type = OPTI_TYPE_ZERO_BYTE
10314 | OPTI_TYPE_NOT_ITERATED;
10315 dgst_pos0 = 0;
10316 dgst_pos1 = 1;
10317 dgst_pos2 = 2;
10318 dgst_pos3 = 3;
10319 break;
10320
10321 case 10600: hash_type = HASH_TYPE_SHA256;
10322 salt_type = SALT_TYPE_EMBEDDED;
10323 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10324 opts_type = OPTS_TYPE_PT_GENERATE_BE
10325 | OPTS_TYPE_ST_ADD80
10326 | OPTS_TYPE_ST_ADDBITS15
10327 | OPTS_TYPE_HASH_COPY;
10328 kern_type = KERN_TYPE_SHA256_PWSLT;
10329 dgst_size = DGST_SIZE_4_8;
10330 parse_func = pdf17l3_parse_hash;
10331 sort_by_digest = sort_by_digest_4_8;
10332 opti_type = OPTI_TYPE_ZERO_BYTE
10333 | OPTI_TYPE_PRECOMPUTE_INIT
10334 | OPTI_TYPE_PRECOMPUTE_MERKLE
10335 | OPTI_TYPE_EARLY_SKIP
10336 | OPTI_TYPE_NOT_ITERATED
10337 | OPTI_TYPE_APPENDED_SALT
10338 | OPTI_TYPE_RAW_HASH;
10339 dgst_pos0 = 3;
10340 dgst_pos1 = 7;
10341 dgst_pos2 = 2;
10342 dgst_pos3 = 6;
10343 break;
10344
10345 case 10700: hash_type = HASH_TYPE_PDFU32;
10346 salt_type = SALT_TYPE_EMBEDDED;
10347 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10348 opts_type = OPTS_TYPE_PT_GENERATE_LE
10349 | OPTS_TYPE_HASH_COPY;
10350 kern_type = KERN_TYPE_PDF17L8;
10351 dgst_size = DGST_SIZE_4_8;
10352 parse_func = pdf17l8_parse_hash;
10353 sort_by_digest = sort_by_digest_4_8;
10354 opti_type = OPTI_TYPE_ZERO_BYTE
10355 | OPTI_TYPE_NOT_ITERATED;
10356 dgst_pos0 = 0;
10357 dgst_pos1 = 1;
10358 dgst_pos2 = 2;
10359 dgst_pos3 = 3;
10360 break;
10361
10362 case 10800: hash_type = HASH_TYPE_SHA384;
10363 salt_type = SALT_TYPE_NONE;
10364 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10365 opts_type = OPTS_TYPE_PT_GENERATE_BE
10366 | OPTS_TYPE_PT_ADD80
10367 | OPTS_TYPE_PT_ADDBITS15;
10368 kern_type = KERN_TYPE_SHA384;
10369 dgst_size = DGST_SIZE_8_8;
10370 parse_func = sha384_parse_hash;
10371 sort_by_digest = sort_by_digest_8_8;
10372 opti_type = OPTI_TYPE_ZERO_BYTE
10373 | OPTI_TYPE_PRECOMPUTE_INIT
10374 | OPTI_TYPE_PRECOMPUTE_MERKLE
10375 | OPTI_TYPE_EARLY_SKIP
10376 | OPTI_TYPE_NOT_ITERATED
10377 | OPTI_TYPE_NOT_SALTED
10378 | OPTI_TYPE_USES_BITS_64
10379 | OPTI_TYPE_RAW_HASH;
10380 dgst_pos0 = 6;
10381 dgst_pos1 = 7;
10382 dgst_pos2 = 4;
10383 dgst_pos3 = 5;
10384 break;
10385
10386 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10387 salt_type = SALT_TYPE_EMBEDDED;
10388 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10389 opts_type = OPTS_TYPE_PT_GENERATE_LE
10390 | OPTS_TYPE_ST_BASE64
10391 | OPTS_TYPE_HASH_COPY;
10392 kern_type = KERN_TYPE_PBKDF2_SHA256;
10393 dgst_size = DGST_SIZE_4_32;
10394 parse_func = pbkdf2_sha256_parse_hash;
10395 sort_by_digest = sort_by_digest_4_32;
10396 opti_type = OPTI_TYPE_ZERO_BYTE
10397 | OPTI_TYPE_SLOW_HASH_SIMD;
10398 dgst_pos0 = 0;
10399 dgst_pos1 = 1;
10400 dgst_pos2 = 2;
10401 dgst_pos3 = 3;
10402 break;
10403
10404 case 11000: hash_type = HASH_TYPE_MD5;
10405 salt_type = SALT_TYPE_INTERN;
10406 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10407 opts_type = OPTS_TYPE_PT_GENERATE_LE
10408 | OPTS_TYPE_PT_ADD80;
10409 kern_type = KERN_TYPE_PRESTASHOP;
10410 dgst_size = DGST_SIZE_4_4;
10411 parse_func = prestashop_parse_hash;
10412 sort_by_digest = sort_by_digest_4_4;
10413 opti_type = OPTI_TYPE_ZERO_BYTE
10414 | OPTI_TYPE_PRECOMPUTE_INIT
10415 | OPTI_TYPE_NOT_ITERATED
10416 | OPTI_TYPE_PREPENDED_SALT;
10417 dgst_pos0 = 0;
10418 dgst_pos1 = 3;
10419 dgst_pos2 = 2;
10420 dgst_pos3 = 1;
10421 break;
10422
10423 case 11100: hash_type = HASH_TYPE_MD5;
10424 salt_type = SALT_TYPE_EMBEDDED;
10425 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10426 opts_type = OPTS_TYPE_PT_GENERATE_LE
10427 | OPTS_TYPE_ST_ADD80;
10428 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10429 dgst_size = DGST_SIZE_4_4;
10430 parse_func = postgresql_auth_parse_hash;
10431 sort_by_digest = sort_by_digest_4_4;
10432 opti_type = OPTI_TYPE_ZERO_BYTE
10433 | OPTI_TYPE_PRECOMPUTE_INIT
10434 | OPTI_TYPE_PRECOMPUTE_MERKLE
10435 | OPTI_TYPE_EARLY_SKIP;
10436 dgst_pos0 = 0;
10437 dgst_pos1 = 3;
10438 dgst_pos2 = 2;
10439 dgst_pos3 = 1;
10440 break;
10441
10442 case 11200: hash_type = HASH_TYPE_SHA1;
10443 salt_type = SALT_TYPE_EMBEDDED;
10444 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10445 opts_type = OPTS_TYPE_PT_GENERATE_BE
10446 | OPTS_TYPE_PT_ADD80
10447 | OPTS_TYPE_ST_HEX;
10448 kern_type = KERN_TYPE_MYSQL_AUTH;
10449 dgst_size = DGST_SIZE_4_5;
10450 parse_func = mysql_auth_parse_hash;
10451 sort_by_digest = sort_by_digest_4_5;
10452 opti_type = OPTI_TYPE_ZERO_BYTE
10453 | OPTI_TYPE_EARLY_SKIP;
10454 dgst_pos0 = 3;
10455 dgst_pos1 = 4;
10456 dgst_pos2 = 2;
10457 dgst_pos3 = 1;
10458 break;
10459
10460 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10461 salt_type = SALT_TYPE_EMBEDDED;
10462 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10463 opts_type = OPTS_TYPE_PT_GENERATE_LE
10464 | OPTS_TYPE_ST_HEX
10465 | OPTS_TYPE_ST_ADD80;
10466 kern_type = KERN_TYPE_BITCOIN_WALLET;
10467 dgst_size = DGST_SIZE_4_4;
10468 parse_func = bitcoin_wallet_parse_hash;
10469 sort_by_digest = sort_by_digest_4_4;
10470 opti_type = OPTI_TYPE_ZERO_BYTE;
10471 dgst_pos0 = 0;
10472 dgst_pos1 = 1;
10473 dgst_pos2 = 2;
10474 dgst_pos3 = 3;
10475 break;
10476
10477 case 11400: hash_type = HASH_TYPE_MD5;
10478 salt_type = SALT_TYPE_EMBEDDED;
10479 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10480 opts_type = OPTS_TYPE_PT_GENERATE_LE
10481 | OPTS_TYPE_PT_ADD80
10482 | OPTS_TYPE_HASH_COPY;
10483 kern_type = KERN_TYPE_SIP_AUTH;
10484 dgst_size = DGST_SIZE_4_4;
10485 parse_func = sip_auth_parse_hash;
10486 sort_by_digest = sort_by_digest_4_4;
10487 opti_type = OPTI_TYPE_ZERO_BYTE;
10488 dgst_pos0 = 0;
10489 dgst_pos1 = 3;
10490 dgst_pos2 = 2;
10491 dgst_pos3 = 1;
10492 break;
10493
10494 case 11500: hash_type = HASH_TYPE_CRC32;
10495 salt_type = SALT_TYPE_INTERN;
10496 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10497 opts_type = OPTS_TYPE_PT_GENERATE_LE
10498 | OPTS_TYPE_ST_GENERATE_LE
10499 | OPTS_TYPE_ST_HEX;
10500 kern_type = KERN_TYPE_CRC32;
10501 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10502 parse_func = crc32_parse_hash;
10503 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10504 opti_type = OPTI_TYPE_ZERO_BYTE;
10505 dgst_pos0 = 0;
10506 dgst_pos1 = 1;
10507 dgst_pos2 = 2;
10508 dgst_pos3 = 3;
10509 break;
10510
10511 case 11600: hash_type = HASH_TYPE_AES;
10512 salt_type = SALT_TYPE_EMBEDDED;
10513 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10514 opts_type = OPTS_TYPE_PT_GENERATE_LE
10515 | OPTS_TYPE_PT_NEVERCRACK;
10516 kern_type = KERN_TYPE_SEVEN_ZIP;
10517 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10518 parse_func = seven_zip_parse_hash;
10519 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10520 opti_type = OPTI_TYPE_ZERO_BYTE;
10521 dgst_pos0 = 0;
10522 dgst_pos1 = 1;
10523 dgst_pos2 = 2;
10524 dgst_pos3 = 3;
10525 break;
10526
10527 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10528 salt_type = SALT_TYPE_NONE;
10529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10530 opts_type = OPTS_TYPE_PT_GENERATE_LE
10531 | OPTS_TYPE_PT_ADD01;
10532 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10533 dgst_size = DGST_SIZE_4_8;
10534 parse_func = gost2012sbog_256_parse_hash;
10535 sort_by_digest = sort_by_digest_4_8;
10536 opti_type = OPTI_TYPE_ZERO_BYTE;
10537 dgst_pos0 = 0;
10538 dgst_pos1 = 1;
10539 dgst_pos2 = 2;
10540 dgst_pos3 = 3;
10541 break;
10542
10543 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10544 salt_type = SALT_TYPE_NONE;
10545 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10546 opts_type = OPTS_TYPE_PT_GENERATE_LE
10547 | OPTS_TYPE_PT_ADD01;
10548 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10549 dgst_size = DGST_SIZE_4_16;
10550 parse_func = gost2012sbog_512_parse_hash;
10551 sort_by_digest = sort_by_digest_4_16;
10552 opti_type = OPTI_TYPE_ZERO_BYTE;
10553 dgst_pos0 = 0;
10554 dgst_pos1 = 1;
10555 dgst_pos2 = 2;
10556 dgst_pos3 = 3;
10557 break;
10558
10559 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10560 salt_type = SALT_TYPE_EMBEDDED;
10561 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10562 opts_type = OPTS_TYPE_PT_GENERATE_LE
10563 | OPTS_TYPE_ST_BASE64
10564 | OPTS_TYPE_HASH_COPY;
10565 kern_type = KERN_TYPE_PBKDF2_MD5;
10566 dgst_size = DGST_SIZE_4_32;
10567 parse_func = pbkdf2_md5_parse_hash;
10568 sort_by_digest = sort_by_digest_4_32;
10569 opti_type = OPTI_TYPE_ZERO_BYTE
10570 | OPTI_TYPE_SLOW_HASH_SIMD;
10571 dgst_pos0 = 0;
10572 dgst_pos1 = 1;
10573 dgst_pos2 = 2;
10574 dgst_pos3 = 3;
10575 break;
10576
10577 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10578 salt_type = SALT_TYPE_EMBEDDED;
10579 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10580 opts_type = OPTS_TYPE_PT_GENERATE_LE
10581 | OPTS_TYPE_ST_BASE64
10582 | OPTS_TYPE_HASH_COPY;
10583 kern_type = KERN_TYPE_PBKDF2_SHA1;
10584 dgst_size = DGST_SIZE_4_32;
10585 parse_func = pbkdf2_sha1_parse_hash;
10586 sort_by_digest = sort_by_digest_4_32;
10587 opti_type = OPTI_TYPE_ZERO_BYTE
10588 | OPTI_TYPE_SLOW_HASH_SIMD;
10589 dgst_pos0 = 0;
10590 dgst_pos1 = 1;
10591 dgst_pos2 = 2;
10592 dgst_pos3 = 3;
10593 break;
10594
10595 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10596 salt_type = SALT_TYPE_EMBEDDED;
10597 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10598 opts_type = OPTS_TYPE_PT_GENERATE_LE
10599 | OPTS_TYPE_ST_BASE64
10600 | OPTS_TYPE_HASH_COPY;
10601 kern_type = KERN_TYPE_PBKDF2_SHA512;
10602 dgst_size = DGST_SIZE_8_16;
10603 parse_func = pbkdf2_sha512_parse_hash;
10604 sort_by_digest = sort_by_digest_8_16;
10605 opti_type = OPTI_TYPE_ZERO_BYTE
10606 | OPTI_TYPE_USES_BITS_64
10607 | OPTI_TYPE_SLOW_HASH_SIMD;
10608 dgst_pos0 = 0;
10609 dgst_pos1 = 1;
10610 dgst_pos2 = 2;
10611 dgst_pos3 = 3;
10612 break;
10613
10614 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10615 salt_type = SALT_TYPE_EMBEDDED;
10616 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10617 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10618 kern_type = KERN_TYPE_ECRYPTFS;
10619 dgst_size = DGST_SIZE_8_8;
10620 parse_func = ecryptfs_parse_hash;
10621 sort_by_digest = sort_by_digest_8_8;
10622 opti_type = OPTI_TYPE_ZERO_BYTE
10623 | OPTI_TYPE_USES_BITS_64;
10624 dgst_pos0 = 0;
10625 dgst_pos1 = 1;
10626 dgst_pos2 = 2;
10627 dgst_pos3 = 3;
10628 break;
10629
10630 case 12300: hash_type = HASH_TYPE_ORACLET;
10631 salt_type = SALT_TYPE_EMBEDDED;
10632 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10633 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10634 kern_type = KERN_TYPE_ORACLET;
10635 dgst_size = DGST_SIZE_8_16;
10636 parse_func = oraclet_parse_hash;
10637 sort_by_digest = sort_by_digest_8_16;
10638 opti_type = OPTI_TYPE_ZERO_BYTE
10639 | OPTI_TYPE_USES_BITS_64;
10640 dgst_pos0 = 0;
10641 dgst_pos1 = 1;
10642 dgst_pos2 = 2;
10643 dgst_pos3 = 3;
10644 break;
10645
10646 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10647 salt_type = SALT_TYPE_EMBEDDED;
10648 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10649 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10650 kern_type = KERN_TYPE_BSDICRYPT;
10651 dgst_size = DGST_SIZE_4_4;
10652 parse_func = bsdicrypt_parse_hash;
10653 sort_by_digest = sort_by_digest_4_4;
10654 opti_type = OPTI_TYPE_ZERO_BYTE
10655 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10656 dgst_pos0 = 0;
10657 dgst_pos1 = 1;
10658 dgst_pos2 = 2;
10659 dgst_pos3 = 3;
10660 break;
10661
10662 case 12500: hash_type = HASH_TYPE_RAR3HP;
10663 salt_type = SALT_TYPE_EMBEDDED;
10664 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10665 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10666 kern_type = KERN_TYPE_RAR3;
10667 dgst_size = DGST_SIZE_4_4;
10668 parse_func = rar3hp_parse_hash;
10669 sort_by_digest = sort_by_digest_4_4;
10670 opti_type = OPTI_TYPE_ZERO_BYTE;
10671 dgst_pos0 = 0;
10672 dgst_pos1 = 1;
10673 dgst_pos2 = 2;
10674 dgst_pos3 = 3;
10675 break;
10676
10677 case 12600: hash_type = HASH_TYPE_SHA256;
10678 salt_type = SALT_TYPE_INTERN;
10679 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10680 opts_type = OPTS_TYPE_PT_GENERATE_BE
10681 | OPTS_TYPE_PT_ADD80;
10682 kern_type = KERN_TYPE_CF10;
10683 dgst_size = DGST_SIZE_4_8;
10684 parse_func = cf10_parse_hash;
10685 sort_by_digest = sort_by_digest_4_8;
10686 opti_type = OPTI_TYPE_ZERO_BYTE
10687 | OPTI_TYPE_PRECOMPUTE_INIT
10688 | OPTI_TYPE_EARLY_SKIP
10689 | OPTI_TYPE_NOT_ITERATED;
10690 dgst_pos0 = 3;
10691 dgst_pos1 = 7;
10692 dgst_pos2 = 2;
10693 dgst_pos3 = 6;
10694 break;
10695
10696 case 12700: hash_type = HASH_TYPE_AES;
10697 salt_type = SALT_TYPE_EMBEDDED;
10698 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10699 opts_type = OPTS_TYPE_PT_GENERATE_LE
10700 | OPTS_TYPE_HASH_COPY;
10701 kern_type = KERN_TYPE_MYWALLET;
10702 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10703 parse_func = mywallet_parse_hash;
10704 sort_by_digest = sort_by_digest_4_5;
10705 opti_type = OPTI_TYPE_ZERO_BYTE;
10706 dgst_pos0 = 0;
10707 dgst_pos1 = 1;
10708 dgst_pos2 = 2;
10709 dgst_pos3 = 3;
10710 break;
10711
10712 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10713 salt_type = SALT_TYPE_EMBEDDED;
10714 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10715 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10716 kern_type = KERN_TYPE_MS_DRSR;
10717 dgst_size = DGST_SIZE_4_8;
10718 parse_func = ms_drsr_parse_hash;
10719 sort_by_digest = sort_by_digest_4_8;
10720 opti_type = OPTI_TYPE_ZERO_BYTE;
10721 dgst_pos0 = 0;
10722 dgst_pos1 = 1;
10723 dgst_pos2 = 2;
10724 dgst_pos3 = 3;
10725 break;
10726
10727 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10728 salt_type = SALT_TYPE_EMBEDDED;
10729 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10730 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10731 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10732 dgst_size = DGST_SIZE_4_8;
10733 parse_func = androidfde_samsung_parse_hash;
10734 sort_by_digest = sort_by_digest_4_8;
10735 opti_type = OPTI_TYPE_ZERO_BYTE;
10736 dgst_pos0 = 0;
10737 dgst_pos1 = 1;
10738 dgst_pos2 = 2;
10739 dgst_pos3 = 3;
10740 break;
10741
10742 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10743 salt_type = SALT_TYPE_EMBEDDED;
10744 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10745 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10746 kern_type = KERN_TYPE_RAR5;
10747 dgst_size = DGST_SIZE_4_4;
10748 parse_func = rar5_parse_hash;
10749 sort_by_digest = sort_by_digest_4_4;
10750 opti_type = OPTI_TYPE_ZERO_BYTE;
10751 dgst_pos0 = 0;
10752 dgst_pos1 = 1;
10753 dgst_pos2 = 2;
10754 dgst_pos3 = 3;
10755 break;
10756
10757 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10758 salt_type = SALT_TYPE_EMBEDDED;
10759 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10760 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10761 kern_type = KERN_TYPE_KRB5TGS;
10762 dgst_size = DGST_SIZE_4_4;
10763 parse_func = krb5tgs_parse_hash;
10764 sort_by_digest = sort_by_digest_4_4;
10765 opti_type = OPTI_TYPE_ZERO_BYTE
10766 | OPTI_TYPE_NOT_ITERATED;
10767 dgst_pos0 = 0;
10768 dgst_pos1 = 1;
10769 dgst_pos2 = 2;
10770 dgst_pos3 = 3;
10771 break;
10772
10773 case 13200: hash_type = HASH_TYPE_AES;
10774 salt_type = SALT_TYPE_EMBEDDED;
10775 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10776 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10777 kern_type = KERN_TYPE_AXCRYPT;
10778 dgst_size = DGST_SIZE_4_4;
10779 parse_func = axcrypt_parse_hash;
10780 sort_by_digest = sort_by_digest_4_4;
10781 opti_type = OPTI_TYPE_ZERO_BYTE;
10782 dgst_pos0 = 0;
10783 dgst_pos1 = 1;
10784 dgst_pos2 = 2;
10785 dgst_pos3 = 3;
10786 break;
10787
10788 case 13300: hash_type = HASH_TYPE_SHA1;
10789 salt_type = SALT_TYPE_NONE;
10790 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10791 opts_type = OPTS_TYPE_PT_GENERATE_BE
10792 | OPTS_TYPE_PT_ADD80
10793 | OPTS_TYPE_PT_ADDBITS15;
10794 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10795 dgst_size = DGST_SIZE_4_5;
10796 parse_func = sha1axcrypt_parse_hash;
10797 sort_by_digest = sort_by_digest_4_5;
10798 opti_type = OPTI_TYPE_ZERO_BYTE
10799 | OPTI_TYPE_PRECOMPUTE_INIT
10800 | OPTI_TYPE_EARLY_SKIP
10801 | OPTI_TYPE_NOT_ITERATED
10802 | OPTI_TYPE_NOT_SALTED;
10803 dgst_pos0 = 0;
10804 dgst_pos1 = 4;
10805 dgst_pos2 = 3;
10806 dgst_pos3 = 2;
10807 break;
10808
10809 case 13400: hash_type = HASH_TYPE_AES;
10810 salt_type = SALT_TYPE_EMBEDDED;
10811 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10812 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10813 kern_type = KERN_TYPE_KEEPASS;
10814 dgst_size = DGST_SIZE_4_4;
10815 parse_func = keepass_parse_hash;
10816 sort_by_digest = sort_by_digest_4_4;
10817 opti_type = OPTI_TYPE_ZERO_BYTE;
10818 dgst_pos0 = 0;
10819 dgst_pos1 = 1;
10820 dgst_pos2 = 2;
10821 dgst_pos3 = 3;
10822 break;
10823
10824 case 13500: hash_type = HASH_TYPE_SHA1;
10825 salt_type = SALT_TYPE_EMBEDDED;
10826 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10827 opts_type = OPTS_TYPE_PT_GENERATE_BE
10828 | OPTS_TYPE_PT_UNICODE
10829 | OPTS_TYPE_PT_ADD80;
10830 kern_type = KERN_TYPE_PSTOKEN;
10831 dgst_size = DGST_SIZE_4_5;
10832 parse_func = pstoken_parse_hash;
10833 sort_by_digest = sort_by_digest_4_5;
10834 opti_type = OPTI_TYPE_ZERO_BYTE
10835 | OPTI_TYPE_PRECOMPUTE_INIT
10836 | OPTI_TYPE_EARLY_SKIP
10837 | OPTI_TYPE_NOT_ITERATED
10838 | OPTI_TYPE_PREPENDED_SALT
10839 | OPTI_TYPE_RAW_HASH;
10840 dgst_pos0 = 3;
10841 dgst_pos1 = 4;
10842 dgst_pos2 = 2;
10843 dgst_pos3 = 1;
10844 break;
10845
10846 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10847 salt_type = SALT_TYPE_EMBEDDED;
10848 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10849 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10850 kern_type = KERN_TYPE_ZIP2;
10851 dgst_size = DGST_SIZE_4_4;
10852 parse_func = zip2_parse_hash;
10853 sort_by_digest = sort_by_digest_4_4;
10854 opti_type = OPTI_TYPE_ZERO_BYTE;
10855 dgst_pos0 = 0;
10856 dgst_pos1 = 1;
10857 dgst_pos2 = 2;
10858 dgst_pos3 = 3;
10859 break;
10860
10861 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10862 salt_type = SALT_TYPE_EMBEDDED;
10863 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10864 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10865 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10866 dgst_size = DGST_SIZE_4_5;
10867 parse_func = veracrypt_parse_hash_655331;
10868 sort_by_digest = sort_by_digest_4_5;
10869 opti_type = OPTI_TYPE_ZERO_BYTE;
10870 dgst_pos0 = 0;
10871 dgst_pos1 = 1;
10872 dgst_pos2 = 2;
10873 dgst_pos3 = 3;
10874 break;
10875
10876 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10877 salt_type = SALT_TYPE_EMBEDDED;
10878 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10879 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10880 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10881 dgst_size = DGST_SIZE_4_5;
10882 parse_func = veracrypt_parse_hash_655331;
10883 sort_by_digest = sort_by_digest_4_5;
10884 opti_type = OPTI_TYPE_ZERO_BYTE;
10885 dgst_pos0 = 0;
10886 dgst_pos1 = 1;
10887 dgst_pos2 = 2;
10888 dgst_pos3 = 3;
10889 break;
10890
10891 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10892 salt_type = SALT_TYPE_EMBEDDED;
10893 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10894 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10895 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10896 dgst_size = DGST_SIZE_4_5;
10897 parse_func = veracrypt_parse_hash_655331;
10898 sort_by_digest = sort_by_digest_4_5;
10899 opti_type = OPTI_TYPE_ZERO_BYTE;
10900 dgst_pos0 = 0;
10901 dgst_pos1 = 1;
10902 dgst_pos2 = 2;
10903 dgst_pos3 = 3;
10904 break;
10905
10906 case 13721: hash_type = HASH_TYPE_SHA512;
10907 salt_type = SALT_TYPE_EMBEDDED;
10908 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10909 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10910 kern_type = KERN_TYPE_TCSHA512_XTS512;
10911 dgst_size = DGST_SIZE_8_8;
10912 parse_func = veracrypt_parse_hash_500000;
10913 sort_by_digest = sort_by_digest_8_8;
10914 opti_type = OPTI_TYPE_ZERO_BYTE
10915 | OPTI_TYPE_USES_BITS_64;
10916 dgst_pos0 = 0;
10917 dgst_pos1 = 1;
10918 dgst_pos2 = 2;
10919 dgst_pos3 = 3;
10920 break;
10921
10922 case 13722: hash_type = HASH_TYPE_SHA512;
10923 salt_type = SALT_TYPE_EMBEDDED;
10924 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10925 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10926 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10927 dgst_size = DGST_SIZE_8_8;
10928 parse_func = veracrypt_parse_hash_500000;
10929 sort_by_digest = sort_by_digest_8_8;
10930 opti_type = OPTI_TYPE_ZERO_BYTE
10931 | OPTI_TYPE_USES_BITS_64;
10932 dgst_pos0 = 0;
10933 dgst_pos1 = 1;
10934 dgst_pos2 = 2;
10935 dgst_pos3 = 3;
10936 break;
10937
10938 case 13723: hash_type = HASH_TYPE_SHA512;
10939 salt_type = SALT_TYPE_EMBEDDED;
10940 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10941 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10942 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10943 dgst_size = DGST_SIZE_8_8;
10944 parse_func = veracrypt_parse_hash_500000;
10945 sort_by_digest = sort_by_digest_8_8;
10946 opti_type = OPTI_TYPE_ZERO_BYTE
10947 | OPTI_TYPE_USES_BITS_64;
10948 dgst_pos0 = 0;
10949 dgst_pos1 = 1;
10950 dgst_pos2 = 2;
10951 dgst_pos3 = 3;
10952 break;
10953
10954 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10955 salt_type = SALT_TYPE_EMBEDDED;
10956 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10957 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10958 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10959 dgst_size = DGST_SIZE_4_8;
10960 parse_func = veracrypt_parse_hash_500000;
10961 sort_by_digest = sort_by_digest_4_8;
10962 opti_type = OPTI_TYPE_ZERO_BYTE;
10963 dgst_pos0 = 0;
10964 dgst_pos1 = 1;
10965 dgst_pos2 = 2;
10966 dgst_pos3 = 3;
10967 break;
10968
10969 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10970 salt_type = SALT_TYPE_EMBEDDED;
10971 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10972 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10973 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10974 dgst_size = DGST_SIZE_4_8;
10975 parse_func = veracrypt_parse_hash_500000;
10976 sort_by_digest = sort_by_digest_4_8;
10977 opti_type = OPTI_TYPE_ZERO_BYTE;
10978 dgst_pos0 = 0;
10979 dgst_pos1 = 1;
10980 dgst_pos2 = 2;
10981 dgst_pos3 = 3;
10982 break;
10983
10984 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10985 salt_type = SALT_TYPE_EMBEDDED;
10986 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10987 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10988 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10989 dgst_size = DGST_SIZE_4_8;
10990 parse_func = veracrypt_parse_hash_500000;
10991 sort_by_digest = sort_by_digest_4_8;
10992 opti_type = OPTI_TYPE_ZERO_BYTE;
10993 dgst_pos0 = 0;
10994 dgst_pos1 = 1;
10995 dgst_pos2 = 2;
10996 dgst_pos3 = 3;
10997 break;
10998
10999 case 13741: hash_type = HASH_TYPE_RIPEMD160;
11000 salt_type = SALT_TYPE_EMBEDDED;
11001 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11002 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11003 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
11004 dgst_size = DGST_SIZE_4_5;
11005 parse_func = veracrypt_parse_hash_327661;
11006 sort_by_digest = sort_by_digest_4_5;
11007 opti_type = OPTI_TYPE_ZERO_BYTE;
11008 dgst_pos0 = 0;
11009 dgst_pos1 = 1;
11010 dgst_pos2 = 2;
11011 dgst_pos3 = 3;
11012 break;
11013
11014 case 13742: hash_type = HASH_TYPE_RIPEMD160;
11015 salt_type = SALT_TYPE_EMBEDDED;
11016 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11017 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11018 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
11019 dgst_size = DGST_SIZE_4_5;
11020 parse_func = veracrypt_parse_hash_327661;
11021 sort_by_digest = sort_by_digest_4_5;
11022 opti_type = OPTI_TYPE_ZERO_BYTE;
11023 dgst_pos0 = 0;
11024 dgst_pos1 = 1;
11025 dgst_pos2 = 2;
11026 dgst_pos3 = 3;
11027 break;
11028
11029 case 13743: hash_type = HASH_TYPE_RIPEMD160;
11030 salt_type = SALT_TYPE_EMBEDDED;
11031 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11032 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11033 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11034 dgst_size = DGST_SIZE_4_5;
11035 parse_func = veracrypt_parse_hash_327661;
11036 sort_by_digest = sort_by_digest_4_5;
11037 opti_type = OPTI_TYPE_ZERO_BYTE;
11038 dgst_pos0 = 0;
11039 dgst_pos1 = 1;
11040 dgst_pos2 = 2;
11041 dgst_pos3 = 3;
11042 break;
11043
11044 case 13751: hash_type = HASH_TYPE_SHA256;
11045 salt_type = SALT_TYPE_EMBEDDED;
11046 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11047 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11048 kern_type = KERN_TYPE_VCSHA256_XTS512;
11049 dgst_size = DGST_SIZE_4_8;
11050 parse_func = veracrypt_parse_hash_500000;
11051 sort_by_digest = sort_by_digest_4_8;
11052 opti_type = OPTI_TYPE_ZERO_BYTE;
11053 dgst_pos0 = 0;
11054 dgst_pos1 = 1;
11055 dgst_pos2 = 2;
11056 dgst_pos3 = 3;
11057 break;
11058
11059 case 13752: hash_type = HASH_TYPE_SHA256;
11060 salt_type = SALT_TYPE_EMBEDDED;
11061 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11062 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11063 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11064 dgst_size = DGST_SIZE_4_8;
11065 parse_func = veracrypt_parse_hash_500000;
11066 sort_by_digest = sort_by_digest_4_8;
11067 opti_type = OPTI_TYPE_ZERO_BYTE;
11068 dgst_pos0 = 0;
11069 dgst_pos1 = 1;
11070 dgst_pos2 = 2;
11071 dgst_pos3 = 3;
11072 break;
11073
11074 case 13753: hash_type = HASH_TYPE_SHA256;
11075 salt_type = SALT_TYPE_EMBEDDED;
11076 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11077 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11078 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11079 dgst_size = DGST_SIZE_4_8;
11080 parse_func = veracrypt_parse_hash_500000;
11081 sort_by_digest = sort_by_digest_4_8;
11082 opti_type = OPTI_TYPE_ZERO_BYTE;
11083 dgst_pos0 = 0;
11084 dgst_pos1 = 1;
11085 dgst_pos2 = 2;
11086 dgst_pos3 = 3;
11087 break;
11088
11089 case 13761: hash_type = HASH_TYPE_SHA256;
11090 salt_type = SALT_TYPE_EMBEDDED;
11091 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11092 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11093 kern_type = KERN_TYPE_VCSHA256_XTS512;
11094 dgst_size = DGST_SIZE_4_8;
11095 parse_func = veracrypt_parse_hash_200000;
11096 sort_by_digest = sort_by_digest_4_8;
11097 opti_type = OPTI_TYPE_ZERO_BYTE;
11098 dgst_pos0 = 0;
11099 dgst_pos1 = 1;
11100 dgst_pos2 = 2;
11101 dgst_pos3 = 3;
11102 break;
11103
11104 case 13762: hash_type = HASH_TYPE_SHA256;
11105 salt_type = SALT_TYPE_EMBEDDED;
11106 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11107 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11108 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11109 dgst_size = DGST_SIZE_4_8;
11110 parse_func = veracrypt_parse_hash_200000;
11111 sort_by_digest = sort_by_digest_4_8;
11112 opti_type = OPTI_TYPE_ZERO_BYTE;
11113 dgst_pos0 = 0;
11114 dgst_pos1 = 1;
11115 dgst_pos2 = 2;
11116 dgst_pos3 = 3;
11117 break;
11118
11119 case 13763: hash_type = HASH_TYPE_SHA256;
11120 salt_type = SALT_TYPE_EMBEDDED;
11121 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11122 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11123 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11124 dgst_size = DGST_SIZE_4_8;
11125 parse_func = veracrypt_parse_hash_200000;
11126 sort_by_digest = sort_by_digest_4_8;
11127 opti_type = OPTI_TYPE_ZERO_BYTE;
11128 dgst_pos0 = 0;
11129 dgst_pos1 = 1;
11130 dgst_pos2 = 2;
11131 dgst_pos3 = 3;
11132 break;
11133
11134 case 13800: hash_type = HASH_TYPE_SHA256;
11135 salt_type = SALT_TYPE_EMBEDDED;
11136 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11137 opts_type = OPTS_TYPE_PT_GENERATE_BE
11138 | OPTS_TYPE_PT_UNICODE;
11139 kern_type = KERN_TYPE_WIN8PHONE;
11140 dgst_size = DGST_SIZE_4_8;
11141 parse_func = win8phone_parse_hash;
11142 sort_by_digest = sort_by_digest_4_8;
11143 opti_type = OPTI_TYPE_ZERO_BYTE
11144 | OPTI_TYPE_PRECOMPUTE_INIT
11145 | OPTI_TYPE_EARLY_SKIP
11146 | OPTI_TYPE_NOT_ITERATED
11147 | OPTI_TYPE_RAW_HASH;
11148 dgst_pos0 = 3;
11149 dgst_pos1 = 7;
11150 dgst_pos2 = 2;
11151 dgst_pos3 = 6;
11152 break;
11153
11154 default: usage_mini_print (PROGNAME); return (-1);
11155 }
11156
11157 /**
11158 * parser
11159 */
11160
11161 data.parse_func = parse_func;
11162
11163 /**
11164 * misc stuff
11165 */
11166
11167 if (hex_salt)
11168 {
11169 if (salt_type == SALT_TYPE_INTERN)
11170 {
11171 opts_type |= OPTS_TYPE_ST_HEX;
11172 }
11173 else
11174 {
11175 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11176
11177 return (-1);
11178 }
11179 }
11180
11181 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11182 | (salt_type == SALT_TYPE_EXTERN)
11183 | (salt_type == SALT_TYPE_EMBEDDED)
11184 | (salt_type == SALT_TYPE_VIRTUAL));
11185
11186 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
11187
11188 data.hash_type = hash_type;
11189 data.attack_mode = attack_mode;
11190 data.attack_kern = attack_kern;
11191 data.attack_exec = attack_exec;
11192 data.kern_type = kern_type;
11193 data.opts_type = opts_type;
11194 data.dgst_size = dgst_size;
11195 data.salt_type = salt_type;
11196 data.isSalted = isSalted;
11197 data.sort_by_digest = sort_by_digest;
11198 data.dgst_pos0 = dgst_pos0;
11199 data.dgst_pos1 = dgst_pos1;
11200 data.dgst_pos2 = dgst_pos2;
11201 data.dgst_pos3 = dgst_pos3;
11202
11203 esalt_size = 0;
11204
11205 switch (hash_mode)
11206 {
11207 case 2500: esalt_size = sizeof (wpa_t); break;
11208 case 5300: esalt_size = sizeof (ikepsk_t); break;
11209 case 5400: esalt_size = sizeof (ikepsk_t); break;
11210 case 5500: esalt_size = sizeof (netntlm_t); break;
11211 case 5600: esalt_size = sizeof (netntlm_t); break;
11212 case 6211: esalt_size = sizeof (tc_t); break;
11213 case 6212: esalt_size = sizeof (tc_t); break;
11214 case 6213: esalt_size = sizeof (tc_t); break;
11215 case 6221: esalt_size = sizeof (tc_t); break;
11216 case 6222: esalt_size = sizeof (tc_t); break;
11217 case 6223: esalt_size = sizeof (tc_t); break;
11218 case 6231: esalt_size = sizeof (tc_t); break;
11219 case 6232: esalt_size = sizeof (tc_t); break;
11220 case 6233: esalt_size = sizeof (tc_t); break;
11221 case 6241: esalt_size = sizeof (tc_t); break;
11222 case 6242: esalt_size = sizeof (tc_t); break;
11223 case 6243: esalt_size = sizeof (tc_t); break;
11224 case 6600: esalt_size = sizeof (agilekey_t); break;
11225 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11226 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
11227 case 7300: esalt_size = sizeof (rakp_t); break;
11228 case 7500: esalt_size = sizeof (krb5pa_t); break;
11229 case 8200: esalt_size = sizeof (cloudkey_t); break;
11230 case 8800: esalt_size = sizeof (androidfde_t); break;
11231 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
11232 case 9400: esalt_size = sizeof (office2007_t); break;
11233 case 9500: esalt_size = sizeof (office2010_t); break;
11234 case 9600: esalt_size = sizeof (office2013_t); break;
11235 case 9700: esalt_size = sizeof (oldoffice01_t); break;
11236 case 9710: esalt_size = sizeof (oldoffice01_t); break;
11237 case 9720: esalt_size = sizeof (oldoffice01_t); break;
11238 case 9800: esalt_size = sizeof (oldoffice34_t); break;
11239 case 9810: esalt_size = sizeof (oldoffice34_t); break;
11240 case 9820: esalt_size = sizeof (oldoffice34_t); break;
11241 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
11242 case 10200: esalt_size = sizeof (cram_md5_t); break;
11243 case 10400: esalt_size = sizeof (pdf_t); break;
11244 case 10410: esalt_size = sizeof (pdf_t); break;
11245 case 10420: esalt_size = sizeof (pdf_t); break;
11246 case 10500: esalt_size = sizeof (pdf_t); break;
11247 case 10600: esalt_size = sizeof (pdf_t); break;
11248 case 10700: esalt_size = sizeof (pdf_t); break;
11249 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
11250 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
11251 case 11400: esalt_size = sizeof (sip_t); break;
11252 case 11600: esalt_size = sizeof (seven_zip_t); break;
11253 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
11254 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
11255 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11256 case 13000: esalt_size = sizeof (rar5_t); break;
11257 case 13100: esalt_size = sizeof (krb5tgs_t); break;
11258 case 13400: esalt_size = sizeof (keepass_t); break;
11259 case 13500: esalt_size = sizeof (pstoken_t); break;
11260 case 13600: esalt_size = sizeof (zip2_t); break;
11261 case 13711: esalt_size = sizeof (tc_t); break;
11262 case 13712: esalt_size = sizeof (tc_t); break;
11263 case 13713: esalt_size = sizeof (tc_t); break;
11264 case 13721: esalt_size = sizeof (tc_t); break;
11265 case 13722: esalt_size = sizeof (tc_t); break;
11266 case 13723: esalt_size = sizeof (tc_t); break;
11267 case 13731: esalt_size = sizeof (tc_t); break;
11268 case 13732: esalt_size = sizeof (tc_t); break;
11269 case 13733: esalt_size = sizeof (tc_t); break;
11270 case 13741: esalt_size = sizeof (tc_t); break;
11271 case 13742: esalt_size = sizeof (tc_t); break;
11272 case 13743: esalt_size = sizeof (tc_t); break;
11273 case 13751: esalt_size = sizeof (tc_t); break;
11274 case 13752: esalt_size = sizeof (tc_t); break;
11275 case 13753: esalt_size = sizeof (tc_t); break;
11276 case 13761: esalt_size = sizeof (tc_t); break;
11277 case 13762: esalt_size = sizeof (tc_t); break;
11278 case 13763: esalt_size = sizeof (tc_t); break;
11279 case 13800: esalt_size = sizeof (win8phone_t); break;
11280 }
11281
11282 data.esalt_size = esalt_size;
11283
11284 /**
11285 * choose dictionary parser
11286 */
11287
11288 if (hash_type == HASH_TYPE_LM)
11289 {
11290 get_next_word_func = get_next_word_lm;
11291 }
11292 else if (opts_type & OPTS_TYPE_PT_UPPER)
11293 {
11294 get_next_word_func = get_next_word_uc;
11295 }
11296 else
11297 {
11298 get_next_word_func = get_next_word_std;
11299 }
11300
11301 /**
11302 * dictstat
11303 */
11304
11305 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11306
11307 #ifdef _POSIX
11308 size_t dictstat_nmemb = 0;
11309 #endif
11310
11311 #ifdef _WIN
11312 uint dictstat_nmemb = 0;
11313 #endif
11314
11315 char dictstat[256] = { 0 };
11316
11317 FILE *dictstat_fp = NULL;
11318
11319 if (keyspace == 0)
11320 {
11321 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11322
11323 dictstat_fp = fopen (dictstat, "rb");
11324
11325 if (dictstat_fp)
11326 {
11327 #ifdef _POSIX
11328 struct stat tmpstat;
11329
11330 fstat (fileno (dictstat_fp), &tmpstat);
11331 #endif
11332
11333 #ifdef _WIN
11334 struct stat64 tmpstat;
11335
11336 _fstat64 (fileno (dictstat_fp), &tmpstat);
11337 #endif
11338
11339 if (tmpstat.st_mtime < COMPTIME)
11340 {
11341 /* with v0.15 the format changed so we have to ensure user is using a good version
11342 since there is no version-header in the dictstat file */
11343
11344 fclose (dictstat_fp);
11345
11346 unlink (dictstat);
11347 }
11348 else
11349 {
11350 while (!feof (dictstat_fp))
11351 {
11352 dictstat_t d;
11353
11354 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11355
11356 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11357
11358 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11359 {
11360 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11361
11362 return -1;
11363 }
11364 }
11365
11366 fclose (dictstat_fp);
11367 }
11368 }
11369 }
11370
11371 /**
11372 * potfile
11373 */
11374
11375 char potfile[256] = { 0 };
11376
11377 if (potfile_path == NULL)
11378 {
11379 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11380 }
11381 else
11382 {
11383 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11384 }
11385
11386 data.pot_fp = NULL;
11387
11388 FILE *out_fp = NULL;
11389 FILE *pot_fp = NULL;
11390
11391 if (show == 1 || left == 1)
11392 {
11393 pot_fp = fopen (potfile, "rb");
11394
11395 if (pot_fp == NULL)
11396 {
11397 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11398
11399 return (-1);
11400 }
11401
11402 if (outfile != NULL)
11403 {
11404 if ((out_fp = fopen (outfile, "ab")) == NULL)
11405 {
11406 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11407
11408 fclose (pot_fp);
11409
11410 return (-1);
11411 }
11412 }
11413 else
11414 {
11415 out_fp = stdout;
11416 }
11417 }
11418 else
11419 {
11420 if (potfile_disable == 0)
11421 {
11422 pot_fp = fopen (potfile, "ab");
11423
11424 if (pot_fp == NULL)
11425 {
11426 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11427
11428 return (-1);
11429 }
11430
11431 data.pot_fp = pot_fp;
11432 }
11433 }
11434
11435 pot_t *pot = NULL;
11436
11437 uint pot_cnt = 0;
11438 uint pot_avail = 0;
11439
11440 if (show == 1 || left == 1)
11441 {
11442 SUPPRESS_OUTPUT = 1;
11443
11444 pot_avail = count_lines (pot_fp);
11445
11446 rewind (pot_fp);
11447
11448 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11449
11450 uint pot_hashes_avail = 0;
11451
11452 uint line_num = 0;
11453
11454 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11455
11456 while (!feof (pot_fp))
11457 {
11458 line_num++;
11459
11460 int line_len = fgetl (pot_fp, line_buf);
11461
11462 if (line_len == 0) continue;
11463
11464 char *plain_buf = line_buf + line_len;
11465
11466 pot_t *pot_ptr = &pot[pot_cnt];
11467
11468 hash_t *hashes_buf = &pot_ptr->hash;
11469
11470 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11471 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11472
11473 if (pot_cnt == pot_hashes_avail)
11474 {
11475 uint pos = 0;
11476
11477 for (pos = 0; pos < INCR_POT; pos++)
11478 {
11479 if ((pot_cnt + pos) >= pot_avail) break;
11480
11481 pot_t *tmp_pot = &pot[pot_cnt + pos];
11482
11483 hash_t *tmp_hash = &tmp_pot->hash;
11484
11485 tmp_hash->digest = mymalloc (dgst_size);
11486
11487 if (isSalted)
11488 {
11489 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11490 }
11491
11492 if (esalt_size)
11493 {
11494 tmp_hash->esalt = mymalloc (esalt_size);
11495 }
11496
11497 pot_hashes_avail++;
11498 }
11499 }
11500
11501 int plain_len = 0;
11502
11503 int parser_status;
11504
11505 int iter = MAX_CUT_TRIES;
11506
11507 do
11508 {
11509 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11510 {
11511 if (line_buf[i] == ':')
11512 {
11513 line_len--;
11514
11515 break;
11516 }
11517 }
11518
11519 if (data.hash_mode != 2500)
11520 {
11521 parser_status = parse_func (line_buf, line_len, hashes_buf);
11522 }
11523 else
11524 {
11525 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11526
11527 if (line_len > max_salt_size)
11528 {
11529 parser_status = PARSER_GLOBAL_LENGTH;
11530 }
11531 else
11532 {
11533 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11534
11535 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11536
11537 hashes_buf->salt->salt_len = line_len;
11538
11539 parser_status = PARSER_OK;
11540 }
11541 }
11542
11543 // if NOT parsed without error, we add the ":" to the plain
11544
11545 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11546 {
11547 plain_len++;
11548 plain_buf--;
11549 }
11550
11551 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11552
11553 if (parser_status < PARSER_GLOBAL_ZERO)
11554 {
11555 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11556
11557 continue;
11558 }
11559
11560 if (plain_len >= 255) continue;
11561
11562 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11563
11564 pot_ptr->plain_len = plain_len;
11565
11566 pot_cnt++;
11567 }
11568
11569 myfree (line_buf);
11570
11571 fclose (pot_fp);
11572
11573 SUPPRESS_OUTPUT = 0;
11574
11575 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11576 }
11577
11578 /**
11579 * word len
11580 */
11581
11582 uint pw_min = PW_MIN;
11583 uint pw_max = PW_MAX;
11584
11585 switch (hash_mode)
11586 {
11587 case 125: if (pw_max > 32) pw_max = 32;
11588 break;
11589 case 400: if (pw_max > 40) pw_max = 40;
11590 break;
11591 case 500: if (pw_max > 16) pw_max = 16;
11592 break;
11593 case 1500: if (pw_max > 8) pw_max = 8;
11594 break;
11595 case 1600: if (pw_max > 16) pw_max = 16;
11596 break;
11597 case 1800: if (pw_max > 16) pw_max = 16;
11598 break;
11599 case 2100: if (pw_max > 16) pw_max = 16;
11600 break;
11601 case 2500: if (pw_min < 8) pw_min = 8;
11602 break;
11603 case 3000: if (pw_max > 7) pw_max = 7;
11604 break;
11605 case 5200: if (pw_max > 24) pw_max = 24;
11606 break;
11607 case 5800: if (pw_max > 16) pw_max = 16;
11608 break;
11609 case 6300: if (pw_max > 16) pw_max = 16;
11610 break;
11611 case 7400: if (pw_max > 16) pw_max = 16;
11612 break;
11613 case 7700: if (pw_max > 8) pw_max = 8;
11614 break;
11615 case 7900: if (pw_max > 48) pw_max = 48;
11616 break;
11617 case 8500: if (pw_max > 8) pw_max = 8;
11618 break;
11619 case 8600: if (pw_max > 16) pw_max = 16;
11620 break;
11621 case 9710: pw_min = 5;
11622 pw_max = 5;
11623 break;
11624 case 9810: pw_min = 5;
11625 pw_max = 5;
11626 break;
11627 case 10410: pw_min = 5;
11628 pw_max = 5;
11629 break;
11630 case 10300: if (pw_max < 3) pw_min = 3;
11631 if (pw_max > 40) pw_max = 40;
11632 break;
11633 case 10500: if (pw_max < 3) pw_min = 3;
11634 if (pw_max > 40) pw_max = 40;
11635 break;
11636 case 10700: if (pw_max > 16) pw_max = 16;
11637 break;
11638 case 11300: if (pw_max > 40) pw_max = 40;
11639 break;
11640 case 11600: if (pw_max > 32) pw_max = 32;
11641 break;
11642 case 12500: if (pw_max > 20) pw_max = 20;
11643 break;
11644 case 12800: if (pw_max > 24) pw_max = 24;
11645 break;
11646 }
11647
11648 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11649 {
11650 switch (attack_kern)
11651 {
11652 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11653 break;
11654 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11655 break;
11656 }
11657 }
11658
11659 /**
11660 * charsets : keep them together for more easy maintainnce
11661 */
11662
11663 cs_t mp_sys[6] = { { { 0 }, 0 } };
11664 cs_t mp_usr[4] = { { { 0 }, 0 } };
11665
11666 mp_setup_sys (mp_sys);
11667
11668 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11669 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11670 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11671 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11672
11673 /**
11674 * load hashes, part I: find input mode, count hashes
11675 */
11676
11677 uint hashlist_mode = 0;
11678 uint hashlist_format = HLFMT_HASHCAT;
11679
11680 uint hashes_avail = 0;
11681
11682 if ((benchmark == 0) && (stdout_flag == 0))
11683 {
11684 struct stat f;
11685
11686 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11687
11688 if ((hash_mode == 2500) ||
11689 (hash_mode == 5200) ||
11690 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11691 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11692 (hash_mode == 9000))
11693 {
11694 hashlist_mode = HL_MODE_ARG;
11695
11696 char *hashfile = myargv[optind];
11697
11698 data.hashfile = hashfile;
11699
11700 logfile_top_var_string ("target", hashfile);
11701 }
11702
11703 if (hashlist_mode == HL_MODE_ARG)
11704 {
11705 if (hash_mode == 2500)
11706 {
11707 struct stat st;
11708
11709 if (stat (data.hashfile, &st) == -1)
11710 {
11711 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11712
11713 return (-1);
11714 }
11715
11716 hashes_avail = st.st_size / sizeof (hccap_t);
11717 }
11718 else
11719 {
11720 hashes_avail = 1;
11721 }
11722 }
11723 else if (hashlist_mode == HL_MODE_FILE)
11724 {
11725 char *hashfile = myargv[optind];
11726
11727 data.hashfile = hashfile;
11728
11729 logfile_top_var_string ("target", hashfile);
11730
11731 FILE *fp = NULL;
11732
11733 if ((fp = fopen (hashfile, "rb")) == NULL)
11734 {
11735 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11736
11737 return (-1);
11738 }
11739
11740 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11741
11742 hashes_avail = count_lines (fp);
11743
11744 rewind (fp);
11745
11746 if (hashes_avail == 0)
11747 {
11748 log_error ("ERROR: hashfile is empty or corrupt");
11749
11750 fclose (fp);
11751
11752 return (-1);
11753 }
11754
11755 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11756
11757 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11758 {
11759 log_error ("ERROR: remove not supported in native hashfile-format mode");
11760
11761 fclose (fp);
11762
11763 return (-1);
11764 }
11765
11766 fclose (fp);
11767 }
11768 }
11769 else
11770 {
11771 hashlist_mode = HL_MODE_ARG;
11772
11773 hashes_avail = 1;
11774 }
11775
11776 if (hash_mode == 3000) hashes_avail *= 2;
11777
11778 data.hashlist_mode = hashlist_mode;
11779 data.hashlist_format = hashlist_format;
11780
11781 logfile_top_uint (hashlist_mode);
11782 logfile_top_uint (hashlist_format);
11783
11784 /**
11785 * load hashes, part II: allocate required memory, set pointers
11786 */
11787
11788 hash_t *hashes_buf = NULL;
11789 void *digests_buf = NULL;
11790 salt_t *salts_buf = NULL;
11791 void *esalts_buf = NULL;
11792
11793 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11794
11795 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11796
11797 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11798 {
11799 u32 hash_pos;
11800
11801 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11802 {
11803 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11804
11805 hashes_buf[hash_pos].hash_info = hash_info;
11806
11807 if (username && (remove || show || left))
11808 {
11809 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11810 }
11811
11812 if (benchmark)
11813 {
11814 hash_info->orighash = (char *) mymalloc (256);
11815 }
11816 }
11817 }
11818
11819 if (isSalted)
11820 {
11821 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11822
11823 if (esalt_size)
11824 {
11825 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11826 }
11827 }
11828 else
11829 {
11830 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11831 }
11832
11833 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11834 {
11835 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11836
11837 if (isSalted)
11838 {
11839 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11840
11841 if (esalt_size)
11842 {
11843 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11844 }
11845 }
11846 else
11847 {
11848 hashes_buf[hash_pos].salt = &salts_buf[0];
11849 }
11850 }
11851
11852 /**
11853 * load hashes, part III: parse hashes or generate them if benchmark
11854 */
11855
11856 uint hashes_cnt = 0;
11857
11858 if (benchmark == 0)
11859 {
11860 if (keyspace == 1)
11861 {
11862 // useless to read hash file for keyspace, cheat a little bit w/ optind
11863 }
11864 else if (stdout_flag == 1)
11865 {
11866 // useless to read hash file for stdout, cheat a little bit w/ optind
11867 }
11868 else if (hashes_avail == 0)
11869 {
11870 }
11871 else if (hashlist_mode == HL_MODE_ARG)
11872 {
11873 char *input_buf = myargv[optind];
11874
11875 uint input_len = strlen (input_buf);
11876
11877 logfile_top_var_string ("target", input_buf);
11878
11879 char *hash_buf = NULL;
11880 int hash_len = 0;
11881
11882 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11883
11884 bool hash_fmt_error = 0;
11885
11886 if (hash_len < 1) hash_fmt_error = 1;
11887 if (hash_buf == NULL) hash_fmt_error = 1;
11888
11889 if (hash_fmt_error)
11890 {
11891 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11892 }
11893 else
11894 {
11895 if (opts_type & OPTS_TYPE_HASH_COPY)
11896 {
11897 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11898
11899 hash_info_tmp->orighash = mystrdup (hash_buf);
11900 }
11901
11902 if (isSalted)
11903 {
11904 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11905 }
11906
11907 int parser_status = PARSER_OK;
11908
11909 if (hash_mode == 2500)
11910 {
11911 if (hash_len == 0)
11912 {
11913 log_error ("ERROR: hccap file not specified");
11914
11915 return (-1);
11916 }
11917
11918 hashlist_mode = HL_MODE_FILE;
11919
11920 data.hashlist_mode = hashlist_mode;
11921
11922 FILE *fp = fopen (hash_buf, "rb");
11923
11924 if (fp == NULL)
11925 {
11926 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11927
11928 return (-1);
11929 }
11930
11931 if (hashes_avail < 1)
11932 {
11933 log_error ("ERROR: hccap file is empty or corrupt");
11934
11935 fclose (fp);
11936
11937 return (-1);
11938 }
11939
11940 uint hccap_size = sizeof (hccap_t);
11941
11942 char *in = (char *) mymalloc (hccap_size);
11943
11944 while (!feof (fp))
11945 {
11946 int n = fread (in, hccap_size, 1, fp);
11947
11948 if (n != 1)
11949 {
11950 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11951
11952 break;
11953 }
11954
11955 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11956
11957 if (parser_status != PARSER_OK)
11958 {
11959 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11960
11961 continue;
11962 }
11963
11964 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11965
11966 if ((show == 1) || (left == 1))
11967 {
11968 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11969
11970 char *salt_ptr = (char *) tmp_salt->salt_buf;
11971
11972 int cur_pos = tmp_salt->salt_len;
11973 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11974
11975 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11976
11977 // do the appending task
11978
11979 snprintf (salt_ptr + cur_pos,
11980 rem_len,
11981 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11982 wpa->orig_mac1[0],
11983 wpa->orig_mac1[1],
11984 wpa->orig_mac1[2],
11985 wpa->orig_mac1[3],
11986 wpa->orig_mac1[4],
11987 wpa->orig_mac1[5],
11988 wpa->orig_mac2[0],
11989 wpa->orig_mac2[1],
11990 wpa->orig_mac2[2],
11991 wpa->orig_mac2[3],
11992 wpa->orig_mac2[4],
11993 wpa->orig_mac2[5]);
11994
11995 // memset () the remaining part of the salt
11996
11997 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11998 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11999
12000 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
12001
12002 tmp_salt->salt_len += 1 + 12 + 1 + 12;
12003 }
12004
12005 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);
12006 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);
12007
12008 hashes_cnt++;
12009 }
12010
12011 fclose (fp);
12012
12013 myfree (in);
12014 }
12015 else if (hash_mode == 3000)
12016 {
12017 if (hash_len == 32)
12018 {
12019 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12020
12021 hash_t *lm_hash_left = NULL;
12022
12023 if (parser_status == PARSER_OK)
12024 {
12025 lm_hash_left = &hashes_buf[hashes_cnt];
12026
12027 hashes_cnt++;
12028 }
12029 else
12030 {
12031 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12032 }
12033
12034 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12035
12036 hash_t *lm_hash_right = NULL;
12037
12038 if (parser_status == PARSER_OK)
12039 {
12040 lm_hash_right = &hashes_buf[hashes_cnt];
12041
12042 hashes_cnt++;
12043 }
12044 else
12045 {
12046 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12047 }
12048
12049 // show / left
12050
12051 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12052 {
12053 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);
12054 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);
12055 }
12056 }
12057 else
12058 {
12059 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12060
12061 if (parser_status == PARSER_OK)
12062 {
12063 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12064 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12065 }
12066
12067 if (parser_status == PARSER_OK)
12068 {
12069 hashes_cnt++;
12070 }
12071 else
12072 {
12073 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12074 }
12075 }
12076 }
12077 else
12078 {
12079 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12080
12081 if (parser_status == PARSER_OK)
12082 {
12083 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12084 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12085 }
12086
12087 if (parser_status == PARSER_OK)
12088 {
12089 hashes_cnt++;
12090 }
12091 else
12092 {
12093 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12094 }
12095 }
12096 }
12097 }
12098 else if (hashlist_mode == HL_MODE_FILE)
12099 {
12100 char *hashfile = data.hashfile;
12101
12102 FILE *fp;
12103
12104 if ((fp = fopen (hashfile, "rb")) == NULL)
12105 {
12106 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12107
12108 return (-1);
12109 }
12110
12111 uint line_num = 0;
12112
12113 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12114
12115 while (!feof (fp))
12116 {
12117 line_num++;
12118
12119 int line_len = fgetl (fp, line_buf);
12120
12121 if (line_len == 0) continue;
12122
12123 char *hash_buf = NULL;
12124 int hash_len = 0;
12125
12126 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12127
12128 bool hash_fmt_error = 0;
12129
12130 if (hash_len < 1) hash_fmt_error = 1;
12131 if (hash_buf == NULL) hash_fmt_error = 1;
12132
12133 if (hash_fmt_error)
12134 {
12135 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12136
12137 continue;
12138 }
12139
12140 if (username)
12141 {
12142 char *user_buf = NULL;
12143 int user_len = 0;
12144
12145 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12146
12147 if (remove || show)
12148 {
12149 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12150
12151 *user = (user_t *) mymalloc (sizeof (user_t));
12152
12153 user_t *user_ptr = *user;
12154
12155 if (user_buf != NULL)
12156 {
12157 user_ptr->user_name = mystrdup (user_buf);
12158 }
12159 else
12160 {
12161 user_ptr->user_name = mystrdup ("");
12162 }
12163
12164 user_ptr->user_len = user_len;
12165 }
12166 }
12167
12168 if (opts_type & OPTS_TYPE_HASH_COPY)
12169 {
12170 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12171
12172 hash_info_tmp->orighash = mystrdup (hash_buf);
12173 }
12174
12175 if (isSalted)
12176 {
12177 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12178 }
12179
12180 if (hash_mode == 3000)
12181 {
12182 if (hash_len == 32)
12183 {
12184 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12185
12186 if (parser_status < PARSER_GLOBAL_ZERO)
12187 {
12188 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12189
12190 continue;
12191 }
12192
12193 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12194
12195 hashes_cnt++;
12196
12197 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12198
12199 if (parser_status < PARSER_GLOBAL_ZERO)
12200 {
12201 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12202
12203 continue;
12204 }
12205
12206 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12207
12208 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
12209
12210 hashes_cnt++;
12211
12212 // show / left
12213
12214 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);
12215 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);
12216 }
12217 else
12218 {
12219 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12220
12221 if (parser_status < PARSER_GLOBAL_ZERO)
12222 {
12223 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12224
12225 continue;
12226 }
12227
12228 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);
12229
12230 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12231 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12232
12233 hashes_cnt++;
12234 }
12235 }
12236 else
12237 {
12238 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12239
12240 if (parser_status < PARSER_GLOBAL_ZERO)
12241 {
12242 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12243
12244 continue;
12245 }
12246
12247 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);
12248
12249 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12250 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12251
12252 hashes_cnt++;
12253 }
12254 }
12255
12256 myfree (line_buf);
12257
12258 fclose (fp);
12259
12260 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12261
12262 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12263 }
12264 }
12265 else
12266 {
12267 if (isSalted)
12268 {
12269 hashes_buf[0].salt->salt_len = 8;
12270
12271 // special salt handling
12272
12273 switch (hash_mode)
12274 {
12275 case 1500: hashes_buf[0].salt->salt_len = 2;
12276 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12277 break;
12278 case 1731: hashes_buf[0].salt->salt_len = 4;
12279 break;
12280 case 2410: hashes_buf[0].salt->salt_len = 4;
12281 break;
12282 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12283 break;
12284 case 3100: hashes_buf[0].salt->salt_len = 1;
12285 break;
12286 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
12287 break;
12288 case 5800: hashes_buf[0].salt->salt_len = 16;
12289 break;
12290 case 6800: hashes_buf[0].salt->salt_len = 32;
12291 break;
12292 case 8400: hashes_buf[0].salt->salt_len = 40;
12293 break;
12294 case 8800: hashes_buf[0].salt->salt_len = 16;
12295 break;
12296 case 8900: hashes_buf[0].salt->salt_len = 16;
12297 hashes_buf[0].salt->scrypt_N = 1024;
12298 hashes_buf[0].salt->scrypt_r = 1;
12299 hashes_buf[0].salt->scrypt_p = 1;
12300 break;
12301 case 9100: hashes_buf[0].salt->salt_len = 16;
12302 break;
12303 case 9300: hashes_buf[0].salt->salt_len = 14;
12304 hashes_buf[0].salt->scrypt_N = 16384;
12305 hashes_buf[0].salt->scrypt_r = 1;
12306 hashes_buf[0].salt->scrypt_p = 1;
12307 break;
12308 case 9400: hashes_buf[0].salt->salt_len = 16;
12309 break;
12310 case 9500: hashes_buf[0].salt->salt_len = 16;
12311 break;
12312 case 9600: hashes_buf[0].salt->salt_len = 16;
12313 break;
12314 case 9700: hashes_buf[0].salt->salt_len = 16;
12315 break;
12316 case 9710: hashes_buf[0].salt->salt_len = 16;
12317 break;
12318 case 9720: hashes_buf[0].salt->salt_len = 16;
12319 break;
12320 case 9800: hashes_buf[0].salt->salt_len = 16;
12321 break;
12322 case 9810: hashes_buf[0].salt->salt_len = 16;
12323 break;
12324 case 9820: hashes_buf[0].salt->salt_len = 16;
12325 break;
12326 case 10300: hashes_buf[0].salt->salt_len = 12;
12327 break;
12328 case 11500: hashes_buf[0].salt->salt_len = 4;
12329 break;
12330 case 11600: hashes_buf[0].salt->salt_len = 4;
12331 break;
12332 case 12400: hashes_buf[0].salt->salt_len = 4;
12333 break;
12334 case 12500: hashes_buf[0].salt->salt_len = 8;
12335 break;
12336 case 12600: hashes_buf[0].salt->salt_len = 64;
12337 break;
12338 }
12339
12340 // special esalt handling
12341
12342 switch (hash_mode)
12343 {
12344 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12345 break;
12346 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12347 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12348 break;
12349 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12350 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12351 break;
12352 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12353 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12354 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12355 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12356 break;
12357 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12358 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12359 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12360 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12361 break;
12362 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12363 break;
12364 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12365 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12366 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12367 break;
12368 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12369 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12370 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12371 break;
12372 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12373 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12374 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12375 break;
12376 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12377 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12378 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12379 break;
12380 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12381 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12382 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12383 break;
12384 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12385 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12386 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12387 break;
12388 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12389 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12390 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12391 break;
12392 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12393 break;
12394 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12395 break;
12396 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12397 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12398 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12399 break;
12400 }
12401 }
12402
12403 // set hashfile
12404
12405 switch (hash_mode)
12406 {
12407 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12408 break;
12409 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12410 break;
12411 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12412 break;
12413 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12414 break;
12415 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12416 break;
12417 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12418 break;
12419 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12420 break;
12421 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12422 break;
12423 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12424 break;
12425 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12426 break;
12427 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12428 break;
12429 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12430 break;
12431 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12432 break;
12433 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12434 break;
12435 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12436 break;
12437 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12438 break;
12439 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12440 break;
12441 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12442 break;
12443 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12444 break;
12445 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12446 break;
12447 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12448 break;
12449 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12450 break;
12451 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12452 break;
12453 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12454 break;
12455 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12456 break;
12457 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12458 break;
12459 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12460 break;
12461 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12462 break;
12463 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12464 break;
12465 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12466 break;
12467 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12468 break;
12469 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12470 break;
12471 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12472 break;
12473 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12474 break;
12475 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12476 break;
12477 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12478 break;
12479 }
12480
12481 // set default iterations
12482
12483 switch (hash_mode)
12484 {
12485 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12486 break;
12487 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12488 break;
12489 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12490 break;
12491 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12492 break;
12493 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12494 break;
12495 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12496 break;
12497 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12498 break;
12499 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12500 break;
12501 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12502 break;
12503 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12504 break;
12505 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12506 break;
12507 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12508 break;
12509 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12510 break;
12511 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12512 break;
12513 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12514 break;
12515 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12516 break;
12517 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12518 break;
12519 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12520 break;
12521 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12522 break;
12523 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12524 break;
12525 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12526 break;
12527 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12528 break;
12529 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12530 break;
12531 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12532 break;
12533 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12534 break;
12535 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12536 break;
12537 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12538 break;
12539 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12540 break;
12541 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12542 break;
12543 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12544 break;
12545 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12546 break;
12547 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12548 break;
12549 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12550 break;
12551 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12552 break;
12553 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12554 break;
12555 case 8900: hashes_buf[0].salt->salt_iter = 1;
12556 break;
12557 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12558 break;
12559 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12560 break;
12561 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12562 break;
12563 case 9300: hashes_buf[0].salt->salt_iter = 1;
12564 break;
12565 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12566 break;
12567 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12568 break;
12569 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12570 break;
12571 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12572 break;
12573 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12574 break;
12575 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12576 break;
12577 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12578 break;
12579 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12580 break;
12581 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12582 break;
12583 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12584 break;
12585 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12586 break;
12587 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12588 break;
12589 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12590 break;
12591 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12592 break;
12593 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12594 break;
12595 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12596 break;
12597 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12598 break;
12599 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12600 break;
12601 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12602 break;
12603 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12604 break;
12605 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12606 break;
12607 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12608 break;
12609 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12610 break;
12611 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12612 break;
12613 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12614 break;
12615 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12616 break;
12617 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12618 break;
12619 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12620 break;
12621 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12622 break;
12623 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12624 break;
12625 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12626 break;
12627 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12628 break;
12629 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12630 break;
12631 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12632 break;
12633 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12634 break;
12635 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12636 break;
12637 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12638 break;
12639 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12640 break;
12641 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12642 break;
12643 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12644 break;
12645 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12646 break;
12647 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12648 break;
12649 }
12650
12651 hashes_cnt = 1;
12652 }
12653
12654 if (show == 1 || left == 1)
12655 {
12656 for (uint i = 0; i < pot_cnt; i++)
12657 {
12658 pot_t *pot_ptr = &pot[i];
12659
12660 hash_t *hashes_buf = &pot_ptr->hash;
12661
12662 local_free (hashes_buf->digest);
12663
12664 if (isSalted)
12665 {
12666 local_free (hashes_buf->salt);
12667 }
12668 }
12669
12670 local_free (pot);
12671
12672 if (data.quiet == 0) log_info_nn ("");
12673
12674 return (0);
12675 }
12676
12677 if ((keyspace == 0) && (stdout_flag == 0))
12678 {
12679 if (hashes_cnt == 0)
12680 {
12681 log_error ("ERROR: No hashes loaded");
12682
12683 return (-1);
12684 }
12685 }
12686
12687 /**
12688 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12689 */
12690
12691 if (data.outfile != NULL)
12692 {
12693 if (data.hashfile != NULL)
12694 {
12695 #ifdef _POSIX
12696 struct stat tmpstat_outfile;
12697 struct stat tmpstat_hashfile;
12698 #endif
12699
12700 #ifdef _WIN
12701 struct stat64 tmpstat_outfile;
12702 struct stat64 tmpstat_hashfile;
12703 #endif
12704
12705 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12706
12707 if (tmp_outfile_fp)
12708 {
12709 #ifdef _POSIX
12710 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12711 #endif
12712
12713 #ifdef _WIN
12714 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12715 #endif
12716
12717 fclose (tmp_outfile_fp);
12718 }
12719
12720 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12721
12722 if (tmp_hashfile_fp)
12723 {
12724 #ifdef _POSIX
12725 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12726 #endif
12727
12728 #ifdef _WIN
12729 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12730 #endif
12731
12732 fclose (tmp_hashfile_fp);
12733 }
12734
12735 if (tmp_outfile_fp && tmp_outfile_fp)
12736 {
12737 tmpstat_outfile.st_mode = 0;
12738 tmpstat_outfile.st_nlink = 0;
12739 tmpstat_outfile.st_uid = 0;
12740 tmpstat_outfile.st_gid = 0;
12741 tmpstat_outfile.st_rdev = 0;
12742 tmpstat_outfile.st_atime = 0;
12743
12744 tmpstat_hashfile.st_mode = 0;
12745 tmpstat_hashfile.st_nlink = 0;
12746 tmpstat_hashfile.st_uid = 0;
12747 tmpstat_hashfile.st_gid = 0;
12748 tmpstat_hashfile.st_rdev = 0;
12749 tmpstat_hashfile.st_atime = 0;
12750
12751 #ifdef _POSIX
12752 tmpstat_outfile.st_blksize = 0;
12753 tmpstat_outfile.st_blocks = 0;
12754
12755 tmpstat_hashfile.st_blksize = 0;
12756 tmpstat_hashfile.st_blocks = 0;
12757 #endif
12758
12759 #ifdef _POSIX
12760 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12761 {
12762 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12763
12764 return (-1);
12765 }
12766 #endif
12767
12768 #ifdef _WIN
12769 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12770 {
12771 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12772
12773 return (-1);
12774 }
12775 #endif
12776 }
12777 }
12778 }
12779
12780 /**
12781 * Remove duplicates
12782 */
12783
12784 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12785
12786 if (isSalted)
12787 {
12788 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12789 }
12790 else
12791 {
12792 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12793 }
12794
12795 uint hashes_cnt_orig = hashes_cnt;
12796
12797 hashes_cnt = 1;
12798
12799 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12800 {
12801 if (isSalted)
12802 {
12803 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12804 {
12805 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12806 }
12807 }
12808 else
12809 {
12810 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12811 }
12812
12813 if (hashes_pos > hashes_cnt)
12814 {
12815 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12816 }
12817
12818 hashes_cnt++;
12819 }
12820
12821 /**
12822 * Potfile removes
12823 */
12824
12825 uint potfile_remove_cracks = 0;
12826
12827 if (potfile_disable == 0)
12828 {
12829 hash_t hash_buf;
12830
12831 hash_buf.digest = mymalloc (dgst_size);
12832 hash_buf.salt = NULL;
12833 hash_buf.esalt = NULL;
12834 hash_buf.hash_info = NULL;
12835 hash_buf.cracked = 0;
12836
12837 if (isSalted)
12838 {
12839 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12840 }
12841
12842 if (esalt_size)
12843 {
12844 hash_buf.esalt = mymalloc (esalt_size);
12845 }
12846
12847 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12848
12849 // no solution for these special hash types (for instane because they use hashfile in output etc)
12850 if ((hash_mode != 5200) &&
12851 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12852 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12853 (hash_mode != 9000))
12854 {
12855 FILE *fp = fopen (potfile, "rb");
12856
12857 if (fp != NULL)
12858 {
12859 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12860
12861 // to be safe work with a copy (because of line_len loop, i etc)
12862 // moved up here because it's easier to handle continue case
12863 // it's just 64kb
12864
12865 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12866
12867 while (!feof (fp))
12868 {
12869 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12870
12871 if (ptr == NULL) break;
12872
12873 int line_len = strlen (line_buf);
12874
12875 if (line_len == 0) continue;
12876
12877 int iter = MAX_CUT_TRIES;
12878
12879 for (int i = line_len - 1; i && iter; i--, line_len--)
12880 {
12881 if (line_buf[i] != ':') continue;
12882
12883 if (isSalted)
12884 {
12885 memset (hash_buf.salt, 0, sizeof (salt_t));
12886 }
12887
12888 hash_t *found = NULL;
12889
12890 if (hash_mode == 6800)
12891 {
12892 if (i < 64) // 64 = 16 * uint in salt_buf[]
12893 {
12894 // manipulate salt_buf
12895 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12896
12897 hash_buf.salt->salt_len = i;
12898
12899 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12900 }
12901 }
12902 else if (hash_mode == 2500)
12903 {
12904 if (i < 64) // 64 = 16 * uint in salt_buf[]
12905 {
12906 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12907 // manipulate salt_buf
12908
12909 memcpy (line_buf_cpy, line_buf, i);
12910
12911 char *mac2_pos = strrchr (line_buf_cpy, ':');
12912
12913 if (mac2_pos == NULL) continue;
12914
12915 mac2_pos[0] = 0;
12916 mac2_pos++;
12917
12918 if (strlen (mac2_pos) != 12) continue;
12919
12920 char *mac1_pos = strrchr (line_buf_cpy, ':');
12921
12922 if (mac1_pos == NULL) continue;
12923
12924 mac1_pos[0] = 0;
12925 mac1_pos++;
12926
12927 if (strlen (mac1_pos) != 12) continue;
12928
12929 uint essid_length = mac1_pos - line_buf_cpy - 1;
12930
12931 // here we need the ESSID
12932 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12933
12934 hash_buf.salt->salt_len = essid_length;
12935
12936 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12937
12938 if (found)
12939 {
12940 wpa_t *wpa = (wpa_t *) found->esalt;
12941
12942 // compare hex string(s) vs binary MAC address(es)
12943
12944 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12945 {
12946 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12947 {
12948 found = NULL;
12949
12950 break;
12951 }
12952 }
12953
12954 // early skip ;)
12955 if (!found) continue;
12956
12957 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12958 {
12959 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12960 {
12961 found = NULL;
12962
12963 break;
12964 }
12965 }
12966 }
12967 }
12968 }
12969 else
12970 {
12971 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12972
12973 if (parser_status == PARSER_OK)
12974 {
12975 if (isSalted)
12976 {
12977 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12978 }
12979 else
12980 {
12981 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12982 }
12983 }
12984 }
12985
12986 if (found == NULL) continue;
12987
12988 if (!found->cracked) potfile_remove_cracks++;
12989
12990 found->cracked = 1;
12991
12992 if (found) break;
12993
12994 iter--;
12995 }
12996 }
12997
12998 myfree (line_buf_cpy);
12999
13000 myfree (line_buf);
13001
13002 fclose (fp);
13003 }
13004 }
13005
13006 if (esalt_size)
13007 {
13008 local_free (hash_buf.esalt);
13009 }
13010
13011 if (isSalted)
13012 {
13013 local_free (hash_buf.salt);
13014 }
13015
13016 local_free (hash_buf.digest);
13017 }
13018
13019 /**
13020 * Now generate all the buffers required for later
13021 */
13022
13023 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
13024
13025 salt_t *salts_buf_new = NULL;
13026 void *esalts_buf_new = NULL;
13027
13028 if (isSalted)
13029 {
13030 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
13031
13032 if (esalt_size)
13033 {
13034 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
13035 }
13036 }
13037 else
13038 {
13039 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13040 }
13041
13042 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13043
13044 uint digests_cnt = hashes_cnt;
13045 uint digests_done = 0;
13046
13047 size_t size_digests = digests_cnt * dgst_size;
13048 size_t size_shown = digests_cnt * sizeof (uint);
13049
13050 uint *digests_shown = (uint *) mymalloc (size_shown);
13051 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13052
13053 uint salts_cnt = 0;
13054 uint salts_done = 0;
13055
13056 hashinfo_t **hash_info = NULL;
13057
13058 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13059 {
13060 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13061
13062 if (username && (remove || show))
13063 {
13064 uint user_pos;
13065
13066 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13067 {
13068 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13069
13070 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13071 }
13072 }
13073 }
13074
13075 uint *salts_shown = (uint *) mymalloc (size_shown);
13076
13077 salt_t *salt_buf;
13078
13079 {
13080 // copied from inner loop
13081
13082 salt_buf = &salts_buf_new[salts_cnt];
13083
13084 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13085
13086 if (esalt_size)
13087 {
13088 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13089 }
13090
13091 salt_buf->digests_cnt = 0;
13092 salt_buf->digests_done = 0;
13093 salt_buf->digests_offset = 0;
13094
13095 salts_cnt++;
13096 }
13097
13098 if (hashes_buf[0].cracked == 1)
13099 {
13100 digests_shown[0] = 1;
13101
13102 digests_done++;
13103
13104 salt_buf->digests_done++;
13105 }
13106
13107 salt_buf->digests_cnt++;
13108
13109 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13110
13111 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13112 {
13113 hash_info[0] = hashes_buf[0].hash_info;
13114 }
13115
13116 // copy from inner loop
13117
13118 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13119 {
13120 if (isSalted)
13121 {
13122 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13123 {
13124 salt_buf = &salts_buf_new[salts_cnt];
13125
13126 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13127
13128 if (esalt_size)
13129 {
13130 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13131 }
13132
13133 salt_buf->digests_cnt = 0;
13134 salt_buf->digests_done = 0;
13135 salt_buf->digests_offset = hashes_pos;
13136
13137 salts_cnt++;
13138 }
13139 }
13140
13141 if (hashes_buf[hashes_pos].cracked == 1)
13142 {
13143 digests_shown[hashes_pos] = 1;
13144
13145 digests_done++;
13146
13147 salt_buf->digests_done++;
13148 }
13149
13150 salt_buf->digests_cnt++;
13151
13152 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13153
13154 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13155 {
13156 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13157 }
13158 }
13159
13160 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13161 {
13162 salt_t *salt_buf = &salts_buf_new[salt_pos];
13163
13164 if (salt_buf->digests_done == salt_buf->digests_cnt)
13165 {
13166 salts_shown[salt_pos] = 1;
13167
13168 salts_done++;
13169 }
13170
13171 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13172 }
13173
13174 local_free (digests_buf);
13175 local_free (salts_buf);
13176 local_free (esalts_buf);
13177
13178 digests_buf = digests_buf_new;
13179 salts_buf = salts_buf_new;
13180 esalts_buf = esalts_buf_new;
13181
13182 local_free (hashes_buf);
13183
13184 /**
13185 * special modification not set from parser
13186 */
13187
13188 switch (hash_mode)
13189 {
13190 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13191 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13192 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13193 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13194 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13195 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13196 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13197 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13198 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13199 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13200 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13201 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13202 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13203 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13204 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13205 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13206 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13207 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13208 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13209 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13210 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13211 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13212 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13213 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13214 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13215 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13216 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13217 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13218 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13219 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13220 }
13221
13222 if (truecrypt_keyfiles)
13223 {
13224 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13225
13226 char *keyfiles = strdup (truecrypt_keyfiles);
13227
13228 char *keyfile = strtok (keyfiles, ",");
13229
13230 do
13231 {
13232 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13233
13234 } while ((keyfile = strtok (NULL, ",")) != NULL);
13235
13236 free (keyfiles);
13237 }
13238
13239 if (veracrypt_keyfiles)
13240 {
13241 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13242
13243 char *keyfiles = strdup (veracrypt_keyfiles);
13244
13245 char *keyfile = strtok (keyfiles, ",");
13246
13247 do
13248 {
13249 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13250
13251 } while ((keyfile = strtok (NULL, ",")) != NULL);
13252
13253 free (keyfiles);
13254 }
13255
13256 data.digests_cnt = digests_cnt;
13257 data.digests_done = digests_done;
13258 data.digests_buf = digests_buf;
13259 data.digests_shown = digests_shown;
13260 data.digests_shown_tmp = digests_shown_tmp;
13261
13262 data.salts_cnt = salts_cnt;
13263 data.salts_done = salts_done;
13264 data.salts_buf = salts_buf;
13265 data.salts_shown = salts_shown;
13266
13267 data.esalts_buf = esalts_buf;
13268 data.hash_info = hash_info;
13269
13270 /**
13271 * Automatic Optimizers
13272 */
13273
13274 if (salts_cnt == 1)
13275 opti_type |= OPTI_TYPE_SINGLE_SALT;
13276
13277 if (digests_cnt == 1)
13278 opti_type |= OPTI_TYPE_SINGLE_HASH;
13279
13280 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13281 opti_type |= OPTI_TYPE_NOT_ITERATED;
13282
13283 if (attack_mode == ATTACK_MODE_BF)
13284 opti_type |= OPTI_TYPE_BRUTE_FORCE;
13285
13286 data.opti_type = opti_type;
13287
13288 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13289 {
13290 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13291 {
13292 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13293 {
13294 if (opts_type & OPTS_TYPE_ST_ADD80)
13295 {
13296 opts_type &= ~OPTS_TYPE_ST_ADD80;
13297 opts_type |= OPTS_TYPE_PT_ADD80;
13298 }
13299
13300 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13301 {
13302 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13303 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13304 }
13305
13306 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13307 {
13308 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13309 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13310 }
13311 }
13312 }
13313 }
13314
13315 /**
13316 * Some algorithm, like descrypt, can benefit from JIT compilation
13317 */
13318
13319 int force_jit_compilation = -1;
13320
13321 if (hash_mode == 8900)
13322 {
13323 force_jit_compilation = 8900;
13324 }
13325 else if (hash_mode == 9300)
13326 {
13327 force_jit_compilation = 8900;
13328 }
13329 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13330 {
13331 force_jit_compilation = 1500;
13332 }
13333
13334 /**
13335 * generate bitmap tables
13336 */
13337
13338 const uint bitmap_shift1 = 5;
13339 const uint bitmap_shift2 = 13;
13340
13341 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13342
13343 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13344 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13345 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13346 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13347 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13348 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13349 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13350 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13351
13352 uint bitmap_bits;
13353 uint bitmap_nums;
13354 uint bitmap_mask;
13355 uint bitmap_size;
13356
13357 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13358 {
13359 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13360
13361 bitmap_nums = 1 << bitmap_bits;
13362
13363 bitmap_mask = bitmap_nums - 1;
13364
13365 bitmap_size = bitmap_nums * sizeof (uint);
13366
13367 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13368
13369 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;
13370 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;
13371
13372 break;
13373 }
13374
13375 bitmap_nums = 1 << bitmap_bits;
13376
13377 bitmap_mask = bitmap_nums - 1;
13378
13379 bitmap_size = bitmap_nums * sizeof (uint);
13380
13381 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);
13382 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);
13383
13384 /**
13385 * prepare quick rule
13386 */
13387
13388 data.rule_buf_l = rule_buf_l;
13389 data.rule_buf_r = rule_buf_r;
13390
13391 int rule_len_l = (int) strlen (rule_buf_l);
13392 int rule_len_r = (int) strlen (rule_buf_r);
13393
13394 data.rule_len_l = rule_len_l;
13395 data.rule_len_r = rule_len_r;
13396
13397 /**
13398 * load rules
13399 */
13400
13401 uint *all_kernel_rules_cnt = NULL;
13402
13403 kernel_rule_t **all_kernel_rules_buf = NULL;
13404
13405 if (rp_files_cnt)
13406 {
13407 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13408
13409 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13410 }
13411
13412 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13413
13414 int rule_len = 0;
13415
13416 for (uint i = 0; i < rp_files_cnt; i++)
13417 {
13418 uint kernel_rules_avail = 0;
13419
13420 uint kernel_rules_cnt = 0;
13421
13422 kernel_rule_t *kernel_rules_buf = NULL;
13423
13424 char *rp_file = rp_files[i];
13425
13426 char in[BLOCK_SIZE] = { 0 };
13427 char out[BLOCK_SIZE] = { 0 };
13428
13429 FILE *fp = NULL;
13430
13431 uint rule_line = 0;
13432
13433 if ((fp = fopen (rp_file, "rb")) == NULL)
13434 {
13435 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13436
13437 return (-1);
13438 }
13439
13440 while (!feof (fp))
13441 {
13442 memset (rule_buf, 0, HCBUFSIZ);
13443
13444 rule_len = fgetl (fp, rule_buf);
13445
13446 rule_line++;
13447
13448 if (rule_len == 0) continue;
13449
13450 if (rule_buf[0] == '#') continue;
13451
13452 if (kernel_rules_avail == kernel_rules_cnt)
13453 {
13454 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13455
13456 kernel_rules_avail += INCR_RULES;
13457 }
13458
13459 memset (in, 0, BLOCK_SIZE);
13460 memset (out, 0, BLOCK_SIZE);
13461
13462 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13463
13464 if (result == -1)
13465 {
13466 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13467
13468 continue;
13469 }
13470
13471 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13472 {
13473 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13474
13475 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13476
13477 continue;
13478 }
13479
13480 /* its so slow
13481 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13482 {
13483 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13484
13485 continue;
13486 }
13487 */
13488
13489 kernel_rules_cnt++;
13490 }
13491
13492 fclose (fp);
13493
13494 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13495
13496 all_kernel_rules_buf[i] = kernel_rules_buf;
13497 }
13498
13499 /**
13500 * merge rules or automatic rule generator
13501 */
13502
13503 uint kernel_rules_cnt = 0;
13504
13505 kernel_rule_t *kernel_rules_buf = NULL;
13506
13507 if (attack_mode == ATTACK_MODE_STRAIGHT)
13508 {
13509 if (rp_files_cnt)
13510 {
13511 kernel_rules_cnt = 1;
13512
13513 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13514
13515 repeats[0] = kernel_rules_cnt;
13516
13517 for (uint i = 0; i < rp_files_cnt; i++)
13518 {
13519 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13520
13521 repeats[i + 1] = kernel_rules_cnt;
13522 }
13523
13524 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13525
13526 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13527
13528 for (uint i = 0; i < kernel_rules_cnt; i++)
13529 {
13530 uint out_pos = 0;
13531
13532 kernel_rule_t *out = &kernel_rules_buf[i];
13533
13534 for (uint j = 0; j < rp_files_cnt; j++)
13535 {
13536 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13537 uint in_pos;
13538
13539 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13540
13541 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13542 {
13543 if (out_pos == RULES_MAX - 1)
13544 {
13545 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13546
13547 break;
13548 }
13549
13550 out->cmds[out_pos] = in->cmds[in_pos];
13551 }
13552 }
13553 }
13554
13555 local_free (repeats);
13556 }
13557 else if (rp_gen)
13558 {
13559 uint kernel_rules_avail = 0;
13560
13561 while (kernel_rules_cnt < rp_gen)
13562 {
13563 if (kernel_rules_avail == kernel_rules_cnt)
13564 {
13565 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13566
13567 kernel_rules_avail += INCR_RULES;
13568 }
13569
13570 memset (rule_buf, 0, HCBUFSIZ);
13571
13572 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13573
13574 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13575
13576 kernel_rules_cnt++;
13577 }
13578 }
13579 }
13580
13581 myfree (rule_buf);
13582
13583 /**
13584 * generate NOP rules
13585 */
13586
13587 if (kernel_rules_cnt == 0)
13588 {
13589 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13590
13591 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13592
13593 kernel_rules_cnt++;
13594 }
13595
13596 data.kernel_rules_cnt = kernel_rules_cnt;
13597 data.kernel_rules_buf = kernel_rules_buf;
13598
13599 /**
13600 * OpenCL platforms: detect
13601 */
13602
13603 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13604 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13605
13606 cl_uint platforms_cnt = 0;
13607 cl_uint platform_devices_cnt = 0;
13608
13609 if (keyspace == 0)
13610 {
13611 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13612
13613 if (platforms_cnt == 0)
13614 {
13615 log_info ("");
13616 log_info ("ATTENTION! No OpenCL compatible platform found");
13617 log_info ("");
13618 log_info ("You're probably missing the OpenCL runtime installation");
13619 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13620 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13621 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13622 log_info ("");
13623
13624 return (-1);
13625 }
13626
13627 if (opencl_platforms_filter != (uint) -1)
13628 {
13629 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13630
13631 if (opencl_platforms_filter > platform_cnt_mask)
13632 {
13633 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13634
13635 return (-1);
13636 }
13637 }
13638 }
13639
13640 /**
13641 * OpenCL device types:
13642 * 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.
13643 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13644 */
13645
13646 if (opencl_device_types == NULL)
13647 {
13648 cl_device_type device_types_all = 0;
13649
13650 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13651 {
13652 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13653
13654 cl_platform_id platform = platforms[platform_id];
13655
13656 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13657
13658 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13659 {
13660 cl_device_id device = platform_devices[platform_devices_id];
13661
13662 cl_device_type device_type;
13663
13664 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13665
13666 device_types_all |= device_type;
13667 }
13668 }
13669
13670 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13671 {
13672 device_types_filter |= CL_DEVICE_TYPE_CPU;
13673 }
13674 }
13675
13676 /**
13677 * OpenCL devices: simply push all devices from all platforms into the same device array
13678 */
13679
13680 int need_adl = 0;
13681 int need_nvapi = 0;
13682 int need_nvml = 0;
13683 int need_xnvctrl = 0;
13684
13685 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13686
13687 data.devices_param = devices_param;
13688
13689 uint devices_cnt = 0;
13690
13691 uint devices_active = 0;
13692
13693 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13694 {
13695 cl_platform_id platform = platforms[platform_id];
13696
13697 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13698
13699 char platform_vendor[INFOSZ] = { 0 };
13700
13701 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13702
13703 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13704 // this causes trouble with vendor id based macros
13705 // we'll assign generic to those without special optimization available
13706
13707 cl_uint platform_vendor_id = 0;
13708
13709 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13710 {
13711 platform_vendor_id = VENDOR_ID_AMD;
13712 }
13713 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13714 {
13715 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13716 }
13717 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13718 {
13719 platform_vendor_id = VENDOR_ID_APPLE;
13720 }
13721 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13722 {
13723 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13724 }
13725 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13726 {
13727 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13728 }
13729 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13730 {
13731 platform_vendor_id = VENDOR_ID_MESA;
13732 }
13733 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13734 {
13735 platform_vendor_id = VENDOR_ID_NV;
13736 }
13737 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13738 {
13739 platform_vendor_id = VENDOR_ID_POCL;
13740 }
13741 else
13742 {
13743 platform_vendor_id = VENDOR_ID_GENERIC;
13744 }
13745
13746 const uint platform_skipped = ((opencl_platforms_filter & (1 << platform_id)) == 0);
13747
13748 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13749 {
13750 if (machine_readable == 0)
13751 {
13752 int len = 0;
13753
13754 if (platform_skipped == 0)
13755 {
13756 len = log_info ("OpenCL Platform #%u: %s", platform_id + 1, platform_vendor);
13757 }
13758 else
13759 {
13760 len = log_info ("OpenCL Platform #%u: %s, skipped", platform_id + 1, platform_vendor);
13761 }
13762
13763 char line[256] = { 0 };
13764
13765 for (int i = 0; i < len; i++) line[i] = '=';
13766
13767 log_info (line);
13768 }
13769 }
13770
13771 if (platform_skipped == 1) continue;
13772
13773 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13774 {
13775 size_t param_value_size = 0;
13776
13777 const uint device_id = devices_cnt;
13778
13779 hc_device_param_t *device_param = &data.devices_param[device_id];
13780
13781 device_param->platform_vendor_id = platform_vendor_id;
13782
13783 device_param->device = platform_devices[platform_devices_id];
13784
13785 device_param->device_id = device_id;
13786
13787 device_param->platform_devices_id = platform_devices_id;
13788
13789 // device_type
13790
13791 cl_device_type device_type;
13792
13793 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13794
13795 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13796
13797 device_param->device_type = device_type;
13798
13799 // device_name
13800
13801 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13802
13803 char *device_name = (char *) mymalloc (param_value_size);
13804
13805 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13806
13807 device_param->device_name = device_name;
13808
13809 // device_vendor
13810
13811 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13812
13813 char *device_vendor = (char *) mymalloc (param_value_size);
13814
13815 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13816
13817 device_param->device_vendor = device_vendor;
13818
13819 cl_uint device_vendor_id = 0;
13820
13821 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13822 {
13823 device_vendor_id = VENDOR_ID_AMD;
13824 }
13825 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13826 {
13827 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13828 }
13829 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13830 {
13831 device_vendor_id = VENDOR_ID_APPLE;
13832 }
13833 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13834 {
13835 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13836 }
13837 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13838 {
13839 device_vendor_id = VENDOR_ID_INTEL_SDK;
13840 }
13841 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13842 {
13843 device_vendor_id = VENDOR_ID_MESA;
13844 }
13845 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13846 {
13847 device_vendor_id = VENDOR_ID_NV;
13848 }
13849 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13850 {
13851 device_vendor_id = VENDOR_ID_POCL;
13852 }
13853 else
13854 {
13855 device_vendor_id = VENDOR_ID_GENERIC;
13856 }
13857
13858 device_param->device_vendor_id = device_vendor_id;
13859
13860 // tuning db
13861
13862 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13863
13864 // device_version
13865
13866 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13867
13868 char *device_version = (char *) mymalloc (param_value_size);
13869
13870 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13871
13872 device_param->device_version = device_version;
13873
13874 // device_opencl_version
13875
13876 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13877
13878 char *device_opencl_version = (char *) mymalloc (param_value_size);
13879
13880 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13881
13882 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13883
13884 myfree (device_opencl_version);
13885
13886 // vector_width
13887
13888 cl_uint vector_width;
13889
13890 if (opencl_vector_width_chgd == 0)
13891 {
13892 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13893 {
13894 if (opti_type & OPTI_TYPE_USES_BITS_64)
13895 {
13896 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13897 }
13898 else
13899 {
13900 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13901 }
13902 }
13903 else
13904 {
13905 vector_width = (cl_uint) tuningdb_entry->vector_width;
13906 }
13907 }
13908 else
13909 {
13910 vector_width = opencl_vector_width;
13911 }
13912
13913 if (vector_width > 16) vector_width = 16;
13914
13915 device_param->vector_width = vector_width;
13916
13917 // max_compute_units
13918
13919 cl_uint device_processors;
13920
13921 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13922
13923 device_param->device_processors = device_processors;
13924
13925 // device_maxmem_alloc
13926 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13927
13928 cl_ulong device_maxmem_alloc;
13929
13930 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13931
13932 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13933
13934 // device_global_mem
13935
13936 cl_ulong device_global_mem;
13937
13938 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13939
13940 device_param->device_global_mem = device_global_mem;
13941
13942 // max_work_group_size
13943
13944 size_t device_maxworkgroup_size;
13945
13946 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13947
13948 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13949
13950 // max_clock_frequency
13951
13952 cl_uint device_maxclock_frequency;
13953
13954 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13955
13956 device_param->device_maxclock_frequency = device_maxclock_frequency;
13957
13958 // device_endian_little
13959
13960 cl_bool device_endian_little;
13961
13962 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13963
13964 if (device_endian_little == CL_FALSE)
13965 {
13966 log_info ("- Device #%u: WARNING: not little endian device", device_id + 1);
13967
13968 device_param->skipped = 1;
13969 }
13970
13971 // device_available
13972
13973 cl_bool device_available;
13974
13975 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13976
13977 if (device_available == CL_FALSE)
13978 {
13979 log_info ("- Device #%u: WARNING: device not available", device_id + 1);
13980
13981 device_param->skipped = 1;
13982 }
13983
13984 // device_compiler_available
13985
13986 cl_bool device_compiler_available;
13987
13988 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13989
13990 if (device_compiler_available == CL_FALSE)
13991 {
13992 log_info ("- Device #%u: WARNING: device no compiler available", device_id + 1);
13993
13994 device_param->skipped = 1;
13995 }
13996
13997 // device_execution_capabilities
13998
13999 cl_device_exec_capabilities device_execution_capabilities;
14000
14001 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
14002
14003 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
14004 {
14005 log_info ("- Device #%u: WARNING: device does not support executing kernels", device_id + 1);
14006
14007 device_param->skipped = 1;
14008 }
14009
14010 // device_extensions
14011
14012 size_t device_extensions_size;
14013
14014 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
14015
14016 char *device_extensions = mymalloc (device_extensions_size + 1);
14017
14018 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
14019
14020 if (strstr (device_extensions, "base_atomics") == 0)
14021 {
14022 log_info ("- Device #%u: WARNING: device does not support base atomics", device_id + 1);
14023
14024 device_param->skipped = 1;
14025 }
14026
14027 if (strstr (device_extensions, "byte_addressable_store") == 0)
14028 {
14029 log_info ("- Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
14030
14031 device_param->skipped = 1;
14032 }
14033
14034 myfree (device_extensions);
14035
14036 // device_local_mem_size
14037
14038 cl_ulong device_local_mem_size;
14039
14040 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
14041
14042 if (device_local_mem_size < 32768)
14043 {
14044 log_info ("- Device #%u: WARNING: device local mem size is too small", device_id + 1);
14045
14046 device_param->skipped = 1;
14047 }
14048
14049 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
14050 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
14051 // This results in both utilizing it for 50%
14052 // However, Intel has much better SIMD control over their own hardware
14053 // It makes sense to give them full control over their own hardware
14054
14055 if (device_type & CL_DEVICE_TYPE_CPU)
14056 {
14057 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14058 {
14059 if (data.force == 0)
14060 {
14061 if (algorithm_pos == 0)
14062 {
14063 log_info ("- Device #%u: WARNING: not native intel opencl runtime, expect massive speed loss", device_id + 1);
14064 log_info (" You can use --force to override this but do not post error reports if you do so");
14065 }
14066
14067 device_param->skipped = 1;
14068 }
14069 }
14070 }
14071
14072 // skipped
14073
14074 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14075 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14076
14077 // driver_version
14078
14079 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14080
14081 char *driver_version = (char *) mymalloc (param_value_size);
14082
14083 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14084
14085 device_param->driver_version = driver_version;
14086
14087 // device_name_chksum
14088
14089 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14090
14091 #if __x86_64__
14092 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);
14093 #else
14094 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);
14095 #endif
14096
14097 uint device_name_digest[4] = { 0 };
14098
14099 md5_64 ((uint *) device_name_chksum, device_name_digest);
14100
14101 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14102
14103 device_param->device_name_chksum = device_name_chksum;
14104
14105 // device_processor_cores
14106
14107 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14108 {
14109 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14110 {
14111 need_adl = 1;
14112 }
14113
14114 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14115 {
14116 need_nvml = 1;
14117
14118 #ifdef LINUX
14119 need_xnvctrl = 1;
14120 #endif
14121
14122 #ifdef WIN
14123 need_nvapi = 1;
14124 #endif
14125 }
14126 }
14127
14128 // device_processor_cores
14129
14130 if (device_type & CL_DEVICE_TYPE_CPU)
14131 {
14132 cl_uint device_processor_cores = 1;
14133
14134 device_param->device_processor_cores = device_processor_cores;
14135 }
14136
14137 if (device_type & CL_DEVICE_TYPE_GPU)
14138 {
14139 if (device_vendor_id == VENDOR_ID_AMD)
14140 {
14141 cl_uint device_processor_cores = 0;
14142
14143 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
14144
14145 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
14146
14147 device_param->device_processor_cores = device_processor_cores;
14148 }
14149 else if (device_vendor_id == VENDOR_ID_NV)
14150 {
14151 cl_uint kernel_exec_timeout = 0;
14152
14153 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14154
14155 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14156
14157 device_param->kernel_exec_timeout = kernel_exec_timeout;
14158
14159 cl_uint device_processor_cores = 0;
14160
14161 #define CL_DEVICE_WARP_SIZE_NV 0x4003
14162
14163 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
14164
14165 device_param->device_processor_cores = device_processor_cores;
14166
14167 cl_uint sm_minor = 0;
14168 cl_uint sm_major = 0;
14169
14170 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14171 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14172
14173 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14174 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14175
14176 device_param->sm_minor = sm_minor;
14177 device_param->sm_major = sm_major;
14178
14179 // CPU burning loop damper
14180 // Value is given as number between 0-100
14181 // By default 100%
14182
14183 device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14184
14185 if (nvidia_spin_damp_chgd == 0)
14186 {
14187 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14188 {
14189 /**
14190 * the workaround is not a friend of rule based attacks
14191 * the words from the wordlist combined with fast and slow rules cause
14192 * fluctuations which cause inaccurate wait time estimations
14193 * using a reduced damping percentage almost compensates this
14194 */
14195
14196 device_param->nvidia_spin_damp = 64;
14197 }
14198 }
14199
14200 device_param->nvidia_spin_damp /= 100;
14201 }
14202 else
14203 {
14204 cl_uint device_processor_cores = 1;
14205
14206 device_param->device_processor_cores = device_processor_cores;
14207 }
14208 }
14209
14210 // display results
14211
14212 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14213 {
14214 if (machine_readable == 0)
14215 {
14216 if (device_param->skipped == 0)
14217 {
14218 log_info ("- Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14219 device_id + 1,
14220 device_name,
14221 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14222 (unsigned int) (device_global_mem / 1024 / 1024),
14223 (unsigned int) device_processors);
14224 }
14225 else
14226 {
14227 log_info ("- Device #%u: %s, skipped",
14228 device_id + 1,
14229 device_name);
14230 }
14231 }
14232 }
14233
14234 // common driver check
14235
14236 if (device_param->skipped == 0)
14237 {
14238 if (device_type & CL_DEVICE_TYPE_GPU)
14239 {
14240 if (platform_vendor_id == VENDOR_ID_AMD)
14241 {
14242 int catalyst_check = (force == 1) ? 0 : 1;
14243
14244 int catalyst_warn = 0;
14245
14246 int catalyst_broken = 0;
14247
14248 if (catalyst_check == 1)
14249 {
14250 catalyst_warn = 1;
14251
14252 // v14.9 and higher
14253 if (atoi (device_param->driver_version) >= 1573)
14254 {
14255 catalyst_warn = 0;
14256 }
14257
14258 catalyst_check = 0;
14259 }
14260
14261 if (catalyst_broken == 1)
14262 {
14263 log_info ("");
14264 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
14265 log_info ("It will pass over cracked hashes and does not report them as cracked");
14266 log_info ("You are STRONGLY encouraged not to use it");
14267 log_info ("You can use --force to override this but do not post error reports if you do so");
14268 log_info ("");
14269
14270 return (-1);
14271 }
14272
14273 if (catalyst_warn == 1)
14274 {
14275 log_info ("");
14276 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
14277 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
14278 log_info ("See hashcat's homepage for official supported catalyst drivers");
14279 #ifdef _WIN
14280 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14281 #endif
14282 log_info ("You can use --force to override this but do not post error reports if you do so");
14283 log_info ("");
14284
14285 return (-1);
14286 }
14287 }
14288 else if (platform_vendor_id == VENDOR_ID_NV)
14289 {
14290 if (device_param->kernel_exec_timeout != 0)
14291 {
14292 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);
14293 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14294 }
14295 }
14296 }
14297
14298 /* turns out pocl still creates segfaults (because of llvm)
14299 if (device_type & CL_DEVICE_TYPE_CPU)
14300 {
14301 if (platform_vendor_id == VENDOR_ID_AMD)
14302 {
14303 if (force == 0)
14304 {
14305 log_info ("");
14306 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14307 log_info ("You are STRONGLY encouraged not to use it");
14308 log_info ("You can use --force to override this but do not post error reports if you do so");
14309 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14310 log_info ("");
14311
14312 return (-1);
14313 }
14314 }
14315 }
14316 */
14317
14318 /**
14319 * kernel accel and loops tuning db adjustment
14320 */
14321
14322 device_param->kernel_accel_min = 1;
14323 device_param->kernel_accel_max = 1024;
14324
14325 device_param->kernel_loops_min = 1;
14326 device_param->kernel_loops_max = 1024;
14327
14328 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14329
14330 if (tuningdb_entry)
14331 {
14332 u32 _kernel_accel = tuningdb_entry->kernel_accel;
14333 u32 _kernel_loops = tuningdb_entry->kernel_loops;
14334
14335 if (_kernel_accel)
14336 {
14337 device_param->kernel_accel_min = _kernel_accel;
14338 device_param->kernel_accel_max = _kernel_accel;
14339 }
14340
14341 if (_kernel_loops)
14342 {
14343 if (workload_profile == 1)
14344 {
14345 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14346 }
14347 else if (workload_profile == 2)
14348 {
14349 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14350 }
14351
14352 device_param->kernel_loops_min = _kernel_loops;
14353 device_param->kernel_loops_max = _kernel_loops;
14354 }
14355 }
14356
14357 // commandline parameters overwrite tuningdb entries
14358
14359 if (kernel_accel)
14360 {
14361 device_param->kernel_accel_min = kernel_accel;
14362 device_param->kernel_accel_max = kernel_accel;
14363 }
14364
14365 if (kernel_loops)
14366 {
14367 device_param->kernel_loops_min = kernel_loops;
14368 device_param->kernel_loops_max = kernel_loops;
14369 }
14370
14371 /**
14372 * activate device
14373 */
14374
14375 devices_active++;
14376 }
14377
14378 // next please
14379
14380 devices_cnt++;
14381 }
14382
14383 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14384 {
14385 if (machine_readable == 0)
14386 {
14387 log_info ("");
14388 }
14389 }
14390 }
14391
14392 if (keyspace == 0 && devices_active == 0)
14393 {
14394 log_error ("ERROR: No devices found/left");
14395
14396 return (-1);
14397 }
14398
14399 // 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)
14400
14401 if (devices_filter != (uint) -1)
14402 {
14403 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14404
14405 if (devices_filter > devices_cnt_mask)
14406 {
14407 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14408
14409 return (-1);
14410 }
14411 }
14412
14413 data.devices_cnt = devices_cnt;
14414
14415 data.devices_active = devices_active;
14416
14417 /**
14418 * HM devices: init
14419 */
14420
14421 #ifdef HAVE_HWMON
14422 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14423 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14424 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14425 hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX] = { { 0 } };
14426
14427 if (gpu_temp_disable == 0)
14428 {
14429 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14430 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14431 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14432 XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));
14433
14434 data.hm_adl = NULL;
14435 data.hm_nvapi = NULL;
14436 data.hm_nvml = NULL;
14437 data.hm_xnvctrl = NULL;
14438
14439 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14440 {
14441 data.hm_nvml = nvml;
14442 }
14443
14444 if (data.hm_nvml)
14445 {
14446 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14447 {
14448 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14449
14450 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14451
14452 int tmp_out = 0;
14453
14454 for (int i = 0; i < tmp_in; i++)
14455 {
14456 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14457 }
14458
14459 for (int i = 0; i < tmp_out; i++)
14460 {
14461 unsigned int speed;
14462
14463 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14464
14465 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14466
14467 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14468 }
14469 }
14470 }
14471
14472 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14473 {
14474 data.hm_nvapi = nvapi;
14475 }
14476
14477 if (data.hm_nvapi)
14478 {
14479 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14480 {
14481 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14482
14483 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14484
14485 int tmp_out = 0;
14486
14487 for (int i = 0; i < tmp_in; i++)
14488 {
14489 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14490 }
14491 }
14492 }
14493
14494 if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0))
14495 {
14496 data.hm_xnvctrl = xnvctrl;
14497 }
14498
14499 if (data.hm_xnvctrl)
14500 {
14501 if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
14502 {
14503 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14504 {
14505 hc_device_param_t *device_param = &data.devices_param[device_id];
14506
14507 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14508
14509 hm_adapters_xnvctrl[device_id].xnvctrl = device_id;
14510
14511 int speed = 0;
14512
14513 if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
14514 }
14515 }
14516 }
14517
14518 if ((need_adl == 1) && (adl_init (adl) == 0))
14519 {
14520 data.hm_adl = adl;
14521 }
14522
14523 if (data.hm_adl)
14524 {
14525 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14526 {
14527 // total number of adapters
14528
14529 int hm_adapters_num;
14530
14531 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14532
14533 // adapter info
14534
14535 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14536
14537 if (lpAdapterInfo == NULL) return (-1);
14538
14539 // get a list (of ids of) valid/usable adapters
14540
14541 int num_adl_adapters = 0;
14542
14543 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14544
14545 if (num_adl_adapters > 0)
14546 {
14547 hc_thread_mutex_lock (mux_adl);
14548
14549 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14550
14551 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14552
14553 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14554 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14555
14556 hc_thread_mutex_unlock (mux_adl);
14557 }
14558
14559 myfree (valid_adl_device_list);
14560 myfree (lpAdapterInfo);
14561 }
14562 }
14563
14564 if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14565 {
14566 gpu_temp_disable = 1;
14567 }
14568 }
14569
14570 /**
14571 * OpenCL devices: allocate buffer for device specific information
14572 */
14573
14574 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14575 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14576
14577 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14578
14579 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14580
14581 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14582
14583 /**
14584 * User-defined GPU temp handling
14585 */
14586
14587 if (gpu_temp_disable == 1)
14588 {
14589 gpu_temp_abort = 0;
14590 gpu_temp_retain = 0;
14591 }
14592
14593 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14594 {
14595 if (gpu_temp_abort < gpu_temp_retain)
14596 {
14597 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14598
14599 return (-1);
14600 }
14601 }
14602
14603 data.gpu_temp_disable = gpu_temp_disable;
14604 data.gpu_temp_abort = gpu_temp_abort;
14605 data.gpu_temp_retain = gpu_temp_retain;
14606 #endif
14607
14608 /**
14609 * enable custom signal handler(s)
14610 */
14611
14612 if (benchmark == 0)
14613 {
14614 hc_signal (sigHandler_default);
14615 }
14616 else
14617 {
14618 hc_signal (sigHandler_benchmark);
14619 }
14620
14621 /**
14622 * inform the user
14623 */
14624
14625 if (data.quiet == 0)
14626 {
14627 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14628
14629 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);
14630
14631 if (attack_mode == ATTACK_MODE_STRAIGHT)
14632 {
14633 log_info ("Rules: %u", kernel_rules_cnt);
14634 }
14635
14636 if (opti_type)
14637 {
14638 log_info ("Applicable Optimizers:");
14639
14640 for (uint i = 0; i < 32; i++)
14641 {
14642 const uint opti_bit = 1u << i;
14643
14644 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14645 }
14646 }
14647
14648 /**
14649 * Watchdog and Temperature balance
14650 */
14651
14652 #ifdef HAVE_HWMON
14653 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14654 {
14655 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14656 }
14657
14658 if (gpu_temp_abort == 0)
14659 {
14660 log_info ("Watchdog: Temperature abort trigger disabled");
14661 }
14662 else
14663 {
14664 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14665 }
14666
14667 if (gpu_temp_retain == 0)
14668 {
14669 log_info ("Watchdog: Temperature retain trigger disabled");
14670 }
14671 else
14672 {
14673 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14674 }
14675
14676 if (data.quiet == 0) log_info ("");
14677 #endif
14678 }
14679
14680 #ifdef HAVE_HWMON
14681
14682 /**
14683 * HM devices: copy
14684 */
14685
14686 if (gpu_temp_disable == 0)
14687 {
14688 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14689 {
14690 hc_device_param_t *device_param = &data.devices_param[device_id];
14691
14692 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14693
14694 if (device_param->skipped) continue;
14695
14696 const uint platform_devices_id = device_param->platform_devices_id;
14697
14698 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14699 {
14700 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14701 data.hm_device[device_id].nvapi = 0;
14702 data.hm_device[device_id].nvml = 0;
14703 data.hm_device[device_id].xnvctrl = 0;
14704 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14705 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14706 data.hm_device[device_id].fan_set_supported = 0;
14707 }
14708
14709 if (device_param->device_vendor_id == VENDOR_ID_NV)
14710 {
14711 data.hm_device[device_id].adl = 0;
14712 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14713 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14714 data.hm_device[device_id].xnvctrl = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
14715 data.hm_device[device_id].od_version = 0;
14716 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14717 data.hm_device[device_id].fan_set_supported = 0;
14718 }
14719 }
14720 }
14721
14722 /**
14723 * powertune on user request
14724 */
14725
14726 if (powertune_enable == 1)
14727 {
14728 hc_thread_mutex_lock (mux_adl);
14729
14730 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14731 {
14732 hc_device_param_t *device_param = &data.devices_param[device_id];
14733
14734 if (device_param->skipped) continue;
14735
14736 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14737 {
14738 /**
14739 * Temporary fix:
14740 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14741 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14742 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14743 * Driver / ADL bug?
14744 */
14745
14746 if (data.hm_device[device_id].od_version == 6)
14747 {
14748 int ADL_rc;
14749
14750 // check powertune capabilities first, if not available then skip device
14751
14752 int powertune_supported = 0;
14753
14754 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14755 {
14756 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14757
14758 return (-1);
14759 }
14760
14761 // first backup current value, we will restore it later
14762
14763 if (powertune_supported != 0)
14764 {
14765 // powercontrol settings
14766
14767 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14768
14769 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14770 {
14771 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14772 }
14773
14774 if (ADL_rc != ADL_OK)
14775 {
14776 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14777
14778 return (-1);
14779 }
14780
14781 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14782 {
14783 log_error ("ERROR: Failed to set new ADL PowerControl values");
14784
14785 return (-1);
14786 }
14787
14788 // clocks
14789
14790 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14791
14792 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14793
14794 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)
14795 {
14796 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14797
14798 return (-1);
14799 }
14800
14801 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14802
14803 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14804
14805 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14806 {
14807 log_error ("ERROR: Failed to get ADL device capabilities");
14808
14809 return (-1);
14810 }
14811
14812 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14813 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14814
14815 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14816 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14817
14818 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14819 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14820
14821 // warning if profile has too low max values
14822
14823 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14824 {
14825 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14826 }
14827
14828 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14829 {
14830 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14831 }
14832
14833 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14834
14835 performance_state->iNumberOfPerformanceLevels = 2;
14836
14837 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14838 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14839 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14840 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14841
14842 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)
14843 {
14844 log_info ("ERROR: Failed to set ADL performance state");
14845
14846 return (-1);
14847 }
14848
14849 local_free (performance_state);
14850 }
14851
14852 // set powertune value only
14853
14854 if (powertune_supported != 0)
14855 {
14856 // powertune set
14857 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14858
14859 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14860 {
14861 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14862
14863 return (-1);
14864 }
14865
14866 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14867 {
14868 log_error ("ERROR: Failed to set new ADL PowerControl values");
14869
14870 return (-1);
14871 }
14872 }
14873 }
14874 }
14875
14876 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14877 {
14878 // first backup current value, we will restore it later
14879
14880 unsigned int limit;
14881
14882 int powertune_supported = 0;
14883
14884 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14885 {
14886 powertune_supported = 1;
14887 }
14888
14889 // if backup worked, activate the maximum allowed
14890
14891 if (powertune_supported != 0)
14892 {
14893 unsigned int minLimit;
14894 unsigned int maxLimit;
14895
14896 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14897 {
14898 if (maxLimit > 0)
14899 {
14900 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14901 {
14902 // now we can be sure we need to reset later
14903
14904 nvml_power_limit[device_id] = limit;
14905 }
14906 }
14907 }
14908 }
14909 }
14910 }
14911
14912 hc_thread_mutex_unlock (mux_adl);
14913 }
14914
14915 #endif // HAVE_HWMON
14916
14917 #ifdef DEBUG
14918 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14919 #endif
14920
14921 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14922
14923 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14924 {
14925 /**
14926 * host buffer
14927 */
14928
14929 hc_device_param_t *device_param = &data.devices_param[device_id];
14930
14931 if (device_param->skipped) continue;
14932
14933 /**
14934 * device properties
14935 */
14936
14937 const char *device_name_chksum = device_param->device_name_chksum;
14938 const u32 device_processors = device_param->device_processors;
14939 const u32 device_processor_cores = device_param->device_processor_cores;
14940
14941 /**
14942 * create context for each device
14943 */
14944
14945 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14946
14947 /**
14948 * create command-queue
14949 */
14950
14951 // not supported with NV
14952 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14953
14954 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14955
14956 /**
14957 * kernel threads: some algorithms need a fixed kernel-threads count
14958 * because of shared memory usage or bitslice
14959 * there needs to be some upper limit, otherwise there's too much overhead
14960 */
14961
14962 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14963
14964 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14965 {
14966 kernel_threads = KERNEL_THREADS_MAX_CPU;
14967 }
14968
14969 if (hash_mode == 1500) kernel_threads = 64; // DES
14970 if (hash_mode == 3000) kernel_threads = 64; // DES
14971 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14972 if (hash_mode == 7500) kernel_threads = 64; // RC4
14973 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14974 if (hash_mode == 9700) kernel_threads = 64; // RC4
14975 if (hash_mode == 9710) kernel_threads = 64; // RC4
14976 if (hash_mode == 9800) kernel_threads = 64; // RC4
14977 if (hash_mode == 9810) kernel_threads = 64; // RC4
14978 if (hash_mode == 10400) kernel_threads = 64; // RC4
14979 if (hash_mode == 10410) kernel_threads = 64; // RC4
14980 if (hash_mode == 10500) kernel_threads = 64; // RC4
14981 if (hash_mode == 13100) kernel_threads = 64; // RC4
14982
14983 device_param->kernel_threads = kernel_threads;
14984
14985 device_param->hardware_power = device_processors * kernel_threads;
14986
14987 /**
14988 * create input buffers on device : calculate size of fixed memory buffers
14989 */
14990
14991 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14992 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14993
14994 device_param->size_root_css = size_root_css;
14995 device_param->size_markov_css = size_markov_css;
14996
14997 size_t size_results = sizeof (uint);
14998
14999 device_param->size_results = size_results;
15000
15001 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
15002 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
15003
15004 size_t size_plains = digests_cnt * sizeof (plain_t);
15005 size_t size_salts = salts_cnt * sizeof (salt_t);
15006 size_t size_esalts = salts_cnt * esalt_size;
15007
15008 device_param->size_plains = size_plains;
15009 device_param->size_digests = size_digests;
15010 device_param->size_shown = size_shown;
15011 device_param->size_salts = size_salts;
15012
15013 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
15014 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
15015 size_t size_tm = 32 * sizeof (bs_word_t);
15016
15017 // scryptV stuff
15018
15019 size_t size_scryptV = 1;
15020
15021 if ((hash_mode == 8900) || (hash_mode == 9300))
15022 {
15023 uint tmto_start = 0;
15024 uint tmto_stop = 10;
15025
15026 if (scrypt_tmto)
15027 {
15028 tmto_start = scrypt_tmto;
15029 }
15030 else
15031 {
15032 // in case the user did not specify the tmto manually
15033 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
15034 // but set the lower end only in case the user has a device with too less memory
15035
15036 if (hash_mode == 8900)
15037 {
15038 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15039 {
15040 tmto_start = 1;
15041 }
15042 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15043 {
15044 tmto_start = 2;
15045 }
15046 }
15047 else if (hash_mode == 9300)
15048 {
15049 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15050 {
15051 tmto_start = 2;
15052 }
15053 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15054 {
15055 tmto_start = 2;
15056 }
15057 }
15058 }
15059
15060 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
15061 {
15062 // TODO: in theory the following calculation needs to be done per salt, not global
15063 // we assume all hashes have the same scrypt settings
15064
15065 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
15066
15067 size_scryptV /= 1 << tmto;
15068
15069 size_scryptV *= device_processors * device_processor_cores;
15070
15071 if (size_scryptV > device_param->device_maxmem_alloc)
15072 {
15073 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15074
15075 continue;
15076 }
15077
15078 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
15079 {
15080 data.salts_buf[salts_pos].scrypt_tmto = tmto;
15081 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
15082 }
15083
15084 break;
15085 }
15086
15087 if (data.salts_buf[0].scrypt_phy == 0)
15088 {
15089 log_error ("ERROR: can't allocate enough device memory");
15090
15091 return -1;
15092 }
15093
15094 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
15095 }
15096
15097 /**
15098 * some algorithms need a fixed kernel-loops count
15099 */
15100
15101 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15102 {
15103 const u32 kernel_loops_fixed = 1024;
15104
15105 device_param->kernel_loops_min = kernel_loops_fixed;
15106 device_param->kernel_loops_max = kernel_loops_fixed;
15107 }
15108
15109 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15110 {
15111 const u32 kernel_loops_fixed = 1024;
15112
15113 device_param->kernel_loops_min = kernel_loops_fixed;
15114 device_param->kernel_loops_max = kernel_loops_fixed;
15115 }
15116
15117 if (hash_mode == 8900)
15118 {
15119 const u32 kernel_loops_fixed = 1;
15120
15121 device_param->kernel_loops_min = kernel_loops_fixed;
15122 device_param->kernel_loops_max = kernel_loops_fixed;
15123 }
15124
15125 if (hash_mode == 9300)
15126 {
15127 const u32 kernel_loops_fixed = 1;
15128
15129 device_param->kernel_loops_min = kernel_loops_fixed;
15130 device_param->kernel_loops_max = kernel_loops_fixed;
15131 }
15132
15133 if (hash_mode == 12500)
15134 {
15135 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15136
15137 device_param->kernel_loops_min = kernel_loops_fixed;
15138 device_param->kernel_loops_max = kernel_loops_fixed;
15139 }
15140
15141 /**
15142 * some algorithms have a maximum kernel-loops count
15143 */
15144
15145 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15146 {
15147 u32 innerloop_cnt = 0;
15148
15149 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15150 {
15151 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15152 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15153 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15154 }
15155 else
15156 {
15157 innerloop_cnt = data.salts_buf[0].salt_iter;
15158 }
15159
15160 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15161 (innerloop_cnt <= device_param->kernel_loops_max))
15162 {
15163 device_param->kernel_loops_max = innerloop_cnt;
15164 }
15165 }
15166
15167 u32 kernel_accel_min = device_param->kernel_accel_min;
15168 u32 kernel_accel_max = device_param->kernel_accel_max;
15169
15170 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15171
15172 size_t size_pws = 4;
15173 size_t size_tmps = 4;
15174 size_t size_hooks = 4;
15175
15176 while (kernel_accel_max >= kernel_accel_min)
15177 {
15178 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15179
15180 // size_pws
15181
15182 size_pws = kernel_power_max * sizeof (pw_t);
15183
15184 // size_tmps
15185
15186 switch (hash_mode)
15187 {
15188 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15189 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15190 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15191 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15192 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15193 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15194 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15195 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15196 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15197 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15198 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15199 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15200 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15201 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15202 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15203 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15204 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15205 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15206 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15207 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15208 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15209 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15210 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15211 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
15212 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
15213 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
15214 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
15215 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
15216 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15217 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15218 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
15219 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
15220 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15221 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
15222 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15223 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
15224 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
15225 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15226 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15227 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
15228 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
15229 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
15230 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15231 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
15232 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
15233 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
15234 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
15235 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15236 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
15237 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
15238 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
15239 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15240 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15241 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
15242 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
15243 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
15244 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
15245 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
15246 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15247 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15248 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15249 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
15250 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
15251 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15252 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15253 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15254 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15255 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15256 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15257 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15258 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15259 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15260 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15261 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15262 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15263 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15264 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15265 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15266 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15267 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15268 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15269 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15270 };
15271
15272 // size_hooks
15273
15274 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15275 {
15276 switch (hash_mode)
15277 {
15278 }
15279 }
15280
15281 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15282 // if not, decrease amplifier and try again
15283
15284 int skip = 0;
15285
15286 const u64 size_total
15287 = bitmap_size
15288 + bitmap_size
15289 + bitmap_size
15290 + bitmap_size
15291 + bitmap_size
15292 + bitmap_size
15293 + bitmap_size
15294 + bitmap_size
15295 + size_bfs
15296 + size_combs
15297 + size_digests
15298 + size_esalts
15299 + size_hooks
15300 + size_markov_css
15301 + size_plains
15302 + size_pws
15303 + size_pws // not a bug
15304 + size_results
15305 + size_root_css
15306 + size_rules
15307 + size_rules_c
15308 + size_salts
15309 + size_scryptV
15310 + size_shown
15311 + size_tm
15312 + size_tmps;
15313
15314 // Don't ask me, ask AMD!
15315
15316 if (size_total > device_param->device_maxmem_alloc) skip = 1;
15317 if (size_total > device_param->device_global_mem) skip = 1;
15318
15319 if (skip == 1)
15320 {
15321 kernel_accel_max--;
15322
15323 continue;
15324 }
15325
15326 break;
15327 }
15328
15329 /*
15330 if (kernel_accel_max == 0)
15331 {
15332 log_error ("- Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
15333
15334 return -1;
15335 }
15336 */
15337
15338 device_param->kernel_accel_min = kernel_accel_min;
15339 device_param->kernel_accel_max = kernel_accel_max;
15340
15341 /*
15342 if (kernel_accel_max < kernel_accel)
15343 {
15344 if (quiet == 0) log_info ("- Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
15345
15346 device_param->kernel_accel = kernel_accel_max;
15347 }
15348 */
15349
15350 device_param->size_bfs = size_bfs;
15351 device_param->size_combs = size_combs;
15352 device_param->size_rules = size_rules;
15353 device_param->size_rules_c = size_rules_c;
15354 device_param->size_pws = size_pws;
15355 device_param->size_tmps = size_tmps;
15356 device_param->size_hooks = size_hooks;
15357
15358 /**
15359 * default building options
15360 */
15361
15362 char build_opts[1024] = { 0 };
15363
15364 // we don't have sm_* on vendors not NV but it doesn't matter
15365
15366 #if _WIN
15367 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\\OpenCL\\\" -I '%s\\OpenCL\\' -I %s\\OpenCL\\ -I\"%s\\OpenCL\\\" -I'%s\\OpenCL\\' -I%s\\OpenCL\\", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
15368 #else
15369 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s/OpenCL/\" -I '%s/OpenCL/' -I %s/OpenCL/ -I\"%s/OpenCL/\" -I'%s/OpenCL/' -I%s/OpenCL/", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
15370 #endif
15371
15372 char build_opts_new[1024] = { 0 };
15373
15374 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u -DKERN_TYPE=%u -D_unroll -cl-std=CL1.1", build_opts, device_param->device_vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type);
15375
15376 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
15377
15378 /*
15379 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
15380 {
15381 // we do vectorizing much better than the auto-vectorizer
15382
15383 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
15384
15385 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
15386 }
15387 */
15388
15389 #ifdef DEBUG
15390 log_info ("- Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15391 #endif
15392
15393 /**
15394 * main kernel
15395 */
15396
15397 {
15398 /**
15399 * kernel source filename
15400 */
15401
15402 char source_file[256] = { 0 };
15403
15404 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15405
15406 struct stat sst;
15407
15408 if (stat (source_file, &sst) == -1)
15409 {
15410 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15411
15412 return -1;
15413 }
15414
15415 /**
15416 * kernel cached filename
15417 */
15418
15419 char cached_file[256] = { 0 };
15420
15421 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15422
15423 int cached = 1;
15424
15425 struct stat cst;
15426
15427 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15428 {
15429 cached = 0;
15430 }
15431
15432 /**
15433 * kernel compile or load
15434 */
15435
15436 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15437
15438 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15439
15440 if (force_jit_compilation == -1)
15441 {
15442 if (cached == 0)
15443 {
15444 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));
15445
15446 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15447
15448 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15449
15450 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15451
15452 #ifdef DEBUG
15453 size_t build_log_size = 0;
15454
15455 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15456
15457 if (build_log_size > 1)
15458 {
15459 char *build_log = (char *) malloc (build_log_size + 1);
15460
15461 memset (build_log, 0, build_log_size + 1);
15462
15463 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15464
15465 puts (build_log);
15466
15467 free (build_log);
15468 }
15469 #endif
15470
15471 if (rc != 0)
15472 {
15473 device_param->skipped = true;
15474
15475 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15476
15477 continue;
15478 }
15479
15480 size_t binary_size;
15481
15482 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15483
15484 u8 *binary = (u8 *) mymalloc (binary_size);
15485
15486 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15487
15488 writeProgramBin (cached_file, binary, binary_size);
15489
15490 local_free (binary);
15491 }
15492 else
15493 {
15494 #ifdef DEBUG
15495 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15496 #endif
15497
15498 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15499
15500 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15501
15502 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15503 }
15504 }
15505 else
15506 {
15507 #ifdef DEBUG
15508 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15509 #endif
15510
15511 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15512
15513 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15514
15515 char build_opts_update[1024] = { 0 };
15516
15517 if (force_jit_compilation == 1500)
15518 {
15519 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15520 }
15521 else if (force_jit_compilation == 8900)
15522 {
15523 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);
15524 }
15525 else
15526 {
15527 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15528 }
15529
15530 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15531
15532 #ifdef DEBUG
15533 size_t build_log_size = 0;
15534
15535 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15536
15537 if (build_log_size > 1)
15538 {
15539 char *build_log = (char *) malloc (build_log_size + 1);
15540
15541 memset (build_log, 0, build_log_size + 1);
15542
15543 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15544
15545 puts (build_log);
15546
15547 free (build_log);
15548 }
15549 #endif
15550
15551 if (rc != 0)
15552 {
15553 device_param->skipped = true;
15554
15555 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15556 }
15557 }
15558
15559 local_free (kernel_lengths);
15560 local_free (kernel_sources[0]);
15561 local_free (kernel_sources);
15562 }
15563
15564 /**
15565 * word generator kernel
15566 */
15567
15568 if (attack_mode != ATTACK_MODE_STRAIGHT)
15569 {
15570 /**
15571 * kernel mp source filename
15572 */
15573
15574 char source_file[256] = { 0 };
15575
15576 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15577
15578 struct stat sst;
15579
15580 if (stat (source_file, &sst) == -1)
15581 {
15582 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15583
15584 return -1;
15585 }
15586
15587 /**
15588 * kernel mp cached filename
15589 */
15590
15591 char cached_file[256] = { 0 };
15592
15593 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15594
15595 int cached = 1;
15596
15597 struct stat cst;
15598
15599 if (stat (cached_file, &cst) == -1)
15600 {
15601 cached = 0;
15602 }
15603
15604 /**
15605 * kernel compile or load
15606 */
15607
15608 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15609
15610 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15611
15612 if (cached == 0)
15613 {
15614 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));
15615 if (quiet == 0) log_info ("");
15616
15617 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15618
15619 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15620
15621 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15622
15623 if (rc != 0)
15624 {
15625 device_param->skipped = true;
15626
15627 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15628
15629 continue;
15630 }
15631
15632 size_t binary_size;
15633
15634 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15635
15636 u8 *binary = (u8 *) mymalloc (binary_size);
15637
15638 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15639
15640 writeProgramBin (cached_file, binary, binary_size);
15641
15642 local_free (binary);
15643 }
15644 else
15645 {
15646 #ifdef DEBUG
15647 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15648 #endif
15649
15650 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15651
15652 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15653
15654 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15655 }
15656
15657 local_free (kernel_lengths);
15658 local_free (kernel_sources[0]);
15659 local_free (kernel_sources);
15660 }
15661
15662 /**
15663 * amplifier kernel
15664 */
15665
15666 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15667 {
15668
15669 }
15670 else
15671 {
15672 /**
15673 * kernel amp source filename
15674 */
15675
15676 char source_file[256] = { 0 };
15677
15678 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15679
15680 struct stat sst;
15681
15682 if (stat (source_file, &sst) == -1)
15683 {
15684 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15685
15686 return -1;
15687 }
15688
15689 /**
15690 * kernel amp cached filename
15691 */
15692
15693 char cached_file[256] = { 0 };
15694
15695 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15696
15697 int cached = 1;
15698
15699 struct stat cst;
15700
15701 if (stat (cached_file, &cst) == -1)
15702 {
15703 cached = 0;
15704 }
15705
15706 /**
15707 * kernel compile or load
15708 */
15709
15710 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15711
15712 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15713
15714 if (cached == 0)
15715 {
15716 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));
15717 if (quiet == 0) log_info ("");
15718
15719 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15720
15721 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15722
15723 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15724
15725 if (rc != 0)
15726 {
15727 device_param->skipped = true;
15728
15729 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15730
15731 continue;
15732 }
15733
15734 size_t binary_size;
15735
15736 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15737
15738 u8 *binary = (u8 *) mymalloc (binary_size);
15739
15740 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15741
15742 writeProgramBin (cached_file, binary, binary_size);
15743
15744 local_free (binary);
15745 }
15746 else
15747 {
15748 #ifdef DEBUG
15749 if (quiet == 0) log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15750 #endif
15751
15752 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15753
15754 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15755
15756 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15757 }
15758
15759 local_free (kernel_lengths);
15760 local_free (kernel_sources[0]);
15761 local_free (kernel_sources);
15762 }
15763
15764 // some algorithm collide too fast, make that impossible
15765
15766 if (benchmark == 1)
15767 {
15768 ((uint *) digests_buf)[0] = -1;
15769 ((uint *) digests_buf)[1] = -1;
15770 ((uint *) digests_buf)[2] = -1;
15771 ((uint *) digests_buf)[3] = -1;
15772 }
15773
15774 /**
15775 * global buffers
15776 */
15777
15778 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15779 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15780 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15781 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15782 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15783 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15784 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15785 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15786 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15787 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15788 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15789 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15790 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15791 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15792 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15793 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15794 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15795 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15796
15797 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);
15798 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);
15799 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);
15800 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);
15801 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);
15802 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);
15803 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);
15804 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);
15805 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15806 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15807 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15808
15809 /**
15810 * special buffers
15811 */
15812
15813 if (attack_kern == ATTACK_KERN_STRAIGHT)
15814 {
15815 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15816 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15817
15818 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15819 }
15820 else if (attack_kern == ATTACK_KERN_COMBI)
15821 {
15822 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15823 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15824 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15825 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15826 }
15827 else if (attack_kern == ATTACK_KERN_BF)
15828 {
15829 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15830 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15831 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15832 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15833 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15834 }
15835
15836 if (size_esalts)
15837 {
15838 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15839
15840 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15841 }
15842
15843 /**
15844 * main host data
15845 */
15846
15847 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15848
15849 device_param->pws_buf = pws_buf;
15850
15851 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15852
15853 device_param->combs_buf = combs_buf;
15854
15855 void *hooks_buf = mymalloc (size_hooks);
15856
15857 device_param->hooks_buf = hooks_buf;
15858
15859 /**
15860 * kernel args
15861 */
15862
15863 device_param->kernel_params_buf32[21] = bitmap_mask;
15864 device_param->kernel_params_buf32[22] = bitmap_shift1;
15865 device_param->kernel_params_buf32[23] = bitmap_shift2;
15866 device_param->kernel_params_buf32[24] = 0; // salt_pos
15867 device_param->kernel_params_buf32[25] = 0; // loop_pos
15868 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15869 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15870 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15871 device_param->kernel_params_buf32[29] = 0; // digests_offset
15872 device_param->kernel_params_buf32[30] = 0; // combs_mode
15873 device_param->kernel_params_buf32[31] = 0; // gid_max
15874
15875 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15876 ? &device_param->d_pws_buf
15877 : &device_param->d_pws_amp_buf;
15878 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15879 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15880 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15881 device_param->kernel_params[ 4] = &device_param->d_tmps;
15882 device_param->kernel_params[ 5] = &device_param->d_hooks;
15883 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15884 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15885 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15886 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15887 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15888 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15889 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15890 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15891 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15892 device_param->kernel_params[15] = &device_param->d_digests_buf;
15893 device_param->kernel_params[16] = &device_param->d_digests_shown;
15894 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15895 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15896 device_param->kernel_params[19] = &device_param->d_result;
15897 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15898 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15899 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15900 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15901 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15902 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15903 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15904 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15905 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15906 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15907 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15908 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15909
15910 device_param->kernel_params_mp_buf64[3] = 0;
15911 device_param->kernel_params_mp_buf32[4] = 0;
15912 device_param->kernel_params_mp_buf32[5] = 0;
15913 device_param->kernel_params_mp_buf32[6] = 0;
15914 device_param->kernel_params_mp_buf32[7] = 0;
15915 device_param->kernel_params_mp_buf32[8] = 0;
15916
15917 device_param->kernel_params_mp[0] = NULL;
15918 device_param->kernel_params_mp[1] = NULL;
15919 device_param->kernel_params_mp[2] = NULL;
15920 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15921 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15922 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15923 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15924 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15925 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15926
15927 device_param->kernel_params_mp_l_buf64[3] = 0;
15928 device_param->kernel_params_mp_l_buf32[4] = 0;
15929 device_param->kernel_params_mp_l_buf32[5] = 0;
15930 device_param->kernel_params_mp_l_buf32[6] = 0;
15931 device_param->kernel_params_mp_l_buf32[7] = 0;
15932 device_param->kernel_params_mp_l_buf32[8] = 0;
15933 device_param->kernel_params_mp_l_buf32[9] = 0;
15934
15935 device_param->kernel_params_mp_l[0] = NULL;
15936 device_param->kernel_params_mp_l[1] = NULL;
15937 device_param->kernel_params_mp_l[2] = NULL;
15938 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15939 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15940 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15941 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15942 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15943 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15944 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15945
15946 device_param->kernel_params_mp_r_buf64[3] = 0;
15947 device_param->kernel_params_mp_r_buf32[4] = 0;
15948 device_param->kernel_params_mp_r_buf32[5] = 0;
15949 device_param->kernel_params_mp_r_buf32[6] = 0;
15950 device_param->kernel_params_mp_r_buf32[7] = 0;
15951 device_param->kernel_params_mp_r_buf32[8] = 0;
15952
15953 device_param->kernel_params_mp_r[0] = NULL;
15954 device_param->kernel_params_mp_r[1] = NULL;
15955 device_param->kernel_params_mp_r[2] = NULL;
15956 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15957 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15958 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15959 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15960 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15961 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15962
15963 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15964 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15965
15966 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15967 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15968 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15969 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15970 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15971 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15972 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15973
15974 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15975 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15976
15977 device_param->kernel_params_memset_buf32[1] = 0; // value
15978 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15979
15980 device_param->kernel_params_memset[0] = NULL;
15981 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15982 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15983
15984 /**
15985 * kernel name
15986 */
15987
15988 size_t kernel_wgs_tmp;
15989
15990 char kernel_name[64] = { 0 };
15991
15992 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15993 {
15994 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15995 {
15996 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15997
15998 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15999
16000 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
16001
16002 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16003
16004 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
16005
16006 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16007 }
16008 else
16009 {
16010 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
16011
16012 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16013
16014 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
16015
16016 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16017
16018 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
16019
16020 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16021 }
16022
16023 if (data.attack_mode == ATTACK_MODE_BF)
16024 {
16025 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16026 {
16027 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
16028
16029 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16030
16031 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);
16032 }
16033 }
16034 }
16035 else
16036 {
16037 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
16038
16039 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16040
16041 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
16042
16043 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16044
16045 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
16046
16047 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16048
16049 if (opts_type & OPTS_TYPE_HOOK12)
16050 {
16051 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
16052
16053 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16054
16055 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);
16056 }
16057
16058 if (opts_type & OPTS_TYPE_HOOK23)
16059 {
16060 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
16061
16062 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16063
16064 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);
16065 }
16066 }
16067
16068 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);
16069 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);
16070 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);
16071
16072 for (uint i = 0; i <= 20; i++)
16073 {
16074 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
16075 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
16076 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
16077
16078 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
16079 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
16080 }
16081
16082 for (uint i = 21; i <= 31; i++)
16083 {
16084 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
16085 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
16086 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
16087
16088 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
16089 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
16090 }
16091
16092 // GPU memset
16093
16094 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
16095
16096 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);
16097
16098 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
16099 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
16100 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
16101
16102 // MP start
16103
16104 if (attack_mode == ATTACK_MODE_BF)
16105 {
16106 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
16107 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
16108
16109 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);
16110 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);
16111
16112 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16113 {
16114 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
16115 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
16116 }
16117 }
16118 else if (attack_mode == ATTACK_MODE_HYBRID1)
16119 {
16120 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16121
16122 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);
16123 }
16124 else if (attack_mode == ATTACK_MODE_HYBRID2)
16125 {
16126 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16127
16128 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);
16129 }
16130
16131 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16132 {
16133 // nothing to do
16134 }
16135 else
16136 {
16137 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
16138
16139 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);
16140 }
16141
16142 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16143 {
16144 // nothing to do
16145 }
16146 else
16147 {
16148 for (uint i = 0; i < 5; i++)
16149 {
16150 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
16151 }
16152
16153 for (uint i = 5; i < 7; i++)
16154 {
16155 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
16156 }
16157 }
16158
16159 // maybe this has been updated by clGetKernelWorkGroupInfo()
16160 // value can only be decreased, so we don't need to reallocate buffers
16161
16162 device_param->kernel_threads = kernel_threads;
16163
16164 // zero some data buffers
16165
16166 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
16167 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
16168 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
16169 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
16170 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
16171 run_kernel_bzero (device_param, device_param->d_result, size_results);
16172
16173 /**
16174 * special buffers
16175 */
16176
16177 if (attack_kern == ATTACK_KERN_STRAIGHT)
16178 {
16179 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
16180 }
16181 else if (attack_kern == ATTACK_KERN_COMBI)
16182 {
16183 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
16184 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
16185 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16186 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16187 }
16188 else if (attack_kern == ATTACK_KERN_BF)
16189 {
16190 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
16191 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
16192 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
16193 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16194 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16195 }
16196
16197 #if defined(HAVE_HWMON)
16198
16199 /**
16200 * Store initial fanspeed if gpu_temp_retain is enabled
16201 */
16202
16203 if (gpu_temp_disable == 0)
16204 {
16205 if (gpu_temp_retain != 0)
16206 {
16207 hc_thread_mutex_lock (mux_adl);
16208
16209 if (data.hm_device[device_id].fan_get_supported == 1)
16210 {
16211 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
16212 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
16213
16214 temp_retain_fanspeed_value[device_id] = fanspeed;
16215 temp_retain_fanpolicy_value[device_id] = fanpolicy;
16216
16217 // we also set it to tell the OS we take control over the fan and it's automatic controller
16218 // if it was set to automatic. we do not control user-defined fanspeeds.
16219
16220 if (fanpolicy == 1)
16221 {
16222 data.hm_device[device_id].fan_set_supported = 1;
16223
16224 int rc = -1;
16225
16226 if (device_param->device_vendor_id == VENDOR_ID_AMD)
16227 {
16228 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
16229 }
16230 else if (device_param->device_vendor_id == VENDOR_ID_NV)
16231 {
16232 #ifdef LINUX
16233 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE);
16234 #endif
16235
16236 #ifdef WIN
16237 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
16238 #endif
16239 }
16240
16241 if (rc == 0)
16242 {
16243 data.hm_device[device_id].fan_set_supported = 1;
16244 }
16245 else
16246 {
16247 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
16248
16249 data.hm_device[device_id].fan_set_supported = 0;
16250 }
16251 }
16252 else
16253 {
16254 data.hm_device[device_id].fan_set_supported = 0;
16255 }
16256 }
16257
16258 hc_thread_mutex_unlock (mux_adl);
16259 }
16260 }
16261
16262 #endif // HAVE_HWMON
16263 }
16264
16265 if (data.quiet == 0) log_info_nn ("");
16266
16267 /**
16268 * In benchmark-mode, inform user which algorithm is checked
16269 */
16270
16271 if (benchmark == 1)
16272 {
16273 if (machine_readable == 0)
16274 {
16275 quiet = 0;
16276
16277 data.quiet = quiet;
16278
16279 char *hash_type = strhashtype (data.hash_mode); // not a bug
16280
16281 log_info ("Hashtype: %s", hash_type);
16282 log_info ("");
16283 }
16284 }
16285
16286 /**
16287 * keep track of the progress
16288 */
16289
16290 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16291 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16292 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16293
16294 /**
16295 * open filehandles
16296 */
16297
16298 #if _WIN
16299 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
16300 {
16301 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
16302
16303 return (-1);
16304 }
16305
16306 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
16307 {
16308 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
16309
16310 return (-1);
16311 }
16312
16313 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
16314 {
16315 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
16316
16317 return (-1);
16318 }
16319 #endif
16320
16321 /**
16322 * dictionary pad
16323 */
16324
16325 segment_size *= (1024 * 1024);
16326
16327 data.segment_size = segment_size;
16328
16329 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
16330
16331 wl_data->buf = (char *) mymalloc (segment_size);
16332 wl_data->avail = segment_size;
16333 wl_data->incr = segment_size;
16334 wl_data->cnt = 0;
16335 wl_data->pos = 0;
16336
16337 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
16338
16339 data.wordlist_mode = wordlist_mode;
16340
16341 cs_t *css_buf = NULL;
16342 uint css_cnt = 0;
16343 uint dictcnt = 0;
16344 uint maskcnt = 1;
16345 char **masks = NULL;
16346 char **dictfiles = NULL;
16347
16348 uint mask_from_file = 0;
16349
16350 if (attack_mode == ATTACK_MODE_STRAIGHT)
16351 {
16352 if (wordlist_mode == WL_MODE_FILE)
16353 {
16354 int wls_left = myargc - (optind + 1);
16355
16356 for (int i = 0; i < wls_left; i++)
16357 {
16358 char *l0_filename = myargv[optind + 1 + i];
16359
16360 struct stat l0_stat;
16361
16362 if (stat (l0_filename, &l0_stat) == -1)
16363 {
16364 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
16365
16366 return (-1);
16367 }
16368
16369 uint is_dir = S_ISDIR (l0_stat.st_mode);
16370
16371 if (is_dir == 0)
16372 {
16373 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16374
16375 dictcnt++;
16376
16377 dictfiles[dictcnt - 1] = l0_filename;
16378 }
16379 else
16380 {
16381 // do not allow --keyspace w/ a directory
16382
16383 if (keyspace == 1)
16384 {
16385 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16386
16387 return (-1);
16388 }
16389
16390 char **dictionary_files = NULL;
16391
16392 dictionary_files = scan_directory (l0_filename);
16393
16394 if (dictionary_files != NULL)
16395 {
16396 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16397
16398 for (int d = 0; dictionary_files[d] != NULL; d++)
16399 {
16400 char *l1_filename = dictionary_files[d];
16401
16402 struct stat l1_stat;
16403
16404 if (stat (l1_filename, &l1_stat) == -1)
16405 {
16406 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16407
16408 return (-1);
16409 }
16410
16411 if (S_ISREG (l1_stat.st_mode))
16412 {
16413 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16414
16415 dictcnt++;
16416
16417 dictfiles[dictcnt - 1] = strdup (l1_filename);
16418 }
16419 }
16420 }
16421
16422 local_free (dictionary_files);
16423 }
16424 }
16425
16426 if (dictcnt < 1)
16427 {
16428 log_error ("ERROR: No usable dictionary file found.");
16429
16430 return (-1);
16431 }
16432 }
16433 else if (wordlist_mode == WL_MODE_STDIN)
16434 {
16435 dictcnt = 1;
16436 }
16437 }
16438 else if (attack_mode == ATTACK_MODE_COMBI)
16439 {
16440 // display
16441
16442 char *dictfile1 = myargv[optind + 1 + 0];
16443 char *dictfile2 = myargv[optind + 1 + 1];
16444
16445 // find the bigger dictionary and use as base
16446
16447 FILE *fp1 = NULL;
16448 FILE *fp2 = NULL;
16449
16450 struct stat tmp_stat;
16451
16452 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16453 {
16454 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16455
16456 return (-1);
16457 }
16458
16459 if (stat (dictfile1, &tmp_stat) == -1)
16460 {
16461 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16462
16463 fclose (fp1);
16464
16465 return (-1);
16466 }
16467
16468 if (S_ISDIR (tmp_stat.st_mode))
16469 {
16470 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16471
16472 fclose (fp1);
16473
16474 return (-1);
16475 }
16476
16477 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16478 {
16479 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16480
16481 fclose (fp1);
16482
16483 return (-1);
16484 }
16485
16486 if (stat (dictfile2, &tmp_stat) == -1)
16487 {
16488 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16489
16490 fclose (fp1);
16491 fclose (fp2);
16492
16493 return (-1);
16494 }
16495
16496 if (S_ISDIR (tmp_stat.st_mode))
16497 {
16498 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16499
16500 fclose (fp1);
16501 fclose (fp2);
16502
16503 return (-1);
16504 }
16505
16506 data.combs_cnt = 1;
16507
16508 data.quiet = 1;
16509
16510 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16511
16512 data.quiet = quiet;
16513
16514 if (words1_cnt == 0)
16515 {
16516 log_error ("ERROR: %s: empty file", dictfile1);
16517
16518 fclose (fp1);
16519 fclose (fp2);
16520
16521 return (-1);
16522 }
16523
16524 data.combs_cnt = 1;
16525
16526 data.quiet = 1;
16527
16528 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16529
16530 data.quiet = quiet;
16531
16532 if (words2_cnt == 0)
16533 {
16534 log_error ("ERROR: %s: empty file", dictfile2);
16535
16536 fclose (fp1);
16537 fclose (fp2);
16538
16539 return (-1);
16540 }
16541
16542 fclose (fp1);
16543 fclose (fp2);
16544
16545 data.dictfile = dictfile1;
16546 data.dictfile2 = dictfile2;
16547
16548 if (words1_cnt >= words2_cnt)
16549 {
16550 data.combs_cnt = words2_cnt;
16551 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16552
16553 dictfiles = &data.dictfile;
16554
16555 dictcnt = 1;
16556 }
16557 else
16558 {
16559 data.combs_cnt = words1_cnt;
16560 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16561
16562 dictfiles = &data.dictfile2;
16563
16564 dictcnt = 1;
16565
16566 // we also have to switch wordlist related rules!
16567
16568 char *tmpc = data.rule_buf_l;
16569
16570 data.rule_buf_l = data.rule_buf_r;
16571 data.rule_buf_r = tmpc;
16572
16573 int tmpi = data.rule_len_l;
16574
16575 data.rule_len_l = data.rule_len_r;
16576 data.rule_len_r = tmpi;
16577 }
16578 }
16579 else if (attack_mode == ATTACK_MODE_BF)
16580 {
16581 char *mask = NULL;
16582
16583 maskcnt = 0;
16584
16585 if (benchmark == 0)
16586 {
16587 mask = myargv[optind + 1];
16588
16589 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16590
16591 if ((optind + 2) <= myargc)
16592 {
16593 struct stat file_stat;
16594
16595 if (stat (mask, &file_stat) == -1)
16596 {
16597 maskcnt = 1;
16598
16599 masks[maskcnt - 1] = mystrdup (mask);
16600 }
16601 else
16602 {
16603 int wls_left = myargc - (optind + 1);
16604
16605 uint masks_avail = INCR_MASKS;
16606
16607 for (int i = 0; i < wls_left; i++)
16608 {
16609 if (i != 0)
16610 {
16611 mask = myargv[optind + 1 + i];
16612
16613 if (stat (mask, &file_stat) == -1)
16614 {
16615 log_error ("ERROR: %s: %s", mask, strerror (errno));
16616
16617 return (-1);
16618 }
16619 }
16620
16621 uint is_file = S_ISREG (file_stat.st_mode);
16622
16623 if (is_file == 1)
16624 {
16625 FILE *mask_fp;
16626
16627 if ((mask_fp = fopen (mask, "r")) == NULL)
16628 {
16629 log_error ("ERROR: %s: %s", mask, strerror (errno));
16630
16631 return (-1);
16632 }
16633
16634 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16635
16636 while (!feof (mask_fp))
16637 {
16638 memset (line_buf, 0, HCBUFSIZ);
16639
16640 int line_len = fgetl (mask_fp, line_buf);
16641
16642 if (line_len == 0) continue;
16643
16644 if (line_buf[0] == '#') continue;
16645
16646 if (masks_avail == maskcnt)
16647 {
16648 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16649
16650 masks_avail += INCR_MASKS;
16651 }
16652
16653 masks[maskcnt] = mystrdup (line_buf);
16654
16655 maskcnt++;
16656 }
16657
16658 myfree (line_buf);
16659
16660 fclose (mask_fp);
16661 }
16662 else
16663 {
16664 log_error ("ERROR: %s: unsupported file-type", mask);
16665
16666 return (-1);
16667 }
16668 }
16669
16670 mask_from_file = 1;
16671 }
16672 }
16673 else
16674 {
16675 custom_charset_1 = (char *) "?l?d?u";
16676 custom_charset_2 = (char *) "?l?d";
16677 custom_charset_3 = (char *) "?l?d*!$@_";
16678
16679 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16680 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16681 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16682
16683 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16684
16685 wordlist_mode = WL_MODE_MASK;
16686
16687 data.wordlist_mode = wordlist_mode;
16688
16689 increment = 1;
16690
16691 maskcnt = 1;
16692 }
16693 }
16694 else
16695 {
16696 /**
16697 * generate full masks and charsets
16698 */
16699
16700 masks = (char **) mymalloc (sizeof (char *));
16701
16702 switch (hash_mode)
16703 {
16704 case 1731: pw_min = 5;
16705 pw_max = 5;
16706 mask = mystrdup ("?b?b?b?b?b");
16707 break;
16708 case 12500: pw_min = 5;
16709 pw_max = 5;
16710 mask = mystrdup ("?b?b?b?b?b");
16711 break;
16712 default: pw_min = 7;
16713 pw_max = 7;
16714 mask = mystrdup ("?b?b?b?b?b?b?b");
16715 break;
16716 }
16717
16718 maskcnt = 1;
16719
16720 masks[maskcnt - 1] = mystrdup (mask);
16721
16722 wordlist_mode = WL_MODE_MASK;
16723
16724 data.wordlist_mode = wordlist_mode;
16725
16726 increment = 1;
16727 }
16728
16729 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16730
16731 if (increment)
16732 {
16733 if (increment_min > pw_min) pw_min = increment_min;
16734
16735 if (increment_max < pw_max) pw_max = increment_max;
16736 }
16737 }
16738 else if (attack_mode == ATTACK_MODE_HYBRID1)
16739 {
16740 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16741
16742 // display
16743
16744 char *mask = myargv[myargc - 1];
16745
16746 maskcnt = 0;
16747
16748 masks = (char **) mymalloc (1 * sizeof (char *));
16749
16750 // mod
16751
16752 struct stat file_stat;
16753
16754 if (stat (mask, &file_stat) == -1)
16755 {
16756 maskcnt = 1;
16757
16758 masks[maskcnt - 1] = mystrdup (mask);
16759 }
16760 else
16761 {
16762 uint is_file = S_ISREG (file_stat.st_mode);
16763
16764 if (is_file == 1)
16765 {
16766 FILE *mask_fp;
16767
16768 if ((mask_fp = fopen (mask, "r")) == NULL)
16769 {
16770 log_error ("ERROR: %s: %s", mask, strerror (errno));
16771
16772 return (-1);
16773 }
16774
16775 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16776
16777 uint masks_avail = 1;
16778
16779 while (!feof (mask_fp))
16780 {
16781 memset (line_buf, 0, HCBUFSIZ);
16782
16783 int line_len = fgetl (mask_fp, line_buf);
16784
16785 if (line_len == 0) continue;
16786
16787 if (line_buf[0] == '#') continue;
16788
16789 if (masks_avail == maskcnt)
16790 {
16791 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16792
16793 masks_avail += INCR_MASKS;
16794 }
16795
16796 masks[maskcnt] = mystrdup (line_buf);
16797
16798 maskcnt++;
16799 }
16800
16801 myfree (line_buf);
16802
16803 fclose (mask_fp);
16804
16805 mask_from_file = 1;
16806 }
16807 else
16808 {
16809 maskcnt = 1;
16810
16811 masks[maskcnt - 1] = mystrdup (mask);
16812 }
16813 }
16814
16815 // base
16816
16817 int wls_left = myargc - (optind + 2);
16818
16819 for (int i = 0; i < wls_left; i++)
16820 {
16821 char *filename = myargv[optind + 1 + i];
16822
16823 struct stat file_stat;
16824
16825 if (stat (filename, &file_stat) == -1)
16826 {
16827 log_error ("ERROR: %s: %s", filename, strerror (errno));
16828
16829 return (-1);
16830 }
16831
16832 uint is_dir = S_ISDIR (file_stat.st_mode);
16833
16834 if (is_dir == 0)
16835 {
16836 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16837
16838 dictcnt++;
16839
16840 dictfiles[dictcnt - 1] = filename;
16841 }
16842 else
16843 {
16844 // do not allow --keyspace w/ a directory
16845
16846 if (keyspace == 1)
16847 {
16848 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16849
16850 return (-1);
16851 }
16852
16853 char **dictionary_files = NULL;
16854
16855 dictionary_files = scan_directory (filename);
16856
16857 if (dictionary_files != NULL)
16858 {
16859 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16860
16861 for (int d = 0; dictionary_files[d] != NULL; d++)
16862 {
16863 char *l1_filename = dictionary_files[d];
16864
16865 struct stat l1_stat;
16866
16867 if (stat (l1_filename, &l1_stat) == -1)
16868 {
16869 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16870
16871 return (-1);
16872 }
16873
16874 if (S_ISREG (l1_stat.st_mode))
16875 {
16876 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16877
16878 dictcnt++;
16879
16880 dictfiles[dictcnt - 1] = strdup (l1_filename);
16881 }
16882 }
16883 }
16884
16885 local_free (dictionary_files);
16886 }
16887 }
16888
16889 if (dictcnt < 1)
16890 {
16891 log_error ("ERROR: No usable dictionary file found.");
16892
16893 return (-1);
16894 }
16895
16896 if (increment)
16897 {
16898 maskcnt = 0;
16899
16900 uint mask_min = increment_min; // we can't reject smaller masks here
16901 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16902
16903 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16904 {
16905 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16906
16907 if (cur_mask == NULL) break;
16908
16909 masks[maskcnt] = cur_mask;
16910
16911 maskcnt++;
16912
16913 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16914 }
16915 }
16916 }
16917 else if (attack_mode == ATTACK_MODE_HYBRID2)
16918 {
16919 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16920
16921 // display
16922
16923 char *mask = myargv[optind + 1 + 0];
16924
16925 maskcnt = 0;
16926
16927 masks = (char **) mymalloc (1 * sizeof (char *));
16928
16929 // mod
16930
16931 struct stat file_stat;
16932
16933 if (stat (mask, &file_stat) == -1)
16934 {
16935 maskcnt = 1;
16936
16937 masks[maskcnt - 1] = mystrdup (mask);
16938 }
16939 else
16940 {
16941 uint is_file = S_ISREG (file_stat.st_mode);
16942
16943 if (is_file == 1)
16944 {
16945 FILE *mask_fp;
16946
16947 if ((mask_fp = fopen (mask, "r")) == NULL)
16948 {
16949 log_error ("ERROR: %s: %s", mask, strerror (errno));
16950
16951 return (-1);
16952 }
16953
16954 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16955
16956 uint masks_avail = 1;
16957
16958 while (!feof (mask_fp))
16959 {
16960 memset (line_buf, 0, HCBUFSIZ);
16961
16962 int line_len = fgetl (mask_fp, line_buf);
16963
16964 if (line_len == 0) continue;
16965
16966 if (line_buf[0] == '#') continue;
16967
16968 if (masks_avail == maskcnt)
16969 {
16970 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16971
16972 masks_avail += INCR_MASKS;
16973 }
16974
16975 masks[maskcnt] = mystrdup (line_buf);
16976
16977 maskcnt++;
16978 }
16979
16980 myfree (line_buf);
16981
16982 fclose (mask_fp);
16983
16984 mask_from_file = 1;
16985 }
16986 else
16987 {
16988 maskcnt = 1;
16989
16990 masks[maskcnt - 1] = mystrdup (mask);
16991 }
16992 }
16993
16994 // base
16995
16996 int wls_left = myargc - (optind + 2);
16997
16998 for (int i = 0; i < wls_left; i++)
16999 {
17000 char *filename = myargv[optind + 2 + i];
17001
17002 struct stat file_stat;
17003
17004 if (stat (filename, &file_stat) == -1)
17005 {
17006 log_error ("ERROR: %s: %s", filename, strerror (errno));
17007
17008 return (-1);
17009 }
17010
17011 uint is_dir = S_ISDIR (file_stat.st_mode);
17012
17013 if (is_dir == 0)
17014 {
17015 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17016
17017 dictcnt++;
17018
17019 dictfiles[dictcnt - 1] = filename;
17020 }
17021 else
17022 {
17023 // do not allow --keyspace w/ a directory
17024
17025 if (keyspace == 1)
17026 {
17027 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
17028
17029 return (-1);
17030 }
17031
17032 char **dictionary_files = NULL;
17033
17034 dictionary_files = scan_directory (filename);
17035
17036 if (dictionary_files != NULL)
17037 {
17038 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17039
17040 for (int d = 0; dictionary_files[d] != NULL; d++)
17041 {
17042 char *l1_filename = dictionary_files[d];
17043
17044 struct stat l1_stat;
17045
17046 if (stat (l1_filename, &l1_stat) == -1)
17047 {
17048 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17049
17050 return (-1);
17051 }
17052
17053 if (S_ISREG (l1_stat.st_mode))
17054 {
17055 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17056
17057 dictcnt++;
17058
17059 dictfiles[dictcnt - 1] = strdup (l1_filename);
17060 }
17061 }
17062 }
17063
17064 local_free (dictionary_files);
17065 }
17066 }
17067
17068 if (dictcnt < 1)
17069 {
17070 log_error ("ERROR: No usable dictionary file found.");
17071
17072 return (-1);
17073 }
17074
17075 if (increment)
17076 {
17077 maskcnt = 0;
17078
17079 uint mask_min = increment_min; // we can't reject smaller masks here
17080 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17081
17082 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17083 {
17084 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17085
17086 if (cur_mask == NULL) break;
17087
17088 masks[maskcnt] = cur_mask;
17089
17090 maskcnt++;
17091
17092 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17093 }
17094 }
17095 }
17096
17097 data.pw_min = pw_min;
17098 data.pw_max = pw_max;
17099
17100 /**
17101 * weak hash check
17102 */
17103
17104 if (weak_hash_threshold >= salts_cnt)
17105 {
17106 hc_device_param_t *device_param = NULL;
17107
17108 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17109 {
17110 device_param = &data.devices_param[device_id];
17111
17112 if (device_param->skipped) continue;
17113
17114 break;
17115 }
17116
17117 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
17118
17119 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
17120 {
17121 weak_hash_check (device_param, salt_pos);
17122 }
17123
17124 // Display hack, guarantee that there is at least one \r before real start
17125
17126 //if (data.quiet == 0) log_info ("");
17127 }
17128
17129 /**
17130 * status and monitor threads
17131 */
17132
17133 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
17134
17135 uint i_threads_cnt = 0;
17136
17137 hc_thread_t *i_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17138
17139 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17140 {
17141 if (stdout_flag == 0)
17142 {
17143 hc_thread_create (i_threads[i_threads_cnt], thread_keypress, &benchmark);
17144
17145 i_threads_cnt++;
17146 }
17147 }
17148
17149 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
17150
17151 uint ni_threads_cnt = 0;
17152
17153 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17154
17155 if (stdout_flag == 0)
17156 {
17157 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
17158
17159 ni_threads_cnt++;
17160 }
17161
17162 /**
17163 * Outfile remove
17164 */
17165
17166 if (keyspace == 0)
17167 {
17168 if (outfile_check_timer != 0)
17169 {
17170 if (data.outfile_check_directory != NULL)
17171 {
17172 if ((hash_mode != 5200) &&
17173 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
17174 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
17175 (hash_mode != 9000))
17176 {
17177 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
17178
17179 ni_threads_cnt++;
17180 }
17181 else
17182 {
17183 outfile_check_timer = 0;
17184 }
17185 }
17186 else
17187 {
17188 outfile_check_timer = 0;
17189 }
17190 }
17191 }
17192
17193 /**
17194 * Inform the user if we got some hashes remove because of the pot file remove feature
17195 */
17196
17197 if (data.quiet == 0)
17198 {
17199 if (potfile_remove_cracks > 0)
17200 {
17201 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
17202 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
17203 }
17204 }
17205
17206 data.outfile_check_timer = outfile_check_timer;
17207
17208 /**
17209 * main loop
17210 */
17211
17212 char **induction_dictionaries = NULL;
17213
17214 int induction_dictionaries_cnt = 0;
17215
17216 hcstat_table_t *root_table_buf = NULL;
17217 hcstat_table_t *markov_table_buf = NULL;
17218
17219 uint initial_restore_done = 0;
17220
17221 data.maskcnt = maskcnt;
17222
17223 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
17224 {
17225 if (data.devices_status == STATUS_CRACKED) break;
17226
17227 data.devices_status = STATUS_INIT;
17228
17229 if (maskpos > rd->maskpos)
17230 {
17231 rd->dictpos = 0;
17232 }
17233
17234 rd->maskpos = maskpos;
17235 data.maskpos = maskpos;
17236
17237 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
17238 {
17239 char *mask = masks[maskpos];
17240
17241 if (mask_from_file == 1)
17242 {
17243 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
17244
17245 char *str_ptr;
17246 uint str_pos;
17247
17248 uint mask_offset = 0;
17249
17250 uint separator_cnt;
17251
17252 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
17253 {
17254 str_ptr = strstr (mask + mask_offset, ",");
17255
17256 if (str_ptr == NULL) break;
17257
17258 str_pos = str_ptr - mask;
17259
17260 // escaped separator, i.e. "\,"
17261
17262 if (str_pos > 0)
17263 {
17264 if (mask[str_pos - 1] == '\\')
17265 {
17266 separator_cnt --;
17267
17268 mask_offset = str_pos + 1;
17269
17270 continue;
17271 }
17272 }
17273
17274 // reset the offset
17275
17276 mask_offset = 0;
17277
17278 mask[str_pos] = '\0';
17279
17280 switch (separator_cnt)
17281 {
17282 case 0:
17283 mp_reset_usr (mp_usr, 0);
17284
17285 custom_charset_1 = mask;
17286 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17287 break;
17288
17289 case 1:
17290 mp_reset_usr (mp_usr, 1);
17291
17292 custom_charset_2 = mask;
17293 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17294 break;
17295
17296 case 2:
17297 mp_reset_usr (mp_usr, 2);
17298
17299 custom_charset_3 = mask;
17300 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17301 break;
17302
17303 case 3:
17304 mp_reset_usr (mp_usr, 3);
17305
17306 custom_charset_4 = mask;
17307 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
17308 break;
17309 }
17310
17311 mask = mask + str_pos + 1;
17312 }
17313 }
17314
17315 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17316 {
17317 if (maskpos > 0)
17318 {
17319 local_free (css_buf);
17320 local_free (data.root_css_buf);
17321 local_free (data.markov_css_buf);
17322
17323 local_free (masks[maskpos - 1]);
17324 }
17325
17326 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17327
17328 data.mask = mask;
17329 data.css_cnt = css_cnt;
17330 data.css_buf = css_buf;
17331
17332 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17333
17334 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17335
17336 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17337 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17338
17339 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17340
17341 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17342
17343 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17344 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17345
17346 data.root_css_buf = root_css_buf;
17347 data.markov_css_buf = markov_css_buf;
17348
17349 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17350
17351 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17352
17353 local_free (root_table_buf);
17354 local_free (markov_table_buf);
17355
17356 // args
17357
17358 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17359 {
17360 hc_device_param_t *device_param = &data.devices_param[device_id];
17361
17362 if (device_param->skipped) continue;
17363
17364 device_param->kernel_params_mp[0] = &device_param->d_combs;
17365 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
17366 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
17367
17368 device_param->kernel_params_mp_buf64[3] = 0;
17369 device_param->kernel_params_mp_buf32[4] = css_cnt;
17370 device_param->kernel_params_mp_buf32[5] = 0;
17371 device_param->kernel_params_mp_buf32[6] = 0;
17372 device_param->kernel_params_mp_buf32[7] = 0;
17373
17374 if (attack_mode == ATTACK_MODE_HYBRID1)
17375 {
17376 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
17377 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
17378 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
17379 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
17380 }
17381 else if (attack_mode == ATTACK_MODE_HYBRID2)
17382 {
17383 device_param->kernel_params_mp_buf32[5] = 0;
17384 device_param->kernel_params_mp_buf32[6] = 0;
17385 device_param->kernel_params_mp_buf32[7] = 0;
17386 }
17387
17388 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]);
17389 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]);
17390 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]);
17391
17392 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);
17393 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);
17394 }
17395 }
17396 else if (attack_mode == ATTACK_MODE_BF)
17397 {
17398 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
17399
17400 if (increment)
17401 {
17402 for (uint i = 0; i < dictcnt; i++)
17403 {
17404 local_free (dictfiles[i]);
17405 }
17406
17407 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17408 {
17409 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17410
17411 if (l1_filename == NULL) break;
17412
17413 dictcnt++;
17414
17415 dictfiles[dictcnt - 1] = l1_filename;
17416 }
17417 }
17418 else
17419 {
17420 dictcnt++;
17421
17422 dictfiles[dictcnt - 1] = mask;
17423 }
17424
17425 if (dictcnt == 0)
17426 {
17427 log_error ("ERROR: Mask is too small");
17428
17429 return (-1);
17430 }
17431 }
17432 }
17433
17434 free (induction_dictionaries);
17435
17436 // induction_dictionaries_cnt = 0; // implied
17437
17438 if (attack_mode != ATTACK_MODE_BF)
17439 {
17440 if (keyspace == 0)
17441 {
17442 induction_dictionaries = scan_directory (induction_directory);
17443
17444 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17445 }
17446 }
17447
17448 if (induction_dictionaries_cnt)
17449 {
17450 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17451 }
17452
17453 /**
17454 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17455 */
17456 if (keyspace == 1)
17457 {
17458 if ((maskcnt > 1) || (dictcnt > 1))
17459 {
17460 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17461
17462 return (-1);
17463 }
17464 }
17465
17466 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17467 {
17468 char *subid = logfile_generate_subid ();
17469
17470 data.subid = subid;
17471
17472 logfile_sub_msg ("START");
17473
17474 data.devices_status = STATUS_INIT;
17475
17476 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17477 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17478 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17479
17480 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17481
17482 data.cpt_pos = 0;
17483
17484 data.cpt_start = time (NULL);
17485
17486 data.cpt_total = 0;
17487
17488 if (data.restore == 0)
17489 {
17490 rd->words_cur = skip;
17491
17492 skip = 0;
17493
17494 data.skip = 0;
17495 }
17496
17497 data.ms_paused = 0;
17498
17499 data.kernel_power_final = 0;
17500
17501 data.words_cur = rd->words_cur;
17502
17503 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17504 {
17505 hc_device_param_t *device_param = &data.devices_param[device_id];
17506
17507 if (device_param->skipped) continue;
17508
17509 device_param->speed_pos = 0;
17510
17511 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17512 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17513
17514 device_param->exec_pos = 0;
17515
17516 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17517
17518 device_param->outerloop_pos = 0;
17519 device_param->outerloop_left = 0;
17520 device_param->innerloop_pos = 0;
17521 device_param->innerloop_left = 0;
17522
17523 // some more resets:
17524
17525 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17526
17527 device_param->pws_cnt = 0;
17528
17529 device_param->words_off = 0;
17530 device_param->words_done = 0;
17531 }
17532
17533 // figure out some workload
17534
17535 if (attack_mode == ATTACK_MODE_STRAIGHT)
17536 {
17537 if (data.wordlist_mode == WL_MODE_FILE)
17538 {
17539 char *dictfile = NULL;
17540
17541 if (induction_dictionaries_cnt)
17542 {
17543 dictfile = induction_dictionaries[0];
17544 }
17545 else
17546 {
17547 dictfile = dictfiles[dictpos];
17548 }
17549
17550 data.dictfile = dictfile;
17551
17552 logfile_sub_string (dictfile);
17553
17554 for (uint i = 0; i < rp_files_cnt; i++)
17555 {
17556 logfile_sub_var_string ("rulefile", rp_files[i]);
17557 }
17558
17559 FILE *fd2 = fopen (dictfile, "rb");
17560
17561 if (fd2 == NULL)
17562 {
17563 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17564
17565 return (-1);
17566 }
17567
17568 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17569
17570 fclose (fd2);
17571
17572 if (data.words_cnt == 0)
17573 {
17574 if (data.devices_status == STATUS_CRACKED) break;
17575 if (data.devices_status == STATUS_ABORTED) break;
17576
17577 dictpos++;
17578
17579 continue;
17580 }
17581 }
17582 }
17583 else if (attack_mode == ATTACK_MODE_COMBI)
17584 {
17585 char *dictfile = data.dictfile;
17586 char *dictfile2 = data.dictfile2;
17587
17588 logfile_sub_string (dictfile);
17589 logfile_sub_string (dictfile2);
17590
17591 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17592 {
17593 FILE *fd2 = fopen (dictfile, "rb");
17594
17595 if (fd2 == NULL)
17596 {
17597 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17598
17599 return (-1);
17600 }
17601
17602 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17603
17604 fclose (fd2);
17605 }
17606 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17607 {
17608 FILE *fd2 = fopen (dictfile2, "rb");
17609
17610 if (fd2 == NULL)
17611 {
17612 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17613
17614 return (-1);
17615 }
17616
17617 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17618
17619 fclose (fd2);
17620 }
17621
17622 if (data.words_cnt == 0)
17623 {
17624 if (data.devices_status == STATUS_CRACKED) break;
17625 if (data.devices_status == STATUS_ABORTED) break;
17626
17627 dictpos++;
17628
17629 continue;
17630 }
17631 }
17632 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17633 {
17634 char *dictfile = NULL;
17635
17636 if (induction_dictionaries_cnt)
17637 {
17638 dictfile = induction_dictionaries[0];
17639 }
17640 else
17641 {
17642 dictfile = dictfiles[dictpos];
17643 }
17644
17645 data.dictfile = dictfile;
17646
17647 char *mask = data.mask;
17648
17649 logfile_sub_string (dictfile);
17650 logfile_sub_string (mask);
17651
17652 FILE *fd2 = fopen (dictfile, "rb");
17653
17654 if (fd2 == NULL)
17655 {
17656 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17657
17658 return (-1);
17659 }
17660
17661 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17662
17663 fclose (fd2);
17664
17665 if (data.words_cnt == 0)
17666 {
17667 if (data.devices_status == STATUS_CRACKED) break;
17668 if (data.devices_status == STATUS_ABORTED) break;
17669
17670 dictpos++;
17671
17672 continue;
17673 }
17674 }
17675 else if (attack_mode == ATTACK_MODE_BF)
17676 {
17677 local_free (css_buf);
17678 local_free (data.root_css_buf);
17679 local_free (data.markov_css_buf);
17680
17681 char *mask = dictfiles[dictpos];
17682
17683 logfile_sub_string (mask);
17684
17685 // base
17686
17687 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17688
17689 if (opts_type & OPTS_TYPE_PT_UNICODE)
17690 {
17691 uint css_cnt_unicode = css_cnt * 2;
17692
17693 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17694
17695 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17696 {
17697 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17698
17699 css_buf_unicode[j + 1].cs_buf[0] = 0;
17700 css_buf_unicode[j + 1].cs_len = 1;
17701 }
17702
17703 free (css_buf);
17704
17705 css_buf = css_buf_unicode;
17706 css_cnt = css_cnt_unicode;
17707 }
17708
17709 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17710
17711 uint mask_min = pw_min;
17712 uint mask_max = pw_max;
17713
17714 if (opts_type & OPTS_TYPE_PT_UNICODE)
17715 {
17716 mask_min *= 2;
17717 mask_max *= 2;
17718 }
17719
17720 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17721 {
17722 if (css_cnt < mask_min)
17723 {
17724 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17725 }
17726
17727 if (css_cnt > mask_max)
17728 {
17729 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17730 }
17731
17732 // skip to next mask
17733
17734 dictpos++;
17735
17736 rd->dictpos = dictpos;
17737
17738 logfile_sub_msg ("STOP");
17739
17740 continue;
17741 }
17742
17743 uint save_css_cnt = css_cnt;
17744
17745 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17746 {
17747 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17748 {
17749 uint salt_len = (uint) data.salts_buf[0].salt_len;
17750 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17751
17752 uint css_cnt_salt = css_cnt + salt_len;
17753
17754 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17755
17756 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17757
17758 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17759 {
17760 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17761 css_buf_salt[j].cs_len = 1;
17762 }
17763
17764 free (css_buf);
17765
17766 css_buf = css_buf_salt;
17767 css_cnt = css_cnt_salt;
17768 }
17769 }
17770
17771 data.mask = mask;
17772 data.css_cnt = css_cnt;
17773 data.css_buf = css_buf;
17774
17775 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17776
17777 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17778
17779 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17780
17781 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17782 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17783
17784 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17785
17786 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17787
17788 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17789 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17790
17791 data.root_css_buf = root_css_buf;
17792 data.markov_css_buf = markov_css_buf;
17793
17794 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17795
17796 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17797
17798 local_free (root_table_buf);
17799 local_free (markov_table_buf);
17800
17801 // copy + args
17802
17803 uint css_cnt_l = css_cnt;
17804 uint css_cnt_r;
17805
17806 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17807 {
17808 if (save_css_cnt < 6)
17809 {
17810 css_cnt_r = 1;
17811 }
17812 else if (save_css_cnt == 6)
17813 {
17814 css_cnt_r = 2;
17815 }
17816 else
17817 {
17818 if (opts_type & OPTS_TYPE_PT_UNICODE)
17819 {
17820 if (save_css_cnt == 8 || save_css_cnt == 10)
17821 {
17822 css_cnt_r = 2;
17823 }
17824 else
17825 {
17826 css_cnt_r = 4;
17827 }
17828 }
17829 else
17830 {
17831 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17832 {
17833 css_cnt_r = 3;
17834 }
17835 else
17836 {
17837 css_cnt_r = 4;
17838 }
17839 }
17840 }
17841 }
17842 else
17843 {
17844 css_cnt_r = 1;
17845
17846 /* unfinished code?
17847 int sum = css_buf[css_cnt_r - 1].cs_len;
17848
17849 for (uint i = 1; i < 4 && i < css_cnt; i++)
17850 {
17851 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17852
17853 css_cnt_r++;
17854
17855 sum *= css_buf[css_cnt_r - 1].cs_len;
17856 }
17857 */
17858 }
17859
17860 css_cnt_l -= css_cnt_r;
17861
17862 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17863
17864 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17865 {
17866 hc_device_param_t *device_param = &data.devices_param[device_id];
17867
17868 if (device_param->skipped) continue;
17869
17870 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17871 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17872 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17873
17874 device_param->kernel_params_mp_l_buf64[3] = 0;
17875 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17876 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17877 device_param->kernel_params_mp_l_buf32[6] = 0;
17878 device_param->kernel_params_mp_l_buf32[7] = 0;
17879 device_param->kernel_params_mp_l_buf32[8] = 0;
17880
17881 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17882 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17883 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17884 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17885
17886 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17887 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17888 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17889
17890 device_param->kernel_params_mp_r_buf64[3] = 0;
17891 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17892 device_param->kernel_params_mp_r_buf32[5] = 0;
17893 device_param->kernel_params_mp_r_buf32[6] = 0;
17894 device_param->kernel_params_mp_r_buf32[7] = 0;
17895
17896 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]);
17897 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]);
17898 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]);
17899
17900 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]);
17901 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]);
17902 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]);
17903
17904 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);
17905 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);
17906 }
17907 }
17908
17909 u64 words_base = data.words_cnt;
17910
17911 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17912 {
17913 if (data.kernel_rules_cnt)
17914 {
17915 words_base /= data.kernel_rules_cnt;
17916 }
17917 }
17918 else if (data.attack_kern == ATTACK_KERN_COMBI)
17919 {
17920 if (data.combs_cnt)
17921 {
17922 words_base /= data.combs_cnt;
17923 }
17924 }
17925 else if (data.attack_kern == ATTACK_KERN_BF)
17926 {
17927 if (data.bfs_cnt)
17928 {
17929 words_base /= data.bfs_cnt;
17930 }
17931 }
17932
17933 data.words_base = words_base;
17934
17935 if (keyspace == 1)
17936 {
17937 log_info ("%llu", (unsigned long long int) words_base);
17938
17939 return (0);
17940 }
17941
17942 if (data.words_cur > data.words_base)
17943 {
17944 log_error ("ERROR: restore value greater keyspace");
17945
17946 return (-1);
17947 }
17948
17949 if (data.words_cur)
17950 {
17951 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17952 {
17953 for (uint i = 0; i < data.salts_cnt; i++)
17954 {
17955 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17956 }
17957 }
17958 else if (data.attack_kern == ATTACK_KERN_COMBI)
17959 {
17960 for (uint i = 0; i < data.salts_cnt; i++)
17961 {
17962 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17963 }
17964 }
17965 else if (data.attack_kern == ATTACK_KERN_BF)
17966 {
17967 for (uint i = 0; i < data.salts_cnt; i++)
17968 {
17969 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17970 }
17971 }
17972 }
17973
17974 /*
17975 * Update loopback file
17976 */
17977
17978 if (loopback == 1)
17979 {
17980 time_t now;
17981
17982 time (&now);
17983
17984 uint random_num = get_random_num (0, 9999);
17985
17986 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17987
17988 data.loopback_file = loopback_file;
17989 }
17990
17991 /*
17992 * Update dictionary statistic
17993 */
17994
17995 if (keyspace == 0)
17996 {
17997 dictstat_fp = fopen (dictstat, "wb");
17998
17999 if (dictstat_fp)
18000 {
18001 lock_file (dictstat_fp);
18002
18003 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
18004
18005 fclose (dictstat_fp);
18006 }
18007 }
18008
18009 /**
18010 * create autotune threads
18011 */
18012
18013 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
18014
18015 data.devices_status = STATUS_AUTOTUNE;
18016
18017 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18018 {
18019 hc_device_param_t *device_param = &devices_param[device_id];
18020
18021 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
18022 }
18023
18024 hc_thread_wait (data.devices_cnt, c_threads);
18025
18026 /*
18027 * Inform user about possible slow speeds
18028 */
18029
18030 uint hardware_power_all = 0;
18031
18032 uint kernel_power_all = 0;
18033
18034 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18035 {
18036 hc_device_param_t *device_param = &devices_param[device_id];
18037
18038 hardware_power_all += device_param->hardware_power;
18039
18040 kernel_power_all += device_param->kernel_power;
18041 }
18042
18043 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
18044
18045 data.kernel_power_all = kernel_power_all;
18046
18047 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18048 {
18049 if (data.words_base < kernel_power_all)
18050 {
18051 if (quiet == 0)
18052 {
18053 log_info ("ATTENTION!");
18054 log_info (" The wordlist or mask you are using is too small.");
18055 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
18056 log_info (" The cracking speed will drop.");
18057 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
18058 log_info ("");
18059 }
18060 }
18061 }
18062
18063 /**
18064 * create cracker threads
18065 */
18066
18067 data.devices_status = STATUS_RUNNING;
18068
18069 if (initial_restore_done == 0)
18070 {
18071 if (data.restore_disable == 0) cycle_restore ();
18072
18073 initial_restore_done = 1;
18074 }
18075
18076 hc_timer_set (&data.timer_running);
18077
18078 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18079 {
18080 if ((quiet == 0) && (status == 0) && (benchmark == 0))
18081 {
18082 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
18083 if (quiet == 0) fflush (stdout);
18084 }
18085 }
18086 else if (wordlist_mode == WL_MODE_STDIN)
18087 {
18088 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
18089 if (data.quiet == 0) log_info ("");
18090 }
18091
18092 time_t runtime_start;
18093
18094 time (&runtime_start);
18095
18096 data.runtime_start = runtime_start;
18097
18098 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18099 {
18100 hc_device_param_t *device_param = &devices_param[device_id];
18101
18102 if (wordlist_mode == WL_MODE_STDIN)
18103 {
18104 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
18105 }
18106 else
18107 {
18108 hc_thread_create (c_threads[device_id], thread_calc, device_param);
18109 }
18110 }
18111
18112 hc_thread_wait (data.devices_cnt, c_threads);
18113
18114 local_free (c_threads);
18115
18116 data.restore = 0;
18117
18118 // finalize task
18119
18120 logfile_sub_var_uint ("status-after-work", data.devices_status);
18121
18122 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18123
18124 if (data.devices_status == STATUS_CRACKED) break;
18125 if (data.devices_status == STATUS_ABORTED) break;
18126
18127 if (data.devices_status == STATUS_BYPASS)
18128 {
18129 data.devices_status = STATUS_RUNNING;
18130 }
18131
18132 if (induction_dictionaries_cnt)
18133 {
18134 unlink (induction_dictionaries[0]);
18135 }
18136
18137 free (induction_dictionaries);
18138
18139 if (attack_mode != ATTACK_MODE_BF)
18140 {
18141 induction_dictionaries = scan_directory (induction_directory);
18142
18143 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18144 }
18145
18146 if (benchmark == 0)
18147 {
18148 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
18149 {
18150 if (quiet == 0) clear_prompt ();
18151
18152 if (quiet == 0) log_info ("");
18153
18154 if (status == 1)
18155 {
18156 status_display ();
18157 }
18158 else
18159 {
18160 if (quiet == 0) status_display ();
18161 }
18162
18163 if (quiet == 0) log_info ("");
18164 }
18165 }
18166
18167 if (attack_mode == ATTACK_MODE_BF)
18168 {
18169 dictpos++;
18170
18171 rd->dictpos = dictpos;
18172 }
18173 else
18174 {
18175 if (induction_dictionaries_cnt)
18176 {
18177 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18178 }
18179 else
18180 {
18181 dictpos++;
18182
18183 rd->dictpos = dictpos;
18184 }
18185 }
18186
18187 time_t runtime_stop;
18188
18189 time (&runtime_stop);
18190
18191 data.runtime_stop = runtime_stop;
18192
18193 logfile_sub_uint (runtime_start);
18194 logfile_sub_uint (runtime_stop);
18195
18196 logfile_sub_msg ("STOP");
18197
18198 global_free (subid);
18199 }
18200
18201 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18202
18203 if (data.devices_status == STATUS_CRACKED) break;
18204 if (data.devices_status == STATUS_ABORTED) break;
18205 if (data.devices_status == STATUS_QUIT) break;
18206
18207 if (data.devices_status == STATUS_BYPASS)
18208 {
18209 data.devices_status = STATUS_RUNNING;
18210 }
18211 }
18212
18213 // 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
18214
18215 if (attack_mode == ATTACK_MODE_STRAIGHT)
18216 {
18217 if (data.wordlist_mode == WL_MODE_FILE)
18218 {
18219 if (data.dictfile == NULL)
18220 {
18221 if (dictfiles != NULL)
18222 {
18223 data.dictfile = dictfiles[0];
18224
18225 hc_timer_set (&data.timer_running);
18226 }
18227 }
18228 }
18229 }
18230 // NOTE: combi is okay because it is already set beforehand
18231 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
18232 {
18233 if (data.dictfile == NULL)
18234 {
18235 if (dictfiles != NULL)
18236 {
18237 hc_timer_set (&data.timer_running);
18238
18239 data.dictfile = dictfiles[0];
18240 }
18241 }
18242 }
18243 else if (attack_mode == ATTACK_MODE_BF)
18244 {
18245 if (data.mask == NULL)
18246 {
18247 hc_timer_set (&data.timer_running);
18248
18249 data.mask = masks[0];
18250 }
18251 }
18252
18253 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18254 {
18255 data.devices_status = STATUS_EXHAUSTED;
18256 }
18257
18258 // if cracked / aborted remove last induction dictionary
18259
18260 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
18261 {
18262 struct stat induct_stat;
18263
18264 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
18265 {
18266 unlink (induction_dictionaries[file_pos]);
18267 }
18268 }
18269
18270 // wait for non-interactive threads
18271
18272 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
18273 {
18274 hc_thread_wait (1, &ni_threads[thread_idx]);
18275 }
18276
18277 local_free (ni_threads);
18278
18279 // wait for interactive threads
18280
18281 for (uint thread_idx = 0; thread_idx < i_threads_cnt; thread_idx++)
18282 {
18283 hc_thread_wait (1, &i_threads[thread_idx]);
18284 }
18285
18286 local_free (i_threads);
18287
18288 // we dont need restore file anymore
18289 if (data.restore_disable == 0)
18290 {
18291 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
18292 {
18293 unlink (eff_restore_file);
18294 unlink (new_restore_file);
18295 }
18296 else
18297 {
18298 cycle_restore ();
18299 }
18300 }
18301
18302 // finally save left hashes
18303
18304 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
18305 {
18306 save_hash ();
18307 }
18308
18309 /**
18310 * Clean up
18311 */
18312
18313 if (benchmark == 1)
18314 {
18315 status_benchmark ();
18316
18317 if (machine_readable == 0)
18318 {
18319 log_info ("");
18320 }
18321 }
18322 else
18323 {
18324 if (quiet == 0) clear_prompt ();
18325
18326 if (quiet == 0) log_info ("");
18327
18328 if (status == 1)
18329 {
18330 status_display ();
18331 }
18332 else
18333 {
18334 if (quiet == 0) status_display ();
18335 }
18336
18337 if (quiet == 0) log_info ("");
18338 }
18339
18340 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18341 {
18342 hc_device_param_t *device_param = &data.devices_param[device_id];
18343
18344 if (device_param->skipped) continue;
18345
18346 local_free (device_param->combs_buf);
18347
18348 local_free (device_param->hooks_buf);
18349
18350 local_free (device_param->device_name);
18351
18352 local_free (device_param->device_name_chksum);
18353
18354 local_free (device_param->device_version);
18355
18356 local_free (device_param->driver_version);
18357
18358 if (device_param->pws_buf) myfree (device_param->pws_buf);
18359 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
18360 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
18361 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
18362 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
18363 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
18364 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
18365 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
18366 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
18367 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
18368 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
18369 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
18370 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
18371 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
18372 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
18373 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
18374 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
18375 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
18376 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
18377 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
18378 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
18379 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
18380 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
18381 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
18382 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
18383 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
18384 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
18385 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
18386 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
18387
18388 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
18389 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
18390 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
18391 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
18392 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
18393 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
18394 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
18395 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
18396 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
18397 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
18398 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
18399
18400 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
18401 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
18402 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
18403
18404 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
18405 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
18406 }
18407
18408 // reset default fan speed
18409
18410 #ifdef HAVE_HWMON
18411 if (gpu_temp_disable == 0)
18412 {
18413 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
18414 {
18415 hc_thread_mutex_lock (mux_adl);
18416
18417 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18418 {
18419 hc_device_param_t *device_param = &data.devices_param[device_id];
18420
18421 if (device_param->skipped) continue;
18422
18423 if (data.hm_device[device_id].fan_set_supported == 1)
18424 {
18425 int fanspeed = temp_retain_fanspeed_value[device_id];
18426 int fanpolicy = temp_retain_fanpolicy_value[device_id];
18427
18428 if (fanpolicy == 1)
18429 {
18430 int rc = -1;
18431
18432 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18433 {
18434 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
18435 }
18436 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18437 {
18438 #ifdef LINUX
18439 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE);
18440 #endif
18441
18442 #ifdef WIN
18443 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, fanpolicy);
18444 #endif
18445 }
18446
18447 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18448 }
18449 }
18450 }
18451
18452 hc_thread_mutex_unlock (mux_adl);
18453 }
18454 }
18455
18456 // reset power tuning
18457
18458 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
18459 {
18460 hc_thread_mutex_lock (mux_adl);
18461
18462 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18463 {
18464 hc_device_param_t *device_param = &data.devices_param[device_id];
18465
18466 if (device_param->skipped) continue;
18467
18468 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18469 {
18470 if (data.hm_device[device_id].od_version == 6)
18471 {
18472 // check powertune capabilities first, if not available then skip device
18473
18474 int powertune_supported = 0;
18475
18476 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18477 {
18478 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18479
18480 return (-1);
18481 }
18482
18483 if (powertune_supported != 0)
18484 {
18485 // powercontrol settings
18486
18487 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18488 {
18489 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18490
18491 return (-1);
18492 }
18493
18494 // clocks
18495
18496 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18497
18498 performance_state->iNumberOfPerformanceLevels = 2;
18499
18500 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18501 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18502 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18503 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18504
18505 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18506 {
18507 log_info ("ERROR: Failed to restore ADL performance state");
18508
18509 return (-1);
18510 }
18511
18512 local_free (performance_state);
18513 }
18514 }
18515 }
18516
18517 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18518 {
18519 unsigned int limit = nvml_power_limit[device_id];
18520
18521 if (limit > 0)
18522 {
18523 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18524 }
18525 }
18526 }
18527
18528 hc_thread_mutex_unlock (mux_adl);
18529 }
18530
18531 if (gpu_temp_disable == 0)
18532 {
18533 if (data.hm_nvml)
18534 {
18535 hm_NVML_nvmlShutdown (data.hm_nvml);
18536
18537 nvml_close (data.hm_nvml);
18538
18539 data.hm_nvml = NULL;
18540 }
18541
18542 if (data.hm_nvapi)
18543 {
18544 hm_NvAPI_Unload (data.hm_nvapi);
18545
18546 nvapi_close (data.hm_nvapi);
18547
18548 data.hm_nvapi = NULL;
18549 }
18550
18551 if (data.hm_xnvctrl)
18552 {
18553 hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);
18554
18555 xnvctrl_close (data.hm_xnvctrl);
18556
18557 data.hm_xnvctrl = NULL;
18558 }
18559
18560 if (data.hm_adl)
18561 {
18562 hm_ADL_Main_Control_Destroy (data.hm_adl);
18563
18564 adl_close (data.hm_adl);
18565
18566 data.hm_adl = NULL;
18567 }
18568 }
18569 #endif // HAVE_HWMON
18570
18571 // free memory
18572
18573 local_free (masks);
18574
18575 local_free (dictstat_base);
18576
18577 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18578 {
18579 pot_t *pot_ptr = &pot[pot_pos];
18580
18581 hash_t *hash = &pot_ptr->hash;
18582
18583 local_free (hash->digest);
18584
18585 if (isSalted)
18586 {
18587 local_free (hash->salt);
18588 }
18589 }
18590
18591 local_free (pot);
18592
18593 local_free (all_kernel_rules_cnt);
18594 local_free (all_kernel_rules_buf);
18595
18596 local_free (wl_data->buf);
18597 local_free (wl_data);
18598
18599 local_free (bitmap_s1_a);
18600 local_free (bitmap_s1_b);
18601 local_free (bitmap_s1_c);
18602 local_free (bitmap_s1_d);
18603 local_free (bitmap_s2_a);
18604 local_free (bitmap_s2_b);
18605 local_free (bitmap_s2_c);
18606 local_free (bitmap_s2_d);
18607
18608 #ifdef HAVE_HWMON
18609 local_free (temp_retain_fanspeed_value);
18610 local_free (od_clock_mem_status);
18611 local_free (od_power_control_status);
18612 local_free (nvml_power_limit);
18613 #endif
18614
18615 global_free (devices_param);
18616
18617 global_free (kernel_rules_buf);
18618
18619 global_free (root_css_buf);
18620 global_free (markov_css_buf);
18621
18622 global_free (digests_buf);
18623 global_free (digests_shown);
18624 global_free (digests_shown_tmp);
18625
18626 global_free (salts_buf);
18627 global_free (salts_shown);
18628
18629 global_free (esalts_buf);
18630
18631 global_free (words_progress_done);
18632 global_free (words_progress_rejected);
18633 global_free (words_progress_restored);
18634
18635 if (pot_fp) fclose (pot_fp);
18636
18637 if (data.devices_status == STATUS_QUIT) break;
18638 }
18639
18640 // destroy others mutex
18641
18642 hc_thread_mutex_delete (mux_dispatcher);
18643 hc_thread_mutex_delete (mux_counter);
18644 hc_thread_mutex_delete (mux_display);
18645 hc_thread_mutex_delete (mux_adl);
18646
18647 // free memory
18648
18649 local_free (eff_restore_file);
18650 local_free (new_restore_file);
18651
18652 local_free (rd);
18653
18654 // tuning db
18655
18656 tuning_db_destroy (tuning_db);
18657
18658 // loopback
18659
18660 local_free (loopback_file);
18661
18662 if (loopback == 1) unlink (loopback_file);
18663
18664 // induction directory
18665
18666 if (induction_dir == NULL)
18667 {
18668 if (attack_mode != ATTACK_MODE_BF)
18669 {
18670 if (rmdir (induction_directory) == -1)
18671 {
18672 if (errno == ENOENT)
18673 {
18674 // good, we can ignore
18675 }
18676 else if (errno == ENOTEMPTY)
18677 {
18678 // good, we can ignore
18679 }
18680 else
18681 {
18682 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18683
18684 return (-1);
18685 }
18686 }
18687
18688 local_free (induction_directory);
18689 }
18690 }
18691
18692 // outfile-check directory
18693
18694 if (outfile_check_dir == NULL)
18695 {
18696 if (rmdir (outfile_check_directory) == -1)
18697 {
18698 if (errno == ENOENT)
18699 {
18700 // good, we can ignore
18701 }
18702 else if (errno == ENOTEMPTY)
18703 {
18704 // good, we can ignore
18705 }
18706 else
18707 {
18708 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18709
18710 return (-1);
18711 }
18712 }
18713
18714 local_free (outfile_check_directory);
18715 }
18716
18717 time_t proc_stop;
18718
18719 time (&proc_stop);
18720
18721 logfile_top_uint (proc_start);
18722 logfile_top_uint (proc_stop);
18723
18724 logfile_top_msg ("STOP");
18725
18726 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18727 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18728
18729 if (data.ocl) ocl_close (data.ocl);
18730
18731 if (data.devices_status == STATUS_ABORTED) return 2;
18732 if (data.devices_status == STATUS_QUIT) return 2;
18733 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18734 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18735 if (data.devices_status == STATUS_CRACKED) return 0;
18736
18737 return -1;
18738 }
Hashcat additions to support pwdhash