projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge pull request #384 from NSAKEY/master
[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 if (data.devices_active >= 10)
1757 {
1758 log_info ("Speed.Dev.#%d: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1759 }
1760 else
1761 {
1762 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1763 }
1764 }
1765
1766 char display_all_cur[16] = { 0 };
1767
1768 strncpy (display_all_cur, "0.00", 4);
1769
1770 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1771
1772 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1773 }
1774
1775 /**
1776 * hashcat -only- functions
1777 */
1778
1779 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1780 {
1781 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1782 {
1783 if (attack_kern == ATTACK_KERN_STRAIGHT)
1784 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1785 else if (attack_kern == ATTACK_KERN_COMBI)
1786 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1787 else if (attack_kern == ATTACK_KERN_BF)
1788 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1789 }
1790 else
1791 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1792 }
1793
1794 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)
1795 {
1796 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1797 {
1798 if (attack_kern == ATTACK_KERN_STRAIGHT)
1799 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1800 else if (attack_kern == ATTACK_KERN_COMBI)
1801 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1802 else if (attack_kern == ATTACK_KERN_BF)
1803 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1804 }
1805 else
1806 {
1807 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1808 }
1809 }
1810
1811 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1812 {
1813 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1814 {
1815 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1816 }
1817 else
1818 {
1819 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1820 }
1821 }
1822
1823 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)
1824 {
1825 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1826 {
1827 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1828 }
1829 else
1830 {
1831 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1832 }
1833 }
1834
1835 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1836 {
1837 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1838 }
1839
1840 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1841 {
1842 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1843 }
1844
1845 static char *filename_from_filepath (char *filepath)
1846 {
1847 char *ptr = NULL;
1848
1849 if ((ptr = strrchr (filepath, '/')) != NULL)
1850 {
1851 ptr++;
1852 }
1853 else if ((ptr = strrchr (filepath, '\\')) != NULL)
1854 {
1855 ptr++;
1856 }
1857 else
1858 {
1859 ptr = filepath;
1860 }
1861
1862 return ptr;
1863 }
1864
1865 static uint convert_from_hex (char *line_buf, const uint line_len)
1866 {
1867 if (line_len & 1) return (line_len); // not in hex
1868
1869 if (data.hex_wordlist == 1)
1870 {
1871 uint i;
1872 uint j;
1873
1874 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1875 {
1876 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1877 }
1878
1879 memset (line_buf + i, 0, line_len - i);
1880
1881 return (i);
1882 }
1883 else if (line_len >= 6) // $HEX[] = 6
1884 {
1885 if (line_buf[0] != '$') return (line_len);
1886 if (line_buf[1] != 'H') return (line_len);
1887 if (line_buf[2] != 'E') return (line_len);
1888 if (line_buf[3] != 'X') return (line_len);
1889 if (line_buf[4] != '[') return (line_len);
1890 if (line_buf[line_len - 1] != ']') return (line_len);
1891
1892 uint i;
1893 uint j;
1894
1895 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1896 {
1897 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1898 }
1899
1900 memset (line_buf + i, 0, line_len - i);
1901
1902 return (i);
1903 }
1904
1905 return (line_len);
1906 }
1907
1908 static void clear_prompt ()
1909 {
1910 fputc ('\r', stdout);
1911
1912 for (size_t i = 0; i < strlen (PROMPT); i++)
1913 {
1914 fputc (' ', stdout);
1915 }
1916
1917 fputc ('\r', stdout);
1918
1919 fflush (stdout);
1920 }
1921
1922 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1923 {
1924 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);
1925 }
1926
1927 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1928 {
1929 char *outfile = data.outfile;
1930 uint quiet = data.quiet;
1931 FILE *pot_fp = data.pot_fp;
1932 uint loopback = data.loopback;
1933 uint debug_mode = data.debug_mode;
1934 char *debug_file = data.debug_file;
1935
1936 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1937 int debug_rule_len = 0; // -1 error
1938 uint debug_plain_len = 0;
1939
1940 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1941
1942 // hash
1943
1944 char out_buf[HCBUFSIZ] = { 0 };
1945
1946 const u32 salt_pos = plain->salt_pos;
1947 const u32 digest_pos = plain->digest_pos; // relative
1948 const u32 gidvid = plain->gidvid;
1949 const u32 il_pos = plain->il_pos;
1950
1951 ascii_digest (out_buf, salt_pos, digest_pos);
1952
1953 // plain
1954
1955 u64 crackpos = device_param->words_off;
1956
1957 uint plain_buf[16] = { 0 };
1958
1959 u8 *plain_ptr = (u8 *) plain_buf;
1960
1961 unsigned int plain_len = 0;
1962
1963 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1964 {
1965 pw_t pw;
1966
1967 gidd_to_pw_t (device_param, gidvid, &pw);
1968
1969 for (int i = 0; i < 16; i++)
1970 {
1971 plain_buf[i] = pw.i[i];
1972 }
1973
1974 plain_len = pw.pw_len;
1975
1976 const uint off = device_param->innerloop_pos + il_pos;
1977
1978 if (debug_mode > 0)
1979 {
1980 debug_rule_len = 0;
1981
1982 // save rule
1983 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1984 {
1985 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1986
1987 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1988 }
1989
1990 // save plain
1991 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1992 {
1993 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1994
1995 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1996
1997 debug_plain_len = plain_len;
1998 }
1999 }
2000
2001 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2002
2003 crackpos += gidvid;
2004 crackpos *= data.kernel_rules_cnt;
2005 crackpos += device_param->innerloop_pos + il_pos;
2006
2007 if (plain_len > data.pw_max) plain_len = data.pw_max;
2008 }
2009 else if (data.attack_mode == ATTACK_MODE_COMBI)
2010 {
2011 pw_t pw;
2012
2013 gidd_to_pw_t (device_param, gidvid, &pw);
2014
2015 for (int i = 0; i < 16; i++)
2016 {
2017 plain_buf[i] = pw.i[i];
2018 }
2019
2020 plain_len = pw.pw_len;
2021
2022 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2023 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2024
2025 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2026 {
2027 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2028 }
2029 else
2030 {
2031 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2032
2033 memcpy (plain_ptr, comb_buf, comb_len);
2034 }
2035
2036 plain_len += comb_len;
2037
2038 crackpos += gidvid;
2039 crackpos *= data.combs_cnt;
2040 crackpos += device_param->innerloop_pos + il_pos;
2041
2042 if (data.pw_max != PW_DICTMAX1)
2043 {
2044 if (plain_len > data.pw_max) plain_len = data.pw_max;
2045 }
2046 }
2047 else if (data.attack_mode == ATTACK_MODE_BF)
2048 {
2049 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2050 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2051
2052 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2053 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2054
2055 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2056 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2057
2058 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2059 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2060
2061 plain_len = data.css_cnt;
2062
2063 crackpos += gidvid;
2064 crackpos *= data.bfs_cnt;
2065 crackpos += device_param->innerloop_pos + il_pos;
2066 }
2067 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2068 {
2069 pw_t pw;
2070
2071 gidd_to_pw_t (device_param, gidvid, &pw);
2072
2073 for (int i = 0; i < 16; i++)
2074 {
2075 plain_buf[i] = pw.i[i];
2076 }
2077
2078 plain_len = pw.pw_len;
2079
2080 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2081
2082 uint start = 0;
2083 uint stop = device_param->kernel_params_mp_buf32[4];
2084
2085 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2086
2087 plain_len += start + stop;
2088
2089 crackpos += gidvid;
2090 crackpos *= data.combs_cnt;
2091 crackpos += device_param->innerloop_pos + il_pos;
2092
2093 if (data.pw_max != PW_DICTMAX1)
2094 {
2095 if (plain_len > data.pw_max) plain_len = data.pw_max;
2096 }
2097 }
2098 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2099 {
2100 pw_t pw;
2101
2102 gidd_to_pw_t (device_param, gidvid, &pw);
2103
2104 for (int i = 0; i < 16; i++)
2105 {
2106 plain_buf[i] = pw.i[i];
2107 }
2108
2109 plain_len = pw.pw_len;
2110
2111 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2112
2113 uint start = 0;
2114 uint stop = device_param->kernel_params_mp_buf32[4];
2115
2116 memmove (plain_ptr + stop, plain_ptr, plain_len);
2117
2118 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2119
2120 plain_len += start + stop;
2121
2122 crackpos += gidvid;
2123 crackpos *= data.combs_cnt;
2124 crackpos += device_param->innerloop_pos + il_pos;
2125
2126 if (data.pw_max != PW_DICTMAX1)
2127 {
2128 if (plain_len > data.pw_max) plain_len = data.pw_max;
2129 }
2130 }
2131
2132 if (data.attack_mode == ATTACK_MODE_BF)
2133 {
2134 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2135 {
2136 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2137 {
2138 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2139 {
2140 plain_len = plain_len - data.salts_buf[0].salt_len;
2141 }
2142 }
2143
2144 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2145 {
2146 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2147 {
2148 plain_ptr[j] = plain_ptr[i];
2149 }
2150
2151 plain_len = plain_len / 2;
2152 }
2153 }
2154 }
2155
2156 // if enabled, update also the potfile
2157
2158 if (pot_fp)
2159 {
2160 lock_file (pot_fp);
2161
2162 fprintf (pot_fp, "%s:", out_buf);
2163
2164 format_plain (pot_fp, plain_ptr, plain_len, 1);
2165
2166 fputc ('\n', pot_fp);
2167
2168 fflush (pot_fp);
2169
2170 unlock_file (pot_fp);
2171 }
2172
2173 // outfile
2174
2175 FILE *out_fp = NULL;
2176
2177 if (outfile != NULL)
2178 {
2179 if ((out_fp = fopen (outfile, "ab")) == NULL)
2180 {
2181 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2182
2183 out_fp = stdout;
2184 }
2185
2186 lock_file (out_fp);
2187 }
2188 else
2189 {
2190 out_fp = stdout;
2191
2192 if (quiet == 0) clear_prompt ();
2193 }
2194
2195 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2196
2197 if (outfile != NULL)
2198 {
2199 if (out_fp != stdout)
2200 {
2201 fclose (out_fp);
2202 }
2203 }
2204 else
2205 {
2206 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2207 {
2208 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2209 {
2210 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2211 if (quiet == 0) fflush (stdout);
2212 }
2213 }
2214 }
2215
2216 // loopback
2217
2218 if (loopback)
2219 {
2220 char *loopback_file = data.loopback_file;
2221
2222 FILE *fb_fp = NULL;
2223
2224 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2225 {
2226 lock_file (fb_fp);
2227
2228 format_plain (fb_fp, plain_ptr, plain_len, 1);
2229
2230 fputc ('\n', fb_fp);
2231
2232 fclose (fb_fp);
2233 }
2234 }
2235
2236 // (rule) debug mode
2237
2238 // the next check implies that:
2239 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2240 // - debug_mode > 0
2241
2242 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2243 {
2244 if (debug_rule_len < 0) debug_rule_len = 0;
2245
2246 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2247
2248 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2249
2250 if ((quiet == 0) && (debug_file == NULL))
2251 {
2252 fprintf (stdout, "%s", PROMPT);
2253
2254 fflush (stdout);
2255 }
2256 }
2257 }
2258
2259 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2260 {
2261 salt_t *salt_buf = &data.salts_buf[salt_pos];
2262
2263 u32 num_cracked;
2264
2265 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2266
2267 if (num_cracked)
2268 {
2269 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2270
2271 log_info_nn ("");
2272
2273 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2274
2275 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);
2276
2277 uint cpt_cracked = 0;
2278
2279 hc_thread_mutex_lock (mux_display);
2280
2281 for (uint i = 0; i < num_cracked; i++)
2282 {
2283 const uint hash_pos = cracked[i].hash_pos;
2284
2285 if (data.digests_shown[hash_pos] == 1) continue;
2286
2287 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2288 {
2289 data.digests_shown[hash_pos] = 1;
2290
2291 data.digests_done++;
2292
2293 cpt_cracked++;
2294
2295 salt_buf->digests_done++;
2296
2297 if (salt_buf->digests_done == salt_buf->digests_cnt)
2298 {
2299 data.salts_shown[salt_pos] = 1;
2300
2301 data.salts_done++;
2302 }
2303 }
2304
2305 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2306
2307 check_hash (device_param, &cracked[i]);
2308 }
2309
2310 hc_thread_mutex_unlock (mux_display);
2311
2312 myfree (cracked);
2313
2314 if (cpt_cracked > 0)
2315 {
2316 hc_thread_mutex_lock (mux_display);
2317
2318 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2319 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2320
2321 data.cpt_pos++;
2322
2323 data.cpt_total += cpt_cracked;
2324
2325 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2326
2327 hc_thread_mutex_unlock (mux_display);
2328 }
2329
2330 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2331 {
2332 // we need to reset cracked state on the device
2333 // otherwise host thinks again and again the hash was cracked
2334 // and returns invalid password each time
2335
2336 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2337
2338 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);
2339 }
2340
2341 num_cracked = 0;
2342
2343 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2344 }
2345 }
2346
2347 // stolen from princeprocessor ;)
2348
2349 typedef struct
2350 {
2351 FILE *fp;
2352
2353 char buf[BUFSIZ];
2354 int len;
2355
2356 } out_t;
2357
2358 static void out_flush (out_t *out)
2359 {
2360 fwrite (out->buf, 1, out->len, out->fp);
2361
2362 out->len = 0;
2363 }
2364
2365 static void out_push (out_t *out, const u8 *pw_buf, const int pw_len)
2366 {
2367 char *ptr = out->buf + out->len;
2368
2369 memcpy (ptr, pw_buf, pw_len);
2370
2371 ptr[pw_len] = '\n';
2372
2373 out->len += pw_len + 1;
2374
2375 if (out->len >= BUFSIZ - 100)
2376 {
2377 out_flush (out);
2378 }
2379 }
2380
2381 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2382 {
2383 out_t out;
2384
2385 out.fp = stdout;
2386 out.len = 0;
2387
2388 uint plain_buf[16] = { 0 };
2389
2390 u8 *plain_ptr = (u8 *) plain_buf;
2391
2392 uint plain_len = 0;
2393
2394 const uint il_cnt = device_param->kernel_params_buf32[27]; // ugly, i know
2395
2396 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2397 {
2398 pw_t pw;
2399
2400 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2401 {
2402 gidd_to_pw_t (device_param, gidvid, &pw);
2403
2404 const uint pos = device_param->innerloop_pos;
2405
2406 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2407 {
2408 for (int i = 0; i < 8; i++)
2409 {
2410 plain_buf[i] = pw.i[i];
2411 }
2412
2413 plain_len = pw.pw_len;
2414
2415 plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2416
2417 if (plain_len > data.pw_max) plain_len = data.pw_max;
2418
2419 out_push (&out, plain_ptr, plain_len);
2420 }
2421 }
2422 }
2423 else if (data.attack_mode == ATTACK_MODE_COMBI)
2424 {
2425 pw_t pw;
2426
2427 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2428 {
2429 gidd_to_pw_t (device_param, gidvid, &pw);
2430
2431 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2432 {
2433 for (int i = 0; i < 8; i++)
2434 {
2435 plain_buf[i] = pw.i[i];
2436 }
2437
2438 plain_len = pw.pw_len;
2439
2440 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2441 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2442
2443 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2444 {
2445 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2446 }
2447 else
2448 {
2449 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2450
2451 memcpy (plain_ptr, comb_buf, comb_len);
2452 }
2453
2454 plain_len += comb_len;
2455
2456 if (data.pw_max != PW_DICTMAX1)
2457 {
2458 if (plain_len > data.pw_max) plain_len = data.pw_max;
2459 }
2460
2461 out_push (&out, plain_ptr, plain_len);
2462 }
2463 }
2464 }
2465 else if (data.attack_mode == ATTACK_MODE_BF)
2466 {
2467 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2468 {
2469 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2470 {
2471 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2472 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2473
2474 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2475 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2476
2477 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2478 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2479
2480 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2481 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2482
2483 plain_len = data.css_cnt;
2484
2485 out_push (&out, plain_ptr, plain_len);
2486 }
2487 }
2488 }
2489 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2490 {
2491 pw_t pw;
2492
2493 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2494 {
2495 gidd_to_pw_t (device_param, gidvid, &pw);
2496
2497 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2498 {
2499 for (int i = 0; i < 8; i++)
2500 {
2501 plain_buf[i] = pw.i[i];
2502 }
2503
2504 plain_len = pw.pw_len;
2505
2506 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2507
2508 uint start = 0;
2509 uint stop = device_param->kernel_params_mp_buf32[4];
2510
2511 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2512
2513 plain_len += start + stop;
2514
2515 out_push (&out, plain_ptr, plain_len);
2516 }
2517 }
2518 }
2519 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2520 {
2521 pw_t pw;
2522
2523 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2524 {
2525 gidd_to_pw_t (device_param, gidvid, &pw);
2526
2527 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2528 {
2529 for (int i = 0; i < 8; i++)
2530 {
2531 plain_buf[i] = pw.i[i];
2532 }
2533
2534 plain_len = pw.pw_len;
2535
2536 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2537
2538 uint start = 0;
2539 uint stop = device_param->kernel_params_mp_buf32[4];
2540
2541 memmove (plain_ptr + stop, plain_ptr, plain_len);
2542
2543 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2544
2545 plain_len += start + stop;
2546
2547 out_push (&out, plain_ptr, plain_len);
2548 }
2549 }
2550 }
2551
2552 out_flush (&out);
2553 }
2554
2555 static void save_hash ()
2556 {
2557 char *hashfile = data.hashfile;
2558
2559 char new_hashfile[256] = { 0 };
2560 char old_hashfile[256] = { 0 };
2561
2562 snprintf (new_hashfile, 255, "%s.new", hashfile);
2563 snprintf (old_hashfile, 255, "%s.old", hashfile);
2564
2565 unlink (new_hashfile);
2566
2567 char separator = data.separator;
2568
2569 FILE *fp = fopen (new_hashfile, "wb");
2570
2571 if (fp == NULL)
2572 {
2573 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2574
2575 exit (-1);
2576 }
2577
2578 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2579 {
2580 if (data.salts_shown[salt_pos] == 1) continue;
2581
2582 salt_t *salt_buf = &data.salts_buf[salt_pos];
2583
2584 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2585 {
2586 uint idx = salt_buf->digests_offset + digest_pos;
2587
2588 if (data.digests_shown[idx] == 1) continue;
2589
2590 if (data.hash_mode != 2500)
2591 {
2592 if (data.username == 1)
2593 {
2594 user_t *user = data.hash_info[idx]->user;
2595
2596 uint i;
2597
2598 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2599
2600 fputc (separator, fp);
2601 }
2602
2603 char out_buf[HCBUFSIZ]; // scratch buffer
2604
2605 out_buf[0] = 0;
2606
2607 ascii_digest (out_buf, salt_pos, digest_pos);
2608
2609 fputs (out_buf, fp);
2610
2611 fputc ('\n', fp);
2612 }
2613 else
2614 {
2615 hccap_t hccap;
2616
2617 to_hccap_t (&hccap, salt_pos, digest_pos);
2618
2619 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2620 }
2621 }
2622 }
2623
2624 fflush (fp);
2625
2626 fclose (fp);
2627
2628 unlink (old_hashfile);
2629
2630 if (rename (hashfile, old_hashfile) != 0)
2631 {
2632 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2633
2634 exit (-1);
2635 }
2636
2637 unlink (hashfile);
2638
2639 if (rename (new_hashfile, hashfile) != 0)
2640 {
2641 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2642
2643 exit (-1);
2644 }
2645
2646 unlink (old_hashfile);
2647 }
2648
2649 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2650 {
2651 uint num_elements = num;
2652
2653 device_param->kernel_params_buf32[30] = data.combs_mode;
2654 device_param->kernel_params_buf32[31] = num;
2655
2656 uint kernel_threads = device_param->kernel_threads;
2657
2658 while (num_elements % kernel_threads) num_elements++;
2659
2660 cl_kernel kernel = NULL;
2661
2662 switch (kern_run)
2663 {
2664 case KERN_RUN_1: kernel = device_param->kernel1; break;
2665 case KERN_RUN_12: kernel = device_param->kernel12; break;
2666 case KERN_RUN_2: kernel = device_param->kernel2; break;
2667 case KERN_RUN_23: kernel = device_param->kernel23; break;
2668 case KERN_RUN_3: kernel = device_param->kernel3; break;
2669 }
2670
2671 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2672 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2673 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2674 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2675 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2676 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2677 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2678 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2679 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2680 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2681 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2682
2683 cl_event event;
2684
2685 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2686 {
2687 const size_t global_work_size[3] = { num_elements, 32, 1 };
2688 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2689
2690 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2691 }
2692 else
2693 {
2694 if (kern_run == KERN_RUN_2)
2695 {
2696 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2697 {
2698 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2699 }
2700 }
2701
2702 while (num_elements % kernel_threads) num_elements++;
2703
2704 const size_t global_work_size[3] = { num_elements, 1, 1 };
2705 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2706
2707 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2708 }
2709
2710 hc_clFlush (data.ocl, device_param->command_queue);
2711
2712 if (device_param->nvidia_spin_damp)
2713 {
2714 if (data.devices_status == STATUS_RUNNING)
2715 {
2716 if (iteration < EXPECTED_ITERATIONS)
2717 {
2718 switch (kern_run)
2719 {
2720 case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration] * device_param->nvidia_spin_damp); break;
2721 case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration] * device_param->nvidia_spin_damp); break;
2722 case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration] * device_param->nvidia_spin_damp); break;
2723 }
2724 }
2725 }
2726 }
2727
2728 hc_clWaitForEvents (data.ocl, 1, &event);
2729
2730 cl_ulong time_start;
2731 cl_ulong time_end;
2732
2733 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2734 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2735
2736 const double exec_us = (double) (time_end - time_start) / 1000;
2737
2738 if (data.devices_status == STATUS_RUNNING)
2739 {
2740 if (iteration < EXPECTED_ITERATIONS)
2741 {
2742 switch (kern_run)
2743 {
2744 case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2745 case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2746 case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2747 }
2748 }
2749 }
2750
2751 if (event_update)
2752 {
2753 uint exec_pos = device_param->exec_pos;
2754
2755 device_param->exec_ms[exec_pos] = exec_us / 1000;
2756
2757 exec_pos++;
2758
2759 if (exec_pos == EXEC_CACHE)
2760 {
2761 exec_pos = 0;
2762 }
2763
2764 device_param->exec_pos = exec_pos;
2765 }
2766
2767 hc_clReleaseEvent (data.ocl, event);
2768
2769 hc_clFinish (data.ocl, device_param->command_queue);
2770 }
2771
2772 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2773 {
2774 uint num_elements = num;
2775
2776 switch (kern_run)
2777 {
2778 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2779 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2780 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2781 }
2782
2783 // causes problems with special threads like in bcrypt
2784 // const uint kernel_threads = device_param->kernel_threads;
2785
2786 uint kernel_threads = device_param->kernel_threads;
2787
2788 while (num_elements % kernel_threads) num_elements++;
2789
2790 cl_kernel kernel = NULL;
2791
2792 switch (kern_run)
2793 {
2794 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2795 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2796 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2797 }
2798
2799 switch (kern_run)
2800 {
2801 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2802 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2803 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2804 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2805 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2806 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2807 break;
2808 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2809 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2810 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2811 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2812 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2813 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2814 break;
2815 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2816 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2817 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2818 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2819 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2820 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2821 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2822 break;
2823 }
2824
2825 const size_t global_work_size[3] = { num_elements, 1, 1 };
2826 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2827
2828 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2829
2830 hc_clFlush (data.ocl, device_param->command_queue);
2831
2832 hc_clFinish (data.ocl, device_param->command_queue);
2833 }
2834
2835 static void run_kernel_tm (hc_device_param_t *device_param)
2836 {
2837 const uint num_elements = 1024; // fixed
2838
2839 uint kernel_threads = 32;
2840
2841 cl_kernel kernel = device_param->kernel_tm;
2842
2843 const size_t global_work_size[3] = { num_elements, 1, 1 };
2844 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2845
2846 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2847
2848 hc_clFlush (data.ocl, device_param->command_queue);
2849
2850 hc_clFinish (data.ocl, device_param->command_queue);
2851 }
2852
2853 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2854 {
2855 uint num_elements = num;
2856
2857 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2858 device_param->kernel_params_amp_buf32[6] = num_elements;
2859
2860 // causes problems with special threads like in bcrypt
2861 // const uint kernel_threads = device_param->kernel_threads;
2862
2863 uint kernel_threads = device_param->kernel_threads;
2864
2865 while (num_elements % kernel_threads) num_elements++;
2866
2867 cl_kernel kernel = device_param->kernel_amp;
2868
2869 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2870 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2871
2872 const size_t global_work_size[3] = { num_elements, 1, 1 };
2873 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2874
2875 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2876
2877 hc_clFlush (data.ocl, device_param->command_queue);
2878
2879 hc_clFinish (data.ocl, device_param->command_queue);
2880 }
2881
2882 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2883 {
2884 const u32 num16d = num / 16;
2885 const u32 num16m = num % 16;
2886
2887 if (num16d)
2888 {
2889 device_param->kernel_params_memset_buf32[1] = value;
2890 device_param->kernel_params_memset_buf32[2] = num16d;
2891
2892 uint kernel_threads = device_param->kernel_threads;
2893
2894 uint num_elements = num16d;
2895
2896 while (num_elements % kernel_threads) num_elements++;
2897
2898 cl_kernel kernel = device_param->kernel_memset;
2899
2900 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2901 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2902 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2903
2904 const size_t global_work_size[3] = { num_elements, 1, 1 };
2905 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2906
2907 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2908
2909 hc_clFlush (data.ocl, device_param->command_queue);
2910
2911 hc_clFinish (data.ocl, device_param->command_queue);
2912 }
2913
2914 if (num16m)
2915 {
2916 u32 tmp[4];
2917
2918 tmp[0] = value;
2919 tmp[1] = value;
2920 tmp[2] = value;
2921 tmp[3] = value;
2922
2923 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2924 }
2925 }
2926
2927 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2928 {
2929 run_kernel_memset (device_param, buf, 0, size);
2930
2931 /*
2932 int rc = -1;
2933
2934 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2935 {
2936 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2937
2938 const cl_uchar zero = 0;
2939
2940 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2941 }
2942
2943 if (rc != 0)
2944 {
2945 // NOTE: clEnqueueFillBuffer () always fails with -59
2946 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2947 // How's that possible, OpenCL 1.2 support is advertised??
2948 // We need to workaround...
2949
2950 #define FILLSZ 0x100000
2951
2952 char *tmp = (char *) mymalloc (FILLSZ);
2953
2954 for (size_t i = 0; i < size; i += FILLSZ)
2955 {
2956 const size_t left = size - i;
2957
2958 const size_t fillsz = MIN (FILLSZ, left);
2959
2960 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2961 }
2962
2963 myfree (tmp);
2964 }
2965 */
2966 }
2967
2968 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)
2969 {
2970 if (data.hash_mode == 2000)
2971 {
2972 process_stdout (device_param, pws_cnt);
2973
2974 return;
2975 }
2976
2977 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2978 {
2979 if (attack_mode == ATTACK_MODE_BF)
2980 {
2981 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2982 {
2983 const uint size_tm = 32 * sizeof (bs_word_t);
2984
2985 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2986
2987 run_kernel_tm (device_param);
2988
2989 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);
2990 }
2991 }
2992
2993 if (highest_pw_len < 16)
2994 {
2995 run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
2996 }
2997 else if (highest_pw_len < 32)
2998 {
2999 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
3000 }
3001 else
3002 {
3003 run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
3004 }
3005 }
3006 else
3007 {
3008 run_kernel_amp (device_param, pws_cnt);
3009
3010 run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
3011
3012 if (opts_type & OPTS_TYPE_HOOK12)
3013 {
3014 run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
3015
3016 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);
3017
3018 // do something with data
3019
3020 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);
3021 }
3022
3023 uint iter = salt_buf->salt_iter;
3024
3025 uint loop_step = device_param->kernel_loops;
3026
3027 for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
3028 {
3029 uint loop_left = iter - loop_pos;
3030
3031 loop_left = MIN (loop_left, loop_step);
3032
3033 device_param->kernel_params_buf32[25] = loop_pos;
3034 device_param->kernel_params_buf32[26] = loop_left;
3035
3036 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
3037
3038 if (data.devices_status == STATUS_CRACKED) break;
3039 if (data.devices_status == STATUS_ABORTED) break;
3040 if (data.devices_status == STATUS_QUIT) break;
3041
3042 /**
3043 * speed
3044 */
3045
3046 const float iter_part = (float) (loop_pos + loop_left) / iter;
3047
3048 const u64 perf_sum_all = pws_cnt * iter_part;
3049
3050 double speed_ms;
3051
3052 hc_timer_get (device_param->timer_speed, speed_ms);
3053
3054 const u32 speed_pos = device_param->speed_pos;
3055
3056 device_param->speed_cnt[speed_pos] = perf_sum_all;
3057
3058 device_param->speed_ms[speed_pos] = speed_ms;
3059
3060 if (data.benchmark == 1)
3061 {
3062 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
3063 }
3064 }
3065
3066 if (opts_type & OPTS_TYPE_HOOK23)
3067 {
3068 run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
3069
3070 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);
3071
3072 // do something with data
3073
3074 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);
3075 }
3076
3077 run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3078 }
3079 }
3080
3081 static int run_rule_engine (const int rule_len, const char *rule_buf)
3082 {
3083 if (rule_len == 0)
3084 {
3085 return 0;
3086 }
3087 else if (rule_len == 1)
3088 {
3089 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3090 }
3091
3092 return 1;
3093 }
3094
3095 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3096 {
3097 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3098 {
3099 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);
3100 }
3101 else if (data.attack_kern == ATTACK_KERN_COMBI)
3102 {
3103 if (data.attack_mode == ATTACK_MODE_COMBI)
3104 {
3105 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3106 {
3107 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3108 {
3109 for (u32 i = 0; i < pws_cnt; i++)
3110 {
3111 const u32 pw_len = device_param->pws_buf[i].pw_len;
3112
3113 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3114
3115 ptr[pw_len] = 0x01;
3116 }
3117 }
3118 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3119 {
3120 for (u32 i = 0; i < pws_cnt; i++)
3121 {
3122 const u32 pw_len = device_param->pws_buf[i].pw_len;
3123
3124 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3125
3126 ptr[pw_len] = 0x80;
3127 }
3128 }
3129 }
3130 }
3131 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3132 {
3133 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3134 {
3135 for (u32 i = 0; i < pws_cnt; i++)
3136 {
3137 const u32 pw_len = device_param->pws_buf[i].pw_len;
3138
3139 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3140
3141 ptr[pw_len] = 0x01;
3142 }
3143 }
3144 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3145 {
3146 for (u32 i = 0; i < pws_cnt; i++)
3147 {
3148 const u32 pw_len = device_param->pws_buf[i].pw_len;
3149
3150 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3151
3152 ptr[pw_len] = 0x80;
3153 }
3154 }
3155 }
3156
3157 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);
3158 }
3159 else if (data.attack_kern == ATTACK_KERN_BF)
3160 {
3161 const u64 off = device_param->words_off;
3162
3163 device_param->kernel_params_mp_l_buf64[3] = off;
3164
3165 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3166 }
3167 }
3168
3169 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3170 {
3171 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3172
3173 device_param->kernel_params_buf32[25] = 0;
3174 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
3175 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3176
3177 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3178 {
3179 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3180 }
3181 else
3182 {
3183 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3184 }
3185
3186 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3187
3188 return exec_ms_prev;
3189 }
3190
3191 static void autotune (hc_device_param_t *device_param)
3192 {
3193 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3194
3195 const u32 kernel_accel_min = device_param->kernel_accel_min;
3196 const u32 kernel_accel_max = device_param->kernel_accel_max;
3197
3198 const u32 kernel_loops_min = device_param->kernel_loops_min;
3199 const u32 kernel_loops_max = device_param->kernel_loops_max;
3200
3201 u32 kernel_accel = kernel_accel_min;
3202 u32 kernel_loops = kernel_loops_min;
3203
3204 // in this case the user specified a fixed -u and -n on the commandline
3205 // no way to tune anything
3206 // but we need to run a few caching rounds
3207
3208 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3209 {
3210 if (data.hash_mode != 2000)
3211 {
3212 try_run (device_param, kernel_accel, kernel_loops);
3213 try_run (device_param, kernel_accel, kernel_loops);
3214 try_run (device_param, kernel_accel, kernel_loops);
3215 try_run (device_param, kernel_accel, kernel_loops);
3216 }
3217
3218 device_param->kernel_accel = kernel_accel;
3219 device_param->kernel_loops = kernel_loops;
3220
3221 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3222
3223 device_param->kernel_power = kernel_power;
3224
3225 return;
3226 }
3227
3228 // from here it's clear we are allowed to autotune
3229 // so let's init some fake words
3230
3231 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3232
3233 if (data.attack_kern == ATTACK_KERN_BF)
3234 {
3235 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3236 }
3237 else
3238 {
3239 for (u32 i = 0; i < kernel_power_max; i++)
3240 {
3241 device_param->pws_buf[i].i[0] = i;
3242 device_param->pws_buf[i].i[1] = 0x01234567;
3243 device_param->pws_buf[i].pw_len = 7 + (i & 7);
3244 }
3245
3246 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);
3247 }
3248
3249 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3250 {
3251 if (data.kernel_rules_cnt > 1)
3252 {
3253 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);
3254 }
3255 }
3256 else
3257 {
3258 run_kernel_amp (device_param, kernel_power_max);
3259 }
3260
3261 #define VERIFIER_CNT 1
3262
3263 // first find out highest kernel-loops that stays below target_ms
3264
3265 if (kernel_loops_min < kernel_loops_max)
3266 {
3267 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3268 {
3269 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3270
3271 for (int i = 0; i < VERIFIER_CNT; i++)
3272 {
3273 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3274
3275 exec_ms = MIN (exec_ms, exec_ms_v);
3276 }
3277
3278 if (exec_ms < target_ms) break;
3279 }
3280 }
3281
3282 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3283
3284 #define STEPS_CNT 10
3285
3286 if (kernel_accel_min < kernel_accel_max)
3287 {
3288 for (int i = 0; i < STEPS_CNT; i++)
3289 {
3290 const u32 kernel_accel_try = 1 << i;
3291
3292 if (kernel_accel_try < kernel_accel_min) continue;
3293 if (kernel_accel_try > kernel_accel_max) break;
3294
3295 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3296
3297 for (int i = 0; i < VERIFIER_CNT; i++)
3298 {
3299 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3300
3301 exec_ms = MIN (exec_ms, exec_ms_v);
3302 }
3303
3304 if (exec_ms > target_ms) break;
3305
3306 kernel_accel = kernel_accel_try;
3307 }
3308 }
3309
3310 // at this point we want to know the actual runtime for the following reason:
3311 // we need a reference for the balancing loop following up, and this
3312 // the balancing loop can have an effect that the creates a new opportunity, for example:
3313 // if the target is 95 ms and the current runtime is 48ms the above loop
3314 // stopped the execution because the previous exec_ms was > 95ms
3315 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3316 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3317
3318 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3319
3320 for (int i = 0; i < VERIFIER_CNT; i++)
3321 {
3322 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3323
3324 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3325 }
3326
3327 u32 diff = kernel_loops - kernel_accel;
3328
3329 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3330 {
3331 u32 kernel_accel_orig = kernel_accel;
3332 u32 kernel_loops_orig = kernel_loops;
3333
3334 for (u32 f = 1; f < 1024; f++)
3335 {
3336 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3337 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3338
3339 if (kernel_accel_try > kernel_accel_max) break;
3340 if (kernel_loops_try < kernel_loops_min) break;
3341
3342 u32 diff_new = kernel_loops_try - kernel_accel_try;
3343
3344 if (diff_new > diff) break;
3345
3346 diff_new = diff;
3347
3348 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3349
3350 for (int i = 0; i < VERIFIER_CNT; i++)
3351 {
3352 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3353
3354 exec_ms = MIN (exec_ms, exec_ms_v);
3355 }
3356
3357 if (exec_ms < exec_ms_pre_final)
3358 {
3359 exec_ms_pre_final = exec_ms;
3360
3361 kernel_accel = kernel_accel_try;
3362 kernel_loops = kernel_loops_try;
3363 }
3364 }
3365 }
3366
3367 const double exec_left = target_ms / exec_ms_pre_final;
3368
3369 const double accel_left = kernel_accel_max / kernel_accel;
3370
3371 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3372
3373 if (exec_accel_min >= 1.0)
3374 {
3375 // this is safe to not overflow kernel_accel_max because of accel_left
3376
3377 kernel_accel = (double) kernel_accel * exec_accel_min;
3378 }
3379
3380 // reset them fake words
3381
3382 /*
3383 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3384
3385 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);
3386 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);
3387 */
3388
3389 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3390
3391 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3392 {
3393 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3394 }
3395
3396 // reset timer
3397
3398 device_param->exec_pos = 0;
3399
3400 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3401
3402 memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3403 memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3404 memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3405
3406 // store
3407
3408 device_param->kernel_accel = kernel_accel;
3409 device_param->kernel_loops = kernel_loops;
3410
3411 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3412
3413 device_param->kernel_power = kernel_power;
3414
3415 #ifdef DEBUG
3416
3417 if (data.quiet == 0)
3418 {
3419 clear_prompt ();
3420
3421 log_info ("- Device #%u: autotuned kernel-accel to %u\n"
3422 "- Device #%u: autotuned kernel-loops to %u\n",
3423 device_param->device_id + 1, kernel_accel,
3424 device_param->device_id + 1, kernel_loops);
3425
3426 fprintf (stdout, "%s", PROMPT);
3427
3428 fflush (stdout);
3429 }
3430
3431 #endif
3432 }
3433
3434 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3435 {
3436 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3437
3438 // init speed timer
3439
3440 uint speed_pos = device_param->speed_pos;
3441
3442 #ifdef _POSIX
3443 if (device_param->timer_speed.tv_sec == 0)
3444 {
3445 hc_timer_set (&device_param->timer_speed);
3446 }
3447 #endif
3448
3449 #ifdef _WIN
3450 if (device_param->timer_speed.QuadPart == 0)
3451 {
3452 hc_timer_set (&device_param->timer_speed);
3453 }
3454 #endif
3455
3456 // find higest password length, this is for optimization stuff
3457
3458 uint highest_pw_len = 0;
3459
3460 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3461 {
3462 }
3463 else if (data.attack_kern == ATTACK_KERN_COMBI)
3464 {
3465 }
3466 else if (data.attack_kern == ATTACK_KERN_BF)
3467 {
3468 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3469 + device_param->kernel_params_mp_l_buf32[5];
3470 }
3471
3472 // iteration type
3473
3474 uint innerloop_step = 0;
3475 uint innerloop_cnt = 0;
3476
3477 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3478 else innerloop_step = 1;
3479
3480 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3481 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3482 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3483
3484 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3485
3486 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3487 {
3488 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3489
3490 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3491
3492 if (data.devices_status == STATUS_CRACKED) break;
3493 if (data.devices_status == STATUS_ABORTED) break;
3494 if (data.devices_status == STATUS_QUIT) break;
3495 if (data.devices_status == STATUS_BYPASS) break;
3496
3497 salt_t *salt_buf = &data.salts_buf[salt_pos];
3498
3499 device_param->kernel_params_buf32[24] = salt_pos;
3500 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3501 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3502
3503 FILE *combs_fp = device_param->combs_fp;
3504
3505 if (data.attack_mode == ATTACK_MODE_COMBI)
3506 {
3507 rewind (combs_fp);
3508 }
3509
3510 // innerloops
3511
3512 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3513 {
3514 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3515
3516 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3517
3518 if (data.devices_status == STATUS_CRACKED) break;
3519 if (data.devices_status == STATUS_ABORTED) break;
3520 if (data.devices_status == STATUS_QUIT) break;
3521 if (data.devices_status == STATUS_BYPASS) break;
3522
3523 uint fast_iteration = 0;
3524
3525 uint innerloop_left = innerloop_cnt - innerloop_pos;
3526
3527 if (innerloop_left > innerloop_step)
3528 {
3529 innerloop_left = innerloop_step;
3530
3531 fast_iteration = 1;
3532 }
3533
3534 device_param->innerloop_pos = innerloop_pos;
3535 device_param->innerloop_left = innerloop_left;
3536
3537 device_param->kernel_params_buf32[27] = innerloop_left;
3538
3539 // i think we can get rid of this
3540 if (innerloop_left == 0)
3541 {
3542 puts ("bug, how should this happen????\n");
3543
3544 continue;
3545 }
3546
3547 if (data.salts_shown[salt_pos] == 1)
3548 {
3549 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3550
3551 continue;
3552 }
3553
3554 // initialize amplifiers
3555
3556 if (data.attack_mode == ATTACK_MODE_COMBI)
3557 {
3558 uint i = 0;
3559
3560 while (i < innerloop_left)
3561 {
3562 if (feof (combs_fp)) break;
3563
3564 int line_len = fgetl (combs_fp, line_buf);
3565
3566 if (line_len >= PW_MAX1) continue;
3567
3568 line_len = convert_from_hex (line_buf, line_len);
3569
3570 char *line_buf_new = line_buf;
3571
3572 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3573 {
3574 char rule_buf_out[BLOCK_SIZE] = { 0 };
3575
3576 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3577
3578 if (rule_len_out < 0)
3579 {
3580 data.words_progress_rejected[salt_pos] += pws_cnt;
3581
3582 continue;
3583 }
3584
3585 line_len = rule_len_out;
3586
3587 line_buf_new = rule_buf_out;
3588 }
3589
3590 line_len = MIN (line_len, PW_DICTMAX);
3591
3592 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3593
3594 memcpy (ptr, line_buf_new, line_len);
3595
3596 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3597
3598 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3599 {
3600 uppercase (ptr, line_len);
3601 }
3602
3603 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3604 {
3605 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3606 {
3607 ptr[line_len] = 0x80;
3608 }
3609
3610 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3611 {
3612 ptr[line_len] = 0x01;
3613 }
3614 }
3615
3616 device_param->combs_buf[i].pw_len = line_len;
3617
3618 i++;
3619 }
3620
3621 for (uint j = i; j < innerloop_left; j++)
3622 {
3623 device_param->combs_buf[j].i[0] = 0;
3624 device_param->combs_buf[j].i[1] = 0;
3625 device_param->combs_buf[j].i[2] = 0;
3626 device_param->combs_buf[j].i[3] = 0;
3627 device_param->combs_buf[j].i[4] = 0;
3628 device_param->combs_buf[j].i[5] = 0;
3629 device_param->combs_buf[j].i[6] = 0;
3630 device_param->combs_buf[j].i[7] = 0;
3631
3632 device_param->combs_buf[j].pw_len = 0;
3633 }
3634
3635 innerloop_left = i;
3636 }
3637 else if (data.attack_mode == ATTACK_MODE_BF)
3638 {
3639 u64 off = innerloop_pos;
3640
3641 device_param->kernel_params_mp_r_buf64[3] = off;
3642
3643 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3644 }
3645 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3646 {
3647 u64 off = innerloop_pos;
3648
3649 device_param->kernel_params_mp_buf64[3] = off;
3650
3651 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3652 }
3653 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3654 {
3655 u64 off = innerloop_pos;
3656
3657 device_param->kernel_params_mp_buf64[3] = off;
3658
3659 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3660 }
3661
3662 // copy amplifiers
3663
3664 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3665 {
3666 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);
3667 }
3668 else if (data.attack_mode == ATTACK_MODE_COMBI)
3669 {
3670 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);
3671 }
3672 else if (data.attack_mode == ATTACK_MODE_BF)
3673 {
3674 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);
3675 }
3676 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3677 {
3678 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);
3679 }
3680 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3681 {
3682 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);
3683 }
3684
3685 if (data.benchmark == 1)
3686 {
3687 hc_timer_set (&device_param->timer_speed);
3688 }
3689
3690 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
3691
3692 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3693
3694 if (data.devices_status == STATUS_CRACKED) break;
3695 if (data.devices_status == STATUS_ABORTED) break;
3696 if (data.devices_status == STATUS_QUIT) break;
3697
3698 /**
3699 * result
3700 */
3701
3702 if (data.benchmark == 0)
3703 {
3704 check_cracked (device_param, salt_pos);
3705 }
3706
3707 /**
3708 * progress
3709 */
3710
3711 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3712
3713 hc_thread_mutex_lock (mux_counter);
3714
3715 data.words_progress_done[salt_pos] += perf_sum_all;
3716
3717 hc_thread_mutex_unlock (mux_counter);
3718
3719 /**
3720 * speed
3721 */
3722
3723 double speed_ms;
3724
3725 hc_timer_get (device_param->timer_speed, speed_ms);
3726
3727 hc_timer_set (&device_param->timer_speed);
3728
3729 // current speed
3730
3731 //hc_thread_mutex_lock (mux_display);
3732
3733 device_param->speed_cnt[speed_pos] = perf_sum_all;
3734
3735 device_param->speed_ms[speed_pos] = speed_ms;
3736
3737 //hc_thread_mutex_unlock (mux_display);
3738
3739 speed_pos++;
3740
3741 if (speed_pos == SPEED_CACHE)
3742 {
3743 speed_pos = 0;
3744 }
3745
3746 /**
3747 * benchmark
3748 */
3749
3750 if (data.benchmark == 1) break;
3751 }
3752 }
3753
3754 device_param->speed_pos = speed_pos;
3755
3756 myfree (line_buf);
3757 }
3758
3759 static void load_segment (wl_data_t *wl_data, FILE *fd)
3760 {
3761 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3762
3763 wl_data->pos = 0;
3764
3765 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3766
3767 wl_data->buf[wl_data->cnt] = 0;
3768
3769 if (wl_data->cnt == 0) return;
3770
3771 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3772
3773 while (!feof (fd))
3774 {
3775 if (wl_data->cnt == wl_data->avail)
3776 {
3777 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3778
3779 wl_data->avail += wl_data->incr;
3780 }
3781
3782 const int c = fgetc (fd);
3783
3784 if (c == EOF) break;
3785
3786 wl_data->buf[wl_data->cnt] = (char) c;
3787
3788 wl_data->cnt++;
3789
3790 if (c == '\n') break;
3791 }
3792
3793 // ensure stream ends with a newline
3794
3795 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3796 {
3797 wl_data->cnt++;
3798
3799 wl_data->buf[wl_data->cnt - 1] = '\n';
3800 }
3801
3802 return;
3803 }
3804
3805 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3806 {
3807 char *ptr = buf;
3808
3809 for (u32 i = 0; i < sz; i++, ptr++)
3810 {
3811 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3812
3813 if (i == 7)
3814 {
3815 *off = i;
3816 *len = i;
3817
3818 return;
3819 }
3820
3821 if (*ptr != '\n') continue;
3822
3823 *off = i + 1;
3824
3825 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3826
3827 *len = i;
3828
3829 return;
3830 }
3831
3832 *off = sz;
3833 *len = sz;
3834 }
3835
3836 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3837 {
3838 char *ptr = buf;
3839
3840 for (u32 i = 0; i < sz; i++, ptr++)
3841 {
3842 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3843
3844 if (*ptr != '\n') continue;
3845
3846 *off = i + 1;
3847
3848 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3849
3850 *len = i;
3851
3852 return;
3853 }
3854
3855 *off = sz;
3856 *len = sz;
3857 }
3858
3859 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3860 {
3861 char *ptr = buf;
3862
3863 for (u32 i = 0; i < sz; i++, ptr++)
3864 {
3865 if (*ptr != '\n') continue;
3866
3867 *off = i + 1;
3868
3869 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3870
3871 *len = i;
3872
3873 return;
3874 }
3875
3876 *off = sz;
3877 *len = sz;
3878 }
3879
3880 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3881 {
3882 while (wl_data->pos < wl_data->cnt)
3883 {
3884 uint off;
3885 uint len;
3886
3887 char *ptr = wl_data->buf + wl_data->pos;
3888
3889 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3890
3891 wl_data->pos += off;
3892
3893 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3894 {
3895 char rule_buf_out[BLOCK_SIZE] = { 0 };
3896
3897 int rule_len_out = -1;
3898
3899 if (len < BLOCK_SIZE)
3900 {
3901 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3902 }
3903
3904 if (rule_len_out < 0)
3905 {
3906 continue;
3907 }
3908
3909 if (rule_len_out > PW_MAX)
3910 {
3911 continue;
3912 }
3913 }
3914 else
3915 {
3916 if (len > PW_MAX)
3917 {
3918 continue;
3919 }
3920 }
3921
3922 *out_buf = ptr;
3923 *out_len = len;
3924
3925 return;
3926 }
3927
3928 if (feof (fd))
3929 {
3930 fprintf (stderr, "BUG feof()!!\n");
3931
3932 return;
3933 }
3934
3935 load_segment (wl_data, fd);
3936
3937 get_next_word (wl_data, fd, out_buf, out_len);
3938 }
3939
3940 #ifdef _POSIX
3941 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3942 #endif
3943
3944 #ifdef _WIN
3945 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3946 #endif
3947 {
3948 hc_signal (NULL);
3949
3950 dictstat_t d;
3951
3952 d.cnt = 0;
3953
3954 #ifdef _POSIX
3955 fstat (fileno (fd), &d.stat);
3956 #endif
3957
3958 #ifdef _WIN
3959 _fstat64 (fileno (fd), &d.stat);
3960 #endif
3961
3962 d.stat.st_mode = 0;
3963 d.stat.st_nlink = 0;
3964 d.stat.st_uid = 0;
3965 d.stat.st_gid = 0;
3966 d.stat.st_rdev = 0;
3967 d.stat.st_atime = 0;
3968
3969 #ifdef _POSIX
3970 d.stat.st_blksize = 0;
3971 d.stat.st_blocks = 0;
3972 #endif
3973
3974 if (d.stat.st_size == 0) return 0;
3975
3976 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3977
3978 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3979 {
3980 if (d_cache)
3981 {
3982 u64 cnt = d_cache->cnt;
3983
3984 u64 keyspace = cnt;
3985
3986 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3987 {
3988 keyspace *= data.kernel_rules_cnt;
3989 }
3990 else if (data.attack_kern == ATTACK_KERN_COMBI)
3991 {
3992 keyspace *= data.combs_cnt;
3993 }
3994
3995 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);
3996 if (data.quiet == 0) log_info ("");
3997
3998 hc_signal (sigHandler_default);
3999
4000 return (keyspace);
4001 }
4002 }
4003
4004 time_t now = 0;
4005 time_t prev = 0;
4006
4007 u64 comp = 0;
4008 u64 cnt = 0;
4009 u64 cnt2 = 0;
4010
4011 while (!feof (fd))
4012 {
4013 load_segment (wl_data, fd);
4014
4015 comp += wl_data->cnt;
4016
4017 u32 i = 0;
4018
4019 while (i < wl_data->cnt)
4020 {
4021 u32 len;
4022 u32 off;
4023
4024 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
4025
4026 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4027 {
4028 char rule_buf_out[BLOCK_SIZE] = { 0 };
4029
4030 int rule_len_out = -1;
4031
4032 if (len < BLOCK_SIZE)
4033 {
4034 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
4035 }
4036
4037 if (rule_len_out < 0)
4038 {
4039 len = PW_MAX1;
4040 }
4041 else
4042 {
4043 len = rule_len_out;
4044 }
4045 }
4046
4047 if (len < PW_MAX1)
4048 {
4049 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4050 {
4051 cnt += data.kernel_rules_cnt;
4052 }
4053 else if (data.attack_kern == ATTACK_KERN_COMBI)
4054 {
4055 cnt += data.combs_cnt;
4056 }
4057
4058 d.cnt++;
4059 }
4060
4061 i += off;
4062
4063 cnt2++;
4064 }
4065
4066 time (&now);
4067
4068 if ((now - prev) == 0) continue;
4069
4070 float percent = (float) comp / (float) d.stat.st_size;
4071
4072 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);
4073
4074 time (&prev);
4075 }
4076
4077 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);
4078 if (data.quiet == 0) log_info ("");
4079
4080 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4081
4082 hc_signal (sigHandler_default);
4083
4084 return (cnt);
4085 }
4086
4087 static void *thread_monitor (void *p)
4088 {
4089 uint runtime_check = 0;
4090 uint remove_check = 0;
4091 uint status_check = 0;
4092 uint restore_check = 0;
4093
4094 uint restore_left = data.restore_timer;
4095 uint remove_left = data.remove_timer;
4096 uint status_left = data.status_timer;
4097
4098 #ifdef HAVE_HWMON
4099 uint hwmon_check = 0;
4100
4101 int slowdown_warnings = 0;
4102
4103 // these variables are mainly used for fan control
4104
4105 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4106
4107 // temperature controller "loopback" values
4108
4109 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4110 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4111
4112 int temp_threshold = 1; // degrees celcius
4113
4114 int fan_speed_min = 15; // in percentage
4115 int fan_speed_max = 100;
4116
4117 time_t last_temp_check_time;
4118 #endif // HAVE_HWMON
4119
4120 uint sleep_time = 1;
4121
4122 if (data.runtime)
4123 {
4124 runtime_check = 1;
4125 }
4126
4127 if (data.restore_timer)
4128 {
4129 restore_check = 1;
4130 }
4131
4132 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4133 {
4134 remove_check = 1;
4135 }
4136
4137 if (data.status == 1)
4138 {
4139 status_check = 1;
4140 }
4141
4142 #ifdef HAVE_HWMON
4143 if (data.gpu_temp_disable == 0)
4144 {
4145 time (&last_temp_check_time);
4146
4147 hwmon_check = 1;
4148 }
4149 #endif
4150
4151 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4152 {
4153 #ifdef HAVE_HWMON
4154 if (hwmon_check == 0)
4155 #endif
4156 return (p);
4157 }
4158
4159 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4160 {
4161 hc_sleep (sleep_time);
4162
4163 if (data.devices_status != STATUS_RUNNING) continue;
4164
4165 #ifdef HAVE_HWMON
4166
4167 if (hwmon_check == 1)
4168 {
4169 hc_thread_mutex_lock (mux_adl);
4170
4171 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4172 {
4173 hc_device_param_t *device_param = &data.devices_param[device_id];
4174
4175 if (device_param->skipped) continue;
4176
4177 if (device_param->device_vendor_id == VENDOR_ID_NV)
4178 {
4179 if (data.hm_nvapi)
4180 {
4181 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
4182 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
4183
4184 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4185 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4186
4187 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4188
4189 perfPolicies_status.info_value = perfPolicies_info.info_value;
4190
4191 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4192
4193 if (perfPolicies_status.throttle & 2)
4194 {
4195 if (slowdown_warnings < 3)
4196 {
4197 if (data.quiet == 0) clear_prompt ();
4198
4199 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4200
4201 if (slowdown_warnings == 2)
4202 {
4203 log_info ("");
4204 }
4205
4206 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4207 if (data.quiet == 0) fflush (stdout);
4208
4209 slowdown_warnings++;
4210 }
4211 }
4212 else
4213 {
4214 slowdown_warnings = 0;
4215 }
4216 }
4217 }
4218 }
4219
4220 hc_thread_mutex_unlock (mux_adl);
4221 }
4222
4223 if (hwmon_check == 1)
4224 {
4225 hc_thread_mutex_lock (mux_adl);
4226
4227 time_t temp_check_time;
4228
4229 time (&temp_check_time);
4230
4231 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4232
4233 if (Ta == 0) Ta = 1;
4234
4235 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4236 {
4237 hc_device_param_t *device_param = &data.devices_param[device_id];
4238
4239 if (device_param->skipped) continue;
4240
4241 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4242
4243 const int temperature = hm_get_temperature_with_device_id (device_id);
4244
4245 if (temperature > (int) data.gpu_temp_abort)
4246 {
4247 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4248
4249 if (data.devices_status != STATUS_QUIT) myabort ();
4250
4251 break;
4252 }
4253
4254 const int gpu_temp_retain = data.gpu_temp_retain;
4255
4256 if (gpu_temp_retain)
4257 {
4258 if (data.hm_device[device_id].fan_set_supported == 1)
4259 {
4260 int temp_cur = temperature;
4261
4262 int temp_diff_new = gpu_temp_retain - temp_cur;
4263
4264 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4265
4266 // calculate Ta value (time difference in seconds between the last check and this check)
4267
4268 last_temp_check_time = temp_check_time;
4269
4270 float Kp = 1.8;
4271 float Ki = 0.005;
4272 float Kd = 6;
4273
4274 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4275
4276 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);
4277
4278 if (abs (fan_diff_required) >= temp_threshold)
4279 {
4280 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4281
4282 int fan_speed_level = fan_speed_cur;
4283
4284 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4285
4286 int fan_speed_new = fan_speed_level - fan_diff_required;
4287
4288 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4289 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4290
4291 if (fan_speed_new != fan_speed_cur)
4292 {
4293 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4294 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4295
4296 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4297 {
4298 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4299 {
4300 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4301 }
4302 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4303 {
4304 #ifdef WIN
4305 hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1);
4306 #endif
4307
4308 #ifdef LINUX
4309 hm_set_fanspeed_with_device_id_xnvctrl (device_id, fan_speed_new);
4310 #endif
4311 }
4312
4313 fan_speed_chgd[device_id] = 1;
4314 }
4315
4316 temp_diff_old[device_id] = temp_diff_new;
4317 }
4318 }
4319 }
4320 }
4321 }
4322
4323 hc_thread_mutex_unlock (mux_adl);
4324 }
4325 #endif // HAVE_HWMON
4326
4327 if (restore_check == 1)
4328 {
4329 restore_left--;
4330
4331 if (restore_left == 0)
4332 {
4333 if (data.restore_disable == 0) cycle_restore ();
4334
4335 restore_left = data.restore_timer;
4336 }
4337 }
4338
4339 if ((runtime_check == 1) && (data.runtime_start > 0))
4340 {
4341 time_t runtime_cur;
4342
4343 time (&runtime_cur);
4344
4345 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4346
4347 if (runtime_left <= 0)
4348 {
4349 if (data.benchmark == 0)
4350 {
4351 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4352 }
4353
4354 if (data.devices_status != STATUS_QUIT) myabort ();
4355 }
4356 }
4357
4358 if (remove_check == 1)
4359 {
4360 remove_left--;
4361
4362 if (remove_left == 0)
4363 {
4364 if (data.digests_saved != data.digests_done)
4365 {
4366 data.digests_saved = data.digests_done;
4367
4368 save_hash ();
4369 }
4370
4371 remove_left = data.remove_timer;
4372 }
4373 }
4374
4375 if (status_check == 1)
4376 {
4377 status_left--;
4378
4379 if (status_left == 0)
4380 {
4381 //hc_thread_mutex_lock (mux_display);
4382
4383 if (data.quiet == 0) clear_prompt ();
4384
4385 if (data.quiet == 0) log_info ("");
4386
4387 status_display ();
4388
4389 if (data.quiet == 0) log_info ("");
4390
4391 //hc_thread_mutex_unlock (mux_display);
4392
4393 status_left = data.status_timer;
4394 }
4395 }
4396 }
4397
4398 #ifdef HAVE_HWMON
4399 myfree (fan_speed_chgd);
4400
4401 myfree (temp_diff_old);
4402 myfree (temp_diff_sum);
4403 #endif
4404
4405 p = NULL;
4406
4407 return (p);
4408 }
4409
4410 static void *thread_outfile_remove (void *p)
4411 {
4412 // some hash-dependent constants
4413 char *outfile_dir = data.outfile_check_directory;
4414 uint dgst_size = data.dgst_size;
4415 uint isSalted = data.isSalted;
4416 uint esalt_size = data.esalt_size;
4417 uint hash_mode = data.hash_mode;
4418
4419 uint outfile_check_timer = data.outfile_check_timer;
4420
4421 char separator = data.separator;
4422
4423 // some hash-dependent functions
4424 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4425 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4426
4427 // buffers
4428 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4429
4430 hash_buf.digest = mymalloc (dgst_size);
4431
4432 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4433
4434 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4435
4436 uint digest_buf[64] = { 0 };
4437
4438 outfile_data_t *out_info = NULL;
4439
4440 char **out_files = NULL;
4441
4442 time_t folder_mtime = 0;
4443
4444 int out_cnt = 0;
4445
4446 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4447
4448 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4449 {
4450 hc_sleep (1);
4451
4452 if (data.devices_status != STATUS_RUNNING) continue;
4453
4454 check_left--;
4455
4456 if (check_left == 0)
4457 {
4458 struct stat outfile_check_stat;
4459
4460 if (stat (outfile_dir, &outfile_check_stat) == 0)
4461 {
4462 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4463
4464 if (is_dir == 1)
4465 {
4466 if (outfile_check_stat.st_mtime > folder_mtime)
4467 {
4468 char **out_files_new = scan_directory (outfile_dir);
4469
4470 int out_cnt_new = count_dictionaries (out_files_new);
4471
4472 outfile_data_t *out_info_new = NULL;
4473
4474 if (out_cnt_new > 0)
4475 {
4476 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4477
4478 for (int i = 0; i < out_cnt_new; i++)
4479 {
4480 out_info_new[i].file_name = out_files_new[i];
4481
4482 // check if there are files that we have seen/checked before (and not changed)
4483
4484 for (int j = 0; j < out_cnt; j++)
4485 {
4486 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4487 {
4488 struct stat outfile_stat;
4489
4490 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4491 {
4492 if (outfile_stat.st_ctime == out_info[j].ctime)
4493 {
4494 out_info_new[i].ctime = out_info[j].ctime;
4495 out_info_new[i].seek = out_info[j].seek;
4496 }
4497 }
4498 }
4499 }
4500 }
4501 }
4502
4503 local_free (out_info);
4504 local_free (out_files);
4505
4506 out_files = out_files_new;
4507 out_cnt = out_cnt_new;
4508 out_info = out_info_new;
4509
4510 folder_mtime = outfile_check_stat.st_mtime;
4511 }
4512
4513 for (int j = 0; j < out_cnt; j++)
4514 {
4515 FILE *fp = fopen (out_info[j].file_name, "rb");
4516
4517 if (fp != NULL)
4518 {
4519 //hc_thread_mutex_lock (mux_display);
4520
4521 #ifdef _POSIX
4522 struct stat outfile_stat;
4523
4524 fstat (fileno (fp), &outfile_stat);
4525 #endif
4526
4527 #ifdef _WIN
4528 struct stat64 outfile_stat;
4529
4530 _fstat64 (fileno (fp), &outfile_stat);
4531 #endif
4532
4533 if (outfile_stat.st_ctime > out_info[j].ctime)
4534 {
4535 out_info[j].ctime = outfile_stat.st_ctime;
4536 out_info[j].seek = 0;
4537 }
4538
4539 fseek (fp, out_info[j].seek, SEEK_SET);
4540
4541 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4542
4543 while (!feof (fp))
4544 {
4545 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4546
4547 if (ptr == NULL) break;
4548
4549 int line_len = strlen (line_buf);
4550
4551 if (line_len <= 0) continue;
4552
4553 int iter = MAX_CUT_TRIES;
4554
4555 for (uint i = line_len - 1; i && iter; i--, line_len--)
4556 {
4557 if (line_buf[i] != separator) continue;
4558
4559 int parser_status = PARSER_OK;
4560
4561 if ((hash_mode != 2500) && (hash_mode != 6800))
4562 {
4563 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4564 }
4565
4566 uint found = 0;
4567
4568 if (parser_status == PARSER_OK)
4569 {
4570 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4571 {
4572 if (data.salts_shown[salt_pos] == 1) continue;
4573
4574 salt_t *salt_buf = &data.salts_buf[salt_pos];
4575
4576 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4577 {
4578 uint idx = salt_buf->digests_offset + digest_pos;
4579
4580 if (data.digests_shown[idx] == 1) continue;
4581
4582 uint cracked = 0;
4583
4584 if (hash_mode == 6800)
4585 {
4586 if (i == salt_buf->salt_len)
4587 {
4588 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4589 }
4590 }
4591 else if (hash_mode == 2500)
4592 {
4593 // BSSID : MAC1 : MAC2 (:plain)
4594 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4595 {
4596 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4597
4598 if (!cracked) continue;
4599
4600 // now compare MAC1 and MAC2 too, since we have this additional info
4601 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4602 char *mac2_pos = mac1_pos + 12 + 1;
4603
4604 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4605 wpa_t *wpa = &wpas[salt_pos];
4606
4607 // compare hex string(s) vs binary MAC address(es)
4608
4609 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4610 {
4611 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4612 {
4613 cracked = 0;
4614
4615 break;
4616 }
4617 }
4618
4619 // early skip ;)
4620 if (!cracked) continue;
4621
4622 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4623 {
4624 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4625 {
4626 cracked = 0;
4627
4628 break;
4629 }
4630 }
4631 }
4632 }
4633 else
4634 {
4635 char *digests_buf_ptr = (char *) data.digests_buf;
4636
4637 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4638
4639 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4640 }
4641
4642 if (cracked == 1)
4643 {
4644 found = 1;
4645
4646 data.digests_shown[idx] = 1;
4647
4648 data.digests_done++;
4649
4650 salt_buf->digests_done++;
4651
4652 if (salt_buf->digests_done == salt_buf->digests_cnt)
4653 {
4654 data.salts_shown[salt_pos] = 1;
4655
4656 data.salts_done++;
4657
4658 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4659 }
4660 }
4661 }
4662
4663 if (data.devices_status == STATUS_CRACKED) break;
4664 }
4665 }
4666
4667 if (found) break;
4668
4669 if (data.devices_status == STATUS_CRACKED) break;
4670
4671 iter--;
4672 }
4673
4674 if (data.devices_status == STATUS_CRACKED) break;
4675 }
4676
4677 myfree (line_buf);
4678
4679 out_info[j].seek = ftell (fp);
4680
4681 //hc_thread_mutex_unlock (mux_display);
4682
4683 fclose (fp);
4684 }
4685 }
4686 }
4687 }
4688
4689 check_left = outfile_check_timer;
4690 }
4691 }
4692
4693 if (esalt_size) local_free (hash_buf.esalt);
4694
4695 if (isSalted) local_free (hash_buf.salt);
4696
4697 local_free (hash_buf.digest);
4698
4699 local_free (out_info);
4700
4701 local_free (out_files);
4702
4703 p = NULL;
4704
4705 return (p);
4706 }
4707
4708 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4709 {
4710 //if (device_param->pws_cnt < device_param->kernel_power)
4711 //{
4712 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4713
4714 u8 *ptr = (u8 *) pw->i;
4715
4716 memcpy (ptr, pw_buf, pw_len);
4717
4718 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4719
4720 pw->pw_len = pw_len;
4721
4722 device_param->pws_cnt++;
4723 //}
4724 //else
4725 //{
4726 // fprintf (stderr, "BUG pw_add()!!\n");
4727 //
4728 // return;
4729 //}
4730 }
4731
4732 static void set_kernel_power_final (const u64 kernel_power_final)
4733 {
4734 if (data.quiet == 0)
4735 {
4736 clear_prompt ();
4737
4738 //log_info ("");
4739
4740 log_info ("INFO: approaching final keyspace, workload adjusted");
4741 log_info ("");
4742
4743 fprintf (stdout, "%s", PROMPT);
4744
4745 fflush (stdout);
4746 }
4747
4748 data.kernel_power_final = kernel_power_final;
4749 }
4750
4751 static u32 get_power (hc_device_param_t *device_param)
4752 {
4753 const u64 kernel_power_final = data.kernel_power_final;
4754
4755 if (kernel_power_final)
4756 {
4757 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4758
4759 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4760
4761 // work should be at least the hardware power available without any accelerator
4762
4763 const u64 work = MAX (words_left_device, device_param->hardware_power);
4764
4765 return work;
4766 }
4767
4768 return device_param->kernel_power;
4769 }
4770
4771 static uint get_work (hc_device_param_t *device_param, const u64 max)
4772 {
4773 hc_thread_mutex_lock (mux_dispatcher);
4774
4775 const u64 words_cur = data.words_cur;
4776 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4777
4778 device_param->words_off = words_cur;
4779
4780 const u64 kernel_power_all = data.kernel_power_all;
4781
4782 const u64 words_left = words_base - words_cur;
4783
4784 if (words_left < kernel_power_all)
4785 {
4786 if (data.kernel_power_final == 0)
4787 {
4788 set_kernel_power_final (words_left);
4789 }
4790 }
4791
4792 const u32 kernel_power = get_power (device_param);
4793
4794 uint work = MIN (words_left, kernel_power);
4795
4796 work = MIN (work, max);
4797
4798 data.words_cur += work;
4799
4800 hc_thread_mutex_unlock (mux_dispatcher);
4801
4802 return work;
4803 }
4804
4805 static void *thread_autotune (void *p)
4806 {
4807 hc_device_param_t *device_param = (hc_device_param_t *) p;
4808
4809 if (device_param->skipped) return NULL;
4810
4811 autotune (device_param);
4812
4813 return NULL;
4814 }
4815
4816 static void *thread_calc_stdin (void *p)
4817 {
4818 hc_device_param_t *device_param = (hc_device_param_t *) p;
4819
4820 if (device_param->skipped) return NULL;
4821
4822 char *buf = (char *) mymalloc (HCBUFSIZ);
4823
4824 const uint attack_kern = data.attack_kern;
4825
4826 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4827 {
4828 hc_thread_mutex_lock (mux_dispatcher);
4829
4830 if (feof (stdin) != 0)
4831 {
4832 hc_thread_mutex_unlock (mux_dispatcher);
4833
4834 break;
4835 }
4836
4837 uint words_cur = 0;
4838
4839 while (words_cur < device_param->kernel_power)
4840 {
4841 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4842
4843 if (line_buf == NULL) break;
4844
4845 uint line_len = in_superchop (line_buf);
4846
4847 line_len = convert_from_hex (line_buf, line_len);
4848
4849 // post-process rule engine
4850
4851 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4852 {
4853 char rule_buf_out[BLOCK_SIZE] = { 0 };
4854
4855 int rule_len_out = -1;
4856
4857 if (line_len < BLOCK_SIZE)
4858 {
4859 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4860 }
4861
4862 if (rule_len_out < 0) continue;
4863
4864 line_buf = rule_buf_out;
4865 line_len = rule_len_out;
4866 }
4867
4868 if (line_len > PW_MAX)
4869 {
4870 continue;
4871 }
4872
4873 // hmm that's always the case, or?
4874
4875 if (attack_kern == ATTACK_KERN_STRAIGHT)
4876 {
4877 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4878 {
4879 hc_thread_mutex_lock (mux_counter);
4880
4881 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4882 {
4883 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4884 }
4885
4886 hc_thread_mutex_unlock (mux_counter);
4887
4888 continue;
4889 }
4890 }
4891
4892 pw_add (device_param, (u8 *) line_buf, line_len);
4893
4894 words_cur++;
4895
4896 if (data.devices_status == STATUS_CRACKED) break;
4897 if (data.devices_status == STATUS_ABORTED) break;
4898 if (data.devices_status == STATUS_QUIT) break;
4899 if (data.devices_status == STATUS_BYPASS) break;
4900 }
4901
4902 hc_thread_mutex_unlock (mux_dispatcher);
4903
4904 if (data.devices_status == STATUS_CRACKED) break;
4905 if (data.devices_status == STATUS_ABORTED) break;
4906 if (data.devices_status == STATUS_QUIT) break;
4907 if (data.devices_status == STATUS_BYPASS) break;
4908
4909 // flush
4910
4911 const uint pws_cnt = device_param->pws_cnt;
4912
4913 if (pws_cnt)
4914 {
4915 run_copy (device_param, pws_cnt);
4916
4917 run_cracker (device_param, pws_cnt);
4918
4919 device_param->pws_cnt = 0;
4920
4921 /*
4922 still required?
4923 if (attack_kern == ATTACK_KERN_STRAIGHT)
4924 {
4925 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4926 }
4927 else if (attack_kern == ATTACK_KERN_COMBI)
4928 {
4929 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4930 }
4931 */
4932 }
4933 }
4934
4935 device_param->kernel_accel = 0;
4936 device_param->kernel_loops = 0;
4937
4938 myfree (buf);
4939
4940 return NULL;
4941 }
4942
4943 static void *thread_calc (void *p)
4944 {
4945 hc_device_param_t *device_param = (hc_device_param_t *) p;
4946
4947 if (device_param->skipped) return NULL;
4948
4949 const uint attack_mode = data.attack_mode;
4950 const uint attack_kern = data.attack_kern;
4951
4952 if (attack_mode == ATTACK_MODE_BF)
4953 {
4954 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4955 {
4956 const uint work = get_work (device_param, -1);
4957
4958 if (work == 0) break;
4959
4960 const u64 words_off = device_param->words_off;
4961 const u64 words_fin = words_off + work;
4962
4963 const uint pws_cnt = work;
4964
4965 device_param->pws_cnt = pws_cnt;
4966
4967 if (pws_cnt)
4968 {
4969 run_copy (device_param, pws_cnt);
4970
4971 run_cracker (device_param, pws_cnt);
4972
4973 device_param->pws_cnt = 0;
4974
4975 /*
4976 still required?
4977 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4978 */
4979 }
4980
4981 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4982
4983 if (data.devices_status == STATUS_CRACKED) break;
4984 if (data.devices_status == STATUS_ABORTED) break;
4985 if (data.devices_status == STATUS_QUIT) break;
4986 if (data.devices_status == STATUS_BYPASS) break;
4987
4988 if (data.benchmark == 1) break;
4989
4990 device_param->words_done = words_fin;
4991 }
4992 }
4993 else
4994 {
4995 const uint segment_size = data.segment_size;
4996
4997 char *dictfile = data.dictfile;
4998
4999 if (attack_mode == ATTACK_MODE_COMBI)
5000 {
5001 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5002 {
5003 dictfile = data.dictfile2;
5004 }
5005 }
5006
5007 FILE *fd = fopen (dictfile, "rb");
5008
5009 if (fd == NULL)
5010 {
5011 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
5012
5013 return NULL;
5014 }
5015
5016 if (attack_mode == ATTACK_MODE_COMBI)
5017 {
5018 const uint combs_mode = data.combs_mode;
5019
5020 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
5021 {
5022 const char *dictfilec = data.dictfile2;
5023
5024 FILE *combs_fp = fopen (dictfilec, "rb");
5025
5026 if (combs_fp == NULL)
5027 {
5028 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5029
5030 fclose (fd);
5031
5032 return NULL;
5033 }
5034
5035 device_param->combs_fp = combs_fp;
5036 }
5037 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5038 {
5039 const char *dictfilec = data.dictfile;
5040
5041 FILE *combs_fp = fopen (dictfilec, "rb");
5042
5043 if (combs_fp == NULL)
5044 {
5045 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5046
5047 fclose (fd);
5048
5049 return NULL;
5050 }
5051
5052 device_param->combs_fp = combs_fp;
5053 }
5054 }
5055
5056 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
5057
5058 wl_data->buf = (char *) mymalloc (segment_size);
5059 wl_data->avail = segment_size;
5060 wl_data->incr = segment_size;
5061 wl_data->cnt = 0;
5062 wl_data->pos = 0;
5063
5064 u64 words_cur = 0;
5065
5066 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5067 {
5068 u64 words_off = 0;
5069 u64 words_fin = 0;
5070
5071 u64 max = -1;
5072
5073 while (max)
5074 {
5075 const uint work = get_work (device_param, max);
5076
5077 if (work == 0) break;
5078
5079 max = 0;
5080
5081 words_off = device_param->words_off;
5082 words_fin = words_off + work;
5083
5084 char *line_buf;
5085 uint line_len;
5086
5087 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5088
5089 for ( ; words_cur < words_fin; words_cur++)
5090 {
5091 get_next_word (wl_data, fd, &line_buf, &line_len);
5092
5093 line_len = convert_from_hex (line_buf, line_len);
5094
5095 // post-process rule engine
5096
5097 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5098 {
5099 char rule_buf_out[BLOCK_SIZE] = { 0 };
5100
5101 int rule_len_out = -1;
5102
5103 if (line_len < BLOCK_SIZE)
5104 {
5105 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5106 }
5107
5108 if (rule_len_out < 0) continue;
5109
5110 line_buf = rule_buf_out;
5111 line_len = rule_len_out;
5112 }
5113
5114 if (attack_kern == ATTACK_KERN_STRAIGHT)
5115 {
5116 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5117 {
5118 max++;
5119
5120 hc_thread_mutex_lock (mux_counter);
5121
5122 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5123 {
5124 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5125 }
5126
5127 hc_thread_mutex_unlock (mux_counter);
5128
5129 continue;
5130 }
5131 }
5132 else if (attack_kern == ATTACK_KERN_COMBI)
5133 {
5134 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5135 // since we still need to combine the plains
5136
5137 if (line_len > data.pw_max)
5138 {
5139 max++;
5140
5141 hc_thread_mutex_lock (mux_counter);
5142
5143 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5144 {
5145 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5146 }
5147
5148 hc_thread_mutex_unlock (mux_counter);
5149
5150 continue;
5151 }
5152 }
5153
5154 pw_add (device_param, (u8 *) line_buf, line_len);
5155
5156 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5157
5158 if (data.devices_status == STATUS_CRACKED) break;
5159 if (data.devices_status == STATUS_ABORTED) break;
5160 if (data.devices_status == STATUS_QUIT) break;
5161 if (data.devices_status == STATUS_BYPASS) break;
5162 }
5163
5164 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5165
5166 if (data.devices_status == STATUS_CRACKED) break;
5167 if (data.devices_status == STATUS_ABORTED) break;
5168 if (data.devices_status == STATUS_QUIT) break;
5169 if (data.devices_status == STATUS_BYPASS) break;
5170 }
5171
5172 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5173
5174 if (data.devices_status == STATUS_CRACKED) break;
5175 if (data.devices_status == STATUS_ABORTED) break;
5176 if (data.devices_status == STATUS_QUIT) break;
5177 if (data.devices_status == STATUS_BYPASS) break;
5178
5179 //
5180 // flush
5181 //
5182
5183 const uint pws_cnt = device_param->pws_cnt;
5184
5185 if (pws_cnt)
5186 {
5187 run_copy (device_param, pws_cnt);
5188
5189 run_cracker (device_param, pws_cnt);
5190
5191 device_param->pws_cnt = 0;
5192
5193 /*
5194 still required?
5195 if (attack_kern == ATTACK_KERN_STRAIGHT)
5196 {
5197 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5198 }
5199 else if (attack_kern == ATTACK_KERN_COMBI)
5200 {
5201 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5202 }
5203 */
5204 }
5205
5206 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5207
5208 if (data.devices_status == STATUS_CRACKED) break;
5209 if (data.devices_status == STATUS_ABORTED) break;
5210 if (data.devices_status == STATUS_QUIT) break;
5211 if (data.devices_status == STATUS_BYPASS) break;
5212
5213 if (words_fin == 0) break;
5214
5215 device_param->words_done = words_fin;
5216 }
5217
5218 if (attack_mode == ATTACK_MODE_COMBI)
5219 {
5220 fclose (device_param->combs_fp);
5221 }
5222
5223 free (wl_data->buf);
5224 free (wl_data);
5225
5226 fclose (fd);
5227 }
5228
5229 device_param->kernel_accel = 0;
5230 device_param->kernel_loops = 0;
5231
5232 return NULL;
5233 }
5234
5235 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5236 {
5237 if (!device_param)
5238 {
5239 log_error ("ERROR: %s : Invalid argument", __func__);
5240
5241 exit (-1);
5242 }
5243
5244 salt_t *salt_buf = &data.salts_buf[salt_pos];
5245
5246 device_param->kernel_params_buf32[24] = salt_pos;
5247 device_param->kernel_params_buf32[27] = 1;
5248 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
5249 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
5250 device_param->kernel_params_buf32[30] = 0;
5251 device_param->kernel_params_buf32[31] = 1;
5252
5253 char *dictfile_old = data.dictfile;
5254
5255 const char *weak_hash_check = "weak-hash-check";
5256
5257 data.dictfile = (char *) weak_hash_check;
5258
5259 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5260
5261 data.kernel_rules_buf[0].cmds[0] = 0;
5262
5263 /**
5264 * run the kernel
5265 */
5266
5267 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5268 {
5269 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5270 }
5271 else
5272 {
5273 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5274
5275 uint loop_step = 16;
5276
5277 const uint iter = salt_buf->salt_iter;
5278
5279 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5280 {
5281 uint loop_left = iter - loop_pos;
5282
5283 loop_left = MIN (loop_left, loop_step);
5284
5285 device_param->kernel_params_buf32[25] = loop_pos;
5286 device_param->kernel_params_buf32[26] = loop_left;
5287
5288 run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5289 }
5290
5291 run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5292 }
5293
5294 /**
5295 * result
5296 */
5297
5298 check_cracked (device_param, salt_pos);
5299
5300 /**
5301 * cleanup
5302 */
5303
5304 device_param->kernel_params_buf32[24] = 0;
5305 device_param->kernel_params_buf32[25] = 0;
5306 device_param->kernel_params_buf32[26] = 0;
5307 device_param->kernel_params_buf32[27] = 0;
5308 device_param->kernel_params_buf32[28] = 0;
5309 device_param->kernel_params_buf32[29] = 0;
5310 device_param->kernel_params_buf32[30] = 0;
5311 device_param->kernel_params_buf32[31] = 0;
5312
5313 data.dictfile = dictfile_old;
5314
5315 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5316 }
5317
5318 // hlfmt hashcat
5319
5320 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5321 {
5322 if (data.username == 0)
5323 {
5324 *hashbuf_pos = line_buf;
5325 *hashbuf_len = line_len;
5326 }
5327 else
5328 {
5329 char *pos = line_buf;
5330 int len = line_len;
5331
5332 for (int i = 0; i < line_len; i++, pos++, len--)
5333 {
5334 if (line_buf[i] == data.separator)
5335 {
5336 pos++;
5337
5338 len--;
5339
5340 break;
5341 }
5342 }
5343
5344 *hashbuf_pos = pos;
5345 *hashbuf_len = len;
5346 }
5347 }
5348
5349 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5350 {
5351 char *pos = NULL;
5352 int len = 0;
5353
5354 int sep_cnt = 0;
5355
5356 for (int i = 0; i < line_len; i++)
5357 {
5358 if (line_buf[i] == data.separator)
5359 {
5360 sep_cnt++;
5361
5362 continue;
5363 }
5364
5365 if (sep_cnt == 0)
5366 {
5367 if (pos == NULL) pos = line_buf + i;
5368
5369 len++;
5370 }
5371 }
5372
5373 *userbuf_pos = pos;
5374 *userbuf_len = len;
5375 }
5376
5377 // hlfmt pwdump
5378
5379 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5380 {
5381 int sep_cnt = 0;
5382
5383 int sep2_len = 0;
5384 int sep3_len = 0;
5385
5386 for (int i = 0; i < line_len; i++)
5387 {
5388 if (line_buf[i] == ':')
5389 {
5390 sep_cnt++;
5391
5392 continue;
5393 }
5394
5395 if (sep_cnt == 2) sep2_len++;
5396 if (sep_cnt == 3) sep3_len++;
5397 }
5398
5399 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5400
5401 return 0;
5402 }
5403
5404 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5405 {
5406 char *pos = NULL;
5407 int len = 0;
5408
5409 int sep_cnt = 0;
5410
5411 for (int i = 0; i < line_len; i++)
5412 {
5413 if (line_buf[i] == ':')
5414 {
5415 sep_cnt++;
5416
5417 continue;
5418 }
5419
5420 if (data.hash_mode == 1000)
5421 {
5422 if (sep_cnt == 3)
5423 {
5424 if (pos == NULL) pos = line_buf + i;
5425
5426 len++;
5427 }
5428 }
5429 else if (data.hash_mode == 3000)
5430 {
5431 if (sep_cnt == 2)
5432 {
5433 if (pos == NULL) pos = line_buf + i;
5434
5435 len++;
5436 }
5437 }
5438 }
5439
5440 *hashbuf_pos = pos;
5441 *hashbuf_len = len;
5442 }
5443
5444 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5445 {
5446 char *pos = NULL;
5447 int len = 0;
5448
5449 int sep_cnt = 0;
5450
5451 for (int i = 0; i < line_len; i++)
5452 {
5453 if (line_buf[i] == ':')
5454 {
5455 sep_cnt++;
5456
5457 continue;
5458 }
5459
5460 if (sep_cnt == 0)
5461 {
5462 if (pos == NULL) pos = line_buf + i;
5463
5464 len++;
5465 }
5466 }
5467
5468 *userbuf_pos = pos;
5469 *userbuf_len = len;
5470 }
5471
5472 // hlfmt passwd
5473
5474 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5475 {
5476 int sep_cnt = 0;
5477
5478 char sep5_first = 0;
5479 char sep6_first = 0;
5480
5481 for (int i = 0; i < line_len; i++)
5482 {
5483 if (line_buf[i] == ':')
5484 {
5485 sep_cnt++;
5486
5487 continue;
5488 }
5489
5490 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5491 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5492 }
5493
5494 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5495
5496 return 0;
5497 }
5498
5499 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5500 {
5501 char *pos = NULL;
5502 int len = 0;
5503
5504 int sep_cnt = 0;
5505
5506 for (int i = 0; i < line_len; i++)
5507 {
5508 if (line_buf[i] == ':')
5509 {
5510 sep_cnt++;
5511
5512 continue;
5513 }
5514
5515 if (sep_cnt == 1)
5516 {
5517 if (pos == NULL) pos = line_buf + i;
5518
5519 len++;
5520 }
5521 }
5522
5523 *hashbuf_pos = pos;
5524 *hashbuf_len = len;
5525 }
5526
5527 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5528 {
5529 char *pos = NULL;
5530 int len = 0;
5531
5532 int sep_cnt = 0;
5533
5534 for (int i = 0; i < line_len; i++)
5535 {
5536 if (line_buf[i] == ':')
5537 {
5538 sep_cnt++;
5539
5540 continue;
5541 }
5542
5543 if (sep_cnt == 0)
5544 {
5545 if (pos == NULL) pos = line_buf + i;
5546
5547 len++;
5548 }
5549 }
5550
5551 *userbuf_pos = pos;
5552 *userbuf_len = len;
5553 }
5554
5555 // hlfmt shadow
5556
5557 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5558 {
5559 int sep_cnt = 0;
5560
5561 for (int i = 0; i < line_len; i++)
5562 {
5563 if (line_buf[i] == ':') sep_cnt++;
5564 }
5565
5566 if (sep_cnt == 8) return 1;
5567
5568 return 0;
5569 }
5570
5571 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5572 {
5573 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5574 }
5575
5576 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5577 {
5578 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5579 }
5580
5581 // hlfmt main
5582
5583 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5584 {
5585 switch (hashfile_format)
5586 {
5587 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5588 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5589 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5590 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5591 }
5592 }
5593
5594 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5595 {
5596 switch (hashfile_format)
5597 {
5598 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5599 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5600 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5601 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5602 }
5603 }
5604
5605 char *strhlfmt (const uint hashfile_format)
5606 {
5607 switch (hashfile_format)
5608 {
5609 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5610 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5611 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5612 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5613 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5614 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5615 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5616 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5617 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5618 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5619 }
5620
5621 return ((char *) "Unknown");
5622 }
5623
5624 static uint hlfmt_detect (FILE *fp, uint max_check)
5625 {
5626 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5627
5628 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5629 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5630
5631 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5632
5633 uint num_check = 0;
5634
5635 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5636
5637 while (!feof (fp))
5638 {
5639 int line_len = fgetl (fp, line_buf);
5640
5641 if (line_len == 0) continue;
5642
5643 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5644 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5645 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5646
5647 if (num_check == max_check) break;
5648
5649 num_check++;
5650 }
5651
5652 myfree (line_buf);
5653
5654 uint hashlist_format = HLFMT_HASHCAT;
5655
5656 for (int i = 1; i < HLFMTS_CNT; i++)
5657 {
5658 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5659
5660 hashlist_format = i;
5661 }
5662
5663 free (formats_cnt);
5664
5665 return hashlist_format;
5666 }
5667
5668 /**
5669 * some further helper function
5670 */
5671
5672 // wrapper around mymalloc for ADL
5673
5674 #if defined(HAVE_HWMON)
5675 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5676 {
5677 return mymalloc (iSize);
5678 }
5679 #endif
5680
5681 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)
5682 {
5683 u64 collisions = 0;
5684
5685 const uint dgst_pos0 = data.dgst_pos0;
5686 const uint dgst_pos1 = data.dgst_pos1;
5687 const uint dgst_pos2 = data.dgst_pos2;
5688 const uint dgst_pos3 = data.dgst_pos3;
5689
5690 memset (bitmap_a, 0, bitmap_size);
5691 memset (bitmap_b, 0, bitmap_size);
5692 memset (bitmap_c, 0, bitmap_size);
5693 memset (bitmap_d, 0, bitmap_size);
5694
5695 for (uint i = 0; i < digests_cnt; i++)
5696 {
5697 uint *digest_ptr = (uint *) digests_buf_ptr;
5698
5699 digests_buf_ptr += dgst_size;
5700
5701 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5702 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5703 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5704 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5705
5706 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5707 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5708 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5709 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5710
5711 if (bitmap_a[idx0] & val0) collisions++;
5712 if (bitmap_b[idx1] & val1) collisions++;
5713 if (bitmap_c[idx2] & val2) collisions++;
5714 if (bitmap_d[idx3] & val3) collisions++;
5715
5716 bitmap_a[idx0] |= val0;
5717 bitmap_b[idx1] |= val1;
5718 bitmap_c[idx2] |= val2;
5719 bitmap_d[idx3] |= val3;
5720
5721 if (collisions >= collisions_max) return 0x7fffffff;
5722 }
5723
5724 return collisions;
5725 }
5726
5727 /**
5728 * main
5729 */
5730
5731 #ifdef WIN
5732 void SetConsoleWindowSize (const int x)
5733 {
5734 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5735
5736 if (h == INVALID_HANDLE_VALUE) return;
5737
5738 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5739
5740 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5741
5742 SMALL_RECT *sr = &bufferInfo.srWindow;
5743
5744 sr->Right = MAX (sr->Right, x - 1);
5745
5746 COORD co;
5747
5748 co.X = sr->Right + 1;
5749 co.Y = 9999;
5750
5751 if (!SetConsoleScreenBufferSize (h, co)) return;
5752
5753 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5754 }
5755 #endif
5756
5757 int main (int argc, char **argv)
5758 {
5759 #ifdef WIN
5760 SetConsoleWindowSize (132);
5761 #endif
5762
5763 /**
5764 * To help users a bit
5765 */
5766
5767 char *compute = getenv ("COMPUTE");
5768
5769 if (compute)
5770 {
5771 static char display[100];
5772
5773 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5774
5775 putenv (display);
5776 }
5777 else
5778 {
5779 if (getenv ("DISPLAY") == NULL)
5780 putenv ((char *) "DISPLAY=:0");
5781 }
5782
5783 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5784 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5785
5786 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5787 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5788
5789 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5790 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5791
5792 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5793 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5794
5795 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5796 putenv ((char *) "POCL_KERNEL_CACHE=0");
5797
5798 umask (077);
5799
5800 /**
5801 * Real init
5802 */
5803
5804 memset (&data, 0, sizeof (hc_global_data_t));
5805
5806 time_t proc_start;
5807
5808 time (&proc_start);
5809
5810 data.proc_start = proc_start;
5811
5812 int myargc = argc;
5813 char **myargv = argv;
5814
5815 hc_thread_mutex_init (mux_dispatcher);
5816 hc_thread_mutex_init (mux_counter);
5817 hc_thread_mutex_init (mux_display);
5818 hc_thread_mutex_init (mux_adl);
5819
5820 /**
5821 * commandline parameters
5822 */
5823
5824 uint usage = USAGE;
5825 uint version = VERSION;
5826 uint quiet = QUIET;
5827 uint benchmark = BENCHMARK;
5828 uint stdout_flag = STDOUT_FLAG;
5829 uint show = SHOW;
5830 uint left = LEFT;
5831 uint username = USERNAME;
5832 uint remove = REMOVE;
5833 uint remove_timer = REMOVE_TIMER;
5834 u64 skip = SKIP;
5835 u64 limit = LIMIT;
5836 uint keyspace = KEYSPACE;
5837 uint potfile_disable = POTFILE_DISABLE;
5838 char *potfile_path = NULL;
5839 uint debug_mode = DEBUG_MODE;
5840 char *debug_file = NULL;
5841 char *induction_dir = NULL;
5842 char *outfile_check_dir = NULL;
5843 uint force = FORCE;
5844 uint runtime = RUNTIME;
5845 uint hash_mode = HASH_MODE;
5846 uint attack_mode = ATTACK_MODE;
5847 uint markov_disable = MARKOV_DISABLE;
5848 uint markov_classic = MARKOV_CLASSIC;
5849 uint markov_threshold = MARKOV_THRESHOLD;
5850 char *markov_hcstat = NULL;
5851 char *outfile = NULL;
5852 uint outfile_format = OUTFILE_FORMAT;
5853 uint outfile_autohex = OUTFILE_AUTOHEX;
5854 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5855 uint restore = RESTORE;
5856 uint restore_timer = RESTORE_TIMER;
5857 uint restore_disable = RESTORE_DISABLE;
5858 uint status = STATUS;
5859 uint status_timer = STATUS_TIMER;
5860 uint machine_readable = MACHINE_READABLE;
5861 uint loopback = LOOPBACK;
5862 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5863 char *session = NULL;
5864 uint hex_charset = HEX_CHARSET;
5865 uint hex_salt = HEX_SALT;
5866 uint hex_wordlist = HEX_WORDLIST;
5867 uint rp_gen = RP_GEN;
5868 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5869 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5870 uint rp_gen_seed = RP_GEN_SEED;
5871 char *rule_buf_l = (char *) RULE_BUF_L;
5872 char *rule_buf_r = (char *) RULE_BUF_R;
5873 uint increment = INCREMENT;
5874 uint increment_min = INCREMENT_MIN;
5875 uint increment_max = INCREMENT_MAX;
5876 char *cpu_affinity = NULL;
5877 OCL_PTR *ocl = NULL;
5878 char *opencl_devices = NULL;
5879 char *opencl_platforms = NULL;
5880 char *opencl_device_types = NULL;
5881 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5882 char *truecrypt_keyfiles = NULL;
5883 char *veracrypt_keyfiles = NULL;
5884 uint veracrypt_pim = 0;
5885 uint workload_profile = WORKLOAD_PROFILE;
5886 uint kernel_accel = KERNEL_ACCEL;
5887 uint kernel_loops = KERNEL_LOOPS;
5888 uint nvidia_spin_damp = NVIDIA_SPIN_DAMP;
5889 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5890 #ifdef HAVE_HWMON
5891 uint gpu_temp_abort = GPU_TEMP_ABORT;
5892 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5893 uint powertune_enable = POWERTUNE_ENABLE;
5894 #endif
5895 uint logfile_disable = LOGFILE_DISABLE;
5896 uint segment_size = SEGMENT_SIZE;
5897 uint scrypt_tmto = SCRYPT_TMTO;
5898 char separator = SEPARATOR;
5899 uint bitmap_min = BITMAP_MIN;
5900 uint bitmap_max = BITMAP_MAX;
5901 char *custom_charset_1 = NULL;
5902 char *custom_charset_2 = NULL;
5903 char *custom_charset_3 = NULL;
5904 char *custom_charset_4 = NULL;
5905
5906 #define IDX_HELP 'h'
5907 #define IDX_VERSION 'V'
5908 #define IDX_VERSION_LOWER 'v'
5909 #define IDX_QUIET 0xff02
5910 #define IDX_SHOW 0xff03
5911 #define IDX_LEFT 0xff04
5912 #define IDX_REMOVE 0xff05
5913 #define IDX_REMOVE_TIMER 0xff37
5914 #define IDX_SKIP 's'
5915 #define IDX_LIMIT 'l'
5916 #define IDX_KEYSPACE 0xff35
5917 #define IDX_POTFILE_DISABLE 0xff06
5918 #define IDX_POTFILE_PATH 0xffe0
5919 #define IDX_DEBUG_MODE 0xff43
5920 #define IDX_DEBUG_FILE 0xff44
5921 #define IDX_INDUCTION_DIR 0xff46
5922 #define IDX_OUTFILE_CHECK_DIR 0xff47
5923 #define IDX_USERNAME 0xff07
5924 #define IDX_FORCE 0xff08
5925 #define IDX_RUNTIME 0xff09
5926 #define IDX_BENCHMARK 'b'
5927 #define IDX_STDOUT_FLAG 0xff77
5928 #define IDX_HASH_MODE 'm'
5929 #define IDX_ATTACK_MODE 'a'
5930 #define IDX_RP_FILE 'r'
5931 #define IDX_RP_GEN 'g'
5932 #define IDX_RP_GEN_FUNC_MIN 0xff10
5933 #define IDX_RP_GEN_FUNC_MAX 0xff11
5934 #define IDX_RP_GEN_SEED 0xff34
5935 #define IDX_RULE_BUF_L 'j'
5936 #define IDX_RULE_BUF_R 'k'
5937 #define IDX_INCREMENT 'i'
5938 #define IDX_INCREMENT_MIN 0xff12
5939 #define IDX_INCREMENT_MAX 0xff13
5940 #define IDX_OUTFILE 'o'
5941 #define IDX_OUTFILE_FORMAT 0xff14
5942 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5943 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5944 #define IDX_RESTORE 0xff15
5945 #define IDX_RESTORE_DISABLE 0xff27
5946 #define IDX_STATUS 0xff17
5947 #define IDX_STATUS_TIMER 0xff18
5948 #define IDX_MACHINE_READABLE 0xff50
5949 #define IDX_LOOPBACK 0xff38
5950 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5951 #define IDX_SESSION 0xff19
5952 #define IDX_HEX_CHARSET 0xff20
5953 #define IDX_HEX_SALT 0xff21
5954 #define IDX_HEX_WORDLIST 0xff40
5955 #define IDX_MARKOV_DISABLE 0xff22
5956 #define IDX_MARKOV_CLASSIC 0xff23
5957 #define IDX_MARKOV_THRESHOLD 't'
5958 #define IDX_MARKOV_HCSTAT 0xff24
5959 #define IDX_CPU_AFFINITY 0xff25
5960 #define IDX_OPENCL_DEVICES 'd'
5961 #define IDX_OPENCL_PLATFORMS 0xff72
5962 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5963 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5964 #define IDX_WORKLOAD_PROFILE 'w'
5965 #define IDX_KERNEL_ACCEL 'n'
5966 #define IDX_KERNEL_LOOPS 'u'
5967 #define IDX_NVIDIA_SPIN_DAMP 0xff79
5968 #define IDX_GPU_TEMP_DISABLE 0xff29
5969 #define IDX_GPU_TEMP_ABORT 0xff30
5970 #define IDX_GPU_TEMP_RETAIN 0xff31
5971 #define IDX_POWERTUNE_ENABLE 0xff41
5972 #define IDX_LOGFILE_DISABLE 0xff51
5973 #define IDX_TRUECRYPT_KEYFILES 0xff52
5974 #define IDX_VERACRYPT_KEYFILES 0xff53
5975 #define IDX_VERACRYPT_PIM 0xff54
5976 #define IDX_SCRYPT_TMTO 0xff61
5977 #define IDX_SEGMENT_SIZE 'c'
5978 #define IDX_SEPARATOR 'p'
5979 #define IDX_BITMAP_MIN 0xff70
5980 #define IDX_BITMAP_MAX 0xff71
5981 #define IDX_CUSTOM_CHARSET_1 '1'
5982 #define IDX_CUSTOM_CHARSET_2 '2'
5983 #define IDX_CUSTOM_CHARSET_3 '3'
5984 #define IDX_CUSTOM_CHARSET_4 '4'
5985
5986 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5987
5988 struct option long_options[] =
5989 {
5990 {"help", no_argument, 0, IDX_HELP},
5991 {"version", no_argument, 0, IDX_VERSION},
5992 {"quiet", no_argument, 0, IDX_QUIET},
5993 {"show", no_argument, 0, IDX_SHOW},
5994 {"left", no_argument, 0, IDX_LEFT},
5995 {"username", no_argument, 0, IDX_USERNAME},
5996 {"remove", no_argument, 0, IDX_REMOVE},
5997 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5998 {"skip", required_argument, 0, IDX_SKIP},
5999 {"limit", required_argument, 0, IDX_LIMIT},
6000 {"keyspace", no_argument, 0, IDX_KEYSPACE},
6001 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
6002 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
6003 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
6004 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
6005 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
6006 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
6007 {"force", no_argument, 0, IDX_FORCE},
6008 {"benchmark", no_argument, 0, IDX_BENCHMARK},
6009 {"stdout", no_argument, 0, IDX_STDOUT_FLAG},
6010 {"restore", no_argument, 0, IDX_RESTORE},
6011 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
6012 {"status", no_argument, 0, IDX_STATUS},
6013 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
6014 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
6015 {"loopback", no_argument, 0, IDX_LOOPBACK},
6016 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
6017 {"session", required_argument, 0, IDX_SESSION},
6018 {"runtime", required_argument, 0, IDX_RUNTIME},
6019 {"generate-rules", required_argument, 0, IDX_RP_GEN},
6020 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
6021 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
6022 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
6023 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
6024 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
6025 {"hash-type", required_argument, 0, IDX_HASH_MODE},
6026 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
6027 {"rules-file", required_argument, 0, IDX_RP_FILE},
6028 {"outfile", required_argument, 0, IDX_OUTFILE},
6029 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
6030 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
6031 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
6032 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
6033 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
6034 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
6035 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
6036 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
6037 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
6038 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
6039 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
6040 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
6041 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
6042 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
6043 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
6044 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
6045 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
6046 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
6047 {"nvidia-spin-damp", required_argument, 0, IDX_NVIDIA_SPIN_DAMP},
6048 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
6049 #ifdef HAVE_HWMON
6050 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
6051 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
6052 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
6053 #endif // HAVE_HWMON
6054 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
6055 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
6056 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
6057 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
6058 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
6059 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
6060 {"seperator", required_argument, 0, IDX_SEPARATOR},
6061 {"separator", required_argument, 0, IDX_SEPARATOR},
6062 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
6063 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
6064 {"increment", no_argument, 0, IDX_INCREMENT},
6065 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
6066 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
6067 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
6068 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
6069 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
6070 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
6071 {0, 0, 0, 0}
6072 };
6073
6074 uint rp_files_cnt = 0;
6075
6076 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6077
6078 int option_index = 0;
6079 int c = -1;
6080
6081 optind = 1;
6082 optopt = 0;
6083
6084 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6085 {
6086 switch (c)
6087 {
6088 case IDX_HELP: usage = 1; break;
6089 case IDX_VERSION:
6090 case IDX_VERSION_LOWER: version = 1; break;
6091 case IDX_RESTORE: restore = 1; break;
6092 case IDX_SESSION: session = optarg; break;
6093 case IDX_SHOW: show = 1; break;
6094 case IDX_LEFT: left = 1; break;
6095 case '?': return (-1);
6096 }
6097 }
6098
6099 if (optopt != 0)
6100 {
6101 log_error ("ERROR: Invalid argument specified");
6102
6103 return (-1);
6104 }
6105
6106 /**
6107 * exit functions
6108 */
6109
6110 if (version)
6111 {
6112 log_info ("%s", VERSION_TAG);
6113
6114 return (0);
6115 }
6116
6117 if (usage)
6118 {
6119 usage_big_print (PROGNAME);
6120
6121 return (0);
6122 }
6123
6124 /**
6125 * session needs to be set, always!
6126 */
6127
6128 if (session == NULL) session = (char *) PROGNAME;
6129
6130 /**
6131 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6132 */
6133
6134 char *exec_path = get_exec_path ();
6135
6136 #ifdef LINUX
6137
6138 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6139 char *resolved_exec_path = realpath (exec_path, NULL);
6140
6141 char *install_dir = get_install_dir (resolved_exec_path);
6142 char *profile_dir = NULL;
6143 char *session_dir = NULL;
6144 char *shared_dir = NULL;
6145
6146 if (strcmp (install_dir, resolved_install_folder) == 0)
6147 {
6148 struct passwd *pw = getpwuid (getuid ());
6149
6150 const char *homedir = pw->pw_dir;
6151
6152 profile_dir = get_profile_dir (homedir);
6153 session_dir = get_session_dir (profile_dir);
6154 shared_dir = strdup (SHARED_FOLDER);
6155
6156 mkdir (profile_dir, 0700);
6157 mkdir (session_dir, 0700);
6158 }
6159 else
6160 {
6161 profile_dir = install_dir;
6162 session_dir = install_dir;
6163 shared_dir = install_dir;
6164 }
6165
6166 myfree (resolved_install_folder);
6167 myfree (resolved_exec_path);
6168
6169 #else
6170
6171 char *install_dir = get_install_dir (exec_path);
6172 char *profile_dir = install_dir;
6173 char *session_dir = install_dir;
6174 char *shared_dir = install_dir;
6175
6176 #endif
6177
6178 data.install_dir = install_dir;
6179 data.profile_dir = profile_dir;
6180 data.session_dir = session_dir;
6181 data.shared_dir = shared_dir;
6182
6183 myfree (exec_path);
6184
6185 /**
6186 * kernel cache, we need to make sure folder exist
6187 */
6188
6189 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6190
6191 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6192
6193 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6194
6195 mkdir (kernels_folder, 0700);
6196
6197 myfree (kernels_folder);
6198
6199 /**
6200 * session
6201 */
6202
6203 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6204
6205 data.session = session;
6206
6207 char *eff_restore_file = (char *) mymalloc (session_size);
6208 char *new_restore_file = (char *) mymalloc (session_size);
6209
6210 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
6211 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6212
6213 data.eff_restore_file = eff_restore_file;
6214 data.new_restore_file = new_restore_file;
6215
6216 if (((show == 1) || (left == 1)) && (restore == 1))
6217 {
6218 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6219 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6220
6221 return (-1);
6222 }
6223
6224 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6225 if ((show == 1) || (left == 1))
6226 {
6227 restore_disable = 1;
6228
6229 restore = 0;
6230 }
6231
6232 data.restore_disable = restore_disable;
6233
6234 restore_data_t *rd = init_restore (argc, argv);
6235
6236 data.rd = rd;
6237
6238 /**
6239 * restore file
6240 */
6241
6242 if (restore == 1)
6243 {
6244 read_restore (eff_restore_file, rd);
6245
6246 if (rd->version_bin < RESTORE_MIN)
6247 {
6248 log_error ("ERROR: Incompatible restore-file version");
6249
6250 return (-1);
6251 }
6252
6253 myargc = rd->argc;
6254 myargv = rd->argv;
6255
6256 #ifdef _POSIX
6257 rd->pid = getpid ();
6258 #elif _WIN
6259 rd->pid = GetCurrentProcessId ();
6260 #endif
6261 }
6262
6263 uint hash_mode_chgd = 0;
6264 uint runtime_chgd = 0;
6265 uint kernel_loops_chgd = 0;
6266 uint kernel_accel_chgd = 0;
6267 uint nvidia_spin_damp_chgd = 0;
6268 uint attack_mode_chgd = 0;
6269 uint outfile_format_chgd = 0;
6270 uint rp_gen_seed_chgd = 0;
6271 uint remove_timer_chgd = 0;
6272 uint increment_min_chgd = 0;
6273 uint increment_max_chgd = 0;
6274 uint workload_profile_chgd = 0;
6275 uint opencl_vector_width_chgd = 0;
6276
6277 optind = 1;
6278 optopt = 0;
6279 option_index = 0;
6280
6281 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6282 {
6283 switch (c)
6284 {
6285 //case IDX_HELP: usage = 1; break;
6286 //case IDX_VERSION: version = 1; break;
6287 //case IDX_RESTORE: restore = 1; break;
6288 case IDX_QUIET: quiet = 1; break;
6289 //case IDX_SHOW: show = 1; break;
6290 case IDX_SHOW: break;
6291 //case IDX_LEFT: left = 1; break;
6292 case IDX_LEFT: break;
6293 case IDX_USERNAME: username = 1; break;
6294 case IDX_REMOVE: remove = 1; break;
6295 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6296 remove_timer_chgd = 1; break;
6297 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6298 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6299 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6300 case IDX_DEBUG_FILE: debug_file = optarg; break;
6301 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6302 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6303 case IDX_FORCE: force = 1; break;
6304 case IDX_SKIP: skip = atoll (optarg); break;
6305 case IDX_LIMIT: limit = atoll (optarg); break;
6306 case IDX_KEYSPACE: keyspace = 1; break;
6307 case IDX_BENCHMARK: benchmark = 1; break;
6308 case IDX_STDOUT_FLAG: stdout_flag = 1; break;
6309 case IDX_RESTORE: break;
6310 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6311 case IDX_STATUS: status = 1; break;
6312 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6313 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6314 case IDX_LOOPBACK: loopback = 1; break;
6315 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6316 //case IDX_SESSION: session = optarg; break;
6317 case IDX_SESSION: break;
6318 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6319 hash_mode_chgd = 1; break;
6320 case IDX_RUNTIME: runtime = atoi (optarg);
6321 runtime_chgd = 1; break;
6322 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6323 attack_mode_chgd = 1; break;
6324 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6325 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6326 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6327 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6328 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6329 rp_gen_seed_chgd = 1; break;
6330 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6331 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6332 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6333 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6334 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6335 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6336 case IDX_OUTFILE: outfile = optarg; break;
6337 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6338 outfile_format_chgd = 1; break;
6339 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6340 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6341 case IDX_HEX_CHARSET: hex_charset = 1; break;
6342 case IDX_HEX_SALT: hex_salt = 1; break;
6343 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6344 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6345 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6346 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6347 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6348 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6349 opencl_vector_width_chgd = 1; break;
6350 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6351 workload_profile_chgd = 1; break;
6352 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6353 kernel_accel_chgd = 1; break;
6354 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6355 kernel_loops_chgd = 1; break;
6356 case IDX_NVIDIA_SPIN_DAMP: nvidia_spin_damp = atoi (optarg);
6357 nvidia_spin_damp_chgd = 1; break;
6358 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6359 #ifdef HAVE_HWMON
6360 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6361 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6362 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6363 #endif // HAVE_HWMON
6364 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6365 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6366 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6367 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6368 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6369 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6370 case IDX_SEPARATOR: separator = optarg[0]; break;
6371 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6372 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6373 case IDX_INCREMENT: increment = 1; break;
6374 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6375 increment_min_chgd = 1; break;
6376 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6377 increment_max_chgd = 1; break;
6378 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6379 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6380 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6381 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6382
6383 default:
6384 log_error ("ERROR: Invalid argument specified");
6385 return (-1);
6386 }
6387 }
6388
6389 if (optopt != 0)
6390 {
6391 log_error ("ERROR: Invalid argument specified");
6392
6393 return (-1);
6394 }
6395
6396 /**
6397 * Inform user things getting started,
6398 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6399 * - we do not need to check algorithm_pos
6400 */
6401
6402 if (quiet == 0)
6403 {
6404 if (benchmark == 1)
6405 {
6406 if (machine_readable == 0)
6407 {
6408 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6409 log_info ("");
6410 }
6411 else
6412 {
6413 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6414 }
6415 }
6416 else if (restore == 1)
6417 {
6418 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6419 log_info ("");
6420 }
6421 else if (stdout_flag == 1)
6422 {
6423 // do nothing
6424 }
6425 else
6426 {
6427 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6428 log_info ("");
6429 }
6430 }
6431
6432 /**
6433 * sanity check
6434 */
6435
6436 if (attack_mode > 7)
6437 {
6438 log_error ("ERROR: Invalid attack-mode specified");
6439
6440 return (-1);
6441 }
6442
6443 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6444 {
6445 log_error ("ERROR: Invalid runtime specified");
6446
6447 return (-1);
6448 }
6449
6450 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6451 {
6452 log_error ("ERROR: Invalid hash-type specified");
6453
6454 return (-1);
6455 }
6456
6457 // renamed hash modes
6458
6459 if (hash_mode_chgd)
6460 {
6461 int n = -1;
6462
6463 switch (hash_mode)
6464 {
6465 case 123: n = 124;
6466 break;
6467 }
6468
6469 if (n >= 0)
6470 {
6471 log_error ("Old -m specified, use -m %d instead", n);
6472
6473 return (-1);
6474 }
6475 }
6476
6477 if (username == 1)
6478 {
6479 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6480 {
6481 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6482
6483 return (-1);
6484 }
6485 }
6486
6487 if (outfile_format > 16)
6488 {
6489 log_error ("ERROR: Invalid outfile-format specified");
6490
6491 return (-1);
6492 }
6493
6494 if (left == 1)
6495 {
6496 if (outfile_format_chgd == 1)
6497 {
6498 if (outfile_format > 1)
6499 {
6500 log_error ("ERROR: Mixing outfile-format > 1 with left parameter is not allowed");
6501
6502 return (-1);
6503 }
6504 }
6505 else
6506 {
6507 outfile_format = OUTFILE_FMT_HASH;
6508 }
6509 }
6510
6511 if (show == 1)
6512 {
6513 if (outfile_format_chgd == 1)
6514 {
6515 if ((outfile_format > 7) && (outfile_format < 16))
6516 {
6517 log_error ("ERROR: Mixing outfile-format > 7 with show parameter is not allowed");
6518
6519 return (-1);
6520 }
6521 }
6522 }
6523
6524 if (increment_min < INCREMENT_MIN)
6525 {
6526 log_error ("ERROR: Invalid increment-min specified");
6527
6528 return (-1);
6529 }
6530
6531 if (increment_max > INCREMENT_MAX)
6532 {
6533 log_error ("ERROR: Invalid increment-max specified");
6534
6535 return (-1);
6536 }
6537
6538 if (increment_min > increment_max)
6539 {
6540 log_error ("ERROR: Invalid increment-min specified");
6541
6542 return (-1);
6543 }
6544
6545 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6546 {
6547 log_error ("ERROR: Increment is not allowed in attack-mode 0");
6548
6549 return (-1);
6550 }
6551
6552 if ((increment == 0) && (increment_min_chgd == 1))
6553 {
6554 log_error ("ERROR: Increment-min is only supported combined with increment switch");
6555
6556 return (-1);
6557 }
6558
6559 if ((increment == 0) && (increment_max_chgd == 1))
6560 {
6561 log_error ("ERROR: Increment-max is only supported combined with increment switch");
6562
6563 return (-1);
6564 }
6565
6566 if (rp_files_cnt && rp_gen)
6567 {
6568 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6569
6570 return (-1);
6571 }
6572
6573 if (rp_files_cnt || rp_gen)
6574 {
6575 if (attack_mode != ATTACK_MODE_STRAIGHT)
6576 {
6577 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6578
6579 return (-1);
6580 }
6581 }
6582
6583 if (rp_gen_func_min > rp_gen_func_max)
6584 {
6585 log_error ("ERROR: Invalid rp-gen-func-min specified");
6586
6587 return (-1);
6588 }
6589
6590 if (kernel_accel_chgd == 1)
6591 {
6592 if (force == 0)
6593 {
6594 log_info ("The manual use of the -n option (or --kernel-accel) is outdated");
6595 log_info ("Please consider using the -w option instead");
6596 log_info ("You can use --force to override this but do not post error reports if you do so");
6597 log_info ("");
6598
6599 return (-1);
6600 }
6601
6602 if (kernel_accel < 1)
6603 {
6604 log_error ("ERROR: Invalid kernel-accel specified");
6605
6606 return (-1);
6607 }
6608
6609 if (kernel_accel > 1024)
6610 {
6611 log_error ("ERROR: Invalid kernel-accel specified");
6612
6613 return (-1);
6614 }
6615 }
6616
6617 if (kernel_loops_chgd == 1)
6618 {
6619 if (force == 0)
6620 {
6621 log_info ("The manual use of the -u option (or --kernel-loops) is outdated");
6622 log_info ("Please consider using the option -w instead");
6623 log_info ("You can use --force to override this but do not post error reports if you do so");
6624 log_info ("");
6625
6626 return (-1);
6627 }
6628
6629 if (kernel_loops < 1)
6630 {
6631 log_error ("ERROR: Invalid kernel-loops specified");
6632
6633 return (-1);
6634 }
6635
6636 if (kernel_loops > 1024)
6637 {
6638 log_error ("ERROR: Invalid kernel-loops specified");
6639
6640 return (-1);
6641 }
6642 }
6643
6644 if ((workload_profile < 1) || (workload_profile > 4))
6645 {
6646 log_error ("ERROR: workload-profile %i not available", workload_profile);
6647
6648 return (-1);
6649 }
6650
6651 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6652 {
6653 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6654
6655 return (-1);
6656 }
6657
6658 if (show == 1 || left == 1)
6659 {
6660 attack_mode = ATTACK_MODE_NONE;
6661
6662 if (remove == 1)
6663 {
6664 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6665
6666 return (-1);
6667 }
6668
6669 if (potfile_disable == 1)
6670 {
6671 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6672
6673 return (-1);
6674 }
6675 }
6676
6677 uint attack_kern = ATTACK_KERN_NONE;
6678
6679 switch (attack_mode)
6680 {
6681 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6682 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6683 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6684 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6685 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6686 }
6687
6688 if (benchmark == 1)
6689 {
6690 if (myargv[optind] != 0)
6691 {
6692 log_error ("ERROR: Invalid argument for benchmark mode specified");
6693
6694 return (-1);
6695 }
6696
6697 if (attack_mode_chgd == 1)
6698 {
6699 if (attack_mode != ATTACK_MODE_BF)
6700 {
6701 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6702
6703 return (-1);
6704 }
6705 }
6706 }
6707 else
6708 {
6709 if (stdout_flag == 1) // no hash here
6710 {
6711 optind--;
6712 }
6713
6714 if (keyspace == 1)
6715 {
6716 int num_additional_params = 1;
6717
6718 if (attack_kern == ATTACK_KERN_COMBI)
6719 {
6720 num_additional_params = 2;
6721 }
6722
6723 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6724
6725 if (keyspace_wordlist_specified == 0) optind--;
6726 }
6727
6728 if (attack_kern == ATTACK_KERN_NONE)
6729 {
6730 if ((optind + 1) != myargc)
6731 {
6732 usage_mini_print (myargv[0]);
6733
6734 return (-1);
6735 }
6736 }
6737 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6738 {
6739 if ((optind + 1) > myargc)
6740 {
6741 usage_mini_print (myargv[0]);
6742
6743 return (-1);
6744 }
6745 }
6746 else if (attack_kern == ATTACK_KERN_COMBI)
6747 {
6748 if ((optind + 3) != myargc)
6749 {
6750 usage_mini_print (myargv[0]);
6751
6752 return (-1);
6753 }
6754 }
6755 else if (attack_kern == ATTACK_KERN_BF)
6756 {
6757 if ((optind + 1) > myargc)
6758 {
6759 usage_mini_print (myargv[0]);
6760
6761 return (-1);
6762 }
6763 }
6764 else
6765 {
6766 usage_mini_print (myargv[0]);
6767
6768 return (-1);
6769 }
6770 }
6771
6772 if (skip != 0 && limit != 0)
6773 {
6774 limit += skip;
6775 }
6776
6777 if (keyspace == 1)
6778 {
6779 if (show == 1)
6780 {
6781 log_error ("ERROR: Combining show parameter with keyspace parameter is not allowed");
6782
6783 return (-1);
6784 }
6785 else if (left == 1)
6786 {
6787 log_error ("ERROR: Combining left parameter with keyspace parameter is not allowed");
6788
6789 return (-1);
6790 }
6791
6792 potfile_disable = 1;
6793
6794 restore_disable = 1;
6795
6796 restore = 0;
6797
6798 weak_hash_threshold = 0;
6799
6800 quiet = 1;
6801 }
6802
6803 if (stdout_flag == 1)
6804 {
6805 status_timer = 0;
6806 restore_timer = 0;
6807 restore_disable = 1;
6808 restore = 0;
6809 potfile_disable = 1;
6810 weak_hash_threshold = 0;
6811 gpu_temp_disable = 1;
6812 hash_mode = 2000;
6813 quiet = 1;
6814 outfile_format = OUTFILE_FMT_PLAIN;
6815 kernel_accel = 1024;
6816 kernel_loops = 1024;
6817 force = 1;
6818 outfile_check_timer = 0;
6819 session = "stdout";
6820 opencl_vector_width = 1;
6821 }
6822
6823 if (remove_timer_chgd == 1)
6824 {
6825 if (remove == 0)
6826 {
6827 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6828
6829 return (-1);
6830 }
6831
6832 if (remove_timer < 1)
6833 {
6834 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6835
6836 return (-1);
6837 }
6838 }
6839
6840 if (loopback == 1)
6841 {
6842 if (attack_mode == ATTACK_MODE_STRAIGHT)
6843 {
6844 if ((rp_files_cnt == 0) && (rp_gen == 0))
6845 {
6846 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6847
6848 return (-1);
6849 }
6850 }
6851 else
6852 {
6853 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6854
6855 return (-1);
6856 }
6857 }
6858
6859 if (debug_mode > 0)
6860 {
6861 if (attack_mode != ATTACK_MODE_STRAIGHT)
6862 {
6863 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6864
6865 return (-1);
6866 }
6867
6868 if ((rp_files_cnt == 0) && (rp_gen == 0))
6869 {
6870 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6871
6872 return (-1);
6873 }
6874 }
6875
6876 if (debug_mode > 4)
6877 {
6878 log_error ("ERROR: Invalid debug-mode specified");
6879
6880 return (-1);
6881 }
6882
6883 if (debug_file != NULL)
6884 {
6885 if (debug_mode < 1)
6886 {
6887 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6888
6889 return (-1);
6890 }
6891 }
6892
6893 if (induction_dir != NULL)
6894 {
6895 if (attack_mode == ATTACK_MODE_BF)
6896 {
6897 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6898
6899 return (-1);
6900 }
6901 }
6902
6903 if (attack_mode != ATTACK_MODE_STRAIGHT)
6904 {
6905 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6906 {
6907 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6908
6909 return (-1);
6910 }
6911
6912 weak_hash_threshold = 0;
6913 }
6914
6915 if (nvidia_spin_damp > 100)
6916 {
6917 log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)");
6918
6919 return (-1);
6920 }
6921
6922
6923 /**
6924 * induction directory
6925 */
6926
6927 char *induction_directory = NULL;
6928
6929 if (attack_mode != ATTACK_MODE_BF)
6930 {
6931 if (induction_dir == NULL)
6932 {
6933 induction_directory = (char *) mymalloc (session_size);
6934
6935 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6936
6937 // create induction folder if it does not already exist
6938
6939 if (keyspace == 0)
6940 {
6941 if (rmdir (induction_directory) == -1)
6942 {
6943 if (errno == ENOENT)
6944 {
6945 // good, we can ignore
6946 }
6947 else if (errno == ENOTEMPTY)
6948 {
6949 char *induction_directory_mv = (char *) mymalloc (session_size);
6950
6951 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6952
6953 if (rename (induction_directory, induction_directory_mv) != 0)
6954 {
6955 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6956
6957 return (-1);
6958 }
6959 }
6960 else
6961 {
6962 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6963
6964 return (-1);
6965 }
6966 }
6967
6968 if (mkdir (induction_directory, 0700) == -1)
6969 {
6970 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6971
6972 return (-1);
6973 }
6974 }
6975 }
6976 else
6977 {
6978 induction_directory = induction_dir;
6979 }
6980 }
6981
6982 data.induction_directory = induction_directory;
6983
6984 /**
6985 * loopback
6986 */
6987
6988 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6989
6990 char *loopback_file = (char *) mymalloc (loopback_size);
6991
6992 /**
6993 * tuning db
6994 */
6995
6996 char tuning_db_file[256] = { 0 };
6997
6998 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6999
7000 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
7001
7002 /**
7003 * outfile-check directory
7004 */
7005
7006 char *outfile_check_directory = NULL;
7007
7008 if (outfile_check_dir == NULL)
7009 {
7010 outfile_check_directory = (char *) mymalloc (session_size);
7011
7012 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
7013 }
7014 else
7015 {
7016 outfile_check_directory = outfile_check_dir;
7017 }
7018
7019 data.outfile_check_directory = outfile_check_directory;
7020
7021 if (keyspace == 0)
7022 {
7023 struct stat outfile_check_stat;
7024
7025 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
7026 {
7027 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
7028
7029 if (is_dir == 0)
7030 {
7031 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
7032
7033 return (-1);
7034 }
7035 }
7036 else if (outfile_check_dir == NULL)
7037 {
7038 if (mkdir (outfile_check_directory, 0700) == -1)
7039 {
7040 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
7041
7042 return (-1);
7043 }
7044 }
7045 }
7046
7047 /**
7048 * special other stuff
7049 */
7050
7051 if (hash_mode == 9710)
7052 {
7053 outfile_format = 5;
7054 outfile_format_chgd = 1;
7055 }
7056
7057 if (hash_mode == 9810)
7058 {
7059 outfile_format = 5;
7060 outfile_format_chgd = 1;
7061 }
7062
7063 if (hash_mode == 10410)
7064 {
7065 outfile_format = 5;
7066 outfile_format_chgd = 1;
7067 }
7068
7069 /**
7070 * store stuff
7071 */
7072
7073 data.hash_mode = hash_mode;
7074 data.restore = restore;
7075 data.restore_timer = restore_timer;
7076 data.restore_disable = restore_disable;
7077 data.status = status;
7078 data.status_timer = status_timer;
7079 data.machine_readable = machine_readable;
7080 data.loopback = loopback;
7081 data.runtime = runtime;
7082 data.remove = remove;
7083 data.remove_timer = remove_timer;
7084 data.debug_mode = debug_mode;
7085 data.debug_file = debug_file;
7086 data.username = username;
7087 data.quiet = quiet;
7088 data.outfile = outfile;
7089 data.outfile_format = outfile_format;
7090 data.outfile_autohex = outfile_autohex;
7091 data.hex_charset = hex_charset;
7092 data.hex_salt = hex_salt;
7093 data.hex_wordlist = hex_wordlist;
7094 data.separator = separator;
7095 data.rp_files = rp_files;
7096 data.rp_files_cnt = rp_files_cnt;
7097 data.rp_gen = rp_gen;
7098 data.rp_gen_seed = rp_gen_seed;
7099 data.force = force;
7100 data.benchmark = benchmark;
7101 data.skip = skip;
7102 data.limit = limit;
7103 #ifdef HAVE_HWMON
7104 data.powertune_enable = powertune_enable;
7105 #endif
7106 data.logfile_disable = logfile_disable;
7107 data.truecrypt_keyfiles = truecrypt_keyfiles;
7108 data.veracrypt_keyfiles = veracrypt_keyfiles;
7109 data.veracrypt_pim = veracrypt_pim;
7110 data.scrypt_tmto = scrypt_tmto;
7111 data.workload_profile = workload_profile;
7112
7113 /**
7114 * cpu affinity
7115 */
7116
7117 if (cpu_affinity)
7118 {
7119 set_cpu_affinity (cpu_affinity);
7120 }
7121
7122 if (rp_gen_seed_chgd == 0)
7123 {
7124 srand (proc_start);
7125 }
7126 else
7127 {
7128 srand (rp_gen_seed);
7129 }
7130
7131 /**
7132 * logfile init
7133 */
7134
7135 if (logfile_disable == 0)
7136 {
7137 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7138
7139 char *logfile = (char *) mymalloc (logfile_size);
7140
7141 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7142
7143 data.logfile = logfile;
7144
7145 char *topid = logfile_generate_topid ();
7146
7147 data.topid = topid;
7148 }
7149
7150 // logfile_append() checks for logfile_disable internally to make it easier from here
7151
7152 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7153 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7154 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7155 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7156 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7157 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7158 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7159 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7160 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7161 #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));
7162
7163 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7164 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7165 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7166 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7167 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7168 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7169 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7170 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7171
7172 logfile_top_msg ("START");
7173
7174 logfile_top_uint (attack_mode);
7175 logfile_top_uint (attack_kern);
7176 logfile_top_uint (benchmark);
7177 logfile_top_uint (stdout_flag);
7178 logfile_top_uint (bitmap_min);
7179 logfile_top_uint (bitmap_max);
7180 logfile_top_uint (debug_mode);
7181 logfile_top_uint (force);
7182 logfile_top_uint (kernel_accel);
7183 logfile_top_uint (kernel_loops);
7184 logfile_top_uint (nvidia_spin_damp);
7185 logfile_top_uint (gpu_temp_disable);
7186 #ifdef HAVE_HWMON
7187 logfile_top_uint (gpu_temp_abort);
7188 logfile_top_uint (gpu_temp_retain);
7189 #endif
7190 logfile_top_uint (hash_mode);
7191 logfile_top_uint (hex_charset);
7192 logfile_top_uint (hex_salt);
7193 logfile_top_uint (hex_wordlist);
7194 logfile_top_uint (increment);
7195 logfile_top_uint (increment_max);
7196 logfile_top_uint (increment_min);
7197 logfile_top_uint (keyspace);
7198 logfile_top_uint (left);
7199 logfile_top_uint (logfile_disable);
7200 logfile_top_uint (loopback);
7201 logfile_top_uint (markov_classic);
7202 logfile_top_uint (markov_disable);
7203 logfile_top_uint (markov_threshold);
7204 logfile_top_uint (outfile_autohex);
7205 logfile_top_uint (outfile_check_timer);
7206 logfile_top_uint (outfile_format);
7207 logfile_top_uint (potfile_disable);
7208 logfile_top_string (potfile_path);
7209 #if defined(HAVE_HWMON)
7210 logfile_top_uint (powertune_enable);
7211 #endif
7212 logfile_top_uint (scrypt_tmto);
7213 logfile_top_uint (quiet);
7214 logfile_top_uint (remove);
7215 logfile_top_uint (remove_timer);
7216 logfile_top_uint (restore);
7217 logfile_top_uint (restore_disable);
7218 logfile_top_uint (restore_timer);
7219 logfile_top_uint (rp_gen);
7220 logfile_top_uint (rp_gen_func_max);
7221 logfile_top_uint (rp_gen_func_min);
7222 logfile_top_uint (rp_gen_seed);
7223 logfile_top_uint (runtime);
7224 logfile_top_uint (segment_size);
7225 logfile_top_uint (show);
7226 logfile_top_uint (status);
7227 logfile_top_uint (machine_readable);
7228 logfile_top_uint (status_timer);
7229 logfile_top_uint (usage);
7230 logfile_top_uint (username);
7231 logfile_top_uint (version);
7232 logfile_top_uint (weak_hash_threshold);
7233 logfile_top_uint (workload_profile);
7234 logfile_top_uint64 (limit);
7235 logfile_top_uint64 (skip);
7236 logfile_top_char (separator);
7237 logfile_top_string (cpu_affinity);
7238 logfile_top_string (custom_charset_1);
7239 logfile_top_string (custom_charset_2);
7240 logfile_top_string (custom_charset_3);
7241 logfile_top_string (custom_charset_4);
7242 logfile_top_string (debug_file);
7243 logfile_top_string (opencl_devices);
7244 logfile_top_string (opencl_platforms);
7245 logfile_top_string (opencl_device_types);
7246 logfile_top_uint (opencl_vector_width);
7247 logfile_top_string (induction_dir);
7248 logfile_top_string (markov_hcstat);
7249 logfile_top_string (outfile);
7250 logfile_top_string (outfile_check_dir);
7251 logfile_top_string (rule_buf_l);
7252 logfile_top_string (rule_buf_r);
7253 logfile_top_string (session);
7254 logfile_top_string (truecrypt_keyfiles);
7255 logfile_top_string (veracrypt_keyfiles);
7256 logfile_top_uint (veracrypt_pim);
7257
7258 /**
7259 * Init OpenCL library loader
7260 */
7261
7262 if (keyspace == 0)
7263 {
7264 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7265
7266 ocl_init (ocl);
7267
7268 data.ocl = ocl;
7269 }
7270
7271 /**
7272 * OpenCL platform selection
7273 */
7274
7275 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7276
7277 /**
7278 * OpenCL device selection
7279 */
7280
7281 u32 devices_filter = setup_devices_filter (opencl_devices);
7282
7283 /**
7284 * OpenCL device type selection
7285 */
7286
7287 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7288
7289 /**
7290 * benchmark
7291 */
7292
7293 if (benchmark == 1)
7294 {
7295 /**
7296 * disable useless stuff for benchmark
7297 */
7298
7299 status_timer = 0;
7300 restore_timer = 0;
7301 restore_disable = 1;
7302 potfile_disable = 1;
7303 weak_hash_threshold = 0;
7304 nvidia_spin_damp = 0;
7305 gpu_temp_disable = 1;
7306 outfile_check_timer = 0;
7307
7308 #ifdef HAVE_HWMON
7309 if (powertune_enable == 1)
7310 {
7311 gpu_temp_disable = 0;
7312 }
7313 #endif
7314
7315 data.status_timer = status_timer;
7316 data.restore_timer = restore_timer;
7317 data.restore_disable = restore_disable;
7318 data.outfile_check_timer = outfile_check_timer;
7319
7320 /**
7321 * force attack mode to be bruteforce
7322 */
7323
7324 attack_mode = ATTACK_MODE_BF;
7325 attack_kern = ATTACK_KERN_BF;
7326
7327 if (workload_profile_chgd == 0)
7328 {
7329 workload_profile = 3;
7330
7331 data.workload_profile = workload_profile;
7332 }
7333 }
7334
7335 /**
7336 * config
7337 */
7338
7339 uint hash_type = 0;
7340 uint salt_type = 0;
7341 uint attack_exec = 0;
7342 uint opts_type = 0;
7343 uint kern_type = 0;
7344 uint dgst_size = 0;
7345 uint esalt_size = 0;
7346 uint opti_type = 0;
7347 uint dgst_pos0 = -1;
7348 uint dgst_pos1 = -1;
7349 uint dgst_pos2 = -1;
7350 uint dgst_pos3 = -1;
7351
7352 int (*parse_func) (char *, uint, hash_t *);
7353 int (*sort_by_digest) (const void *, const void *);
7354
7355 uint algorithm_pos = 0;
7356 uint algorithm_max = 1;
7357
7358 uint *algorithms = default_benchmark_algorithms;
7359
7360 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7361
7362 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7363 {
7364 /*
7365 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7366 * the following algos are skipped entirely
7367 */
7368
7369 if (algorithm_pos > 0)
7370 {
7371 local_free (rd);
7372
7373 rd = init_restore (argc, argv);
7374
7375 data.rd = rd;
7376 }
7377
7378 /**
7379 * update hash_mode in case of multihash benchmark
7380 */
7381
7382 if (benchmark == 1)
7383 {
7384 if (hash_mode_chgd == 0)
7385 {
7386 hash_mode = algorithms[algorithm_pos];
7387
7388 data.hash_mode = hash_mode;
7389 }
7390
7391 quiet = 1;
7392
7393 data.quiet = quiet;
7394 }
7395
7396 switch (hash_mode)
7397 {
7398 case 0: hash_type = HASH_TYPE_MD5;
7399 salt_type = SALT_TYPE_NONE;
7400 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7401 opts_type = OPTS_TYPE_PT_GENERATE_LE
7402 | OPTS_TYPE_PT_ADD80
7403 | OPTS_TYPE_PT_ADDBITS14;
7404 kern_type = KERN_TYPE_MD5;
7405 dgst_size = DGST_SIZE_4_4;
7406 parse_func = md5_parse_hash;
7407 sort_by_digest = sort_by_digest_4_4;
7408 opti_type = OPTI_TYPE_ZERO_BYTE
7409 | OPTI_TYPE_PRECOMPUTE_INIT
7410 | OPTI_TYPE_PRECOMPUTE_MERKLE
7411 | OPTI_TYPE_MEET_IN_MIDDLE
7412 | OPTI_TYPE_EARLY_SKIP
7413 | OPTI_TYPE_NOT_ITERATED
7414 | OPTI_TYPE_NOT_SALTED
7415 | OPTI_TYPE_RAW_HASH;
7416 dgst_pos0 = 0;
7417 dgst_pos1 = 3;
7418 dgst_pos2 = 2;
7419 dgst_pos3 = 1;
7420 break;
7421
7422 case 10: hash_type = HASH_TYPE_MD5;
7423 salt_type = SALT_TYPE_INTERN;
7424 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7425 opts_type = OPTS_TYPE_PT_GENERATE_LE
7426 | OPTS_TYPE_ST_ADD80
7427 | OPTS_TYPE_ST_ADDBITS14;
7428 kern_type = KERN_TYPE_MD5_PWSLT;
7429 dgst_size = DGST_SIZE_4_4;
7430 parse_func = md5s_parse_hash;
7431 sort_by_digest = sort_by_digest_4_4;
7432 opti_type = OPTI_TYPE_ZERO_BYTE
7433 | OPTI_TYPE_PRECOMPUTE_INIT
7434 | OPTI_TYPE_PRECOMPUTE_MERKLE
7435 | OPTI_TYPE_MEET_IN_MIDDLE
7436 | OPTI_TYPE_EARLY_SKIP
7437 | OPTI_TYPE_NOT_ITERATED
7438 | OPTI_TYPE_APPENDED_SALT
7439 | OPTI_TYPE_RAW_HASH;
7440 dgst_pos0 = 0;
7441 dgst_pos1 = 3;
7442 dgst_pos2 = 2;
7443 dgst_pos3 = 1;
7444 break;
7445
7446 case 11: hash_type = HASH_TYPE_MD5;
7447 salt_type = SALT_TYPE_INTERN;
7448 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7449 opts_type = OPTS_TYPE_PT_GENERATE_LE
7450 | OPTS_TYPE_ST_ADD80
7451 | OPTS_TYPE_ST_ADDBITS14;
7452 kern_type = KERN_TYPE_MD5_PWSLT;
7453 dgst_size = DGST_SIZE_4_4;
7454 parse_func = joomla_parse_hash;
7455 sort_by_digest = sort_by_digest_4_4;
7456 opti_type = OPTI_TYPE_ZERO_BYTE
7457 | OPTI_TYPE_PRECOMPUTE_INIT
7458 | OPTI_TYPE_PRECOMPUTE_MERKLE
7459 | OPTI_TYPE_MEET_IN_MIDDLE
7460 | OPTI_TYPE_EARLY_SKIP
7461 | OPTI_TYPE_NOT_ITERATED
7462 | OPTI_TYPE_APPENDED_SALT
7463 | OPTI_TYPE_RAW_HASH;
7464 dgst_pos0 = 0;
7465 dgst_pos1 = 3;
7466 dgst_pos2 = 2;
7467 dgst_pos3 = 1;
7468 break;
7469
7470 case 12: hash_type = HASH_TYPE_MD5;
7471 salt_type = SALT_TYPE_INTERN;
7472 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7473 opts_type = OPTS_TYPE_PT_GENERATE_LE
7474 | OPTS_TYPE_ST_ADD80
7475 | OPTS_TYPE_ST_ADDBITS14;
7476 kern_type = KERN_TYPE_MD5_PWSLT;
7477 dgst_size = DGST_SIZE_4_4;
7478 parse_func = postgresql_parse_hash;
7479 sort_by_digest = sort_by_digest_4_4;
7480 opti_type = OPTI_TYPE_ZERO_BYTE
7481 | OPTI_TYPE_PRECOMPUTE_INIT
7482 | OPTI_TYPE_PRECOMPUTE_MERKLE
7483 | OPTI_TYPE_MEET_IN_MIDDLE
7484 | OPTI_TYPE_EARLY_SKIP
7485 | OPTI_TYPE_NOT_ITERATED
7486 | OPTI_TYPE_APPENDED_SALT
7487 | OPTI_TYPE_RAW_HASH;
7488 dgst_pos0 = 0;
7489 dgst_pos1 = 3;
7490 dgst_pos2 = 2;
7491 dgst_pos3 = 1;
7492 break;
7493
7494 case 20: hash_type = HASH_TYPE_MD5;
7495 salt_type = SALT_TYPE_INTERN;
7496 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7497 opts_type = OPTS_TYPE_PT_GENERATE_LE
7498 | OPTS_TYPE_PT_ADD80
7499 | OPTS_TYPE_PT_ADDBITS14;
7500 kern_type = KERN_TYPE_MD5_SLTPW;
7501 dgst_size = DGST_SIZE_4_4;
7502 parse_func = md5s_parse_hash;
7503 sort_by_digest = sort_by_digest_4_4;
7504 opti_type = OPTI_TYPE_ZERO_BYTE
7505 | OPTI_TYPE_PRECOMPUTE_INIT
7506 | OPTI_TYPE_PRECOMPUTE_MERKLE
7507 | OPTI_TYPE_EARLY_SKIP
7508 | OPTI_TYPE_NOT_ITERATED
7509 | OPTI_TYPE_PREPENDED_SALT
7510 | OPTI_TYPE_RAW_HASH;
7511 dgst_pos0 = 0;
7512 dgst_pos1 = 3;
7513 dgst_pos2 = 2;
7514 dgst_pos3 = 1;
7515 break;
7516
7517 case 21: hash_type = HASH_TYPE_MD5;
7518 salt_type = SALT_TYPE_INTERN;
7519 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7520 opts_type = OPTS_TYPE_PT_GENERATE_LE
7521 | OPTS_TYPE_PT_ADD80
7522 | OPTS_TYPE_PT_ADDBITS14;
7523 kern_type = KERN_TYPE_MD5_SLTPW;
7524 dgst_size = DGST_SIZE_4_4;
7525 parse_func = osc_parse_hash;
7526 sort_by_digest = sort_by_digest_4_4;
7527 opti_type = OPTI_TYPE_ZERO_BYTE
7528 | OPTI_TYPE_PRECOMPUTE_INIT
7529 | OPTI_TYPE_PRECOMPUTE_MERKLE
7530 | OPTI_TYPE_EARLY_SKIP
7531 | OPTI_TYPE_NOT_ITERATED
7532 | OPTI_TYPE_PREPENDED_SALT
7533 | OPTI_TYPE_RAW_HASH;
7534 dgst_pos0 = 0;
7535 dgst_pos1 = 3;
7536 dgst_pos2 = 2;
7537 dgst_pos3 = 1;
7538 break;
7539
7540 case 22: hash_type = HASH_TYPE_MD5;
7541 salt_type = SALT_TYPE_EMBEDDED;
7542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7543 opts_type = OPTS_TYPE_PT_GENERATE_LE
7544 | OPTS_TYPE_PT_ADD80
7545 | OPTS_TYPE_PT_ADDBITS14;
7546 kern_type = KERN_TYPE_MD5_SLTPW;
7547 dgst_size = DGST_SIZE_4_4;
7548 parse_func = netscreen_parse_hash;
7549 sort_by_digest = sort_by_digest_4_4;
7550 opti_type = OPTI_TYPE_ZERO_BYTE
7551 | OPTI_TYPE_PRECOMPUTE_INIT
7552 | OPTI_TYPE_PRECOMPUTE_MERKLE
7553 | OPTI_TYPE_EARLY_SKIP
7554 | OPTI_TYPE_NOT_ITERATED
7555 | OPTI_TYPE_PREPENDED_SALT
7556 | OPTI_TYPE_RAW_HASH;
7557 dgst_pos0 = 0;
7558 dgst_pos1 = 3;
7559 dgst_pos2 = 2;
7560 dgst_pos3 = 1;
7561 break;
7562
7563 case 23: hash_type = HASH_TYPE_MD5;
7564 salt_type = SALT_TYPE_EMBEDDED;
7565 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7566 opts_type = OPTS_TYPE_PT_GENERATE_LE
7567 | OPTS_TYPE_PT_ADD80
7568 | OPTS_TYPE_PT_ADDBITS14;
7569 kern_type = KERN_TYPE_MD5_SLTPW;
7570 dgst_size = DGST_SIZE_4_4;
7571 parse_func = skype_parse_hash;
7572 sort_by_digest = sort_by_digest_4_4;
7573 opti_type = OPTI_TYPE_ZERO_BYTE
7574 | OPTI_TYPE_PRECOMPUTE_INIT
7575 | OPTI_TYPE_PRECOMPUTE_MERKLE
7576 | OPTI_TYPE_EARLY_SKIP
7577 | OPTI_TYPE_NOT_ITERATED
7578 | OPTI_TYPE_PREPENDED_SALT
7579 | OPTI_TYPE_RAW_HASH;
7580 dgst_pos0 = 0;
7581 dgst_pos1 = 3;
7582 dgst_pos2 = 2;
7583 dgst_pos3 = 1;
7584 break;
7585
7586 case 30: hash_type = HASH_TYPE_MD5;
7587 salt_type = SALT_TYPE_INTERN;
7588 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7589 opts_type = OPTS_TYPE_PT_GENERATE_LE
7590 | OPTS_TYPE_PT_UNICODE
7591 | OPTS_TYPE_ST_ADD80
7592 | OPTS_TYPE_ST_ADDBITS14;
7593 kern_type = KERN_TYPE_MD5_PWUSLT;
7594 dgst_size = DGST_SIZE_4_4;
7595 parse_func = md5s_parse_hash;
7596 sort_by_digest = sort_by_digest_4_4;
7597 opti_type = OPTI_TYPE_ZERO_BYTE
7598 | OPTI_TYPE_PRECOMPUTE_INIT
7599 | OPTI_TYPE_PRECOMPUTE_MERKLE
7600 | OPTI_TYPE_MEET_IN_MIDDLE
7601 | OPTI_TYPE_EARLY_SKIP
7602 | OPTI_TYPE_NOT_ITERATED
7603 | OPTI_TYPE_APPENDED_SALT
7604 | OPTI_TYPE_RAW_HASH;
7605 dgst_pos0 = 0;
7606 dgst_pos1 = 3;
7607 dgst_pos2 = 2;
7608 dgst_pos3 = 1;
7609 break;
7610
7611 case 40: hash_type = HASH_TYPE_MD5;
7612 salt_type = SALT_TYPE_INTERN;
7613 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7614 opts_type = OPTS_TYPE_PT_GENERATE_LE
7615 | OPTS_TYPE_PT_ADD80
7616 | OPTS_TYPE_PT_ADDBITS14
7617 | OPTS_TYPE_PT_UNICODE;
7618 kern_type = KERN_TYPE_MD5_SLTPWU;
7619 dgst_size = DGST_SIZE_4_4;
7620 parse_func = md5s_parse_hash;
7621 sort_by_digest = sort_by_digest_4_4;
7622 opti_type = OPTI_TYPE_ZERO_BYTE
7623 | OPTI_TYPE_PRECOMPUTE_INIT
7624 | OPTI_TYPE_PRECOMPUTE_MERKLE
7625 | OPTI_TYPE_EARLY_SKIP
7626 | OPTI_TYPE_NOT_ITERATED
7627 | OPTI_TYPE_PREPENDED_SALT
7628 | OPTI_TYPE_RAW_HASH;
7629 dgst_pos0 = 0;
7630 dgst_pos1 = 3;
7631 dgst_pos2 = 2;
7632 dgst_pos3 = 1;
7633 break;
7634
7635 case 50: hash_type = HASH_TYPE_MD5;
7636 salt_type = SALT_TYPE_INTERN;
7637 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7638 opts_type = OPTS_TYPE_PT_GENERATE_LE
7639 | OPTS_TYPE_ST_ADD80
7640 | OPTS_TYPE_ST_ADDBITS14;
7641 kern_type = KERN_TYPE_HMACMD5_PW;
7642 dgst_size = DGST_SIZE_4_4;
7643 parse_func = hmacmd5_parse_hash;
7644 sort_by_digest = sort_by_digest_4_4;
7645 opti_type = OPTI_TYPE_ZERO_BYTE
7646 | OPTI_TYPE_NOT_ITERATED;
7647 dgst_pos0 = 0;
7648 dgst_pos1 = 3;
7649 dgst_pos2 = 2;
7650 dgst_pos3 = 1;
7651 break;
7652
7653 case 60: hash_type = HASH_TYPE_MD5;
7654 salt_type = SALT_TYPE_INTERN;
7655 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7656 opts_type = OPTS_TYPE_PT_GENERATE_LE
7657 | OPTS_TYPE_PT_ADD80
7658 | OPTS_TYPE_PT_ADDBITS14;
7659 kern_type = KERN_TYPE_HMACMD5_SLT;
7660 dgst_size = DGST_SIZE_4_4;
7661 parse_func = hmacmd5_parse_hash;
7662 sort_by_digest = sort_by_digest_4_4;
7663 opti_type = OPTI_TYPE_ZERO_BYTE
7664 | OPTI_TYPE_NOT_ITERATED;
7665 dgst_pos0 = 0;
7666 dgst_pos1 = 3;
7667 dgst_pos2 = 2;
7668 dgst_pos3 = 1;
7669 break;
7670
7671 case 100: hash_type = HASH_TYPE_SHA1;
7672 salt_type = SALT_TYPE_NONE;
7673 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7674 opts_type = OPTS_TYPE_PT_GENERATE_BE
7675 | OPTS_TYPE_PT_ADD80
7676 | OPTS_TYPE_PT_ADDBITS15;
7677 kern_type = KERN_TYPE_SHA1;
7678 dgst_size = DGST_SIZE_4_5;
7679 parse_func = sha1_parse_hash;
7680 sort_by_digest = sort_by_digest_4_5;
7681 opti_type = OPTI_TYPE_ZERO_BYTE
7682 | OPTI_TYPE_PRECOMPUTE_INIT
7683 | OPTI_TYPE_PRECOMPUTE_MERKLE
7684 | OPTI_TYPE_EARLY_SKIP
7685 | OPTI_TYPE_NOT_ITERATED
7686 | OPTI_TYPE_NOT_SALTED
7687 | OPTI_TYPE_RAW_HASH;
7688 dgst_pos0 = 3;
7689 dgst_pos1 = 4;
7690 dgst_pos2 = 2;
7691 dgst_pos3 = 1;
7692 break;
7693
7694 case 101: hash_type = HASH_TYPE_SHA1;
7695 salt_type = SALT_TYPE_NONE;
7696 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7697 opts_type = OPTS_TYPE_PT_GENERATE_BE
7698 | OPTS_TYPE_PT_ADD80
7699 | OPTS_TYPE_PT_ADDBITS15;
7700 kern_type = KERN_TYPE_SHA1;
7701 dgst_size = DGST_SIZE_4_5;
7702 parse_func = sha1b64_parse_hash;
7703 sort_by_digest = sort_by_digest_4_5;
7704 opti_type = OPTI_TYPE_ZERO_BYTE
7705 | OPTI_TYPE_PRECOMPUTE_INIT
7706 | OPTI_TYPE_PRECOMPUTE_MERKLE
7707 | OPTI_TYPE_EARLY_SKIP
7708 | OPTI_TYPE_NOT_ITERATED
7709 | OPTI_TYPE_NOT_SALTED
7710 | OPTI_TYPE_RAW_HASH;
7711 dgst_pos0 = 3;
7712 dgst_pos1 = 4;
7713 dgst_pos2 = 2;
7714 dgst_pos3 = 1;
7715 break;
7716
7717 case 110: hash_type = HASH_TYPE_SHA1;
7718 salt_type = SALT_TYPE_INTERN;
7719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7720 opts_type = OPTS_TYPE_PT_GENERATE_BE
7721 | OPTS_TYPE_ST_ADD80
7722 | OPTS_TYPE_ST_ADDBITS15;
7723 kern_type = KERN_TYPE_SHA1_PWSLT;
7724 dgst_size = DGST_SIZE_4_5;
7725 parse_func = sha1s_parse_hash;
7726 sort_by_digest = sort_by_digest_4_5;
7727 opti_type = OPTI_TYPE_ZERO_BYTE
7728 | OPTI_TYPE_PRECOMPUTE_INIT
7729 | OPTI_TYPE_PRECOMPUTE_MERKLE
7730 | OPTI_TYPE_EARLY_SKIP
7731 | OPTI_TYPE_NOT_ITERATED
7732 | OPTI_TYPE_APPENDED_SALT
7733 | OPTI_TYPE_RAW_HASH;
7734 dgst_pos0 = 3;
7735 dgst_pos1 = 4;
7736 dgst_pos2 = 2;
7737 dgst_pos3 = 1;
7738 break;
7739
7740 case 111: hash_type = HASH_TYPE_SHA1;
7741 salt_type = SALT_TYPE_EMBEDDED;
7742 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7743 opts_type = OPTS_TYPE_PT_GENERATE_BE
7744 | OPTS_TYPE_ST_ADD80
7745 | OPTS_TYPE_ST_ADDBITS15;
7746 kern_type = KERN_TYPE_SHA1_PWSLT;
7747 dgst_size = DGST_SIZE_4_5;
7748 parse_func = sha1b64s_parse_hash;
7749 sort_by_digest = sort_by_digest_4_5;
7750 opti_type = OPTI_TYPE_ZERO_BYTE
7751 | OPTI_TYPE_PRECOMPUTE_INIT
7752 | OPTI_TYPE_PRECOMPUTE_MERKLE
7753 | OPTI_TYPE_EARLY_SKIP
7754 | OPTI_TYPE_NOT_ITERATED
7755 | OPTI_TYPE_APPENDED_SALT
7756 | OPTI_TYPE_RAW_HASH;
7757 dgst_pos0 = 3;
7758 dgst_pos1 = 4;
7759 dgst_pos2 = 2;
7760 dgst_pos3 = 1;
7761 break;
7762
7763 case 112: hash_type = HASH_TYPE_SHA1;
7764 salt_type = SALT_TYPE_INTERN;
7765 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7766 opts_type = OPTS_TYPE_PT_GENERATE_BE
7767 | OPTS_TYPE_ST_ADD80
7768 | OPTS_TYPE_ST_ADDBITS15
7769 | OPTS_TYPE_ST_HEX;
7770 kern_type = KERN_TYPE_SHA1_PWSLT;
7771 dgst_size = DGST_SIZE_4_5;
7772 parse_func = oracles_parse_hash;
7773 sort_by_digest = sort_by_digest_4_5;
7774 opti_type = OPTI_TYPE_ZERO_BYTE
7775 | OPTI_TYPE_PRECOMPUTE_INIT
7776 | OPTI_TYPE_PRECOMPUTE_MERKLE
7777 | OPTI_TYPE_EARLY_SKIP
7778 | OPTI_TYPE_NOT_ITERATED
7779 | OPTI_TYPE_APPENDED_SALT
7780 | OPTI_TYPE_RAW_HASH;
7781 dgst_pos0 = 3;
7782 dgst_pos1 = 4;
7783 dgst_pos2 = 2;
7784 dgst_pos3 = 1;
7785 break;
7786
7787 case 120: hash_type = HASH_TYPE_SHA1;
7788 salt_type = SALT_TYPE_INTERN;
7789 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7790 opts_type = OPTS_TYPE_PT_GENERATE_BE
7791 | OPTS_TYPE_PT_ADD80
7792 | OPTS_TYPE_PT_ADDBITS15;
7793 kern_type = KERN_TYPE_SHA1_SLTPW;
7794 dgst_size = DGST_SIZE_4_5;
7795 parse_func = sha1s_parse_hash;
7796 sort_by_digest = sort_by_digest_4_5;
7797 opti_type = OPTI_TYPE_ZERO_BYTE
7798 | OPTI_TYPE_PRECOMPUTE_INIT
7799 | OPTI_TYPE_PRECOMPUTE_MERKLE
7800 | OPTI_TYPE_EARLY_SKIP
7801 | OPTI_TYPE_NOT_ITERATED
7802 | OPTI_TYPE_PREPENDED_SALT
7803 | OPTI_TYPE_RAW_HASH;
7804 dgst_pos0 = 3;
7805 dgst_pos1 = 4;
7806 dgst_pos2 = 2;
7807 dgst_pos3 = 1;
7808 break;
7809
7810 case 121: hash_type = HASH_TYPE_SHA1;
7811 salt_type = SALT_TYPE_INTERN;
7812 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7813 opts_type = OPTS_TYPE_PT_GENERATE_BE
7814 | OPTS_TYPE_PT_ADD80
7815 | OPTS_TYPE_PT_ADDBITS15
7816 | OPTS_TYPE_ST_LOWER;
7817 kern_type = KERN_TYPE_SHA1_SLTPW;
7818 dgst_size = DGST_SIZE_4_5;
7819 parse_func = smf_parse_hash;
7820 sort_by_digest = sort_by_digest_4_5;
7821 opti_type = OPTI_TYPE_ZERO_BYTE
7822 | OPTI_TYPE_PRECOMPUTE_INIT
7823 | OPTI_TYPE_PRECOMPUTE_MERKLE
7824 | OPTI_TYPE_EARLY_SKIP
7825 | OPTI_TYPE_NOT_ITERATED
7826 | OPTI_TYPE_PREPENDED_SALT
7827 | OPTI_TYPE_RAW_HASH;
7828 dgst_pos0 = 3;
7829 dgst_pos1 = 4;
7830 dgst_pos2 = 2;
7831 dgst_pos3 = 1;
7832 break;
7833
7834 case 122: hash_type = HASH_TYPE_SHA1;
7835 salt_type = SALT_TYPE_EMBEDDED;
7836 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7837 opts_type = OPTS_TYPE_PT_GENERATE_BE
7838 | OPTS_TYPE_PT_ADD80
7839 | OPTS_TYPE_PT_ADDBITS15
7840 | OPTS_TYPE_ST_HEX;
7841 kern_type = KERN_TYPE_SHA1_SLTPW;
7842 dgst_size = DGST_SIZE_4_5;
7843 parse_func = osx1_parse_hash;
7844 sort_by_digest = sort_by_digest_4_5;
7845 opti_type = OPTI_TYPE_ZERO_BYTE
7846 | OPTI_TYPE_PRECOMPUTE_INIT
7847 | OPTI_TYPE_PRECOMPUTE_MERKLE
7848 | OPTI_TYPE_EARLY_SKIP
7849 | OPTI_TYPE_NOT_ITERATED
7850 | OPTI_TYPE_PREPENDED_SALT
7851 | OPTI_TYPE_RAW_HASH;
7852 dgst_pos0 = 3;
7853 dgst_pos1 = 4;
7854 dgst_pos2 = 2;
7855 dgst_pos3 = 1;
7856 break;
7857
7858 case 124: hash_type = HASH_TYPE_SHA1;
7859 salt_type = SALT_TYPE_EMBEDDED;
7860 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7861 opts_type = OPTS_TYPE_PT_GENERATE_BE
7862 | OPTS_TYPE_PT_ADD80
7863 | OPTS_TYPE_PT_ADDBITS15;
7864 kern_type = KERN_TYPE_SHA1_SLTPW;
7865 dgst_size = DGST_SIZE_4_5;
7866 parse_func = djangosha1_parse_hash;
7867 sort_by_digest = sort_by_digest_4_5;
7868 opti_type = OPTI_TYPE_ZERO_BYTE
7869 | OPTI_TYPE_PRECOMPUTE_INIT
7870 | OPTI_TYPE_PRECOMPUTE_MERKLE
7871 | OPTI_TYPE_EARLY_SKIP
7872 | OPTI_TYPE_NOT_ITERATED
7873 | OPTI_TYPE_PREPENDED_SALT
7874 | OPTI_TYPE_RAW_HASH;
7875 dgst_pos0 = 3;
7876 dgst_pos1 = 4;
7877 dgst_pos2 = 2;
7878 dgst_pos3 = 1;
7879 break;
7880
7881 case 125: hash_type = HASH_TYPE_SHA1;
7882 salt_type = SALT_TYPE_EMBEDDED;
7883 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7884 opts_type = OPTS_TYPE_PT_GENERATE_BE
7885 | OPTS_TYPE_PT_ADD80
7886 | OPTS_TYPE_PT_ADDBITS15
7887 | OPTS_TYPE_ST_HEX;
7888 kern_type = KERN_TYPE_SHA1_SLTPW;
7889 dgst_size = DGST_SIZE_4_5;
7890 parse_func = arubaos_parse_hash;
7891 sort_by_digest = sort_by_digest_4_5;
7892 opti_type = OPTI_TYPE_ZERO_BYTE
7893 | OPTI_TYPE_PRECOMPUTE_INIT
7894 | OPTI_TYPE_PRECOMPUTE_MERKLE
7895 | OPTI_TYPE_EARLY_SKIP
7896 | OPTI_TYPE_NOT_ITERATED
7897 | OPTI_TYPE_PREPENDED_SALT
7898 | OPTI_TYPE_RAW_HASH;
7899 dgst_pos0 = 3;
7900 dgst_pos1 = 4;
7901 dgst_pos2 = 2;
7902 dgst_pos3 = 1;
7903 break;
7904
7905 case 130: hash_type = HASH_TYPE_SHA1;
7906 salt_type = SALT_TYPE_INTERN;
7907 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7908 opts_type = OPTS_TYPE_PT_GENERATE_BE
7909 | OPTS_TYPE_PT_UNICODE
7910 | OPTS_TYPE_ST_ADD80
7911 | OPTS_TYPE_ST_ADDBITS15;
7912 kern_type = KERN_TYPE_SHA1_PWUSLT;
7913 dgst_size = DGST_SIZE_4_5;
7914 parse_func = sha1s_parse_hash;
7915 sort_by_digest = sort_by_digest_4_5;
7916 opti_type = OPTI_TYPE_ZERO_BYTE
7917 | OPTI_TYPE_PRECOMPUTE_INIT
7918 | OPTI_TYPE_PRECOMPUTE_MERKLE
7919 | OPTI_TYPE_EARLY_SKIP
7920 | OPTI_TYPE_NOT_ITERATED
7921 | OPTI_TYPE_APPENDED_SALT
7922 | OPTI_TYPE_RAW_HASH;
7923 dgst_pos0 = 3;
7924 dgst_pos1 = 4;
7925 dgst_pos2 = 2;
7926 dgst_pos3 = 1;
7927 break;
7928
7929 case 131: hash_type = HASH_TYPE_SHA1;
7930 salt_type = SALT_TYPE_EMBEDDED;
7931 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7932 opts_type = OPTS_TYPE_PT_GENERATE_BE
7933 | OPTS_TYPE_PT_UNICODE
7934 | OPTS_TYPE_PT_UPPER
7935 | OPTS_TYPE_ST_ADD80
7936 | OPTS_TYPE_ST_ADDBITS15
7937 | OPTS_TYPE_ST_HEX;
7938 kern_type = KERN_TYPE_SHA1_PWUSLT;
7939 dgst_size = DGST_SIZE_4_5;
7940 parse_func = mssql2000_parse_hash;
7941 sort_by_digest = sort_by_digest_4_5;
7942 opti_type = OPTI_TYPE_ZERO_BYTE
7943 | OPTI_TYPE_PRECOMPUTE_INIT
7944 | OPTI_TYPE_PRECOMPUTE_MERKLE
7945 | OPTI_TYPE_EARLY_SKIP
7946 | OPTI_TYPE_NOT_ITERATED
7947 | OPTI_TYPE_APPENDED_SALT
7948 | OPTI_TYPE_RAW_HASH;
7949 dgst_pos0 = 3;
7950 dgst_pos1 = 4;
7951 dgst_pos2 = 2;
7952 dgst_pos3 = 1;
7953 break;
7954
7955 case 132: hash_type = HASH_TYPE_SHA1;
7956 salt_type = SALT_TYPE_EMBEDDED;
7957 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7958 opts_type = OPTS_TYPE_PT_GENERATE_BE
7959 | OPTS_TYPE_PT_UNICODE
7960 | OPTS_TYPE_ST_ADD80
7961 | OPTS_TYPE_ST_ADDBITS15
7962 | OPTS_TYPE_ST_HEX;
7963 kern_type = KERN_TYPE_SHA1_PWUSLT;
7964 dgst_size = DGST_SIZE_4_5;
7965 parse_func = mssql2005_parse_hash;
7966 sort_by_digest = sort_by_digest_4_5;
7967 opti_type = OPTI_TYPE_ZERO_BYTE
7968 | OPTI_TYPE_PRECOMPUTE_INIT
7969 | OPTI_TYPE_PRECOMPUTE_MERKLE
7970 | OPTI_TYPE_EARLY_SKIP
7971 | OPTI_TYPE_NOT_ITERATED
7972 | OPTI_TYPE_APPENDED_SALT
7973 | OPTI_TYPE_RAW_HASH;
7974 dgst_pos0 = 3;
7975 dgst_pos1 = 4;
7976 dgst_pos2 = 2;
7977 dgst_pos3 = 1;
7978 break;
7979
7980 case 133: hash_type = HASH_TYPE_SHA1;
7981 salt_type = SALT_TYPE_EMBEDDED;
7982 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7983 opts_type = OPTS_TYPE_PT_GENERATE_BE
7984 | OPTS_TYPE_PT_UNICODE
7985 | OPTS_TYPE_ST_ADD80
7986 | OPTS_TYPE_ST_ADDBITS15;
7987 kern_type = KERN_TYPE_SHA1_PWUSLT;
7988 dgst_size = DGST_SIZE_4_5;
7989 parse_func = peoplesoft_parse_hash;
7990 sort_by_digest = sort_by_digest_4_5;
7991 opti_type = OPTI_TYPE_ZERO_BYTE
7992 | OPTI_TYPE_PRECOMPUTE_INIT
7993 | OPTI_TYPE_PRECOMPUTE_MERKLE
7994 | OPTI_TYPE_EARLY_SKIP
7995 | OPTI_TYPE_NOT_ITERATED
7996 | OPTI_TYPE_APPENDED_SALT
7997 | OPTI_TYPE_RAW_HASH;
7998 dgst_pos0 = 3;
7999 dgst_pos1 = 4;
8000 dgst_pos2 = 2;
8001 dgst_pos3 = 1;
8002 break;
8003
8004 case 140: hash_type = HASH_TYPE_SHA1;
8005 salt_type = SALT_TYPE_INTERN;
8006 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8007 opts_type = OPTS_TYPE_PT_GENERATE_BE
8008 | OPTS_TYPE_PT_ADD80
8009 | OPTS_TYPE_PT_ADDBITS15
8010 | OPTS_TYPE_PT_UNICODE;
8011 kern_type = KERN_TYPE_SHA1_SLTPWU;
8012 dgst_size = DGST_SIZE_4_5;
8013 parse_func = sha1s_parse_hash;
8014 sort_by_digest = sort_by_digest_4_5;
8015 opti_type = OPTI_TYPE_ZERO_BYTE
8016 | OPTI_TYPE_PRECOMPUTE_INIT
8017 | OPTI_TYPE_PRECOMPUTE_MERKLE
8018 | OPTI_TYPE_EARLY_SKIP
8019 | OPTI_TYPE_NOT_ITERATED
8020 | OPTI_TYPE_PREPENDED_SALT
8021 | OPTI_TYPE_RAW_HASH;
8022 dgst_pos0 = 3;
8023 dgst_pos1 = 4;
8024 dgst_pos2 = 2;
8025 dgst_pos3 = 1;
8026 break;
8027
8028 case 141: hash_type = HASH_TYPE_SHA1;
8029 salt_type = SALT_TYPE_EMBEDDED;
8030 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8031 opts_type = OPTS_TYPE_PT_GENERATE_BE
8032 | OPTS_TYPE_PT_ADD80
8033 | OPTS_TYPE_PT_ADDBITS15
8034 | OPTS_TYPE_PT_UNICODE
8035 | OPTS_TYPE_ST_BASE64;
8036 kern_type = KERN_TYPE_SHA1_SLTPWU;
8037 dgst_size = DGST_SIZE_4_5;
8038 parse_func = episerver_parse_hash;
8039 sort_by_digest = sort_by_digest_4_5;
8040 opti_type = OPTI_TYPE_ZERO_BYTE
8041 | OPTI_TYPE_PRECOMPUTE_INIT
8042 | OPTI_TYPE_PRECOMPUTE_MERKLE
8043 | OPTI_TYPE_EARLY_SKIP
8044 | OPTI_TYPE_NOT_ITERATED
8045 | OPTI_TYPE_PREPENDED_SALT
8046 | OPTI_TYPE_RAW_HASH;
8047 dgst_pos0 = 3;
8048 dgst_pos1 = 4;
8049 dgst_pos2 = 2;
8050 dgst_pos3 = 1;
8051 break;
8052
8053 case 150: hash_type = HASH_TYPE_SHA1;
8054 salt_type = SALT_TYPE_INTERN;
8055 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8056 opts_type = OPTS_TYPE_PT_GENERATE_BE
8057 | OPTS_TYPE_ST_ADD80
8058 | OPTS_TYPE_ST_ADDBITS15;
8059 kern_type = KERN_TYPE_HMACSHA1_PW;
8060 dgst_size = DGST_SIZE_4_5;
8061 parse_func = hmacsha1_parse_hash;
8062 sort_by_digest = sort_by_digest_4_5;
8063 opti_type = OPTI_TYPE_ZERO_BYTE
8064 | OPTI_TYPE_NOT_ITERATED;
8065 dgst_pos0 = 3;
8066 dgst_pos1 = 4;
8067 dgst_pos2 = 2;
8068 dgst_pos3 = 1;
8069 break;
8070
8071 case 160: hash_type = HASH_TYPE_SHA1;
8072 salt_type = SALT_TYPE_INTERN;
8073 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8074 opts_type = OPTS_TYPE_PT_GENERATE_BE
8075 | OPTS_TYPE_PT_ADD80
8076 | OPTS_TYPE_PT_ADDBITS15;
8077 kern_type = KERN_TYPE_HMACSHA1_SLT;
8078 dgst_size = DGST_SIZE_4_5;
8079 parse_func = hmacsha1_parse_hash;
8080 sort_by_digest = sort_by_digest_4_5;
8081 opti_type = OPTI_TYPE_ZERO_BYTE
8082 | OPTI_TYPE_NOT_ITERATED;
8083 dgst_pos0 = 3;
8084 dgst_pos1 = 4;
8085 dgst_pos2 = 2;
8086 dgst_pos3 = 1;
8087 break;
8088
8089 case 190: hash_type = HASH_TYPE_SHA1;
8090 salt_type = SALT_TYPE_NONE;
8091 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8092 opts_type = OPTS_TYPE_PT_GENERATE_BE
8093 | OPTS_TYPE_PT_ADD80
8094 | OPTS_TYPE_PT_ADDBITS15;
8095 kern_type = KERN_TYPE_SHA1_LINKEDIN;
8096 dgst_size = DGST_SIZE_4_5;
8097 parse_func = sha1linkedin_parse_hash;
8098 sort_by_digest = sort_by_digest_4_5;
8099 opti_type = OPTI_TYPE_ZERO_BYTE
8100 | OPTI_TYPE_PRECOMPUTE_INIT
8101 | OPTI_TYPE_EARLY_SKIP
8102 | OPTI_TYPE_NOT_ITERATED
8103 | OPTI_TYPE_NOT_SALTED;
8104 dgst_pos0 = 0;
8105 dgst_pos1 = 4;
8106 dgst_pos2 = 3;
8107 dgst_pos3 = 2;
8108 break;
8109
8110 case 200: hash_type = HASH_TYPE_MYSQL;
8111 salt_type = SALT_TYPE_NONE;
8112 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8113 opts_type = 0;
8114 kern_type = KERN_TYPE_MYSQL;
8115 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8116 parse_func = mysql323_parse_hash;
8117 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8118 opti_type = OPTI_TYPE_ZERO_BYTE;
8119 dgst_pos0 = 0;
8120 dgst_pos1 = 1;
8121 dgst_pos2 = 2;
8122 dgst_pos3 = 3;
8123 break;
8124
8125 case 300: hash_type = HASH_TYPE_SHA1;
8126 salt_type = SALT_TYPE_NONE;
8127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8128 opts_type = OPTS_TYPE_PT_GENERATE_BE
8129 | OPTS_TYPE_PT_ADD80
8130 | OPTS_TYPE_PT_ADDBITS15;
8131 kern_type = KERN_TYPE_MYSQL41;
8132 dgst_size = DGST_SIZE_4_5;
8133 parse_func = sha1_parse_hash;
8134 sort_by_digest = sort_by_digest_4_5;
8135 opti_type = OPTI_TYPE_ZERO_BYTE
8136 | OPTI_TYPE_PRECOMPUTE_INIT
8137 | OPTI_TYPE_PRECOMPUTE_MERKLE
8138 | OPTI_TYPE_EARLY_SKIP
8139 | OPTI_TYPE_NOT_ITERATED
8140 | OPTI_TYPE_NOT_SALTED;
8141 dgst_pos0 = 3;
8142 dgst_pos1 = 4;
8143 dgst_pos2 = 2;
8144 dgst_pos3 = 1;
8145 break;
8146
8147 case 400: hash_type = HASH_TYPE_MD5;
8148 salt_type = SALT_TYPE_EMBEDDED;
8149 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8150 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8151 kern_type = KERN_TYPE_PHPASS;
8152 dgst_size = DGST_SIZE_4_4;
8153 parse_func = phpass_parse_hash;
8154 sort_by_digest = sort_by_digest_4_4;
8155 opti_type = OPTI_TYPE_ZERO_BYTE
8156 | OPTI_TYPE_SLOW_HASH_SIMD;
8157 dgst_pos0 = 0;
8158 dgst_pos1 = 1;
8159 dgst_pos2 = 2;
8160 dgst_pos3 = 3;
8161 break;
8162
8163 case 500: hash_type = HASH_TYPE_MD5;
8164 salt_type = SALT_TYPE_EMBEDDED;
8165 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8166 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8167 kern_type = KERN_TYPE_MD5CRYPT;
8168 dgst_size = DGST_SIZE_4_4;
8169 parse_func = md5crypt_parse_hash;
8170 sort_by_digest = sort_by_digest_4_4;
8171 opti_type = OPTI_TYPE_ZERO_BYTE;
8172 dgst_pos0 = 0;
8173 dgst_pos1 = 1;
8174 dgst_pos2 = 2;
8175 dgst_pos3 = 3;
8176 break;
8177
8178 case 501: hash_type = HASH_TYPE_MD5;
8179 salt_type = SALT_TYPE_EMBEDDED;
8180 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8181 opts_type = OPTS_TYPE_PT_GENERATE_LE
8182 | OPTS_TYPE_HASH_COPY;
8183 kern_type = KERN_TYPE_MD5CRYPT;
8184 dgst_size = DGST_SIZE_4_4;
8185 parse_func = juniper_parse_hash;
8186 sort_by_digest = sort_by_digest_4_4;
8187 opti_type = OPTI_TYPE_ZERO_BYTE;
8188 dgst_pos0 = 0;
8189 dgst_pos1 = 1;
8190 dgst_pos2 = 2;
8191 dgst_pos3 = 3;
8192 break;
8193
8194 case 900: hash_type = HASH_TYPE_MD4;
8195 salt_type = SALT_TYPE_NONE;
8196 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8197 opts_type = OPTS_TYPE_PT_GENERATE_LE
8198 | OPTS_TYPE_PT_ADD80
8199 | OPTS_TYPE_PT_ADDBITS14;
8200 kern_type = KERN_TYPE_MD4;
8201 dgst_size = DGST_SIZE_4_4;
8202 parse_func = md4_parse_hash;
8203 sort_by_digest = sort_by_digest_4_4;
8204 opti_type = OPTI_TYPE_ZERO_BYTE
8205 | OPTI_TYPE_PRECOMPUTE_INIT
8206 | OPTI_TYPE_PRECOMPUTE_MERKLE
8207 | OPTI_TYPE_MEET_IN_MIDDLE
8208 | OPTI_TYPE_EARLY_SKIP
8209 | OPTI_TYPE_NOT_ITERATED
8210 | OPTI_TYPE_NOT_SALTED
8211 | OPTI_TYPE_RAW_HASH;
8212 dgst_pos0 = 0;
8213 dgst_pos1 = 3;
8214 dgst_pos2 = 2;
8215 dgst_pos3 = 1;
8216 break;
8217
8218 case 1000: hash_type = HASH_TYPE_MD4;
8219 salt_type = SALT_TYPE_NONE;
8220 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8221 opts_type = OPTS_TYPE_PT_GENERATE_LE
8222 | OPTS_TYPE_PT_ADD80
8223 | OPTS_TYPE_PT_ADDBITS14
8224 | OPTS_TYPE_PT_UNICODE;
8225 kern_type = KERN_TYPE_MD4_PWU;
8226 dgst_size = DGST_SIZE_4_4;
8227 parse_func = md4_parse_hash;
8228 sort_by_digest = sort_by_digest_4_4;
8229 opti_type = OPTI_TYPE_ZERO_BYTE
8230 | OPTI_TYPE_PRECOMPUTE_INIT
8231 | OPTI_TYPE_PRECOMPUTE_MERKLE
8232 | OPTI_TYPE_MEET_IN_MIDDLE
8233 | OPTI_TYPE_EARLY_SKIP
8234 | OPTI_TYPE_NOT_ITERATED
8235 | OPTI_TYPE_NOT_SALTED
8236 | OPTI_TYPE_RAW_HASH;
8237 dgst_pos0 = 0;
8238 dgst_pos1 = 3;
8239 dgst_pos2 = 2;
8240 dgst_pos3 = 1;
8241 break;
8242
8243 case 1100: hash_type = HASH_TYPE_MD4;
8244 salt_type = SALT_TYPE_INTERN;
8245 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8246 opts_type = OPTS_TYPE_PT_GENERATE_LE
8247 | OPTS_TYPE_PT_ADD80
8248 | OPTS_TYPE_PT_ADDBITS14
8249 | OPTS_TYPE_PT_UNICODE
8250 | OPTS_TYPE_ST_ADD80
8251 | OPTS_TYPE_ST_UNICODE
8252 | OPTS_TYPE_ST_LOWER;
8253 kern_type = KERN_TYPE_MD44_PWUSLT;
8254 dgst_size = DGST_SIZE_4_4;
8255 parse_func = dcc_parse_hash;
8256 sort_by_digest = sort_by_digest_4_4;
8257 opti_type = OPTI_TYPE_ZERO_BYTE
8258 | OPTI_TYPE_PRECOMPUTE_INIT
8259 | OPTI_TYPE_PRECOMPUTE_MERKLE
8260 | OPTI_TYPE_EARLY_SKIP
8261 | OPTI_TYPE_NOT_ITERATED;
8262 dgst_pos0 = 0;
8263 dgst_pos1 = 3;
8264 dgst_pos2 = 2;
8265 dgst_pos3 = 1;
8266 break;
8267
8268 case 1400: hash_type = HASH_TYPE_SHA256;
8269 salt_type = SALT_TYPE_NONE;
8270 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8271 opts_type = OPTS_TYPE_PT_GENERATE_BE
8272 | OPTS_TYPE_PT_ADD80
8273 | OPTS_TYPE_PT_ADDBITS15;
8274 kern_type = KERN_TYPE_SHA256;
8275 dgst_size = DGST_SIZE_4_8;
8276 parse_func = sha256_parse_hash;
8277 sort_by_digest = sort_by_digest_4_8;
8278 opti_type = OPTI_TYPE_ZERO_BYTE
8279 | OPTI_TYPE_PRECOMPUTE_INIT
8280 | OPTI_TYPE_PRECOMPUTE_MERKLE
8281 | OPTI_TYPE_EARLY_SKIP
8282 | OPTI_TYPE_NOT_ITERATED
8283 | OPTI_TYPE_NOT_SALTED
8284 | OPTI_TYPE_RAW_HASH;
8285 dgst_pos0 = 3;
8286 dgst_pos1 = 7;
8287 dgst_pos2 = 2;
8288 dgst_pos3 = 6;
8289 break;
8290
8291 case 1410: hash_type = HASH_TYPE_SHA256;
8292 salt_type = SALT_TYPE_INTERN;
8293 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8294 opts_type = OPTS_TYPE_PT_GENERATE_BE
8295 | OPTS_TYPE_ST_ADD80
8296 | OPTS_TYPE_ST_ADDBITS15;
8297 kern_type = KERN_TYPE_SHA256_PWSLT;
8298 dgst_size = DGST_SIZE_4_8;
8299 parse_func = sha256s_parse_hash;
8300 sort_by_digest = sort_by_digest_4_8;
8301 opti_type = OPTI_TYPE_ZERO_BYTE
8302 | OPTI_TYPE_PRECOMPUTE_INIT
8303 | OPTI_TYPE_PRECOMPUTE_MERKLE
8304 | OPTI_TYPE_EARLY_SKIP
8305 | OPTI_TYPE_NOT_ITERATED
8306 | OPTI_TYPE_APPENDED_SALT
8307 | OPTI_TYPE_RAW_HASH;
8308 dgst_pos0 = 3;
8309 dgst_pos1 = 7;
8310 dgst_pos2 = 2;
8311 dgst_pos3 = 6;
8312 break;
8313
8314 case 1420: hash_type = HASH_TYPE_SHA256;
8315 salt_type = SALT_TYPE_INTERN;
8316 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8317 opts_type = OPTS_TYPE_PT_GENERATE_BE
8318 | OPTS_TYPE_PT_ADD80
8319 | OPTS_TYPE_PT_ADDBITS15;
8320 kern_type = KERN_TYPE_SHA256_SLTPW;
8321 dgst_size = DGST_SIZE_4_8;
8322 parse_func = sha256s_parse_hash;
8323 sort_by_digest = sort_by_digest_4_8;
8324 opti_type = OPTI_TYPE_ZERO_BYTE
8325 | OPTI_TYPE_PRECOMPUTE_INIT
8326 | OPTI_TYPE_PRECOMPUTE_MERKLE
8327 | OPTI_TYPE_EARLY_SKIP
8328 | OPTI_TYPE_NOT_ITERATED
8329 | OPTI_TYPE_PREPENDED_SALT
8330 | OPTI_TYPE_RAW_HASH;
8331 dgst_pos0 = 3;
8332 dgst_pos1 = 7;
8333 dgst_pos2 = 2;
8334 dgst_pos3 = 6;
8335 break;
8336
8337 case 1421: hash_type = HASH_TYPE_SHA256;
8338 salt_type = SALT_TYPE_EMBEDDED;
8339 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8340 opts_type = OPTS_TYPE_PT_GENERATE_BE
8341 | OPTS_TYPE_PT_ADD80
8342 | OPTS_TYPE_PT_ADDBITS15;
8343 kern_type = KERN_TYPE_SHA256_SLTPW;
8344 dgst_size = DGST_SIZE_4_8;
8345 parse_func = hmailserver_parse_hash;
8346 sort_by_digest = sort_by_digest_4_8;
8347 opti_type = OPTI_TYPE_ZERO_BYTE
8348 | OPTI_TYPE_PRECOMPUTE_INIT
8349 | OPTI_TYPE_PRECOMPUTE_MERKLE
8350 | OPTI_TYPE_EARLY_SKIP
8351 | OPTI_TYPE_NOT_ITERATED
8352 | OPTI_TYPE_PREPENDED_SALT
8353 | OPTI_TYPE_RAW_HASH;
8354 dgst_pos0 = 3;
8355 dgst_pos1 = 7;
8356 dgst_pos2 = 2;
8357 dgst_pos3 = 6;
8358 break;
8359
8360 case 1430: hash_type = HASH_TYPE_SHA256;
8361 salt_type = SALT_TYPE_INTERN;
8362 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8363 opts_type = OPTS_TYPE_PT_GENERATE_BE
8364 | OPTS_TYPE_PT_UNICODE
8365 | OPTS_TYPE_ST_ADD80
8366 | OPTS_TYPE_ST_ADDBITS15;
8367 kern_type = KERN_TYPE_SHA256_PWUSLT;
8368 dgst_size = DGST_SIZE_4_8;
8369 parse_func = sha256s_parse_hash;
8370 sort_by_digest = sort_by_digest_4_8;
8371 opti_type = OPTI_TYPE_ZERO_BYTE
8372 | OPTI_TYPE_PRECOMPUTE_INIT
8373 | OPTI_TYPE_PRECOMPUTE_MERKLE
8374 | OPTI_TYPE_EARLY_SKIP
8375 | OPTI_TYPE_NOT_ITERATED
8376 | OPTI_TYPE_APPENDED_SALT
8377 | OPTI_TYPE_RAW_HASH;
8378 dgst_pos0 = 3;
8379 dgst_pos1 = 7;
8380 dgst_pos2 = 2;
8381 dgst_pos3 = 6;
8382 break;
8383
8384 case 1440: hash_type = HASH_TYPE_SHA256;
8385 salt_type = SALT_TYPE_INTERN;
8386 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8387 opts_type = OPTS_TYPE_PT_GENERATE_BE
8388 | OPTS_TYPE_PT_ADD80
8389 | OPTS_TYPE_PT_ADDBITS15
8390 | OPTS_TYPE_PT_UNICODE;
8391 kern_type = KERN_TYPE_SHA256_SLTPWU;
8392 dgst_size = DGST_SIZE_4_8;
8393 parse_func = sha256s_parse_hash;
8394 sort_by_digest = sort_by_digest_4_8;
8395 opti_type = OPTI_TYPE_ZERO_BYTE
8396 | OPTI_TYPE_PRECOMPUTE_INIT
8397 | OPTI_TYPE_PRECOMPUTE_MERKLE
8398 | OPTI_TYPE_EARLY_SKIP
8399 | OPTI_TYPE_NOT_ITERATED
8400 | OPTI_TYPE_PREPENDED_SALT
8401 | OPTI_TYPE_RAW_HASH;
8402 dgst_pos0 = 3;
8403 dgst_pos1 = 7;
8404 dgst_pos2 = 2;
8405 dgst_pos3 = 6;
8406 break;
8407
8408 case 1441: hash_type = HASH_TYPE_SHA256;
8409 salt_type = SALT_TYPE_EMBEDDED;
8410 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8411 opts_type = OPTS_TYPE_PT_GENERATE_BE
8412 | OPTS_TYPE_PT_ADD80
8413 | OPTS_TYPE_PT_ADDBITS15
8414 | OPTS_TYPE_PT_UNICODE
8415 | OPTS_TYPE_ST_BASE64;
8416 kern_type = KERN_TYPE_SHA256_SLTPWU;
8417 dgst_size = DGST_SIZE_4_8;
8418 parse_func = episerver4_parse_hash;
8419 sort_by_digest = sort_by_digest_4_8;
8420 opti_type = OPTI_TYPE_ZERO_BYTE
8421 | OPTI_TYPE_PRECOMPUTE_INIT
8422 | OPTI_TYPE_PRECOMPUTE_MERKLE
8423 | OPTI_TYPE_EARLY_SKIP
8424 | OPTI_TYPE_NOT_ITERATED
8425 | OPTI_TYPE_PREPENDED_SALT
8426 | OPTI_TYPE_RAW_HASH;
8427 dgst_pos0 = 3;
8428 dgst_pos1 = 7;
8429 dgst_pos2 = 2;
8430 dgst_pos3 = 6;
8431 break;
8432
8433 case 1450: hash_type = HASH_TYPE_SHA256;
8434 salt_type = SALT_TYPE_INTERN;
8435 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8436 opts_type = OPTS_TYPE_PT_GENERATE_BE
8437 | OPTS_TYPE_ST_ADD80;
8438 kern_type = KERN_TYPE_HMACSHA256_PW;
8439 dgst_size = DGST_SIZE_4_8;
8440 parse_func = hmacsha256_parse_hash;
8441 sort_by_digest = sort_by_digest_4_8;
8442 opti_type = OPTI_TYPE_ZERO_BYTE
8443 | OPTI_TYPE_NOT_ITERATED;
8444 dgst_pos0 = 3;
8445 dgst_pos1 = 7;
8446 dgst_pos2 = 2;
8447 dgst_pos3 = 6;
8448 break;
8449
8450 case 1460: hash_type = HASH_TYPE_SHA256;
8451 salt_type = SALT_TYPE_INTERN;
8452 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8453 opts_type = OPTS_TYPE_PT_GENERATE_BE
8454 | OPTS_TYPE_PT_ADD80
8455 | OPTS_TYPE_PT_ADDBITS15;
8456 kern_type = KERN_TYPE_HMACSHA256_SLT;
8457 dgst_size = DGST_SIZE_4_8;
8458 parse_func = hmacsha256_parse_hash;
8459 sort_by_digest = sort_by_digest_4_8;
8460 opti_type = OPTI_TYPE_ZERO_BYTE
8461 | OPTI_TYPE_NOT_ITERATED;
8462 dgst_pos0 = 3;
8463 dgst_pos1 = 7;
8464 dgst_pos2 = 2;
8465 dgst_pos3 = 6;
8466 break;
8467
8468 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8469 salt_type = SALT_TYPE_EMBEDDED;
8470 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8471 opts_type = OPTS_TYPE_PT_GENERATE_LE
8472 | OPTS_TYPE_PT_BITSLICE;
8473 kern_type = KERN_TYPE_DESCRYPT;
8474 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8475 parse_func = descrypt_parse_hash;
8476 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8477 opti_type = OPTI_TYPE_ZERO_BYTE
8478 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8479 dgst_pos0 = 0;
8480 dgst_pos1 = 1;
8481 dgst_pos2 = 2;
8482 dgst_pos3 = 3;
8483 break;
8484
8485 case 1600: hash_type = HASH_TYPE_MD5;
8486 salt_type = SALT_TYPE_EMBEDDED;
8487 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8488 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8489 kern_type = KERN_TYPE_APR1CRYPT;
8490 dgst_size = DGST_SIZE_4_4;
8491 parse_func = md5apr1_parse_hash;
8492 sort_by_digest = sort_by_digest_4_4;
8493 opti_type = OPTI_TYPE_ZERO_BYTE;
8494 dgst_pos0 = 0;
8495 dgst_pos1 = 1;
8496 dgst_pos2 = 2;
8497 dgst_pos3 = 3;
8498 break;
8499
8500 case 1700: hash_type = HASH_TYPE_SHA512;
8501 salt_type = SALT_TYPE_NONE;
8502 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8503 opts_type = OPTS_TYPE_PT_GENERATE_BE
8504 | OPTS_TYPE_PT_ADD80
8505 | OPTS_TYPE_PT_ADDBITS15;
8506 kern_type = KERN_TYPE_SHA512;
8507 dgst_size = DGST_SIZE_8_8;
8508 parse_func = sha512_parse_hash;
8509 sort_by_digest = sort_by_digest_8_8;
8510 opti_type = OPTI_TYPE_ZERO_BYTE
8511 | OPTI_TYPE_PRECOMPUTE_INIT
8512 | OPTI_TYPE_PRECOMPUTE_MERKLE
8513 | OPTI_TYPE_EARLY_SKIP
8514 | OPTI_TYPE_NOT_ITERATED
8515 | OPTI_TYPE_NOT_SALTED
8516 | OPTI_TYPE_USES_BITS_64
8517 | OPTI_TYPE_RAW_HASH;
8518 dgst_pos0 = 14;
8519 dgst_pos1 = 15;
8520 dgst_pos2 = 6;
8521 dgst_pos3 = 7;
8522 break;
8523
8524 case 1710: hash_type = HASH_TYPE_SHA512;
8525 salt_type = SALT_TYPE_INTERN;
8526 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8527 opts_type = OPTS_TYPE_PT_GENERATE_BE
8528 | OPTS_TYPE_ST_ADD80
8529 | OPTS_TYPE_ST_ADDBITS15;
8530 kern_type = KERN_TYPE_SHA512_PWSLT;
8531 dgst_size = DGST_SIZE_8_8;
8532 parse_func = sha512s_parse_hash;
8533 sort_by_digest = sort_by_digest_8_8;
8534 opti_type = OPTI_TYPE_ZERO_BYTE
8535 | OPTI_TYPE_PRECOMPUTE_INIT
8536 | OPTI_TYPE_PRECOMPUTE_MERKLE
8537 | OPTI_TYPE_EARLY_SKIP
8538 | OPTI_TYPE_NOT_ITERATED
8539 | OPTI_TYPE_APPENDED_SALT
8540 | OPTI_TYPE_USES_BITS_64
8541 | OPTI_TYPE_RAW_HASH;
8542 dgst_pos0 = 14;
8543 dgst_pos1 = 15;
8544 dgst_pos2 = 6;
8545 dgst_pos3 = 7;
8546 break;
8547
8548 case 1711: hash_type = HASH_TYPE_SHA512;
8549 salt_type = SALT_TYPE_EMBEDDED;
8550 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8551 opts_type = OPTS_TYPE_PT_GENERATE_BE
8552 | OPTS_TYPE_ST_ADD80
8553 | OPTS_TYPE_ST_ADDBITS15;
8554 kern_type = KERN_TYPE_SHA512_PWSLT;
8555 dgst_size = DGST_SIZE_8_8;
8556 parse_func = sha512b64s_parse_hash;
8557 sort_by_digest = sort_by_digest_8_8;
8558 opti_type = OPTI_TYPE_ZERO_BYTE
8559 | OPTI_TYPE_PRECOMPUTE_INIT
8560 | OPTI_TYPE_PRECOMPUTE_MERKLE
8561 | OPTI_TYPE_EARLY_SKIP
8562 | OPTI_TYPE_NOT_ITERATED
8563 | OPTI_TYPE_APPENDED_SALT
8564 | OPTI_TYPE_USES_BITS_64
8565 | OPTI_TYPE_RAW_HASH;
8566 dgst_pos0 = 14;
8567 dgst_pos1 = 15;
8568 dgst_pos2 = 6;
8569 dgst_pos3 = 7;
8570 break;
8571
8572 case 1720: hash_type = HASH_TYPE_SHA512;
8573 salt_type = SALT_TYPE_INTERN;
8574 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8575 opts_type = OPTS_TYPE_PT_GENERATE_BE
8576 | OPTS_TYPE_PT_ADD80
8577 | OPTS_TYPE_PT_ADDBITS15;
8578 kern_type = KERN_TYPE_SHA512_SLTPW;
8579 dgst_size = DGST_SIZE_8_8;
8580 parse_func = sha512s_parse_hash;
8581 sort_by_digest = sort_by_digest_8_8;
8582 opti_type = OPTI_TYPE_ZERO_BYTE
8583 | OPTI_TYPE_PRECOMPUTE_INIT
8584 | OPTI_TYPE_PRECOMPUTE_MERKLE
8585 | OPTI_TYPE_EARLY_SKIP
8586 | OPTI_TYPE_NOT_ITERATED
8587 | OPTI_TYPE_PREPENDED_SALT
8588 | OPTI_TYPE_USES_BITS_64
8589 | OPTI_TYPE_RAW_HASH;
8590 dgst_pos0 = 14;
8591 dgst_pos1 = 15;
8592 dgst_pos2 = 6;
8593 dgst_pos3 = 7;
8594 break;
8595
8596 case 1722: hash_type = HASH_TYPE_SHA512;
8597 salt_type = SALT_TYPE_EMBEDDED;
8598 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8599 opts_type = OPTS_TYPE_PT_GENERATE_BE
8600 | OPTS_TYPE_PT_ADD80
8601 | OPTS_TYPE_PT_ADDBITS15
8602 | OPTS_TYPE_ST_HEX;
8603 kern_type = KERN_TYPE_SHA512_SLTPW;
8604 dgst_size = DGST_SIZE_8_8;
8605 parse_func = osx512_parse_hash;
8606 sort_by_digest = sort_by_digest_8_8;
8607 opti_type = OPTI_TYPE_ZERO_BYTE
8608 | OPTI_TYPE_PRECOMPUTE_INIT
8609 | OPTI_TYPE_PRECOMPUTE_MERKLE
8610 | OPTI_TYPE_EARLY_SKIP
8611 | OPTI_TYPE_NOT_ITERATED
8612 | OPTI_TYPE_PREPENDED_SALT
8613 | OPTI_TYPE_USES_BITS_64
8614 | OPTI_TYPE_RAW_HASH;
8615 dgst_pos0 = 14;
8616 dgst_pos1 = 15;
8617 dgst_pos2 = 6;
8618 dgst_pos3 = 7;
8619 break;
8620
8621 case 1730: hash_type = HASH_TYPE_SHA512;
8622 salt_type = SALT_TYPE_INTERN;
8623 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8624 opts_type = OPTS_TYPE_PT_GENERATE_BE
8625 | OPTS_TYPE_PT_UNICODE
8626 | OPTS_TYPE_ST_ADD80
8627 | OPTS_TYPE_ST_ADDBITS15;
8628 kern_type = KERN_TYPE_SHA512_PWSLTU;
8629 dgst_size = DGST_SIZE_8_8;
8630 parse_func = sha512s_parse_hash;
8631 sort_by_digest = sort_by_digest_8_8;
8632 opti_type = OPTI_TYPE_ZERO_BYTE
8633 | OPTI_TYPE_PRECOMPUTE_INIT
8634 | OPTI_TYPE_PRECOMPUTE_MERKLE
8635 | OPTI_TYPE_EARLY_SKIP
8636 | OPTI_TYPE_NOT_ITERATED
8637 | OPTI_TYPE_APPENDED_SALT
8638 | OPTI_TYPE_USES_BITS_64
8639 | OPTI_TYPE_RAW_HASH;
8640 dgst_pos0 = 14;
8641 dgst_pos1 = 15;
8642 dgst_pos2 = 6;
8643 dgst_pos3 = 7;
8644 break;
8645
8646 case 1731: hash_type = HASH_TYPE_SHA512;
8647 salt_type = SALT_TYPE_EMBEDDED;
8648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8649 opts_type = OPTS_TYPE_PT_GENERATE_BE
8650 | OPTS_TYPE_PT_UNICODE
8651 | OPTS_TYPE_ST_ADD80
8652 | OPTS_TYPE_ST_ADDBITS15
8653 | OPTS_TYPE_ST_HEX;
8654 kern_type = KERN_TYPE_SHA512_PWSLTU;
8655 dgst_size = DGST_SIZE_8_8;
8656 parse_func = mssql2012_parse_hash;
8657 sort_by_digest = sort_by_digest_8_8;
8658 opti_type = OPTI_TYPE_ZERO_BYTE
8659 | OPTI_TYPE_PRECOMPUTE_INIT
8660 | OPTI_TYPE_PRECOMPUTE_MERKLE
8661 | OPTI_TYPE_EARLY_SKIP
8662 | OPTI_TYPE_NOT_ITERATED
8663 | OPTI_TYPE_APPENDED_SALT
8664 | OPTI_TYPE_USES_BITS_64
8665 | OPTI_TYPE_RAW_HASH;
8666 dgst_pos0 = 14;
8667 dgst_pos1 = 15;
8668 dgst_pos2 = 6;
8669 dgst_pos3 = 7;
8670 break;
8671
8672 case 1740: hash_type = HASH_TYPE_SHA512;
8673 salt_type = SALT_TYPE_INTERN;
8674 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8675 opts_type = OPTS_TYPE_PT_GENERATE_BE
8676 | OPTS_TYPE_PT_ADD80
8677 | OPTS_TYPE_PT_ADDBITS15
8678 | OPTS_TYPE_PT_UNICODE;
8679 kern_type = KERN_TYPE_SHA512_SLTPWU;
8680 dgst_size = DGST_SIZE_8_8;
8681 parse_func = sha512s_parse_hash;
8682 sort_by_digest = sort_by_digest_8_8;
8683 opti_type = OPTI_TYPE_ZERO_BYTE
8684 | OPTI_TYPE_PRECOMPUTE_INIT
8685 | OPTI_TYPE_PRECOMPUTE_MERKLE
8686 | OPTI_TYPE_EARLY_SKIP
8687 | OPTI_TYPE_NOT_ITERATED
8688 | OPTI_TYPE_PREPENDED_SALT
8689 | OPTI_TYPE_USES_BITS_64
8690 | OPTI_TYPE_RAW_HASH;
8691 dgst_pos0 = 14;
8692 dgst_pos1 = 15;
8693 dgst_pos2 = 6;
8694 dgst_pos3 = 7;
8695 break;
8696
8697 case 1750: hash_type = HASH_TYPE_SHA512;
8698 salt_type = SALT_TYPE_INTERN;
8699 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8700 opts_type = OPTS_TYPE_PT_GENERATE_BE
8701 | OPTS_TYPE_ST_ADD80;
8702 kern_type = KERN_TYPE_HMACSHA512_PW;
8703 dgst_size = DGST_SIZE_8_8;
8704 parse_func = hmacsha512_parse_hash;
8705 sort_by_digest = sort_by_digest_8_8;
8706 opti_type = OPTI_TYPE_ZERO_BYTE
8707 | OPTI_TYPE_USES_BITS_64
8708 | OPTI_TYPE_NOT_ITERATED;
8709 dgst_pos0 = 14;
8710 dgst_pos1 = 15;
8711 dgst_pos2 = 6;
8712 dgst_pos3 = 7;
8713 break;
8714
8715 case 1760: hash_type = HASH_TYPE_SHA512;
8716 salt_type = SALT_TYPE_INTERN;
8717 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8718 opts_type = OPTS_TYPE_PT_GENERATE_BE
8719 | OPTS_TYPE_PT_ADD80
8720 | OPTS_TYPE_PT_ADDBITS15;
8721 kern_type = KERN_TYPE_HMACSHA512_SLT;
8722 dgst_size = DGST_SIZE_8_8;
8723 parse_func = hmacsha512_parse_hash;
8724 sort_by_digest = sort_by_digest_8_8;
8725 opti_type = OPTI_TYPE_ZERO_BYTE
8726 | OPTI_TYPE_USES_BITS_64
8727 | OPTI_TYPE_NOT_ITERATED;
8728 dgst_pos0 = 14;
8729 dgst_pos1 = 15;
8730 dgst_pos2 = 6;
8731 dgst_pos3 = 7;
8732 break;
8733
8734 case 1800: hash_type = HASH_TYPE_SHA512;
8735 salt_type = SALT_TYPE_EMBEDDED;
8736 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8737 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8738 kern_type = KERN_TYPE_SHA512CRYPT;
8739 dgst_size = DGST_SIZE_8_8;
8740 parse_func = sha512crypt_parse_hash;
8741 sort_by_digest = sort_by_digest_8_8;
8742 opti_type = OPTI_TYPE_ZERO_BYTE
8743 | OPTI_TYPE_USES_BITS_64;
8744 dgst_pos0 = 0;
8745 dgst_pos1 = 1;
8746 dgst_pos2 = 2;
8747 dgst_pos3 = 3;
8748 break;
8749
8750 case 2000: hash_type = HASH_TYPE_STDOUT;
8751 salt_type = SALT_TYPE_NONE;
8752 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8753 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8754 kern_type = KERN_TYPE_STDOUT;
8755 dgst_size = DGST_SIZE_4_4;
8756 parse_func = NULL;
8757 sort_by_digest = NULL;
8758 opti_type = 0;
8759 dgst_pos0 = 0;
8760 dgst_pos1 = 0;
8761 dgst_pos2 = 0;
8762 dgst_pos3 = 0;
8763 break;
8764
8765 case 2100: hash_type = HASH_TYPE_DCC2;
8766 salt_type = SALT_TYPE_EMBEDDED;
8767 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8768 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8769 | OPTS_TYPE_ST_LOWER
8770 | OPTS_TYPE_ST_UNICODE;
8771 kern_type = KERN_TYPE_DCC2;
8772 dgst_size = DGST_SIZE_4_4;
8773 parse_func = dcc2_parse_hash;
8774 sort_by_digest = sort_by_digest_4_4;
8775 opti_type = OPTI_TYPE_ZERO_BYTE
8776 | OPTI_TYPE_SLOW_HASH_SIMD;
8777 dgst_pos0 = 0;
8778 dgst_pos1 = 1;
8779 dgst_pos2 = 2;
8780 dgst_pos3 = 3;
8781 break;
8782
8783 case 2400: hash_type = HASH_TYPE_MD5;
8784 salt_type = SALT_TYPE_NONE;
8785 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8786 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8787 kern_type = KERN_TYPE_MD5PIX;
8788 dgst_size = DGST_SIZE_4_4;
8789 parse_func = md5pix_parse_hash;
8790 sort_by_digest = sort_by_digest_4_4;
8791 opti_type = OPTI_TYPE_ZERO_BYTE
8792 | OPTI_TYPE_PRECOMPUTE_INIT
8793 | OPTI_TYPE_PRECOMPUTE_MERKLE
8794 | OPTI_TYPE_EARLY_SKIP
8795 | OPTI_TYPE_NOT_ITERATED
8796 | OPTI_TYPE_NOT_SALTED;
8797 dgst_pos0 = 0;
8798 dgst_pos1 = 3;
8799 dgst_pos2 = 2;
8800 dgst_pos3 = 1;
8801 break;
8802
8803 case 2410: hash_type = HASH_TYPE_MD5;
8804 salt_type = SALT_TYPE_INTERN;
8805 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8806 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8807 kern_type = KERN_TYPE_MD5ASA;
8808 dgst_size = DGST_SIZE_4_4;
8809 parse_func = md5asa_parse_hash;
8810 sort_by_digest = sort_by_digest_4_4;
8811 opti_type = OPTI_TYPE_ZERO_BYTE
8812 | OPTI_TYPE_PRECOMPUTE_INIT
8813 | OPTI_TYPE_PRECOMPUTE_MERKLE
8814 | OPTI_TYPE_EARLY_SKIP
8815 | OPTI_TYPE_NOT_ITERATED;
8816 dgst_pos0 = 0;
8817 dgst_pos1 = 3;
8818 dgst_pos2 = 2;
8819 dgst_pos3 = 1;
8820 break;
8821
8822 case 2500: hash_type = HASH_TYPE_WPA;
8823 salt_type = SALT_TYPE_EMBEDDED;
8824 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8825 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8826 kern_type = KERN_TYPE_WPA;
8827 dgst_size = DGST_SIZE_4_4;
8828 parse_func = wpa_parse_hash;
8829 sort_by_digest = sort_by_digest_4_4;
8830 opti_type = OPTI_TYPE_ZERO_BYTE
8831 | OPTI_TYPE_SLOW_HASH_SIMD;
8832 dgst_pos0 = 0;
8833 dgst_pos1 = 1;
8834 dgst_pos2 = 2;
8835 dgst_pos3 = 3;
8836 break;
8837
8838 case 2600: hash_type = HASH_TYPE_MD5;
8839 salt_type = SALT_TYPE_VIRTUAL;
8840 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8841 opts_type = OPTS_TYPE_PT_GENERATE_LE
8842 | OPTS_TYPE_PT_ADD80
8843 | OPTS_TYPE_PT_ADDBITS14
8844 | OPTS_TYPE_ST_ADD80;
8845 kern_type = KERN_TYPE_MD55_PWSLT1;
8846 dgst_size = DGST_SIZE_4_4;
8847 parse_func = md5md5_parse_hash;
8848 sort_by_digest = sort_by_digest_4_4;
8849 opti_type = OPTI_TYPE_ZERO_BYTE
8850 | OPTI_TYPE_PRECOMPUTE_INIT
8851 | OPTI_TYPE_PRECOMPUTE_MERKLE
8852 | OPTI_TYPE_EARLY_SKIP;
8853 dgst_pos0 = 0;
8854 dgst_pos1 = 3;
8855 dgst_pos2 = 2;
8856 dgst_pos3 = 1;
8857 break;
8858
8859 case 2611: hash_type = HASH_TYPE_MD5;
8860 salt_type = SALT_TYPE_INTERN;
8861 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8862 opts_type = OPTS_TYPE_PT_GENERATE_LE
8863 | OPTS_TYPE_PT_ADD80
8864 | OPTS_TYPE_PT_ADDBITS14
8865 | OPTS_TYPE_ST_ADD80;
8866 kern_type = KERN_TYPE_MD55_PWSLT1;
8867 dgst_size = DGST_SIZE_4_4;
8868 parse_func = vb3_parse_hash;
8869 sort_by_digest = sort_by_digest_4_4;
8870 opti_type = OPTI_TYPE_ZERO_BYTE
8871 | OPTI_TYPE_PRECOMPUTE_INIT
8872 | OPTI_TYPE_PRECOMPUTE_MERKLE
8873 | OPTI_TYPE_EARLY_SKIP;
8874 dgst_pos0 = 0;
8875 dgst_pos1 = 3;
8876 dgst_pos2 = 2;
8877 dgst_pos3 = 1;
8878 break;
8879
8880 case 2612: hash_type = HASH_TYPE_MD5;
8881 salt_type = SALT_TYPE_EMBEDDED;
8882 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8883 opts_type = OPTS_TYPE_PT_GENERATE_LE
8884 | OPTS_TYPE_PT_ADD80
8885 | OPTS_TYPE_PT_ADDBITS14
8886 | OPTS_TYPE_ST_ADD80
8887 | OPTS_TYPE_ST_HEX;
8888 kern_type = KERN_TYPE_MD55_PWSLT1;
8889 dgst_size = DGST_SIZE_4_4;
8890 parse_func = phps_parse_hash;
8891 sort_by_digest = sort_by_digest_4_4;
8892 opti_type = OPTI_TYPE_ZERO_BYTE
8893 | OPTI_TYPE_PRECOMPUTE_INIT
8894 | OPTI_TYPE_PRECOMPUTE_MERKLE
8895 | OPTI_TYPE_EARLY_SKIP;
8896 dgst_pos0 = 0;
8897 dgst_pos1 = 3;
8898 dgst_pos2 = 2;
8899 dgst_pos3 = 1;
8900 break;
8901
8902 case 2711: hash_type = HASH_TYPE_MD5;
8903 salt_type = SALT_TYPE_INTERN;
8904 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8905 opts_type = OPTS_TYPE_PT_GENERATE_LE
8906 | OPTS_TYPE_PT_ADD80
8907 | OPTS_TYPE_PT_ADDBITS14
8908 | OPTS_TYPE_ST_ADD80;
8909 kern_type = KERN_TYPE_MD55_PWSLT2;
8910 dgst_size = DGST_SIZE_4_4;
8911 parse_func = vb30_parse_hash;
8912 sort_by_digest = sort_by_digest_4_4;
8913 opti_type = OPTI_TYPE_ZERO_BYTE
8914 | OPTI_TYPE_PRECOMPUTE_INIT
8915 | OPTI_TYPE_EARLY_SKIP;
8916 dgst_pos0 = 0;
8917 dgst_pos1 = 3;
8918 dgst_pos2 = 2;
8919 dgst_pos3 = 1;
8920 break;
8921
8922 case 2811: hash_type = HASH_TYPE_MD5;
8923 salt_type = SALT_TYPE_INTERN;
8924 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8925 opts_type = OPTS_TYPE_PT_GENERATE_LE
8926 | OPTS_TYPE_PT_ADD80
8927 | OPTS_TYPE_PT_ADDBITS14;
8928 kern_type = KERN_TYPE_MD55_SLTPW;
8929 dgst_size = DGST_SIZE_4_4;
8930 parse_func = ipb2_parse_hash;
8931 sort_by_digest = sort_by_digest_4_4;
8932 opti_type = OPTI_TYPE_ZERO_BYTE
8933 | OPTI_TYPE_PRECOMPUTE_INIT
8934 | OPTI_TYPE_EARLY_SKIP;
8935 dgst_pos0 = 0;
8936 dgst_pos1 = 3;
8937 dgst_pos2 = 2;
8938 dgst_pos3 = 1;
8939 break;
8940
8941 case 3000: hash_type = HASH_TYPE_LM;
8942 salt_type = SALT_TYPE_NONE;
8943 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8944 opts_type = OPTS_TYPE_PT_GENERATE_LE
8945 | OPTS_TYPE_PT_UPPER
8946 | OPTS_TYPE_PT_BITSLICE;
8947 kern_type = KERN_TYPE_LM;
8948 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8949 parse_func = lm_parse_hash;
8950 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8951 opti_type = OPTI_TYPE_ZERO_BYTE
8952 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8953 dgst_pos0 = 0;
8954 dgst_pos1 = 1;
8955 dgst_pos2 = 2;
8956 dgst_pos3 = 3;
8957 break;
8958
8959 case 3100: hash_type = HASH_TYPE_ORACLEH;
8960 salt_type = SALT_TYPE_INTERN;
8961 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8962 opts_type = OPTS_TYPE_PT_GENERATE_LE
8963 | OPTS_TYPE_PT_UPPER
8964 | OPTS_TYPE_ST_UPPER;
8965 kern_type = KERN_TYPE_ORACLEH;
8966 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8967 parse_func = oracleh_parse_hash;
8968 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8969 opti_type = OPTI_TYPE_ZERO_BYTE;
8970 dgst_pos0 = 0;
8971 dgst_pos1 = 1;
8972 dgst_pos2 = 2;
8973 dgst_pos3 = 3;
8974 break;
8975
8976 case 3200: hash_type = HASH_TYPE_BCRYPT;
8977 salt_type = SALT_TYPE_EMBEDDED;
8978 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8979 opts_type = OPTS_TYPE_PT_GENERATE_LE
8980 | OPTS_TYPE_ST_GENERATE_LE;
8981 kern_type = KERN_TYPE_BCRYPT;
8982 dgst_size = DGST_SIZE_4_6;
8983 parse_func = bcrypt_parse_hash;
8984 sort_by_digest = sort_by_digest_4_6;
8985 opti_type = OPTI_TYPE_ZERO_BYTE;
8986 dgst_pos0 = 0;
8987 dgst_pos1 = 1;
8988 dgst_pos2 = 2;
8989 dgst_pos3 = 3;
8990 break;
8991
8992 case 3710: hash_type = HASH_TYPE_MD5;
8993 salt_type = SALT_TYPE_INTERN;
8994 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8995 opts_type = OPTS_TYPE_PT_GENERATE_LE
8996 | OPTS_TYPE_PT_ADD80
8997 | OPTS_TYPE_PT_ADDBITS14;
8998 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8999 dgst_size = DGST_SIZE_4_4;
9000 parse_func = md5s_parse_hash;
9001 sort_by_digest = sort_by_digest_4_4;
9002 opti_type = OPTI_TYPE_ZERO_BYTE
9003 | OPTI_TYPE_PRECOMPUTE_INIT
9004 | OPTI_TYPE_PRECOMPUTE_MERKLE
9005 | OPTI_TYPE_EARLY_SKIP;
9006 dgst_pos0 = 0;
9007 dgst_pos1 = 3;
9008 dgst_pos2 = 2;
9009 dgst_pos3 = 1;
9010 break;
9011
9012 case 3711: hash_type = HASH_TYPE_MD5;
9013 salt_type = SALT_TYPE_EMBEDDED;
9014 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9015 opts_type = OPTS_TYPE_PT_GENERATE_LE
9016 | OPTS_TYPE_PT_ADD80
9017 | OPTS_TYPE_PT_ADDBITS14;
9018 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9019 dgst_size = DGST_SIZE_4_4;
9020 parse_func = mediawiki_b_parse_hash;
9021 sort_by_digest = sort_by_digest_4_4;
9022 opti_type = OPTI_TYPE_ZERO_BYTE
9023 | OPTI_TYPE_PRECOMPUTE_INIT
9024 | OPTI_TYPE_PRECOMPUTE_MERKLE
9025 | OPTI_TYPE_EARLY_SKIP;
9026 dgst_pos0 = 0;
9027 dgst_pos1 = 3;
9028 dgst_pos2 = 2;
9029 dgst_pos3 = 1;
9030 break;
9031
9032 case 3800: hash_type = HASH_TYPE_MD5;
9033 salt_type = SALT_TYPE_INTERN;
9034 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9035 opts_type = OPTS_TYPE_PT_GENERATE_LE
9036 | OPTS_TYPE_ST_ADDBITS14;
9037 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
9038 dgst_size = DGST_SIZE_4_4;
9039 parse_func = md5s_parse_hash;
9040 sort_by_digest = sort_by_digest_4_4;
9041 opti_type = OPTI_TYPE_ZERO_BYTE
9042 | OPTI_TYPE_PRECOMPUTE_INIT
9043 | OPTI_TYPE_PRECOMPUTE_MERKLE
9044 | OPTI_TYPE_EARLY_SKIP
9045 | OPTI_TYPE_NOT_ITERATED
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 4300: hash_type = HASH_TYPE_MD5;
9054 salt_type = SALT_TYPE_VIRTUAL;
9055 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9056 opts_type = OPTS_TYPE_PT_GENERATE_LE
9057 | OPTS_TYPE_PT_ADD80
9058 | OPTS_TYPE_PT_ADDBITS14
9059 | OPTS_TYPE_ST_ADD80;
9060 kern_type = KERN_TYPE_MD5U5_PWSLT1;
9061 dgst_size = DGST_SIZE_4_4;
9062 parse_func = md5md5_parse_hash;
9063 sort_by_digest = sort_by_digest_4_4;
9064 opti_type = OPTI_TYPE_ZERO_BYTE
9065 | OPTI_TYPE_PRECOMPUTE_INIT
9066 | OPTI_TYPE_PRECOMPUTE_MERKLE
9067 | OPTI_TYPE_EARLY_SKIP;
9068 dgst_pos0 = 0;
9069 dgst_pos1 = 3;
9070 dgst_pos2 = 2;
9071 dgst_pos3 = 1;
9072 break;
9073
9074
9075 case 4400: hash_type = HASH_TYPE_MD5;
9076 salt_type = SALT_TYPE_NONE;
9077 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9078 opts_type = OPTS_TYPE_PT_GENERATE_BE
9079 | OPTS_TYPE_PT_ADD80
9080 | OPTS_TYPE_PT_ADDBITS15;
9081 kern_type = KERN_TYPE_MD5_SHA1;
9082 dgst_size = DGST_SIZE_4_4;
9083 parse_func = md5_parse_hash;
9084 sort_by_digest = sort_by_digest_4_4;
9085 opti_type = OPTI_TYPE_ZERO_BYTE
9086 | OPTI_TYPE_PRECOMPUTE_INIT
9087 | OPTI_TYPE_PRECOMPUTE_MERKLE
9088 | OPTI_TYPE_EARLY_SKIP
9089 | OPTI_TYPE_NOT_ITERATED
9090 | OPTI_TYPE_NOT_SALTED
9091 | OPTI_TYPE_RAW_HASH;
9092 dgst_pos0 = 0;
9093 dgst_pos1 = 3;
9094 dgst_pos2 = 2;
9095 dgst_pos3 = 1;
9096 break;
9097
9098 case 4500: hash_type = HASH_TYPE_SHA1;
9099 salt_type = SALT_TYPE_NONE;
9100 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9101 opts_type = OPTS_TYPE_PT_GENERATE_BE
9102 | OPTS_TYPE_PT_ADD80
9103 | OPTS_TYPE_PT_ADDBITS15;
9104 kern_type = KERN_TYPE_SHA11;
9105 dgst_size = DGST_SIZE_4_5;
9106 parse_func = sha1_parse_hash;
9107 sort_by_digest = sort_by_digest_4_5;
9108 opti_type = OPTI_TYPE_ZERO_BYTE
9109 | OPTI_TYPE_PRECOMPUTE_INIT
9110 | OPTI_TYPE_PRECOMPUTE_MERKLE
9111 | OPTI_TYPE_EARLY_SKIP
9112 | OPTI_TYPE_NOT_SALTED;
9113 dgst_pos0 = 3;
9114 dgst_pos1 = 4;
9115 dgst_pos2 = 2;
9116 dgst_pos3 = 1;
9117 break;
9118
9119 case 4700: hash_type = HASH_TYPE_SHA1;
9120 salt_type = SALT_TYPE_NONE;
9121 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9122 opts_type = OPTS_TYPE_PT_GENERATE_LE
9123 | OPTS_TYPE_PT_ADD80
9124 | OPTS_TYPE_PT_ADDBITS14;
9125 kern_type = KERN_TYPE_SHA1_MD5;
9126 dgst_size = DGST_SIZE_4_5;
9127 parse_func = sha1_parse_hash;
9128 sort_by_digest = sort_by_digest_4_5;
9129 opti_type = OPTI_TYPE_ZERO_BYTE
9130 | OPTI_TYPE_PRECOMPUTE_INIT
9131 | OPTI_TYPE_PRECOMPUTE_MERKLE
9132 | OPTI_TYPE_EARLY_SKIP
9133 | OPTI_TYPE_NOT_ITERATED
9134 | OPTI_TYPE_NOT_SALTED
9135 | OPTI_TYPE_RAW_HASH;
9136 dgst_pos0 = 3;
9137 dgst_pos1 = 4;
9138 dgst_pos2 = 2;
9139 dgst_pos3 = 1;
9140 break;
9141
9142 case 4800: hash_type = HASH_TYPE_MD5;
9143 salt_type = SALT_TYPE_EMBEDDED;
9144 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9145 opts_type = OPTS_TYPE_PT_GENERATE_LE
9146 | OPTS_TYPE_PT_ADDBITS14;
9147 kern_type = KERN_TYPE_MD5_CHAP;
9148 dgst_size = DGST_SIZE_4_4;
9149 parse_func = chap_parse_hash;
9150 sort_by_digest = sort_by_digest_4_4;
9151 opti_type = OPTI_TYPE_ZERO_BYTE
9152 | OPTI_TYPE_PRECOMPUTE_INIT
9153 | OPTI_TYPE_PRECOMPUTE_MERKLE
9154 | OPTI_TYPE_MEET_IN_MIDDLE
9155 | OPTI_TYPE_EARLY_SKIP
9156 | OPTI_TYPE_NOT_ITERATED
9157 | OPTI_TYPE_RAW_HASH;
9158 dgst_pos0 = 0;
9159 dgst_pos1 = 3;
9160 dgst_pos2 = 2;
9161 dgst_pos3 = 1;
9162 break;
9163
9164 case 4900: hash_type = HASH_TYPE_SHA1;
9165 salt_type = SALT_TYPE_INTERN;
9166 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9167 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9168 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9169 dgst_size = DGST_SIZE_4_5;
9170 parse_func = sha1s_parse_hash;
9171 sort_by_digest = sort_by_digest_4_5;
9172 opti_type = OPTI_TYPE_ZERO_BYTE
9173 | OPTI_TYPE_PRECOMPUTE_INIT
9174 | OPTI_TYPE_PRECOMPUTE_MERKLE
9175 | OPTI_TYPE_EARLY_SKIP;
9176 dgst_pos0 = 3;
9177 dgst_pos1 = 4;
9178 dgst_pos2 = 2;
9179 dgst_pos3 = 1;
9180 break;
9181
9182 case 5000: hash_type = HASH_TYPE_KECCAK;
9183 salt_type = SALT_TYPE_EMBEDDED;
9184 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9185 opts_type = OPTS_TYPE_PT_GENERATE_LE
9186 | OPTS_TYPE_PT_ADD01;
9187 kern_type = KERN_TYPE_KECCAK;
9188 dgst_size = DGST_SIZE_8_25;
9189 parse_func = keccak_parse_hash;
9190 sort_by_digest = sort_by_digest_8_25;
9191 opti_type = OPTI_TYPE_ZERO_BYTE
9192 | OPTI_TYPE_USES_BITS_64
9193 | OPTI_TYPE_RAW_HASH;
9194 dgst_pos0 = 2;
9195 dgst_pos1 = 3;
9196 dgst_pos2 = 4;
9197 dgst_pos3 = 5;
9198 break;
9199
9200 case 5100: hash_type = HASH_TYPE_MD5H;
9201 salt_type = SALT_TYPE_NONE;
9202 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9203 opts_type = OPTS_TYPE_PT_GENERATE_LE
9204 | OPTS_TYPE_PT_ADD80
9205 | OPTS_TYPE_PT_ADDBITS14;
9206 kern_type = KERN_TYPE_MD5H;
9207 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9208 parse_func = md5half_parse_hash;
9209 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9210 opti_type = OPTI_TYPE_ZERO_BYTE
9211 | OPTI_TYPE_RAW_HASH;
9212 dgst_pos0 = 0;
9213 dgst_pos1 = 1;
9214 dgst_pos2 = 2;
9215 dgst_pos3 = 3;
9216 break;
9217
9218 case 5200: hash_type = HASH_TYPE_SHA256;
9219 salt_type = SALT_TYPE_EMBEDDED;
9220 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9221 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9222 kern_type = KERN_TYPE_PSAFE3;
9223 dgst_size = DGST_SIZE_4_8;
9224 parse_func = psafe3_parse_hash;
9225 sort_by_digest = sort_by_digest_4_8;
9226 opti_type = OPTI_TYPE_ZERO_BYTE;
9227 dgst_pos0 = 0;
9228 dgst_pos1 = 1;
9229 dgst_pos2 = 2;
9230 dgst_pos3 = 3;
9231 break;
9232
9233 case 5300: hash_type = HASH_TYPE_MD5;
9234 salt_type = SALT_TYPE_EMBEDDED;
9235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9236 opts_type = OPTS_TYPE_PT_GENERATE_LE
9237 | OPTS_TYPE_ST_ADD80;
9238 kern_type = KERN_TYPE_IKEPSK_MD5;
9239 dgst_size = DGST_SIZE_4_4;
9240 parse_func = ikepsk_md5_parse_hash;
9241 sort_by_digest = sort_by_digest_4_4;
9242 opti_type = OPTI_TYPE_ZERO_BYTE;
9243 dgst_pos0 = 0;
9244 dgst_pos1 = 3;
9245 dgst_pos2 = 2;
9246 dgst_pos3 = 1;
9247 break;
9248
9249 case 5400: hash_type = HASH_TYPE_SHA1;
9250 salt_type = SALT_TYPE_EMBEDDED;
9251 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9252 opts_type = OPTS_TYPE_PT_GENERATE_BE
9253 | OPTS_TYPE_ST_ADD80;
9254 kern_type = KERN_TYPE_IKEPSK_SHA1;
9255 dgst_size = DGST_SIZE_4_5;
9256 parse_func = ikepsk_sha1_parse_hash;
9257 sort_by_digest = sort_by_digest_4_5;
9258 opti_type = OPTI_TYPE_ZERO_BYTE;
9259 dgst_pos0 = 3;
9260 dgst_pos1 = 4;
9261 dgst_pos2 = 2;
9262 dgst_pos3 = 1;
9263 break;
9264
9265 case 5500: hash_type = HASH_TYPE_NETNTLM;
9266 salt_type = SALT_TYPE_EMBEDDED;
9267 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9268 opts_type = OPTS_TYPE_PT_GENERATE_LE
9269 | OPTS_TYPE_PT_ADD80
9270 | OPTS_TYPE_PT_ADDBITS14
9271 | OPTS_TYPE_PT_UNICODE
9272 | OPTS_TYPE_ST_HEX;
9273 kern_type = KERN_TYPE_NETNTLMv1;
9274 dgst_size = DGST_SIZE_4_4;
9275 parse_func = netntlmv1_parse_hash;
9276 sort_by_digest = sort_by_digest_4_4;
9277 opti_type = OPTI_TYPE_ZERO_BYTE
9278 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9279 dgst_pos0 = 0;
9280 dgst_pos1 = 1;
9281 dgst_pos2 = 2;
9282 dgst_pos3 = 3;
9283 break;
9284
9285 case 5600: hash_type = HASH_TYPE_MD5;
9286 salt_type = SALT_TYPE_EMBEDDED;
9287 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9288 opts_type = OPTS_TYPE_PT_GENERATE_LE
9289 | OPTS_TYPE_PT_ADD80
9290 | OPTS_TYPE_PT_ADDBITS14
9291 | OPTS_TYPE_PT_UNICODE;
9292 kern_type = KERN_TYPE_NETNTLMv2;
9293 dgst_size = DGST_SIZE_4_4;
9294 parse_func = netntlmv2_parse_hash;
9295 sort_by_digest = sort_by_digest_4_4;
9296 opti_type = OPTI_TYPE_ZERO_BYTE;
9297 dgst_pos0 = 0;
9298 dgst_pos1 = 3;
9299 dgst_pos2 = 2;
9300 dgst_pos3 = 1;
9301 break;
9302
9303 case 5700: hash_type = HASH_TYPE_SHA256;
9304 salt_type = SALT_TYPE_NONE;
9305 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9306 opts_type = OPTS_TYPE_PT_GENERATE_BE
9307 | OPTS_TYPE_PT_ADD80
9308 | OPTS_TYPE_PT_ADDBITS15;
9309 kern_type = KERN_TYPE_SHA256;
9310 dgst_size = DGST_SIZE_4_8;
9311 parse_func = cisco4_parse_hash;
9312 sort_by_digest = sort_by_digest_4_8;
9313 opti_type = OPTI_TYPE_ZERO_BYTE
9314 | OPTI_TYPE_PRECOMPUTE_INIT
9315 | OPTI_TYPE_PRECOMPUTE_MERKLE
9316 | OPTI_TYPE_EARLY_SKIP
9317 | OPTI_TYPE_NOT_ITERATED
9318 | OPTI_TYPE_NOT_SALTED
9319 | OPTI_TYPE_RAW_HASH;
9320 dgst_pos0 = 3;
9321 dgst_pos1 = 7;
9322 dgst_pos2 = 2;
9323 dgst_pos3 = 6;
9324 break;
9325
9326 case 5800: hash_type = HASH_TYPE_SHA1;
9327 salt_type = SALT_TYPE_INTERN;
9328 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9329 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9330 | OPTS_TYPE_ST_ADD80;
9331 kern_type = KERN_TYPE_ANDROIDPIN;
9332 dgst_size = DGST_SIZE_4_5;
9333 parse_func = androidpin_parse_hash;
9334 sort_by_digest = sort_by_digest_4_5;
9335 opti_type = OPTI_TYPE_ZERO_BYTE;
9336 dgst_pos0 = 0;
9337 dgst_pos1 = 1;
9338 dgst_pos2 = 2;
9339 dgst_pos3 = 3;
9340 break;
9341
9342 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9343 salt_type = SALT_TYPE_NONE;
9344 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9345 opts_type = OPTS_TYPE_PT_GENERATE_LE
9346 | OPTS_TYPE_PT_ADD80;
9347 kern_type = KERN_TYPE_RIPEMD160;
9348 dgst_size = DGST_SIZE_4_5;
9349 parse_func = ripemd160_parse_hash;
9350 sort_by_digest = sort_by_digest_4_5;
9351 opti_type = OPTI_TYPE_ZERO_BYTE;
9352 dgst_pos0 = 0;
9353 dgst_pos1 = 1;
9354 dgst_pos2 = 2;
9355 dgst_pos3 = 3;
9356 break;
9357
9358 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9359 salt_type = SALT_TYPE_NONE;
9360 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9361 opts_type = OPTS_TYPE_PT_GENERATE_BE
9362 | OPTS_TYPE_PT_ADD80;
9363 kern_type = KERN_TYPE_WHIRLPOOL;
9364 dgst_size = DGST_SIZE_4_16;
9365 parse_func = whirlpool_parse_hash;
9366 sort_by_digest = sort_by_digest_4_16;
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 6211: hash_type = HASH_TYPE_RIPEMD160;
9375 salt_type = SALT_TYPE_EMBEDDED;
9376 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9377 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9378 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9379 dgst_size = DGST_SIZE_4_5;
9380 parse_func = truecrypt_parse_hash_2k;
9381 sort_by_digest = sort_by_digest_4_5;
9382 opti_type = OPTI_TYPE_ZERO_BYTE;
9383 dgst_pos0 = 0;
9384 dgst_pos1 = 1;
9385 dgst_pos2 = 2;
9386 dgst_pos3 = 3;
9387 break;
9388
9389 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9390 salt_type = SALT_TYPE_EMBEDDED;
9391 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9392 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9393 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9394 dgst_size = DGST_SIZE_4_5;
9395 parse_func = truecrypt_parse_hash_2k;
9396 sort_by_digest = sort_by_digest_4_5;
9397 opti_type = OPTI_TYPE_ZERO_BYTE;
9398 dgst_pos0 = 0;
9399 dgst_pos1 = 1;
9400 dgst_pos2 = 2;
9401 dgst_pos3 = 3;
9402 break;
9403
9404 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9405 salt_type = SALT_TYPE_EMBEDDED;
9406 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9407 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9408 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9409 dgst_size = DGST_SIZE_4_5;
9410 parse_func = truecrypt_parse_hash_2k;
9411 sort_by_digest = sort_by_digest_4_5;
9412 opti_type = OPTI_TYPE_ZERO_BYTE;
9413 dgst_pos0 = 0;
9414 dgst_pos1 = 1;
9415 dgst_pos2 = 2;
9416 dgst_pos3 = 3;
9417 break;
9418
9419 case 6221: hash_type = HASH_TYPE_SHA512;
9420 salt_type = SALT_TYPE_EMBEDDED;
9421 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9422 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9423 kern_type = KERN_TYPE_TCSHA512_XTS512;
9424 dgst_size = DGST_SIZE_8_8;
9425 parse_func = truecrypt_parse_hash_1k;
9426 sort_by_digest = sort_by_digest_8_8;
9427 opti_type = OPTI_TYPE_ZERO_BYTE
9428 | OPTI_TYPE_USES_BITS_64;
9429 dgst_pos0 = 0;
9430 dgst_pos1 = 1;
9431 dgst_pos2 = 2;
9432 dgst_pos3 = 3;
9433 break;
9434
9435 case 6222: hash_type = HASH_TYPE_SHA512;
9436 salt_type = SALT_TYPE_EMBEDDED;
9437 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9438 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9439 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9440 dgst_size = DGST_SIZE_8_8;
9441 parse_func = truecrypt_parse_hash_1k;
9442 sort_by_digest = sort_by_digest_8_8;
9443 opti_type = OPTI_TYPE_ZERO_BYTE
9444 | OPTI_TYPE_USES_BITS_64;
9445 dgst_pos0 = 0;
9446 dgst_pos1 = 1;
9447 dgst_pos2 = 2;
9448 dgst_pos3 = 3;
9449 break;
9450
9451 case 6223: hash_type = HASH_TYPE_SHA512;
9452 salt_type = SALT_TYPE_EMBEDDED;
9453 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9454 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9455 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9456 dgst_size = DGST_SIZE_8_8;
9457 parse_func = truecrypt_parse_hash_1k;
9458 sort_by_digest = sort_by_digest_8_8;
9459 opti_type = OPTI_TYPE_ZERO_BYTE
9460 | OPTI_TYPE_USES_BITS_64;
9461 dgst_pos0 = 0;
9462 dgst_pos1 = 1;
9463 dgst_pos2 = 2;
9464 dgst_pos3 = 3;
9465 break;
9466
9467 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
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_TCWHIRLPOOL_XTS512;
9472 dgst_size = DGST_SIZE_4_8;
9473 parse_func = truecrypt_parse_hash_1k;
9474 sort_by_digest = sort_by_digest_4_8;
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 6232: hash_type = HASH_TYPE_WHIRLPOOL;
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_TCWHIRLPOOL_XTS1024;
9487 dgst_size = DGST_SIZE_4_8;
9488 parse_func = truecrypt_parse_hash_1k;
9489 sort_by_digest = sort_by_digest_4_8;
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 6233: hash_type = HASH_TYPE_WHIRLPOOL;
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_TCWHIRLPOOL_XTS1536;
9502 dgst_size = DGST_SIZE_4_8;
9503 parse_func = truecrypt_parse_hash_1k;
9504 sort_by_digest = sort_by_digest_4_8;
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 6241: hash_type = HASH_TYPE_RIPEMD160;
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_TCRIPEMD160_XTS512;
9517 dgst_size = DGST_SIZE_4_5;
9518 parse_func = truecrypt_parse_hash_1k;
9519 sort_by_digest = sort_by_digest_4_5;
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 6242: hash_type = HASH_TYPE_RIPEMD160;
9528 salt_type = SALT_TYPE_EMBEDDED;
9529 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9530 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9531 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9532 dgst_size = DGST_SIZE_4_5;
9533 parse_func = truecrypt_parse_hash_1k;
9534 sort_by_digest = sort_by_digest_4_5;
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 6243: hash_type = HASH_TYPE_RIPEMD160;
9543 salt_type = SALT_TYPE_EMBEDDED;
9544 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9545 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9546 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9547 dgst_size = DGST_SIZE_4_5;
9548 parse_func = truecrypt_parse_hash_1k;
9549 sort_by_digest = sort_by_digest_4_5;
9550 opti_type = OPTI_TYPE_ZERO_BYTE;
9551 dgst_pos0 = 0;
9552 dgst_pos1 = 1;
9553 dgst_pos2 = 2;
9554 dgst_pos3 = 3;
9555 break;
9556
9557 case 6300: hash_type = HASH_TYPE_MD5;
9558 salt_type = SALT_TYPE_EMBEDDED;
9559 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9560 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9561 kern_type = KERN_TYPE_MD5AIX;
9562 dgst_size = DGST_SIZE_4_4;
9563 parse_func = md5aix_parse_hash;
9564 sort_by_digest = sort_by_digest_4_4;
9565 opti_type = OPTI_TYPE_ZERO_BYTE;
9566 dgst_pos0 = 0;
9567 dgst_pos1 = 1;
9568 dgst_pos2 = 2;
9569 dgst_pos3 = 3;
9570 break;
9571
9572 case 6400: hash_type = HASH_TYPE_SHA256;
9573 salt_type = SALT_TYPE_EMBEDDED;
9574 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9575 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9576 kern_type = KERN_TYPE_SHA256AIX;
9577 dgst_size = DGST_SIZE_4_8;
9578 parse_func = sha256aix_parse_hash;
9579 sort_by_digest = sort_by_digest_4_8;
9580 opti_type = OPTI_TYPE_ZERO_BYTE;
9581 dgst_pos0 = 0;
9582 dgst_pos1 = 1;
9583 dgst_pos2 = 2;
9584 dgst_pos3 = 3;
9585 break;
9586
9587 case 6500: hash_type = HASH_TYPE_SHA512;
9588 salt_type = SALT_TYPE_EMBEDDED;
9589 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9590 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9591 kern_type = KERN_TYPE_SHA512AIX;
9592 dgst_size = DGST_SIZE_8_8;
9593 parse_func = sha512aix_parse_hash;
9594 sort_by_digest = sort_by_digest_8_8;
9595 opti_type = OPTI_TYPE_ZERO_BYTE
9596 | OPTI_TYPE_USES_BITS_64;
9597 dgst_pos0 = 0;
9598 dgst_pos1 = 1;
9599 dgst_pos2 = 2;
9600 dgst_pos3 = 3;
9601 break;
9602
9603 case 6600: hash_type = HASH_TYPE_AES;
9604 salt_type = SALT_TYPE_EMBEDDED;
9605 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9606 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9607 kern_type = KERN_TYPE_AGILEKEY;
9608 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9609 parse_func = agilekey_parse_hash;
9610 sort_by_digest = sort_by_digest_4_5;
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 6700: hash_type = HASH_TYPE_SHA1;
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_SHA1AIX;
9623 dgst_size = DGST_SIZE_4_5;
9624 parse_func = sha1aix_parse_hash;
9625 sort_by_digest = sort_by_digest_4_5;
9626 opti_type = OPTI_TYPE_ZERO_BYTE;
9627 dgst_pos0 = 0;
9628 dgst_pos1 = 1;
9629 dgst_pos2 = 2;
9630 dgst_pos3 = 3;
9631 break;
9632
9633 case 6800: hash_type = HASH_TYPE_AES;
9634 salt_type = SALT_TYPE_EMBEDDED;
9635 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9636 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9637 kern_type = KERN_TYPE_LASTPASS;
9638 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9639 parse_func = lastpass_parse_hash;
9640 sort_by_digest = sort_by_digest_4_8;
9641 opti_type = OPTI_TYPE_ZERO_BYTE;
9642 dgst_pos0 = 0;
9643 dgst_pos1 = 1;
9644 dgst_pos2 = 2;
9645 dgst_pos3 = 3;
9646 break;
9647
9648 case 6900: hash_type = HASH_TYPE_GOST;
9649 salt_type = SALT_TYPE_NONE;
9650 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9651 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9652 kern_type = KERN_TYPE_GOST;
9653 dgst_size = DGST_SIZE_4_8;
9654 parse_func = gost_parse_hash;
9655 sort_by_digest = sort_by_digest_4_8;
9656 opti_type = OPTI_TYPE_ZERO_BYTE;
9657 dgst_pos0 = 0;
9658 dgst_pos1 = 1;
9659 dgst_pos2 = 2;
9660 dgst_pos3 = 3;
9661 break;
9662
9663 case 7100: hash_type = HASH_TYPE_SHA512;
9664 salt_type = SALT_TYPE_EMBEDDED;
9665 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9666 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9667 kern_type = KERN_TYPE_PBKDF2_SHA512;
9668 dgst_size = DGST_SIZE_8_16;
9669 parse_func = sha512osx_parse_hash;
9670 sort_by_digest = sort_by_digest_8_16;
9671 opti_type = OPTI_TYPE_ZERO_BYTE
9672 | OPTI_TYPE_USES_BITS_64
9673 | OPTI_TYPE_SLOW_HASH_SIMD;
9674 dgst_pos0 = 0;
9675 dgst_pos1 = 1;
9676 dgst_pos2 = 2;
9677 dgst_pos3 = 3;
9678 break;
9679
9680 case 7200: hash_type = HASH_TYPE_SHA512;
9681 salt_type = SALT_TYPE_EMBEDDED;
9682 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9683 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9684 kern_type = KERN_TYPE_PBKDF2_SHA512;
9685 dgst_size = DGST_SIZE_8_16;
9686 parse_func = sha512grub_parse_hash;
9687 sort_by_digest = sort_by_digest_8_16;
9688 opti_type = OPTI_TYPE_ZERO_BYTE
9689 | OPTI_TYPE_USES_BITS_64
9690 | OPTI_TYPE_SLOW_HASH_SIMD;
9691 dgst_pos0 = 0;
9692 dgst_pos1 = 1;
9693 dgst_pos2 = 2;
9694 dgst_pos3 = 3;
9695 break;
9696
9697 case 7300: hash_type = HASH_TYPE_SHA1;
9698 salt_type = SALT_TYPE_EMBEDDED;
9699 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9700 opts_type = OPTS_TYPE_PT_GENERATE_BE
9701 | OPTS_TYPE_ST_ADD80
9702 | OPTS_TYPE_ST_ADDBITS15;
9703 kern_type = KERN_TYPE_RAKP;
9704 dgst_size = DGST_SIZE_4_5;
9705 parse_func = rakp_parse_hash;
9706 sort_by_digest = sort_by_digest_4_5;
9707 opti_type = OPTI_TYPE_ZERO_BYTE
9708 | OPTI_TYPE_NOT_ITERATED;
9709 dgst_pos0 = 3;
9710 dgst_pos1 = 4;
9711 dgst_pos2 = 2;
9712 dgst_pos3 = 1;
9713 break;
9714
9715 case 7400: hash_type = HASH_TYPE_SHA256;
9716 salt_type = SALT_TYPE_EMBEDDED;
9717 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9718 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9719 kern_type = KERN_TYPE_SHA256CRYPT;
9720 dgst_size = DGST_SIZE_4_8;
9721 parse_func = sha256crypt_parse_hash;
9722 sort_by_digest = sort_by_digest_4_8;
9723 opti_type = OPTI_TYPE_ZERO_BYTE;
9724 dgst_pos0 = 0;
9725 dgst_pos1 = 1;
9726 dgst_pos2 = 2;
9727 dgst_pos3 = 3;
9728 break;
9729
9730 case 7500: hash_type = HASH_TYPE_KRB5PA;
9731 salt_type = SALT_TYPE_EMBEDDED;
9732 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9733 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9734 kern_type = KERN_TYPE_KRB5PA;
9735 dgst_size = DGST_SIZE_4_4;
9736 parse_func = krb5pa_parse_hash;
9737 sort_by_digest = sort_by_digest_4_4;
9738 opti_type = OPTI_TYPE_ZERO_BYTE
9739 | OPTI_TYPE_NOT_ITERATED;
9740 dgst_pos0 = 0;
9741 dgst_pos1 = 1;
9742 dgst_pos2 = 2;
9743 dgst_pos3 = 3;
9744 break;
9745
9746 case 7600: hash_type = HASH_TYPE_SHA1;
9747 salt_type = SALT_TYPE_INTERN;
9748 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9749 opts_type = OPTS_TYPE_PT_GENERATE_BE
9750 | OPTS_TYPE_PT_ADD80
9751 | OPTS_TYPE_PT_ADDBITS15;
9752 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9753 dgst_size = DGST_SIZE_4_5;
9754 parse_func = redmine_parse_hash;
9755 sort_by_digest = sort_by_digest_4_5;
9756 opti_type = OPTI_TYPE_ZERO_BYTE
9757 | OPTI_TYPE_PRECOMPUTE_INIT
9758 | OPTI_TYPE_EARLY_SKIP
9759 | OPTI_TYPE_NOT_ITERATED
9760 | OPTI_TYPE_PREPENDED_SALT;
9761 dgst_pos0 = 3;
9762 dgst_pos1 = 4;
9763 dgst_pos2 = 2;
9764 dgst_pos3 = 1;
9765 break;
9766
9767 case 7700: hash_type = HASH_TYPE_SAPB;
9768 salt_type = SALT_TYPE_EMBEDDED;
9769 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9770 opts_type = OPTS_TYPE_PT_GENERATE_LE
9771 | OPTS_TYPE_PT_UPPER
9772 | OPTS_TYPE_ST_UPPER;
9773 kern_type = KERN_TYPE_SAPB;
9774 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9775 parse_func = sapb_parse_hash;
9776 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9777 opti_type = OPTI_TYPE_ZERO_BYTE
9778 | OPTI_TYPE_PRECOMPUTE_INIT
9779 | OPTI_TYPE_NOT_ITERATED;
9780 dgst_pos0 = 0;
9781 dgst_pos1 = 1;
9782 dgst_pos2 = 2;
9783 dgst_pos3 = 3;
9784 break;
9785
9786 case 7800: hash_type = HASH_TYPE_SAPG;
9787 salt_type = SALT_TYPE_EMBEDDED;
9788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9789 opts_type = OPTS_TYPE_PT_GENERATE_BE
9790 | OPTS_TYPE_ST_ADD80
9791 | OPTS_TYPE_ST_UPPER;
9792 kern_type = KERN_TYPE_SAPG;
9793 dgst_size = DGST_SIZE_4_5;
9794 parse_func = sapg_parse_hash;
9795 sort_by_digest = sort_by_digest_4_5;
9796 opti_type = OPTI_TYPE_ZERO_BYTE
9797 | OPTI_TYPE_PRECOMPUTE_INIT
9798 | OPTI_TYPE_NOT_ITERATED;
9799 dgst_pos0 = 3;
9800 dgst_pos1 = 4;
9801 dgst_pos2 = 2;
9802 dgst_pos3 = 1;
9803 break;
9804
9805 case 7900: hash_type = HASH_TYPE_SHA512;
9806 salt_type = SALT_TYPE_EMBEDDED;
9807 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9808 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9809 kern_type = KERN_TYPE_DRUPAL7;
9810 dgst_size = DGST_SIZE_8_8;
9811 parse_func = drupal7_parse_hash;
9812 sort_by_digest = sort_by_digest_8_8;
9813 opti_type = OPTI_TYPE_ZERO_BYTE
9814 | OPTI_TYPE_USES_BITS_64;
9815 dgst_pos0 = 0;
9816 dgst_pos1 = 1;
9817 dgst_pos2 = 2;
9818 dgst_pos3 = 3;
9819 break;
9820
9821 case 8000: hash_type = HASH_TYPE_SHA256;
9822 salt_type = SALT_TYPE_EMBEDDED;
9823 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9824 opts_type = OPTS_TYPE_PT_GENERATE_BE
9825 | OPTS_TYPE_PT_UNICODE
9826 | OPTS_TYPE_ST_ADD80
9827 | OPTS_TYPE_ST_HEX;
9828 kern_type = KERN_TYPE_SYBASEASE;
9829 dgst_size = DGST_SIZE_4_8;
9830 parse_func = sybasease_parse_hash;
9831 sort_by_digest = sort_by_digest_4_8;
9832 opti_type = OPTI_TYPE_ZERO_BYTE
9833 | OPTI_TYPE_PRECOMPUTE_INIT
9834 | OPTI_TYPE_EARLY_SKIP
9835 | OPTI_TYPE_NOT_ITERATED
9836 | OPTI_TYPE_RAW_HASH;
9837 dgst_pos0 = 3;
9838 dgst_pos1 = 7;
9839 dgst_pos2 = 2;
9840 dgst_pos3 = 6;
9841 break;
9842
9843 case 8100: hash_type = HASH_TYPE_SHA1;
9844 salt_type = SALT_TYPE_EMBEDDED;
9845 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9846 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9847 kern_type = KERN_TYPE_NETSCALER;
9848 dgst_size = DGST_SIZE_4_5;
9849 parse_func = netscaler_parse_hash;
9850 sort_by_digest = sort_by_digest_4_5;
9851 opti_type = OPTI_TYPE_ZERO_BYTE
9852 | OPTI_TYPE_PRECOMPUTE_INIT
9853 | OPTI_TYPE_PRECOMPUTE_MERKLE
9854 | OPTI_TYPE_EARLY_SKIP
9855 | OPTI_TYPE_NOT_ITERATED
9856 | OPTI_TYPE_PREPENDED_SALT
9857 | OPTI_TYPE_RAW_HASH;
9858 dgst_pos0 = 3;
9859 dgst_pos1 = 4;
9860 dgst_pos2 = 2;
9861 dgst_pos3 = 1;
9862 break;
9863
9864 case 8200: hash_type = HASH_TYPE_SHA256;
9865 salt_type = SALT_TYPE_EMBEDDED;
9866 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9867 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9868 kern_type = KERN_TYPE_CLOUDKEY;
9869 dgst_size = DGST_SIZE_4_8;
9870 parse_func = cloudkey_parse_hash;
9871 sort_by_digest = sort_by_digest_4_8;
9872 opti_type = OPTI_TYPE_ZERO_BYTE;
9873 dgst_pos0 = 0;
9874 dgst_pos1 = 1;
9875 dgst_pos2 = 2;
9876 dgst_pos3 = 3;
9877 break;
9878
9879 case 8300: hash_type = HASH_TYPE_SHA1;
9880 salt_type = SALT_TYPE_EMBEDDED;
9881 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9882 opts_type = OPTS_TYPE_PT_GENERATE_BE
9883 | OPTS_TYPE_ST_HEX
9884 | OPTS_TYPE_ST_ADD80;
9885 kern_type = KERN_TYPE_NSEC3;
9886 dgst_size = DGST_SIZE_4_5;
9887 parse_func = nsec3_parse_hash;
9888 sort_by_digest = sort_by_digest_4_5;
9889 opti_type = OPTI_TYPE_ZERO_BYTE;
9890 dgst_pos0 = 3;
9891 dgst_pos1 = 4;
9892 dgst_pos2 = 2;
9893 dgst_pos3 = 1;
9894 break;
9895
9896 case 8400: hash_type = HASH_TYPE_SHA1;
9897 salt_type = SALT_TYPE_INTERN;
9898 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9899 opts_type = OPTS_TYPE_PT_GENERATE_BE
9900 | OPTS_TYPE_PT_ADD80
9901 | OPTS_TYPE_PT_ADDBITS15;
9902 kern_type = KERN_TYPE_WBB3;
9903 dgst_size = DGST_SIZE_4_5;
9904 parse_func = wbb3_parse_hash;
9905 sort_by_digest = sort_by_digest_4_5;
9906 opti_type = OPTI_TYPE_ZERO_BYTE
9907 | OPTI_TYPE_PRECOMPUTE_INIT
9908 | OPTI_TYPE_NOT_ITERATED;
9909 dgst_pos0 = 3;
9910 dgst_pos1 = 4;
9911 dgst_pos2 = 2;
9912 dgst_pos3 = 1;
9913 break;
9914
9915 case 8500: hash_type = HASH_TYPE_DESRACF;
9916 salt_type = SALT_TYPE_EMBEDDED;
9917 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9918 opts_type = OPTS_TYPE_PT_GENERATE_LE
9919 | OPTS_TYPE_ST_UPPER;
9920 kern_type = KERN_TYPE_RACF;
9921 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9922 parse_func = racf_parse_hash;
9923 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9924 opti_type = OPTI_TYPE_ZERO_BYTE
9925 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9926 dgst_pos0 = 0;
9927 dgst_pos1 = 1;
9928 dgst_pos2 = 2;
9929 dgst_pos3 = 3;
9930 break;
9931
9932 case 8600: hash_type = HASH_TYPE_LOTUS5;
9933 salt_type = SALT_TYPE_NONE;
9934 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9935 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9936 kern_type = KERN_TYPE_LOTUS5;
9937 dgst_size = DGST_SIZE_4_4;
9938 parse_func = lotus5_parse_hash;
9939 sort_by_digest = sort_by_digest_4_4;
9940 opti_type = OPTI_TYPE_EARLY_SKIP
9941 | OPTI_TYPE_NOT_ITERATED
9942 | OPTI_TYPE_NOT_SALTED
9943 | OPTI_TYPE_RAW_HASH;
9944 dgst_pos0 = 0;
9945 dgst_pos1 = 1;
9946 dgst_pos2 = 2;
9947 dgst_pos3 = 3;
9948 break;
9949
9950 case 8700: hash_type = HASH_TYPE_LOTUS6;
9951 salt_type = SALT_TYPE_EMBEDDED;
9952 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9953 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9954 kern_type = KERN_TYPE_LOTUS6;
9955 dgst_size = DGST_SIZE_4_4;
9956 parse_func = lotus6_parse_hash;
9957 sort_by_digest = sort_by_digest_4_4;
9958 opti_type = OPTI_TYPE_EARLY_SKIP
9959 | OPTI_TYPE_NOT_ITERATED
9960 | OPTI_TYPE_RAW_HASH;
9961 dgst_pos0 = 0;
9962 dgst_pos1 = 1;
9963 dgst_pos2 = 2;
9964 dgst_pos3 = 3;
9965 break;
9966
9967 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9968 salt_type = SALT_TYPE_EMBEDDED;
9969 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9970 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9971 kern_type = KERN_TYPE_ANDROIDFDE;
9972 dgst_size = DGST_SIZE_4_4;
9973 parse_func = androidfde_parse_hash;
9974 sort_by_digest = sort_by_digest_4_4;
9975 opti_type = OPTI_TYPE_ZERO_BYTE;
9976 dgst_pos0 = 0;
9977 dgst_pos1 = 1;
9978 dgst_pos2 = 2;
9979 dgst_pos3 = 3;
9980 break;
9981
9982 case 8900: hash_type = HASH_TYPE_SCRYPT;
9983 salt_type = SALT_TYPE_EMBEDDED;
9984 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9985 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9986 kern_type = KERN_TYPE_SCRYPT;
9987 dgst_size = DGST_SIZE_4_8;
9988 parse_func = scrypt_parse_hash;
9989 sort_by_digest = sort_by_digest_4_8;
9990 opti_type = OPTI_TYPE_ZERO_BYTE;
9991 dgst_pos0 = 0;
9992 dgst_pos1 = 1;
9993 dgst_pos2 = 2;
9994 dgst_pos3 = 3;
9995 break;
9996
9997 case 9000: hash_type = HASH_TYPE_SHA1;
9998 salt_type = SALT_TYPE_EMBEDDED;
9999 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10000 opts_type = OPTS_TYPE_PT_GENERATE_LE
10001 | OPTS_TYPE_ST_GENERATE_LE;
10002 kern_type = KERN_TYPE_PSAFE2;
10003 dgst_size = DGST_SIZE_4_5;
10004 parse_func = psafe2_parse_hash;
10005 sort_by_digest = sort_by_digest_4_5;
10006 opti_type = OPTI_TYPE_ZERO_BYTE;
10007 dgst_pos0 = 0;
10008 dgst_pos1 = 1;
10009 dgst_pos2 = 2;
10010 dgst_pos3 = 3;
10011 break;
10012
10013 case 9100: hash_type = HASH_TYPE_LOTUS8;
10014 salt_type = SALT_TYPE_EMBEDDED;
10015 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10016 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10017 kern_type = KERN_TYPE_LOTUS8;
10018 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10019 parse_func = lotus8_parse_hash;
10020 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10021 opti_type = OPTI_TYPE_ZERO_BYTE;
10022 dgst_pos0 = 0;
10023 dgst_pos1 = 1;
10024 dgst_pos2 = 2;
10025 dgst_pos3 = 3;
10026 break;
10027
10028 case 9200: hash_type = HASH_TYPE_SHA256;
10029 salt_type = SALT_TYPE_EMBEDDED;
10030 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10031 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10032 kern_type = KERN_TYPE_PBKDF2_SHA256;
10033 dgst_size = DGST_SIZE_4_32;
10034 parse_func = cisco8_parse_hash;
10035 sort_by_digest = sort_by_digest_4_32;
10036 opti_type = OPTI_TYPE_ZERO_BYTE
10037 | OPTI_TYPE_SLOW_HASH_SIMD;
10038 dgst_pos0 = 0;
10039 dgst_pos1 = 1;
10040 dgst_pos2 = 2;
10041 dgst_pos3 = 3;
10042 break;
10043
10044 case 9300: hash_type = HASH_TYPE_SCRYPT;
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_SCRYPT;
10049 dgst_size = DGST_SIZE_4_8;
10050 parse_func = cisco9_parse_hash;
10051 sort_by_digest = sort_by_digest_4_8;
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 9400: hash_type = HASH_TYPE_OFFICE2007;
10060 salt_type = SALT_TYPE_EMBEDDED;
10061 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10062 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10063 kern_type = KERN_TYPE_OFFICE2007;
10064 dgst_size = DGST_SIZE_4_4;
10065 parse_func = office2007_parse_hash;
10066 sort_by_digest = sort_by_digest_4_4;
10067 opti_type = OPTI_TYPE_ZERO_BYTE;
10068 dgst_pos0 = 0;
10069 dgst_pos1 = 1;
10070 dgst_pos2 = 2;
10071 dgst_pos3 = 3;
10072 break;
10073
10074 case 9500: hash_type = HASH_TYPE_OFFICE2010;
10075 salt_type = SALT_TYPE_EMBEDDED;
10076 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10077 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10078 kern_type = KERN_TYPE_OFFICE2010;
10079 dgst_size = DGST_SIZE_4_4;
10080 parse_func = office2010_parse_hash;
10081 sort_by_digest = sort_by_digest_4_4;
10082 opti_type = OPTI_TYPE_ZERO_BYTE;
10083 dgst_pos0 = 0;
10084 dgst_pos1 = 1;
10085 dgst_pos2 = 2;
10086 dgst_pos3 = 3;
10087 break;
10088
10089 case 9600: hash_type = HASH_TYPE_OFFICE2013;
10090 salt_type = SALT_TYPE_EMBEDDED;
10091 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10092 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10093 kern_type = KERN_TYPE_OFFICE2013;
10094 dgst_size = DGST_SIZE_4_4;
10095 parse_func = office2013_parse_hash;
10096 sort_by_digest = sort_by_digest_4_4;
10097 opti_type = OPTI_TYPE_ZERO_BYTE;
10098 dgst_pos0 = 0;
10099 dgst_pos1 = 1;
10100 dgst_pos2 = 2;
10101 dgst_pos3 = 3;
10102 break;
10103
10104 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
10105 salt_type = SALT_TYPE_EMBEDDED;
10106 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10107 opts_type = OPTS_TYPE_PT_GENERATE_LE
10108 | OPTS_TYPE_PT_ADD80
10109 | OPTS_TYPE_PT_UNICODE;
10110 kern_type = KERN_TYPE_OLDOFFICE01;
10111 dgst_size = DGST_SIZE_4_4;
10112 parse_func = oldoffice01_parse_hash;
10113 sort_by_digest = sort_by_digest_4_4;
10114 opti_type = OPTI_TYPE_ZERO_BYTE
10115 | OPTI_TYPE_PRECOMPUTE_INIT
10116 | OPTI_TYPE_NOT_ITERATED;
10117 dgst_pos0 = 0;
10118 dgst_pos1 = 1;
10119 dgst_pos2 = 2;
10120 dgst_pos3 = 3;
10121 break;
10122
10123 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
10124 salt_type = SALT_TYPE_EMBEDDED;
10125 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10126 opts_type = OPTS_TYPE_PT_GENERATE_LE
10127 | OPTS_TYPE_PT_ADD80;
10128 kern_type = KERN_TYPE_OLDOFFICE01CM1;
10129 dgst_size = DGST_SIZE_4_4;
10130 parse_func = oldoffice01cm1_parse_hash;
10131 sort_by_digest = sort_by_digest_4_4;
10132 opti_type = OPTI_TYPE_ZERO_BYTE
10133 | OPTI_TYPE_PRECOMPUTE_INIT
10134 | OPTI_TYPE_NOT_ITERATED;
10135 dgst_pos0 = 0;
10136 dgst_pos1 = 1;
10137 dgst_pos2 = 2;
10138 dgst_pos3 = 3;
10139 break;
10140
10141 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
10142 salt_type = SALT_TYPE_EMBEDDED;
10143 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10144 opts_type = OPTS_TYPE_PT_GENERATE_LE
10145 | OPTS_TYPE_PT_ADD80
10146 | OPTS_TYPE_PT_UNICODE
10147 | OPTS_TYPE_PT_NEVERCRACK;
10148 kern_type = KERN_TYPE_OLDOFFICE01CM2;
10149 dgst_size = DGST_SIZE_4_4;
10150 parse_func = oldoffice01cm2_parse_hash;
10151 sort_by_digest = sort_by_digest_4_4;
10152 opti_type = OPTI_TYPE_ZERO_BYTE
10153 | OPTI_TYPE_PRECOMPUTE_INIT
10154 | OPTI_TYPE_NOT_ITERATED;
10155 dgst_pos0 = 0;
10156 dgst_pos1 = 1;
10157 dgst_pos2 = 2;
10158 dgst_pos3 = 3;
10159 break;
10160
10161 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
10162 salt_type = SALT_TYPE_EMBEDDED;
10163 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10164 opts_type = OPTS_TYPE_PT_GENERATE_BE
10165 | OPTS_TYPE_PT_ADD80
10166 | OPTS_TYPE_PT_UNICODE;
10167 kern_type = KERN_TYPE_OLDOFFICE34;
10168 dgst_size = DGST_SIZE_4_4;
10169 parse_func = oldoffice34_parse_hash;
10170 sort_by_digest = sort_by_digest_4_4;
10171 opti_type = OPTI_TYPE_ZERO_BYTE
10172 | OPTI_TYPE_PRECOMPUTE_INIT
10173 | OPTI_TYPE_NOT_ITERATED;
10174 dgst_pos0 = 0;
10175 dgst_pos1 = 1;
10176 dgst_pos2 = 2;
10177 dgst_pos3 = 3;
10178 break;
10179
10180 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10181 salt_type = SALT_TYPE_EMBEDDED;
10182 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10183 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10184 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10185 dgst_size = DGST_SIZE_4_4;
10186 parse_func = oldoffice34cm1_parse_hash;
10187 sort_by_digest = sort_by_digest_4_4;
10188 opti_type = OPTI_TYPE_ZERO_BYTE
10189 | OPTI_TYPE_PRECOMPUTE_INIT
10190 | OPTI_TYPE_NOT_ITERATED;
10191 dgst_pos0 = 0;
10192 dgst_pos1 = 1;
10193 dgst_pos2 = 2;
10194 dgst_pos3 = 3;
10195 break;
10196
10197 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10198 salt_type = SALT_TYPE_EMBEDDED;
10199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10200 opts_type = OPTS_TYPE_PT_GENERATE_BE
10201 | OPTS_TYPE_PT_ADD80
10202 | OPTS_TYPE_PT_UNICODE
10203 | OPTS_TYPE_PT_NEVERCRACK;
10204 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10205 dgst_size = DGST_SIZE_4_4;
10206 parse_func = oldoffice34cm2_parse_hash;
10207 sort_by_digest = sort_by_digest_4_4;
10208 opti_type = OPTI_TYPE_ZERO_BYTE
10209 | OPTI_TYPE_PRECOMPUTE_INIT
10210 | OPTI_TYPE_NOT_ITERATED;
10211 dgst_pos0 = 0;
10212 dgst_pos1 = 1;
10213 dgst_pos2 = 2;
10214 dgst_pos3 = 3;
10215 break;
10216
10217 case 9900: hash_type = HASH_TYPE_MD5;
10218 salt_type = SALT_TYPE_NONE;
10219 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10220 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10221 kern_type = KERN_TYPE_RADMIN2;
10222 dgst_size = DGST_SIZE_4_4;
10223 parse_func = radmin2_parse_hash;
10224 sort_by_digest = sort_by_digest_4_4;
10225 opti_type = OPTI_TYPE_ZERO_BYTE
10226 | OPTI_TYPE_PRECOMPUTE_INIT
10227 | OPTI_TYPE_EARLY_SKIP
10228 | OPTI_TYPE_NOT_ITERATED
10229 | OPTI_TYPE_NOT_SALTED;
10230 dgst_pos0 = 0;
10231 dgst_pos1 = 3;
10232 dgst_pos2 = 2;
10233 dgst_pos3 = 1;
10234 break;
10235
10236 case 10000: hash_type = HASH_TYPE_SHA256;
10237 salt_type = SALT_TYPE_EMBEDDED;
10238 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10239 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10240 kern_type = KERN_TYPE_PBKDF2_SHA256;
10241 dgst_size = DGST_SIZE_4_32;
10242 parse_func = djangopbkdf2_parse_hash;
10243 sort_by_digest = sort_by_digest_4_32;
10244 opti_type = OPTI_TYPE_ZERO_BYTE
10245 | OPTI_TYPE_SLOW_HASH_SIMD;
10246 dgst_pos0 = 0;
10247 dgst_pos1 = 1;
10248 dgst_pos2 = 2;
10249 dgst_pos3 = 3;
10250 break;
10251
10252 case 10100: hash_type = HASH_TYPE_SIPHASH;
10253 salt_type = SALT_TYPE_EMBEDDED;
10254 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10255 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10256 kern_type = KERN_TYPE_SIPHASH;
10257 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10258 parse_func = siphash_parse_hash;
10259 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10260 opti_type = OPTI_TYPE_ZERO_BYTE
10261 | OPTI_TYPE_NOT_ITERATED
10262 | OPTI_TYPE_RAW_HASH;
10263 dgst_pos0 = 0;
10264 dgst_pos1 = 1;
10265 dgst_pos2 = 2;
10266 dgst_pos3 = 3;
10267 break;
10268
10269 case 10200: hash_type = HASH_TYPE_MD5;
10270 salt_type = SALT_TYPE_EMBEDDED;
10271 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10272 opts_type = OPTS_TYPE_PT_GENERATE_LE
10273 | OPTS_TYPE_ST_ADD80
10274 | OPTS_TYPE_ST_ADDBITS14;
10275 kern_type = KERN_TYPE_HMACMD5_PW;
10276 dgst_size = DGST_SIZE_4_4;
10277 parse_func = crammd5_parse_hash;
10278 sort_by_digest = sort_by_digest_4_4;
10279 opti_type = OPTI_TYPE_ZERO_BYTE
10280 | OPTI_TYPE_NOT_ITERATED;
10281 dgst_pos0 = 0;
10282 dgst_pos1 = 3;
10283 dgst_pos2 = 2;
10284 dgst_pos3 = 1;
10285 break;
10286
10287 case 10300: hash_type = HASH_TYPE_SHA1;
10288 salt_type = SALT_TYPE_EMBEDDED;
10289 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10290 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10291 kern_type = KERN_TYPE_SAPH_SHA1;
10292 dgst_size = DGST_SIZE_4_5;
10293 parse_func = saph_sha1_parse_hash;
10294 sort_by_digest = sort_by_digest_4_5;
10295 opti_type = OPTI_TYPE_ZERO_BYTE;
10296 dgst_pos0 = 0;
10297 dgst_pos1 = 1;
10298 dgst_pos2 = 2;
10299 dgst_pos3 = 3;
10300 break;
10301
10302 case 10400: hash_type = HASH_TYPE_PDFU16;
10303 salt_type = SALT_TYPE_EMBEDDED;
10304 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10305 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10306 kern_type = KERN_TYPE_PDF11;
10307 dgst_size = DGST_SIZE_4_4;
10308 parse_func = pdf11_parse_hash;
10309 sort_by_digest = sort_by_digest_4_4;
10310 opti_type = OPTI_TYPE_ZERO_BYTE
10311 | OPTI_TYPE_NOT_ITERATED;
10312 dgst_pos0 = 0;
10313 dgst_pos1 = 1;
10314 dgst_pos2 = 2;
10315 dgst_pos3 = 3;
10316 break;
10317
10318 case 10410: hash_type = HASH_TYPE_PDFU16;
10319 salt_type = SALT_TYPE_EMBEDDED;
10320 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10321 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10322 kern_type = KERN_TYPE_PDF11CM1;
10323 dgst_size = DGST_SIZE_4_4;
10324 parse_func = pdf11cm1_parse_hash;
10325 sort_by_digest = sort_by_digest_4_4;
10326 opti_type = OPTI_TYPE_ZERO_BYTE
10327 | OPTI_TYPE_NOT_ITERATED;
10328 dgst_pos0 = 0;
10329 dgst_pos1 = 1;
10330 dgst_pos2 = 2;
10331 dgst_pos3 = 3;
10332 break;
10333
10334 case 10420: hash_type = HASH_TYPE_PDFU16;
10335 salt_type = SALT_TYPE_EMBEDDED;
10336 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10337 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10338 kern_type = KERN_TYPE_PDF11CM2;
10339 dgst_size = DGST_SIZE_4_4;
10340 parse_func = pdf11cm2_parse_hash;
10341 sort_by_digest = sort_by_digest_4_4;
10342 opti_type = OPTI_TYPE_ZERO_BYTE
10343 | OPTI_TYPE_NOT_ITERATED;
10344 dgst_pos0 = 0;
10345 dgst_pos1 = 1;
10346 dgst_pos2 = 2;
10347 dgst_pos3 = 3;
10348 break;
10349
10350 case 10500: hash_type = HASH_TYPE_PDFU16;
10351 salt_type = SALT_TYPE_EMBEDDED;
10352 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10353 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10354 kern_type = KERN_TYPE_PDF14;
10355 dgst_size = DGST_SIZE_4_4;
10356 parse_func = pdf14_parse_hash;
10357 sort_by_digest = sort_by_digest_4_4;
10358 opti_type = OPTI_TYPE_ZERO_BYTE
10359 | OPTI_TYPE_NOT_ITERATED;
10360 dgst_pos0 = 0;
10361 dgst_pos1 = 1;
10362 dgst_pos2 = 2;
10363 dgst_pos3 = 3;
10364 break;
10365
10366 case 10600: hash_type = HASH_TYPE_SHA256;
10367 salt_type = SALT_TYPE_EMBEDDED;
10368 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10369 opts_type = OPTS_TYPE_PT_GENERATE_BE
10370 | OPTS_TYPE_ST_ADD80
10371 | OPTS_TYPE_ST_ADDBITS15
10372 | OPTS_TYPE_HASH_COPY;
10373 kern_type = KERN_TYPE_SHA256_PWSLT;
10374 dgst_size = DGST_SIZE_4_8;
10375 parse_func = pdf17l3_parse_hash;
10376 sort_by_digest = sort_by_digest_4_8;
10377 opti_type = OPTI_TYPE_ZERO_BYTE
10378 | OPTI_TYPE_PRECOMPUTE_INIT
10379 | OPTI_TYPE_PRECOMPUTE_MERKLE
10380 | OPTI_TYPE_EARLY_SKIP
10381 | OPTI_TYPE_NOT_ITERATED
10382 | OPTI_TYPE_APPENDED_SALT
10383 | OPTI_TYPE_RAW_HASH;
10384 dgst_pos0 = 3;
10385 dgst_pos1 = 7;
10386 dgst_pos2 = 2;
10387 dgst_pos3 = 6;
10388 break;
10389
10390 case 10700: hash_type = HASH_TYPE_PDFU32;
10391 salt_type = SALT_TYPE_EMBEDDED;
10392 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10393 opts_type = OPTS_TYPE_PT_GENERATE_LE
10394 | OPTS_TYPE_HASH_COPY;
10395 kern_type = KERN_TYPE_PDF17L8;
10396 dgst_size = DGST_SIZE_4_8;
10397 parse_func = pdf17l8_parse_hash;
10398 sort_by_digest = sort_by_digest_4_8;
10399 opti_type = OPTI_TYPE_ZERO_BYTE
10400 | OPTI_TYPE_NOT_ITERATED;
10401 dgst_pos0 = 0;
10402 dgst_pos1 = 1;
10403 dgst_pos2 = 2;
10404 dgst_pos3 = 3;
10405 break;
10406
10407 case 10800: hash_type = HASH_TYPE_SHA384;
10408 salt_type = SALT_TYPE_NONE;
10409 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10410 opts_type = OPTS_TYPE_PT_GENERATE_BE
10411 | OPTS_TYPE_PT_ADD80
10412 | OPTS_TYPE_PT_ADDBITS15;
10413 kern_type = KERN_TYPE_SHA384;
10414 dgst_size = DGST_SIZE_8_8;
10415 parse_func = sha384_parse_hash;
10416 sort_by_digest = sort_by_digest_8_8;
10417 opti_type = OPTI_TYPE_ZERO_BYTE
10418 | OPTI_TYPE_PRECOMPUTE_INIT
10419 | OPTI_TYPE_PRECOMPUTE_MERKLE
10420 | OPTI_TYPE_EARLY_SKIP
10421 | OPTI_TYPE_NOT_ITERATED
10422 | OPTI_TYPE_NOT_SALTED
10423 | OPTI_TYPE_USES_BITS_64
10424 | OPTI_TYPE_RAW_HASH;
10425 dgst_pos0 = 6;
10426 dgst_pos1 = 7;
10427 dgst_pos2 = 4;
10428 dgst_pos3 = 5;
10429 break;
10430
10431 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10432 salt_type = SALT_TYPE_EMBEDDED;
10433 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10434 opts_type = OPTS_TYPE_PT_GENERATE_LE
10435 | OPTS_TYPE_ST_BASE64
10436 | OPTS_TYPE_HASH_COPY;
10437 kern_type = KERN_TYPE_PBKDF2_SHA256;
10438 dgst_size = DGST_SIZE_4_32;
10439 parse_func = pbkdf2_sha256_parse_hash;
10440 sort_by_digest = sort_by_digest_4_32;
10441 opti_type = OPTI_TYPE_ZERO_BYTE
10442 | OPTI_TYPE_SLOW_HASH_SIMD;
10443 dgst_pos0 = 0;
10444 dgst_pos1 = 1;
10445 dgst_pos2 = 2;
10446 dgst_pos3 = 3;
10447 break;
10448
10449 case 11000: hash_type = HASH_TYPE_MD5;
10450 salt_type = SALT_TYPE_INTERN;
10451 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10452 opts_type = OPTS_TYPE_PT_GENERATE_LE
10453 | OPTS_TYPE_PT_ADD80;
10454 kern_type = KERN_TYPE_PRESTASHOP;
10455 dgst_size = DGST_SIZE_4_4;
10456 parse_func = prestashop_parse_hash;
10457 sort_by_digest = sort_by_digest_4_4;
10458 opti_type = OPTI_TYPE_ZERO_BYTE
10459 | OPTI_TYPE_PRECOMPUTE_INIT
10460 | OPTI_TYPE_NOT_ITERATED
10461 | OPTI_TYPE_PREPENDED_SALT;
10462 dgst_pos0 = 0;
10463 dgst_pos1 = 3;
10464 dgst_pos2 = 2;
10465 dgst_pos3 = 1;
10466 break;
10467
10468 case 11100: hash_type = HASH_TYPE_MD5;
10469 salt_type = SALT_TYPE_EMBEDDED;
10470 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10471 opts_type = OPTS_TYPE_PT_GENERATE_LE
10472 | OPTS_TYPE_ST_ADD80;
10473 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10474 dgst_size = DGST_SIZE_4_4;
10475 parse_func = postgresql_auth_parse_hash;
10476 sort_by_digest = sort_by_digest_4_4;
10477 opti_type = OPTI_TYPE_ZERO_BYTE
10478 | OPTI_TYPE_PRECOMPUTE_INIT
10479 | OPTI_TYPE_PRECOMPUTE_MERKLE
10480 | OPTI_TYPE_EARLY_SKIP;
10481 dgst_pos0 = 0;
10482 dgst_pos1 = 3;
10483 dgst_pos2 = 2;
10484 dgst_pos3 = 1;
10485 break;
10486
10487 case 11200: hash_type = HASH_TYPE_SHA1;
10488 salt_type = SALT_TYPE_EMBEDDED;
10489 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10490 opts_type = OPTS_TYPE_PT_GENERATE_BE
10491 | OPTS_TYPE_PT_ADD80
10492 | OPTS_TYPE_ST_HEX;
10493 kern_type = KERN_TYPE_MYSQL_AUTH;
10494 dgst_size = DGST_SIZE_4_5;
10495 parse_func = mysql_auth_parse_hash;
10496 sort_by_digest = sort_by_digest_4_5;
10497 opti_type = OPTI_TYPE_ZERO_BYTE
10498 | OPTI_TYPE_EARLY_SKIP;
10499 dgst_pos0 = 3;
10500 dgst_pos1 = 4;
10501 dgst_pos2 = 2;
10502 dgst_pos3 = 1;
10503 break;
10504
10505 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10506 salt_type = SALT_TYPE_EMBEDDED;
10507 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10508 opts_type = OPTS_TYPE_PT_GENERATE_LE
10509 | OPTS_TYPE_ST_HEX
10510 | OPTS_TYPE_ST_ADD80;
10511 kern_type = KERN_TYPE_BITCOIN_WALLET;
10512 dgst_size = DGST_SIZE_4_4;
10513 parse_func = bitcoin_wallet_parse_hash;
10514 sort_by_digest = sort_by_digest_4_4;
10515 opti_type = OPTI_TYPE_ZERO_BYTE;
10516 dgst_pos0 = 0;
10517 dgst_pos1 = 1;
10518 dgst_pos2 = 2;
10519 dgst_pos3 = 3;
10520 break;
10521
10522 case 11400: hash_type = HASH_TYPE_MD5;
10523 salt_type = SALT_TYPE_EMBEDDED;
10524 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10525 opts_type = OPTS_TYPE_PT_GENERATE_LE
10526 | OPTS_TYPE_PT_ADD80
10527 | OPTS_TYPE_HASH_COPY;
10528 kern_type = KERN_TYPE_SIP_AUTH;
10529 dgst_size = DGST_SIZE_4_4;
10530 parse_func = sip_auth_parse_hash;
10531 sort_by_digest = sort_by_digest_4_4;
10532 opti_type = OPTI_TYPE_ZERO_BYTE;
10533 dgst_pos0 = 0;
10534 dgst_pos1 = 3;
10535 dgst_pos2 = 2;
10536 dgst_pos3 = 1;
10537 break;
10538
10539 case 11500: hash_type = HASH_TYPE_CRC32;
10540 salt_type = SALT_TYPE_INTERN;
10541 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10542 opts_type = OPTS_TYPE_PT_GENERATE_LE
10543 | OPTS_TYPE_ST_GENERATE_LE
10544 | OPTS_TYPE_ST_HEX;
10545 kern_type = KERN_TYPE_CRC32;
10546 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10547 parse_func = crc32_parse_hash;
10548 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10549 opti_type = OPTI_TYPE_ZERO_BYTE;
10550 dgst_pos0 = 0;
10551 dgst_pos1 = 1;
10552 dgst_pos2 = 2;
10553 dgst_pos3 = 3;
10554 break;
10555
10556 case 11600: hash_type = HASH_TYPE_AES;
10557 salt_type = SALT_TYPE_EMBEDDED;
10558 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10559 opts_type = OPTS_TYPE_PT_GENERATE_LE
10560 | OPTS_TYPE_PT_NEVERCRACK;
10561 kern_type = KERN_TYPE_SEVEN_ZIP;
10562 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10563 parse_func = seven_zip_parse_hash;
10564 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10565 opti_type = OPTI_TYPE_ZERO_BYTE;
10566 dgst_pos0 = 0;
10567 dgst_pos1 = 1;
10568 dgst_pos2 = 2;
10569 dgst_pos3 = 3;
10570 break;
10571
10572 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10573 salt_type = SALT_TYPE_NONE;
10574 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10575 opts_type = OPTS_TYPE_PT_GENERATE_LE
10576 | OPTS_TYPE_PT_ADD01;
10577 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10578 dgst_size = DGST_SIZE_4_8;
10579 parse_func = gost2012sbog_256_parse_hash;
10580 sort_by_digest = sort_by_digest_4_8;
10581 opti_type = OPTI_TYPE_ZERO_BYTE;
10582 dgst_pos0 = 0;
10583 dgst_pos1 = 1;
10584 dgst_pos2 = 2;
10585 dgst_pos3 = 3;
10586 break;
10587
10588 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10589 salt_type = SALT_TYPE_NONE;
10590 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10591 opts_type = OPTS_TYPE_PT_GENERATE_LE
10592 | OPTS_TYPE_PT_ADD01;
10593 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10594 dgst_size = DGST_SIZE_4_16;
10595 parse_func = gost2012sbog_512_parse_hash;
10596 sort_by_digest = sort_by_digest_4_16;
10597 opti_type = OPTI_TYPE_ZERO_BYTE;
10598 dgst_pos0 = 0;
10599 dgst_pos1 = 1;
10600 dgst_pos2 = 2;
10601 dgst_pos3 = 3;
10602 break;
10603
10604 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10605 salt_type = SALT_TYPE_EMBEDDED;
10606 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10607 opts_type = OPTS_TYPE_PT_GENERATE_LE
10608 | OPTS_TYPE_ST_BASE64
10609 | OPTS_TYPE_HASH_COPY;
10610 kern_type = KERN_TYPE_PBKDF2_MD5;
10611 dgst_size = DGST_SIZE_4_32;
10612 parse_func = pbkdf2_md5_parse_hash;
10613 sort_by_digest = sort_by_digest_4_32;
10614 opti_type = OPTI_TYPE_ZERO_BYTE
10615 | OPTI_TYPE_SLOW_HASH_SIMD;
10616 dgst_pos0 = 0;
10617 dgst_pos1 = 1;
10618 dgst_pos2 = 2;
10619 dgst_pos3 = 3;
10620 break;
10621
10622 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10623 salt_type = SALT_TYPE_EMBEDDED;
10624 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10625 opts_type = OPTS_TYPE_PT_GENERATE_LE
10626 | OPTS_TYPE_ST_BASE64
10627 | OPTS_TYPE_HASH_COPY;
10628 kern_type = KERN_TYPE_PBKDF2_SHA1;
10629 dgst_size = DGST_SIZE_4_32;
10630 parse_func = pbkdf2_sha1_parse_hash;
10631 sort_by_digest = sort_by_digest_4_32;
10632 opti_type = OPTI_TYPE_ZERO_BYTE
10633 | OPTI_TYPE_SLOW_HASH_SIMD;
10634 dgst_pos0 = 0;
10635 dgst_pos1 = 1;
10636 dgst_pos2 = 2;
10637 dgst_pos3 = 3;
10638 break;
10639
10640 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10641 salt_type = SALT_TYPE_EMBEDDED;
10642 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10643 opts_type = OPTS_TYPE_PT_GENERATE_LE
10644 | OPTS_TYPE_ST_BASE64
10645 | OPTS_TYPE_HASH_COPY;
10646 kern_type = KERN_TYPE_PBKDF2_SHA512;
10647 dgst_size = DGST_SIZE_8_16;
10648 parse_func = pbkdf2_sha512_parse_hash;
10649 sort_by_digest = sort_by_digest_8_16;
10650 opti_type = OPTI_TYPE_ZERO_BYTE
10651 | OPTI_TYPE_USES_BITS_64
10652 | OPTI_TYPE_SLOW_HASH_SIMD;
10653 dgst_pos0 = 0;
10654 dgst_pos1 = 1;
10655 dgst_pos2 = 2;
10656 dgst_pos3 = 3;
10657 break;
10658
10659 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10660 salt_type = SALT_TYPE_EMBEDDED;
10661 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10662 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10663 kern_type = KERN_TYPE_ECRYPTFS;
10664 dgst_size = DGST_SIZE_8_8;
10665 parse_func = ecryptfs_parse_hash;
10666 sort_by_digest = sort_by_digest_8_8;
10667 opti_type = OPTI_TYPE_ZERO_BYTE
10668 | OPTI_TYPE_USES_BITS_64;
10669 dgst_pos0 = 0;
10670 dgst_pos1 = 1;
10671 dgst_pos2 = 2;
10672 dgst_pos3 = 3;
10673 break;
10674
10675 case 12300: hash_type = HASH_TYPE_ORACLET;
10676 salt_type = SALT_TYPE_EMBEDDED;
10677 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10678 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10679 kern_type = KERN_TYPE_ORACLET;
10680 dgst_size = DGST_SIZE_8_16;
10681 parse_func = oraclet_parse_hash;
10682 sort_by_digest = sort_by_digest_8_16;
10683 opti_type = OPTI_TYPE_ZERO_BYTE
10684 | OPTI_TYPE_USES_BITS_64;
10685 dgst_pos0 = 0;
10686 dgst_pos1 = 1;
10687 dgst_pos2 = 2;
10688 dgst_pos3 = 3;
10689 break;
10690
10691 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10692 salt_type = SALT_TYPE_EMBEDDED;
10693 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10694 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10695 kern_type = KERN_TYPE_BSDICRYPT;
10696 dgst_size = DGST_SIZE_4_4;
10697 parse_func = bsdicrypt_parse_hash;
10698 sort_by_digest = sort_by_digest_4_4;
10699 opti_type = OPTI_TYPE_ZERO_BYTE
10700 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10701 dgst_pos0 = 0;
10702 dgst_pos1 = 1;
10703 dgst_pos2 = 2;
10704 dgst_pos3 = 3;
10705 break;
10706
10707 case 12500: hash_type = HASH_TYPE_RAR3HP;
10708 salt_type = SALT_TYPE_EMBEDDED;
10709 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10710 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10711 kern_type = KERN_TYPE_RAR3;
10712 dgst_size = DGST_SIZE_4_4;
10713 parse_func = rar3hp_parse_hash;
10714 sort_by_digest = sort_by_digest_4_4;
10715 opti_type = OPTI_TYPE_ZERO_BYTE;
10716 dgst_pos0 = 0;
10717 dgst_pos1 = 1;
10718 dgst_pos2 = 2;
10719 dgst_pos3 = 3;
10720 break;
10721
10722 case 12600: hash_type = HASH_TYPE_SHA256;
10723 salt_type = SALT_TYPE_INTERN;
10724 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10725 opts_type = OPTS_TYPE_PT_GENERATE_BE
10726 | OPTS_TYPE_PT_ADD80;
10727 kern_type = KERN_TYPE_CF10;
10728 dgst_size = DGST_SIZE_4_8;
10729 parse_func = cf10_parse_hash;
10730 sort_by_digest = sort_by_digest_4_8;
10731 opti_type = OPTI_TYPE_ZERO_BYTE
10732 | OPTI_TYPE_PRECOMPUTE_INIT
10733 | OPTI_TYPE_EARLY_SKIP
10734 | OPTI_TYPE_NOT_ITERATED;
10735 dgst_pos0 = 3;
10736 dgst_pos1 = 7;
10737 dgst_pos2 = 2;
10738 dgst_pos3 = 6;
10739 break;
10740
10741 case 12700: hash_type = HASH_TYPE_AES;
10742 salt_type = SALT_TYPE_EMBEDDED;
10743 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10744 opts_type = OPTS_TYPE_PT_GENERATE_LE
10745 | OPTS_TYPE_HASH_COPY;
10746 kern_type = KERN_TYPE_MYWALLET;
10747 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10748 parse_func = mywallet_parse_hash;
10749 sort_by_digest = sort_by_digest_4_5;
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 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10758 salt_type = SALT_TYPE_EMBEDDED;
10759 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10760 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10761 kern_type = KERN_TYPE_MS_DRSR;
10762 dgst_size = DGST_SIZE_4_8;
10763 parse_func = ms_drsr_parse_hash;
10764 sort_by_digest = sort_by_digest_4_8;
10765 opti_type = OPTI_TYPE_ZERO_BYTE;
10766 dgst_pos0 = 0;
10767 dgst_pos1 = 1;
10768 dgst_pos2 = 2;
10769 dgst_pos3 = 3;
10770 break;
10771
10772 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10773 salt_type = SALT_TYPE_EMBEDDED;
10774 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10775 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10776 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10777 dgst_size = DGST_SIZE_4_8;
10778 parse_func = androidfde_samsung_parse_hash;
10779 sort_by_digest = sort_by_digest_4_8;
10780 opti_type = OPTI_TYPE_ZERO_BYTE;
10781 dgst_pos0 = 0;
10782 dgst_pos1 = 1;
10783 dgst_pos2 = 2;
10784 dgst_pos3 = 3;
10785 break;
10786
10787 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10788 salt_type = SALT_TYPE_EMBEDDED;
10789 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10790 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10791 kern_type = KERN_TYPE_RAR5;
10792 dgst_size = DGST_SIZE_4_4;
10793 parse_func = rar5_parse_hash;
10794 sort_by_digest = sort_by_digest_4_4;
10795 opti_type = OPTI_TYPE_ZERO_BYTE;
10796 dgst_pos0 = 0;
10797 dgst_pos1 = 1;
10798 dgst_pos2 = 2;
10799 dgst_pos3 = 3;
10800 break;
10801
10802 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10803 salt_type = SALT_TYPE_EMBEDDED;
10804 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10805 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10806 kern_type = KERN_TYPE_KRB5TGS;
10807 dgst_size = DGST_SIZE_4_4;
10808 parse_func = krb5tgs_parse_hash;
10809 sort_by_digest = sort_by_digest_4_4;
10810 opti_type = OPTI_TYPE_ZERO_BYTE
10811 | OPTI_TYPE_NOT_ITERATED;
10812 dgst_pos0 = 0;
10813 dgst_pos1 = 1;
10814 dgst_pos2 = 2;
10815 dgst_pos3 = 3;
10816 break;
10817
10818 case 13200: hash_type = HASH_TYPE_AES;
10819 salt_type = SALT_TYPE_EMBEDDED;
10820 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10821 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10822 kern_type = KERN_TYPE_AXCRYPT;
10823 dgst_size = DGST_SIZE_4_4;
10824 parse_func = axcrypt_parse_hash;
10825 sort_by_digest = sort_by_digest_4_4;
10826 opti_type = OPTI_TYPE_ZERO_BYTE;
10827 dgst_pos0 = 0;
10828 dgst_pos1 = 1;
10829 dgst_pos2 = 2;
10830 dgst_pos3 = 3;
10831 break;
10832
10833 case 13300: hash_type = HASH_TYPE_SHA1;
10834 salt_type = SALT_TYPE_NONE;
10835 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10836 opts_type = OPTS_TYPE_PT_GENERATE_BE
10837 | OPTS_TYPE_PT_ADD80
10838 | OPTS_TYPE_PT_ADDBITS15;
10839 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10840 dgst_size = DGST_SIZE_4_5;
10841 parse_func = sha1axcrypt_parse_hash;
10842 sort_by_digest = sort_by_digest_4_5;
10843 opti_type = OPTI_TYPE_ZERO_BYTE
10844 | OPTI_TYPE_PRECOMPUTE_INIT
10845 | OPTI_TYPE_EARLY_SKIP
10846 | OPTI_TYPE_NOT_ITERATED
10847 | OPTI_TYPE_NOT_SALTED;
10848 dgst_pos0 = 0;
10849 dgst_pos1 = 4;
10850 dgst_pos2 = 3;
10851 dgst_pos3 = 2;
10852 break;
10853
10854 case 13400: hash_type = HASH_TYPE_AES;
10855 salt_type = SALT_TYPE_EMBEDDED;
10856 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10857 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10858 kern_type = KERN_TYPE_KEEPASS;
10859 dgst_size = DGST_SIZE_4_4;
10860 parse_func = keepass_parse_hash;
10861 sort_by_digest = sort_by_digest_4_4;
10862 opti_type = OPTI_TYPE_ZERO_BYTE;
10863 dgst_pos0 = 0;
10864 dgst_pos1 = 1;
10865 dgst_pos2 = 2;
10866 dgst_pos3 = 3;
10867 break;
10868
10869 case 13500: hash_type = HASH_TYPE_SHA1;
10870 salt_type = SALT_TYPE_EMBEDDED;
10871 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10872 opts_type = OPTS_TYPE_PT_GENERATE_BE
10873 | OPTS_TYPE_PT_UNICODE
10874 | OPTS_TYPE_PT_ADD80;
10875 kern_type = KERN_TYPE_PSTOKEN;
10876 dgst_size = DGST_SIZE_4_5;
10877 parse_func = pstoken_parse_hash;
10878 sort_by_digest = sort_by_digest_4_5;
10879 opti_type = OPTI_TYPE_ZERO_BYTE
10880 | OPTI_TYPE_PRECOMPUTE_INIT
10881 | OPTI_TYPE_EARLY_SKIP
10882 | OPTI_TYPE_NOT_ITERATED
10883 | OPTI_TYPE_PREPENDED_SALT
10884 | OPTI_TYPE_RAW_HASH;
10885 dgst_pos0 = 3;
10886 dgst_pos1 = 4;
10887 dgst_pos2 = 2;
10888 dgst_pos3 = 1;
10889 break;
10890
10891 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
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_ZIP2;
10896 dgst_size = DGST_SIZE_4_4;
10897 parse_func = zip2_parse_hash;
10898 sort_by_digest = sort_by_digest_4_4;
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 13711: hash_type = HASH_TYPE_RIPEMD160;
10907 salt_type = SALT_TYPE_EMBEDDED;
10908 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10909 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10910 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10911 dgst_size = DGST_SIZE_4_5;
10912 parse_func = veracrypt_parse_hash_655331;
10913 sort_by_digest = sort_by_digest_4_5;
10914 opti_type = OPTI_TYPE_ZERO_BYTE;
10915 dgst_pos0 = 0;
10916 dgst_pos1 = 1;
10917 dgst_pos2 = 2;
10918 dgst_pos3 = 3;
10919 break;
10920
10921 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10922 salt_type = SALT_TYPE_EMBEDDED;
10923 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10924 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10925 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10926 dgst_size = DGST_SIZE_4_5;
10927 parse_func = veracrypt_parse_hash_655331;
10928 sort_by_digest = sort_by_digest_4_5;
10929 opti_type = OPTI_TYPE_ZERO_BYTE;
10930 dgst_pos0 = 0;
10931 dgst_pos1 = 1;
10932 dgst_pos2 = 2;
10933 dgst_pos3 = 3;
10934 break;
10935
10936 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10937 salt_type = SALT_TYPE_EMBEDDED;
10938 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10939 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10940 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10941 dgst_size = DGST_SIZE_4_5;
10942 parse_func = veracrypt_parse_hash_655331;
10943 sort_by_digest = sort_by_digest_4_5;
10944 opti_type = OPTI_TYPE_ZERO_BYTE;
10945 dgst_pos0 = 0;
10946 dgst_pos1 = 1;
10947 dgst_pos2 = 2;
10948 dgst_pos3 = 3;
10949 break;
10950
10951 case 13721: hash_type = HASH_TYPE_SHA512;
10952 salt_type = SALT_TYPE_EMBEDDED;
10953 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10954 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10955 kern_type = KERN_TYPE_TCSHA512_XTS512;
10956 dgst_size = DGST_SIZE_8_8;
10957 parse_func = veracrypt_parse_hash_500000;
10958 sort_by_digest = sort_by_digest_8_8;
10959 opti_type = OPTI_TYPE_ZERO_BYTE
10960 | OPTI_TYPE_USES_BITS_64;
10961 dgst_pos0 = 0;
10962 dgst_pos1 = 1;
10963 dgst_pos2 = 2;
10964 dgst_pos3 = 3;
10965 break;
10966
10967 case 13722: hash_type = HASH_TYPE_SHA512;
10968 salt_type = SALT_TYPE_EMBEDDED;
10969 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10970 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10971 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10972 dgst_size = DGST_SIZE_8_8;
10973 parse_func = veracrypt_parse_hash_500000;
10974 sort_by_digest = sort_by_digest_8_8;
10975 opti_type = OPTI_TYPE_ZERO_BYTE
10976 | OPTI_TYPE_USES_BITS_64;
10977 dgst_pos0 = 0;
10978 dgst_pos1 = 1;
10979 dgst_pos2 = 2;
10980 dgst_pos3 = 3;
10981 break;
10982
10983 case 13723: hash_type = HASH_TYPE_SHA512;
10984 salt_type = SALT_TYPE_EMBEDDED;
10985 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10986 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10987 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10988 dgst_size = DGST_SIZE_8_8;
10989 parse_func = veracrypt_parse_hash_500000;
10990 sort_by_digest = sort_by_digest_8_8;
10991 opti_type = OPTI_TYPE_ZERO_BYTE
10992 | OPTI_TYPE_USES_BITS_64;
10993 dgst_pos0 = 0;
10994 dgst_pos1 = 1;
10995 dgst_pos2 = 2;
10996 dgst_pos3 = 3;
10997 break;
10998
10999 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
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_TCWHIRLPOOL_XTS512;
11004 dgst_size = DGST_SIZE_4_8;
11005 parse_func = veracrypt_parse_hash_500000;
11006 sort_by_digest = sort_by_digest_4_8;
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 13732: hash_type = HASH_TYPE_WHIRLPOOL;
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_TCWHIRLPOOL_XTS1024;
11019 dgst_size = DGST_SIZE_4_8;
11020 parse_func = veracrypt_parse_hash_500000;
11021 sort_by_digest = sort_by_digest_4_8;
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 13733: hash_type = HASH_TYPE_WHIRLPOOL;
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_TCWHIRLPOOL_XTS1536;
11034 dgst_size = DGST_SIZE_4_8;
11035 parse_func = veracrypt_parse_hash_500000;
11036 sort_by_digest = sort_by_digest_4_8;
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 13741: hash_type = HASH_TYPE_RIPEMD160;
11045 salt_type = SALT_TYPE_EMBEDDED;
11046 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11047 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11048 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
11049 dgst_size = DGST_SIZE_4_5;
11050 parse_func = veracrypt_parse_hash_327661;
11051 sort_by_digest = sort_by_digest_4_5;
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 13742: hash_type = HASH_TYPE_RIPEMD160;
11060 salt_type = SALT_TYPE_EMBEDDED;
11061 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11062 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11063 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
11064 dgst_size = DGST_SIZE_4_5;
11065 parse_func = veracrypt_parse_hash_327661;
11066 sort_by_digest = sort_by_digest_4_5;
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 13743: hash_type = HASH_TYPE_RIPEMD160;
11075 salt_type = SALT_TYPE_EMBEDDED;
11076 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11077 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11078 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11079 dgst_size = DGST_SIZE_4_5;
11080 parse_func = veracrypt_parse_hash_327661;
11081 sort_by_digest = sort_by_digest_4_5;
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 13751: 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_500000;
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 13752: 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_500000;
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 13753: 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_500000;
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 13761: hash_type = HASH_TYPE_SHA256;
11135 salt_type = SALT_TYPE_EMBEDDED;
11136 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11137 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11138 kern_type = KERN_TYPE_VCSHA256_XTS512;
11139 dgst_size = DGST_SIZE_4_8;
11140 parse_func = veracrypt_parse_hash_200000;
11141 sort_by_digest = sort_by_digest_4_8;
11142 opti_type = OPTI_TYPE_ZERO_BYTE;
11143 dgst_pos0 = 0;
11144 dgst_pos1 = 1;
11145 dgst_pos2 = 2;
11146 dgst_pos3 = 3;
11147 break;
11148
11149 case 13762: hash_type = HASH_TYPE_SHA256;
11150 salt_type = SALT_TYPE_EMBEDDED;
11151 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11152 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11153 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11154 dgst_size = DGST_SIZE_4_8;
11155 parse_func = veracrypt_parse_hash_200000;
11156 sort_by_digest = sort_by_digest_4_8;
11157 opti_type = OPTI_TYPE_ZERO_BYTE;
11158 dgst_pos0 = 0;
11159 dgst_pos1 = 1;
11160 dgst_pos2 = 2;
11161 dgst_pos3 = 3;
11162 break;
11163
11164 case 13763: hash_type = HASH_TYPE_SHA256;
11165 salt_type = SALT_TYPE_EMBEDDED;
11166 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11167 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11168 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11169 dgst_size = DGST_SIZE_4_8;
11170 parse_func = veracrypt_parse_hash_200000;
11171 sort_by_digest = sort_by_digest_4_8;
11172 opti_type = OPTI_TYPE_ZERO_BYTE;
11173 dgst_pos0 = 0;
11174 dgst_pos1 = 1;
11175 dgst_pos2 = 2;
11176 dgst_pos3 = 3;
11177 break;
11178
11179 case 13800: hash_type = HASH_TYPE_SHA256;
11180 salt_type = SALT_TYPE_EMBEDDED;
11181 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11182 opts_type = OPTS_TYPE_PT_GENERATE_BE
11183 | OPTS_TYPE_PT_UNICODE;
11184 kern_type = KERN_TYPE_WIN8PHONE;
11185 dgst_size = DGST_SIZE_4_8;
11186 parse_func = win8phone_parse_hash;
11187 sort_by_digest = sort_by_digest_4_8;
11188 opti_type = OPTI_TYPE_ZERO_BYTE
11189 | OPTI_TYPE_PRECOMPUTE_INIT
11190 | OPTI_TYPE_EARLY_SKIP
11191 | OPTI_TYPE_NOT_ITERATED
11192 | OPTI_TYPE_RAW_HASH;
11193 dgst_pos0 = 3;
11194 dgst_pos1 = 7;
11195 dgst_pos2 = 2;
11196 dgst_pos3 = 6;
11197 break;
11198
11199 default: usage_mini_print (PROGNAME); return (-1);
11200 }
11201
11202 /**
11203 * parser
11204 */
11205
11206 data.parse_func = parse_func;
11207
11208 /**
11209 * misc stuff
11210 */
11211
11212 if (hex_salt)
11213 {
11214 if (salt_type == SALT_TYPE_INTERN)
11215 {
11216 opts_type |= OPTS_TYPE_ST_HEX;
11217 }
11218 else
11219 {
11220 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11221
11222 return (-1);
11223 }
11224 }
11225
11226 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11227 | (salt_type == SALT_TYPE_EXTERN)
11228 | (salt_type == SALT_TYPE_EMBEDDED)
11229 | (salt_type == SALT_TYPE_VIRTUAL));
11230
11231 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
11232
11233 data.hash_type = hash_type;
11234 data.attack_mode = attack_mode;
11235 data.attack_kern = attack_kern;
11236 data.attack_exec = attack_exec;
11237 data.kern_type = kern_type;
11238 data.opts_type = opts_type;
11239 data.dgst_size = dgst_size;
11240 data.salt_type = salt_type;
11241 data.isSalted = isSalted;
11242 data.sort_by_digest = sort_by_digest;
11243 data.dgst_pos0 = dgst_pos0;
11244 data.dgst_pos1 = dgst_pos1;
11245 data.dgst_pos2 = dgst_pos2;
11246 data.dgst_pos3 = dgst_pos3;
11247
11248 esalt_size = 0;
11249
11250 switch (hash_mode)
11251 {
11252 case 2500: esalt_size = sizeof (wpa_t); break;
11253 case 5300: esalt_size = sizeof (ikepsk_t); break;
11254 case 5400: esalt_size = sizeof (ikepsk_t); break;
11255 case 5500: esalt_size = sizeof (netntlm_t); break;
11256 case 5600: esalt_size = sizeof (netntlm_t); break;
11257 case 6211: esalt_size = sizeof (tc_t); break;
11258 case 6212: esalt_size = sizeof (tc_t); break;
11259 case 6213: esalt_size = sizeof (tc_t); break;
11260 case 6221: esalt_size = sizeof (tc_t); break;
11261 case 6222: esalt_size = sizeof (tc_t); break;
11262 case 6223: esalt_size = sizeof (tc_t); break;
11263 case 6231: esalt_size = sizeof (tc_t); break;
11264 case 6232: esalt_size = sizeof (tc_t); break;
11265 case 6233: esalt_size = sizeof (tc_t); break;
11266 case 6241: esalt_size = sizeof (tc_t); break;
11267 case 6242: esalt_size = sizeof (tc_t); break;
11268 case 6243: esalt_size = sizeof (tc_t); break;
11269 case 6600: esalt_size = sizeof (agilekey_t); break;
11270 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11271 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
11272 case 7300: esalt_size = sizeof (rakp_t); break;
11273 case 7500: esalt_size = sizeof (krb5pa_t); break;
11274 case 8200: esalt_size = sizeof (cloudkey_t); break;
11275 case 8800: esalt_size = sizeof (androidfde_t); break;
11276 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
11277 case 9400: esalt_size = sizeof (office2007_t); break;
11278 case 9500: esalt_size = sizeof (office2010_t); break;
11279 case 9600: esalt_size = sizeof (office2013_t); break;
11280 case 9700: esalt_size = sizeof (oldoffice01_t); break;
11281 case 9710: esalt_size = sizeof (oldoffice01_t); break;
11282 case 9720: esalt_size = sizeof (oldoffice01_t); break;
11283 case 9800: esalt_size = sizeof (oldoffice34_t); break;
11284 case 9810: esalt_size = sizeof (oldoffice34_t); break;
11285 case 9820: esalt_size = sizeof (oldoffice34_t); break;
11286 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
11287 case 10200: esalt_size = sizeof (cram_md5_t); break;
11288 case 10400: esalt_size = sizeof (pdf_t); break;
11289 case 10410: esalt_size = sizeof (pdf_t); break;
11290 case 10420: esalt_size = sizeof (pdf_t); break;
11291 case 10500: esalt_size = sizeof (pdf_t); break;
11292 case 10600: esalt_size = sizeof (pdf_t); break;
11293 case 10700: esalt_size = sizeof (pdf_t); break;
11294 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
11295 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
11296 case 11400: esalt_size = sizeof (sip_t); break;
11297 case 11600: esalt_size = sizeof (seven_zip_t); break;
11298 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
11299 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
11300 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11301 case 13000: esalt_size = sizeof (rar5_t); break;
11302 case 13100: esalt_size = sizeof (krb5tgs_t); break;
11303 case 13400: esalt_size = sizeof (keepass_t); break;
11304 case 13500: esalt_size = sizeof (pstoken_t); break;
11305 case 13600: esalt_size = sizeof (zip2_t); break;
11306 case 13711: esalt_size = sizeof (tc_t); break;
11307 case 13712: esalt_size = sizeof (tc_t); break;
11308 case 13713: esalt_size = sizeof (tc_t); break;
11309 case 13721: esalt_size = sizeof (tc_t); break;
11310 case 13722: esalt_size = sizeof (tc_t); break;
11311 case 13723: esalt_size = sizeof (tc_t); break;
11312 case 13731: esalt_size = sizeof (tc_t); break;
11313 case 13732: esalt_size = sizeof (tc_t); break;
11314 case 13733: esalt_size = sizeof (tc_t); break;
11315 case 13741: esalt_size = sizeof (tc_t); break;
11316 case 13742: esalt_size = sizeof (tc_t); break;
11317 case 13743: esalt_size = sizeof (tc_t); break;
11318 case 13751: esalt_size = sizeof (tc_t); break;
11319 case 13752: esalt_size = sizeof (tc_t); break;
11320 case 13753: esalt_size = sizeof (tc_t); break;
11321 case 13761: esalt_size = sizeof (tc_t); break;
11322 case 13762: esalt_size = sizeof (tc_t); break;
11323 case 13763: esalt_size = sizeof (tc_t); break;
11324 case 13800: esalt_size = sizeof (win8phone_t); break;
11325 }
11326
11327 data.esalt_size = esalt_size;
11328
11329 /**
11330 * choose dictionary parser
11331 */
11332
11333 if (hash_type == HASH_TYPE_LM)
11334 {
11335 get_next_word_func = get_next_word_lm;
11336 }
11337 else if (opts_type & OPTS_TYPE_PT_UPPER)
11338 {
11339 get_next_word_func = get_next_word_uc;
11340 }
11341 else
11342 {
11343 get_next_word_func = get_next_word_std;
11344 }
11345
11346 /**
11347 * dictstat
11348 */
11349
11350 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11351
11352 #ifdef _POSIX
11353 size_t dictstat_nmemb = 0;
11354 #endif
11355
11356 #ifdef _WIN
11357 uint dictstat_nmemb = 0;
11358 #endif
11359
11360 char dictstat[256] = { 0 };
11361
11362 FILE *dictstat_fp = NULL;
11363
11364 if (keyspace == 0)
11365 {
11366 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11367
11368 dictstat_fp = fopen (dictstat, "rb");
11369
11370 if (dictstat_fp)
11371 {
11372 #ifdef _POSIX
11373 struct stat tmpstat;
11374
11375 fstat (fileno (dictstat_fp), &tmpstat);
11376 #endif
11377
11378 #ifdef _WIN
11379 struct stat64 tmpstat;
11380
11381 _fstat64 (fileno (dictstat_fp), &tmpstat);
11382 #endif
11383
11384 if (tmpstat.st_mtime < COMPTIME)
11385 {
11386 /* with v0.15 the format changed so we have to ensure user is using a good version
11387 since there is no version-header in the dictstat file */
11388
11389 fclose (dictstat_fp);
11390
11391 unlink (dictstat);
11392 }
11393 else
11394 {
11395 while (!feof (dictstat_fp))
11396 {
11397 dictstat_t d;
11398
11399 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11400
11401 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11402
11403 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11404 {
11405 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11406
11407 return -1;
11408 }
11409 }
11410
11411 fclose (dictstat_fp);
11412 }
11413 }
11414 }
11415
11416 /**
11417 * potfile
11418 */
11419
11420 char potfile[256] = { 0 };
11421
11422 if (potfile_path == NULL)
11423 {
11424 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11425 }
11426 else
11427 {
11428 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11429 }
11430
11431 data.pot_fp = NULL;
11432
11433 FILE *out_fp = NULL;
11434 FILE *pot_fp = NULL;
11435
11436 if (show == 1 || left == 1)
11437 {
11438 pot_fp = fopen (potfile, "rb");
11439
11440 if (pot_fp == NULL)
11441 {
11442 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11443
11444 return (-1);
11445 }
11446
11447 if (outfile != NULL)
11448 {
11449 if ((out_fp = fopen (outfile, "ab")) == NULL)
11450 {
11451 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11452
11453 fclose (pot_fp);
11454
11455 return (-1);
11456 }
11457 }
11458 else
11459 {
11460 out_fp = stdout;
11461 }
11462 }
11463 else
11464 {
11465 if (potfile_disable == 0)
11466 {
11467 pot_fp = fopen (potfile, "ab");
11468
11469 if (pot_fp == NULL)
11470 {
11471 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11472
11473 return (-1);
11474 }
11475
11476 data.pot_fp = pot_fp;
11477 }
11478 }
11479
11480 pot_t *pot = NULL;
11481
11482 uint pot_cnt = 0;
11483 uint pot_avail = 0;
11484
11485 if (show == 1 || left == 1)
11486 {
11487 SUPPRESS_OUTPUT = 1;
11488
11489 pot_avail = count_lines (pot_fp);
11490
11491 rewind (pot_fp);
11492
11493 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11494
11495 uint pot_hashes_avail = 0;
11496
11497 uint line_num = 0;
11498
11499 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11500
11501 while (!feof (pot_fp))
11502 {
11503 line_num++;
11504
11505 int line_len = fgetl (pot_fp, line_buf);
11506
11507 if (line_len == 0) continue;
11508
11509 char *plain_buf = line_buf + line_len;
11510
11511 pot_t *pot_ptr = &pot[pot_cnt];
11512
11513 hash_t *hashes_buf = &pot_ptr->hash;
11514
11515 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11516 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11517
11518 if (pot_cnt == pot_hashes_avail)
11519 {
11520 uint pos = 0;
11521
11522 for (pos = 0; pos < INCR_POT; pos++)
11523 {
11524 if ((pot_cnt + pos) >= pot_avail) break;
11525
11526 pot_t *tmp_pot = &pot[pot_cnt + pos];
11527
11528 hash_t *tmp_hash = &tmp_pot->hash;
11529
11530 tmp_hash->digest = mymalloc (dgst_size);
11531
11532 if (isSalted)
11533 {
11534 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11535 }
11536
11537 if (esalt_size)
11538 {
11539 tmp_hash->esalt = mymalloc (esalt_size);
11540 }
11541
11542 pot_hashes_avail++;
11543 }
11544 }
11545
11546 int plain_len = 0;
11547
11548 int parser_status;
11549
11550 int iter = MAX_CUT_TRIES;
11551
11552 do
11553 {
11554 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11555 {
11556 if (line_buf[i] == ':')
11557 {
11558 line_len--;
11559
11560 break;
11561 }
11562 }
11563
11564 if (data.hash_mode != 2500)
11565 {
11566 parser_status = parse_func (line_buf, line_len, hashes_buf);
11567 }
11568 else
11569 {
11570 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11571
11572 if (line_len > max_salt_size)
11573 {
11574 parser_status = PARSER_GLOBAL_LENGTH;
11575 }
11576 else
11577 {
11578 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11579
11580 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11581
11582 hashes_buf->salt->salt_len = line_len;
11583
11584 parser_status = PARSER_OK;
11585 }
11586 }
11587
11588 // if NOT parsed without error, we add the ":" to the plain
11589
11590 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11591 {
11592 plain_len++;
11593 plain_buf--;
11594 }
11595
11596 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11597
11598 if (parser_status < PARSER_GLOBAL_ZERO)
11599 {
11600 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11601
11602 continue;
11603 }
11604
11605 if (plain_len >= 255) continue;
11606
11607 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11608
11609 pot_ptr->plain_len = plain_len;
11610
11611 pot_cnt++;
11612 }
11613
11614 myfree (line_buf);
11615
11616 fclose (pot_fp);
11617
11618 SUPPRESS_OUTPUT = 0;
11619
11620 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11621 }
11622
11623 /**
11624 * word len
11625 */
11626
11627 uint pw_min = PW_MIN;
11628 uint pw_max = PW_MAX;
11629
11630 switch (hash_mode)
11631 {
11632 case 125: if (pw_max > 32) pw_max = 32;
11633 break;
11634 case 400: if (pw_max > 40) pw_max = 40;
11635 break;
11636 case 500: if (pw_max > 16) pw_max = 16;
11637 break;
11638 case 1500: if (pw_max > 8) pw_max = 8;
11639 break;
11640 case 1600: if (pw_max > 16) pw_max = 16;
11641 break;
11642 case 1800: if (pw_max > 16) pw_max = 16;
11643 break;
11644 case 2100: if (pw_max > 16) pw_max = 16;
11645 break;
11646 case 2500: if (pw_min < 8) pw_min = 8;
11647 break;
11648 case 3000: if (pw_max > 7) pw_max = 7;
11649 break;
11650 case 5200: if (pw_max > 24) pw_max = 24;
11651 break;
11652 case 5800: if (pw_max > 16) pw_max = 16;
11653 break;
11654 case 6300: if (pw_max > 16) pw_max = 16;
11655 break;
11656 case 7400: if (pw_max > 16) pw_max = 16;
11657 break;
11658 case 7700: if (pw_max > 8) pw_max = 8;
11659 break;
11660 case 7900: if (pw_max > 48) pw_max = 48;
11661 break;
11662 case 8500: if (pw_max > 8) pw_max = 8;
11663 break;
11664 case 8600: if (pw_max > 16) pw_max = 16;
11665 break;
11666 case 9710: pw_min = 5;
11667 pw_max = 5;
11668 break;
11669 case 9810: pw_min = 5;
11670 pw_max = 5;
11671 break;
11672 case 10410: pw_min = 5;
11673 pw_max = 5;
11674 break;
11675 case 10300: if (pw_max < 3) pw_min = 3;
11676 if (pw_max > 40) pw_max = 40;
11677 break;
11678 case 10500: if (pw_max < 3) pw_min = 3;
11679 if (pw_max > 40) pw_max = 40;
11680 break;
11681 case 10700: if (pw_max > 16) pw_max = 16;
11682 break;
11683 case 11300: if (pw_max > 40) pw_max = 40;
11684 break;
11685 case 11600: if (pw_max > 32) pw_max = 32;
11686 break;
11687 case 12500: if (pw_max > 20) pw_max = 20;
11688 break;
11689 case 12800: if (pw_max > 24) pw_max = 24;
11690 break;
11691 }
11692
11693 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11694 {
11695 switch (attack_kern)
11696 {
11697 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11698 break;
11699 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11700 break;
11701 }
11702 }
11703
11704 /**
11705 * charsets : keep them together for more easy maintainnce
11706 */
11707
11708 cs_t mp_sys[6] = { { { 0 }, 0 } };
11709 cs_t mp_usr[4] = { { { 0 }, 0 } };
11710
11711 mp_setup_sys (mp_sys);
11712
11713 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11714 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11715 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11716 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11717
11718 /**
11719 * load hashes, part I: find input mode, count hashes
11720 */
11721
11722 uint hashlist_mode = 0;
11723 uint hashlist_format = HLFMT_HASHCAT;
11724
11725 uint hashes_avail = 0;
11726
11727 if ((benchmark == 0) && (stdout_flag == 0))
11728 {
11729 struct stat f;
11730
11731 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11732
11733 if ((hash_mode == 2500) ||
11734 (hash_mode == 5200) ||
11735 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11736 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11737 (hash_mode == 9000))
11738 {
11739 hashlist_mode = HL_MODE_ARG;
11740
11741 char *hashfile = myargv[optind];
11742
11743 data.hashfile = hashfile;
11744
11745 logfile_top_var_string ("target", hashfile);
11746 }
11747
11748 if (hashlist_mode == HL_MODE_ARG)
11749 {
11750 if (hash_mode == 2500)
11751 {
11752 struct stat st;
11753
11754 if (stat (data.hashfile, &st) == -1)
11755 {
11756 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11757
11758 return (-1);
11759 }
11760
11761 hashes_avail = st.st_size / sizeof (hccap_t);
11762 }
11763 else
11764 {
11765 hashes_avail = 1;
11766 }
11767 }
11768 else if (hashlist_mode == HL_MODE_FILE)
11769 {
11770 char *hashfile = myargv[optind];
11771
11772 data.hashfile = hashfile;
11773
11774 logfile_top_var_string ("target", hashfile);
11775
11776 FILE *fp = NULL;
11777
11778 if ((fp = fopen (hashfile, "rb")) == NULL)
11779 {
11780 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11781
11782 return (-1);
11783 }
11784
11785 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11786
11787 hashes_avail = count_lines (fp);
11788
11789 rewind (fp);
11790
11791 if (hashes_avail == 0)
11792 {
11793 log_error ("ERROR: hashfile is empty or corrupt");
11794
11795 fclose (fp);
11796
11797 return (-1);
11798 }
11799
11800 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11801
11802 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11803 {
11804 log_error ("ERROR: remove not supported in native hashfile-format mode");
11805
11806 fclose (fp);
11807
11808 return (-1);
11809 }
11810
11811 fclose (fp);
11812 }
11813 }
11814 else
11815 {
11816 hashlist_mode = HL_MODE_ARG;
11817
11818 hashes_avail = 1;
11819 }
11820
11821 if (hash_mode == 3000) hashes_avail *= 2;
11822
11823 data.hashlist_mode = hashlist_mode;
11824 data.hashlist_format = hashlist_format;
11825
11826 logfile_top_uint (hashlist_mode);
11827 logfile_top_uint (hashlist_format);
11828
11829 /**
11830 * load hashes, part II: allocate required memory, set pointers
11831 */
11832
11833 hash_t *hashes_buf = NULL;
11834 void *digests_buf = NULL;
11835 salt_t *salts_buf = NULL;
11836 void *esalts_buf = NULL;
11837
11838 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11839
11840 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11841
11842 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11843 {
11844 u32 hash_pos;
11845
11846 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11847 {
11848 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11849
11850 hashes_buf[hash_pos].hash_info = hash_info;
11851
11852 if (username && (remove || show || left))
11853 {
11854 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11855 }
11856
11857 if (benchmark)
11858 {
11859 hash_info->orighash = (char *) mymalloc (256);
11860 }
11861 }
11862 }
11863
11864 if (isSalted)
11865 {
11866 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11867
11868 if (esalt_size)
11869 {
11870 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11871 }
11872 }
11873 else
11874 {
11875 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11876 }
11877
11878 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11879 {
11880 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11881
11882 if (isSalted)
11883 {
11884 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11885
11886 if (esalt_size)
11887 {
11888 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11889 }
11890 }
11891 else
11892 {
11893 hashes_buf[hash_pos].salt = &salts_buf[0];
11894 }
11895 }
11896
11897 /**
11898 * load hashes, part III: parse hashes or generate them if benchmark
11899 */
11900
11901 uint hashes_cnt = 0;
11902
11903 if (benchmark == 0)
11904 {
11905 if (keyspace == 1)
11906 {
11907 // useless to read hash file for keyspace, cheat a little bit w/ optind
11908 }
11909 else if (stdout_flag == 1)
11910 {
11911 // useless to read hash file for stdout, cheat a little bit w/ optind
11912 }
11913 else if (hashes_avail == 0)
11914 {
11915 }
11916 else if (hashlist_mode == HL_MODE_ARG)
11917 {
11918 char *input_buf = myargv[optind];
11919
11920 uint input_len = strlen (input_buf);
11921
11922 logfile_top_var_string ("target", input_buf);
11923
11924 char *hash_buf = NULL;
11925 int hash_len = 0;
11926
11927 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11928
11929 bool hash_fmt_error = 0;
11930
11931 if (hash_len < 1) hash_fmt_error = 1;
11932 if (hash_buf == NULL) hash_fmt_error = 1;
11933
11934 if (hash_fmt_error)
11935 {
11936 log_info ("WARNING: Failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11937 }
11938 else
11939 {
11940 if (opts_type & OPTS_TYPE_HASH_COPY)
11941 {
11942 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11943
11944 hash_info_tmp->orighash = mystrdup (hash_buf);
11945 }
11946
11947 if (isSalted)
11948 {
11949 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11950 }
11951
11952 int parser_status = PARSER_OK;
11953
11954 if (hash_mode == 2500)
11955 {
11956 if (hash_len == 0)
11957 {
11958 log_error ("ERROR: hccap file not specified");
11959
11960 return (-1);
11961 }
11962
11963 hashlist_mode = HL_MODE_FILE;
11964
11965 data.hashlist_mode = hashlist_mode;
11966
11967 FILE *fp = fopen (hash_buf, "rb");
11968
11969 if (fp == NULL)
11970 {
11971 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11972
11973 return (-1);
11974 }
11975
11976 if (hashes_avail < 1)
11977 {
11978 log_error ("ERROR: hccap file is empty or corrupt");
11979
11980 fclose (fp);
11981
11982 return (-1);
11983 }
11984
11985 uint hccap_size = sizeof (hccap_t);
11986
11987 char *in = (char *) mymalloc (hccap_size);
11988
11989 while (!feof (fp))
11990 {
11991 int n = fread (in, hccap_size, 1, fp);
11992
11993 if (n != 1)
11994 {
11995 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11996
11997 break;
11998 }
11999
12000 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
12001
12002 if (parser_status != PARSER_OK)
12003 {
12004 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
12005
12006 continue;
12007 }
12008
12009 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
12010
12011 if ((show == 1) || (left == 1))
12012 {
12013 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
12014
12015 char *salt_ptr = (char *) tmp_salt->salt_buf;
12016
12017 int cur_pos = tmp_salt->salt_len;
12018 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12019
12020 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
12021
12022 // do the appending task
12023
12024 snprintf (salt_ptr + cur_pos,
12025 rem_len,
12026 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
12027 wpa->orig_mac1[0],
12028 wpa->orig_mac1[1],
12029 wpa->orig_mac1[2],
12030 wpa->orig_mac1[3],
12031 wpa->orig_mac1[4],
12032 wpa->orig_mac1[5],
12033 wpa->orig_mac2[0],
12034 wpa->orig_mac2[1],
12035 wpa->orig_mac2[2],
12036 wpa->orig_mac2[3],
12037 wpa->orig_mac2[4],
12038 wpa->orig_mac2[5]);
12039
12040 // memset () the remaining part of the salt
12041
12042 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
12043 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12044
12045 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
12046
12047 tmp_salt->salt_len += 1 + 12 + 1 + 12;
12048 }
12049
12050 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);
12051 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);
12052
12053 hashes_cnt++;
12054 }
12055
12056 fclose (fp);
12057
12058 myfree (in);
12059 }
12060 else if (hash_mode == 3000)
12061 {
12062 if (hash_len == 32)
12063 {
12064 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12065
12066 hash_t *lm_hash_left = NULL;
12067
12068 if (parser_status == PARSER_OK)
12069 {
12070 lm_hash_left = &hashes_buf[hashes_cnt];
12071
12072 hashes_cnt++;
12073 }
12074 else
12075 {
12076 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12077 }
12078
12079 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12080
12081 hash_t *lm_hash_right = NULL;
12082
12083 if (parser_status == PARSER_OK)
12084 {
12085 lm_hash_right = &hashes_buf[hashes_cnt];
12086
12087 hashes_cnt++;
12088 }
12089 else
12090 {
12091 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12092 }
12093
12094 // show / left
12095
12096 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12097 {
12098 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);
12099 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);
12100 }
12101 }
12102 else
12103 {
12104 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12105
12106 if (parser_status == PARSER_OK)
12107 {
12108 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12109 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12110 }
12111
12112 if (parser_status == PARSER_OK)
12113 {
12114 hashes_cnt++;
12115 }
12116 else
12117 {
12118 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12119 }
12120 }
12121 }
12122 else
12123 {
12124 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12125
12126 if (parser_status == PARSER_OK)
12127 {
12128 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12129 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12130 }
12131
12132 if (parser_status == PARSER_OK)
12133 {
12134 hashes_cnt++;
12135 }
12136 else
12137 {
12138 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12139 }
12140 }
12141 }
12142 }
12143 else if (hashlist_mode == HL_MODE_FILE)
12144 {
12145 char *hashfile = data.hashfile;
12146
12147 FILE *fp;
12148
12149 if ((fp = fopen (hashfile, "rb")) == NULL)
12150 {
12151 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12152
12153 return (-1);
12154 }
12155
12156 uint line_num = 0;
12157
12158 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12159
12160 while (!feof (fp))
12161 {
12162 line_num++;
12163
12164 int line_len = fgetl (fp, line_buf);
12165
12166 if (line_len == 0) continue;
12167
12168 char *hash_buf = NULL;
12169 int hash_len = 0;
12170
12171 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12172
12173 bool hash_fmt_error = 0;
12174
12175 if (hash_len < 1) hash_fmt_error = 1;
12176 if (hash_buf == NULL) hash_fmt_error = 1;
12177
12178 if (hash_fmt_error)
12179 {
12180 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12181
12182 continue;
12183 }
12184
12185 if (username)
12186 {
12187 char *user_buf = NULL;
12188 int user_len = 0;
12189
12190 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12191
12192 if (remove || show)
12193 {
12194 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12195
12196 *user = (user_t *) mymalloc (sizeof (user_t));
12197
12198 user_t *user_ptr = *user;
12199
12200 if (user_buf != NULL)
12201 {
12202 user_ptr->user_name = mystrdup (user_buf);
12203 }
12204 else
12205 {
12206 user_ptr->user_name = mystrdup ("");
12207 }
12208
12209 user_ptr->user_len = user_len;
12210 }
12211 }
12212
12213 if (opts_type & OPTS_TYPE_HASH_COPY)
12214 {
12215 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12216
12217 hash_info_tmp->orighash = mystrdup (hash_buf);
12218 }
12219
12220 if (isSalted)
12221 {
12222 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12223 }
12224
12225 if (hash_mode == 3000)
12226 {
12227 if (hash_len == 32)
12228 {
12229 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12230
12231 if (parser_status < PARSER_GLOBAL_ZERO)
12232 {
12233 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12234
12235 continue;
12236 }
12237
12238 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12239
12240 hashes_cnt++;
12241
12242 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12243
12244 if (parser_status < PARSER_GLOBAL_ZERO)
12245 {
12246 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12247
12248 continue;
12249 }
12250
12251 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12252
12253 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);
12254
12255 hashes_cnt++;
12256
12257 // show / left
12258
12259 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);
12260 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);
12261 }
12262 else
12263 {
12264 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12265
12266 if (parser_status < PARSER_GLOBAL_ZERO)
12267 {
12268 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12269
12270 continue;
12271 }
12272
12273 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);
12274
12275 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12276 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12277
12278 hashes_cnt++;
12279 }
12280 }
12281 else
12282 {
12283 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12284
12285 if (parser_status < PARSER_GLOBAL_ZERO)
12286 {
12287 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12288
12289 continue;
12290 }
12291
12292 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
12293
12294 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12295 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12296
12297 hashes_cnt++;
12298 }
12299 }
12300
12301 myfree (line_buf);
12302
12303 fclose (fp);
12304
12305 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12306
12307 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12308 }
12309 }
12310 else
12311 {
12312 if (isSalted)
12313 {
12314 hashes_buf[0].salt->salt_len = 8;
12315
12316 // special salt handling
12317
12318 switch (hash_mode)
12319 {
12320 case 1500: hashes_buf[0].salt->salt_len = 2;
12321 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12322 break;
12323 case 1731: hashes_buf[0].salt->salt_len = 4;
12324 break;
12325 case 2410: hashes_buf[0].salt->salt_len = 4;
12326 break;
12327 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12328 break;
12329 case 3100: hashes_buf[0].salt->salt_len = 1;
12330 break;
12331 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
12332 break;
12333 case 5800: hashes_buf[0].salt->salt_len = 16;
12334 break;
12335 case 6800: hashes_buf[0].salt->salt_len = 32;
12336 break;
12337 case 8400: hashes_buf[0].salt->salt_len = 40;
12338 break;
12339 case 8800: hashes_buf[0].salt->salt_len = 16;
12340 break;
12341 case 8900: hashes_buf[0].salt->salt_len = 16;
12342 hashes_buf[0].salt->scrypt_N = 1024;
12343 hashes_buf[0].salt->scrypt_r = 1;
12344 hashes_buf[0].salt->scrypt_p = 1;
12345 break;
12346 case 9100: hashes_buf[0].salt->salt_len = 16;
12347 break;
12348 case 9300: hashes_buf[0].salt->salt_len = 14;
12349 hashes_buf[0].salt->scrypt_N = 16384;
12350 hashes_buf[0].salt->scrypt_r = 1;
12351 hashes_buf[0].salt->scrypt_p = 1;
12352 break;
12353 case 9400: hashes_buf[0].salt->salt_len = 16;
12354 break;
12355 case 9500: hashes_buf[0].salt->salt_len = 16;
12356 break;
12357 case 9600: hashes_buf[0].salt->salt_len = 16;
12358 break;
12359 case 9700: hashes_buf[0].salt->salt_len = 16;
12360 break;
12361 case 9710: hashes_buf[0].salt->salt_len = 16;
12362 break;
12363 case 9720: hashes_buf[0].salt->salt_len = 16;
12364 break;
12365 case 9800: hashes_buf[0].salt->salt_len = 16;
12366 break;
12367 case 9810: hashes_buf[0].salt->salt_len = 16;
12368 break;
12369 case 9820: hashes_buf[0].salt->salt_len = 16;
12370 break;
12371 case 10300: hashes_buf[0].salt->salt_len = 12;
12372 break;
12373 case 11500: hashes_buf[0].salt->salt_len = 4;
12374 break;
12375 case 11600: hashes_buf[0].salt->salt_len = 4;
12376 break;
12377 case 12400: hashes_buf[0].salt->salt_len = 4;
12378 break;
12379 case 12500: hashes_buf[0].salt->salt_len = 8;
12380 break;
12381 case 12600: hashes_buf[0].salt->salt_len = 64;
12382 break;
12383 }
12384
12385 // special esalt handling
12386
12387 switch (hash_mode)
12388 {
12389 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12390 break;
12391 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12392 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12393 break;
12394 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12395 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12396 break;
12397 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12398 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12399 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12400 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12401 break;
12402 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12403 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12404 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12405 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12406 break;
12407 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12408 break;
12409 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12410 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12411 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12412 break;
12413 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12414 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12415 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12416 break;
12417 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12418 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12419 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12420 break;
12421 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12422 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12423 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12424 break;
12425 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12426 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12427 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12428 break;
12429 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12430 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12431 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12432 break;
12433 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12434 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12435 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12436 break;
12437 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12438 break;
12439 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12440 break;
12441 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12442 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12443 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12444 break;
12445 }
12446 }
12447
12448 // set hashfile
12449
12450 switch (hash_mode)
12451 {
12452 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12453 break;
12454 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12455 break;
12456 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12457 break;
12458 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12459 break;
12460 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12461 break;
12462 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12463 break;
12464 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12465 break;
12466 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12467 break;
12468 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12469 break;
12470 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12471 break;
12472 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12473 break;
12474 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12475 break;
12476 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12477 break;
12478 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12479 break;
12480 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12481 break;
12482 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12483 break;
12484 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12485 break;
12486 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12487 break;
12488 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12489 break;
12490 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12491 break;
12492 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12493 break;
12494 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12495 break;
12496 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12497 break;
12498 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12499 break;
12500 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12501 break;
12502 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12503 break;
12504 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12505 break;
12506 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12507 break;
12508 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12509 break;
12510 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12511 break;
12512 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12513 break;
12514 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12515 break;
12516 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12517 break;
12518 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12519 break;
12520 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12521 break;
12522 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12523 break;
12524 }
12525
12526 // set default iterations
12527
12528 switch (hash_mode)
12529 {
12530 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12531 break;
12532 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12533 break;
12534 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12535 break;
12536 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12537 break;
12538 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12539 break;
12540 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12541 break;
12542 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12543 break;
12544 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12545 break;
12546 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12547 break;
12548 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12549 break;
12550 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12551 break;
12552 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12553 break;
12554 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12555 break;
12556 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12557 break;
12558 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12559 break;
12560 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12561 break;
12562 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12563 break;
12564 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12565 break;
12566 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12567 break;
12568 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12569 break;
12570 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12571 break;
12572 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12573 break;
12574 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12575 break;
12576 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12577 break;
12578 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12579 break;
12580 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12581 break;
12582 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12583 break;
12584 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12585 break;
12586 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12587 break;
12588 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12589 break;
12590 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12591 break;
12592 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12593 break;
12594 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12595 break;
12596 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12597 break;
12598 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12599 break;
12600 case 8900: hashes_buf[0].salt->salt_iter = 1;
12601 break;
12602 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12603 break;
12604 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12605 break;
12606 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12607 break;
12608 case 9300: hashes_buf[0].salt->salt_iter = 1;
12609 break;
12610 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12611 break;
12612 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12613 break;
12614 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12615 break;
12616 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12617 break;
12618 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12619 break;
12620 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12621 break;
12622 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12623 break;
12624 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12625 break;
12626 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12627 break;
12628 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12629 break;
12630 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12631 break;
12632 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12633 break;
12634 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12635 break;
12636 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12637 break;
12638 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12639 break;
12640 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12641 break;
12642 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12643 break;
12644 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12645 break;
12646 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12647 break;
12648 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12649 break;
12650 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12651 break;
12652 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12653 break;
12654 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12655 break;
12656 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12657 break;
12658 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12659 break;
12660 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12661 break;
12662 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12663 break;
12664 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12665 break;
12666 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12667 break;
12668 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12669 break;
12670 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12671 break;
12672 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12673 break;
12674 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12675 break;
12676 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12677 break;
12678 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12679 break;
12680 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12681 break;
12682 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12683 break;
12684 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12685 break;
12686 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12687 break;
12688 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12689 break;
12690 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12691 break;
12692 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12693 break;
12694 }
12695
12696 hashes_cnt = 1;
12697 }
12698
12699 if (show == 1 || left == 1)
12700 {
12701 for (uint i = 0; i < pot_cnt; i++)
12702 {
12703 pot_t *pot_ptr = &pot[i];
12704
12705 hash_t *hashes_buf = &pot_ptr->hash;
12706
12707 local_free (hashes_buf->digest);
12708
12709 if (isSalted)
12710 {
12711 local_free (hashes_buf->salt);
12712 }
12713 }
12714
12715 local_free (pot);
12716
12717 if (data.quiet == 0) log_info_nn ("");
12718
12719 return (0);
12720 }
12721
12722 if ((keyspace == 0) && (stdout_flag == 0))
12723 {
12724 if (hashes_cnt == 0)
12725 {
12726 log_error ("ERROR: No hashes loaded");
12727
12728 return (-1);
12729 }
12730 }
12731
12732 /**
12733 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12734 */
12735
12736 if (data.outfile != NULL)
12737 {
12738 if (data.hashfile != NULL)
12739 {
12740 #ifdef _POSIX
12741 struct stat tmpstat_outfile;
12742 struct stat tmpstat_hashfile;
12743 #endif
12744
12745 #ifdef _WIN
12746 struct stat64 tmpstat_outfile;
12747 struct stat64 tmpstat_hashfile;
12748 #endif
12749
12750 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12751
12752 if (tmp_outfile_fp)
12753 {
12754 #ifdef _POSIX
12755 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12756 #endif
12757
12758 #ifdef _WIN
12759 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12760 #endif
12761
12762 fclose (tmp_outfile_fp);
12763 }
12764
12765 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12766
12767 if (tmp_hashfile_fp)
12768 {
12769 #ifdef _POSIX
12770 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12771 #endif
12772
12773 #ifdef _WIN
12774 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12775 #endif
12776
12777 fclose (tmp_hashfile_fp);
12778 }
12779
12780 if (tmp_outfile_fp && tmp_outfile_fp)
12781 {
12782 tmpstat_outfile.st_mode = 0;
12783 tmpstat_outfile.st_nlink = 0;
12784 tmpstat_outfile.st_uid = 0;
12785 tmpstat_outfile.st_gid = 0;
12786 tmpstat_outfile.st_rdev = 0;
12787 tmpstat_outfile.st_atime = 0;
12788
12789 tmpstat_hashfile.st_mode = 0;
12790 tmpstat_hashfile.st_nlink = 0;
12791 tmpstat_hashfile.st_uid = 0;
12792 tmpstat_hashfile.st_gid = 0;
12793 tmpstat_hashfile.st_rdev = 0;
12794 tmpstat_hashfile.st_atime = 0;
12795
12796 #ifdef _POSIX
12797 tmpstat_outfile.st_blksize = 0;
12798 tmpstat_outfile.st_blocks = 0;
12799
12800 tmpstat_hashfile.st_blksize = 0;
12801 tmpstat_hashfile.st_blocks = 0;
12802 #endif
12803
12804 #ifdef _POSIX
12805 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12806 {
12807 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12808
12809 return (-1);
12810 }
12811 #endif
12812
12813 #ifdef _WIN
12814 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12815 {
12816 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12817
12818 return (-1);
12819 }
12820 #endif
12821 }
12822 }
12823 }
12824
12825 /**
12826 * Remove duplicates
12827 */
12828
12829 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12830
12831 if (isSalted)
12832 {
12833 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12834 }
12835 else
12836 {
12837 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12838 }
12839
12840 uint hashes_cnt_orig = hashes_cnt;
12841
12842 hashes_cnt = 1;
12843
12844 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12845 {
12846 if (isSalted)
12847 {
12848 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12849 {
12850 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12851 }
12852 }
12853 else
12854 {
12855 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12856 }
12857
12858 if (hashes_pos > hashes_cnt)
12859 {
12860 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12861 }
12862
12863 hashes_cnt++;
12864 }
12865
12866 /**
12867 * Potfile removes
12868 */
12869
12870 uint potfile_remove_cracks = 0;
12871
12872 if (potfile_disable == 0)
12873 {
12874 hash_t hash_buf;
12875
12876 hash_buf.digest = mymalloc (dgst_size);
12877 hash_buf.salt = NULL;
12878 hash_buf.esalt = NULL;
12879 hash_buf.hash_info = NULL;
12880 hash_buf.cracked = 0;
12881
12882 if (isSalted)
12883 {
12884 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12885 }
12886
12887 if (esalt_size)
12888 {
12889 hash_buf.esalt = mymalloc (esalt_size);
12890 }
12891
12892 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12893
12894 // no solution for these special hash types (for instane because they use hashfile in output etc)
12895 if ((hash_mode != 5200) &&
12896 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12897 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12898 (hash_mode != 9000))
12899 {
12900 FILE *fp = fopen (potfile, "rb");
12901
12902 if (fp != NULL)
12903 {
12904 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12905
12906 // to be safe work with a copy (because of line_len loop, i etc)
12907 // moved up here because it's easier to handle continue case
12908 // it's just 64kb
12909
12910 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12911
12912 while (!feof (fp))
12913 {
12914 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12915
12916 if (ptr == NULL) break;
12917
12918 int line_len = strlen (line_buf);
12919
12920 if (line_len == 0) continue;
12921
12922 int iter = MAX_CUT_TRIES;
12923
12924 for (int i = line_len - 1; i && iter; i--, line_len--)
12925 {
12926 if (line_buf[i] != ':') continue;
12927
12928 if (isSalted)
12929 {
12930 memset (hash_buf.salt, 0, sizeof (salt_t));
12931 }
12932
12933 hash_t *found = NULL;
12934
12935 if (hash_mode == 6800)
12936 {
12937 if (i < 64) // 64 = 16 * uint in salt_buf[]
12938 {
12939 // manipulate salt_buf
12940 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12941
12942 hash_buf.salt->salt_len = i;
12943
12944 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12945 }
12946 }
12947 else if (hash_mode == 2500)
12948 {
12949 if (i < 64) // 64 = 16 * uint in salt_buf[]
12950 {
12951 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12952 // manipulate salt_buf
12953
12954 memcpy (line_buf_cpy, line_buf, i);
12955
12956 char *mac2_pos = strrchr (line_buf_cpy, ':');
12957
12958 if (mac2_pos == NULL) continue;
12959
12960 mac2_pos[0] = 0;
12961 mac2_pos++;
12962
12963 if (strlen (mac2_pos) != 12) continue;
12964
12965 char *mac1_pos = strrchr (line_buf_cpy, ':');
12966
12967 if (mac1_pos == NULL) continue;
12968
12969 mac1_pos[0] = 0;
12970 mac1_pos++;
12971
12972 if (strlen (mac1_pos) != 12) continue;
12973
12974 uint essid_length = mac1_pos - line_buf_cpy - 1;
12975
12976 // here we need the ESSID
12977 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12978
12979 hash_buf.salt->salt_len = essid_length;
12980
12981 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12982
12983 if (found)
12984 {
12985 wpa_t *wpa = (wpa_t *) found->esalt;
12986
12987 // compare hex string(s) vs binary MAC address(es)
12988
12989 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12990 {
12991 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12992 {
12993 found = NULL;
12994
12995 break;
12996 }
12997 }
12998
12999 // early skip ;)
13000 if (!found) continue;
13001
13002 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13003 {
13004 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
13005 {
13006 found = NULL;
13007
13008 break;
13009 }
13010 }
13011 }
13012 }
13013 }
13014 else
13015 {
13016 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
13017
13018 if (parser_status == PARSER_OK)
13019 {
13020 if (isSalted)
13021 {
13022 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
13023 }
13024 else
13025 {
13026 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
13027 }
13028 }
13029 }
13030
13031 if (found == NULL) continue;
13032
13033 if (!found->cracked) potfile_remove_cracks++;
13034
13035 found->cracked = 1;
13036
13037 if (found) break;
13038
13039 iter--;
13040 }
13041 }
13042
13043 myfree (line_buf_cpy);
13044
13045 myfree (line_buf);
13046
13047 fclose (fp);
13048 }
13049 }
13050
13051 if (esalt_size)
13052 {
13053 local_free (hash_buf.esalt);
13054 }
13055
13056 if (isSalted)
13057 {
13058 local_free (hash_buf.salt);
13059 }
13060
13061 local_free (hash_buf.digest);
13062 }
13063
13064 /**
13065 * Now generate all the buffers required for later
13066 */
13067
13068 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
13069
13070 salt_t *salts_buf_new = NULL;
13071 void *esalts_buf_new = NULL;
13072
13073 if (isSalted)
13074 {
13075 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
13076
13077 if (esalt_size)
13078 {
13079 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
13080 }
13081 }
13082 else
13083 {
13084 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13085 }
13086
13087 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13088
13089 uint digests_cnt = hashes_cnt;
13090 uint digests_done = 0;
13091
13092 size_t size_digests = digests_cnt * dgst_size;
13093 size_t size_shown = digests_cnt * sizeof (uint);
13094
13095 uint *digests_shown = (uint *) mymalloc (size_shown);
13096 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13097
13098 uint salts_cnt = 0;
13099 uint salts_done = 0;
13100
13101 hashinfo_t **hash_info = NULL;
13102
13103 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13104 {
13105 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13106
13107 if (username && (remove || show))
13108 {
13109 uint user_pos;
13110
13111 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13112 {
13113 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13114
13115 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13116 }
13117 }
13118 }
13119
13120 uint *salts_shown = (uint *) mymalloc (size_shown);
13121
13122 salt_t *salt_buf;
13123
13124 {
13125 // copied from inner loop
13126
13127 salt_buf = &salts_buf_new[salts_cnt];
13128
13129 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13130
13131 if (esalt_size)
13132 {
13133 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13134 }
13135
13136 salt_buf->digests_cnt = 0;
13137 salt_buf->digests_done = 0;
13138 salt_buf->digests_offset = 0;
13139
13140 salts_cnt++;
13141 }
13142
13143 if (hashes_buf[0].cracked == 1)
13144 {
13145 digests_shown[0] = 1;
13146
13147 digests_done++;
13148
13149 salt_buf->digests_done++;
13150 }
13151
13152 salt_buf->digests_cnt++;
13153
13154 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13155
13156 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13157 {
13158 hash_info[0] = hashes_buf[0].hash_info;
13159 }
13160
13161 // copy from inner loop
13162
13163 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13164 {
13165 if (isSalted)
13166 {
13167 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13168 {
13169 salt_buf = &salts_buf_new[salts_cnt];
13170
13171 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13172
13173 if (esalt_size)
13174 {
13175 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13176 }
13177
13178 salt_buf->digests_cnt = 0;
13179 salt_buf->digests_done = 0;
13180 salt_buf->digests_offset = hashes_pos;
13181
13182 salts_cnt++;
13183 }
13184 }
13185
13186 if (hashes_buf[hashes_pos].cracked == 1)
13187 {
13188 digests_shown[hashes_pos] = 1;
13189
13190 digests_done++;
13191
13192 salt_buf->digests_done++;
13193 }
13194
13195 salt_buf->digests_cnt++;
13196
13197 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13198
13199 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13200 {
13201 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13202 }
13203 }
13204
13205 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13206 {
13207 salt_t *salt_buf = &salts_buf_new[salt_pos];
13208
13209 if (salt_buf->digests_done == salt_buf->digests_cnt)
13210 {
13211 salts_shown[salt_pos] = 1;
13212
13213 salts_done++;
13214 }
13215
13216 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13217 }
13218
13219 local_free (digests_buf);
13220 local_free (salts_buf);
13221 local_free (esalts_buf);
13222
13223 digests_buf = digests_buf_new;
13224 salts_buf = salts_buf_new;
13225 esalts_buf = esalts_buf_new;
13226
13227 local_free (hashes_buf);
13228
13229 /**
13230 * special modification not set from parser
13231 */
13232
13233 switch (hash_mode)
13234 {
13235 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13236 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13237 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13238 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13239 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13240 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13241 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13242 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13243 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13244 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13245 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13246 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13247 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13248 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13249 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13250 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13251 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13252 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13253 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13254 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13255 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13256 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13257 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13258 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13259 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13260 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13261 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13262 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13263 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13264 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13265 }
13266
13267 if (truecrypt_keyfiles)
13268 {
13269 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13270
13271 char *keyfiles = strdup (truecrypt_keyfiles);
13272
13273 char *keyfile = strtok (keyfiles, ",");
13274
13275 do
13276 {
13277 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13278
13279 } while ((keyfile = strtok (NULL, ",")) != NULL);
13280
13281 free (keyfiles);
13282 }
13283
13284 if (veracrypt_keyfiles)
13285 {
13286 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13287
13288 char *keyfiles = strdup (veracrypt_keyfiles);
13289
13290 char *keyfile = strtok (keyfiles, ",");
13291
13292 do
13293 {
13294 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13295
13296 } while ((keyfile = strtok (NULL, ",")) != NULL);
13297
13298 free (keyfiles);
13299 }
13300
13301 data.digests_cnt = digests_cnt;
13302 data.digests_done = digests_done;
13303 data.digests_buf = digests_buf;
13304 data.digests_shown = digests_shown;
13305 data.digests_shown_tmp = digests_shown_tmp;
13306
13307 data.salts_cnt = salts_cnt;
13308 data.salts_done = salts_done;
13309 data.salts_buf = salts_buf;
13310 data.salts_shown = salts_shown;
13311
13312 data.esalts_buf = esalts_buf;
13313 data.hash_info = hash_info;
13314
13315 /**
13316 * Automatic Optimizers
13317 */
13318
13319 if (salts_cnt == 1)
13320 opti_type |= OPTI_TYPE_SINGLE_SALT;
13321
13322 if (digests_cnt == 1)
13323 opti_type |= OPTI_TYPE_SINGLE_HASH;
13324
13325 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13326 opti_type |= OPTI_TYPE_NOT_ITERATED;
13327
13328 if (attack_mode == ATTACK_MODE_BF)
13329 opti_type |= OPTI_TYPE_BRUTE_FORCE;
13330
13331 data.opti_type = opti_type;
13332
13333 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13334 {
13335 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13336 {
13337 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13338 {
13339 if (opts_type & OPTS_TYPE_ST_ADD80)
13340 {
13341 opts_type &= ~OPTS_TYPE_ST_ADD80;
13342 opts_type |= OPTS_TYPE_PT_ADD80;
13343 }
13344
13345 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13346 {
13347 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13348 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13349 }
13350
13351 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13352 {
13353 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13354 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13355 }
13356 }
13357 }
13358 }
13359
13360 /**
13361 * Some algorithm, like descrypt, can benefit from JIT compilation
13362 */
13363
13364 int force_jit_compilation = -1;
13365
13366 if (hash_mode == 8900)
13367 {
13368 force_jit_compilation = 8900;
13369 }
13370 else if (hash_mode == 9300)
13371 {
13372 force_jit_compilation = 8900;
13373 }
13374 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13375 {
13376 force_jit_compilation = 1500;
13377 }
13378
13379 /**
13380 * generate bitmap tables
13381 */
13382
13383 const uint bitmap_shift1 = 5;
13384 const uint bitmap_shift2 = 13;
13385
13386 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13387
13388 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13389 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13390 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13391 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13392 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13393 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13394 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13395 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13396
13397 uint bitmap_bits;
13398 uint bitmap_nums;
13399 uint bitmap_mask;
13400 uint bitmap_size;
13401
13402 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13403 {
13404 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13405
13406 bitmap_nums = 1 << bitmap_bits;
13407
13408 bitmap_mask = bitmap_nums - 1;
13409
13410 bitmap_size = bitmap_nums * sizeof (uint);
13411
13412 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13413
13414 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;
13415 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;
13416
13417 break;
13418 }
13419
13420 bitmap_nums = 1 << bitmap_bits;
13421
13422 bitmap_mask = bitmap_nums - 1;
13423
13424 bitmap_size = bitmap_nums * sizeof (uint);
13425
13426 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);
13427 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);
13428
13429 /**
13430 * prepare quick rule
13431 */
13432
13433 data.rule_buf_l = rule_buf_l;
13434 data.rule_buf_r = rule_buf_r;
13435
13436 int rule_len_l = (int) strlen (rule_buf_l);
13437 int rule_len_r = (int) strlen (rule_buf_r);
13438
13439 data.rule_len_l = rule_len_l;
13440 data.rule_len_r = rule_len_r;
13441
13442 /**
13443 * load rules
13444 */
13445
13446 uint *all_kernel_rules_cnt = NULL;
13447
13448 kernel_rule_t **all_kernel_rules_buf = NULL;
13449
13450 if (rp_files_cnt)
13451 {
13452 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13453
13454 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13455 }
13456
13457 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13458
13459 int rule_len = 0;
13460
13461 for (uint i = 0; i < rp_files_cnt; i++)
13462 {
13463 uint kernel_rules_avail = 0;
13464
13465 uint kernel_rules_cnt = 0;
13466
13467 kernel_rule_t *kernel_rules_buf = NULL;
13468
13469 char *rp_file = rp_files[i];
13470
13471 char in[BLOCK_SIZE] = { 0 };
13472 char out[BLOCK_SIZE] = { 0 };
13473
13474 FILE *fp = NULL;
13475
13476 uint rule_line = 0;
13477
13478 if ((fp = fopen (rp_file, "rb")) == NULL)
13479 {
13480 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13481
13482 return (-1);
13483 }
13484
13485 while (!feof (fp))
13486 {
13487 memset (rule_buf, 0, HCBUFSIZ);
13488
13489 rule_len = fgetl (fp, rule_buf);
13490
13491 rule_line++;
13492
13493 if (rule_len == 0) continue;
13494
13495 if (rule_buf[0] == '#') continue;
13496
13497 if (kernel_rules_avail == kernel_rules_cnt)
13498 {
13499 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13500
13501 kernel_rules_avail += INCR_RULES;
13502 }
13503
13504 memset (in, 0, BLOCK_SIZE);
13505 memset (out, 0, BLOCK_SIZE);
13506
13507 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13508
13509 if (result == -1)
13510 {
13511 log_info ("WARNING: Skipping invalid or unsupported rule in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13512
13513 continue;
13514 }
13515
13516 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13517 {
13518 log_info ("WARNING: Cannot convert rule for use on device in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13519
13520 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13521
13522 continue;
13523 }
13524
13525 /* its so slow
13526 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13527 {
13528 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13529
13530 continue;
13531 }
13532 */
13533
13534 kernel_rules_cnt++;
13535 }
13536
13537 fclose (fp);
13538
13539 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13540
13541 all_kernel_rules_buf[i] = kernel_rules_buf;
13542 }
13543
13544 /**
13545 * merge rules or automatic rule generator
13546 */
13547
13548 uint kernel_rules_cnt = 0;
13549
13550 kernel_rule_t *kernel_rules_buf = NULL;
13551
13552 if (attack_mode == ATTACK_MODE_STRAIGHT)
13553 {
13554 if (rp_files_cnt)
13555 {
13556 kernel_rules_cnt = 1;
13557
13558 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13559
13560 repeats[0] = kernel_rules_cnt;
13561
13562 for (uint i = 0; i < rp_files_cnt; i++)
13563 {
13564 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13565
13566 repeats[i + 1] = kernel_rules_cnt;
13567 }
13568
13569 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13570
13571 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13572
13573 for (uint i = 0; i < kernel_rules_cnt; i++)
13574 {
13575 uint out_pos = 0;
13576
13577 kernel_rule_t *out = &kernel_rules_buf[i];
13578
13579 for (uint j = 0; j < rp_files_cnt; j++)
13580 {
13581 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13582 uint in_pos;
13583
13584 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13585
13586 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13587 {
13588 if (out_pos == RULES_MAX - 1)
13589 {
13590 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13591
13592 break;
13593 }
13594
13595 out->cmds[out_pos] = in->cmds[in_pos];
13596 }
13597 }
13598 }
13599
13600 local_free (repeats);
13601 }
13602 else if (rp_gen)
13603 {
13604 uint kernel_rules_avail = 0;
13605
13606 while (kernel_rules_cnt < rp_gen)
13607 {
13608 if (kernel_rules_avail == kernel_rules_cnt)
13609 {
13610 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13611
13612 kernel_rules_avail += INCR_RULES;
13613 }
13614
13615 memset (rule_buf, 0, HCBUFSIZ);
13616
13617 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13618
13619 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13620
13621 kernel_rules_cnt++;
13622 }
13623 }
13624 }
13625
13626 myfree (rule_buf);
13627
13628 /**
13629 * generate NOP rules
13630 */
13631
13632 if (kernel_rules_cnt == 0)
13633 {
13634 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13635
13636 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13637
13638 kernel_rules_cnt++;
13639 }
13640
13641 data.kernel_rules_cnt = kernel_rules_cnt;
13642 data.kernel_rules_buf = kernel_rules_buf;
13643
13644 /**
13645 * OpenCL platforms: detect
13646 */
13647
13648 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13649 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13650
13651 cl_uint platforms_cnt = 0;
13652 cl_uint platform_devices_cnt = 0;
13653
13654 if (keyspace == 0)
13655 {
13656 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13657
13658 if (platforms_cnt == 0)
13659 {
13660 log_info ("");
13661 log_info ("ATTENTION! No OpenCL compatible platform found");
13662 log_info ("");
13663 log_info ("You're probably missing the OpenCL runtime installation");
13664 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13665 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13666 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13667 log_info ("");
13668
13669 return (-1);
13670 }
13671
13672 if (opencl_platforms_filter != (uint) -1)
13673 {
13674 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13675
13676 if (opencl_platforms_filter > platform_cnt_mask)
13677 {
13678 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13679
13680 return (-1);
13681 }
13682 }
13683 }
13684
13685 if (opencl_device_types == NULL)
13686 {
13687 /**
13688 * OpenCL device types:
13689 * 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.
13690 */
13691
13692 cl_device_type device_types_all = 0;
13693
13694 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13695 {
13696 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13697
13698 cl_platform_id platform = platforms[platform_id];
13699
13700 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13701
13702 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13703 {
13704 cl_device_id device = platform_devices[platform_devices_id];
13705
13706 cl_device_type device_type;
13707
13708 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13709
13710 device_types_all |= device_type;
13711 }
13712 }
13713
13714 // In such a case, automatically enable CPU device type support, since it's disabled by default.
13715
13716 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13717 {
13718 device_types_filter |= CL_DEVICE_TYPE_CPU;
13719 }
13720
13721 // In another case, when the user uses --stdout, using CPU devices is much faster to setup
13722 // If we have a CPU device, force it to be used
13723
13724 if (stdout_flag == 1)
13725 {
13726 if (device_types_all & CL_DEVICE_TYPE_CPU)
13727 {
13728 device_types_filter = CL_DEVICE_TYPE_CPU;
13729 }
13730 }
13731 }
13732
13733 /**
13734 * OpenCL devices: simply push all devices from all platforms into the same device array
13735 */
13736
13737 int need_adl = 0;
13738 int need_nvapi = 0;
13739 int need_nvml = 0;
13740 int need_xnvctrl = 0;
13741
13742 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13743
13744 data.devices_param = devices_param;
13745
13746 uint devices_cnt = 0;
13747
13748 uint devices_active = 0;
13749
13750 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13751 {
13752 cl_platform_id platform = platforms[platform_id];
13753
13754 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13755
13756 char platform_vendor[INFOSZ] = { 0 };
13757
13758 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13759
13760 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13761 // this causes trouble with vendor id based macros
13762 // we'll assign generic to those without special optimization available
13763
13764 cl_uint platform_vendor_id = 0;
13765
13766 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13767 {
13768 platform_vendor_id = VENDOR_ID_AMD;
13769 }
13770 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13771 {
13772 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13773 }
13774 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13775 {
13776 platform_vendor_id = VENDOR_ID_APPLE;
13777 }
13778 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13779 {
13780 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13781 }
13782 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13783 {
13784 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13785 }
13786 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13787 {
13788 platform_vendor_id = VENDOR_ID_MESA;
13789 }
13790 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13791 {
13792 platform_vendor_id = VENDOR_ID_NV;
13793 }
13794 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13795 {
13796 platform_vendor_id = VENDOR_ID_POCL;
13797 }
13798 else
13799 {
13800 platform_vendor_id = VENDOR_ID_GENERIC;
13801 }
13802
13803 const uint platform_skipped = ((opencl_platforms_filter & (1 << platform_id)) == 0);
13804
13805 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13806 {
13807 if (machine_readable == 0)
13808 {
13809 if (platform_skipped == 0)
13810 {
13811 const int len = log_info ("OpenCL Platform #%u: %s", platform_id + 1, platform_vendor);
13812
13813 char line[256] = { 0 };
13814
13815 for (int i = 0; i < len; i++) line[i] = '=';
13816
13817 log_info (line);
13818 }
13819 else
13820 {
13821 log_info ("OpenCL Platform #%u: %s, skipped", platform_id + 1, platform_vendor);
13822 log_info ("");
13823 }
13824 }
13825 }
13826
13827 if (platform_skipped == 1) continue;
13828
13829 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13830 {
13831 size_t param_value_size = 0;
13832
13833 const uint device_id = devices_cnt;
13834
13835 hc_device_param_t *device_param = &data.devices_param[device_id];
13836
13837 device_param->platform_vendor_id = platform_vendor_id;
13838
13839 device_param->device = platform_devices[platform_devices_id];
13840
13841 device_param->device_id = device_id;
13842
13843 device_param->platform_devices_id = platform_devices_id;
13844
13845 // device_type
13846
13847 cl_device_type device_type;
13848
13849 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13850
13851 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13852
13853 device_param->device_type = device_type;
13854
13855 // device_name
13856
13857 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13858
13859 char *device_name = (char *) mymalloc (param_value_size);
13860
13861 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13862
13863 device_param->device_name = device_name;
13864
13865 // device_vendor
13866
13867 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13868
13869 char *device_vendor = (char *) mymalloc (param_value_size);
13870
13871 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13872
13873 device_param->device_vendor = device_vendor;
13874
13875 cl_uint device_vendor_id = 0;
13876
13877 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13878 {
13879 device_vendor_id = VENDOR_ID_AMD;
13880 }
13881 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13882 {
13883 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13884 }
13885 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13886 {
13887 device_vendor_id = VENDOR_ID_APPLE;
13888 }
13889 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13890 {
13891 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13892 }
13893 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13894 {
13895 device_vendor_id = VENDOR_ID_INTEL_SDK;
13896 }
13897 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13898 {
13899 device_vendor_id = VENDOR_ID_MESA;
13900 }
13901 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13902 {
13903 device_vendor_id = VENDOR_ID_NV;
13904 }
13905 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13906 {
13907 device_vendor_id = VENDOR_ID_POCL;
13908 }
13909 else
13910 {
13911 device_vendor_id = VENDOR_ID_GENERIC;
13912 }
13913
13914 device_param->device_vendor_id = device_vendor_id;
13915
13916 // tuning db
13917
13918 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13919
13920 // device_version
13921
13922 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13923
13924 char *device_version = (char *) mymalloc (param_value_size);
13925
13926 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13927
13928 device_param->device_version = device_version;
13929
13930 // device_opencl_version
13931
13932 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13933
13934 char *device_opencl_version = (char *) mymalloc (param_value_size);
13935
13936 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13937
13938 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13939
13940 myfree (device_opencl_version);
13941
13942 // vector_width
13943
13944 cl_uint vector_width;
13945
13946 if (opencl_vector_width_chgd == 0)
13947 {
13948 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13949 {
13950 if (opti_type & OPTI_TYPE_USES_BITS_64)
13951 {
13952 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13953 }
13954 else
13955 {
13956 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13957 }
13958 }
13959 else
13960 {
13961 vector_width = (cl_uint) tuningdb_entry->vector_width;
13962 }
13963 }
13964 else
13965 {
13966 vector_width = opencl_vector_width;
13967 }
13968
13969 if (vector_width > 16) vector_width = 16;
13970
13971 device_param->vector_width = vector_width;
13972
13973 // max_compute_units
13974
13975 cl_uint device_processors;
13976
13977 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13978
13979 device_param->device_processors = device_processors;
13980
13981 // device_maxmem_alloc
13982 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13983
13984 cl_ulong device_maxmem_alloc;
13985
13986 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13987
13988 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13989
13990 // device_global_mem
13991
13992 cl_ulong device_global_mem;
13993
13994 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13995
13996 device_param->device_global_mem = device_global_mem;
13997
13998 // max_work_group_size
13999
14000 size_t device_maxworkgroup_size;
14001
14002 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
14003
14004 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
14005
14006 // max_clock_frequency
14007
14008 cl_uint device_maxclock_frequency;
14009
14010 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
14011
14012 device_param->device_maxclock_frequency = device_maxclock_frequency;
14013
14014 // device_endian_little
14015
14016 cl_bool device_endian_little;
14017
14018 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
14019
14020 if (device_endian_little == CL_FALSE)
14021 {
14022 log_info ("- Device #%u: WARNING: Not a little endian device", device_id + 1);
14023
14024 device_param->skipped = 1;
14025 }
14026
14027 // device_available
14028
14029 cl_bool device_available;
14030
14031 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
14032
14033 if (device_available == CL_FALSE)
14034 {
14035 log_info ("- Device #%u: WARNING: Device not available", device_id + 1);
14036
14037 device_param->skipped = 1;
14038 }
14039
14040 // device_compiler_available
14041
14042 cl_bool device_compiler_available;
14043
14044 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
14045
14046 if (device_compiler_available == CL_FALSE)
14047 {
14048 log_info ("- Device #%u: WARNING: No compiler available for device", device_id + 1);
14049
14050 device_param->skipped = 1;
14051 }
14052
14053 // device_execution_capabilities
14054
14055 cl_device_exec_capabilities device_execution_capabilities;
14056
14057 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
14058
14059 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
14060 {
14061 log_info ("- Device #%u: WARNING: Device does not support executing kernels", device_id + 1);
14062
14063 device_param->skipped = 1;
14064 }
14065
14066 // device_extensions
14067
14068 size_t device_extensions_size;
14069
14070 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
14071
14072 char *device_extensions = mymalloc (device_extensions_size + 1);
14073
14074 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
14075
14076 if (strstr (device_extensions, "base_atomics") == 0)
14077 {
14078 log_info ("- Device #%u: WARNING: Device does not support base atomics", device_id + 1);
14079
14080 device_param->skipped = 1;
14081 }
14082
14083 if (strstr (device_extensions, "byte_addressable_store") == 0)
14084 {
14085 log_info ("- Device #%u: WARNING: Device does not support byte addressable store", device_id + 1);
14086
14087 device_param->skipped = 1;
14088 }
14089
14090 myfree (device_extensions);
14091
14092 // device_local_mem_size
14093
14094 cl_ulong device_local_mem_size;
14095
14096 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
14097
14098 if (device_local_mem_size < 32768)
14099 {
14100 log_info ("- Device #%u: WARNING: Device local mem size is too small", device_id + 1);
14101
14102 device_param->skipped = 1;
14103 }
14104
14105 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
14106 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
14107 // This results in both utilizing it for 50%
14108 // However, Intel has much better SIMD control over their own hardware
14109 // It makes sense to give them full control over their own hardware
14110
14111 if (device_type & CL_DEVICE_TYPE_CPU)
14112 {
14113 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14114 {
14115 if (data.force == 0)
14116 {
14117 if (algorithm_pos == 0)
14118 {
14119 log_info ("- Device #%u: WARNING: Not a native intel opencl runtime, expect massive speed loss", device_id + 1);
14120 log_info (" You can use --force to override this but do not post error reports if you do so");
14121 }
14122
14123 device_param->skipped = 1;
14124 }
14125 }
14126 }
14127
14128 // skipped
14129
14130 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14131 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14132
14133 // driver_version
14134
14135 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14136
14137 char *driver_version = (char *) mymalloc (param_value_size);
14138
14139 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14140
14141 device_param->driver_version = driver_version;
14142
14143 // device_name_chksum
14144
14145 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14146
14147 #if __x86_64__
14148 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);
14149 #else
14150 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);
14151 #endif
14152
14153 uint device_name_digest[4] = { 0 };
14154
14155 md5_64 ((uint *) device_name_chksum, device_name_digest);
14156
14157 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14158
14159 device_param->device_name_chksum = device_name_chksum;
14160
14161 // device_processor_cores
14162
14163 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14164 {
14165 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14166 {
14167 need_adl = 1;
14168 }
14169
14170 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14171 {
14172 need_nvml = 1;
14173
14174 #ifdef LINUX
14175 need_xnvctrl = 1;
14176 #endif
14177
14178 #ifdef WIN
14179 need_nvapi = 1;
14180 #endif
14181 }
14182 }
14183
14184 // device_processor_cores
14185
14186 if (device_type & CL_DEVICE_TYPE_CPU)
14187 {
14188 cl_uint device_processor_cores = 1;
14189
14190 device_param->device_processor_cores = device_processor_cores;
14191 }
14192
14193 if (device_type & CL_DEVICE_TYPE_GPU)
14194 {
14195 if (device_vendor_id == VENDOR_ID_AMD)
14196 {
14197 cl_uint device_processor_cores = 0;
14198
14199 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
14200
14201 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
14202
14203 device_param->device_processor_cores = device_processor_cores;
14204 }
14205 else if (device_vendor_id == VENDOR_ID_NV)
14206 {
14207 cl_uint kernel_exec_timeout = 0;
14208
14209 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14210
14211 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14212
14213 device_param->kernel_exec_timeout = kernel_exec_timeout;
14214
14215 cl_uint device_processor_cores = 0;
14216
14217 #define CL_DEVICE_WARP_SIZE_NV 0x4003
14218
14219 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
14220
14221 device_param->device_processor_cores = device_processor_cores;
14222
14223 cl_uint sm_minor = 0;
14224 cl_uint sm_major = 0;
14225
14226 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14227 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14228
14229 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14230 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14231
14232 device_param->sm_minor = sm_minor;
14233 device_param->sm_major = sm_major;
14234
14235 // CPU burning loop damper
14236 // Value is given as number between 0-100
14237 // By default 100%
14238
14239 device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14240
14241 if (nvidia_spin_damp_chgd == 0)
14242 {
14243 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14244 {
14245 /**
14246 * the workaround is not a friend of rule based attacks
14247 * the words from the wordlist combined with fast and slow rules cause
14248 * fluctuations which cause inaccurate wait time estimations
14249 * using a reduced damping percentage almost compensates this
14250 */
14251
14252 device_param->nvidia_spin_damp = 64;
14253 }
14254 }
14255
14256 device_param->nvidia_spin_damp /= 100;
14257 }
14258 else
14259 {
14260 cl_uint device_processor_cores = 1;
14261
14262 device_param->device_processor_cores = device_processor_cores;
14263 }
14264 }
14265
14266 // display results
14267
14268 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14269 {
14270 if (machine_readable == 0)
14271 {
14272 if (device_param->skipped == 0)
14273 {
14274 log_info ("- Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14275 device_id + 1,
14276 device_name,
14277 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14278 (unsigned int) (device_global_mem / 1024 / 1024),
14279 (unsigned int) device_processors);
14280 }
14281 else
14282 {
14283 log_info ("- Device #%u: %s, skipped",
14284 device_id + 1,
14285 device_name);
14286 }
14287 }
14288 }
14289
14290 // common driver check
14291
14292 if (device_param->skipped == 0)
14293 {
14294 if (device_type & CL_DEVICE_TYPE_GPU)
14295 {
14296 if (platform_vendor_id == VENDOR_ID_AMD)
14297 {
14298 int catalyst_check = (force == 1) ? 0 : 1;
14299
14300 int catalyst_warn = 0;
14301
14302 int catalyst_broken = 0;
14303
14304 if (catalyst_check == 1)
14305 {
14306 catalyst_warn = 1;
14307
14308 // v14.9 and higher
14309 if (atoi (device_param->driver_version) >= 1573)
14310 {
14311 catalyst_warn = 0;
14312 }
14313
14314 catalyst_check = 0;
14315 }
14316
14317 if (catalyst_broken == 1)
14318 {
14319 log_info ("");
14320 log_info ("ATTENTION! The Catalyst driver installed on your system is known to be broken!");
14321 log_info ("It passes over cracked hashes and will not report them as cracked");
14322 log_info ("You are STRONGLY encouraged not to use it");
14323 log_info ("You can use --force to override this but do not post error reports if you do so");
14324 log_info ("");
14325
14326 return (-1);
14327 }
14328
14329 if (catalyst_warn == 1)
14330 {
14331 log_info ("");
14332 log_info ("ATTENTION! Unsupported or incorrectly installed Catalyst driver detected!");
14333 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver");
14334 log_info ("See hashcat's homepage for official supported catalyst drivers");
14335 #ifdef _WIN
14336 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14337 #endif
14338 log_info ("You can use --force to override this but do not post error reports if you do so");
14339 log_info ("");
14340
14341 return (-1);
14342 }
14343 }
14344 else if (platform_vendor_id == VENDOR_ID_NV)
14345 {
14346 if (device_param->kernel_exec_timeout != 0)
14347 {
14348 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);
14349 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14350 }
14351 }
14352 }
14353
14354 /* turns out pocl still creates segfaults (because of llvm)
14355 if (device_type & CL_DEVICE_TYPE_CPU)
14356 {
14357 if (platform_vendor_id == VENDOR_ID_AMD)
14358 {
14359 if (force == 0)
14360 {
14361 log_info ("");
14362 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14363 log_info ("You are STRONGLY encouraged not to use it");
14364 log_info ("You can use --force to override this but do not post error reports if you do so");
14365 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14366 log_info ("");
14367
14368 return (-1);
14369 }
14370 }
14371 }
14372 */
14373
14374 /**
14375 * kernel accel and loops tuning db adjustment
14376 */
14377
14378 device_param->kernel_accel_min = 1;
14379 device_param->kernel_accel_max = 1024;
14380
14381 device_param->kernel_loops_min = 1;
14382 device_param->kernel_loops_max = 1024;
14383
14384 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14385
14386 if (tuningdb_entry)
14387 {
14388 u32 _kernel_accel = tuningdb_entry->kernel_accel;
14389 u32 _kernel_loops = tuningdb_entry->kernel_loops;
14390
14391 if (_kernel_accel)
14392 {
14393 device_param->kernel_accel_min = _kernel_accel;
14394 device_param->kernel_accel_max = _kernel_accel;
14395 }
14396
14397 if (_kernel_loops)
14398 {
14399 if (workload_profile == 1)
14400 {
14401 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14402 }
14403 else if (workload_profile == 2)
14404 {
14405 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14406 }
14407
14408 device_param->kernel_loops_min = _kernel_loops;
14409 device_param->kernel_loops_max = _kernel_loops;
14410 }
14411 }
14412
14413 // commandline parameters overwrite tuningdb entries
14414
14415 if (kernel_accel)
14416 {
14417 device_param->kernel_accel_min = kernel_accel;
14418 device_param->kernel_accel_max = kernel_accel;
14419 }
14420
14421 if (kernel_loops)
14422 {
14423 device_param->kernel_loops_min = kernel_loops;
14424 device_param->kernel_loops_max = kernel_loops;
14425 }
14426
14427 /**
14428 * activate device
14429 */
14430
14431 devices_active++;
14432 }
14433
14434 // next please
14435
14436 devices_cnt++;
14437 }
14438
14439 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14440 {
14441 if (machine_readable == 0)
14442 {
14443 log_info ("");
14444 }
14445 }
14446 }
14447
14448 if (keyspace == 0 && devices_active == 0)
14449 {
14450 log_error ("ERROR: No devices found/left");
14451
14452 return (-1);
14453 }
14454
14455 // 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)
14456
14457 if (devices_filter != (uint) -1)
14458 {
14459 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14460
14461 if (devices_filter > devices_cnt_mask)
14462 {
14463 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14464
14465 return (-1);
14466 }
14467 }
14468
14469 data.devices_cnt = devices_cnt;
14470
14471 data.devices_active = devices_active;
14472
14473 /**
14474 * HM devices: init
14475 */
14476
14477 #ifdef HAVE_HWMON
14478 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14479 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14480 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14481 hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX] = { { 0 } };
14482
14483 if (gpu_temp_disable == 0)
14484 {
14485 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14486 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14487 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14488 XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));
14489
14490 data.hm_adl = NULL;
14491 data.hm_nvapi = NULL;
14492 data.hm_nvml = NULL;
14493 data.hm_xnvctrl = NULL;
14494
14495 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14496 {
14497 data.hm_nvml = nvml;
14498 }
14499
14500 if (data.hm_nvml)
14501 {
14502 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14503 {
14504 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14505
14506 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14507
14508 int tmp_out = 0;
14509
14510 for (int i = 0; i < tmp_in; i++)
14511 {
14512 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14513 }
14514
14515 for (int i = 0; i < tmp_out; i++)
14516 {
14517 unsigned int speed;
14518
14519 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14520
14521 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14522
14523 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14524 }
14525 }
14526 }
14527
14528 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14529 {
14530 data.hm_nvapi = nvapi;
14531 }
14532
14533 if (data.hm_nvapi)
14534 {
14535 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14536 {
14537 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14538
14539 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14540
14541 int tmp_out = 0;
14542
14543 for (int i = 0; i < tmp_in; i++)
14544 {
14545 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14546 }
14547 }
14548 }
14549
14550 if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0))
14551 {
14552 data.hm_xnvctrl = xnvctrl;
14553 }
14554
14555 if (data.hm_xnvctrl)
14556 {
14557 if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
14558 {
14559 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14560 {
14561 hc_device_param_t *device_param = &data.devices_param[device_id];
14562
14563 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14564
14565 hm_adapters_xnvctrl[device_id].xnvctrl = device_id;
14566
14567 int speed = 0;
14568
14569 if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
14570 }
14571 }
14572 }
14573
14574 if ((need_adl == 1) && (adl_init (adl) == 0))
14575 {
14576 data.hm_adl = adl;
14577 }
14578
14579 if (data.hm_adl)
14580 {
14581 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14582 {
14583 // total number of adapters
14584
14585 int hm_adapters_num;
14586
14587 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14588
14589 // adapter info
14590
14591 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14592
14593 if (lpAdapterInfo == NULL) return (-1);
14594
14595 // get a list (of ids of) valid/usable adapters
14596
14597 int num_adl_adapters = 0;
14598
14599 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14600
14601 if (num_adl_adapters > 0)
14602 {
14603 hc_thread_mutex_lock (mux_adl);
14604
14605 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14606
14607 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14608
14609 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14610 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14611
14612 hc_thread_mutex_unlock (mux_adl);
14613 }
14614
14615 myfree (valid_adl_device_list);
14616 myfree (lpAdapterInfo);
14617 }
14618 }
14619
14620 if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14621 {
14622 gpu_temp_disable = 1;
14623 }
14624 }
14625
14626 /**
14627 * OpenCL devices: allocate buffer for device specific information
14628 */
14629
14630 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14631 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14632
14633 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14634
14635 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14636
14637 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14638
14639 /**
14640 * User-defined GPU temp handling
14641 */
14642
14643 if (gpu_temp_disable == 1)
14644 {
14645 gpu_temp_abort = 0;
14646 gpu_temp_retain = 0;
14647 }
14648
14649 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14650 {
14651 if (gpu_temp_abort < gpu_temp_retain)
14652 {
14653 log_error ("ERROR: Invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14654
14655 return (-1);
14656 }
14657 }
14658
14659 data.gpu_temp_disable = gpu_temp_disable;
14660 data.gpu_temp_abort = gpu_temp_abort;
14661 data.gpu_temp_retain = gpu_temp_retain;
14662 #endif
14663
14664 /**
14665 * enable custom signal handler(s)
14666 */
14667
14668 if (benchmark == 0)
14669 {
14670 hc_signal (sigHandler_default);
14671 }
14672 else
14673 {
14674 hc_signal (sigHandler_benchmark);
14675 }
14676
14677 /**
14678 * inform the user
14679 */
14680
14681 if (data.quiet == 0)
14682 {
14683 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14684
14685 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);
14686
14687 if (attack_mode == ATTACK_MODE_STRAIGHT)
14688 {
14689 log_info ("Rules: %u", kernel_rules_cnt);
14690 }
14691
14692 if (opti_type)
14693 {
14694 log_info ("Applicable Optimizers:");
14695
14696 for (uint i = 0; i < 32; i++)
14697 {
14698 const uint opti_bit = 1u << i;
14699
14700 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14701 }
14702 }
14703
14704 /**
14705 * Watchdog and Temperature balance
14706 */
14707
14708 #ifdef HAVE_HWMON
14709 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14710 {
14711 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14712 }
14713
14714 if (gpu_temp_abort == 0)
14715 {
14716 log_info ("Watchdog: Temperature abort trigger disabled");
14717 }
14718 else
14719 {
14720 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14721 }
14722
14723 if (gpu_temp_retain == 0)
14724 {
14725 log_info ("Watchdog: Temperature retain trigger disabled");
14726 }
14727 else
14728 {
14729 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14730 }
14731
14732 if (data.quiet == 0) log_info ("");
14733 #endif
14734 }
14735
14736 #ifdef HAVE_HWMON
14737
14738 /**
14739 * HM devices: copy
14740 */
14741
14742 if (gpu_temp_disable == 0)
14743 {
14744 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14745 {
14746 hc_device_param_t *device_param = &data.devices_param[device_id];
14747
14748 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14749
14750 if (device_param->skipped) continue;
14751
14752 const uint platform_devices_id = device_param->platform_devices_id;
14753
14754 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14755 {
14756 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14757 data.hm_device[device_id].nvapi = 0;
14758 data.hm_device[device_id].nvml = 0;
14759 data.hm_device[device_id].xnvctrl = 0;
14760 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14761 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14762 data.hm_device[device_id].fan_set_supported = 0;
14763 }
14764
14765 if (device_param->device_vendor_id == VENDOR_ID_NV)
14766 {
14767 data.hm_device[device_id].adl = 0;
14768 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14769 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14770 data.hm_device[device_id].xnvctrl = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
14771 data.hm_device[device_id].od_version = 0;
14772 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14773 data.hm_device[device_id].fan_set_supported = 0;
14774 }
14775 }
14776 }
14777
14778 /**
14779 * powertune on user request
14780 */
14781
14782 if (powertune_enable == 1)
14783 {
14784 hc_thread_mutex_lock (mux_adl);
14785
14786 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14787 {
14788 hc_device_param_t *device_param = &data.devices_param[device_id];
14789
14790 if (device_param->skipped) continue;
14791
14792 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14793 {
14794 /**
14795 * Temporary fix:
14796 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14797 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14798 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14799 * Driver / ADL bug?
14800 */
14801
14802 if (data.hm_device[device_id].od_version == 6)
14803 {
14804 int ADL_rc;
14805
14806 // check powertune capabilities first, if not available then skip device
14807
14808 int powertune_supported = 0;
14809
14810 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14811 {
14812 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14813
14814 return (-1);
14815 }
14816
14817 // first backup current value, we will restore it later
14818
14819 if (powertune_supported != 0)
14820 {
14821 // powercontrol settings
14822
14823 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14824
14825 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14826 {
14827 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14828 }
14829
14830 if (ADL_rc != ADL_OK)
14831 {
14832 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14833
14834 return (-1);
14835 }
14836
14837 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14838 {
14839 log_error ("ERROR: Failed to set new ADL PowerControl values");
14840
14841 return (-1);
14842 }
14843
14844 // clocks
14845
14846 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14847
14848 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14849
14850 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)
14851 {
14852 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14853
14854 return (-1);
14855 }
14856
14857 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14858
14859 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14860
14861 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14862 {
14863 log_error ("ERROR: Failed to get ADL device capabilities");
14864
14865 return (-1);
14866 }
14867
14868 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14869 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14870
14871 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14872 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14873
14874 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14875 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14876
14877 // warning if profile has too low max values
14878
14879 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14880 {
14881 log_info ("WARN: The custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14882 }
14883
14884 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14885 {
14886 log_info ("WARN: The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14887 }
14888
14889 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14890
14891 performance_state->iNumberOfPerformanceLevels = 2;
14892
14893 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14894 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14895 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14896 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14897
14898 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)
14899 {
14900 log_info ("ERROR: Failed to set ADL performance state");
14901
14902 return (-1);
14903 }
14904
14905 local_free (performance_state);
14906 }
14907
14908 // set powertune value only
14909
14910 if (powertune_supported != 0)
14911 {
14912 // powertune set
14913 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14914
14915 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14916 {
14917 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14918
14919 return (-1);
14920 }
14921
14922 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14923 {
14924 log_error ("ERROR: Failed to set new ADL PowerControl values");
14925
14926 return (-1);
14927 }
14928 }
14929 }
14930 }
14931
14932 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14933 {
14934 // first backup current value, we will restore it later
14935
14936 unsigned int limit;
14937
14938 int powertune_supported = 0;
14939
14940 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14941 {
14942 powertune_supported = 1;
14943 }
14944
14945 // if backup worked, activate the maximum allowed
14946
14947 if (powertune_supported != 0)
14948 {
14949 unsigned int minLimit;
14950 unsigned int maxLimit;
14951
14952 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14953 {
14954 if (maxLimit > 0)
14955 {
14956 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14957 {
14958 // now we can be sure we need to reset later
14959
14960 nvml_power_limit[device_id] = limit;
14961 }
14962 }
14963 }
14964 }
14965 }
14966 }
14967
14968 hc_thread_mutex_unlock (mux_adl);
14969 }
14970
14971 #endif // HAVE_HWMON
14972
14973 #ifdef DEBUG
14974 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14975 #endif
14976
14977 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14978
14979 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14980 {
14981 /**
14982 * host buffer
14983 */
14984
14985 hc_device_param_t *device_param = &data.devices_param[device_id];
14986
14987 if (device_param->skipped) continue;
14988
14989 /**
14990 * device properties
14991 */
14992
14993 const char *device_name_chksum = device_param->device_name_chksum;
14994 const u32 device_processors = device_param->device_processors;
14995 const u32 device_processor_cores = device_param->device_processor_cores;
14996
14997 /**
14998 * create context for each device
14999 */
15000
15001 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
15002
15003 /**
15004 * create command-queue
15005 */
15006
15007 // not supported with NV
15008 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
15009
15010 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
15011
15012 /**
15013 * kernel threads: some algorithms need a fixed kernel-threads count
15014 * because of shared memory usage or bitslice
15015 * there needs to be some upper limit, otherwise there's too much overhead
15016 */
15017
15018 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
15019
15020 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
15021 {
15022 kernel_threads = KERNEL_THREADS_MAX_CPU;
15023 }
15024
15025 if (hash_mode == 1500) kernel_threads = 64; // DES
15026 if (hash_mode == 3000) kernel_threads = 64; // DES
15027 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
15028 if (hash_mode == 7500) kernel_threads = 64; // RC4
15029 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
15030 if (hash_mode == 9700) kernel_threads = 64; // RC4
15031 if (hash_mode == 9710) kernel_threads = 64; // RC4
15032 if (hash_mode == 9800) kernel_threads = 64; // RC4
15033 if (hash_mode == 9810) kernel_threads = 64; // RC4
15034 if (hash_mode == 10400) kernel_threads = 64; // RC4
15035 if (hash_mode == 10410) kernel_threads = 64; // RC4
15036 if (hash_mode == 10500) kernel_threads = 64; // RC4
15037 if (hash_mode == 13100) kernel_threads = 64; // RC4
15038
15039 device_param->kernel_threads = kernel_threads;
15040
15041 device_param->hardware_power = device_processors * kernel_threads;
15042
15043 /**
15044 * create input buffers on device : calculate size of fixed memory buffers
15045 */
15046
15047 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
15048 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
15049
15050 device_param->size_root_css = size_root_css;
15051 device_param->size_markov_css = size_markov_css;
15052
15053 size_t size_results = sizeof (uint);
15054
15055 device_param->size_results = size_results;
15056
15057 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
15058 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
15059
15060 size_t size_plains = digests_cnt * sizeof (plain_t);
15061 size_t size_salts = salts_cnt * sizeof (salt_t);
15062 size_t size_esalts = salts_cnt * esalt_size;
15063
15064 device_param->size_plains = size_plains;
15065 device_param->size_digests = size_digests;
15066 device_param->size_shown = size_shown;
15067 device_param->size_salts = size_salts;
15068
15069 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
15070 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
15071 size_t size_tm = 32 * sizeof (bs_word_t);
15072
15073 // scryptV stuff
15074
15075 size_t size_scryptV = 1;
15076
15077 if ((hash_mode == 8900) || (hash_mode == 9300))
15078 {
15079 uint tmto_start = 0;
15080 uint tmto_stop = 10;
15081
15082 if (scrypt_tmto)
15083 {
15084 tmto_start = scrypt_tmto;
15085 }
15086 else
15087 {
15088 // in case the user did not specify the tmto manually
15089 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
15090 // but set the lower end only in case the user has a device with too less memory
15091
15092 if (hash_mode == 8900)
15093 {
15094 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15095 {
15096 tmto_start = 1;
15097 }
15098 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15099 {
15100 tmto_start = 2;
15101 }
15102 }
15103 else if (hash_mode == 9300)
15104 {
15105 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15106 {
15107 tmto_start = 2;
15108 }
15109 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15110 {
15111 tmto_start = 2;
15112 }
15113 }
15114 }
15115
15116 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
15117 {
15118 // TODO: in theory the following calculation needs to be done per salt, not global
15119 // we assume all hashes have the same scrypt settings
15120
15121 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
15122
15123 size_scryptV /= 1 << tmto;
15124
15125 size_scryptV *= device_processors * device_processor_cores;
15126
15127 if (size_scryptV > device_param->device_maxmem_alloc)
15128 {
15129 if (quiet == 0) log_info ("WARNING: Not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15130
15131 continue;
15132 }
15133
15134 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
15135 {
15136 data.salts_buf[salts_pos].scrypt_tmto = tmto;
15137 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
15138 }
15139
15140 break;
15141 }
15142
15143 if (data.salts_buf[0].scrypt_phy == 0)
15144 {
15145 log_error ("ERROR: Can't allocate enough device memory");
15146
15147 return -1;
15148 }
15149
15150 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
15151 }
15152
15153 /**
15154 * some algorithms need a fixed kernel-loops count
15155 */
15156
15157 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15158 {
15159 const u32 kernel_loops_fixed = 1024;
15160
15161 device_param->kernel_loops_min = kernel_loops_fixed;
15162 device_param->kernel_loops_max = kernel_loops_fixed;
15163 }
15164
15165 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15166 {
15167 const u32 kernel_loops_fixed = 1024;
15168
15169 device_param->kernel_loops_min = kernel_loops_fixed;
15170 device_param->kernel_loops_max = kernel_loops_fixed;
15171 }
15172
15173 if (hash_mode == 8900)
15174 {
15175 const u32 kernel_loops_fixed = 1;
15176
15177 device_param->kernel_loops_min = kernel_loops_fixed;
15178 device_param->kernel_loops_max = kernel_loops_fixed;
15179 }
15180
15181 if (hash_mode == 9300)
15182 {
15183 const u32 kernel_loops_fixed = 1;
15184
15185 device_param->kernel_loops_min = kernel_loops_fixed;
15186 device_param->kernel_loops_max = kernel_loops_fixed;
15187 }
15188
15189 if (hash_mode == 12500)
15190 {
15191 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15192
15193 device_param->kernel_loops_min = kernel_loops_fixed;
15194 device_param->kernel_loops_max = kernel_loops_fixed;
15195 }
15196
15197 /**
15198 * some algorithms have a maximum kernel-loops count
15199 */
15200
15201 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15202 {
15203 u32 innerloop_cnt = 0;
15204
15205 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15206 {
15207 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15208 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15209 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15210 }
15211 else
15212 {
15213 innerloop_cnt = data.salts_buf[0].salt_iter;
15214 }
15215
15216 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15217 (innerloop_cnt <= device_param->kernel_loops_max))
15218 {
15219 device_param->kernel_loops_max = innerloop_cnt;
15220 }
15221 }
15222
15223 u32 kernel_accel_min = device_param->kernel_accel_min;
15224 u32 kernel_accel_max = device_param->kernel_accel_max;
15225
15226 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15227
15228 size_t size_pws = 4;
15229 size_t size_tmps = 4;
15230 size_t size_hooks = 4;
15231
15232 while (kernel_accel_max >= kernel_accel_min)
15233 {
15234 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15235
15236 // size_pws
15237
15238 size_pws = kernel_power_max * sizeof (pw_t);
15239
15240 // size_tmps
15241
15242 switch (hash_mode)
15243 {
15244 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15245 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15246 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15247 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15248 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15249 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15250 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15251 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15252 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15253 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15254 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15255 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15256 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15257 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15258 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15259 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15260 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15261 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15262 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15263 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15264 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15265 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15266 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15267 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
15268 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
15269 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
15270 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
15271 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
15272 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15273 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15274 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
15275 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
15276 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15277 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
15278 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15279 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
15280 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
15281 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15282 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15283 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
15284 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
15285 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
15286 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15287 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
15288 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
15289 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
15290 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
15291 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15292 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
15293 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
15294 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
15295 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15296 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15297 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
15298 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
15299 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
15300 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
15301 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
15302 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15303 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15304 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15305 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
15306 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
15307 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15308 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15309 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15310 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15311 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15312 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15313 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15314 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15315 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15316 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15317 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15318 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15319 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15320 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15321 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15322 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15323 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15324 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15325 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15326 };
15327
15328 // size_hooks
15329
15330 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15331 {
15332 switch (hash_mode)
15333 {
15334 }
15335 }
15336
15337 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15338 // if not, decrease amplifier and try again
15339
15340 int skip = 0;
15341
15342 const u64 size_total
15343 = bitmap_size
15344 + bitmap_size
15345 + bitmap_size
15346 + bitmap_size
15347 + bitmap_size
15348 + bitmap_size
15349 + bitmap_size
15350 + bitmap_size
15351 + size_bfs
15352 + size_combs
15353 + size_digests
15354 + size_esalts
15355 + size_hooks
15356 + size_markov_css
15357 + size_plains
15358 + size_pws
15359 + size_pws // not a bug
15360 + size_results
15361 + size_root_css
15362 + size_rules
15363 + size_rules_c
15364 + size_salts
15365 + size_scryptV
15366 + size_shown
15367 + size_tm
15368 + size_tmps;
15369
15370 // Don't ask me, ask AMD!
15371
15372 if (size_total > device_param->device_maxmem_alloc) skip = 1;
15373 if (size_total > device_param->device_global_mem) skip = 1;
15374
15375 if (skip == 1)
15376 {
15377 kernel_accel_max--;
15378
15379 continue;
15380 }
15381
15382 break;
15383 }
15384
15385 /*
15386 if (kernel_accel_max == 0)
15387 {
15388 log_error ("- Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
15389
15390 return -1;
15391 }
15392 */
15393
15394 device_param->kernel_accel_min = kernel_accel_min;
15395 device_param->kernel_accel_max = kernel_accel_max;
15396
15397 /*
15398 if (kernel_accel_max < kernel_accel)
15399 {
15400 if (quiet == 0) log_info ("- Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
15401
15402 device_param->kernel_accel = kernel_accel_max;
15403 }
15404 */
15405
15406 device_param->size_bfs = size_bfs;
15407 device_param->size_combs = size_combs;
15408 device_param->size_rules = size_rules;
15409 device_param->size_rules_c = size_rules_c;
15410 device_param->size_pws = size_pws;
15411 device_param->size_tmps = size_tmps;
15412 device_param->size_hooks = size_hooks;
15413
15414 /**
15415 * default building options
15416 */
15417
15418 char build_opts[1024] = { 0 };
15419
15420 // we don't have sm_* on vendors not NV but it doesn't matter
15421
15422 #if _WIN
15423 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);
15424 #else
15425 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);
15426 #endif
15427
15428 char build_opts_new[1024] = { 0 };
15429
15430 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);
15431
15432 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
15433
15434 /*
15435 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
15436 {
15437 // we do vectorizing much better than the auto-vectorizer
15438
15439 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
15440
15441 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
15442 }
15443 */
15444
15445 #ifdef DEBUG
15446 log_info ("- Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15447 #endif
15448
15449 /**
15450 * main kernel
15451 */
15452
15453 {
15454 /**
15455 * kernel source filename
15456 */
15457
15458 char source_file[256] = { 0 };
15459
15460 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15461
15462 struct stat sst;
15463
15464 if (stat (source_file, &sst) == -1)
15465 {
15466 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15467
15468 return -1;
15469 }
15470
15471 /**
15472 * kernel cached filename
15473 */
15474
15475 char cached_file[256] = { 0 };
15476
15477 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15478
15479 int cached = 1;
15480
15481 struct stat cst;
15482
15483 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15484 {
15485 cached = 0;
15486 }
15487
15488 /**
15489 * kernel compile or load
15490 */
15491
15492 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15493
15494 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15495
15496 if (force_jit_compilation == -1)
15497 {
15498 if (cached == 0)
15499 {
15500 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));
15501
15502 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15503
15504 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15505
15506 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15507
15508 #ifdef DEBUG
15509 size_t build_log_size = 0;
15510
15511 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15512
15513 if (build_log_size > 1)
15514 {
15515 char *build_log = (char *) malloc (build_log_size + 1);
15516
15517 memset (build_log, 0, build_log_size + 1);
15518
15519 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15520
15521 puts (build_log);
15522
15523 free (build_log);
15524 }
15525 #endif
15526
15527 if (rc != 0)
15528 {
15529 device_param->skipped = true;
15530
15531 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15532
15533 continue;
15534 }
15535
15536 size_t binary_size;
15537
15538 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15539
15540 u8 *binary = (u8 *) mymalloc (binary_size);
15541
15542 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15543
15544 writeProgramBin (cached_file, binary, binary_size);
15545
15546 local_free (binary);
15547 }
15548 else
15549 {
15550 #ifdef DEBUG
15551 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15552 #endif
15553
15554 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15555
15556 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15557
15558 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15559 }
15560 }
15561 else
15562 {
15563 #ifdef DEBUG
15564 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15565 #endif
15566
15567 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15568
15569 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15570
15571 char build_opts_update[1024] = { 0 };
15572
15573 if (force_jit_compilation == 1500)
15574 {
15575 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15576 }
15577 else if (force_jit_compilation == 8900)
15578 {
15579 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);
15580 }
15581 else
15582 {
15583 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15584 }
15585
15586 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15587
15588 #ifdef DEBUG
15589 size_t build_log_size = 0;
15590
15591 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15592
15593 if (build_log_size > 1)
15594 {
15595 char *build_log = (char *) malloc (build_log_size + 1);
15596
15597 memset (build_log, 0, build_log_size + 1);
15598
15599 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15600
15601 puts (build_log);
15602
15603 free (build_log);
15604 }
15605 #endif
15606
15607 if (rc != 0)
15608 {
15609 device_param->skipped = true;
15610
15611 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15612 }
15613 }
15614
15615 local_free (kernel_lengths);
15616 local_free (kernel_sources[0]);
15617 local_free (kernel_sources);
15618 }
15619
15620 /**
15621 * word generator kernel
15622 */
15623
15624 if (attack_mode != ATTACK_MODE_STRAIGHT)
15625 {
15626 /**
15627 * kernel mp source filename
15628 */
15629
15630 char source_file[256] = { 0 };
15631
15632 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15633
15634 struct stat sst;
15635
15636 if (stat (source_file, &sst) == -1)
15637 {
15638 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15639
15640 return -1;
15641 }
15642
15643 /**
15644 * kernel mp cached filename
15645 */
15646
15647 char cached_file[256] = { 0 };
15648
15649 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15650
15651 int cached = 1;
15652
15653 struct stat cst;
15654
15655 if (stat (cached_file, &cst) == -1)
15656 {
15657 cached = 0;
15658 }
15659
15660 /**
15661 * kernel compile or load
15662 */
15663
15664 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15665
15666 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15667
15668 if (cached == 0)
15669 {
15670 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));
15671 if (quiet == 0) log_info ("");
15672
15673 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15674
15675 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15676
15677 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15678
15679 if (rc != 0)
15680 {
15681 device_param->skipped = true;
15682
15683 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15684
15685 continue;
15686 }
15687
15688 size_t binary_size;
15689
15690 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15691
15692 u8 *binary = (u8 *) mymalloc (binary_size);
15693
15694 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15695
15696 writeProgramBin (cached_file, binary, binary_size);
15697
15698 local_free (binary);
15699 }
15700 else
15701 {
15702 #ifdef DEBUG
15703 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15704 #endif
15705
15706 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15707
15708 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15709
15710 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15711 }
15712
15713 local_free (kernel_lengths);
15714 local_free (kernel_sources[0]);
15715 local_free (kernel_sources);
15716 }
15717
15718 /**
15719 * amplifier kernel
15720 */
15721
15722 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15723 {
15724
15725 }
15726 else
15727 {
15728 /**
15729 * kernel amp source filename
15730 */
15731
15732 char source_file[256] = { 0 };
15733
15734 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15735
15736 struct stat sst;
15737
15738 if (stat (source_file, &sst) == -1)
15739 {
15740 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15741
15742 return -1;
15743 }
15744
15745 /**
15746 * kernel amp cached filename
15747 */
15748
15749 char cached_file[256] = { 0 };
15750
15751 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15752
15753 int cached = 1;
15754
15755 struct stat cst;
15756
15757 if (stat (cached_file, &cst) == -1)
15758 {
15759 cached = 0;
15760 }
15761
15762 /**
15763 * kernel compile or load
15764 */
15765
15766 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15767
15768 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15769
15770 if (cached == 0)
15771 {
15772 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));
15773 if (quiet == 0) log_info ("");
15774
15775 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15776
15777 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15778
15779 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15780
15781 if (rc != 0)
15782 {
15783 device_param->skipped = true;
15784
15785 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15786
15787 continue;
15788 }
15789
15790 size_t binary_size;
15791
15792 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15793
15794 u8 *binary = (u8 *) mymalloc (binary_size);
15795
15796 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15797
15798 writeProgramBin (cached_file, binary, binary_size);
15799
15800 local_free (binary);
15801 }
15802 else
15803 {
15804 #ifdef DEBUG
15805 if (quiet == 0) log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15806 #endif
15807
15808 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15809
15810 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15811
15812 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15813 }
15814
15815 local_free (kernel_lengths);
15816 local_free (kernel_sources[0]);
15817 local_free (kernel_sources);
15818 }
15819
15820 // some algorithm collide too fast, make that impossible
15821
15822 if (benchmark == 1)
15823 {
15824 ((uint *) digests_buf)[0] = -1;
15825 ((uint *) digests_buf)[1] = -1;
15826 ((uint *) digests_buf)[2] = -1;
15827 ((uint *) digests_buf)[3] = -1;
15828 }
15829
15830 /**
15831 * global buffers
15832 */
15833
15834 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15835 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15836 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15837 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15838 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15839 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15840 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15841 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15842 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15843 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15844 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15845 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15846 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15847 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15848 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15849 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15850 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15851 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15852
15853 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);
15854 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);
15855 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);
15856 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);
15857 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);
15858 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);
15859 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);
15860 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);
15861 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15862 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15863 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15864
15865 /**
15866 * special buffers
15867 */
15868
15869 if (attack_kern == ATTACK_KERN_STRAIGHT)
15870 {
15871 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15872 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15873
15874 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15875 }
15876 else if (attack_kern == ATTACK_KERN_COMBI)
15877 {
15878 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15879 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15880 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15881 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15882 }
15883 else if (attack_kern == ATTACK_KERN_BF)
15884 {
15885 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15886 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15887 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15888 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15889 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15890 }
15891
15892 if (size_esalts)
15893 {
15894 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15895
15896 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15897 }
15898
15899 /**
15900 * main host data
15901 */
15902
15903 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15904
15905 device_param->pws_buf = pws_buf;
15906
15907 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15908
15909 device_param->combs_buf = combs_buf;
15910
15911 void *hooks_buf = mymalloc (size_hooks);
15912
15913 device_param->hooks_buf = hooks_buf;
15914
15915 /**
15916 * kernel args
15917 */
15918
15919 device_param->kernel_params_buf32[21] = bitmap_mask;
15920 device_param->kernel_params_buf32[22] = bitmap_shift1;
15921 device_param->kernel_params_buf32[23] = bitmap_shift2;
15922 device_param->kernel_params_buf32[24] = 0; // salt_pos
15923 device_param->kernel_params_buf32[25] = 0; // loop_pos
15924 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15925 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15926 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15927 device_param->kernel_params_buf32[29] = 0; // digests_offset
15928 device_param->kernel_params_buf32[30] = 0; // combs_mode
15929 device_param->kernel_params_buf32[31] = 0; // gid_max
15930
15931 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15932 ? &device_param->d_pws_buf
15933 : &device_param->d_pws_amp_buf;
15934 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15935 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15936 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15937 device_param->kernel_params[ 4] = &device_param->d_tmps;
15938 device_param->kernel_params[ 5] = &device_param->d_hooks;
15939 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15940 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15941 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15942 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15943 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15944 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15945 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15946 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15947 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15948 device_param->kernel_params[15] = &device_param->d_digests_buf;
15949 device_param->kernel_params[16] = &device_param->d_digests_shown;
15950 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15951 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15952 device_param->kernel_params[19] = &device_param->d_result;
15953 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15954 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15955 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15956 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15957 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15958 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15959 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15960 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15961 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15962 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15963 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15964 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15965
15966 device_param->kernel_params_mp_buf64[3] = 0;
15967 device_param->kernel_params_mp_buf32[4] = 0;
15968 device_param->kernel_params_mp_buf32[5] = 0;
15969 device_param->kernel_params_mp_buf32[6] = 0;
15970 device_param->kernel_params_mp_buf32[7] = 0;
15971 device_param->kernel_params_mp_buf32[8] = 0;
15972
15973 device_param->kernel_params_mp[0] = NULL;
15974 device_param->kernel_params_mp[1] = NULL;
15975 device_param->kernel_params_mp[2] = NULL;
15976 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15977 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15978 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15979 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15980 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15981 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15982
15983 device_param->kernel_params_mp_l_buf64[3] = 0;
15984 device_param->kernel_params_mp_l_buf32[4] = 0;
15985 device_param->kernel_params_mp_l_buf32[5] = 0;
15986 device_param->kernel_params_mp_l_buf32[6] = 0;
15987 device_param->kernel_params_mp_l_buf32[7] = 0;
15988 device_param->kernel_params_mp_l_buf32[8] = 0;
15989 device_param->kernel_params_mp_l_buf32[9] = 0;
15990
15991 device_param->kernel_params_mp_l[0] = NULL;
15992 device_param->kernel_params_mp_l[1] = NULL;
15993 device_param->kernel_params_mp_l[2] = NULL;
15994 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15995 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15996 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15997 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15998 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15999 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
16000 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
16001
16002 device_param->kernel_params_mp_r_buf64[3] = 0;
16003 device_param->kernel_params_mp_r_buf32[4] = 0;
16004 device_param->kernel_params_mp_r_buf32[5] = 0;
16005 device_param->kernel_params_mp_r_buf32[6] = 0;
16006 device_param->kernel_params_mp_r_buf32[7] = 0;
16007 device_param->kernel_params_mp_r_buf32[8] = 0;
16008
16009 device_param->kernel_params_mp_r[0] = NULL;
16010 device_param->kernel_params_mp_r[1] = NULL;
16011 device_param->kernel_params_mp_r[2] = NULL;
16012 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
16013 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
16014 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
16015 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
16016 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
16017 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
16018
16019 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
16020 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
16021
16022 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
16023 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
16024 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
16025 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
16026 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
16027 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
16028 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
16029
16030 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
16031 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
16032
16033 device_param->kernel_params_memset_buf32[1] = 0; // value
16034 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
16035
16036 device_param->kernel_params_memset[0] = NULL;
16037 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
16038 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
16039
16040 /**
16041 * kernel name
16042 */
16043
16044 size_t kernel_wgs_tmp;
16045
16046 char kernel_name[64] = { 0 };
16047
16048 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16049 {
16050 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16051 {
16052 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
16053
16054 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16055
16056 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
16057
16058 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16059
16060 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
16061
16062 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16063 }
16064 else
16065 {
16066 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
16067
16068 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16069
16070 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
16071
16072 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16073
16074 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
16075
16076 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16077 }
16078
16079 if (data.attack_mode == ATTACK_MODE_BF)
16080 {
16081 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16082 {
16083 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
16084
16085 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16086
16087 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);
16088 }
16089 }
16090 }
16091 else
16092 {
16093 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
16094
16095 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16096
16097 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
16098
16099 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16100
16101 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
16102
16103 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16104
16105 if (opts_type & OPTS_TYPE_HOOK12)
16106 {
16107 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
16108
16109 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16110
16111 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);
16112 }
16113
16114 if (opts_type & OPTS_TYPE_HOOK23)
16115 {
16116 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
16117
16118 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16119
16120 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);
16121 }
16122 }
16123
16124 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);
16125 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);
16126 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);
16127
16128 for (uint i = 0; i <= 20; i++)
16129 {
16130 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
16131 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
16132 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
16133
16134 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
16135 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
16136 }
16137
16138 for (uint i = 21; i <= 31; i++)
16139 {
16140 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
16141 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
16142 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
16143
16144 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
16145 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
16146 }
16147
16148 // GPU memset
16149
16150 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
16151
16152 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);
16153
16154 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
16155 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
16156 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
16157
16158 // MP start
16159
16160 if (attack_mode == ATTACK_MODE_BF)
16161 {
16162 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
16163 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
16164
16165 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);
16166 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);
16167
16168 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16169 {
16170 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
16171 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
16172 }
16173 }
16174 else if (attack_mode == ATTACK_MODE_HYBRID1)
16175 {
16176 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16177
16178 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);
16179 }
16180 else if (attack_mode == ATTACK_MODE_HYBRID2)
16181 {
16182 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16183
16184 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);
16185 }
16186
16187 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16188 {
16189 // nothing to do
16190 }
16191 else
16192 {
16193 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
16194
16195 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);
16196 }
16197
16198 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16199 {
16200 // nothing to do
16201 }
16202 else
16203 {
16204 for (uint i = 0; i < 5; i++)
16205 {
16206 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
16207 }
16208
16209 for (uint i = 5; i < 7; i++)
16210 {
16211 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
16212 }
16213 }
16214
16215 // maybe this has been updated by clGetKernelWorkGroupInfo()
16216 // value can only be decreased, so we don't need to reallocate buffers
16217
16218 device_param->kernel_threads = kernel_threads;
16219
16220 // zero some data buffers
16221
16222 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
16223 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
16224 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
16225 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
16226 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
16227 run_kernel_bzero (device_param, device_param->d_result, size_results);
16228
16229 /**
16230 * special buffers
16231 */
16232
16233 if (attack_kern == ATTACK_KERN_STRAIGHT)
16234 {
16235 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
16236 }
16237 else if (attack_kern == ATTACK_KERN_COMBI)
16238 {
16239 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
16240 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
16241 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16242 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16243 }
16244 else if (attack_kern == ATTACK_KERN_BF)
16245 {
16246 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
16247 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
16248 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
16249 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16250 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16251 }
16252
16253 #if defined(HAVE_HWMON)
16254
16255 /**
16256 * Store initial fanspeed if gpu_temp_retain is enabled
16257 */
16258
16259 if (gpu_temp_disable == 0)
16260 {
16261 if (gpu_temp_retain != 0)
16262 {
16263 hc_thread_mutex_lock (mux_adl);
16264
16265 if (data.hm_device[device_id].fan_get_supported == 1)
16266 {
16267 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
16268 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
16269
16270 temp_retain_fanspeed_value[device_id] = fanspeed;
16271 temp_retain_fanpolicy_value[device_id] = fanpolicy;
16272
16273 // we also set it to tell the OS we take control over the fan and it's automatic controller
16274 // if it was set to automatic. we do not control user-defined fanspeeds.
16275
16276 if (fanpolicy == 1)
16277 {
16278 data.hm_device[device_id].fan_set_supported = 1;
16279
16280 int rc = -1;
16281
16282 if (device_param->device_vendor_id == VENDOR_ID_AMD)
16283 {
16284 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
16285 }
16286 else if (device_param->device_vendor_id == VENDOR_ID_NV)
16287 {
16288 #ifdef LINUX
16289 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE);
16290 #endif
16291
16292 #ifdef WIN
16293 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
16294 #endif
16295 }
16296
16297 if (rc == 0)
16298 {
16299 data.hm_device[device_id].fan_set_supported = 1;
16300 }
16301 else
16302 {
16303 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
16304
16305 data.hm_device[device_id].fan_set_supported = 0;
16306 }
16307 }
16308 else
16309 {
16310 data.hm_device[device_id].fan_set_supported = 0;
16311 }
16312 }
16313
16314 hc_thread_mutex_unlock (mux_adl);
16315 }
16316 }
16317
16318 #endif // HAVE_HWMON
16319 }
16320
16321 if (data.quiet == 0) log_info_nn ("");
16322
16323 /**
16324 * In benchmark-mode, inform user which algorithm is checked
16325 */
16326
16327 if (benchmark == 1)
16328 {
16329 if (machine_readable == 0)
16330 {
16331 quiet = 0;
16332
16333 data.quiet = quiet;
16334
16335 char *hash_type = strhashtype (data.hash_mode); // not a bug
16336
16337 log_info ("Hashtype: %s", hash_type);
16338 log_info ("");
16339 }
16340 }
16341
16342 /**
16343 * keep track of the progress
16344 */
16345
16346 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16347 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16348 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16349
16350 /**
16351 * open filehandles
16352 */
16353
16354 #if _WIN
16355 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
16356 {
16357 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
16358
16359 return (-1);
16360 }
16361
16362 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
16363 {
16364 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
16365
16366 return (-1);
16367 }
16368
16369 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
16370 {
16371 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
16372
16373 return (-1);
16374 }
16375 #endif
16376
16377 /**
16378 * dictionary pad
16379 */
16380
16381 segment_size *= (1024 * 1024);
16382
16383 data.segment_size = segment_size;
16384
16385 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
16386
16387 wl_data->buf = (char *) mymalloc (segment_size);
16388 wl_data->avail = segment_size;
16389 wl_data->incr = segment_size;
16390 wl_data->cnt = 0;
16391 wl_data->pos = 0;
16392
16393 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
16394
16395 data.wordlist_mode = wordlist_mode;
16396
16397 cs_t *css_buf = NULL;
16398 uint css_cnt = 0;
16399 uint dictcnt = 0;
16400 uint maskcnt = 1;
16401 char **masks = NULL;
16402 char **dictfiles = NULL;
16403
16404 uint mask_from_file = 0;
16405
16406 if (attack_mode == ATTACK_MODE_STRAIGHT)
16407 {
16408 if (wordlist_mode == WL_MODE_FILE)
16409 {
16410 int wls_left = myargc - (optind + 1);
16411
16412 for (int i = 0; i < wls_left; i++)
16413 {
16414 char *l0_filename = myargv[optind + 1 + i];
16415
16416 struct stat l0_stat;
16417
16418 if (stat (l0_filename, &l0_stat) == -1)
16419 {
16420 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
16421
16422 return (-1);
16423 }
16424
16425 uint is_dir = S_ISDIR (l0_stat.st_mode);
16426
16427 if (is_dir == 0)
16428 {
16429 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16430
16431 dictcnt++;
16432
16433 dictfiles[dictcnt - 1] = l0_filename;
16434 }
16435 else
16436 {
16437 // do not allow --keyspace w/ a directory
16438
16439 if (keyspace == 1)
16440 {
16441 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16442
16443 return (-1);
16444 }
16445
16446 char **dictionary_files = NULL;
16447
16448 dictionary_files = scan_directory (l0_filename);
16449
16450 if (dictionary_files != NULL)
16451 {
16452 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16453
16454 for (int d = 0; dictionary_files[d] != NULL; d++)
16455 {
16456 char *l1_filename = dictionary_files[d];
16457
16458 struct stat l1_stat;
16459
16460 if (stat (l1_filename, &l1_stat) == -1)
16461 {
16462 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16463
16464 return (-1);
16465 }
16466
16467 if (S_ISREG (l1_stat.st_mode))
16468 {
16469 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16470
16471 dictcnt++;
16472
16473 dictfiles[dictcnt - 1] = strdup (l1_filename);
16474 }
16475 }
16476 }
16477
16478 local_free (dictionary_files);
16479 }
16480 }
16481
16482 if (dictcnt < 1)
16483 {
16484 log_error ("ERROR: No usable dictionary file found.");
16485
16486 return (-1);
16487 }
16488 }
16489 else if (wordlist_mode == WL_MODE_STDIN)
16490 {
16491 dictcnt = 1;
16492 }
16493 }
16494 else if (attack_mode == ATTACK_MODE_COMBI)
16495 {
16496 // display
16497
16498 char *dictfile1 = myargv[optind + 1 + 0];
16499 char *dictfile2 = myargv[optind + 1 + 1];
16500
16501 // find the bigger dictionary and use as base
16502
16503 FILE *fp1 = NULL;
16504 FILE *fp2 = NULL;
16505
16506 struct stat tmp_stat;
16507
16508 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16509 {
16510 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16511
16512 return (-1);
16513 }
16514
16515 if (stat (dictfile1, &tmp_stat) == -1)
16516 {
16517 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16518
16519 fclose (fp1);
16520
16521 return (-1);
16522 }
16523
16524 if (S_ISDIR (tmp_stat.st_mode))
16525 {
16526 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16527
16528 fclose (fp1);
16529
16530 return (-1);
16531 }
16532
16533 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16534 {
16535 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16536
16537 fclose (fp1);
16538
16539 return (-1);
16540 }
16541
16542 if (stat (dictfile2, &tmp_stat) == -1)
16543 {
16544 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16545
16546 fclose (fp1);
16547 fclose (fp2);
16548
16549 return (-1);
16550 }
16551
16552 if (S_ISDIR (tmp_stat.st_mode))
16553 {
16554 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16555
16556 fclose (fp1);
16557 fclose (fp2);
16558
16559 return (-1);
16560 }
16561
16562 data.combs_cnt = 1;
16563
16564 data.quiet = 1;
16565
16566 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16567
16568 data.quiet = quiet;
16569
16570 if (words1_cnt == 0)
16571 {
16572 log_error ("ERROR: %s: empty file", dictfile1);
16573
16574 fclose (fp1);
16575 fclose (fp2);
16576
16577 return (-1);
16578 }
16579
16580 data.combs_cnt = 1;
16581
16582 data.quiet = 1;
16583
16584 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16585
16586 data.quiet = quiet;
16587
16588 if (words2_cnt == 0)
16589 {
16590 log_error ("ERROR: %s: empty file", dictfile2);
16591
16592 fclose (fp1);
16593 fclose (fp2);
16594
16595 return (-1);
16596 }
16597
16598 fclose (fp1);
16599 fclose (fp2);
16600
16601 data.dictfile = dictfile1;
16602 data.dictfile2 = dictfile2;
16603
16604 if (words1_cnt >= words2_cnt)
16605 {
16606 data.combs_cnt = words2_cnt;
16607 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16608
16609 dictfiles = &data.dictfile;
16610
16611 dictcnt = 1;
16612 }
16613 else
16614 {
16615 data.combs_cnt = words1_cnt;
16616 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16617
16618 dictfiles = &data.dictfile2;
16619
16620 dictcnt = 1;
16621
16622 // we also have to switch wordlist related rules!
16623
16624 char *tmpc = data.rule_buf_l;
16625
16626 data.rule_buf_l = data.rule_buf_r;
16627 data.rule_buf_r = tmpc;
16628
16629 int tmpi = data.rule_len_l;
16630
16631 data.rule_len_l = data.rule_len_r;
16632 data.rule_len_r = tmpi;
16633 }
16634 }
16635 else if (attack_mode == ATTACK_MODE_BF)
16636 {
16637 char *mask = NULL;
16638
16639 maskcnt = 0;
16640
16641 if (benchmark == 0)
16642 {
16643 mask = myargv[optind + 1];
16644
16645 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16646
16647 if ((optind + 2) <= myargc)
16648 {
16649 struct stat file_stat;
16650
16651 if (stat (mask, &file_stat) == -1)
16652 {
16653 maskcnt = 1;
16654
16655 masks[maskcnt - 1] = mystrdup (mask);
16656 }
16657 else
16658 {
16659 int wls_left = myargc - (optind + 1);
16660
16661 uint masks_avail = INCR_MASKS;
16662
16663 for (int i = 0; i < wls_left; i++)
16664 {
16665 if (i != 0)
16666 {
16667 mask = myargv[optind + 1 + i];
16668
16669 if (stat (mask, &file_stat) == -1)
16670 {
16671 log_error ("ERROR: %s: %s", mask, strerror (errno));
16672
16673 return (-1);
16674 }
16675 }
16676
16677 uint is_file = S_ISREG (file_stat.st_mode);
16678
16679 if (is_file == 1)
16680 {
16681 FILE *mask_fp;
16682
16683 if ((mask_fp = fopen (mask, "r")) == NULL)
16684 {
16685 log_error ("ERROR: %s: %s", mask, strerror (errno));
16686
16687 return (-1);
16688 }
16689
16690 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16691
16692 while (!feof (mask_fp))
16693 {
16694 memset (line_buf, 0, HCBUFSIZ);
16695
16696 int line_len = fgetl (mask_fp, line_buf);
16697
16698 if (line_len == 0) continue;
16699
16700 if (line_buf[0] == '#') continue;
16701
16702 if (masks_avail == maskcnt)
16703 {
16704 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16705
16706 masks_avail += INCR_MASKS;
16707 }
16708
16709 masks[maskcnt] = mystrdup (line_buf);
16710
16711 maskcnt++;
16712 }
16713
16714 myfree (line_buf);
16715
16716 fclose (mask_fp);
16717 }
16718 else
16719 {
16720 log_error ("ERROR: %s: unsupported file-type", mask);
16721
16722 return (-1);
16723 }
16724 }
16725
16726 mask_from_file = 1;
16727 }
16728 }
16729 else
16730 {
16731 custom_charset_1 = (char *) "?l?d?u";
16732 custom_charset_2 = (char *) "?l?d";
16733 custom_charset_3 = (char *) "?l?d*!$@_";
16734
16735 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16736 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16737 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16738
16739 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16740
16741 wordlist_mode = WL_MODE_MASK;
16742
16743 data.wordlist_mode = wordlist_mode;
16744
16745 increment = 1;
16746
16747 maskcnt = 1;
16748 }
16749 }
16750 else
16751 {
16752 /**
16753 * generate full masks and charsets
16754 */
16755
16756 masks = (char **) mymalloc (sizeof (char *));
16757
16758 switch (hash_mode)
16759 {
16760 case 1731: pw_min = 5;
16761 pw_max = 5;
16762 mask = mystrdup ("?b?b?b?b?b");
16763 break;
16764 case 12500: pw_min = 5;
16765 pw_max = 5;
16766 mask = mystrdup ("?b?b?b?b?b");
16767 break;
16768 default: pw_min = 7;
16769 pw_max = 7;
16770 mask = mystrdup ("?b?b?b?b?b?b?b");
16771 break;
16772 }
16773
16774 maskcnt = 1;
16775
16776 masks[maskcnt - 1] = mystrdup (mask);
16777
16778 wordlist_mode = WL_MODE_MASK;
16779
16780 data.wordlist_mode = wordlist_mode;
16781
16782 increment = 1;
16783 }
16784
16785 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16786
16787 if (increment)
16788 {
16789 if (increment_min > pw_min) pw_min = increment_min;
16790
16791 if (increment_max < pw_max) pw_max = increment_max;
16792 }
16793 }
16794 else if (attack_mode == ATTACK_MODE_HYBRID1)
16795 {
16796 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16797
16798 // display
16799
16800 char *mask = myargv[myargc - 1];
16801
16802 maskcnt = 0;
16803
16804 masks = (char **) mymalloc (1 * sizeof (char *));
16805
16806 // mod
16807
16808 struct stat file_stat;
16809
16810 if (stat (mask, &file_stat) == -1)
16811 {
16812 maskcnt = 1;
16813
16814 masks[maskcnt - 1] = mystrdup (mask);
16815 }
16816 else
16817 {
16818 uint is_file = S_ISREG (file_stat.st_mode);
16819
16820 if (is_file == 1)
16821 {
16822 FILE *mask_fp;
16823
16824 if ((mask_fp = fopen (mask, "r")) == NULL)
16825 {
16826 log_error ("ERROR: %s: %s", mask, strerror (errno));
16827
16828 return (-1);
16829 }
16830
16831 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16832
16833 uint masks_avail = 1;
16834
16835 while (!feof (mask_fp))
16836 {
16837 memset (line_buf, 0, HCBUFSIZ);
16838
16839 int line_len = fgetl (mask_fp, line_buf);
16840
16841 if (line_len == 0) continue;
16842
16843 if (line_buf[0] == '#') continue;
16844
16845 if (masks_avail == maskcnt)
16846 {
16847 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16848
16849 masks_avail += INCR_MASKS;
16850 }
16851
16852 masks[maskcnt] = mystrdup (line_buf);
16853
16854 maskcnt++;
16855 }
16856
16857 myfree (line_buf);
16858
16859 fclose (mask_fp);
16860
16861 mask_from_file = 1;
16862 }
16863 else
16864 {
16865 maskcnt = 1;
16866
16867 masks[maskcnt - 1] = mystrdup (mask);
16868 }
16869 }
16870
16871 // base
16872
16873 int wls_left = myargc - (optind + 2);
16874
16875 for (int i = 0; i < wls_left; i++)
16876 {
16877 char *filename = myargv[optind + 1 + i];
16878
16879 struct stat file_stat;
16880
16881 if (stat (filename, &file_stat) == -1)
16882 {
16883 log_error ("ERROR: %s: %s", filename, strerror (errno));
16884
16885 return (-1);
16886 }
16887
16888 uint is_dir = S_ISDIR (file_stat.st_mode);
16889
16890 if (is_dir == 0)
16891 {
16892 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16893
16894 dictcnt++;
16895
16896 dictfiles[dictcnt - 1] = filename;
16897 }
16898 else
16899 {
16900 // do not allow --keyspace w/ a directory
16901
16902 if (keyspace == 1)
16903 {
16904 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16905
16906 return (-1);
16907 }
16908
16909 char **dictionary_files = NULL;
16910
16911 dictionary_files = scan_directory (filename);
16912
16913 if (dictionary_files != NULL)
16914 {
16915 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16916
16917 for (int d = 0; dictionary_files[d] != NULL; d++)
16918 {
16919 char *l1_filename = dictionary_files[d];
16920
16921 struct stat l1_stat;
16922
16923 if (stat (l1_filename, &l1_stat) == -1)
16924 {
16925 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16926
16927 return (-1);
16928 }
16929
16930 if (S_ISREG (l1_stat.st_mode))
16931 {
16932 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16933
16934 dictcnt++;
16935
16936 dictfiles[dictcnt - 1] = strdup (l1_filename);
16937 }
16938 }
16939 }
16940
16941 local_free (dictionary_files);
16942 }
16943 }
16944
16945 if (dictcnt < 1)
16946 {
16947 log_error ("ERROR: No usable dictionary file found.");
16948
16949 return (-1);
16950 }
16951
16952 if (increment)
16953 {
16954 maskcnt = 0;
16955
16956 uint mask_min = increment_min; // we can't reject smaller masks here
16957 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16958
16959 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16960 {
16961 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16962
16963 if (cur_mask == NULL) break;
16964
16965 masks[maskcnt] = cur_mask;
16966
16967 maskcnt++;
16968
16969 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16970 }
16971 }
16972 }
16973 else if (attack_mode == ATTACK_MODE_HYBRID2)
16974 {
16975 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16976
16977 // display
16978
16979 char *mask = myargv[optind + 1 + 0];
16980
16981 maskcnt = 0;
16982
16983 masks = (char **) mymalloc (1 * sizeof (char *));
16984
16985 // mod
16986
16987 struct stat file_stat;
16988
16989 if (stat (mask, &file_stat) == -1)
16990 {
16991 maskcnt = 1;
16992
16993 masks[maskcnt - 1] = mystrdup (mask);
16994 }
16995 else
16996 {
16997 uint is_file = S_ISREG (file_stat.st_mode);
16998
16999 if (is_file == 1)
17000 {
17001 FILE *mask_fp;
17002
17003 if ((mask_fp = fopen (mask, "r")) == NULL)
17004 {
17005 log_error ("ERROR: %s: %s", mask, strerror (errno));
17006
17007 return (-1);
17008 }
17009
17010 char *line_buf = (char *) mymalloc (HCBUFSIZ);
17011
17012 uint masks_avail = 1;
17013
17014 while (!feof (mask_fp))
17015 {
17016 memset (line_buf, 0, HCBUFSIZ);
17017
17018 int line_len = fgetl (mask_fp, line_buf);
17019
17020 if (line_len == 0) continue;
17021
17022 if (line_buf[0] == '#') continue;
17023
17024 if (masks_avail == maskcnt)
17025 {
17026 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
17027
17028 masks_avail += INCR_MASKS;
17029 }
17030
17031 masks[maskcnt] = mystrdup (line_buf);
17032
17033 maskcnt++;
17034 }
17035
17036 myfree (line_buf);
17037
17038 fclose (mask_fp);
17039
17040 mask_from_file = 1;
17041 }
17042 else
17043 {
17044 maskcnt = 1;
17045
17046 masks[maskcnt - 1] = mystrdup (mask);
17047 }
17048 }
17049
17050 // base
17051
17052 int wls_left = myargc - (optind + 2);
17053
17054 for (int i = 0; i < wls_left; i++)
17055 {
17056 char *filename = myargv[optind + 2 + i];
17057
17058 struct stat file_stat;
17059
17060 if (stat (filename, &file_stat) == -1)
17061 {
17062 log_error ("ERROR: %s: %s", filename, strerror (errno));
17063
17064 return (-1);
17065 }
17066
17067 uint is_dir = S_ISDIR (file_stat.st_mode);
17068
17069 if (is_dir == 0)
17070 {
17071 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17072
17073 dictcnt++;
17074
17075 dictfiles[dictcnt - 1] = filename;
17076 }
17077 else
17078 {
17079 // do not allow --keyspace w/ a directory
17080
17081 if (keyspace == 1)
17082 {
17083 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17084
17085 return (-1);
17086 }
17087
17088 char **dictionary_files = NULL;
17089
17090 dictionary_files = scan_directory (filename);
17091
17092 if (dictionary_files != NULL)
17093 {
17094 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17095
17096 for (int d = 0; dictionary_files[d] != NULL; d++)
17097 {
17098 char *l1_filename = dictionary_files[d];
17099
17100 struct stat l1_stat;
17101
17102 if (stat (l1_filename, &l1_stat) == -1)
17103 {
17104 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17105
17106 return (-1);
17107 }
17108
17109 if (S_ISREG (l1_stat.st_mode))
17110 {
17111 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17112
17113 dictcnt++;
17114
17115 dictfiles[dictcnt - 1] = strdup (l1_filename);
17116 }
17117 }
17118 }
17119
17120 local_free (dictionary_files);
17121 }
17122 }
17123
17124 if (dictcnt < 1)
17125 {
17126 log_error ("ERROR: No usable dictionary file found.");
17127
17128 return (-1);
17129 }
17130
17131 if (increment)
17132 {
17133 maskcnt = 0;
17134
17135 uint mask_min = increment_min; // we can't reject smaller masks here
17136 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17137
17138 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17139 {
17140 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17141
17142 if (cur_mask == NULL) break;
17143
17144 masks[maskcnt] = cur_mask;
17145
17146 maskcnt++;
17147
17148 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17149 }
17150 }
17151 }
17152
17153 data.pw_min = pw_min;
17154 data.pw_max = pw_max;
17155
17156 /**
17157 * weak hash check
17158 */
17159
17160 if (weak_hash_threshold >= salts_cnt)
17161 {
17162 hc_device_param_t *device_param = NULL;
17163
17164 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17165 {
17166 device_param = &data.devices_param[device_id];
17167
17168 if (device_param->skipped) continue;
17169
17170 break;
17171 }
17172
17173 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
17174
17175 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
17176 {
17177 weak_hash_check (device_param, salt_pos);
17178 }
17179
17180 // Display hack, guarantee that there is at least one \r before real start
17181
17182 //if (data.quiet == 0) log_info ("");
17183 }
17184
17185 /**
17186 * status and monitor threads
17187 */
17188
17189 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
17190
17191 uint i_threads_cnt = 0;
17192
17193 hc_thread_t *i_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17194
17195 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17196 {
17197 if (stdout_flag == 0)
17198 {
17199 hc_thread_create (i_threads[i_threads_cnt], thread_keypress, &benchmark);
17200
17201 i_threads_cnt++;
17202 }
17203 }
17204
17205 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
17206
17207 uint ni_threads_cnt = 0;
17208
17209 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17210
17211 if (stdout_flag == 0)
17212 {
17213 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
17214
17215 ni_threads_cnt++;
17216 }
17217
17218 /**
17219 * Outfile remove
17220 */
17221
17222 if (keyspace == 0)
17223 {
17224 if (outfile_check_timer != 0)
17225 {
17226 if (data.outfile_check_directory != NULL)
17227 {
17228 if ((hash_mode != 5200) &&
17229 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
17230 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
17231 (hash_mode != 9000))
17232 {
17233 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
17234
17235 ni_threads_cnt++;
17236 }
17237 else
17238 {
17239 outfile_check_timer = 0;
17240 }
17241 }
17242 else
17243 {
17244 outfile_check_timer = 0;
17245 }
17246 }
17247 }
17248
17249 /**
17250 * Inform the user if we got some hashes remove because of the pot file remove feature
17251 */
17252
17253 if (data.quiet == 0)
17254 {
17255 if (potfile_remove_cracks > 0)
17256 {
17257 if (potfile_remove_cracks == 1) log_info ("INFO: Removed 1 hash found in pot file\n");
17258 else log_info ("INFO: Removed %u hashes found in pot file\n", potfile_remove_cracks);
17259 }
17260 }
17261
17262 data.outfile_check_timer = outfile_check_timer;
17263
17264 /**
17265 * main loop
17266 */
17267
17268 char **induction_dictionaries = NULL;
17269
17270 int induction_dictionaries_cnt = 0;
17271
17272 hcstat_table_t *root_table_buf = NULL;
17273 hcstat_table_t *markov_table_buf = NULL;
17274
17275 uint initial_restore_done = 0;
17276
17277 data.maskcnt = maskcnt;
17278
17279 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
17280 {
17281 if (data.devices_status == STATUS_CRACKED) break;
17282
17283 data.devices_status = STATUS_INIT;
17284
17285 if (maskpos > rd->maskpos)
17286 {
17287 rd->dictpos = 0;
17288 }
17289
17290 rd->maskpos = maskpos;
17291 data.maskpos = maskpos;
17292
17293 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
17294 {
17295 char *mask = masks[maskpos];
17296
17297 if (mask_from_file == 1)
17298 {
17299 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
17300
17301 char *str_ptr;
17302 uint str_pos;
17303
17304 uint mask_offset = 0;
17305
17306 uint separator_cnt;
17307
17308 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
17309 {
17310 str_ptr = strstr (mask + mask_offset, ",");
17311
17312 if (str_ptr == NULL) break;
17313
17314 str_pos = str_ptr - mask;
17315
17316 // escaped separator, i.e. "\,"
17317
17318 if (str_pos > 0)
17319 {
17320 if (mask[str_pos - 1] == '\\')
17321 {
17322 separator_cnt --;
17323
17324 mask_offset = str_pos + 1;
17325
17326 continue;
17327 }
17328 }
17329
17330 // reset the offset
17331
17332 mask_offset = 0;
17333
17334 mask[str_pos] = '\0';
17335
17336 switch (separator_cnt)
17337 {
17338 case 0:
17339 mp_reset_usr (mp_usr, 0);
17340
17341 custom_charset_1 = mask;
17342 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17343 break;
17344
17345 case 1:
17346 mp_reset_usr (mp_usr, 1);
17347
17348 custom_charset_2 = mask;
17349 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17350 break;
17351
17352 case 2:
17353 mp_reset_usr (mp_usr, 2);
17354
17355 custom_charset_3 = mask;
17356 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17357 break;
17358
17359 case 3:
17360 mp_reset_usr (mp_usr, 3);
17361
17362 custom_charset_4 = mask;
17363 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
17364 break;
17365 }
17366
17367 mask = mask + str_pos + 1;
17368 }
17369 }
17370
17371 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17372 {
17373 if (maskpos > 0)
17374 {
17375 local_free (css_buf);
17376 local_free (data.root_css_buf);
17377 local_free (data.markov_css_buf);
17378
17379 local_free (masks[maskpos - 1]);
17380 }
17381
17382 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17383
17384 data.mask = mask;
17385 data.css_cnt = css_cnt;
17386 data.css_buf = css_buf;
17387
17388 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17389
17390 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17391
17392 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17393 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17394
17395 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17396
17397 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17398
17399 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17400 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17401
17402 data.root_css_buf = root_css_buf;
17403 data.markov_css_buf = markov_css_buf;
17404
17405 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17406
17407 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17408
17409 local_free (root_table_buf);
17410 local_free (markov_table_buf);
17411
17412 // args
17413
17414 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17415 {
17416 hc_device_param_t *device_param = &data.devices_param[device_id];
17417
17418 if (device_param->skipped) continue;
17419
17420 device_param->kernel_params_mp[0] = &device_param->d_combs;
17421 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
17422 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
17423
17424 device_param->kernel_params_mp_buf64[3] = 0;
17425 device_param->kernel_params_mp_buf32[4] = css_cnt;
17426 device_param->kernel_params_mp_buf32[5] = 0;
17427 device_param->kernel_params_mp_buf32[6] = 0;
17428 device_param->kernel_params_mp_buf32[7] = 0;
17429
17430 if (attack_mode == ATTACK_MODE_HYBRID1)
17431 {
17432 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
17433 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
17434 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
17435 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
17436 }
17437 else if (attack_mode == ATTACK_MODE_HYBRID2)
17438 {
17439 device_param->kernel_params_mp_buf32[5] = 0;
17440 device_param->kernel_params_mp_buf32[6] = 0;
17441 device_param->kernel_params_mp_buf32[7] = 0;
17442 }
17443
17444 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]);
17445 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]);
17446 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]);
17447
17448 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);
17449 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);
17450 }
17451 }
17452 else if (attack_mode == ATTACK_MODE_BF)
17453 {
17454 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
17455
17456 if (increment)
17457 {
17458 for (uint i = 0; i < dictcnt; i++)
17459 {
17460 local_free (dictfiles[i]);
17461 }
17462
17463 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17464 {
17465 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17466
17467 if (l1_filename == NULL) break;
17468
17469 dictcnt++;
17470
17471 dictfiles[dictcnt - 1] = l1_filename;
17472 }
17473 }
17474 else
17475 {
17476 dictcnt++;
17477
17478 dictfiles[dictcnt - 1] = mask;
17479 }
17480
17481 if (dictcnt == 0)
17482 {
17483 log_error ("ERROR: Mask is too small");
17484
17485 return (-1);
17486 }
17487 }
17488 }
17489
17490 free (induction_dictionaries);
17491
17492 // induction_dictionaries_cnt = 0; // implied
17493
17494 if (attack_mode != ATTACK_MODE_BF)
17495 {
17496 if (keyspace == 0)
17497 {
17498 induction_dictionaries = scan_directory (induction_directory);
17499
17500 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17501 }
17502 }
17503
17504 if (induction_dictionaries_cnt)
17505 {
17506 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17507 }
17508
17509 /**
17510 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17511 */
17512 if (keyspace == 1)
17513 {
17514 if ((maskcnt > 1) || (dictcnt > 1))
17515 {
17516 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17517
17518 return (-1);
17519 }
17520 }
17521
17522 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17523 {
17524 char *subid = logfile_generate_subid ();
17525
17526 data.subid = subid;
17527
17528 logfile_sub_msg ("START");
17529
17530 data.devices_status = STATUS_INIT;
17531
17532 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17533 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17534 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17535
17536 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17537
17538 data.cpt_pos = 0;
17539
17540 data.cpt_start = time (NULL);
17541
17542 data.cpt_total = 0;
17543
17544 if (data.restore == 0)
17545 {
17546 rd->words_cur = skip;
17547
17548 skip = 0;
17549
17550 data.skip = 0;
17551 }
17552
17553 data.ms_paused = 0;
17554
17555 data.kernel_power_final = 0;
17556
17557 data.words_cur = rd->words_cur;
17558
17559 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17560 {
17561 hc_device_param_t *device_param = &data.devices_param[device_id];
17562
17563 if (device_param->skipped) continue;
17564
17565 device_param->speed_pos = 0;
17566
17567 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17568 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17569
17570 device_param->exec_pos = 0;
17571
17572 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17573
17574 device_param->outerloop_pos = 0;
17575 device_param->outerloop_left = 0;
17576 device_param->innerloop_pos = 0;
17577 device_param->innerloop_left = 0;
17578
17579 // some more resets:
17580
17581 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17582
17583 device_param->pws_cnt = 0;
17584
17585 device_param->words_off = 0;
17586 device_param->words_done = 0;
17587 }
17588
17589 // figure out some workload
17590
17591 if (attack_mode == ATTACK_MODE_STRAIGHT)
17592 {
17593 if (data.wordlist_mode == WL_MODE_FILE)
17594 {
17595 char *dictfile = NULL;
17596
17597 if (induction_dictionaries_cnt)
17598 {
17599 dictfile = induction_dictionaries[0];
17600 }
17601 else
17602 {
17603 dictfile = dictfiles[dictpos];
17604 }
17605
17606 data.dictfile = dictfile;
17607
17608 logfile_sub_string (dictfile);
17609
17610 for (uint i = 0; i < rp_files_cnt; i++)
17611 {
17612 logfile_sub_var_string ("rulefile", rp_files[i]);
17613 }
17614
17615 FILE *fd2 = fopen (dictfile, "rb");
17616
17617 if (fd2 == NULL)
17618 {
17619 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17620
17621 return (-1);
17622 }
17623
17624 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17625
17626 fclose (fd2);
17627
17628 if (data.words_cnt == 0)
17629 {
17630 if (data.devices_status == STATUS_CRACKED) break;
17631 if (data.devices_status == STATUS_ABORTED) break;
17632
17633 dictpos++;
17634
17635 continue;
17636 }
17637 }
17638 }
17639 else if (attack_mode == ATTACK_MODE_COMBI)
17640 {
17641 char *dictfile = data.dictfile;
17642 char *dictfile2 = data.dictfile2;
17643
17644 logfile_sub_string (dictfile);
17645 logfile_sub_string (dictfile2);
17646
17647 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17648 {
17649 FILE *fd2 = fopen (dictfile, "rb");
17650
17651 if (fd2 == NULL)
17652 {
17653 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17654
17655 return (-1);
17656 }
17657
17658 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17659
17660 fclose (fd2);
17661 }
17662 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17663 {
17664 FILE *fd2 = fopen (dictfile2, "rb");
17665
17666 if (fd2 == NULL)
17667 {
17668 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17669
17670 return (-1);
17671 }
17672
17673 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17674
17675 fclose (fd2);
17676 }
17677
17678 if (data.words_cnt == 0)
17679 {
17680 if (data.devices_status == STATUS_CRACKED) break;
17681 if (data.devices_status == STATUS_ABORTED) break;
17682
17683 dictpos++;
17684
17685 continue;
17686 }
17687 }
17688 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17689 {
17690 char *dictfile = NULL;
17691
17692 if (induction_dictionaries_cnt)
17693 {
17694 dictfile = induction_dictionaries[0];
17695 }
17696 else
17697 {
17698 dictfile = dictfiles[dictpos];
17699 }
17700
17701 data.dictfile = dictfile;
17702
17703 char *mask = data.mask;
17704
17705 logfile_sub_string (dictfile);
17706 logfile_sub_string (mask);
17707
17708 FILE *fd2 = fopen (dictfile, "rb");
17709
17710 if (fd2 == NULL)
17711 {
17712 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17713
17714 return (-1);
17715 }
17716
17717 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17718
17719 fclose (fd2);
17720
17721 if (data.words_cnt == 0)
17722 {
17723 if (data.devices_status == STATUS_CRACKED) break;
17724 if (data.devices_status == STATUS_ABORTED) break;
17725
17726 dictpos++;
17727
17728 continue;
17729 }
17730 }
17731 else if (attack_mode == ATTACK_MODE_BF)
17732 {
17733 local_free (css_buf);
17734 local_free (data.root_css_buf);
17735 local_free (data.markov_css_buf);
17736
17737 char *mask = dictfiles[dictpos];
17738
17739 logfile_sub_string (mask);
17740
17741 // base
17742
17743 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17744
17745 if (opts_type & OPTS_TYPE_PT_UNICODE)
17746 {
17747 uint css_cnt_unicode = css_cnt * 2;
17748
17749 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17750
17751 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17752 {
17753 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17754
17755 css_buf_unicode[j + 1].cs_buf[0] = 0;
17756 css_buf_unicode[j + 1].cs_len = 1;
17757 }
17758
17759 free (css_buf);
17760
17761 css_buf = css_buf_unicode;
17762 css_cnt = css_cnt_unicode;
17763 }
17764
17765 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17766
17767 uint mask_min = pw_min;
17768 uint mask_max = pw_max;
17769
17770 if (opts_type & OPTS_TYPE_PT_UNICODE)
17771 {
17772 mask_min *= 2;
17773 mask_max *= 2;
17774 }
17775
17776 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17777 {
17778 if (css_cnt < mask_min)
17779 {
17780 log_info ("WARNING: Skipping mask '%s' because it is smaller than the minimum password length", mask);
17781 }
17782
17783 if (css_cnt > mask_max)
17784 {
17785 log_info ("WARNING: Skipping mask '%s' because it is larger than the maximum password length", mask);
17786 }
17787
17788 // skip to next mask
17789
17790 dictpos++;
17791
17792 rd->dictpos = dictpos;
17793
17794 logfile_sub_msg ("STOP");
17795
17796 continue;
17797 }
17798
17799 uint save_css_cnt = css_cnt;
17800
17801 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17802 {
17803 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17804 {
17805 uint salt_len = (uint) data.salts_buf[0].salt_len;
17806 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17807
17808 uint css_cnt_salt = css_cnt + salt_len;
17809
17810 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17811
17812 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17813
17814 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17815 {
17816 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17817 css_buf_salt[j].cs_len = 1;
17818 }
17819
17820 free (css_buf);
17821
17822 css_buf = css_buf_salt;
17823 css_cnt = css_cnt_salt;
17824 }
17825 }
17826
17827 data.mask = mask;
17828 data.css_cnt = css_cnt;
17829 data.css_buf = css_buf;
17830
17831 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17832
17833 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17834
17835 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17836
17837 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17838 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17839
17840 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17841
17842 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17843
17844 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17845 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17846
17847 data.root_css_buf = root_css_buf;
17848 data.markov_css_buf = markov_css_buf;
17849
17850 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17851
17852 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17853
17854 local_free (root_table_buf);
17855 local_free (markov_table_buf);
17856
17857 // copy + args
17858
17859 uint css_cnt_l = css_cnt;
17860 uint css_cnt_r;
17861
17862 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17863 {
17864 if (save_css_cnt < 6)
17865 {
17866 css_cnt_r = 1;
17867 }
17868 else if (save_css_cnt == 6)
17869 {
17870 css_cnt_r = 2;
17871 }
17872 else
17873 {
17874 if (opts_type & OPTS_TYPE_PT_UNICODE)
17875 {
17876 if (save_css_cnt == 8 || save_css_cnt == 10)
17877 {
17878 css_cnt_r = 2;
17879 }
17880 else
17881 {
17882 css_cnt_r = 4;
17883 }
17884 }
17885 else
17886 {
17887 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17888 {
17889 css_cnt_r = 3;
17890 }
17891 else
17892 {
17893 css_cnt_r = 4;
17894 }
17895 }
17896 }
17897 }
17898 else
17899 {
17900 css_cnt_r = 1;
17901
17902 /* unfinished code?
17903 int sum = css_buf[css_cnt_r - 1].cs_len;
17904
17905 for (uint i = 1; i < 4 && i < css_cnt; i++)
17906 {
17907 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17908
17909 css_cnt_r++;
17910
17911 sum *= css_buf[css_cnt_r - 1].cs_len;
17912 }
17913 */
17914 }
17915
17916 css_cnt_l -= css_cnt_r;
17917
17918 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17919
17920 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17921 {
17922 hc_device_param_t *device_param = &data.devices_param[device_id];
17923
17924 if (device_param->skipped) continue;
17925
17926 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17927 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17928 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17929
17930 device_param->kernel_params_mp_l_buf64[3] = 0;
17931 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17932 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17933 device_param->kernel_params_mp_l_buf32[6] = 0;
17934 device_param->kernel_params_mp_l_buf32[7] = 0;
17935 device_param->kernel_params_mp_l_buf32[8] = 0;
17936
17937 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17938 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17939 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17940 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17941
17942 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17943 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17944 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17945
17946 device_param->kernel_params_mp_r_buf64[3] = 0;
17947 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17948 device_param->kernel_params_mp_r_buf32[5] = 0;
17949 device_param->kernel_params_mp_r_buf32[6] = 0;
17950 device_param->kernel_params_mp_r_buf32[7] = 0;
17951
17952 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]);
17953 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]);
17954 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]);
17955
17956 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]);
17957 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]);
17958 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]);
17959
17960 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);
17961 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);
17962 }
17963 }
17964
17965 u64 words_base = data.words_cnt;
17966
17967 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17968 {
17969 if (data.kernel_rules_cnt)
17970 {
17971 words_base /= data.kernel_rules_cnt;
17972 }
17973 }
17974 else if (data.attack_kern == ATTACK_KERN_COMBI)
17975 {
17976 if (data.combs_cnt)
17977 {
17978 words_base /= data.combs_cnt;
17979 }
17980 }
17981 else if (data.attack_kern == ATTACK_KERN_BF)
17982 {
17983 if (data.bfs_cnt)
17984 {
17985 words_base /= data.bfs_cnt;
17986 }
17987 }
17988
17989 data.words_base = words_base;
17990
17991 if (keyspace == 1)
17992 {
17993 log_info ("%llu", (unsigned long long int) words_base);
17994
17995 return (0);
17996 }
17997
17998 if (data.words_cur > data.words_base)
17999 {
18000 log_error ("ERROR: Restore value greater keyspace");
18001
18002 return (-1);
18003 }
18004
18005 if (data.words_cur)
18006 {
18007 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18008 {
18009 for (uint i = 0; i < data.salts_cnt; i++)
18010 {
18011 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
18012 }
18013 }
18014 else if (data.attack_kern == ATTACK_KERN_COMBI)
18015 {
18016 for (uint i = 0; i < data.salts_cnt; i++)
18017 {
18018 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
18019 }
18020 }
18021 else if (data.attack_kern == ATTACK_KERN_BF)
18022 {
18023 for (uint i = 0; i < data.salts_cnt; i++)
18024 {
18025 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
18026 }
18027 }
18028 }
18029
18030 /*
18031 * Update loopback file
18032 */
18033
18034 if (loopback == 1)
18035 {
18036 time_t now;
18037
18038 time (&now);
18039
18040 uint random_num = get_random_num (0, 9999);
18041
18042 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
18043
18044 data.loopback_file = loopback_file;
18045 }
18046
18047 /*
18048 * Update dictionary statistic
18049 */
18050
18051 if (keyspace == 0)
18052 {
18053 dictstat_fp = fopen (dictstat, "wb");
18054
18055 if (dictstat_fp)
18056 {
18057 lock_file (dictstat_fp);
18058
18059 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
18060
18061 fclose (dictstat_fp);
18062 }
18063 }
18064
18065 /**
18066 * create autotune threads
18067 */
18068
18069 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
18070
18071 data.devices_status = STATUS_AUTOTUNE;
18072
18073 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18074 {
18075 hc_device_param_t *device_param = &devices_param[device_id];
18076
18077 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
18078 }
18079
18080 hc_thread_wait (data.devices_cnt, c_threads);
18081
18082 /*
18083 * Inform user about possible slow speeds
18084 */
18085
18086 uint hardware_power_all = 0;
18087
18088 uint kernel_power_all = 0;
18089
18090 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18091 {
18092 hc_device_param_t *device_param = &devices_param[device_id];
18093
18094 hardware_power_all += device_param->hardware_power;
18095
18096 kernel_power_all += device_param->kernel_power;
18097 }
18098
18099 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
18100
18101 data.kernel_power_all = kernel_power_all;
18102
18103 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18104 {
18105 if (data.words_base < kernel_power_all)
18106 {
18107 if (quiet == 0)
18108 {
18109 log_info ("ATTENTION!");
18110 log_info (" The wordlist or mask you are using is too small.");
18111 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
18112 log_info (" The cracking speed will drop.");
18113 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
18114 log_info ("");
18115 }
18116 }
18117 }
18118
18119 /**
18120 * create cracker threads
18121 */
18122
18123 data.devices_status = STATUS_RUNNING;
18124
18125 if (initial_restore_done == 0)
18126 {
18127 if (data.restore_disable == 0) cycle_restore ();
18128
18129 initial_restore_done = 1;
18130 }
18131
18132 hc_timer_set (&data.timer_running);
18133
18134 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18135 {
18136 if ((quiet == 0) && (status == 0) && (benchmark == 0))
18137 {
18138 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
18139 if (quiet == 0) fflush (stdout);
18140 }
18141 }
18142 else if (wordlist_mode == WL_MODE_STDIN)
18143 {
18144 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
18145 if (data.quiet == 0) log_info ("");
18146 }
18147
18148 time_t runtime_start;
18149
18150 time (&runtime_start);
18151
18152 data.runtime_start = runtime_start;
18153
18154 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18155 {
18156 hc_device_param_t *device_param = &devices_param[device_id];
18157
18158 if (wordlist_mode == WL_MODE_STDIN)
18159 {
18160 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
18161 }
18162 else
18163 {
18164 hc_thread_create (c_threads[device_id], thread_calc, device_param);
18165 }
18166 }
18167
18168 hc_thread_wait (data.devices_cnt, c_threads);
18169
18170 local_free (c_threads);
18171
18172 data.restore = 0;
18173
18174 // finalize task
18175
18176 logfile_sub_var_uint ("status-after-work", data.devices_status);
18177
18178 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18179
18180 if (data.devices_status == STATUS_CRACKED) break;
18181 if (data.devices_status == STATUS_ABORTED) break;
18182
18183 if (data.devices_status == STATUS_BYPASS)
18184 {
18185 data.devices_status = STATUS_RUNNING;
18186 }
18187
18188 if (induction_dictionaries_cnt)
18189 {
18190 unlink (induction_dictionaries[0]);
18191 }
18192
18193 free (induction_dictionaries);
18194
18195 if (attack_mode != ATTACK_MODE_BF)
18196 {
18197 induction_dictionaries = scan_directory (induction_directory);
18198
18199 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18200 }
18201
18202 if (benchmark == 0)
18203 {
18204 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
18205 {
18206 if (quiet == 0) clear_prompt ();
18207
18208 if (quiet == 0) log_info ("");
18209
18210 if (status == 1)
18211 {
18212 status_display ();
18213 }
18214 else
18215 {
18216 if (quiet == 0) status_display ();
18217 }
18218
18219 if (quiet == 0) log_info ("");
18220 }
18221 }
18222
18223 if (attack_mode == ATTACK_MODE_BF)
18224 {
18225 dictpos++;
18226
18227 rd->dictpos = dictpos;
18228 }
18229 else
18230 {
18231 if (induction_dictionaries_cnt)
18232 {
18233 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18234 }
18235 else
18236 {
18237 dictpos++;
18238
18239 rd->dictpos = dictpos;
18240 }
18241 }
18242
18243 time_t runtime_stop;
18244
18245 time (&runtime_stop);
18246
18247 data.runtime_stop = runtime_stop;
18248
18249 logfile_sub_uint (runtime_start);
18250 logfile_sub_uint (runtime_stop);
18251
18252 logfile_sub_msg ("STOP");
18253
18254 global_free (subid);
18255 }
18256
18257 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18258
18259 if (data.devices_status == STATUS_CRACKED) break;
18260 if (data.devices_status == STATUS_ABORTED) break;
18261 if (data.devices_status == STATUS_QUIT) break;
18262
18263 if (data.devices_status == STATUS_BYPASS)
18264 {
18265 data.devices_status = STATUS_RUNNING;
18266 }
18267 }
18268
18269 // 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
18270
18271 if (attack_mode == ATTACK_MODE_STRAIGHT)
18272 {
18273 if (data.wordlist_mode == WL_MODE_FILE)
18274 {
18275 if (data.dictfile == NULL)
18276 {
18277 if (dictfiles != NULL)
18278 {
18279 data.dictfile = dictfiles[0];
18280
18281 hc_timer_set (&data.timer_running);
18282 }
18283 }
18284 }
18285 }
18286 // NOTE: combi is okay because it is already set beforehand
18287 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
18288 {
18289 if (data.dictfile == NULL)
18290 {
18291 if (dictfiles != NULL)
18292 {
18293 hc_timer_set (&data.timer_running);
18294
18295 data.dictfile = dictfiles[0];
18296 }
18297 }
18298 }
18299 else if (attack_mode == ATTACK_MODE_BF)
18300 {
18301 if (data.mask == NULL)
18302 {
18303 hc_timer_set (&data.timer_running);
18304
18305 data.mask = masks[0];
18306 }
18307 }
18308
18309 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18310 {
18311 data.devices_status = STATUS_EXHAUSTED;
18312 }
18313
18314 // if cracked / aborted remove last induction dictionary
18315
18316 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
18317 {
18318 struct stat induct_stat;
18319
18320 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
18321 {
18322 unlink (induction_dictionaries[file_pos]);
18323 }
18324 }
18325
18326 // wait for non-interactive threads
18327
18328 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
18329 {
18330 hc_thread_wait (1, &ni_threads[thread_idx]);
18331 }
18332
18333 local_free (ni_threads);
18334
18335 // wait for interactive threads
18336
18337 for (uint thread_idx = 0; thread_idx < i_threads_cnt; thread_idx++)
18338 {
18339 hc_thread_wait (1, &i_threads[thread_idx]);
18340 }
18341
18342 local_free (i_threads);
18343
18344 // we dont need restore file anymore
18345 if (data.restore_disable == 0)
18346 {
18347 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
18348 {
18349 unlink (eff_restore_file);
18350 unlink (new_restore_file);
18351 }
18352 else
18353 {
18354 cycle_restore ();
18355 }
18356 }
18357
18358 // finally save left hashes
18359
18360 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
18361 {
18362 save_hash ();
18363 }
18364
18365 /**
18366 * Clean up
18367 */
18368
18369 if (benchmark == 1)
18370 {
18371 status_benchmark ();
18372
18373 if (machine_readable == 0)
18374 {
18375 log_info ("");
18376 }
18377 }
18378 else
18379 {
18380 if (quiet == 0) clear_prompt ();
18381
18382 if (quiet == 0) log_info ("");
18383
18384 if (status == 1)
18385 {
18386 status_display ();
18387 }
18388 else
18389 {
18390 if (quiet == 0) status_display ();
18391 }
18392
18393 if (quiet == 0) log_info ("");
18394 }
18395
18396 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18397 {
18398 hc_device_param_t *device_param = &data.devices_param[device_id];
18399
18400 if (device_param->skipped) continue;
18401
18402 local_free (device_param->combs_buf);
18403
18404 local_free (device_param->hooks_buf);
18405
18406 local_free (device_param->device_name);
18407
18408 local_free (device_param->device_name_chksum);
18409
18410 local_free (device_param->device_version);
18411
18412 local_free (device_param->driver_version);
18413
18414 if (device_param->pws_buf) myfree (device_param->pws_buf);
18415 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
18416 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
18417 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
18418 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
18419 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
18420 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
18421 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
18422 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
18423 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
18424 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
18425 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
18426 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
18427 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
18428 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
18429 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
18430 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
18431 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
18432 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
18433 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
18434 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
18435 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
18436 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
18437 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
18438 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
18439 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
18440 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
18441 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
18442 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
18443
18444 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
18445 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
18446 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
18447 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
18448 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
18449 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
18450 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
18451 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
18452 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
18453 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
18454 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
18455
18456 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
18457 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
18458 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
18459
18460 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
18461 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
18462 }
18463
18464 // reset default fan speed
18465
18466 #ifdef HAVE_HWMON
18467 if (gpu_temp_disable == 0)
18468 {
18469 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
18470 {
18471 hc_thread_mutex_lock (mux_adl);
18472
18473 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18474 {
18475 hc_device_param_t *device_param = &data.devices_param[device_id];
18476
18477 if (device_param->skipped) continue;
18478
18479 if (data.hm_device[device_id].fan_set_supported == 1)
18480 {
18481 int fanspeed = temp_retain_fanspeed_value[device_id];
18482 int fanpolicy = temp_retain_fanpolicy_value[device_id];
18483
18484 if (fanpolicy == 1)
18485 {
18486 int rc = -1;
18487
18488 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18489 {
18490 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
18491 }
18492 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18493 {
18494 #ifdef LINUX
18495 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE);
18496 #endif
18497
18498 #ifdef WIN
18499 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, fanpolicy);
18500 #endif
18501 }
18502
18503 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18504 }
18505 }
18506 }
18507
18508 hc_thread_mutex_unlock (mux_adl);
18509 }
18510 }
18511
18512 // reset power tuning
18513
18514 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
18515 {
18516 hc_thread_mutex_lock (mux_adl);
18517
18518 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18519 {
18520 hc_device_param_t *device_param = &data.devices_param[device_id];
18521
18522 if (device_param->skipped) continue;
18523
18524 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18525 {
18526 if (data.hm_device[device_id].od_version == 6)
18527 {
18528 // check powertune capabilities first, if not available then skip device
18529
18530 int powertune_supported = 0;
18531
18532 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18533 {
18534 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18535
18536 return (-1);
18537 }
18538
18539 if (powertune_supported != 0)
18540 {
18541 // powercontrol settings
18542
18543 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18544 {
18545 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18546
18547 return (-1);
18548 }
18549
18550 // clocks
18551
18552 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18553
18554 performance_state->iNumberOfPerformanceLevels = 2;
18555
18556 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18557 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18558 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18559 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18560
18561 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18562 {
18563 log_info ("ERROR: Failed to restore ADL performance state");
18564
18565 return (-1);
18566 }
18567
18568 local_free (performance_state);
18569 }
18570 }
18571 }
18572
18573 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18574 {
18575 unsigned int limit = nvml_power_limit[device_id];
18576
18577 if (limit > 0)
18578 {
18579 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18580 }
18581 }
18582 }
18583
18584 hc_thread_mutex_unlock (mux_adl);
18585 }
18586
18587 if (gpu_temp_disable == 0)
18588 {
18589 if (data.hm_nvml)
18590 {
18591 hm_NVML_nvmlShutdown (data.hm_nvml);
18592
18593 nvml_close (data.hm_nvml);
18594
18595 data.hm_nvml = NULL;
18596 }
18597
18598 if (data.hm_nvapi)
18599 {
18600 hm_NvAPI_Unload (data.hm_nvapi);
18601
18602 nvapi_close (data.hm_nvapi);
18603
18604 data.hm_nvapi = NULL;
18605 }
18606
18607 if (data.hm_xnvctrl)
18608 {
18609 hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);
18610
18611 xnvctrl_close (data.hm_xnvctrl);
18612
18613 data.hm_xnvctrl = NULL;
18614 }
18615
18616 if (data.hm_adl)
18617 {
18618 hm_ADL_Main_Control_Destroy (data.hm_adl);
18619
18620 adl_close (data.hm_adl);
18621
18622 data.hm_adl = NULL;
18623 }
18624 }
18625 #endif // HAVE_HWMON
18626
18627 // free memory
18628
18629 local_free (masks);
18630
18631 local_free (dictstat_base);
18632
18633 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18634 {
18635 pot_t *pot_ptr = &pot[pot_pos];
18636
18637 hash_t *hash = &pot_ptr->hash;
18638
18639 local_free (hash->digest);
18640
18641 if (isSalted)
18642 {
18643 local_free (hash->salt);
18644 }
18645 }
18646
18647 local_free (pot);
18648
18649 local_free (all_kernel_rules_cnt);
18650 local_free (all_kernel_rules_buf);
18651
18652 local_free (wl_data->buf);
18653 local_free (wl_data);
18654
18655 local_free (bitmap_s1_a);
18656 local_free (bitmap_s1_b);
18657 local_free (bitmap_s1_c);
18658 local_free (bitmap_s1_d);
18659 local_free (bitmap_s2_a);
18660 local_free (bitmap_s2_b);
18661 local_free (bitmap_s2_c);
18662 local_free (bitmap_s2_d);
18663
18664 #ifdef HAVE_HWMON
18665 local_free (temp_retain_fanspeed_value);
18666 local_free (od_clock_mem_status);
18667 local_free (od_power_control_status);
18668 local_free (nvml_power_limit);
18669 #endif
18670
18671 global_free (devices_param);
18672
18673 global_free (kernel_rules_buf);
18674
18675 global_free (root_css_buf);
18676 global_free (markov_css_buf);
18677
18678 global_free (digests_buf);
18679 global_free (digests_shown);
18680 global_free (digests_shown_tmp);
18681
18682 global_free (salts_buf);
18683 global_free (salts_shown);
18684
18685 global_free (esalts_buf);
18686
18687 global_free (words_progress_done);
18688 global_free (words_progress_rejected);
18689 global_free (words_progress_restored);
18690
18691 if (pot_fp) fclose (pot_fp);
18692
18693 if (data.devices_status == STATUS_QUIT) break;
18694 }
18695
18696 // destroy others mutex
18697
18698 hc_thread_mutex_delete (mux_dispatcher);
18699 hc_thread_mutex_delete (mux_counter);
18700 hc_thread_mutex_delete (mux_display);
18701 hc_thread_mutex_delete (mux_adl);
18702
18703 // free memory
18704
18705 local_free (eff_restore_file);
18706 local_free (new_restore_file);
18707
18708 local_free (rd);
18709
18710 // tuning db
18711
18712 tuning_db_destroy (tuning_db);
18713
18714 // loopback
18715
18716 local_free (loopback_file);
18717
18718 if (loopback == 1) unlink (loopback_file);
18719
18720 // induction directory
18721
18722 if (induction_dir == NULL)
18723 {
18724 if (attack_mode != ATTACK_MODE_BF)
18725 {
18726 if (rmdir (induction_directory) == -1)
18727 {
18728 if (errno == ENOENT)
18729 {
18730 // good, we can ignore
18731 }
18732 else if (errno == ENOTEMPTY)
18733 {
18734 // good, we can ignore
18735 }
18736 else
18737 {
18738 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18739
18740 return (-1);
18741 }
18742 }
18743
18744 local_free (induction_directory);
18745 }
18746 }
18747
18748 // outfile-check directory
18749
18750 if (outfile_check_dir == NULL)
18751 {
18752 if (rmdir (outfile_check_directory) == -1)
18753 {
18754 if (errno == ENOENT)
18755 {
18756 // good, we can ignore
18757 }
18758 else if (errno == ENOTEMPTY)
18759 {
18760 // good, we can ignore
18761 }
18762 else
18763 {
18764 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18765
18766 return (-1);
18767 }
18768 }
18769
18770 local_free (outfile_check_directory);
18771 }
18772
18773 time_t proc_stop;
18774
18775 time (&proc_stop);
18776
18777 logfile_top_uint (proc_start);
18778 logfile_top_uint (proc_stop);
18779
18780 logfile_top_msg ("STOP");
18781
18782 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18783 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18784
18785 if (data.ocl) ocl_close (data.ocl);
18786
18787 if (data.devices_status == STATUS_ABORTED) return 2;
18788 if (data.devices_status == STATUS_QUIT) return 2;
18789 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18790 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18791 if (data.devices_status == STATUS_CRACKED) return 0;
18792
18793 return -1;
18794 }
Hashcat additions to support pwdhash