projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge pull request #378 from dropdeadfu/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 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1757 }
1758
1759 char display_all_cur[16] = { 0 };
1760
1761 strncpy (display_all_cur, "0.00", 4);
1762
1763 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1764
1765 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1766 }
1767
1768 /**
1769 * hashcat -only- functions
1770 */
1771
1772 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1773 {
1774 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1775 {
1776 if (attack_kern == ATTACK_KERN_STRAIGHT)
1777 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1778 else if (attack_kern == ATTACK_KERN_COMBI)
1779 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1780 else if (attack_kern == ATTACK_KERN_BF)
1781 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1782 }
1783 else
1784 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1785 }
1786
1787 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1788 {
1789 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1790 {
1791 if (attack_kern == ATTACK_KERN_STRAIGHT)
1792 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1793 else if (attack_kern == ATTACK_KERN_COMBI)
1794 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1795 else if (attack_kern == ATTACK_KERN_BF)
1796 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1797 }
1798 else
1799 {
1800 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1801 }
1802 }
1803
1804 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1805 {
1806 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1807 {
1808 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1809 }
1810 else
1811 {
1812 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1813 }
1814 }
1815
1816 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1817 {
1818 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1819 {
1820 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1821 }
1822 else
1823 {
1824 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1825 }
1826 }
1827
1828 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1829 {
1830 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1831 }
1832
1833 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1834 {
1835 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1836 }
1837
1838 static char *filename_from_filepath (char *filepath)
1839 {
1840 char *ptr = NULL;
1841
1842 if ((ptr = strrchr (filepath, '/')) != NULL)
1843 {
1844 ptr++;
1845 }
1846 else if ((ptr = strrchr (filepath, '\\')) != NULL)
1847 {
1848 ptr++;
1849 }
1850 else
1851 {
1852 ptr = filepath;
1853 }
1854
1855 return ptr;
1856 }
1857
1858 static uint convert_from_hex (char *line_buf, const uint line_len)
1859 {
1860 if (line_len & 1) return (line_len); // not in hex
1861
1862 if (data.hex_wordlist == 1)
1863 {
1864 uint i;
1865 uint j;
1866
1867 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1868 {
1869 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1870 }
1871
1872 memset (line_buf + i, 0, line_len - i);
1873
1874 return (i);
1875 }
1876 else if (line_len >= 6) // $HEX[] = 6
1877 {
1878 if (line_buf[0] != '$') return (line_len);
1879 if (line_buf[1] != 'H') return (line_len);
1880 if (line_buf[2] != 'E') return (line_len);
1881 if (line_buf[3] != 'X') return (line_len);
1882 if (line_buf[4] != '[') return (line_len);
1883 if (line_buf[line_len - 1] != ']') return (line_len);
1884
1885 uint i;
1886 uint j;
1887
1888 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1889 {
1890 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1891 }
1892
1893 memset (line_buf + i, 0, line_len - i);
1894
1895 return (i);
1896 }
1897
1898 return (line_len);
1899 }
1900
1901 static void clear_prompt ()
1902 {
1903 fputc ('\r', stdout);
1904
1905 for (size_t i = 0; i < strlen (PROMPT); i++)
1906 {
1907 fputc (' ', stdout);
1908 }
1909
1910 fputc ('\r', stdout);
1911
1912 fflush (stdout);
1913 }
1914
1915 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1916 {
1917 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1918 }
1919
1920 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1921 {
1922 char *outfile = data.outfile;
1923 uint quiet = data.quiet;
1924 FILE *pot_fp = data.pot_fp;
1925 uint loopback = data.loopback;
1926 uint debug_mode = data.debug_mode;
1927 char *debug_file = data.debug_file;
1928
1929 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1930 int debug_rule_len = 0; // -1 error
1931 uint debug_plain_len = 0;
1932
1933 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1934
1935 // hash
1936
1937 char out_buf[HCBUFSIZ] = { 0 };
1938
1939 const u32 salt_pos = plain->salt_pos;
1940 const u32 digest_pos = plain->digest_pos; // relative
1941 const u32 gidvid = plain->gidvid;
1942 const u32 il_pos = plain->il_pos;
1943
1944 ascii_digest (out_buf, salt_pos, digest_pos);
1945
1946 // plain
1947
1948 u64 crackpos = device_param->words_off;
1949
1950 uint plain_buf[16] = { 0 };
1951
1952 u8 *plain_ptr = (u8 *) plain_buf;
1953
1954 unsigned int plain_len = 0;
1955
1956 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1957 {
1958 pw_t pw;
1959
1960 gidd_to_pw_t (device_param, gidvid, &pw);
1961
1962 for (int i = 0; i < 16; i++)
1963 {
1964 plain_buf[i] = pw.i[i];
1965 }
1966
1967 plain_len = pw.pw_len;
1968
1969 const uint off = device_param->innerloop_pos + il_pos;
1970
1971 if (debug_mode > 0)
1972 {
1973 debug_rule_len = 0;
1974
1975 // save rule
1976 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1977 {
1978 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1979
1980 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1981 }
1982
1983 // save plain
1984 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1985 {
1986 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1987
1988 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1989
1990 debug_plain_len = plain_len;
1991 }
1992 }
1993
1994 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1995
1996 crackpos += gidvid;
1997 crackpos *= data.kernel_rules_cnt;
1998 crackpos += device_param->innerloop_pos + il_pos;
1999
2000 if (plain_len > data.pw_max) plain_len = data.pw_max;
2001 }
2002 else if (data.attack_mode == ATTACK_MODE_COMBI)
2003 {
2004 pw_t pw;
2005
2006 gidd_to_pw_t (device_param, gidvid, &pw);
2007
2008 for (int i = 0; i < 16; i++)
2009 {
2010 plain_buf[i] = pw.i[i];
2011 }
2012
2013 plain_len = pw.pw_len;
2014
2015 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2016 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2017
2018 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2019 {
2020 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2021 }
2022 else
2023 {
2024 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2025
2026 memcpy (plain_ptr, comb_buf, comb_len);
2027 }
2028
2029 plain_len += comb_len;
2030
2031 crackpos += gidvid;
2032 crackpos *= data.combs_cnt;
2033 crackpos += device_param->innerloop_pos + il_pos;
2034
2035 if (data.pw_max != PW_DICTMAX1)
2036 {
2037 if (plain_len > data.pw_max) plain_len = data.pw_max;
2038 }
2039 }
2040 else if (data.attack_mode == ATTACK_MODE_BF)
2041 {
2042 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2043 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2044
2045 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2046 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2047
2048 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2049 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2050
2051 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2052 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2053
2054 plain_len = data.css_cnt;
2055
2056 crackpos += gidvid;
2057 crackpos *= data.bfs_cnt;
2058 crackpos += device_param->innerloop_pos + il_pos;
2059 }
2060 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2061 {
2062 pw_t pw;
2063
2064 gidd_to_pw_t (device_param, gidvid, &pw);
2065
2066 for (int i = 0; i < 16; i++)
2067 {
2068 plain_buf[i] = pw.i[i];
2069 }
2070
2071 plain_len = pw.pw_len;
2072
2073 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2074
2075 uint start = 0;
2076 uint stop = device_param->kernel_params_mp_buf32[4];
2077
2078 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2079
2080 plain_len += start + stop;
2081
2082 crackpos += gidvid;
2083 crackpos *= data.combs_cnt;
2084 crackpos += device_param->innerloop_pos + il_pos;
2085
2086 if (data.pw_max != PW_DICTMAX1)
2087 {
2088 if (plain_len > data.pw_max) plain_len = data.pw_max;
2089 }
2090 }
2091 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2092 {
2093 pw_t pw;
2094
2095 gidd_to_pw_t (device_param, gidvid, &pw);
2096
2097 for (int i = 0; i < 16; i++)
2098 {
2099 plain_buf[i] = pw.i[i];
2100 }
2101
2102 plain_len = pw.pw_len;
2103
2104 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2105
2106 uint start = 0;
2107 uint stop = device_param->kernel_params_mp_buf32[4];
2108
2109 memmove (plain_ptr + stop, plain_ptr, plain_len);
2110
2111 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2112
2113 plain_len += start + stop;
2114
2115 crackpos += gidvid;
2116 crackpos *= data.combs_cnt;
2117 crackpos += device_param->innerloop_pos + il_pos;
2118
2119 if (data.pw_max != PW_DICTMAX1)
2120 {
2121 if (plain_len > data.pw_max) plain_len = data.pw_max;
2122 }
2123 }
2124
2125 if (data.attack_mode == ATTACK_MODE_BF)
2126 {
2127 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2128 {
2129 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2130 {
2131 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2132 {
2133 plain_len = plain_len - data.salts_buf[0].salt_len;
2134 }
2135 }
2136
2137 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2138 {
2139 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2140 {
2141 plain_ptr[j] = plain_ptr[i];
2142 }
2143
2144 plain_len = plain_len / 2;
2145 }
2146 }
2147 }
2148
2149 // if enabled, update also the potfile
2150
2151 if (pot_fp)
2152 {
2153 lock_file (pot_fp);
2154
2155 fprintf (pot_fp, "%s:", out_buf);
2156
2157 format_plain (pot_fp, plain_ptr, plain_len, 1);
2158
2159 fputc ('\n', pot_fp);
2160
2161 fflush (pot_fp);
2162
2163 unlock_file (pot_fp);
2164 }
2165
2166 // outfile
2167
2168 FILE *out_fp = NULL;
2169
2170 if (outfile != NULL)
2171 {
2172 if ((out_fp = fopen (outfile, "ab")) == NULL)
2173 {
2174 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2175
2176 out_fp = stdout;
2177 }
2178
2179 lock_file (out_fp);
2180 }
2181 else
2182 {
2183 out_fp = stdout;
2184
2185 if (quiet == 0) clear_prompt ();
2186 }
2187
2188 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2189
2190 if (outfile != NULL)
2191 {
2192 if (out_fp != stdout)
2193 {
2194 fclose (out_fp);
2195 }
2196 }
2197 else
2198 {
2199 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2200 {
2201 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2202 {
2203 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2204 if (quiet == 0) fflush (stdout);
2205 }
2206 }
2207 }
2208
2209 // loopback
2210
2211 if (loopback)
2212 {
2213 char *loopback_file = data.loopback_file;
2214
2215 FILE *fb_fp = NULL;
2216
2217 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2218 {
2219 lock_file (fb_fp);
2220
2221 format_plain (fb_fp, plain_ptr, plain_len, 1);
2222
2223 fputc ('\n', fb_fp);
2224
2225 fclose (fb_fp);
2226 }
2227 }
2228
2229 // (rule) debug mode
2230
2231 // the next check implies that:
2232 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2233 // - debug_mode > 0
2234
2235 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2236 {
2237 if (debug_rule_len < 0) debug_rule_len = 0;
2238
2239 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2240
2241 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2242
2243 if ((quiet == 0) && (debug_file == NULL))
2244 {
2245 fprintf (stdout, "%s", PROMPT);
2246
2247 fflush (stdout);
2248 }
2249 }
2250 }
2251
2252 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2253 {
2254 salt_t *salt_buf = &data.salts_buf[salt_pos];
2255
2256 u32 num_cracked;
2257
2258 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2259
2260 if (num_cracked)
2261 {
2262 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2263
2264 log_info_nn ("");
2265
2266 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2267
2268 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, 0, num_cracked * sizeof (plain_t), cracked, 0, NULL, NULL);
2269
2270 uint cpt_cracked = 0;
2271
2272 for (uint i = 0; i < num_cracked; i++)
2273 {
2274 const uint hash_pos = cracked[i].hash_pos;
2275
2276 if (data.digests_shown[hash_pos] == 1) continue;
2277
2278 hc_thread_mutex_lock (mux_display);
2279
2280 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2281 {
2282 data.digests_shown[hash_pos] = 1;
2283
2284 data.digests_done++;
2285
2286 cpt_cracked++;
2287
2288 salt_buf->digests_done++;
2289
2290 if (salt_buf->digests_done == salt_buf->digests_cnt)
2291 {
2292 data.salts_shown[salt_pos] = 1;
2293
2294 data.salts_done++;
2295 }
2296 }
2297
2298 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2299
2300 hc_thread_mutex_unlock (mux_display);
2301
2302 check_hash (device_param, &cracked[i]);
2303 }
2304
2305 myfree (cracked);
2306
2307 if (cpt_cracked > 0)
2308 {
2309 hc_thread_mutex_lock (mux_display);
2310
2311 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2312 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2313
2314 data.cpt_pos++;
2315
2316 data.cpt_total += cpt_cracked;
2317
2318 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2319
2320 hc_thread_mutex_unlock (mux_display);
2321 }
2322
2323 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2324 {
2325 // we need to reset cracked state on the device
2326 // otherwise host thinks again and again the hash was cracked
2327 // and returns invalid password each time
2328
2329 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2330
2331 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2332 }
2333
2334 num_cracked = 0;
2335
2336 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2337 }
2338 }
2339
2340 // stolen from princeprocessor ;)
2341
2342 typedef struct
2343 {
2344 FILE *fp;
2345
2346 char buf[BUFSIZ];
2347 int len;
2348
2349 } out_t;
2350
2351 static void out_flush (out_t *out)
2352 {
2353 fwrite (out->buf, 1, out->len, out->fp);
2354
2355 out->len = 0;
2356 }
2357
2358 static void out_push (out_t *out, const u8 *pw_buf, const int pw_len)
2359 {
2360 char *ptr = out->buf + out->len;
2361
2362 memcpy (ptr, pw_buf, pw_len);
2363
2364 ptr[pw_len] = '\n';
2365
2366 out->len += pw_len + 1;
2367
2368 if (out->len >= BUFSIZ - 100)
2369 {
2370 out_flush (out);
2371 }
2372 }
2373
2374 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2375 {
2376 out_t out;
2377
2378 out.fp = stdout;
2379 out.len = 0;
2380
2381 uint plain_buf[16] = { 0 };
2382
2383 u8 *plain_ptr = (u8 *) plain_buf;
2384
2385 uint plain_len = 0;
2386
2387 const uint il_cnt = device_param->kernel_params_buf32[27]; // ugly, i know
2388
2389 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2390 {
2391 pw_t pw;
2392
2393 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2394 {
2395 gidd_to_pw_t (device_param, gidvid, &pw);
2396
2397 const uint pos = device_param->innerloop_pos;
2398
2399 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2400 {
2401 for (int i = 0; i < 8; i++)
2402 {
2403 plain_buf[i] = pw.i[i];
2404 }
2405
2406 plain_len = pw.pw_len;
2407
2408 plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2409
2410 if (plain_len > data.pw_max) plain_len = data.pw_max;
2411
2412 out_push (&out, plain_ptr, plain_len);
2413 }
2414 }
2415 }
2416 else if (data.attack_mode == ATTACK_MODE_COMBI)
2417 {
2418 pw_t pw;
2419
2420 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2421 {
2422 gidd_to_pw_t (device_param, gidvid, &pw);
2423
2424 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2425 {
2426 for (int i = 0; i < 8; i++)
2427 {
2428 plain_buf[i] = pw.i[i];
2429 }
2430
2431 plain_len = pw.pw_len;
2432
2433 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2434 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2435
2436 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2437 {
2438 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2439 }
2440 else
2441 {
2442 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2443
2444 memcpy (plain_ptr, comb_buf, comb_len);
2445 }
2446
2447 plain_len += comb_len;
2448
2449 if (data.pw_max != PW_DICTMAX1)
2450 {
2451 if (plain_len > data.pw_max) plain_len = data.pw_max;
2452 }
2453
2454 out_push (&out, plain_ptr, plain_len);
2455 }
2456 }
2457 }
2458 else if (data.attack_mode == ATTACK_MODE_BF)
2459 {
2460 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2461 {
2462 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2463 {
2464 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2465 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2466
2467 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2468 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2469
2470 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2471 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2472
2473 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2474 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2475
2476 plain_len = data.css_cnt;
2477
2478 out_push (&out, plain_ptr, plain_len);
2479 }
2480 }
2481 }
2482 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2483 {
2484 pw_t pw;
2485
2486 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2487 {
2488 gidd_to_pw_t (device_param, gidvid, &pw);
2489
2490 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2491 {
2492 for (int i = 0; i < 8; i++)
2493 {
2494 plain_buf[i] = pw.i[i];
2495 }
2496
2497 plain_len = pw.pw_len;
2498
2499 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2500
2501 uint start = 0;
2502 uint stop = device_param->kernel_params_mp_buf32[4];
2503
2504 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2505
2506 plain_len += start + stop;
2507
2508 out_push (&out, plain_ptr, plain_len);
2509 }
2510 }
2511 }
2512 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2513 {
2514 pw_t pw;
2515
2516 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2517 {
2518 gidd_to_pw_t (device_param, gidvid, &pw);
2519
2520 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2521 {
2522 for (int i = 0; i < 8; i++)
2523 {
2524 plain_buf[i] = pw.i[i];
2525 }
2526
2527 plain_len = pw.pw_len;
2528
2529 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2530
2531 uint start = 0;
2532 uint stop = device_param->kernel_params_mp_buf32[4];
2533
2534 memmove (plain_ptr + stop, plain_ptr, plain_len);
2535
2536 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2537
2538 plain_len += start + stop;
2539
2540 out_push (&out, plain_ptr, plain_len);
2541 }
2542 }
2543 }
2544
2545 out_flush (&out);
2546 }
2547
2548 static void save_hash ()
2549 {
2550 char *hashfile = data.hashfile;
2551
2552 char new_hashfile[256] = { 0 };
2553 char old_hashfile[256] = { 0 };
2554
2555 snprintf (new_hashfile, 255, "%s.new", hashfile);
2556 snprintf (old_hashfile, 255, "%s.old", hashfile);
2557
2558 unlink (new_hashfile);
2559
2560 char separator = data.separator;
2561
2562 FILE *fp = fopen (new_hashfile, "wb");
2563
2564 if (fp == NULL)
2565 {
2566 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2567
2568 exit (-1);
2569 }
2570
2571 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2572 {
2573 if (data.salts_shown[salt_pos] == 1) continue;
2574
2575 salt_t *salt_buf = &data.salts_buf[salt_pos];
2576
2577 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2578 {
2579 uint idx = salt_buf->digests_offset + digest_pos;
2580
2581 if (data.digests_shown[idx] == 1) continue;
2582
2583 if (data.hash_mode != 2500)
2584 {
2585 if (data.username == 1)
2586 {
2587 user_t *user = data.hash_info[idx]->user;
2588
2589 uint i;
2590
2591 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2592
2593 fputc (separator, fp);
2594 }
2595
2596 char out_buf[HCBUFSIZ]; // scratch buffer
2597
2598 out_buf[0] = 0;
2599
2600 ascii_digest (out_buf, salt_pos, digest_pos);
2601
2602 fputs (out_buf, fp);
2603
2604 fputc ('\n', fp);
2605 }
2606 else
2607 {
2608 hccap_t hccap;
2609
2610 to_hccap_t (&hccap, salt_pos, digest_pos);
2611
2612 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2613 }
2614 }
2615 }
2616
2617 fflush (fp);
2618
2619 fclose (fp);
2620
2621 unlink (old_hashfile);
2622
2623 if (rename (hashfile, old_hashfile) != 0)
2624 {
2625 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2626
2627 exit (-1);
2628 }
2629
2630 unlink (hashfile);
2631
2632 if (rename (new_hashfile, hashfile) != 0)
2633 {
2634 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2635
2636 exit (-1);
2637 }
2638
2639 unlink (old_hashfile);
2640 }
2641
2642 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2643 {
2644 uint num_elements = num;
2645
2646 device_param->kernel_params_buf32[30] = data.combs_mode;
2647 device_param->kernel_params_buf32[31] = num;
2648
2649 uint kernel_threads = device_param->kernel_threads;
2650
2651 while (num_elements % kernel_threads) num_elements++;
2652
2653 cl_kernel kernel = NULL;
2654
2655 switch (kern_run)
2656 {
2657 case KERN_RUN_1: kernel = device_param->kernel1; break;
2658 case KERN_RUN_12: kernel = device_param->kernel12; break;
2659 case KERN_RUN_2: kernel = device_param->kernel2; break;
2660 case KERN_RUN_23: kernel = device_param->kernel23; break;
2661 case KERN_RUN_3: kernel = device_param->kernel3; break;
2662 }
2663
2664 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2665 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2666 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2667 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2668 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2669 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2670 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2671 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2672 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2673 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2674 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2675
2676 cl_event event;
2677
2678 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2679 {
2680 const size_t global_work_size[3] = { num_elements, 32, 1 };
2681 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2682
2683 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2684 }
2685 else
2686 {
2687 if (kern_run == KERN_RUN_2)
2688 {
2689 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2690 {
2691 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2692 }
2693 }
2694
2695 while (num_elements % kernel_threads) num_elements++;
2696
2697 const size_t global_work_size[3] = { num_elements, 1, 1 };
2698 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2699
2700 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2701 }
2702
2703 hc_clFlush (data.ocl, device_param->command_queue);
2704
2705 if (device_param->nvidia_spin_damp)
2706 {
2707 if (data.devices_status == STATUS_RUNNING)
2708 {
2709 if (iteration < EXPECTED_ITERATIONS)
2710 {
2711 switch (kern_run)
2712 {
2713 case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration] * device_param->nvidia_spin_damp); break;
2714 case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration] * device_param->nvidia_spin_damp); break;
2715 case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration] * device_param->nvidia_spin_damp); break;
2716 }
2717 }
2718 }
2719 }
2720
2721 hc_clWaitForEvents (data.ocl, 1, &event);
2722
2723 cl_ulong time_start;
2724 cl_ulong time_end;
2725
2726 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2727 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2728
2729 const double exec_us = (double) (time_end - time_start) / 1000;
2730
2731 if (data.devices_status == STATUS_RUNNING)
2732 {
2733 if (iteration < EXPECTED_ITERATIONS)
2734 {
2735 switch (kern_run)
2736 {
2737 case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2738 case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2739 case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2740 }
2741 }
2742 }
2743
2744 if (event_update)
2745 {
2746 uint exec_pos = device_param->exec_pos;
2747
2748 device_param->exec_ms[exec_pos] = exec_us / 1000;
2749
2750 exec_pos++;
2751
2752 if (exec_pos == EXEC_CACHE)
2753 {
2754 exec_pos = 0;
2755 }
2756
2757 device_param->exec_pos = exec_pos;
2758 }
2759
2760 hc_clReleaseEvent (data.ocl, event);
2761
2762 hc_clFinish (data.ocl, device_param->command_queue);
2763 }
2764
2765 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2766 {
2767 uint num_elements = num;
2768
2769 switch (kern_run)
2770 {
2771 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2772 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2773 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2774 }
2775
2776 // causes problems with special threads like in bcrypt
2777 // const uint kernel_threads = device_param->kernel_threads;
2778
2779 uint kernel_threads = device_param->kernel_threads;
2780
2781 while (num_elements % kernel_threads) num_elements++;
2782
2783 cl_kernel kernel = NULL;
2784
2785 switch (kern_run)
2786 {
2787 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2788 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2789 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2790 }
2791
2792 switch (kern_run)
2793 {
2794 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2795 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2796 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2797 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2798 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2799 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2800 break;
2801 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2802 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2803 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2804 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2805 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2806 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2807 break;
2808 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2809 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2810 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2811 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2812 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2813 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2814 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2815 break;
2816 }
2817
2818 const size_t global_work_size[3] = { num_elements, 1, 1 };
2819 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2820
2821 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2822
2823 hc_clFlush (data.ocl, device_param->command_queue);
2824
2825 hc_clFinish (data.ocl, device_param->command_queue);
2826 }
2827
2828 static void run_kernel_tm (hc_device_param_t *device_param)
2829 {
2830 const uint num_elements = 1024; // fixed
2831
2832 uint kernel_threads = 32;
2833
2834 cl_kernel kernel = device_param->kernel_tm;
2835
2836 const size_t global_work_size[3] = { num_elements, 1, 1 };
2837 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2838
2839 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2840
2841 hc_clFlush (data.ocl, device_param->command_queue);
2842
2843 hc_clFinish (data.ocl, device_param->command_queue);
2844 }
2845
2846 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2847 {
2848 uint num_elements = num;
2849
2850 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2851 device_param->kernel_params_amp_buf32[6] = num_elements;
2852
2853 // causes problems with special threads like in bcrypt
2854 // const uint kernel_threads = device_param->kernel_threads;
2855
2856 uint kernel_threads = device_param->kernel_threads;
2857
2858 while (num_elements % kernel_threads) num_elements++;
2859
2860 cl_kernel kernel = device_param->kernel_amp;
2861
2862 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2863 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2864
2865 const size_t global_work_size[3] = { num_elements, 1, 1 };
2866 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2867
2868 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2869
2870 hc_clFlush (data.ocl, device_param->command_queue);
2871
2872 hc_clFinish (data.ocl, device_param->command_queue);
2873 }
2874
2875 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2876 {
2877 const u32 num16d = num / 16;
2878 const u32 num16m = num % 16;
2879
2880 if (num16d)
2881 {
2882 device_param->kernel_params_memset_buf32[1] = value;
2883 device_param->kernel_params_memset_buf32[2] = num16d;
2884
2885 uint kernel_threads = device_param->kernel_threads;
2886
2887 uint num_elements = num16d;
2888
2889 while (num_elements % kernel_threads) num_elements++;
2890
2891 cl_kernel kernel = device_param->kernel_memset;
2892
2893 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2894 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2895 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2896
2897 const size_t global_work_size[3] = { num_elements, 1, 1 };
2898 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2899
2900 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2901
2902 hc_clFlush (data.ocl, device_param->command_queue);
2903
2904 hc_clFinish (data.ocl, device_param->command_queue);
2905 }
2906
2907 if (num16m)
2908 {
2909 u32 tmp[4];
2910
2911 tmp[0] = value;
2912 tmp[1] = value;
2913 tmp[2] = value;
2914 tmp[3] = value;
2915
2916 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2917 }
2918 }
2919
2920 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2921 {
2922 run_kernel_memset (device_param, buf, 0, size);
2923
2924 /*
2925 int rc = -1;
2926
2927 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2928 {
2929 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2930
2931 const cl_uchar zero = 0;
2932
2933 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2934 }
2935
2936 if (rc != 0)
2937 {
2938 // NOTE: clEnqueueFillBuffer () always fails with -59
2939 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2940 // How's that possible, OpenCL 1.2 support is advertised??
2941 // We need to workaround...
2942
2943 #define FILLSZ 0x100000
2944
2945 char *tmp = (char *) mymalloc (FILLSZ);
2946
2947 for (size_t i = 0; i < size; i += FILLSZ)
2948 {
2949 const size_t left = size - i;
2950
2951 const size_t fillsz = MIN (FILLSZ, left);
2952
2953 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2954 }
2955
2956 myfree (tmp);
2957 }
2958 */
2959 }
2960
2961 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)
2962 {
2963 if (data.hash_mode == 2000)
2964 {
2965 process_stdout (device_param, pws_cnt);
2966
2967 return;
2968 }
2969
2970 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2971 {
2972 if (attack_mode == ATTACK_MODE_BF)
2973 {
2974 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2975 {
2976 const uint size_tm = 32 * sizeof (bs_word_t);
2977
2978 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2979
2980 run_kernel_tm (device_param);
2981
2982 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);
2983 }
2984 }
2985
2986 if (highest_pw_len < 16)
2987 {
2988 run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
2989 }
2990 else if (highest_pw_len < 32)
2991 {
2992 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
2993 }
2994 else
2995 {
2996 run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
2997 }
2998 }
2999 else
3000 {
3001 run_kernel_amp (device_param, pws_cnt);
3002
3003 run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
3004
3005 if (opts_type & OPTS_TYPE_HOOK12)
3006 {
3007 run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
3008
3009 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);
3010
3011 // do something with data
3012
3013 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);
3014 }
3015
3016 uint iter = salt_buf->salt_iter;
3017
3018 uint loop_step = device_param->kernel_loops;
3019
3020 for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
3021 {
3022 uint loop_left = iter - loop_pos;
3023
3024 loop_left = MIN (loop_left, loop_step);
3025
3026 device_param->kernel_params_buf32[25] = loop_pos;
3027 device_param->kernel_params_buf32[26] = loop_left;
3028
3029 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
3030
3031 if (data.devices_status == STATUS_CRACKED) break;
3032 if (data.devices_status == STATUS_ABORTED) break;
3033 if (data.devices_status == STATUS_QUIT) break;
3034
3035 /**
3036 * speed
3037 */
3038
3039 const float iter_part = (float) (loop_pos + loop_left) / iter;
3040
3041 const u64 perf_sum_all = pws_cnt * iter_part;
3042
3043 double speed_ms;
3044
3045 hc_timer_get (device_param->timer_speed, speed_ms);
3046
3047 const u32 speed_pos = device_param->speed_pos;
3048
3049 device_param->speed_cnt[speed_pos] = perf_sum_all;
3050
3051 device_param->speed_ms[speed_pos] = speed_ms;
3052
3053 if (data.benchmark == 1)
3054 {
3055 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
3056 }
3057 }
3058
3059 if (opts_type & OPTS_TYPE_HOOK23)
3060 {
3061 run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
3062
3063 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);
3064
3065 // do something with data
3066
3067 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);
3068 }
3069
3070 run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3071 }
3072 }
3073
3074 static int run_rule_engine (const int rule_len, const char *rule_buf)
3075 {
3076 if (rule_len == 0)
3077 {
3078 return 0;
3079 }
3080 else if (rule_len == 1)
3081 {
3082 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3083 }
3084
3085 return 1;
3086 }
3087
3088 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3089 {
3090 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3091 {
3092 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);
3093 }
3094 else if (data.attack_kern == ATTACK_KERN_COMBI)
3095 {
3096 if (data.attack_mode == ATTACK_MODE_COMBI)
3097 {
3098 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3099 {
3100 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3101 {
3102 for (u32 i = 0; i < pws_cnt; i++)
3103 {
3104 const u32 pw_len = device_param->pws_buf[i].pw_len;
3105
3106 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3107
3108 ptr[pw_len] = 0x01;
3109 }
3110 }
3111 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3112 {
3113 for (u32 i = 0; i < pws_cnt; i++)
3114 {
3115 const u32 pw_len = device_param->pws_buf[i].pw_len;
3116
3117 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3118
3119 ptr[pw_len] = 0x80;
3120 }
3121 }
3122 }
3123 }
3124 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3125 {
3126 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3127 {
3128 for (u32 i = 0; i < pws_cnt; i++)
3129 {
3130 const u32 pw_len = device_param->pws_buf[i].pw_len;
3131
3132 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3133
3134 ptr[pw_len] = 0x01;
3135 }
3136 }
3137 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3138 {
3139 for (u32 i = 0; i < pws_cnt; i++)
3140 {
3141 const u32 pw_len = device_param->pws_buf[i].pw_len;
3142
3143 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3144
3145 ptr[pw_len] = 0x80;
3146 }
3147 }
3148 }
3149
3150 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);
3151 }
3152 else if (data.attack_kern == ATTACK_KERN_BF)
3153 {
3154 const u64 off = device_param->words_off;
3155
3156 device_param->kernel_params_mp_l_buf64[3] = off;
3157
3158 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3159 }
3160 }
3161
3162 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3163 {
3164 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3165
3166 device_param->kernel_params_buf32[25] = 0;
3167 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
3168 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3169
3170 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3171 {
3172 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3173 }
3174 else
3175 {
3176 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3177 }
3178
3179 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3180
3181 return exec_ms_prev;
3182 }
3183
3184 static void autotune (hc_device_param_t *device_param)
3185 {
3186 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3187
3188 const u32 kernel_accel_min = device_param->kernel_accel_min;
3189 const u32 kernel_accel_max = device_param->kernel_accel_max;
3190
3191 const u32 kernel_loops_min = device_param->kernel_loops_min;
3192 const u32 kernel_loops_max = device_param->kernel_loops_max;
3193
3194 u32 kernel_accel = kernel_accel_min;
3195 u32 kernel_loops = kernel_loops_min;
3196
3197 // in this case the user specified a fixed -u and -n on the commandline
3198 // no way to tune anything
3199 // but we need to run a few caching rounds
3200
3201 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3202 {
3203 if (data.hash_mode != 2000)
3204 {
3205 try_run (device_param, kernel_accel, kernel_loops);
3206 try_run (device_param, kernel_accel, kernel_loops);
3207 try_run (device_param, kernel_accel, kernel_loops);
3208 try_run (device_param, kernel_accel, kernel_loops);
3209 }
3210
3211 device_param->kernel_accel = kernel_accel;
3212 device_param->kernel_loops = kernel_loops;
3213
3214 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3215
3216 device_param->kernel_power = kernel_power;
3217
3218 return;
3219 }
3220
3221 // from here it's clear we are allowed to autotune
3222 // so let's init some fake words
3223
3224 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3225
3226 if (data.attack_kern == ATTACK_KERN_BF)
3227 {
3228 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3229 }
3230 else
3231 {
3232 for (u32 i = 0; i < kernel_power_max; i++)
3233 {
3234 device_param->pws_buf[i].i[0] = i;
3235 device_param->pws_buf[i].i[1] = 0x01234567;
3236 device_param->pws_buf[i].pw_len = 7 + (i & 7);
3237 }
3238
3239 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);
3240 }
3241
3242 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3243 {
3244 if (data.kernel_rules_cnt > 1)
3245 {
3246 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);
3247 }
3248 }
3249 else
3250 {
3251 run_kernel_amp (device_param, kernel_power_max);
3252 }
3253
3254 #define VERIFIER_CNT 1
3255
3256 // first find out highest kernel-loops that stays below target_ms
3257
3258 if (kernel_loops_min < kernel_loops_max)
3259 {
3260 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3261 {
3262 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3263
3264 for (int i = 0; i < VERIFIER_CNT; i++)
3265 {
3266 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3267
3268 exec_ms = MIN (exec_ms, exec_ms_v);
3269 }
3270
3271 if (exec_ms < target_ms) break;
3272 }
3273 }
3274
3275 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3276
3277 #define STEPS_CNT 10
3278
3279 if (kernel_accel_min < kernel_accel_max)
3280 {
3281 for (int i = 0; i < STEPS_CNT; i++)
3282 {
3283 const u32 kernel_accel_try = 1 << i;
3284
3285 if (kernel_accel_try < kernel_accel_min) continue;
3286 if (kernel_accel_try > kernel_accel_max) break;
3287
3288 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3289
3290 for (int i = 0; i < VERIFIER_CNT; i++)
3291 {
3292 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3293
3294 exec_ms = MIN (exec_ms, exec_ms_v);
3295 }
3296
3297 if (exec_ms > target_ms) break;
3298
3299 kernel_accel = kernel_accel_try;
3300 }
3301 }
3302
3303 // at this point we want to know the actual runtime for the following reason:
3304 // we need a reference for the balancing loop following up, and this
3305 // the balancing loop can have an effect that the creates a new opportunity, for example:
3306 // if the target is 95 ms and the current runtime is 48ms the above loop
3307 // stopped the execution because the previous exec_ms was > 95ms
3308 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3309 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3310
3311 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3312
3313 for (int i = 0; i < VERIFIER_CNT; i++)
3314 {
3315 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3316
3317 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3318 }
3319
3320 u32 diff = kernel_loops - kernel_accel;
3321
3322 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3323 {
3324 u32 kernel_accel_orig = kernel_accel;
3325 u32 kernel_loops_orig = kernel_loops;
3326
3327 for (u32 f = 1; f < 1024; f++)
3328 {
3329 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3330 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3331
3332 if (kernel_accel_try > kernel_accel_max) break;
3333 if (kernel_loops_try < kernel_loops_min) break;
3334
3335 u32 diff_new = kernel_loops_try - kernel_accel_try;
3336
3337 if (diff_new > diff) break;
3338
3339 diff_new = diff;
3340
3341 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3342
3343 for (int i = 0; i < VERIFIER_CNT; i++)
3344 {
3345 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3346
3347 exec_ms = MIN (exec_ms, exec_ms_v);
3348 }
3349
3350 if (exec_ms < exec_ms_pre_final)
3351 {
3352 exec_ms_pre_final = exec_ms;
3353
3354 kernel_accel = kernel_accel_try;
3355 kernel_loops = kernel_loops_try;
3356 }
3357 }
3358 }
3359
3360 const double exec_left = target_ms / exec_ms_pre_final;
3361
3362 const double accel_left = kernel_accel_max / kernel_accel;
3363
3364 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3365
3366 if (exec_accel_min >= 1.0)
3367 {
3368 // this is safe to not overflow kernel_accel_max because of accel_left
3369
3370 kernel_accel = (double) kernel_accel * exec_accel_min;
3371 }
3372
3373 // reset them fake words
3374
3375 /*
3376 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3377
3378 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);
3379 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);
3380 */
3381
3382 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3383
3384 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3385 {
3386 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3387 }
3388
3389 // reset timer
3390
3391 device_param->exec_pos = 0;
3392
3393 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3394
3395 memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3396 memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3397 memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3398
3399 // store
3400
3401 device_param->kernel_accel = kernel_accel;
3402 device_param->kernel_loops = kernel_loops;
3403
3404 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3405
3406 device_param->kernel_power = kernel_power;
3407
3408 #ifdef DEBUG
3409
3410 if (data.quiet == 0)
3411 {
3412 clear_prompt ();
3413
3414 log_info ("- Device #%u: autotuned kernel-accel to %u\n"
3415 "- Device #%u: autotuned kernel-loops to %u\n",
3416 device_param->device_id + 1, kernel_accel,
3417 device_param->device_id + 1, kernel_loops);
3418
3419 fprintf (stdout, "%s", PROMPT);
3420
3421 fflush (stdout);
3422 }
3423
3424 #endif
3425 }
3426
3427 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3428 {
3429 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3430
3431 // init speed timer
3432
3433 uint speed_pos = device_param->speed_pos;
3434
3435 #ifdef _POSIX
3436 if (device_param->timer_speed.tv_sec == 0)
3437 {
3438 hc_timer_set (&device_param->timer_speed);
3439 }
3440 #endif
3441
3442 #ifdef _WIN
3443 if (device_param->timer_speed.QuadPart == 0)
3444 {
3445 hc_timer_set (&device_param->timer_speed);
3446 }
3447 #endif
3448
3449 // find higest password length, this is for optimization stuff
3450
3451 uint highest_pw_len = 0;
3452
3453 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3454 {
3455 }
3456 else if (data.attack_kern == ATTACK_KERN_COMBI)
3457 {
3458 }
3459 else if (data.attack_kern == ATTACK_KERN_BF)
3460 {
3461 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3462 + device_param->kernel_params_mp_l_buf32[5];
3463 }
3464
3465 // iteration type
3466
3467 uint innerloop_step = 0;
3468 uint innerloop_cnt = 0;
3469
3470 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3471 else innerloop_step = 1;
3472
3473 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3474 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3475 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3476
3477 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3478
3479 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3480 {
3481 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3482
3483 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3484
3485 if (data.devices_status == STATUS_CRACKED) break;
3486 if (data.devices_status == STATUS_ABORTED) break;
3487 if (data.devices_status == STATUS_QUIT) break;
3488 if (data.devices_status == STATUS_BYPASS) break;
3489
3490 salt_t *salt_buf = &data.salts_buf[salt_pos];
3491
3492 device_param->kernel_params_buf32[24] = salt_pos;
3493 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3494 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3495
3496 FILE *combs_fp = device_param->combs_fp;
3497
3498 if (data.attack_mode == ATTACK_MODE_COMBI)
3499 {
3500 rewind (combs_fp);
3501 }
3502
3503 // innerloops
3504
3505 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3506 {
3507 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3508
3509 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3510
3511 if (data.devices_status == STATUS_CRACKED) break;
3512 if (data.devices_status == STATUS_ABORTED) break;
3513 if (data.devices_status == STATUS_QUIT) break;
3514 if (data.devices_status == STATUS_BYPASS) break;
3515
3516 uint fast_iteration = 0;
3517
3518 uint innerloop_left = innerloop_cnt - innerloop_pos;
3519
3520 if (innerloop_left > innerloop_step)
3521 {
3522 innerloop_left = innerloop_step;
3523
3524 fast_iteration = 1;
3525 }
3526
3527 device_param->innerloop_pos = innerloop_pos;
3528 device_param->innerloop_left = innerloop_left;
3529
3530 device_param->kernel_params_buf32[27] = innerloop_left;
3531
3532 // i think we can get rid of this
3533 if (innerloop_left == 0)
3534 {
3535 puts ("bug, how should this happen????\n");
3536
3537 continue;
3538 }
3539
3540 if (data.salts_shown[salt_pos] == 1)
3541 {
3542 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3543
3544 continue;
3545 }
3546
3547 // initialize amplifiers
3548
3549 if (data.attack_mode == ATTACK_MODE_COMBI)
3550 {
3551 uint i = 0;
3552
3553 while (i < innerloop_left)
3554 {
3555 if (feof (combs_fp)) break;
3556
3557 int line_len = fgetl (combs_fp, line_buf);
3558
3559 if (line_len >= PW_MAX1) continue;
3560
3561 line_len = convert_from_hex (line_buf, line_len);
3562
3563 char *line_buf_new = line_buf;
3564
3565 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3566 {
3567 char rule_buf_out[BLOCK_SIZE] = { 0 };
3568
3569 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3570
3571 if (rule_len_out < 0)
3572 {
3573 data.words_progress_rejected[salt_pos] += pws_cnt;
3574
3575 continue;
3576 }
3577
3578 line_len = rule_len_out;
3579
3580 line_buf_new = rule_buf_out;
3581 }
3582
3583 line_len = MIN (line_len, PW_DICTMAX);
3584
3585 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3586
3587 memcpy (ptr, line_buf_new, line_len);
3588
3589 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3590
3591 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3592 {
3593 uppercase (ptr, line_len);
3594 }
3595
3596 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3597 {
3598 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3599 {
3600 ptr[line_len] = 0x80;
3601 }
3602
3603 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3604 {
3605 ptr[line_len] = 0x01;
3606 }
3607 }
3608
3609 device_param->combs_buf[i].pw_len = line_len;
3610
3611 i++;
3612 }
3613
3614 for (uint j = i; j < innerloop_left; j++)
3615 {
3616 device_param->combs_buf[j].i[0] = 0;
3617 device_param->combs_buf[j].i[1] = 0;
3618 device_param->combs_buf[j].i[2] = 0;
3619 device_param->combs_buf[j].i[3] = 0;
3620 device_param->combs_buf[j].i[4] = 0;
3621 device_param->combs_buf[j].i[5] = 0;
3622 device_param->combs_buf[j].i[6] = 0;
3623 device_param->combs_buf[j].i[7] = 0;
3624
3625 device_param->combs_buf[j].pw_len = 0;
3626 }
3627
3628 innerloop_left = i;
3629 }
3630 else if (data.attack_mode == ATTACK_MODE_BF)
3631 {
3632 u64 off = innerloop_pos;
3633
3634 device_param->kernel_params_mp_r_buf64[3] = off;
3635
3636 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3637 }
3638 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3639 {
3640 u64 off = innerloop_pos;
3641
3642 device_param->kernel_params_mp_buf64[3] = off;
3643
3644 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3645 }
3646 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3647 {
3648 u64 off = innerloop_pos;
3649
3650 device_param->kernel_params_mp_buf64[3] = off;
3651
3652 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3653 }
3654
3655 // copy amplifiers
3656
3657 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3658 {
3659 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);
3660 }
3661 else if (data.attack_mode == ATTACK_MODE_COMBI)
3662 {
3663 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);
3664 }
3665 else if (data.attack_mode == ATTACK_MODE_BF)
3666 {
3667 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);
3668 }
3669 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3670 {
3671 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);
3672 }
3673 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3674 {
3675 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);
3676 }
3677
3678 if (data.benchmark == 1)
3679 {
3680 hc_timer_set (&device_param->timer_speed);
3681 }
3682
3683 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
3684
3685 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3686
3687 if (data.devices_status == STATUS_CRACKED) break;
3688 if (data.devices_status == STATUS_ABORTED) break;
3689 if (data.devices_status == STATUS_QUIT) break;
3690
3691 /**
3692 * result
3693 */
3694
3695 if (data.benchmark == 0)
3696 {
3697 check_cracked (device_param, salt_pos);
3698 }
3699
3700 /**
3701 * progress
3702 */
3703
3704 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3705
3706 hc_thread_mutex_lock (mux_counter);
3707
3708 data.words_progress_done[salt_pos] += perf_sum_all;
3709
3710 hc_thread_mutex_unlock (mux_counter);
3711
3712 /**
3713 * speed
3714 */
3715
3716 double speed_ms;
3717
3718 hc_timer_get (device_param->timer_speed, speed_ms);
3719
3720 hc_timer_set (&device_param->timer_speed);
3721
3722 // current speed
3723
3724 //hc_thread_mutex_lock (mux_display);
3725
3726 device_param->speed_cnt[speed_pos] = perf_sum_all;
3727
3728 device_param->speed_ms[speed_pos] = speed_ms;
3729
3730 //hc_thread_mutex_unlock (mux_display);
3731
3732 speed_pos++;
3733
3734 if (speed_pos == SPEED_CACHE)
3735 {
3736 speed_pos = 0;
3737 }
3738
3739 /**
3740 * benchmark
3741 */
3742
3743 if (data.benchmark == 1) break;
3744 }
3745 }
3746
3747 device_param->speed_pos = speed_pos;
3748
3749 myfree (line_buf);
3750 }
3751
3752 static void load_segment (wl_data_t *wl_data, FILE *fd)
3753 {
3754 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3755
3756 wl_data->pos = 0;
3757
3758 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3759
3760 wl_data->buf[wl_data->cnt] = 0;
3761
3762 if (wl_data->cnt == 0) return;
3763
3764 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3765
3766 while (!feof (fd))
3767 {
3768 if (wl_data->cnt == wl_data->avail)
3769 {
3770 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3771
3772 wl_data->avail += wl_data->incr;
3773 }
3774
3775 const int c = fgetc (fd);
3776
3777 if (c == EOF) break;
3778
3779 wl_data->buf[wl_data->cnt] = (char) c;
3780
3781 wl_data->cnt++;
3782
3783 if (c == '\n') break;
3784 }
3785
3786 // ensure stream ends with a newline
3787
3788 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3789 {
3790 wl_data->cnt++;
3791
3792 wl_data->buf[wl_data->cnt - 1] = '\n';
3793 }
3794
3795 return;
3796 }
3797
3798 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3799 {
3800 char *ptr = buf;
3801
3802 for (u32 i = 0; i < sz; i++, ptr++)
3803 {
3804 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3805
3806 if (i == 7)
3807 {
3808 *off = i;
3809 *len = i;
3810
3811 return;
3812 }
3813
3814 if (*ptr != '\n') continue;
3815
3816 *off = i + 1;
3817
3818 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3819
3820 *len = i;
3821
3822 return;
3823 }
3824
3825 *off = sz;
3826 *len = sz;
3827 }
3828
3829 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3830 {
3831 char *ptr = buf;
3832
3833 for (u32 i = 0; i < sz; i++, ptr++)
3834 {
3835 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3836
3837 if (*ptr != '\n') continue;
3838
3839 *off = i + 1;
3840
3841 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3842
3843 *len = i;
3844
3845 return;
3846 }
3847
3848 *off = sz;
3849 *len = sz;
3850 }
3851
3852 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3853 {
3854 char *ptr = buf;
3855
3856 for (u32 i = 0; i < sz; i++, ptr++)
3857 {
3858 if (*ptr != '\n') continue;
3859
3860 *off = i + 1;
3861
3862 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3863
3864 *len = i;
3865
3866 return;
3867 }
3868
3869 *off = sz;
3870 *len = sz;
3871 }
3872
3873 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3874 {
3875 while (wl_data->pos < wl_data->cnt)
3876 {
3877 uint off;
3878 uint len;
3879
3880 char *ptr = wl_data->buf + wl_data->pos;
3881
3882 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3883
3884 wl_data->pos += off;
3885
3886 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3887 {
3888 char rule_buf_out[BLOCK_SIZE] = { 0 };
3889
3890 int rule_len_out = -1;
3891
3892 if (len < BLOCK_SIZE)
3893 {
3894 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3895 }
3896
3897 if (rule_len_out < 0)
3898 {
3899 continue;
3900 }
3901
3902 if (rule_len_out > PW_MAX)
3903 {
3904 continue;
3905 }
3906 }
3907 else
3908 {
3909 if (len > PW_MAX)
3910 {
3911 continue;
3912 }
3913 }
3914
3915 *out_buf = ptr;
3916 *out_len = len;
3917
3918 return;
3919 }
3920
3921 if (feof (fd))
3922 {
3923 fprintf (stderr, "BUG feof()!!\n");
3924
3925 return;
3926 }
3927
3928 load_segment (wl_data, fd);
3929
3930 get_next_word (wl_data, fd, out_buf, out_len);
3931 }
3932
3933 #ifdef _POSIX
3934 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3935 #endif
3936
3937 #ifdef _WIN
3938 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3939 #endif
3940 {
3941 hc_signal (NULL);
3942
3943 dictstat_t d;
3944
3945 d.cnt = 0;
3946
3947 #ifdef _POSIX
3948 fstat (fileno (fd), &d.stat);
3949 #endif
3950
3951 #ifdef _WIN
3952 _fstat64 (fileno (fd), &d.stat);
3953 #endif
3954
3955 d.stat.st_mode = 0;
3956 d.stat.st_nlink = 0;
3957 d.stat.st_uid = 0;
3958 d.stat.st_gid = 0;
3959 d.stat.st_rdev = 0;
3960 d.stat.st_atime = 0;
3961
3962 #ifdef _POSIX
3963 d.stat.st_blksize = 0;
3964 d.stat.st_blocks = 0;
3965 #endif
3966
3967 if (d.stat.st_size == 0) return 0;
3968
3969 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3970
3971 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3972 {
3973 if (d_cache)
3974 {
3975 u64 cnt = d_cache->cnt;
3976
3977 u64 keyspace = cnt;
3978
3979 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3980 {
3981 keyspace *= data.kernel_rules_cnt;
3982 }
3983 else if (data.attack_kern == ATTACK_KERN_COMBI)
3984 {
3985 keyspace *= data.combs_cnt;
3986 }
3987
3988 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);
3989 if (data.quiet == 0) log_info ("");
3990
3991 hc_signal (sigHandler_default);
3992
3993 return (keyspace);
3994 }
3995 }
3996
3997 time_t now = 0;
3998 time_t prev = 0;
3999
4000 u64 comp = 0;
4001 u64 cnt = 0;
4002 u64 cnt2 = 0;
4003
4004 while (!feof (fd))
4005 {
4006 load_segment (wl_data, fd);
4007
4008 comp += wl_data->cnt;
4009
4010 u32 i = 0;
4011
4012 while (i < wl_data->cnt)
4013 {
4014 u32 len;
4015 u32 off;
4016
4017 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
4018
4019 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4020 {
4021 char rule_buf_out[BLOCK_SIZE] = { 0 };
4022
4023 int rule_len_out = -1;
4024
4025 if (len < BLOCK_SIZE)
4026 {
4027 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
4028 }
4029
4030 if (rule_len_out < 0)
4031 {
4032 len = PW_MAX1;
4033 }
4034 else
4035 {
4036 len = rule_len_out;
4037 }
4038 }
4039
4040 if (len < PW_MAX1)
4041 {
4042 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4043 {
4044 cnt += data.kernel_rules_cnt;
4045 }
4046 else if (data.attack_kern == ATTACK_KERN_COMBI)
4047 {
4048 cnt += data.combs_cnt;
4049 }
4050
4051 d.cnt++;
4052 }
4053
4054 i += off;
4055
4056 cnt2++;
4057 }
4058
4059 time (&now);
4060
4061 if ((now - prev) == 0) continue;
4062
4063 float percent = (float) comp / (float) d.stat.st_size;
4064
4065 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);
4066
4067 time (&prev);
4068 }
4069
4070 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);
4071 if (data.quiet == 0) log_info ("");
4072
4073 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4074
4075 hc_signal (sigHandler_default);
4076
4077 return (cnt);
4078 }
4079
4080 static void *thread_monitor (void *p)
4081 {
4082 uint runtime_check = 0;
4083 uint remove_check = 0;
4084 uint status_check = 0;
4085 uint restore_check = 0;
4086
4087 uint restore_left = data.restore_timer;
4088 uint remove_left = data.remove_timer;
4089 uint status_left = data.status_timer;
4090
4091 #ifdef HAVE_HWMON
4092 uint hwmon_check = 0;
4093
4094 int slowdown_warnings = 0;
4095
4096 // these variables are mainly used for fan control
4097
4098 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4099
4100 // temperature controller "loopback" values
4101
4102 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4103 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4104
4105 int temp_threshold = 1; // degrees celcius
4106
4107 int fan_speed_min = 15; // in percentage
4108 int fan_speed_max = 100;
4109
4110 time_t last_temp_check_time;
4111 #endif // HAVE_HWMON
4112
4113 uint sleep_time = 1;
4114
4115 if (data.runtime)
4116 {
4117 runtime_check = 1;
4118 }
4119
4120 if (data.restore_timer)
4121 {
4122 restore_check = 1;
4123 }
4124
4125 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4126 {
4127 remove_check = 1;
4128 }
4129
4130 if (data.status == 1)
4131 {
4132 status_check = 1;
4133 }
4134
4135 #ifdef HAVE_HWMON
4136 if (data.gpu_temp_disable == 0)
4137 {
4138 time (&last_temp_check_time);
4139
4140 hwmon_check = 1;
4141 }
4142 #endif
4143
4144 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4145 {
4146 #ifdef HAVE_HWMON
4147 if (hwmon_check == 0)
4148 #endif
4149 return (p);
4150 }
4151
4152 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4153 {
4154 hc_sleep (sleep_time);
4155
4156 if (data.devices_status != STATUS_RUNNING) continue;
4157
4158 #ifdef HAVE_HWMON
4159
4160 if (hwmon_check == 1)
4161 {
4162 hc_thread_mutex_lock (mux_adl);
4163
4164 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4165 {
4166 hc_device_param_t *device_param = &data.devices_param[device_id];
4167
4168 if (device_param->skipped) continue;
4169
4170 if (device_param->device_vendor_id == VENDOR_ID_NV)
4171 {
4172 if (data.hm_nvapi)
4173 {
4174 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
4175 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
4176
4177 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4178 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4179
4180 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4181
4182 perfPolicies_status.info_value = perfPolicies_info.info_value;
4183
4184 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4185
4186 if (perfPolicies_status.throttle & 2)
4187 {
4188 if (slowdown_warnings < 3)
4189 {
4190 if (data.quiet == 0) clear_prompt ();
4191
4192 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4193
4194 if (slowdown_warnings == 2)
4195 {
4196 log_info ("");
4197 }
4198
4199 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4200 if (data.quiet == 0) fflush (stdout);
4201
4202 slowdown_warnings++;
4203 }
4204 }
4205 else
4206 {
4207 slowdown_warnings = 0;
4208 }
4209 }
4210 }
4211 }
4212
4213 hc_thread_mutex_unlock (mux_adl);
4214 }
4215
4216 if (hwmon_check == 1)
4217 {
4218 hc_thread_mutex_lock (mux_adl);
4219
4220 time_t temp_check_time;
4221
4222 time (&temp_check_time);
4223
4224 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4225
4226 if (Ta == 0) Ta = 1;
4227
4228 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4229 {
4230 hc_device_param_t *device_param = &data.devices_param[device_id];
4231
4232 if (device_param->skipped) continue;
4233
4234 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4235
4236 const int temperature = hm_get_temperature_with_device_id (device_id);
4237
4238 if (temperature > (int) data.gpu_temp_abort)
4239 {
4240 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4241
4242 if (data.devices_status != STATUS_QUIT) myabort ();
4243
4244 break;
4245 }
4246
4247 const int gpu_temp_retain = data.gpu_temp_retain;
4248
4249 if (gpu_temp_retain)
4250 {
4251 if (data.hm_device[device_id].fan_set_supported == 1)
4252 {
4253 int temp_cur = temperature;
4254
4255 int temp_diff_new = gpu_temp_retain - temp_cur;
4256
4257 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4258
4259 // calculate Ta value (time difference in seconds between the last check and this check)
4260
4261 last_temp_check_time = temp_check_time;
4262
4263 float Kp = 1.8;
4264 float Ki = 0.005;
4265 float Kd = 6;
4266
4267 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4268
4269 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);
4270
4271 if (abs (fan_diff_required) >= temp_threshold)
4272 {
4273 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4274
4275 int fan_speed_level = fan_speed_cur;
4276
4277 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4278
4279 int fan_speed_new = fan_speed_level - fan_diff_required;
4280
4281 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4282 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4283
4284 if (fan_speed_new != fan_speed_cur)
4285 {
4286 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4287 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4288
4289 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4290 {
4291 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4292 {
4293 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4294 }
4295 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4296 {
4297 #ifdef WIN
4298 hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1);
4299 #endif
4300
4301 #ifdef LINUX
4302 hm_set_fanspeed_with_device_id_xnvctrl (device_id, fan_speed_new);
4303 #endif
4304 }
4305
4306 fan_speed_chgd[device_id] = 1;
4307 }
4308
4309 temp_diff_old[device_id] = temp_diff_new;
4310 }
4311 }
4312 }
4313 }
4314 }
4315
4316 hc_thread_mutex_unlock (mux_adl);
4317 }
4318 #endif // HAVE_HWMON
4319
4320 if (restore_check == 1)
4321 {
4322 restore_left--;
4323
4324 if (restore_left == 0)
4325 {
4326 if (data.restore_disable == 0) cycle_restore ();
4327
4328 restore_left = data.restore_timer;
4329 }
4330 }
4331
4332 if ((runtime_check == 1) && (data.runtime_start > 0))
4333 {
4334 time_t runtime_cur;
4335
4336 time (&runtime_cur);
4337
4338 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4339
4340 if (runtime_left <= 0)
4341 {
4342 if (data.benchmark == 0)
4343 {
4344 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4345 }
4346
4347 if (data.devices_status != STATUS_QUIT) myabort ();
4348 }
4349 }
4350
4351 if (remove_check == 1)
4352 {
4353 remove_left--;
4354
4355 if (remove_left == 0)
4356 {
4357 if (data.digests_saved != data.digests_done)
4358 {
4359 data.digests_saved = data.digests_done;
4360
4361 save_hash ();
4362 }
4363
4364 remove_left = data.remove_timer;
4365 }
4366 }
4367
4368 if (status_check == 1)
4369 {
4370 status_left--;
4371
4372 if (status_left == 0)
4373 {
4374 //hc_thread_mutex_lock (mux_display);
4375
4376 if (data.quiet == 0) clear_prompt ();
4377
4378 if (data.quiet == 0) log_info ("");
4379
4380 status_display ();
4381
4382 if (data.quiet == 0) log_info ("");
4383
4384 //hc_thread_mutex_unlock (mux_display);
4385
4386 status_left = data.status_timer;
4387 }
4388 }
4389 }
4390
4391 #ifdef HAVE_HWMON
4392 myfree (fan_speed_chgd);
4393
4394 myfree (temp_diff_old);
4395 myfree (temp_diff_sum);
4396 #endif
4397
4398 p = NULL;
4399
4400 return (p);
4401 }
4402
4403 static void *thread_outfile_remove (void *p)
4404 {
4405 // some hash-dependent constants
4406 char *outfile_dir = data.outfile_check_directory;
4407 uint dgst_size = data.dgst_size;
4408 uint isSalted = data.isSalted;
4409 uint esalt_size = data.esalt_size;
4410 uint hash_mode = data.hash_mode;
4411
4412 uint outfile_check_timer = data.outfile_check_timer;
4413
4414 char separator = data.separator;
4415
4416 // some hash-dependent functions
4417 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4418 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4419
4420 // buffers
4421 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4422
4423 hash_buf.digest = mymalloc (dgst_size);
4424
4425 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4426
4427 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4428
4429 uint digest_buf[64] = { 0 };
4430
4431 outfile_data_t *out_info = NULL;
4432
4433 char **out_files = NULL;
4434
4435 time_t folder_mtime = 0;
4436
4437 int out_cnt = 0;
4438
4439 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4440
4441 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4442 {
4443 hc_sleep (1);
4444
4445 if (data.devices_status != STATUS_RUNNING) continue;
4446
4447 check_left--;
4448
4449 if (check_left == 0)
4450 {
4451 struct stat outfile_check_stat;
4452
4453 if (stat (outfile_dir, &outfile_check_stat) == 0)
4454 {
4455 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4456
4457 if (is_dir == 1)
4458 {
4459 if (outfile_check_stat.st_mtime > folder_mtime)
4460 {
4461 char **out_files_new = scan_directory (outfile_dir);
4462
4463 int out_cnt_new = count_dictionaries (out_files_new);
4464
4465 outfile_data_t *out_info_new = NULL;
4466
4467 if (out_cnt_new > 0)
4468 {
4469 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4470
4471 for (int i = 0; i < out_cnt_new; i++)
4472 {
4473 out_info_new[i].file_name = out_files_new[i];
4474
4475 // check if there are files that we have seen/checked before (and not changed)
4476
4477 for (int j = 0; j < out_cnt; j++)
4478 {
4479 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4480 {
4481 struct stat outfile_stat;
4482
4483 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4484 {
4485 if (outfile_stat.st_ctime == out_info[j].ctime)
4486 {
4487 out_info_new[i].ctime = out_info[j].ctime;
4488 out_info_new[i].seek = out_info[j].seek;
4489 }
4490 }
4491 }
4492 }
4493 }
4494 }
4495
4496 local_free (out_info);
4497 local_free (out_files);
4498
4499 out_files = out_files_new;
4500 out_cnt = out_cnt_new;
4501 out_info = out_info_new;
4502
4503 folder_mtime = outfile_check_stat.st_mtime;
4504 }
4505
4506 for (int j = 0; j < out_cnt; j++)
4507 {
4508 FILE *fp = fopen (out_info[j].file_name, "rb");
4509
4510 if (fp != NULL)
4511 {
4512 //hc_thread_mutex_lock (mux_display);
4513
4514 #ifdef _POSIX
4515 struct stat outfile_stat;
4516
4517 fstat (fileno (fp), &outfile_stat);
4518 #endif
4519
4520 #ifdef _WIN
4521 struct stat64 outfile_stat;
4522
4523 _fstat64 (fileno (fp), &outfile_stat);
4524 #endif
4525
4526 if (outfile_stat.st_ctime > out_info[j].ctime)
4527 {
4528 out_info[j].ctime = outfile_stat.st_ctime;
4529 out_info[j].seek = 0;
4530 }
4531
4532 fseek (fp, out_info[j].seek, SEEK_SET);
4533
4534 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4535
4536 while (!feof (fp))
4537 {
4538 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4539
4540 if (ptr == NULL) break;
4541
4542 int line_len = strlen (line_buf);
4543
4544 if (line_len <= 0) continue;
4545
4546 int iter = MAX_CUT_TRIES;
4547
4548 for (uint i = line_len - 1; i && iter; i--, line_len--)
4549 {
4550 if (line_buf[i] != separator) continue;
4551
4552 int parser_status = PARSER_OK;
4553
4554 if ((hash_mode != 2500) && (hash_mode != 6800))
4555 {
4556 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4557 }
4558
4559 uint found = 0;
4560
4561 if (parser_status == PARSER_OK)
4562 {
4563 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4564 {
4565 if (data.salts_shown[salt_pos] == 1) continue;
4566
4567 salt_t *salt_buf = &data.salts_buf[salt_pos];
4568
4569 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4570 {
4571 uint idx = salt_buf->digests_offset + digest_pos;
4572
4573 if (data.digests_shown[idx] == 1) continue;
4574
4575 uint cracked = 0;
4576
4577 if (hash_mode == 6800)
4578 {
4579 if (i == salt_buf->salt_len)
4580 {
4581 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4582 }
4583 }
4584 else if (hash_mode == 2500)
4585 {
4586 // BSSID : MAC1 : MAC2 (:plain)
4587 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4588 {
4589 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4590
4591 if (!cracked) continue;
4592
4593 // now compare MAC1 and MAC2 too, since we have this additional info
4594 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4595 char *mac2_pos = mac1_pos + 12 + 1;
4596
4597 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4598 wpa_t *wpa = &wpas[salt_pos];
4599
4600 // compare hex string(s) vs binary MAC address(es)
4601
4602 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4603 {
4604 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4605 {
4606 cracked = 0;
4607
4608 break;
4609 }
4610 }
4611
4612 // early skip ;)
4613 if (!cracked) continue;
4614
4615 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4616 {
4617 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4618 {
4619 cracked = 0;
4620
4621 break;
4622 }
4623 }
4624 }
4625 }
4626 else
4627 {
4628 char *digests_buf_ptr = (char *) data.digests_buf;
4629
4630 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4631
4632 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4633 }
4634
4635 if (cracked == 1)
4636 {
4637 found = 1;
4638
4639 data.digests_shown[idx] = 1;
4640
4641 data.digests_done++;
4642
4643 salt_buf->digests_done++;
4644
4645 if (salt_buf->digests_done == salt_buf->digests_cnt)
4646 {
4647 data.salts_shown[salt_pos] = 1;
4648
4649 data.salts_done++;
4650
4651 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4652 }
4653 }
4654 }
4655
4656 if (data.devices_status == STATUS_CRACKED) break;
4657 }
4658 }
4659
4660 if (found) break;
4661
4662 if (data.devices_status == STATUS_CRACKED) break;
4663
4664 iter--;
4665 }
4666
4667 if (data.devices_status == STATUS_CRACKED) break;
4668 }
4669
4670 myfree (line_buf);
4671
4672 out_info[j].seek = ftell (fp);
4673
4674 //hc_thread_mutex_unlock (mux_display);
4675
4676 fclose (fp);
4677 }
4678 }
4679 }
4680 }
4681
4682 check_left = outfile_check_timer;
4683 }
4684 }
4685
4686 if (esalt_size) local_free (hash_buf.esalt);
4687
4688 if (isSalted) local_free (hash_buf.salt);
4689
4690 local_free (hash_buf.digest);
4691
4692 local_free (out_info);
4693
4694 local_free (out_files);
4695
4696 p = NULL;
4697
4698 return (p);
4699 }
4700
4701 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4702 {
4703 //if (device_param->pws_cnt < device_param->kernel_power)
4704 //{
4705 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4706
4707 u8 *ptr = (u8 *) pw->i;
4708
4709 memcpy (ptr, pw_buf, pw_len);
4710
4711 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4712
4713 pw->pw_len = pw_len;
4714
4715 device_param->pws_cnt++;
4716 //}
4717 //else
4718 //{
4719 // fprintf (stderr, "BUG pw_add()!!\n");
4720 //
4721 // return;
4722 //}
4723 }
4724
4725 static void set_kernel_power_final (const u64 kernel_power_final)
4726 {
4727 if (data.quiet == 0)
4728 {
4729 clear_prompt ();
4730
4731 //log_info ("");
4732
4733 log_info ("INFO: approaching final keyspace, workload adjusted");
4734 log_info ("");
4735
4736 fprintf (stdout, "%s", PROMPT);
4737
4738 fflush (stdout);
4739 }
4740
4741 data.kernel_power_final = kernel_power_final;
4742 }
4743
4744 static u32 get_power (hc_device_param_t *device_param)
4745 {
4746 const u64 kernel_power_final = data.kernel_power_final;
4747
4748 if (kernel_power_final)
4749 {
4750 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4751
4752 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4753
4754 // work should be at least the hardware power available without any accelerator
4755
4756 const u64 work = MAX (words_left_device, device_param->hardware_power);
4757
4758 return work;
4759 }
4760
4761 return device_param->kernel_power;
4762 }
4763
4764 static uint get_work (hc_device_param_t *device_param, const u64 max)
4765 {
4766 hc_thread_mutex_lock (mux_dispatcher);
4767
4768 const u64 words_cur = data.words_cur;
4769 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4770
4771 device_param->words_off = words_cur;
4772
4773 const u64 kernel_power_all = data.kernel_power_all;
4774
4775 const u64 words_left = words_base - words_cur;
4776
4777 if (words_left < kernel_power_all)
4778 {
4779 if (data.kernel_power_final == 0)
4780 {
4781 set_kernel_power_final (words_left);
4782 }
4783 }
4784
4785 const u32 kernel_power = get_power (device_param);
4786
4787 uint work = MIN (words_left, kernel_power);
4788
4789 work = MIN (work, max);
4790
4791 data.words_cur += work;
4792
4793 hc_thread_mutex_unlock (mux_dispatcher);
4794
4795 return work;
4796 }
4797
4798 static void *thread_autotune (void *p)
4799 {
4800 hc_device_param_t *device_param = (hc_device_param_t *) p;
4801
4802 if (device_param->skipped) return NULL;
4803
4804 autotune (device_param);
4805
4806 return NULL;
4807 }
4808
4809 static void *thread_calc_stdin (void *p)
4810 {
4811 hc_device_param_t *device_param = (hc_device_param_t *) p;
4812
4813 if (device_param->skipped) return NULL;
4814
4815 char *buf = (char *) mymalloc (HCBUFSIZ);
4816
4817 const uint attack_kern = data.attack_kern;
4818
4819 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4820 {
4821 hc_thread_mutex_lock (mux_dispatcher);
4822
4823 if (feof (stdin) != 0)
4824 {
4825 hc_thread_mutex_unlock (mux_dispatcher);
4826
4827 break;
4828 }
4829
4830 uint words_cur = 0;
4831
4832 while (words_cur < device_param->kernel_power)
4833 {
4834 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4835
4836 if (line_buf == NULL) break;
4837
4838 uint line_len = in_superchop (line_buf);
4839
4840 line_len = convert_from_hex (line_buf, line_len);
4841
4842 // post-process rule engine
4843
4844 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4845 {
4846 char rule_buf_out[BLOCK_SIZE] = { 0 };
4847
4848 int rule_len_out = -1;
4849
4850 if (line_len < BLOCK_SIZE)
4851 {
4852 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4853 }
4854
4855 if (rule_len_out < 0) continue;
4856
4857 line_buf = rule_buf_out;
4858 line_len = rule_len_out;
4859 }
4860
4861 if (line_len > PW_MAX)
4862 {
4863 continue;
4864 }
4865
4866 // hmm that's always the case, or?
4867
4868 if (attack_kern == ATTACK_KERN_STRAIGHT)
4869 {
4870 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4871 {
4872 hc_thread_mutex_lock (mux_counter);
4873
4874 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4875 {
4876 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4877 }
4878
4879 hc_thread_mutex_unlock (mux_counter);
4880
4881 continue;
4882 }
4883 }
4884
4885 pw_add (device_param, (u8 *) line_buf, line_len);
4886
4887 words_cur++;
4888
4889 if (data.devices_status == STATUS_CRACKED) break;
4890 if (data.devices_status == STATUS_ABORTED) break;
4891 if (data.devices_status == STATUS_QUIT) break;
4892 if (data.devices_status == STATUS_BYPASS) break;
4893 }
4894
4895 hc_thread_mutex_unlock (mux_dispatcher);
4896
4897 if (data.devices_status == STATUS_CRACKED) break;
4898 if (data.devices_status == STATUS_ABORTED) break;
4899 if (data.devices_status == STATUS_QUIT) break;
4900 if (data.devices_status == STATUS_BYPASS) break;
4901
4902 // flush
4903
4904 const uint pws_cnt = device_param->pws_cnt;
4905
4906 if (pws_cnt)
4907 {
4908 run_copy (device_param, pws_cnt);
4909
4910 run_cracker (device_param, pws_cnt);
4911
4912 device_param->pws_cnt = 0;
4913
4914 /*
4915 still required?
4916 if (attack_kern == ATTACK_KERN_STRAIGHT)
4917 {
4918 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4919 }
4920 else if (attack_kern == ATTACK_KERN_COMBI)
4921 {
4922 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4923 }
4924 */
4925 }
4926 }
4927
4928 device_param->kernel_accel = 0;
4929 device_param->kernel_loops = 0;
4930
4931 myfree (buf);
4932
4933 return NULL;
4934 }
4935
4936 static void *thread_calc (void *p)
4937 {
4938 hc_device_param_t *device_param = (hc_device_param_t *) p;
4939
4940 if (device_param->skipped) return NULL;
4941
4942 const uint attack_mode = data.attack_mode;
4943 const uint attack_kern = data.attack_kern;
4944
4945 if (attack_mode == ATTACK_MODE_BF)
4946 {
4947 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4948 {
4949 const uint work = get_work (device_param, -1);
4950
4951 if (work == 0) break;
4952
4953 const u64 words_off = device_param->words_off;
4954 const u64 words_fin = words_off + work;
4955
4956 const uint pws_cnt = work;
4957
4958 device_param->pws_cnt = pws_cnt;
4959
4960 if (pws_cnt)
4961 {
4962 run_copy (device_param, pws_cnt);
4963
4964 run_cracker (device_param, pws_cnt);
4965
4966 device_param->pws_cnt = 0;
4967
4968 /*
4969 still required?
4970 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4971 */
4972 }
4973
4974 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4975
4976 if (data.devices_status == STATUS_CRACKED) break;
4977 if (data.devices_status == STATUS_ABORTED) break;
4978 if (data.devices_status == STATUS_QUIT) break;
4979 if (data.devices_status == STATUS_BYPASS) break;
4980
4981 if (data.benchmark == 1) break;
4982
4983 device_param->words_done = words_fin;
4984 }
4985 }
4986 else
4987 {
4988 const uint segment_size = data.segment_size;
4989
4990 char *dictfile = data.dictfile;
4991
4992 if (attack_mode == ATTACK_MODE_COMBI)
4993 {
4994 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4995 {
4996 dictfile = data.dictfile2;
4997 }
4998 }
4999
5000 FILE *fd = fopen (dictfile, "rb");
5001
5002 if (fd == NULL)
5003 {
5004 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
5005
5006 return NULL;
5007 }
5008
5009 if (attack_mode == ATTACK_MODE_COMBI)
5010 {
5011 const uint combs_mode = data.combs_mode;
5012
5013 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
5014 {
5015 const char *dictfilec = data.dictfile2;
5016
5017 FILE *combs_fp = fopen (dictfilec, "rb");
5018
5019 if (combs_fp == NULL)
5020 {
5021 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5022
5023 fclose (fd);
5024
5025 return NULL;
5026 }
5027
5028 device_param->combs_fp = combs_fp;
5029 }
5030 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5031 {
5032 const char *dictfilec = data.dictfile;
5033
5034 FILE *combs_fp = fopen (dictfilec, "rb");
5035
5036 if (combs_fp == NULL)
5037 {
5038 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5039
5040 fclose (fd);
5041
5042 return NULL;
5043 }
5044
5045 device_param->combs_fp = combs_fp;
5046 }
5047 }
5048
5049 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
5050
5051 wl_data->buf = (char *) mymalloc (segment_size);
5052 wl_data->avail = segment_size;
5053 wl_data->incr = segment_size;
5054 wl_data->cnt = 0;
5055 wl_data->pos = 0;
5056
5057 u64 words_cur = 0;
5058
5059 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5060 {
5061 u64 words_off = 0;
5062 u64 words_fin = 0;
5063
5064 u64 max = -1;
5065
5066 while (max)
5067 {
5068 const uint work = get_work (device_param, max);
5069
5070 if (work == 0) break;
5071
5072 max = 0;
5073
5074 words_off = device_param->words_off;
5075 words_fin = words_off + work;
5076
5077 char *line_buf;
5078 uint line_len;
5079
5080 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5081
5082 for ( ; words_cur < words_fin; words_cur++)
5083 {
5084 get_next_word (wl_data, fd, &line_buf, &line_len);
5085
5086 line_len = convert_from_hex (line_buf, line_len);
5087
5088 // post-process rule engine
5089
5090 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5091 {
5092 char rule_buf_out[BLOCK_SIZE] = { 0 };
5093
5094 int rule_len_out = -1;
5095
5096 if (line_len < BLOCK_SIZE)
5097 {
5098 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5099 }
5100
5101 if (rule_len_out < 0) continue;
5102
5103 line_buf = rule_buf_out;
5104 line_len = rule_len_out;
5105 }
5106
5107 if (attack_kern == ATTACK_KERN_STRAIGHT)
5108 {
5109 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5110 {
5111 max++;
5112
5113 hc_thread_mutex_lock (mux_counter);
5114
5115 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5116 {
5117 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5118 }
5119
5120 hc_thread_mutex_unlock (mux_counter);
5121
5122 continue;
5123 }
5124 }
5125 else if (attack_kern == ATTACK_KERN_COMBI)
5126 {
5127 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5128 // since we still need to combine the plains
5129
5130 if (line_len > data.pw_max)
5131 {
5132 max++;
5133
5134 hc_thread_mutex_lock (mux_counter);
5135
5136 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5137 {
5138 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5139 }
5140
5141 hc_thread_mutex_unlock (mux_counter);
5142
5143 continue;
5144 }
5145 }
5146
5147 pw_add (device_param, (u8 *) line_buf, line_len);
5148
5149 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5150
5151 if (data.devices_status == STATUS_CRACKED) break;
5152 if (data.devices_status == STATUS_ABORTED) break;
5153 if (data.devices_status == STATUS_QUIT) break;
5154 if (data.devices_status == STATUS_BYPASS) break;
5155 }
5156
5157 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5158
5159 if (data.devices_status == STATUS_CRACKED) break;
5160 if (data.devices_status == STATUS_ABORTED) break;
5161 if (data.devices_status == STATUS_QUIT) break;
5162 if (data.devices_status == STATUS_BYPASS) break;
5163 }
5164
5165 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5166
5167 if (data.devices_status == STATUS_CRACKED) break;
5168 if (data.devices_status == STATUS_ABORTED) break;
5169 if (data.devices_status == STATUS_QUIT) break;
5170 if (data.devices_status == STATUS_BYPASS) break;
5171
5172 //
5173 // flush
5174 //
5175
5176 const uint pws_cnt = device_param->pws_cnt;
5177
5178 if (pws_cnt)
5179 {
5180 run_copy (device_param, pws_cnt);
5181
5182 run_cracker (device_param, pws_cnt);
5183
5184 device_param->pws_cnt = 0;
5185
5186 /*
5187 still required?
5188 if (attack_kern == ATTACK_KERN_STRAIGHT)
5189 {
5190 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5191 }
5192 else if (attack_kern == ATTACK_KERN_COMBI)
5193 {
5194 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5195 }
5196 */
5197 }
5198
5199 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5200
5201 if (data.devices_status == STATUS_CRACKED) break;
5202 if (data.devices_status == STATUS_ABORTED) break;
5203 if (data.devices_status == STATUS_QUIT) break;
5204 if (data.devices_status == STATUS_BYPASS) break;
5205
5206 if (words_fin == 0) break;
5207
5208 device_param->words_done = words_fin;
5209 }
5210
5211 if (attack_mode == ATTACK_MODE_COMBI)
5212 {
5213 fclose (device_param->combs_fp);
5214 }
5215
5216 free (wl_data->buf);
5217 free (wl_data);
5218
5219 fclose (fd);
5220 }
5221
5222 device_param->kernel_accel = 0;
5223 device_param->kernel_loops = 0;
5224
5225 return NULL;
5226 }
5227
5228 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5229 {
5230 if (!device_param)
5231 {
5232 log_error ("ERROR: %s : Invalid argument", __func__);
5233
5234 exit (-1);
5235 }
5236
5237 salt_t *salt_buf = &data.salts_buf[salt_pos];
5238
5239 device_param->kernel_params_buf32[24] = salt_pos;
5240 device_param->kernel_params_buf32[27] = 1;
5241 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
5242 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
5243 device_param->kernel_params_buf32[30] = 0;
5244 device_param->kernel_params_buf32[31] = 1;
5245
5246 char *dictfile_old = data.dictfile;
5247
5248 const char *weak_hash_check = "weak-hash-check";
5249
5250 data.dictfile = (char *) weak_hash_check;
5251
5252 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5253
5254 data.kernel_rules_buf[0].cmds[0] = 0;
5255
5256 /**
5257 * run the kernel
5258 */
5259
5260 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5261 {
5262 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5263 }
5264 else
5265 {
5266 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5267
5268 uint loop_step = 16;
5269
5270 const uint iter = salt_buf->salt_iter;
5271
5272 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5273 {
5274 uint loop_left = iter - loop_pos;
5275
5276 loop_left = MIN (loop_left, loop_step);
5277
5278 device_param->kernel_params_buf32[25] = loop_pos;
5279 device_param->kernel_params_buf32[26] = loop_left;
5280
5281 run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5282 }
5283
5284 run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5285 }
5286
5287 /**
5288 * result
5289 */
5290
5291 check_cracked (device_param, salt_pos);
5292
5293 /**
5294 * cleanup
5295 */
5296
5297 device_param->kernel_params_buf32[24] = 0;
5298 device_param->kernel_params_buf32[25] = 0;
5299 device_param->kernel_params_buf32[26] = 0;
5300 device_param->kernel_params_buf32[27] = 0;
5301 device_param->kernel_params_buf32[28] = 0;
5302 device_param->kernel_params_buf32[29] = 0;
5303 device_param->kernel_params_buf32[30] = 0;
5304 device_param->kernel_params_buf32[31] = 0;
5305
5306 data.dictfile = dictfile_old;
5307
5308 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5309 }
5310
5311 // hlfmt hashcat
5312
5313 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5314 {
5315 if (data.username == 0)
5316 {
5317 *hashbuf_pos = line_buf;
5318 *hashbuf_len = line_len;
5319 }
5320 else
5321 {
5322 char *pos = line_buf;
5323 int len = line_len;
5324
5325 for (int i = 0; i < line_len; i++, pos++, len--)
5326 {
5327 if (line_buf[i] == data.separator)
5328 {
5329 pos++;
5330
5331 len--;
5332
5333 break;
5334 }
5335 }
5336
5337 *hashbuf_pos = pos;
5338 *hashbuf_len = len;
5339 }
5340 }
5341
5342 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5343 {
5344 char *pos = NULL;
5345 int len = 0;
5346
5347 int sep_cnt = 0;
5348
5349 for (int i = 0; i < line_len; i++)
5350 {
5351 if (line_buf[i] == data.separator)
5352 {
5353 sep_cnt++;
5354
5355 continue;
5356 }
5357
5358 if (sep_cnt == 0)
5359 {
5360 if (pos == NULL) pos = line_buf + i;
5361
5362 len++;
5363 }
5364 }
5365
5366 *userbuf_pos = pos;
5367 *userbuf_len = len;
5368 }
5369
5370 // hlfmt pwdump
5371
5372 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5373 {
5374 int sep_cnt = 0;
5375
5376 int sep2_len = 0;
5377 int sep3_len = 0;
5378
5379 for (int i = 0; i < line_len; i++)
5380 {
5381 if (line_buf[i] == ':')
5382 {
5383 sep_cnt++;
5384
5385 continue;
5386 }
5387
5388 if (sep_cnt == 2) sep2_len++;
5389 if (sep_cnt == 3) sep3_len++;
5390 }
5391
5392 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5393
5394 return 0;
5395 }
5396
5397 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5398 {
5399 char *pos = NULL;
5400 int len = 0;
5401
5402 int sep_cnt = 0;
5403
5404 for (int i = 0; i < line_len; i++)
5405 {
5406 if (line_buf[i] == ':')
5407 {
5408 sep_cnt++;
5409
5410 continue;
5411 }
5412
5413 if (data.hash_mode == 1000)
5414 {
5415 if (sep_cnt == 3)
5416 {
5417 if (pos == NULL) pos = line_buf + i;
5418
5419 len++;
5420 }
5421 }
5422 else if (data.hash_mode == 3000)
5423 {
5424 if (sep_cnt == 2)
5425 {
5426 if (pos == NULL) pos = line_buf + i;
5427
5428 len++;
5429 }
5430 }
5431 }
5432
5433 *hashbuf_pos = pos;
5434 *hashbuf_len = len;
5435 }
5436
5437 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5438 {
5439 char *pos = NULL;
5440 int len = 0;
5441
5442 int sep_cnt = 0;
5443
5444 for (int i = 0; i < line_len; i++)
5445 {
5446 if (line_buf[i] == ':')
5447 {
5448 sep_cnt++;
5449
5450 continue;
5451 }
5452
5453 if (sep_cnt == 0)
5454 {
5455 if (pos == NULL) pos = line_buf + i;
5456
5457 len++;
5458 }
5459 }
5460
5461 *userbuf_pos = pos;
5462 *userbuf_len = len;
5463 }
5464
5465 // hlfmt passwd
5466
5467 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5468 {
5469 int sep_cnt = 0;
5470
5471 char sep5_first = 0;
5472 char sep6_first = 0;
5473
5474 for (int i = 0; i < line_len; i++)
5475 {
5476 if (line_buf[i] == ':')
5477 {
5478 sep_cnt++;
5479
5480 continue;
5481 }
5482
5483 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5484 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5485 }
5486
5487 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5488
5489 return 0;
5490 }
5491
5492 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5493 {
5494 char *pos = NULL;
5495 int len = 0;
5496
5497 int sep_cnt = 0;
5498
5499 for (int i = 0; i < line_len; i++)
5500 {
5501 if (line_buf[i] == ':')
5502 {
5503 sep_cnt++;
5504
5505 continue;
5506 }
5507
5508 if (sep_cnt == 1)
5509 {
5510 if (pos == NULL) pos = line_buf + i;
5511
5512 len++;
5513 }
5514 }
5515
5516 *hashbuf_pos = pos;
5517 *hashbuf_len = len;
5518 }
5519
5520 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5521 {
5522 char *pos = NULL;
5523 int len = 0;
5524
5525 int sep_cnt = 0;
5526
5527 for (int i = 0; i < line_len; i++)
5528 {
5529 if (line_buf[i] == ':')
5530 {
5531 sep_cnt++;
5532
5533 continue;
5534 }
5535
5536 if (sep_cnt == 0)
5537 {
5538 if (pos == NULL) pos = line_buf + i;
5539
5540 len++;
5541 }
5542 }
5543
5544 *userbuf_pos = pos;
5545 *userbuf_len = len;
5546 }
5547
5548 // hlfmt shadow
5549
5550 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5551 {
5552 int sep_cnt = 0;
5553
5554 for (int i = 0; i < line_len; i++)
5555 {
5556 if (line_buf[i] == ':') sep_cnt++;
5557 }
5558
5559 if (sep_cnt == 8) return 1;
5560
5561 return 0;
5562 }
5563
5564 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5565 {
5566 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5567 }
5568
5569 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5570 {
5571 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5572 }
5573
5574 // hlfmt main
5575
5576 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5577 {
5578 switch (hashfile_format)
5579 {
5580 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5581 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5582 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5583 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5584 }
5585 }
5586
5587 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5588 {
5589 switch (hashfile_format)
5590 {
5591 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5592 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5593 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5594 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5595 }
5596 }
5597
5598 char *strhlfmt (const uint hashfile_format)
5599 {
5600 switch (hashfile_format)
5601 {
5602 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5603 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5604 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5605 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5606 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5607 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5608 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5609 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5610 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5611 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5612 }
5613
5614 return ((char *) "Unknown");
5615 }
5616
5617 static uint hlfmt_detect (FILE *fp, uint max_check)
5618 {
5619 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5620
5621 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5622 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5623
5624 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5625
5626 uint num_check = 0;
5627
5628 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5629
5630 while (!feof (fp))
5631 {
5632 int line_len = fgetl (fp, line_buf);
5633
5634 if (line_len == 0) continue;
5635
5636 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5637 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5638 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5639
5640 if (num_check == max_check) break;
5641
5642 num_check++;
5643 }
5644
5645 myfree (line_buf);
5646
5647 uint hashlist_format = HLFMT_HASHCAT;
5648
5649 for (int i = 1; i < HLFMTS_CNT; i++)
5650 {
5651 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5652
5653 hashlist_format = i;
5654 }
5655
5656 free (formats_cnt);
5657
5658 return hashlist_format;
5659 }
5660
5661 /**
5662 * some further helper function
5663 */
5664
5665 // wrapper around mymalloc for ADL
5666
5667 #if defined(HAVE_HWMON)
5668 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5669 {
5670 return mymalloc (iSize);
5671 }
5672 #endif
5673
5674 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)
5675 {
5676 u64 collisions = 0;
5677
5678 const uint dgst_pos0 = data.dgst_pos0;
5679 const uint dgst_pos1 = data.dgst_pos1;
5680 const uint dgst_pos2 = data.dgst_pos2;
5681 const uint dgst_pos3 = data.dgst_pos3;
5682
5683 memset (bitmap_a, 0, bitmap_size);
5684 memset (bitmap_b, 0, bitmap_size);
5685 memset (bitmap_c, 0, bitmap_size);
5686 memset (bitmap_d, 0, bitmap_size);
5687
5688 for (uint i = 0; i < digests_cnt; i++)
5689 {
5690 uint *digest_ptr = (uint *) digests_buf_ptr;
5691
5692 digests_buf_ptr += dgst_size;
5693
5694 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5695 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5696 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5697 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5698
5699 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5700 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5701 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5702 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5703
5704 if (bitmap_a[idx0] & val0) collisions++;
5705 if (bitmap_b[idx1] & val1) collisions++;
5706 if (bitmap_c[idx2] & val2) collisions++;
5707 if (bitmap_d[idx3] & val3) collisions++;
5708
5709 bitmap_a[idx0] |= val0;
5710 bitmap_b[idx1] |= val1;
5711 bitmap_c[idx2] |= val2;
5712 bitmap_d[idx3] |= val3;
5713
5714 if (collisions >= collisions_max) return 0x7fffffff;
5715 }
5716
5717 return collisions;
5718 }
5719
5720 /**
5721 * main
5722 */
5723
5724 #ifdef WIN
5725 void SetConsoleWindowSize (const int x)
5726 {
5727 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5728
5729 if (h == INVALID_HANDLE_VALUE) return;
5730
5731 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5732
5733 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5734
5735 SMALL_RECT *sr = &bufferInfo.srWindow;
5736
5737 sr->Right = MAX (sr->Right, x - 1);
5738
5739 COORD co;
5740
5741 co.X = sr->Right + 1;
5742 co.Y = 9999;
5743
5744 if (!SetConsoleScreenBufferSize (h, co)) return;
5745
5746 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5747 }
5748 #endif
5749
5750 int main (int argc, char **argv)
5751 {
5752 #ifdef WIN
5753 SetConsoleWindowSize (132);
5754 #endif
5755
5756 /**
5757 * To help users a bit
5758 */
5759
5760 char *compute = getenv ("COMPUTE");
5761
5762 if (compute)
5763 {
5764 static char display[100];
5765
5766 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5767
5768 putenv (display);
5769 }
5770 else
5771 {
5772 if (getenv ("DISPLAY") == NULL)
5773 putenv ((char *) "DISPLAY=:0");
5774 }
5775
5776 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5777 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5778
5779 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5780 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5781
5782 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5783 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5784
5785 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5786 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5787
5788 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5789 putenv ((char *) "POCL_KERNEL_CACHE=0");
5790
5791 umask (077);
5792
5793 /**
5794 * Real init
5795 */
5796
5797 memset (&data, 0, sizeof (hc_global_data_t));
5798
5799 time_t proc_start;
5800
5801 time (&proc_start);
5802
5803 data.proc_start = proc_start;
5804
5805 int myargc = argc;
5806 char **myargv = argv;
5807
5808 hc_thread_mutex_init (mux_dispatcher);
5809 hc_thread_mutex_init (mux_counter);
5810 hc_thread_mutex_init (mux_display);
5811 hc_thread_mutex_init (mux_adl);
5812
5813 /**
5814 * commandline parameters
5815 */
5816
5817 uint usage = USAGE;
5818 uint version = VERSION;
5819 uint quiet = QUIET;
5820 uint benchmark = BENCHMARK;
5821 uint stdout_flag = STDOUT_FLAG;
5822 uint show = SHOW;
5823 uint left = LEFT;
5824 uint username = USERNAME;
5825 uint remove = REMOVE;
5826 uint remove_timer = REMOVE_TIMER;
5827 u64 skip = SKIP;
5828 u64 limit = LIMIT;
5829 uint keyspace = KEYSPACE;
5830 uint potfile_disable = POTFILE_DISABLE;
5831 char *potfile_path = NULL;
5832 uint debug_mode = DEBUG_MODE;
5833 char *debug_file = NULL;
5834 char *induction_dir = NULL;
5835 char *outfile_check_dir = NULL;
5836 uint force = FORCE;
5837 uint runtime = RUNTIME;
5838 uint hash_mode = HASH_MODE;
5839 uint attack_mode = ATTACK_MODE;
5840 uint markov_disable = MARKOV_DISABLE;
5841 uint markov_classic = MARKOV_CLASSIC;
5842 uint markov_threshold = MARKOV_THRESHOLD;
5843 char *markov_hcstat = NULL;
5844 char *outfile = NULL;
5845 uint outfile_format = OUTFILE_FORMAT;
5846 uint outfile_autohex = OUTFILE_AUTOHEX;
5847 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5848 uint restore = RESTORE;
5849 uint restore_timer = RESTORE_TIMER;
5850 uint restore_disable = RESTORE_DISABLE;
5851 uint status = STATUS;
5852 uint status_timer = STATUS_TIMER;
5853 uint machine_readable = MACHINE_READABLE;
5854 uint loopback = LOOPBACK;
5855 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5856 char *session = NULL;
5857 uint hex_charset = HEX_CHARSET;
5858 uint hex_salt = HEX_SALT;
5859 uint hex_wordlist = HEX_WORDLIST;
5860 uint rp_gen = RP_GEN;
5861 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5862 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5863 uint rp_gen_seed = RP_GEN_SEED;
5864 char *rule_buf_l = (char *) RULE_BUF_L;
5865 char *rule_buf_r = (char *) RULE_BUF_R;
5866 uint increment = INCREMENT;
5867 uint increment_min = INCREMENT_MIN;
5868 uint increment_max = INCREMENT_MAX;
5869 char *cpu_affinity = NULL;
5870 OCL_PTR *ocl = NULL;
5871 char *opencl_devices = NULL;
5872 char *opencl_platforms = NULL;
5873 char *opencl_device_types = NULL;
5874 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5875 char *truecrypt_keyfiles = NULL;
5876 char *veracrypt_keyfiles = NULL;
5877 uint veracrypt_pim = 0;
5878 uint workload_profile = WORKLOAD_PROFILE;
5879 uint kernel_accel = KERNEL_ACCEL;
5880 uint kernel_loops = KERNEL_LOOPS;
5881 uint nvidia_spin_damp = NVIDIA_SPIN_DAMP;
5882 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5883 #ifdef HAVE_HWMON
5884 uint gpu_temp_abort = GPU_TEMP_ABORT;
5885 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5886 uint powertune_enable = POWERTUNE_ENABLE;
5887 #endif
5888 uint logfile_disable = LOGFILE_DISABLE;
5889 uint segment_size = SEGMENT_SIZE;
5890 uint scrypt_tmto = SCRYPT_TMTO;
5891 char separator = SEPARATOR;
5892 uint bitmap_min = BITMAP_MIN;
5893 uint bitmap_max = BITMAP_MAX;
5894 char *custom_charset_1 = NULL;
5895 char *custom_charset_2 = NULL;
5896 char *custom_charset_3 = NULL;
5897 char *custom_charset_4 = NULL;
5898
5899 #define IDX_HELP 'h'
5900 #define IDX_VERSION 'V'
5901 #define IDX_VERSION_LOWER 'v'
5902 #define IDX_QUIET 0xff02
5903 #define IDX_SHOW 0xff03
5904 #define IDX_LEFT 0xff04
5905 #define IDX_REMOVE 0xff05
5906 #define IDX_REMOVE_TIMER 0xff37
5907 #define IDX_SKIP 's'
5908 #define IDX_LIMIT 'l'
5909 #define IDX_KEYSPACE 0xff35
5910 #define IDX_POTFILE_DISABLE 0xff06
5911 #define IDX_POTFILE_PATH 0xffe0
5912 #define IDX_DEBUG_MODE 0xff43
5913 #define IDX_DEBUG_FILE 0xff44
5914 #define IDX_INDUCTION_DIR 0xff46
5915 #define IDX_OUTFILE_CHECK_DIR 0xff47
5916 #define IDX_USERNAME 0xff07
5917 #define IDX_FORCE 0xff08
5918 #define IDX_RUNTIME 0xff09
5919 #define IDX_BENCHMARK 'b'
5920 #define IDX_STDOUT_FLAG 0xff77
5921 #define IDX_HASH_MODE 'm'
5922 #define IDX_ATTACK_MODE 'a'
5923 #define IDX_RP_FILE 'r'
5924 #define IDX_RP_GEN 'g'
5925 #define IDX_RP_GEN_FUNC_MIN 0xff10
5926 #define IDX_RP_GEN_FUNC_MAX 0xff11
5927 #define IDX_RP_GEN_SEED 0xff34
5928 #define IDX_RULE_BUF_L 'j'
5929 #define IDX_RULE_BUF_R 'k'
5930 #define IDX_INCREMENT 'i'
5931 #define IDX_INCREMENT_MIN 0xff12
5932 #define IDX_INCREMENT_MAX 0xff13
5933 #define IDX_OUTFILE 'o'
5934 #define IDX_OUTFILE_FORMAT 0xff14
5935 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5936 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5937 #define IDX_RESTORE 0xff15
5938 #define IDX_RESTORE_DISABLE 0xff27
5939 #define IDX_STATUS 0xff17
5940 #define IDX_STATUS_TIMER 0xff18
5941 #define IDX_MACHINE_READABLE 0xff50
5942 #define IDX_LOOPBACK 0xff38
5943 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5944 #define IDX_SESSION 0xff19
5945 #define IDX_HEX_CHARSET 0xff20
5946 #define IDX_HEX_SALT 0xff21
5947 #define IDX_HEX_WORDLIST 0xff40
5948 #define IDX_MARKOV_DISABLE 0xff22
5949 #define IDX_MARKOV_CLASSIC 0xff23
5950 #define IDX_MARKOV_THRESHOLD 't'
5951 #define IDX_MARKOV_HCSTAT 0xff24
5952 #define IDX_CPU_AFFINITY 0xff25
5953 #define IDX_OPENCL_DEVICES 'd'
5954 #define IDX_OPENCL_PLATFORMS 0xff72
5955 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5956 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5957 #define IDX_WORKLOAD_PROFILE 'w'
5958 #define IDX_KERNEL_ACCEL 'n'
5959 #define IDX_KERNEL_LOOPS 'u'
5960 #define IDX_NVIDIA_SPIN_DAMP 0xff79
5961 #define IDX_GPU_TEMP_DISABLE 0xff29
5962 #define IDX_GPU_TEMP_ABORT 0xff30
5963 #define IDX_GPU_TEMP_RETAIN 0xff31
5964 #define IDX_POWERTUNE_ENABLE 0xff41
5965 #define IDX_LOGFILE_DISABLE 0xff51
5966 #define IDX_TRUECRYPT_KEYFILES 0xff52
5967 #define IDX_VERACRYPT_KEYFILES 0xff53
5968 #define IDX_VERACRYPT_PIM 0xff54
5969 #define IDX_SCRYPT_TMTO 0xff61
5970 #define IDX_SEGMENT_SIZE 'c'
5971 #define IDX_SEPARATOR 'p'
5972 #define IDX_BITMAP_MIN 0xff70
5973 #define IDX_BITMAP_MAX 0xff71
5974 #define IDX_CUSTOM_CHARSET_1 '1'
5975 #define IDX_CUSTOM_CHARSET_2 '2'
5976 #define IDX_CUSTOM_CHARSET_3 '3'
5977 #define IDX_CUSTOM_CHARSET_4 '4'
5978
5979 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5980
5981 struct option long_options[] =
5982 {
5983 {"help", no_argument, 0, IDX_HELP},
5984 {"version", no_argument, 0, IDX_VERSION},
5985 {"quiet", no_argument, 0, IDX_QUIET},
5986 {"show", no_argument, 0, IDX_SHOW},
5987 {"left", no_argument, 0, IDX_LEFT},
5988 {"username", no_argument, 0, IDX_USERNAME},
5989 {"remove", no_argument, 0, IDX_REMOVE},
5990 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5991 {"skip", required_argument, 0, IDX_SKIP},
5992 {"limit", required_argument, 0, IDX_LIMIT},
5993 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5994 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5995 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5996 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5997 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5998 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5999 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
6000 {"force", no_argument, 0, IDX_FORCE},
6001 {"benchmark", no_argument, 0, IDX_BENCHMARK},
6002 {"stdout", no_argument, 0, IDX_STDOUT_FLAG},
6003 {"restore", no_argument, 0, IDX_RESTORE},
6004 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
6005 {"status", no_argument, 0, IDX_STATUS},
6006 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
6007 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
6008 {"loopback", no_argument, 0, IDX_LOOPBACK},
6009 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
6010 {"session", required_argument, 0, IDX_SESSION},
6011 {"runtime", required_argument, 0, IDX_RUNTIME},
6012 {"generate-rules", required_argument, 0, IDX_RP_GEN},
6013 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
6014 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
6015 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
6016 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
6017 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
6018 {"hash-type", required_argument, 0, IDX_HASH_MODE},
6019 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
6020 {"rules-file", required_argument, 0, IDX_RP_FILE},
6021 {"outfile", required_argument, 0, IDX_OUTFILE},
6022 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
6023 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
6024 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
6025 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
6026 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
6027 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
6028 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
6029 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
6030 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
6031 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
6032 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
6033 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
6034 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
6035 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
6036 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
6037 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
6038 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
6039 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
6040 {"nvidia-spin-damp", required_argument, 0, IDX_NVIDIA_SPIN_DAMP},
6041 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
6042 #ifdef HAVE_HWMON
6043 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
6044 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
6045 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
6046 #endif // HAVE_HWMON
6047 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
6048 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
6049 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
6050 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
6051 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
6052 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
6053 {"seperator", required_argument, 0, IDX_SEPARATOR},
6054 {"separator", required_argument, 0, IDX_SEPARATOR},
6055 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
6056 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
6057 {"increment", no_argument, 0, IDX_INCREMENT},
6058 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
6059 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
6060 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
6061 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
6062 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
6063 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
6064 {0, 0, 0, 0}
6065 };
6066
6067 uint rp_files_cnt = 0;
6068
6069 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6070
6071 int option_index = 0;
6072 int c = -1;
6073
6074 optind = 1;
6075 optopt = 0;
6076
6077 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6078 {
6079 switch (c)
6080 {
6081 case IDX_HELP: usage = 1; break;
6082 case IDX_VERSION:
6083 case IDX_VERSION_LOWER: version = 1; break;
6084 case IDX_RESTORE: restore = 1; break;
6085 case IDX_SESSION: session = optarg; break;
6086 case IDX_SHOW: show = 1; break;
6087 case IDX_LEFT: left = 1; break;
6088 case '?': return (-1);
6089 }
6090 }
6091
6092 if (optopt != 0)
6093 {
6094 log_error ("ERROR: Invalid argument specified");
6095
6096 return (-1);
6097 }
6098
6099 /**
6100 * exit functions
6101 */
6102
6103 if (version)
6104 {
6105 log_info ("%s", VERSION_TAG);
6106
6107 return (0);
6108 }
6109
6110 if (usage)
6111 {
6112 usage_big_print (PROGNAME);
6113
6114 return (0);
6115 }
6116
6117 /**
6118 * session needs to be set, always!
6119 */
6120
6121 if (session == NULL) session = (char *) PROGNAME;
6122
6123 /**
6124 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6125 */
6126
6127 char *exec_path = get_exec_path ();
6128
6129 #ifdef LINUX
6130
6131 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6132 char *resolved_exec_path = realpath (exec_path, NULL);
6133
6134 char *install_dir = get_install_dir (resolved_exec_path);
6135 char *profile_dir = NULL;
6136 char *session_dir = NULL;
6137 char *shared_dir = NULL;
6138
6139 if (strcmp (install_dir, resolved_install_folder) == 0)
6140 {
6141 struct passwd *pw = getpwuid (getuid ());
6142
6143 const char *homedir = pw->pw_dir;
6144
6145 profile_dir = get_profile_dir (homedir);
6146 session_dir = get_session_dir (profile_dir);
6147 shared_dir = strdup (SHARED_FOLDER);
6148
6149 mkdir (profile_dir, 0700);
6150 mkdir (session_dir, 0700);
6151 }
6152 else
6153 {
6154 profile_dir = install_dir;
6155 session_dir = install_dir;
6156 shared_dir = install_dir;
6157 }
6158
6159 myfree (resolved_install_folder);
6160 myfree (resolved_exec_path);
6161
6162 #else
6163
6164 char *install_dir = get_install_dir (exec_path);
6165 char *profile_dir = install_dir;
6166 char *session_dir = install_dir;
6167 char *shared_dir = install_dir;
6168
6169 #endif
6170
6171 data.install_dir = install_dir;
6172 data.profile_dir = profile_dir;
6173 data.session_dir = session_dir;
6174 data.shared_dir = shared_dir;
6175
6176 myfree (exec_path);
6177
6178 /**
6179 * kernel cache, we need to make sure folder exist
6180 */
6181
6182 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6183
6184 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6185
6186 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6187
6188 mkdir (kernels_folder, 0700);
6189
6190 myfree (kernels_folder);
6191
6192 /**
6193 * session
6194 */
6195
6196 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6197
6198 data.session = session;
6199
6200 char *eff_restore_file = (char *) mymalloc (session_size);
6201 char *new_restore_file = (char *) mymalloc (session_size);
6202
6203 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
6204 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6205
6206 data.eff_restore_file = eff_restore_file;
6207 data.new_restore_file = new_restore_file;
6208
6209 if (((show == 1) || (left == 1)) && (restore == 1))
6210 {
6211 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6212 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6213
6214 return (-1);
6215 }
6216
6217 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6218 if ((show == 1) || (left == 1))
6219 {
6220 restore_disable = 1;
6221
6222 restore = 0;
6223 }
6224
6225 data.restore_disable = restore_disable;
6226
6227 restore_data_t *rd = init_restore (argc, argv);
6228
6229 data.rd = rd;
6230
6231 /**
6232 * restore file
6233 */
6234
6235 if (restore == 1)
6236 {
6237 read_restore (eff_restore_file, rd);
6238
6239 if (rd->version_bin < RESTORE_MIN)
6240 {
6241 log_error ("ERROR: Incompatible restore-file version");
6242
6243 return (-1);
6244 }
6245
6246 myargc = rd->argc;
6247 myargv = rd->argv;
6248
6249 #ifdef _POSIX
6250 rd->pid = getpid ();
6251 #elif _WIN
6252 rd->pid = GetCurrentProcessId ();
6253 #endif
6254 }
6255
6256 uint hash_mode_chgd = 0;
6257 uint runtime_chgd = 0;
6258 uint kernel_loops_chgd = 0;
6259 uint kernel_accel_chgd = 0;
6260 uint nvidia_spin_damp_chgd = 0;
6261 uint attack_mode_chgd = 0;
6262 uint outfile_format_chgd = 0;
6263 uint rp_gen_seed_chgd = 0;
6264 uint remove_timer_chgd = 0;
6265 uint increment_min_chgd = 0;
6266 uint increment_max_chgd = 0;
6267 uint workload_profile_chgd = 0;
6268 uint opencl_vector_width_chgd = 0;
6269
6270 optind = 1;
6271 optopt = 0;
6272 option_index = 0;
6273
6274 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6275 {
6276 switch (c)
6277 {
6278 //case IDX_HELP: usage = 1; break;
6279 //case IDX_VERSION: version = 1; break;
6280 //case IDX_RESTORE: restore = 1; break;
6281 case IDX_QUIET: quiet = 1; break;
6282 //case IDX_SHOW: show = 1; break;
6283 case IDX_SHOW: break;
6284 //case IDX_LEFT: left = 1; break;
6285 case IDX_LEFT: break;
6286 case IDX_USERNAME: username = 1; break;
6287 case IDX_REMOVE: remove = 1; break;
6288 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6289 remove_timer_chgd = 1; break;
6290 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6291 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6292 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6293 case IDX_DEBUG_FILE: debug_file = optarg; break;
6294 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6295 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6296 case IDX_FORCE: force = 1; break;
6297 case IDX_SKIP: skip = atoll (optarg); break;
6298 case IDX_LIMIT: limit = atoll (optarg); break;
6299 case IDX_KEYSPACE: keyspace = 1; break;
6300 case IDX_BENCHMARK: benchmark = 1; break;
6301 case IDX_STDOUT_FLAG: stdout_flag = 1; break;
6302 case IDX_RESTORE: break;
6303 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6304 case IDX_STATUS: status = 1; break;
6305 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6306 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6307 case IDX_LOOPBACK: loopback = 1; break;
6308 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6309 //case IDX_SESSION: session = optarg; break;
6310 case IDX_SESSION: break;
6311 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6312 hash_mode_chgd = 1; break;
6313 case IDX_RUNTIME: runtime = atoi (optarg);
6314 runtime_chgd = 1; break;
6315 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6316 attack_mode_chgd = 1; break;
6317 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6318 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6319 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6320 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6321 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6322 rp_gen_seed_chgd = 1; break;
6323 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6324 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6325 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6326 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6327 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6328 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6329 case IDX_OUTFILE: outfile = optarg; break;
6330 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6331 outfile_format_chgd = 1; break;
6332 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6333 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6334 case IDX_HEX_CHARSET: hex_charset = 1; break;
6335 case IDX_HEX_SALT: hex_salt = 1; break;
6336 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6337 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6338 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6339 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6340 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6341 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6342 opencl_vector_width_chgd = 1; break;
6343 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6344 workload_profile_chgd = 1; break;
6345 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6346 kernel_accel_chgd = 1; break;
6347 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6348 kernel_loops_chgd = 1; break;
6349 case IDX_NVIDIA_SPIN_DAMP: nvidia_spin_damp = atoi (optarg);
6350 nvidia_spin_damp_chgd = 1; break;
6351 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6352 #ifdef HAVE_HWMON
6353 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6354 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6355 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6356 #endif // HAVE_HWMON
6357 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6358 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6359 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6360 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6361 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6362 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6363 case IDX_SEPARATOR: separator = optarg[0]; break;
6364 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6365 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6366 case IDX_INCREMENT: increment = 1; break;
6367 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6368 increment_min_chgd = 1; break;
6369 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6370 increment_max_chgd = 1; break;
6371 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6372 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6373 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6374 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6375
6376 default:
6377 log_error ("ERROR: Invalid argument specified");
6378 return (-1);
6379 }
6380 }
6381
6382 if (optopt != 0)
6383 {
6384 log_error ("ERROR: Invalid argument specified");
6385
6386 return (-1);
6387 }
6388
6389 /**
6390 * Inform user things getting started,
6391 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6392 * - we do not need to check algorithm_pos
6393 */
6394
6395 if (quiet == 0)
6396 {
6397 if (benchmark == 1)
6398 {
6399 if (machine_readable == 0)
6400 {
6401 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6402 log_info ("");
6403 log_info ("Note: Reported benchmark cracking speed = real cracking speed");
6404 log_info ("To verify, run hashcat like this: only_one_hash.txt -a 3 -w 3 ?b?b?b?b?b?b?b");
6405 log_info ("");
6406 }
6407 else
6408 {
6409 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6410 }
6411 }
6412 else if (restore == 1)
6413 {
6414 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6415 log_info ("");
6416 }
6417 else if (stdout_flag == 1)
6418 {
6419 // do nothing
6420 }
6421 else
6422 {
6423 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6424 log_info ("");
6425 }
6426 }
6427
6428 /**
6429 * sanity check
6430 */
6431
6432 if (attack_mode > 7)
6433 {
6434 log_error ("ERROR: Invalid attack-mode specified");
6435
6436 return (-1);
6437 }
6438
6439 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6440 {
6441 log_error ("ERROR: Invalid runtime specified");
6442
6443 return (-1);
6444 }
6445
6446 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6447 {
6448 log_error ("ERROR: Invalid hash-type specified");
6449
6450 return (-1);
6451 }
6452
6453 // renamed hash modes
6454
6455 if (hash_mode_chgd)
6456 {
6457 int n = -1;
6458
6459 switch (hash_mode)
6460 {
6461 case 123: n = 124;
6462 break;
6463 }
6464
6465 if (n >= 0)
6466 {
6467 log_error ("Old -m specified, use -m %d instead", n);
6468
6469 return (-1);
6470 }
6471 }
6472
6473 if (username == 1)
6474 {
6475 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6476 {
6477 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6478
6479 return (-1);
6480 }
6481 }
6482
6483 if (outfile_format > 16)
6484 {
6485 log_error ("ERROR: Invalid outfile-format specified");
6486
6487 return (-1);
6488 }
6489
6490 if (left == 1)
6491 {
6492 if (outfile_format_chgd == 1)
6493 {
6494 if (outfile_format > 1)
6495 {
6496 log_error ("ERROR: Mixing outfile-format > 1 with left parameter is not allowed");
6497
6498 return (-1);
6499 }
6500 }
6501 else
6502 {
6503 outfile_format = OUTFILE_FMT_HASH;
6504 }
6505 }
6506
6507 if (show == 1)
6508 {
6509 if (outfile_format_chgd == 1)
6510 {
6511 if ((outfile_format > 7) && (outfile_format < 16))
6512 {
6513 log_error ("ERROR: Mixing outfile-format > 7 with show parameter is not allowed");
6514
6515 return (-1);
6516 }
6517 }
6518 }
6519
6520 if (increment_min < INCREMENT_MIN)
6521 {
6522 log_error ("ERROR: Invalid increment-min specified");
6523
6524 return (-1);
6525 }
6526
6527 if (increment_max > INCREMENT_MAX)
6528 {
6529 log_error ("ERROR: Invalid increment-max specified");
6530
6531 return (-1);
6532 }
6533
6534 if (increment_min > increment_max)
6535 {
6536 log_error ("ERROR: Invalid increment-min specified");
6537
6538 return (-1);
6539 }
6540
6541 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6542 {
6543 log_error ("ERROR: Increment is not allowed in attack-mode 0");
6544
6545 return (-1);
6546 }
6547
6548 if ((increment == 0) && (increment_min_chgd == 1))
6549 {
6550 log_error ("ERROR: Increment-min is only supported combined with increment switch");
6551
6552 return (-1);
6553 }
6554
6555 if ((increment == 0) && (increment_max_chgd == 1))
6556 {
6557 log_error ("ERROR: Increment-max is only supported combined with increment switch");
6558
6559 return (-1);
6560 }
6561
6562 if (rp_files_cnt && rp_gen)
6563 {
6564 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6565
6566 return (-1);
6567 }
6568
6569 if (rp_files_cnt || rp_gen)
6570 {
6571 if (attack_mode != ATTACK_MODE_STRAIGHT)
6572 {
6573 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6574
6575 return (-1);
6576 }
6577 }
6578
6579 if (rp_gen_func_min > rp_gen_func_max)
6580 {
6581 log_error ("ERROR: Invalid rp-gen-func-min specified");
6582
6583 return (-1);
6584 }
6585
6586 if (kernel_accel_chgd == 1)
6587 {
6588 if (force == 0)
6589 {
6590 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6591 log_info ("Please consider using the option -w instead");
6592 log_info ("You can use --force to override this but do not post error reports if you do so");
6593 log_info ("");
6594
6595 return (-1);
6596 }
6597
6598 if (kernel_accel < 1)
6599 {
6600 log_error ("ERROR: Invalid kernel-accel specified");
6601
6602 return (-1);
6603 }
6604
6605 if (kernel_accel > 1024)
6606 {
6607 log_error ("ERROR: Invalid kernel-accel specified");
6608
6609 return (-1);
6610 }
6611 }
6612
6613 if (kernel_loops_chgd == 1)
6614 {
6615 if (force == 0)
6616 {
6617 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6618 log_info ("Please consider using the option -w instead");
6619 log_info ("You can use --force to override this but do not post error reports if you do so");
6620 log_info ("");
6621
6622 return (-1);
6623 }
6624
6625 if (kernel_loops < 1)
6626 {
6627 log_error ("ERROR: Invalid kernel-loops specified");
6628
6629 return (-1);
6630 }
6631
6632 if (kernel_loops > 1024)
6633 {
6634 log_error ("ERROR: Invalid kernel-loops specified");
6635
6636 return (-1);
6637 }
6638 }
6639
6640 if ((workload_profile < 1) || (workload_profile > 4))
6641 {
6642 log_error ("ERROR: workload-profile %i not available", workload_profile);
6643
6644 return (-1);
6645 }
6646
6647 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6648 {
6649 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6650
6651 return (-1);
6652 }
6653
6654 if (show == 1 || left == 1)
6655 {
6656 attack_mode = ATTACK_MODE_NONE;
6657
6658 if (remove == 1)
6659 {
6660 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6661
6662 return (-1);
6663 }
6664
6665 if (potfile_disable == 1)
6666 {
6667 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6668
6669 return (-1);
6670 }
6671 }
6672
6673 uint attack_kern = ATTACK_KERN_NONE;
6674
6675 switch (attack_mode)
6676 {
6677 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6678 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6679 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6680 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6681 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6682 }
6683
6684 if (benchmark == 1)
6685 {
6686 if (myargv[optind] != 0)
6687 {
6688 log_error ("ERROR: Invalid argument for benchmark mode specified");
6689
6690 return (-1);
6691 }
6692
6693 if (attack_mode_chgd == 1)
6694 {
6695 if (attack_mode != ATTACK_MODE_BF)
6696 {
6697 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6698
6699 return (-1);
6700 }
6701 }
6702 }
6703 else
6704 {
6705 if (stdout_flag == 1) // no hash here
6706 {
6707 optind--;
6708 }
6709
6710 if (keyspace == 1)
6711 {
6712 int num_additional_params = 1;
6713
6714 if (attack_kern == ATTACK_KERN_COMBI)
6715 {
6716 num_additional_params = 2;
6717 }
6718
6719 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6720
6721 if (keyspace_wordlist_specified == 0) optind--;
6722 }
6723
6724 if (attack_kern == ATTACK_KERN_NONE)
6725 {
6726 if ((optind + 1) != myargc)
6727 {
6728 usage_mini_print (myargv[0]);
6729
6730 return (-1);
6731 }
6732 }
6733 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6734 {
6735 if ((optind + 1) > myargc)
6736 {
6737 usage_mini_print (myargv[0]);
6738
6739 return (-1);
6740 }
6741 }
6742 else if (attack_kern == ATTACK_KERN_COMBI)
6743 {
6744 if ((optind + 3) != myargc)
6745 {
6746 usage_mini_print (myargv[0]);
6747
6748 return (-1);
6749 }
6750 }
6751 else if (attack_kern == ATTACK_KERN_BF)
6752 {
6753 if ((optind + 1) > myargc)
6754 {
6755 usage_mini_print (myargv[0]);
6756
6757 return (-1);
6758 }
6759 }
6760 else
6761 {
6762 usage_mini_print (myargv[0]);
6763
6764 return (-1);
6765 }
6766 }
6767
6768 if (skip != 0 && limit != 0)
6769 {
6770 limit += skip;
6771 }
6772
6773 if (keyspace == 1)
6774 {
6775 if (show == 1)
6776 {
6777 log_error ("ERROR: Combining show parameter with keyspace parameter is not allowed");
6778
6779 return (-1);
6780 }
6781 else if (left == 1)
6782 {
6783 log_error ("ERROR: Combining left parameter with keyspace parameter is not allowed");
6784
6785 return (-1);
6786 }
6787
6788 potfile_disable = 1;
6789
6790 restore_disable = 1;
6791
6792 restore = 0;
6793
6794 weak_hash_threshold = 0;
6795
6796 quiet = 1;
6797 }
6798
6799 if (stdout_flag == 1)
6800 {
6801 status_timer = 0;
6802 restore_timer = 0;
6803 restore_disable = 1;
6804 restore = 0;
6805 potfile_disable = 1;
6806 weak_hash_threshold = 0;
6807 gpu_temp_disable = 1;
6808 hash_mode = 2000;
6809 quiet = 1;
6810 outfile_format = OUTFILE_FMT_PLAIN;
6811 kernel_accel = 1024;
6812 kernel_loops = 1024;
6813 force = 1;
6814 outfile_check_timer = 0;
6815 session = "stdout";
6816 opencl_vector_width = 1;
6817 }
6818
6819 if (remove_timer_chgd == 1)
6820 {
6821 if (remove == 0)
6822 {
6823 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6824
6825 return (-1);
6826 }
6827
6828 if (remove_timer < 1)
6829 {
6830 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6831
6832 return (-1);
6833 }
6834 }
6835
6836 if (loopback == 1)
6837 {
6838 if (attack_mode == ATTACK_MODE_STRAIGHT)
6839 {
6840 if ((rp_files_cnt == 0) && (rp_gen == 0))
6841 {
6842 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6843
6844 return (-1);
6845 }
6846 }
6847 else
6848 {
6849 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6850
6851 return (-1);
6852 }
6853 }
6854
6855 if (debug_mode > 0)
6856 {
6857 if (attack_mode != ATTACK_MODE_STRAIGHT)
6858 {
6859 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6860
6861 return (-1);
6862 }
6863
6864 if ((rp_files_cnt == 0) && (rp_gen == 0))
6865 {
6866 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6867
6868 return (-1);
6869 }
6870 }
6871
6872 if (debug_mode > 4)
6873 {
6874 log_error ("ERROR: Invalid debug-mode specified");
6875
6876 return (-1);
6877 }
6878
6879 if (debug_file != NULL)
6880 {
6881 if (debug_mode < 1)
6882 {
6883 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6884
6885 return (-1);
6886 }
6887 }
6888
6889 if (induction_dir != NULL)
6890 {
6891 if (attack_mode == ATTACK_MODE_BF)
6892 {
6893 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6894
6895 return (-1);
6896 }
6897 }
6898
6899 if (attack_mode != ATTACK_MODE_STRAIGHT)
6900 {
6901 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6902 {
6903 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6904
6905 return (-1);
6906 }
6907
6908 weak_hash_threshold = 0;
6909 }
6910
6911 if (nvidia_spin_damp > 100)
6912 {
6913 log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)");
6914
6915 return (-1);
6916 }
6917
6918
6919 /**
6920 * induction directory
6921 */
6922
6923 char *induction_directory = NULL;
6924
6925 if (attack_mode != ATTACK_MODE_BF)
6926 {
6927 if (induction_dir == NULL)
6928 {
6929 induction_directory = (char *) mymalloc (session_size);
6930
6931 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6932
6933 // create induction folder if it does not already exist
6934
6935 if (keyspace == 0)
6936 {
6937 if (rmdir (induction_directory) == -1)
6938 {
6939 if (errno == ENOENT)
6940 {
6941 // good, we can ignore
6942 }
6943 else if (errno == ENOTEMPTY)
6944 {
6945 char *induction_directory_mv = (char *) mymalloc (session_size);
6946
6947 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6948
6949 if (rename (induction_directory, induction_directory_mv) != 0)
6950 {
6951 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6952
6953 return (-1);
6954 }
6955 }
6956 else
6957 {
6958 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6959
6960 return (-1);
6961 }
6962 }
6963
6964 if (mkdir (induction_directory, 0700) == -1)
6965 {
6966 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6967
6968 return (-1);
6969 }
6970 }
6971 }
6972 else
6973 {
6974 induction_directory = induction_dir;
6975 }
6976 }
6977
6978 data.induction_directory = induction_directory;
6979
6980 /**
6981 * loopback
6982 */
6983
6984 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6985
6986 char *loopback_file = (char *) mymalloc (loopback_size);
6987
6988 /**
6989 * tuning db
6990 */
6991
6992 char tuning_db_file[256] = { 0 };
6993
6994 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6995
6996 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6997
6998 /**
6999 * outfile-check directory
7000 */
7001
7002 char *outfile_check_directory = NULL;
7003
7004 if (outfile_check_dir == NULL)
7005 {
7006 outfile_check_directory = (char *) mymalloc (session_size);
7007
7008 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
7009 }
7010 else
7011 {
7012 outfile_check_directory = outfile_check_dir;
7013 }
7014
7015 data.outfile_check_directory = outfile_check_directory;
7016
7017 if (keyspace == 0)
7018 {
7019 struct stat outfile_check_stat;
7020
7021 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
7022 {
7023 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
7024
7025 if (is_dir == 0)
7026 {
7027 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
7028
7029 return (-1);
7030 }
7031 }
7032 else if (outfile_check_dir == NULL)
7033 {
7034 if (mkdir (outfile_check_directory, 0700) == -1)
7035 {
7036 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
7037
7038 return (-1);
7039 }
7040 }
7041 }
7042
7043 /**
7044 * special other stuff
7045 */
7046
7047 if (hash_mode == 9710)
7048 {
7049 outfile_format = 5;
7050 outfile_format_chgd = 1;
7051 }
7052
7053 if (hash_mode == 9810)
7054 {
7055 outfile_format = 5;
7056 outfile_format_chgd = 1;
7057 }
7058
7059 if (hash_mode == 10410)
7060 {
7061 outfile_format = 5;
7062 outfile_format_chgd = 1;
7063 }
7064
7065 /**
7066 * store stuff
7067 */
7068
7069 data.hash_mode = hash_mode;
7070 data.restore = restore;
7071 data.restore_timer = restore_timer;
7072 data.restore_disable = restore_disable;
7073 data.status = status;
7074 data.status_timer = status_timer;
7075 data.machine_readable = machine_readable;
7076 data.loopback = loopback;
7077 data.runtime = runtime;
7078 data.remove = remove;
7079 data.remove_timer = remove_timer;
7080 data.debug_mode = debug_mode;
7081 data.debug_file = debug_file;
7082 data.username = username;
7083 data.quiet = quiet;
7084 data.outfile = outfile;
7085 data.outfile_format = outfile_format;
7086 data.outfile_autohex = outfile_autohex;
7087 data.hex_charset = hex_charset;
7088 data.hex_salt = hex_salt;
7089 data.hex_wordlist = hex_wordlist;
7090 data.separator = separator;
7091 data.rp_files = rp_files;
7092 data.rp_files_cnt = rp_files_cnt;
7093 data.rp_gen = rp_gen;
7094 data.rp_gen_seed = rp_gen_seed;
7095 data.force = force;
7096 data.benchmark = benchmark;
7097 data.skip = skip;
7098 data.limit = limit;
7099 #ifdef HAVE_HWMON
7100 data.powertune_enable = powertune_enable;
7101 #endif
7102 data.logfile_disable = logfile_disable;
7103 data.truecrypt_keyfiles = truecrypt_keyfiles;
7104 data.veracrypt_keyfiles = veracrypt_keyfiles;
7105 data.veracrypt_pim = veracrypt_pim;
7106 data.scrypt_tmto = scrypt_tmto;
7107 data.workload_profile = workload_profile;
7108
7109 /**
7110 * cpu affinity
7111 */
7112
7113 if (cpu_affinity)
7114 {
7115 set_cpu_affinity (cpu_affinity);
7116 }
7117
7118 if (rp_gen_seed_chgd == 0)
7119 {
7120 srand (proc_start);
7121 }
7122 else
7123 {
7124 srand (rp_gen_seed);
7125 }
7126
7127 /**
7128 * logfile init
7129 */
7130
7131 if (logfile_disable == 0)
7132 {
7133 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7134
7135 char *logfile = (char *) mymalloc (logfile_size);
7136
7137 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7138
7139 data.logfile = logfile;
7140
7141 char *topid = logfile_generate_topid ();
7142
7143 data.topid = topid;
7144 }
7145
7146 // logfile_append() checks for logfile_disable internally to make it easier from here
7147
7148 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7149 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7150 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7151 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7152 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7153 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7154 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7155 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7156 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7157 #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));
7158
7159 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7160 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7161 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7162 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7163 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7164 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7165 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7166 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7167
7168 logfile_top_msg ("START");
7169
7170 logfile_top_uint (attack_mode);
7171 logfile_top_uint (attack_kern);
7172 logfile_top_uint (benchmark);
7173 logfile_top_uint (stdout_flag);
7174 logfile_top_uint (bitmap_min);
7175 logfile_top_uint (bitmap_max);
7176 logfile_top_uint (debug_mode);
7177 logfile_top_uint (force);
7178 logfile_top_uint (kernel_accel);
7179 logfile_top_uint (kernel_loops);
7180 logfile_top_uint (nvidia_spin_damp);
7181 logfile_top_uint (gpu_temp_disable);
7182 #ifdef HAVE_HWMON
7183 logfile_top_uint (gpu_temp_abort);
7184 logfile_top_uint (gpu_temp_retain);
7185 #endif
7186 logfile_top_uint (hash_mode);
7187 logfile_top_uint (hex_charset);
7188 logfile_top_uint (hex_salt);
7189 logfile_top_uint (hex_wordlist);
7190 logfile_top_uint (increment);
7191 logfile_top_uint (increment_max);
7192 logfile_top_uint (increment_min);
7193 logfile_top_uint (keyspace);
7194 logfile_top_uint (left);
7195 logfile_top_uint (logfile_disable);
7196 logfile_top_uint (loopback);
7197 logfile_top_uint (markov_classic);
7198 logfile_top_uint (markov_disable);
7199 logfile_top_uint (markov_threshold);
7200 logfile_top_uint (outfile_autohex);
7201 logfile_top_uint (outfile_check_timer);
7202 logfile_top_uint (outfile_format);
7203 logfile_top_uint (potfile_disable);
7204 logfile_top_string (potfile_path);
7205 #if defined(HAVE_HWMON)
7206 logfile_top_uint (powertune_enable);
7207 #endif
7208 logfile_top_uint (scrypt_tmto);
7209 logfile_top_uint (quiet);
7210 logfile_top_uint (remove);
7211 logfile_top_uint (remove_timer);
7212 logfile_top_uint (restore);
7213 logfile_top_uint (restore_disable);
7214 logfile_top_uint (restore_timer);
7215 logfile_top_uint (rp_gen);
7216 logfile_top_uint (rp_gen_func_max);
7217 logfile_top_uint (rp_gen_func_min);
7218 logfile_top_uint (rp_gen_seed);
7219 logfile_top_uint (runtime);
7220 logfile_top_uint (segment_size);
7221 logfile_top_uint (show);
7222 logfile_top_uint (status);
7223 logfile_top_uint (machine_readable);
7224 logfile_top_uint (status_timer);
7225 logfile_top_uint (usage);
7226 logfile_top_uint (username);
7227 logfile_top_uint (version);
7228 logfile_top_uint (weak_hash_threshold);
7229 logfile_top_uint (workload_profile);
7230 logfile_top_uint64 (limit);
7231 logfile_top_uint64 (skip);
7232 logfile_top_char (separator);
7233 logfile_top_string (cpu_affinity);
7234 logfile_top_string (custom_charset_1);
7235 logfile_top_string (custom_charset_2);
7236 logfile_top_string (custom_charset_3);
7237 logfile_top_string (custom_charset_4);
7238 logfile_top_string (debug_file);
7239 logfile_top_string (opencl_devices);
7240 logfile_top_string (opencl_platforms);
7241 logfile_top_string (opencl_device_types);
7242 logfile_top_uint (opencl_vector_width);
7243 logfile_top_string (induction_dir);
7244 logfile_top_string (markov_hcstat);
7245 logfile_top_string (outfile);
7246 logfile_top_string (outfile_check_dir);
7247 logfile_top_string (rule_buf_l);
7248 logfile_top_string (rule_buf_r);
7249 logfile_top_string (session);
7250 logfile_top_string (truecrypt_keyfiles);
7251 logfile_top_string (veracrypt_keyfiles);
7252 logfile_top_uint (veracrypt_pim);
7253
7254 /**
7255 * Init OpenCL library loader
7256 */
7257
7258 if (keyspace == 0)
7259 {
7260 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7261
7262 ocl_init (ocl);
7263
7264 data.ocl = ocl;
7265 }
7266
7267 /**
7268 * OpenCL platform selection
7269 */
7270
7271 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7272
7273 /**
7274 * OpenCL device selection
7275 */
7276
7277 u32 devices_filter = setup_devices_filter (opencl_devices);
7278
7279 /**
7280 * OpenCL device type selection
7281 */
7282
7283 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7284
7285 /**
7286 * benchmark
7287 */
7288
7289 if (benchmark == 1)
7290 {
7291 /**
7292 * disable useless stuff for benchmark
7293 */
7294
7295 status_timer = 0;
7296 restore_timer = 0;
7297 restore_disable = 1;
7298 potfile_disable = 1;
7299 weak_hash_threshold = 0;
7300 nvidia_spin_damp = 0;
7301 gpu_temp_disable = 1;
7302 outfile_check_timer = 0;
7303
7304 #ifdef HAVE_HWMON
7305 if (powertune_enable == 1)
7306 {
7307 gpu_temp_disable = 0;
7308 }
7309 #endif
7310
7311 data.status_timer = status_timer;
7312 data.restore_timer = restore_timer;
7313 data.restore_disable = restore_disable;
7314 data.outfile_check_timer = outfile_check_timer;
7315
7316 /**
7317 * force attack mode to be bruteforce
7318 */
7319
7320 attack_mode = ATTACK_MODE_BF;
7321 attack_kern = ATTACK_KERN_BF;
7322
7323 if (workload_profile_chgd == 0)
7324 {
7325 workload_profile = 3;
7326
7327 data.workload_profile = workload_profile;
7328 }
7329 }
7330
7331 /**
7332 * config
7333 */
7334
7335 uint hash_type = 0;
7336 uint salt_type = 0;
7337 uint attack_exec = 0;
7338 uint opts_type = 0;
7339 uint kern_type = 0;
7340 uint dgst_size = 0;
7341 uint esalt_size = 0;
7342 uint opti_type = 0;
7343 uint dgst_pos0 = -1;
7344 uint dgst_pos1 = -1;
7345 uint dgst_pos2 = -1;
7346 uint dgst_pos3 = -1;
7347
7348 int (*parse_func) (char *, uint, hash_t *);
7349 int (*sort_by_digest) (const void *, const void *);
7350
7351 uint algorithm_pos = 0;
7352 uint algorithm_max = 1;
7353
7354 uint *algorithms = default_benchmark_algorithms;
7355
7356 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7357
7358 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7359 {
7360 /*
7361 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7362 * the following algos are skipped entirely
7363 */
7364
7365 if (algorithm_pos > 0)
7366 {
7367 local_free (rd);
7368
7369 rd = init_restore (argc, argv);
7370
7371 data.rd = rd;
7372 }
7373
7374 /**
7375 * update hash_mode in case of multihash benchmark
7376 */
7377
7378 if (benchmark == 1)
7379 {
7380 if (hash_mode_chgd == 0)
7381 {
7382 hash_mode = algorithms[algorithm_pos];
7383
7384 data.hash_mode = hash_mode;
7385 }
7386
7387 quiet = 1;
7388
7389 data.quiet = quiet;
7390 }
7391
7392 switch (hash_mode)
7393 {
7394 case 0: hash_type = HASH_TYPE_MD5;
7395 salt_type = SALT_TYPE_NONE;
7396 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7397 opts_type = OPTS_TYPE_PT_GENERATE_LE
7398 | OPTS_TYPE_PT_ADD80
7399 | OPTS_TYPE_PT_ADDBITS14;
7400 kern_type = KERN_TYPE_MD5;
7401 dgst_size = DGST_SIZE_4_4;
7402 parse_func = md5_parse_hash;
7403 sort_by_digest = sort_by_digest_4_4;
7404 opti_type = OPTI_TYPE_ZERO_BYTE
7405 | OPTI_TYPE_PRECOMPUTE_INIT
7406 | OPTI_TYPE_PRECOMPUTE_MERKLE
7407 | OPTI_TYPE_MEET_IN_MIDDLE
7408 | OPTI_TYPE_EARLY_SKIP
7409 | OPTI_TYPE_NOT_ITERATED
7410 | OPTI_TYPE_NOT_SALTED
7411 | OPTI_TYPE_RAW_HASH;
7412 dgst_pos0 = 0;
7413 dgst_pos1 = 3;
7414 dgst_pos2 = 2;
7415 dgst_pos3 = 1;
7416 break;
7417
7418 case 10: hash_type = HASH_TYPE_MD5;
7419 salt_type = SALT_TYPE_INTERN;
7420 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7421 opts_type = OPTS_TYPE_PT_GENERATE_LE
7422 | OPTS_TYPE_ST_ADD80
7423 | OPTS_TYPE_ST_ADDBITS14;
7424 kern_type = KERN_TYPE_MD5_PWSLT;
7425 dgst_size = DGST_SIZE_4_4;
7426 parse_func = md5s_parse_hash;
7427 sort_by_digest = sort_by_digest_4_4;
7428 opti_type = OPTI_TYPE_ZERO_BYTE
7429 | OPTI_TYPE_PRECOMPUTE_INIT
7430 | OPTI_TYPE_PRECOMPUTE_MERKLE
7431 | OPTI_TYPE_MEET_IN_MIDDLE
7432 | OPTI_TYPE_EARLY_SKIP
7433 | OPTI_TYPE_NOT_ITERATED
7434 | OPTI_TYPE_APPENDED_SALT
7435 | OPTI_TYPE_RAW_HASH;
7436 dgst_pos0 = 0;
7437 dgst_pos1 = 3;
7438 dgst_pos2 = 2;
7439 dgst_pos3 = 1;
7440 break;
7441
7442 case 11: hash_type = HASH_TYPE_MD5;
7443 salt_type = SALT_TYPE_INTERN;
7444 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7445 opts_type = OPTS_TYPE_PT_GENERATE_LE
7446 | OPTS_TYPE_ST_ADD80
7447 | OPTS_TYPE_ST_ADDBITS14;
7448 kern_type = KERN_TYPE_MD5_PWSLT;
7449 dgst_size = DGST_SIZE_4_4;
7450 parse_func = joomla_parse_hash;
7451 sort_by_digest = sort_by_digest_4_4;
7452 opti_type = OPTI_TYPE_ZERO_BYTE
7453 | OPTI_TYPE_PRECOMPUTE_INIT
7454 | OPTI_TYPE_PRECOMPUTE_MERKLE
7455 | OPTI_TYPE_MEET_IN_MIDDLE
7456 | OPTI_TYPE_EARLY_SKIP
7457 | OPTI_TYPE_NOT_ITERATED
7458 | OPTI_TYPE_APPENDED_SALT
7459 | OPTI_TYPE_RAW_HASH;
7460 dgst_pos0 = 0;
7461 dgst_pos1 = 3;
7462 dgst_pos2 = 2;
7463 dgst_pos3 = 1;
7464 break;
7465
7466 case 12: hash_type = HASH_TYPE_MD5;
7467 salt_type = SALT_TYPE_INTERN;
7468 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7469 opts_type = OPTS_TYPE_PT_GENERATE_LE
7470 | OPTS_TYPE_ST_ADD80
7471 | OPTS_TYPE_ST_ADDBITS14;
7472 kern_type = KERN_TYPE_MD5_PWSLT;
7473 dgst_size = DGST_SIZE_4_4;
7474 parse_func = postgresql_parse_hash;
7475 sort_by_digest = sort_by_digest_4_4;
7476 opti_type = OPTI_TYPE_ZERO_BYTE
7477 | OPTI_TYPE_PRECOMPUTE_INIT
7478 | OPTI_TYPE_PRECOMPUTE_MERKLE
7479 | OPTI_TYPE_MEET_IN_MIDDLE
7480 | OPTI_TYPE_EARLY_SKIP
7481 | OPTI_TYPE_NOT_ITERATED
7482 | OPTI_TYPE_APPENDED_SALT
7483 | OPTI_TYPE_RAW_HASH;
7484 dgst_pos0 = 0;
7485 dgst_pos1 = 3;
7486 dgst_pos2 = 2;
7487 dgst_pos3 = 1;
7488 break;
7489
7490 case 20: hash_type = HASH_TYPE_MD5;
7491 salt_type = SALT_TYPE_INTERN;
7492 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7493 opts_type = OPTS_TYPE_PT_GENERATE_LE
7494 | OPTS_TYPE_PT_ADD80
7495 | OPTS_TYPE_PT_ADDBITS14;
7496 kern_type = KERN_TYPE_MD5_SLTPW;
7497 dgst_size = DGST_SIZE_4_4;
7498 parse_func = md5s_parse_hash;
7499 sort_by_digest = sort_by_digest_4_4;
7500 opti_type = OPTI_TYPE_ZERO_BYTE
7501 | OPTI_TYPE_PRECOMPUTE_INIT
7502 | OPTI_TYPE_PRECOMPUTE_MERKLE
7503 | OPTI_TYPE_EARLY_SKIP
7504 | OPTI_TYPE_NOT_ITERATED
7505 | OPTI_TYPE_PREPENDED_SALT
7506 | OPTI_TYPE_RAW_HASH;
7507 dgst_pos0 = 0;
7508 dgst_pos1 = 3;
7509 dgst_pos2 = 2;
7510 dgst_pos3 = 1;
7511 break;
7512
7513 case 21: hash_type = HASH_TYPE_MD5;
7514 salt_type = SALT_TYPE_INTERN;
7515 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7516 opts_type = OPTS_TYPE_PT_GENERATE_LE
7517 | OPTS_TYPE_PT_ADD80
7518 | OPTS_TYPE_PT_ADDBITS14;
7519 kern_type = KERN_TYPE_MD5_SLTPW;
7520 dgst_size = DGST_SIZE_4_4;
7521 parse_func = osc_parse_hash;
7522 sort_by_digest = sort_by_digest_4_4;
7523 opti_type = OPTI_TYPE_ZERO_BYTE
7524 | OPTI_TYPE_PRECOMPUTE_INIT
7525 | OPTI_TYPE_PRECOMPUTE_MERKLE
7526 | OPTI_TYPE_EARLY_SKIP
7527 | OPTI_TYPE_NOT_ITERATED
7528 | OPTI_TYPE_PREPENDED_SALT
7529 | OPTI_TYPE_RAW_HASH;
7530 dgst_pos0 = 0;
7531 dgst_pos1 = 3;
7532 dgst_pos2 = 2;
7533 dgst_pos3 = 1;
7534 break;
7535
7536 case 22: hash_type = HASH_TYPE_MD5;
7537 salt_type = SALT_TYPE_EMBEDDED;
7538 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7539 opts_type = OPTS_TYPE_PT_GENERATE_LE
7540 | OPTS_TYPE_PT_ADD80
7541 | OPTS_TYPE_PT_ADDBITS14;
7542 kern_type = KERN_TYPE_MD5_SLTPW;
7543 dgst_size = DGST_SIZE_4_4;
7544 parse_func = netscreen_parse_hash;
7545 sort_by_digest = sort_by_digest_4_4;
7546 opti_type = OPTI_TYPE_ZERO_BYTE
7547 | OPTI_TYPE_PRECOMPUTE_INIT
7548 | OPTI_TYPE_PRECOMPUTE_MERKLE
7549 | OPTI_TYPE_EARLY_SKIP
7550 | OPTI_TYPE_NOT_ITERATED
7551 | OPTI_TYPE_PREPENDED_SALT
7552 | OPTI_TYPE_RAW_HASH;
7553 dgst_pos0 = 0;
7554 dgst_pos1 = 3;
7555 dgst_pos2 = 2;
7556 dgst_pos3 = 1;
7557 break;
7558
7559 case 23: hash_type = HASH_TYPE_MD5;
7560 salt_type = SALT_TYPE_EMBEDDED;
7561 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7562 opts_type = OPTS_TYPE_PT_GENERATE_LE
7563 | OPTS_TYPE_PT_ADD80
7564 | OPTS_TYPE_PT_ADDBITS14;
7565 kern_type = KERN_TYPE_MD5_SLTPW;
7566 dgst_size = DGST_SIZE_4_4;
7567 parse_func = skype_parse_hash;
7568 sort_by_digest = sort_by_digest_4_4;
7569 opti_type = OPTI_TYPE_ZERO_BYTE
7570 | OPTI_TYPE_PRECOMPUTE_INIT
7571 | OPTI_TYPE_PRECOMPUTE_MERKLE
7572 | OPTI_TYPE_EARLY_SKIP
7573 | OPTI_TYPE_NOT_ITERATED
7574 | OPTI_TYPE_PREPENDED_SALT
7575 | OPTI_TYPE_RAW_HASH;
7576 dgst_pos0 = 0;
7577 dgst_pos1 = 3;
7578 dgst_pos2 = 2;
7579 dgst_pos3 = 1;
7580 break;
7581
7582 case 30: hash_type = HASH_TYPE_MD5;
7583 salt_type = SALT_TYPE_INTERN;
7584 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7585 opts_type = OPTS_TYPE_PT_GENERATE_LE
7586 | OPTS_TYPE_PT_UNICODE
7587 | OPTS_TYPE_ST_ADD80
7588 | OPTS_TYPE_ST_ADDBITS14;
7589 kern_type = KERN_TYPE_MD5_PWUSLT;
7590 dgst_size = DGST_SIZE_4_4;
7591 parse_func = md5s_parse_hash;
7592 sort_by_digest = sort_by_digest_4_4;
7593 opti_type = OPTI_TYPE_ZERO_BYTE
7594 | OPTI_TYPE_PRECOMPUTE_INIT
7595 | OPTI_TYPE_PRECOMPUTE_MERKLE
7596 | OPTI_TYPE_MEET_IN_MIDDLE
7597 | OPTI_TYPE_EARLY_SKIP
7598 | OPTI_TYPE_NOT_ITERATED
7599 | OPTI_TYPE_APPENDED_SALT
7600 | OPTI_TYPE_RAW_HASH;
7601 dgst_pos0 = 0;
7602 dgst_pos1 = 3;
7603 dgst_pos2 = 2;
7604 dgst_pos3 = 1;
7605 break;
7606
7607 case 40: hash_type = HASH_TYPE_MD5;
7608 salt_type = SALT_TYPE_INTERN;
7609 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7610 opts_type = OPTS_TYPE_PT_GENERATE_LE
7611 | OPTS_TYPE_PT_ADD80
7612 | OPTS_TYPE_PT_ADDBITS14
7613 | OPTS_TYPE_PT_UNICODE;
7614 kern_type = KERN_TYPE_MD5_SLTPWU;
7615 dgst_size = DGST_SIZE_4_4;
7616 parse_func = md5s_parse_hash;
7617 sort_by_digest = sort_by_digest_4_4;
7618 opti_type = OPTI_TYPE_ZERO_BYTE
7619 | OPTI_TYPE_PRECOMPUTE_INIT
7620 | OPTI_TYPE_PRECOMPUTE_MERKLE
7621 | OPTI_TYPE_EARLY_SKIP
7622 | OPTI_TYPE_NOT_ITERATED
7623 | OPTI_TYPE_PREPENDED_SALT
7624 | OPTI_TYPE_RAW_HASH;
7625 dgst_pos0 = 0;
7626 dgst_pos1 = 3;
7627 dgst_pos2 = 2;
7628 dgst_pos3 = 1;
7629 break;
7630
7631 case 50: hash_type = HASH_TYPE_MD5;
7632 salt_type = SALT_TYPE_INTERN;
7633 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7634 opts_type = OPTS_TYPE_PT_GENERATE_LE
7635 | OPTS_TYPE_ST_ADD80
7636 | OPTS_TYPE_ST_ADDBITS14;
7637 kern_type = KERN_TYPE_HMACMD5_PW;
7638 dgst_size = DGST_SIZE_4_4;
7639 parse_func = hmacmd5_parse_hash;
7640 sort_by_digest = sort_by_digest_4_4;
7641 opti_type = OPTI_TYPE_ZERO_BYTE
7642 | OPTI_TYPE_NOT_ITERATED;
7643 dgst_pos0 = 0;
7644 dgst_pos1 = 3;
7645 dgst_pos2 = 2;
7646 dgst_pos3 = 1;
7647 break;
7648
7649 case 60: hash_type = HASH_TYPE_MD5;
7650 salt_type = SALT_TYPE_INTERN;
7651 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7652 opts_type = OPTS_TYPE_PT_GENERATE_LE
7653 | OPTS_TYPE_PT_ADD80
7654 | OPTS_TYPE_PT_ADDBITS14;
7655 kern_type = KERN_TYPE_HMACMD5_SLT;
7656 dgst_size = DGST_SIZE_4_4;
7657 parse_func = hmacmd5_parse_hash;
7658 sort_by_digest = sort_by_digest_4_4;
7659 opti_type = OPTI_TYPE_ZERO_BYTE
7660 | OPTI_TYPE_NOT_ITERATED;
7661 dgst_pos0 = 0;
7662 dgst_pos1 = 3;
7663 dgst_pos2 = 2;
7664 dgst_pos3 = 1;
7665 break;
7666
7667 case 100: hash_type = HASH_TYPE_SHA1;
7668 salt_type = SALT_TYPE_NONE;
7669 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7670 opts_type = OPTS_TYPE_PT_GENERATE_BE
7671 | OPTS_TYPE_PT_ADD80
7672 | OPTS_TYPE_PT_ADDBITS15;
7673 kern_type = KERN_TYPE_SHA1;
7674 dgst_size = DGST_SIZE_4_5;
7675 parse_func = sha1_parse_hash;
7676 sort_by_digest = sort_by_digest_4_5;
7677 opti_type = OPTI_TYPE_ZERO_BYTE
7678 | OPTI_TYPE_PRECOMPUTE_INIT
7679 | OPTI_TYPE_PRECOMPUTE_MERKLE
7680 | OPTI_TYPE_EARLY_SKIP
7681 | OPTI_TYPE_NOT_ITERATED
7682 | OPTI_TYPE_NOT_SALTED
7683 | OPTI_TYPE_RAW_HASH;
7684 dgst_pos0 = 3;
7685 dgst_pos1 = 4;
7686 dgst_pos2 = 2;
7687 dgst_pos3 = 1;
7688 break;
7689
7690 case 101: hash_type = HASH_TYPE_SHA1;
7691 salt_type = SALT_TYPE_NONE;
7692 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7693 opts_type = OPTS_TYPE_PT_GENERATE_BE
7694 | OPTS_TYPE_PT_ADD80
7695 | OPTS_TYPE_PT_ADDBITS15;
7696 kern_type = KERN_TYPE_SHA1;
7697 dgst_size = DGST_SIZE_4_5;
7698 parse_func = sha1b64_parse_hash;
7699 sort_by_digest = sort_by_digest_4_5;
7700 opti_type = OPTI_TYPE_ZERO_BYTE
7701 | OPTI_TYPE_PRECOMPUTE_INIT
7702 | OPTI_TYPE_PRECOMPUTE_MERKLE
7703 | OPTI_TYPE_EARLY_SKIP
7704 | OPTI_TYPE_NOT_ITERATED
7705 | OPTI_TYPE_NOT_SALTED
7706 | OPTI_TYPE_RAW_HASH;
7707 dgst_pos0 = 3;
7708 dgst_pos1 = 4;
7709 dgst_pos2 = 2;
7710 dgst_pos3 = 1;
7711 break;
7712
7713 case 110: hash_type = HASH_TYPE_SHA1;
7714 salt_type = SALT_TYPE_INTERN;
7715 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7716 opts_type = OPTS_TYPE_PT_GENERATE_BE
7717 | OPTS_TYPE_ST_ADD80
7718 | OPTS_TYPE_ST_ADDBITS15;
7719 kern_type = KERN_TYPE_SHA1_PWSLT;
7720 dgst_size = DGST_SIZE_4_5;
7721 parse_func = sha1s_parse_hash;
7722 sort_by_digest = sort_by_digest_4_5;
7723 opti_type = OPTI_TYPE_ZERO_BYTE
7724 | OPTI_TYPE_PRECOMPUTE_INIT
7725 | OPTI_TYPE_PRECOMPUTE_MERKLE
7726 | OPTI_TYPE_EARLY_SKIP
7727 | OPTI_TYPE_NOT_ITERATED
7728 | OPTI_TYPE_APPENDED_SALT
7729 | OPTI_TYPE_RAW_HASH;
7730 dgst_pos0 = 3;
7731 dgst_pos1 = 4;
7732 dgst_pos2 = 2;
7733 dgst_pos3 = 1;
7734 break;
7735
7736 case 111: hash_type = HASH_TYPE_SHA1;
7737 salt_type = SALT_TYPE_EMBEDDED;
7738 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7739 opts_type = OPTS_TYPE_PT_GENERATE_BE
7740 | OPTS_TYPE_ST_ADD80
7741 | OPTS_TYPE_ST_ADDBITS15;
7742 kern_type = KERN_TYPE_SHA1_PWSLT;
7743 dgst_size = DGST_SIZE_4_5;
7744 parse_func = sha1b64s_parse_hash;
7745 sort_by_digest = sort_by_digest_4_5;
7746 opti_type = OPTI_TYPE_ZERO_BYTE
7747 | OPTI_TYPE_PRECOMPUTE_INIT
7748 | OPTI_TYPE_PRECOMPUTE_MERKLE
7749 | OPTI_TYPE_EARLY_SKIP
7750 | OPTI_TYPE_NOT_ITERATED
7751 | OPTI_TYPE_APPENDED_SALT
7752 | OPTI_TYPE_RAW_HASH;
7753 dgst_pos0 = 3;
7754 dgst_pos1 = 4;
7755 dgst_pos2 = 2;
7756 dgst_pos3 = 1;
7757 break;
7758
7759 case 112: hash_type = HASH_TYPE_SHA1;
7760 salt_type = SALT_TYPE_INTERN;
7761 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7762 opts_type = OPTS_TYPE_PT_GENERATE_BE
7763 | OPTS_TYPE_ST_ADD80
7764 | OPTS_TYPE_ST_ADDBITS15
7765 | OPTS_TYPE_ST_HEX;
7766 kern_type = KERN_TYPE_SHA1_PWSLT;
7767 dgst_size = DGST_SIZE_4_5;
7768 parse_func = oracles_parse_hash;
7769 sort_by_digest = sort_by_digest_4_5;
7770 opti_type = OPTI_TYPE_ZERO_BYTE
7771 | OPTI_TYPE_PRECOMPUTE_INIT
7772 | OPTI_TYPE_PRECOMPUTE_MERKLE
7773 | OPTI_TYPE_EARLY_SKIP
7774 | OPTI_TYPE_NOT_ITERATED
7775 | OPTI_TYPE_APPENDED_SALT
7776 | OPTI_TYPE_RAW_HASH;
7777 dgst_pos0 = 3;
7778 dgst_pos1 = 4;
7779 dgst_pos2 = 2;
7780 dgst_pos3 = 1;
7781 break;
7782
7783 case 120: hash_type = HASH_TYPE_SHA1;
7784 salt_type = SALT_TYPE_INTERN;
7785 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7786 opts_type = OPTS_TYPE_PT_GENERATE_BE
7787 | OPTS_TYPE_PT_ADD80
7788 | OPTS_TYPE_PT_ADDBITS15;
7789 kern_type = KERN_TYPE_SHA1_SLTPW;
7790 dgst_size = DGST_SIZE_4_5;
7791 parse_func = sha1s_parse_hash;
7792 sort_by_digest = sort_by_digest_4_5;
7793 opti_type = OPTI_TYPE_ZERO_BYTE
7794 | OPTI_TYPE_PRECOMPUTE_INIT
7795 | OPTI_TYPE_PRECOMPUTE_MERKLE
7796 | OPTI_TYPE_EARLY_SKIP
7797 | OPTI_TYPE_NOT_ITERATED
7798 | OPTI_TYPE_PREPENDED_SALT
7799 | OPTI_TYPE_RAW_HASH;
7800 dgst_pos0 = 3;
7801 dgst_pos1 = 4;
7802 dgst_pos2 = 2;
7803 dgst_pos3 = 1;
7804 break;
7805
7806 case 121: hash_type = HASH_TYPE_SHA1;
7807 salt_type = SALT_TYPE_INTERN;
7808 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7809 opts_type = OPTS_TYPE_PT_GENERATE_BE
7810 | OPTS_TYPE_PT_ADD80
7811 | OPTS_TYPE_PT_ADDBITS15
7812 | OPTS_TYPE_ST_LOWER;
7813 kern_type = KERN_TYPE_SHA1_SLTPW;
7814 dgst_size = DGST_SIZE_4_5;
7815 parse_func = smf_parse_hash;
7816 sort_by_digest = sort_by_digest_4_5;
7817 opti_type = OPTI_TYPE_ZERO_BYTE
7818 | OPTI_TYPE_PRECOMPUTE_INIT
7819 | OPTI_TYPE_PRECOMPUTE_MERKLE
7820 | OPTI_TYPE_EARLY_SKIP
7821 | OPTI_TYPE_NOT_ITERATED
7822 | OPTI_TYPE_PREPENDED_SALT
7823 | OPTI_TYPE_RAW_HASH;
7824 dgst_pos0 = 3;
7825 dgst_pos1 = 4;
7826 dgst_pos2 = 2;
7827 dgst_pos3 = 1;
7828 break;
7829
7830 case 122: hash_type = HASH_TYPE_SHA1;
7831 salt_type = SALT_TYPE_EMBEDDED;
7832 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7833 opts_type = OPTS_TYPE_PT_GENERATE_BE
7834 | OPTS_TYPE_PT_ADD80
7835 | OPTS_TYPE_PT_ADDBITS15
7836 | OPTS_TYPE_ST_HEX;
7837 kern_type = KERN_TYPE_SHA1_SLTPW;
7838 dgst_size = DGST_SIZE_4_5;
7839 parse_func = osx1_parse_hash;
7840 sort_by_digest = sort_by_digest_4_5;
7841 opti_type = OPTI_TYPE_ZERO_BYTE
7842 | OPTI_TYPE_PRECOMPUTE_INIT
7843 | OPTI_TYPE_PRECOMPUTE_MERKLE
7844 | OPTI_TYPE_EARLY_SKIP
7845 | OPTI_TYPE_NOT_ITERATED
7846 | OPTI_TYPE_PREPENDED_SALT
7847 | OPTI_TYPE_RAW_HASH;
7848 dgst_pos0 = 3;
7849 dgst_pos1 = 4;
7850 dgst_pos2 = 2;
7851 dgst_pos3 = 1;
7852 break;
7853
7854 case 124: hash_type = HASH_TYPE_SHA1;
7855 salt_type = SALT_TYPE_EMBEDDED;
7856 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7857 opts_type = OPTS_TYPE_PT_GENERATE_BE
7858 | OPTS_TYPE_PT_ADD80
7859 | OPTS_TYPE_PT_ADDBITS15;
7860 kern_type = KERN_TYPE_SHA1_SLTPW;
7861 dgst_size = DGST_SIZE_4_5;
7862 parse_func = djangosha1_parse_hash;
7863 sort_by_digest = sort_by_digest_4_5;
7864 opti_type = OPTI_TYPE_ZERO_BYTE
7865 | OPTI_TYPE_PRECOMPUTE_INIT
7866 | OPTI_TYPE_PRECOMPUTE_MERKLE
7867 | OPTI_TYPE_EARLY_SKIP
7868 | OPTI_TYPE_NOT_ITERATED
7869 | OPTI_TYPE_PREPENDED_SALT
7870 | OPTI_TYPE_RAW_HASH;
7871 dgst_pos0 = 3;
7872 dgst_pos1 = 4;
7873 dgst_pos2 = 2;
7874 dgst_pos3 = 1;
7875 break;
7876
7877 case 125: hash_type = HASH_TYPE_SHA1;
7878 salt_type = SALT_TYPE_EMBEDDED;
7879 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7880 opts_type = OPTS_TYPE_PT_GENERATE_BE
7881 | OPTS_TYPE_PT_ADD80
7882 | OPTS_TYPE_PT_ADDBITS15
7883 | OPTS_TYPE_ST_HEX;
7884 kern_type = KERN_TYPE_SHA1_SLTPW;
7885 dgst_size = DGST_SIZE_4_5;
7886 parse_func = arubaos_parse_hash;
7887 sort_by_digest = sort_by_digest_4_5;
7888 opti_type = OPTI_TYPE_ZERO_BYTE
7889 | OPTI_TYPE_PRECOMPUTE_INIT
7890 | OPTI_TYPE_PRECOMPUTE_MERKLE
7891 | OPTI_TYPE_EARLY_SKIP
7892 | OPTI_TYPE_NOT_ITERATED
7893 | OPTI_TYPE_PREPENDED_SALT
7894 | OPTI_TYPE_RAW_HASH;
7895 dgst_pos0 = 3;
7896 dgst_pos1 = 4;
7897 dgst_pos2 = 2;
7898 dgst_pos3 = 1;
7899 break;
7900
7901 case 130: hash_type = HASH_TYPE_SHA1;
7902 salt_type = SALT_TYPE_INTERN;
7903 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7904 opts_type = OPTS_TYPE_PT_GENERATE_BE
7905 | OPTS_TYPE_PT_UNICODE
7906 | OPTS_TYPE_ST_ADD80
7907 | OPTS_TYPE_ST_ADDBITS15;
7908 kern_type = KERN_TYPE_SHA1_PWUSLT;
7909 dgst_size = DGST_SIZE_4_5;
7910 parse_func = sha1s_parse_hash;
7911 sort_by_digest = sort_by_digest_4_5;
7912 opti_type = OPTI_TYPE_ZERO_BYTE
7913 | OPTI_TYPE_PRECOMPUTE_INIT
7914 | OPTI_TYPE_PRECOMPUTE_MERKLE
7915 | OPTI_TYPE_EARLY_SKIP
7916 | OPTI_TYPE_NOT_ITERATED
7917 | OPTI_TYPE_APPENDED_SALT
7918 | OPTI_TYPE_RAW_HASH;
7919 dgst_pos0 = 3;
7920 dgst_pos1 = 4;
7921 dgst_pos2 = 2;
7922 dgst_pos3 = 1;
7923 break;
7924
7925 case 131: hash_type = HASH_TYPE_SHA1;
7926 salt_type = SALT_TYPE_EMBEDDED;
7927 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7928 opts_type = OPTS_TYPE_PT_GENERATE_BE
7929 | OPTS_TYPE_PT_UNICODE
7930 | OPTS_TYPE_PT_UPPER
7931 | OPTS_TYPE_ST_ADD80
7932 | OPTS_TYPE_ST_ADDBITS15
7933 | OPTS_TYPE_ST_HEX;
7934 kern_type = KERN_TYPE_SHA1_PWUSLT;
7935 dgst_size = DGST_SIZE_4_5;
7936 parse_func = mssql2000_parse_hash;
7937 sort_by_digest = sort_by_digest_4_5;
7938 opti_type = OPTI_TYPE_ZERO_BYTE
7939 | OPTI_TYPE_PRECOMPUTE_INIT
7940 | OPTI_TYPE_PRECOMPUTE_MERKLE
7941 | OPTI_TYPE_EARLY_SKIP
7942 | OPTI_TYPE_NOT_ITERATED
7943 | OPTI_TYPE_APPENDED_SALT
7944 | OPTI_TYPE_RAW_HASH;
7945 dgst_pos0 = 3;
7946 dgst_pos1 = 4;
7947 dgst_pos2 = 2;
7948 dgst_pos3 = 1;
7949 break;
7950
7951 case 132: hash_type = HASH_TYPE_SHA1;
7952 salt_type = SALT_TYPE_EMBEDDED;
7953 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7954 opts_type = OPTS_TYPE_PT_GENERATE_BE
7955 | OPTS_TYPE_PT_UNICODE
7956 | OPTS_TYPE_ST_ADD80
7957 | OPTS_TYPE_ST_ADDBITS15
7958 | OPTS_TYPE_ST_HEX;
7959 kern_type = KERN_TYPE_SHA1_PWUSLT;
7960 dgst_size = DGST_SIZE_4_5;
7961 parse_func = mssql2005_parse_hash;
7962 sort_by_digest = sort_by_digest_4_5;
7963 opti_type = OPTI_TYPE_ZERO_BYTE
7964 | OPTI_TYPE_PRECOMPUTE_INIT
7965 | OPTI_TYPE_PRECOMPUTE_MERKLE
7966 | OPTI_TYPE_EARLY_SKIP
7967 | OPTI_TYPE_NOT_ITERATED
7968 | OPTI_TYPE_APPENDED_SALT
7969 | OPTI_TYPE_RAW_HASH;
7970 dgst_pos0 = 3;
7971 dgst_pos1 = 4;
7972 dgst_pos2 = 2;
7973 dgst_pos3 = 1;
7974 break;
7975
7976 case 133: hash_type = HASH_TYPE_SHA1;
7977 salt_type = SALT_TYPE_EMBEDDED;
7978 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7979 opts_type = OPTS_TYPE_PT_GENERATE_BE
7980 | OPTS_TYPE_PT_UNICODE
7981 | OPTS_TYPE_ST_ADD80
7982 | OPTS_TYPE_ST_ADDBITS15;
7983 kern_type = KERN_TYPE_SHA1_PWUSLT;
7984 dgst_size = DGST_SIZE_4_5;
7985 parse_func = peoplesoft_parse_hash;
7986 sort_by_digest = sort_by_digest_4_5;
7987 opti_type = OPTI_TYPE_ZERO_BYTE
7988 | OPTI_TYPE_PRECOMPUTE_INIT
7989 | OPTI_TYPE_PRECOMPUTE_MERKLE
7990 | OPTI_TYPE_EARLY_SKIP
7991 | OPTI_TYPE_NOT_ITERATED
7992 | OPTI_TYPE_APPENDED_SALT
7993 | OPTI_TYPE_RAW_HASH;
7994 dgst_pos0 = 3;
7995 dgst_pos1 = 4;
7996 dgst_pos2 = 2;
7997 dgst_pos3 = 1;
7998 break;
7999
8000 case 140: hash_type = HASH_TYPE_SHA1;
8001 salt_type = SALT_TYPE_INTERN;
8002 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8003 opts_type = OPTS_TYPE_PT_GENERATE_BE
8004 | OPTS_TYPE_PT_ADD80
8005 | OPTS_TYPE_PT_ADDBITS15
8006 | OPTS_TYPE_PT_UNICODE;
8007 kern_type = KERN_TYPE_SHA1_SLTPWU;
8008 dgst_size = DGST_SIZE_4_5;
8009 parse_func = sha1s_parse_hash;
8010 sort_by_digest = sort_by_digest_4_5;
8011 opti_type = OPTI_TYPE_ZERO_BYTE
8012 | OPTI_TYPE_PRECOMPUTE_INIT
8013 | OPTI_TYPE_PRECOMPUTE_MERKLE
8014 | OPTI_TYPE_EARLY_SKIP
8015 | OPTI_TYPE_NOT_ITERATED
8016 | OPTI_TYPE_PREPENDED_SALT
8017 | OPTI_TYPE_RAW_HASH;
8018 dgst_pos0 = 3;
8019 dgst_pos1 = 4;
8020 dgst_pos2 = 2;
8021 dgst_pos3 = 1;
8022 break;
8023
8024 case 141: hash_type = HASH_TYPE_SHA1;
8025 salt_type = SALT_TYPE_EMBEDDED;
8026 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8027 opts_type = OPTS_TYPE_PT_GENERATE_BE
8028 | OPTS_TYPE_PT_ADD80
8029 | OPTS_TYPE_PT_ADDBITS15
8030 | OPTS_TYPE_PT_UNICODE
8031 | OPTS_TYPE_ST_BASE64;
8032 kern_type = KERN_TYPE_SHA1_SLTPWU;
8033 dgst_size = DGST_SIZE_4_5;
8034 parse_func = episerver_parse_hash;
8035 sort_by_digest = sort_by_digest_4_5;
8036 opti_type = OPTI_TYPE_ZERO_BYTE
8037 | OPTI_TYPE_PRECOMPUTE_INIT
8038 | OPTI_TYPE_PRECOMPUTE_MERKLE
8039 | OPTI_TYPE_EARLY_SKIP
8040 | OPTI_TYPE_NOT_ITERATED
8041 | OPTI_TYPE_PREPENDED_SALT
8042 | OPTI_TYPE_RAW_HASH;
8043 dgst_pos0 = 3;
8044 dgst_pos1 = 4;
8045 dgst_pos2 = 2;
8046 dgst_pos3 = 1;
8047 break;
8048
8049 case 150: hash_type = HASH_TYPE_SHA1;
8050 salt_type = SALT_TYPE_INTERN;
8051 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8052 opts_type = OPTS_TYPE_PT_GENERATE_BE
8053 | OPTS_TYPE_ST_ADD80
8054 | OPTS_TYPE_ST_ADDBITS15;
8055 kern_type = KERN_TYPE_HMACSHA1_PW;
8056 dgst_size = DGST_SIZE_4_5;
8057 parse_func = hmacsha1_parse_hash;
8058 sort_by_digest = sort_by_digest_4_5;
8059 opti_type = OPTI_TYPE_ZERO_BYTE
8060 | OPTI_TYPE_NOT_ITERATED;
8061 dgst_pos0 = 3;
8062 dgst_pos1 = 4;
8063 dgst_pos2 = 2;
8064 dgst_pos3 = 1;
8065 break;
8066
8067 case 160: hash_type = HASH_TYPE_SHA1;
8068 salt_type = SALT_TYPE_INTERN;
8069 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8070 opts_type = OPTS_TYPE_PT_GENERATE_BE
8071 | OPTS_TYPE_PT_ADD80
8072 | OPTS_TYPE_PT_ADDBITS15;
8073 kern_type = KERN_TYPE_HMACSHA1_SLT;
8074 dgst_size = DGST_SIZE_4_5;
8075 parse_func = hmacsha1_parse_hash;
8076 sort_by_digest = sort_by_digest_4_5;
8077 opti_type = OPTI_TYPE_ZERO_BYTE
8078 | OPTI_TYPE_NOT_ITERATED;
8079 dgst_pos0 = 3;
8080 dgst_pos1 = 4;
8081 dgst_pos2 = 2;
8082 dgst_pos3 = 1;
8083 break;
8084
8085 case 190: hash_type = HASH_TYPE_SHA1;
8086 salt_type = SALT_TYPE_NONE;
8087 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8088 opts_type = OPTS_TYPE_PT_GENERATE_BE
8089 | OPTS_TYPE_PT_ADD80
8090 | OPTS_TYPE_PT_ADDBITS15;
8091 kern_type = KERN_TYPE_SHA1_LINKEDIN;
8092 dgst_size = DGST_SIZE_4_5;
8093 parse_func = sha1linkedin_parse_hash;
8094 sort_by_digest = sort_by_digest_4_5;
8095 opti_type = OPTI_TYPE_ZERO_BYTE
8096 | OPTI_TYPE_PRECOMPUTE_INIT
8097 | OPTI_TYPE_EARLY_SKIP
8098 | OPTI_TYPE_NOT_ITERATED
8099 | OPTI_TYPE_NOT_SALTED;
8100 dgst_pos0 = 0;
8101 dgst_pos1 = 4;
8102 dgst_pos2 = 3;
8103 dgst_pos3 = 2;
8104 break;
8105
8106 case 200: hash_type = HASH_TYPE_MYSQL;
8107 salt_type = SALT_TYPE_NONE;
8108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8109 opts_type = 0;
8110 kern_type = KERN_TYPE_MYSQL;
8111 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8112 parse_func = mysql323_parse_hash;
8113 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8114 opti_type = OPTI_TYPE_ZERO_BYTE;
8115 dgst_pos0 = 0;
8116 dgst_pos1 = 1;
8117 dgst_pos2 = 2;
8118 dgst_pos3 = 3;
8119 break;
8120
8121 case 300: hash_type = HASH_TYPE_SHA1;
8122 salt_type = SALT_TYPE_NONE;
8123 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8124 opts_type = OPTS_TYPE_PT_GENERATE_BE
8125 | OPTS_TYPE_PT_ADD80
8126 | OPTS_TYPE_PT_ADDBITS15;
8127 kern_type = KERN_TYPE_MYSQL41;
8128 dgst_size = DGST_SIZE_4_5;
8129 parse_func = sha1_parse_hash;
8130 sort_by_digest = sort_by_digest_4_5;
8131 opti_type = OPTI_TYPE_ZERO_BYTE
8132 | OPTI_TYPE_PRECOMPUTE_INIT
8133 | OPTI_TYPE_PRECOMPUTE_MERKLE
8134 | OPTI_TYPE_EARLY_SKIP
8135 | OPTI_TYPE_NOT_ITERATED
8136 | OPTI_TYPE_NOT_SALTED;
8137 dgst_pos0 = 3;
8138 dgst_pos1 = 4;
8139 dgst_pos2 = 2;
8140 dgst_pos3 = 1;
8141 break;
8142
8143 case 400: hash_type = HASH_TYPE_MD5;
8144 salt_type = SALT_TYPE_EMBEDDED;
8145 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8146 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8147 kern_type = KERN_TYPE_PHPASS;
8148 dgst_size = DGST_SIZE_4_4;
8149 parse_func = phpass_parse_hash;
8150 sort_by_digest = sort_by_digest_4_4;
8151 opti_type = OPTI_TYPE_ZERO_BYTE
8152 | OPTI_TYPE_SLOW_HASH_SIMD;
8153 dgst_pos0 = 0;
8154 dgst_pos1 = 1;
8155 dgst_pos2 = 2;
8156 dgst_pos3 = 3;
8157 break;
8158
8159 case 500: hash_type = HASH_TYPE_MD5;
8160 salt_type = SALT_TYPE_EMBEDDED;
8161 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8162 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8163 kern_type = KERN_TYPE_MD5CRYPT;
8164 dgst_size = DGST_SIZE_4_4;
8165 parse_func = md5crypt_parse_hash;
8166 sort_by_digest = sort_by_digest_4_4;
8167 opti_type = OPTI_TYPE_ZERO_BYTE;
8168 dgst_pos0 = 0;
8169 dgst_pos1 = 1;
8170 dgst_pos2 = 2;
8171 dgst_pos3 = 3;
8172 break;
8173
8174 case 501: hash_type = HASH_TYPE_MD5;
8175 salt_type = SALT_TYPE_EMBEDDED;
8176 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8177 opts_type = OPTS_TYPE_PT_GENERATE_LE
8178 | OPTS_TYPE_HASH_COPY;
8179 kern_type = KERN_TYPE_MD5CRYPT;
8180 dgst_size = DGST_SIZE_4_4;
8181 parse_func = juniper_parse_hash;
8182 sort_by_digest = sort_by_digest_4_4;
8183 opti_type = OPTI_TYPE_ZERO_BYTE;
8184 dgst_pos0 = 0;
8185 dgst_pos1 = 1;
8186 dgst_pos2 = 2;
8187 dgst_pos3 = 3;
8188 break;
8189
8190 case 900: hash_type = HASH_TYPE_MD4;
8191 salt_type = SALT_TYPE_NONE;
8192 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8193 opts_type = OPTS_TYPE_PT_GENERATE_LE
8194 | OPTS_TYPE_PT_ADD80
8195 | OPTS_TYPE_PT_ADDBITS14;
8196 kern_type = KERN_TYPE_MD4;
8197 dgst_size = DGST_SIZE_4_4;
8198 parse_func = md4_parse_hash;
8199 sort_by_digest = sort_by_digest_4_4;
8200 opti_type = OPTI_TYPE_ZERO_BYTE
8201 | OPTI_TYPE_PRECOMPUTE_INIT
8202 | OPTI_TYPE_PRECOMPUTE_MERKLE
8203 | OPTI_TYPE_MEET_IN_MIDDLE
8204 | OPTI_TYPE_EARLY_SKIP
8205 | OPTI_TYPE_NOT_ITERATED
8206 | OPTI_TYPE_NOT_SALTED
8207 | OPTI_TYPE_RAW_HASH;
8208 dgst_pos0 = 0;
8209 dgst_pos1 = 3;
8210 dgst_pos2 = 2;
8211 dgst_pos3 = 1;
8212 break;
8213
8214 case 1000: hash_type = HASH_TYPE_MD4;
8215 salt_type = SALT_TYPE_NONE;
8216 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8217 opts_type = OPTS_TYPE_PT_GENERATE_LE
8218 | OPTS_TYPE_PT_ADD80
8219 | OPTS_TYPE_PT_ADDBITS14
8220 | OPTS_TYPE_PT_UNICODE;
8221 kern_type = KERN_TYPE_MD4_PWU;
8222 dgst_size = DGST_SIZE_4_4;
8223 parse_func = md4_parse_hash;
8224 sort_by_digest = sort_by_digest_4_4;
8225 opti_type = OPTI_TYPE_ZERO_BYTE
8226 | OPTI_TYPE_PRECOMPUTE_INIT
8227 | OPTI_TYPE_PRECOMPUTE_MERKLE
8228 | OPTI_TYPE_MEET_IN_MIDDLE
8229 | OPTI_TYPE_EARLY_SKIP
8230 | OPTI_TYPE_NOT_ITERATED
8231 | OPTI_TYPE_NOT_SALTED
8232 | OPTI_TYPE_RAW_HASH;
8233 dgst_pos0 = 0;
8234 dgst_pos1 = 3;
8235 dgst_pos2 = 2;
8236 dgst_pos3 = 1;
8237 break;
8238
8239 case 1100: hash_type = HASH_TYPE_MD4;
8240 salt_type = SALT_TYPE_INTERN;
8241 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8242 opts_type = OPTS_TYPE_PT_GENERATE_LE
8243 | OPTS_TYPE_PT_ADD80
8244 | OPTS_TYPE_PT_ADDBITS14
8245 | OPTS_TYPE_PT_UNICODE
8246 | OPTS_TYPE_ST_ADD80
8247 | OPTS_TYPE_ST_UNICODE
8248 | OPTS_TYPE_ST_LOWER;
8249 kern_type = KERN_TYPE_MD44_PWUSLT;
8250 dgst_size = DGST_SIZE_4_4;
8251 parse_func = dcc_parse_hash;
8252 sort_by_digest = sort_by_digest_4_4;
8253 opti_type = OPTI_TYPE_ZERO_BYTE
8254 | OPTI_TYPE_PRECOMPUTE_INIT
8255 | OPTI_TYPE_PRECOMPUTE_MERKLE
8256 | OPTI_TYPE_EARLY_SKIP
8257 | OPTI_TYPE_NOT_ITERATED;
8258 dgst_pos0 = 0;
8259 dgst_pos1 = 3;
8260 dgst_pos2 = 2;
8261 dgst_pos3 = 1;
8262 break;
8263
8264 case 1400: hash_type = HASH_TYPE_SHA256;
8265 salt_type = SALT_TYPE_NONE;
8266 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8267 opts_type = OPTS_TYPE_PT_GENERATE_BE
8268 | OPTS_TYPE_PT_ADD80
8269 | OPTS_TYPE_PT_ADDBITS15;
8270 kern_type = KERN_TYPE_SHA256;
8271 dgst_size = DGST_SIZE_4_8;
8272 parse_func = sha256_parse_hash;
8273 sort_by_digest = sort_by_digest_4_8;
8274 opti_type = OPTI_TYPE_ZERO_BYTE
8275 | OPTI_TYPE_PRECOMPUTE_INIT
8276 | OPTI_TYPE_PRECOMPUTE_MERKLE
8277 | OPTI_TYPE_EARLY_SKIP
8278 | OPTI_TYPE_NOT_ITERATED
8279 | OPTI_TYPE_NOT_SALTED
8280 | OPTI_TYPE_RAW_HASH;
8281 dgst_pos0 = 3;
8282 dgst_pos1 = 7;
8283 dgst_pos2 = 2;
8284 dgst_pos3 = 6;
8285 break;
8286
8287 case 1410: hash_type = HASH_TYPE_SHA256;
8288 salt_type = SALT_TYPE_INTERN;
8289 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8290 opts_type = OPTS_TYPE_PT_GENERATE_BE
8291 | OPTS_TYPE_ST_ADD80
8292 | OPTS_TYPE_ST_ADDBITS15;
8293 kern_type = KERN_TYPE_SHA256_PWSLT;
8294 dgst_size = DGST_SIZE_4_8;
8295 parse_func = sha256s_parse_hash;
8296 sort_by_digest = sort_by_digest_4_8;
8297 opti_type = OPTI_TYPE_ZERO_BYTE
8298 | OPTI_TYPE_PRECOMPUTE_INIT
8299 | OPTI_TYPE_PRECOMPUTE_MERKLE
8300 | OPTI_TYPE_EARLY_SKIP
8301 | OPTI_TYPE_NOT_ITERATED
8302 | OPTI_TYPE_APPENDED_SALT
8303 | OPTI_TYPE_RAW_HASH;
8304 dgst_pos0 = 3;
8305 dgst_pos1 = 7;
8306 dgst_pos2 = 2;
8307 dgst_pos3 = 6;
8308 break;
8309
8310 case 1420: hash_type = HASH_TYPE_SHA256;
8311 salt_type = SALT_TYPE_INTERN;
8312 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8313 opts_type = OPTS_TYPE_PT_GENERATE_BE
8314 | OPTS_TYPE_PT_ADD80
8315 | OPTS_TYPE_PT_ADDBITS15;
8316 kern_type = KERN_TYPE_SHA256_SLTPW;
8317 dgst_size = DGST_SIZE_4_8;
8318 parse_func = sha256s_parse_hash;
8319 sort_by_digest = sort_by_digest_4_8;
8320 opti_type = OPTI_TYPE_ZERO_BYTE
8321 | OPTI_TYPE_PRECOMPUTE_INIT
8322 | OPTI_TYPE_PRECOMPUTE_MERKLE
8323 | OPTI_TYPE_EARLY_SKIP
8324 | OPTI_TYPE_NOT_ITERATED
8325 | OPTI_TYPE_PREPENDED_SALT
8326 | OPTI_TYPE_RAW_HASH;
8327 dgst_pos0 = 3;
8328 dgst_pos1 = 7;
8329 dgst_pos2 = 2;
8330 dgst_pos3 = 6;
8331 break;
8332
8333 case 1421: hash_type = HASH_TYPE_SHA256;
8334 salt_type = SALT_TYPE_EMBEDDED;
8335 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8336 opts_type = OPTS_TYPE_PT_GENERATE_BE
8337 | OPTS_TYPE_PT_ADD80
8338 | OPTS_TYPE_PT_ADDBITS15;
8339 kern_type = KERN_TYPE_SHA256_SLTPW;
8340 dgst_size = DGST_SIZE_4_8;
8341 parse_func = hmailserver_parse_hash;
8342 sort_by_digest = sort_by_digest_4_8;
8343 opti_type = OPTI_TYPE_ZERO_BYTE
8344 | OPTI_TYPE_PRECOMPUTE_INIT
8345 | OPTI_TYPE_PRECOMPUTE_MERKLE
8346 | OPTI_TYPE_EARLY_SKIP
8347 | OPTI_TYPE_NOT_ITERATED
8348 | OPTI_TYPE_PREPENDED_SALT
8349 | OPTI_TYPE_RAW_HASH;
8350 dgst_pos0 = 3;
8351 dgst_pos1 = 7;
8352 dgst_pos2 = 2;
8353 dgst_pos3 = 6;
8354 break;
8355
8356 case 1430: hash_type = HASH_TYPE_SHA256;
8357 salt_type = SALT_TYPE_INTERN;
8358 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8359 opts_type = OPTS_TYPE_PT_GENERATE_BE
8360 | OPTS_TYPE_PT_UNICODE
8361 | OPTS_TYPE_ST_ADD80
8362 | OPTS_TYPE_ST_ADDBITS15;
8363 kern_type = KERN_TYPE_SHA256_PWUSLT;
8364 dgst_size = DGST_SIZE_4_8;
8365 parse_func = sha256s_parse_hash;
8366 sort_by_digest = sort_by_digest_4_8;
8367 opti_type = OPTI_TYPE_ZERO_BYTE
8368 | OPTI_TYPE_PRECOMPUTE_INIT
8369 | OPTI_TYPE_PRECOMPUTE_MERKLE
8370 | OPTI_TYPE_EARLY_SKIP
8371 | OPTI_TYPE_NOT_ITERATED
8372 | OPTI_TYPE_APPENDED_SALT
8373 | OPTI_TYPE_RAW_HASH;
8374 dgst_pos0 = 3;
8375 dgst_pos1 = 7;
8376 dgst_pos2 = 2;
8377 dgst_pos3 = 6;
8378 break;
8379
8380 case 1440: hash_type = HASH_TYPE_SHA256;
8381 salt_type = SALT_TYPE_INTERN;
8382 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8383 opts_type = OPTS_TYPE_PT_GENERATE_BE
8384 | OPTS_TYPE_PT_ADD80
8385 | OPTS_TYPE_PT_ADDBITS15
8386 | OPTS_TYPE_PT_UNICODE;
8387 kern_type = KERN_TYPE_SHA256_SLTPWU;
8388 dgst_size = DGST_SIZE_4_8;
8389 parse_func = sha256s_parse_hash;
8390 sort_by_digest = sort_by_digest_4_8;
8391 opti_type = OPTI_TYPE_ZERO_BYTE
8392 | OPTI_TYPE_PRECOMPUTE_INIT
8393 | OPTI_TYPE_PRECOMPUTE_MERKLE
8394 | OPTI_TYPE_EARLY_SKIP
8395 | OPTI_TYPE_NOT_ITERATED
8396 | OPTI_TYPE_PREPENDED_SALT
8397 | OPTI_TYPE_RAW_HASH;
8398 dgst_pos0 = 3;
8399 dgst_pos1 = 7;
8400 dgst_pos2 = 2;
8401 dgst_pos3 = 6;
8402 break;
8403
8404 case 1441: hash_type = HASH_TYPE_SHA256;
8405 salt_type = SALT_TYPE_EMBEDDED;
8406 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8407 opts_type = OPTS_TYPE_PT_GENERATE_BE
8408 | OPTS_TYPE_PT_ADD80
8409 | OPTS_TYPE_PT_ADDBITS15
8410 | OPTS_TYPE_PT_UNICODE
8411 | OPTS_TYPE_ST_BASE64;
8412 kern_type = KERN_TYPE_SHA256_SLTPWU;
8413 dgst_size = DGST_SIZE_4_8;
8414 parse_func = episerver4_parse_hash;
8415 sort_by_digest = sort_by_digest_4_8;
8416 opti_type = OPTI_TYPE_ZERO_BYTE
8417 | OPTI_TYPE_PRECOMPUTE_INIT
8418 | OPTI_TYPE_PRECOMPUTE_MERKLE
8419 | OPTI_TYPE_EARLY_SKIP
8420 | OPTI_TYPE_NOT_ITERATED
8421 | OPTI_TYPE_PREPENDED_SALT
8422 | OPTI_TYPE_RAW_HASH;
8423 dgst_pos0 = 3;
8424 dgst_pos1 = 7;
8425 dgst_pos2 = 2;
8426 dgst_pos3 = 6;
8427 break;
8428
8429 case 1450: hash_type = HASH_TYPE_SHA256;
8430 salt_type = SALT_TYPE_INTERN;
8431 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8432 opts_type = OPTS_TYPE_PT_GENERATE_BE
8433 | OPTS_TYPE_ST_ADD80;
8434 kern_type = KERN_TYPE_HMACSHA256_PW;
8435 dgst_size = DGST_SIZE_4_8;
8436 parse_func = hmacsha256_parse_hash;
8437 sort_by_digest = sort_by_digest_4_8;
8438 opti_type = OPTI_TYPE_ZERO_BYTE
8439 | OPTI_TYPE_NOT_ITERATED;
8440 dgst_pos0 = 3;
8441 dgst_pos1 = 7;
8442 dgst_pos2 = 2;
8443 dgst_pos3 = 6;
8444 break;
8445
8446 case 1460: hash_type = HASH_TYPE_SHA256;
8447 salt_type = SALT_TYPE_INTERN;
8448 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8449 opts_type = OPTS_TYPE_PT_GENERATE_BE
8450 | OPTS_TYPE_PT_ADD80
8451 | OPTS_TYPE_PT_ADDBITS15;
8452 kern_type = KERN_TYPE_HMACSHA256_SLT;
8453 dgst_size = DGST_SIZE_4_8;
8454 parse_func = hmacsha256_parse_hash;
8455 sort_by_digest = sort_by_digest_4_8;
8456 opti_type = OPTI_TYPE_ZERO_BYTE
8457 | OPTI_TYPE_NOT_ITERATED;
8458 dgst_pos0 = 3;
8459 dgst_pos1 = 7;
8460 dgst_pos2 = 2;
8461 dgst_pos3 = 6;
8462 break;
8463
8464 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8465 salt_type = SALT_TYPE_EMBEDDED;
8466 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8467 opts_type = OPTS_TYPE_PT_GENERATE_LE
8468 | OPTS_TYPE_PT_BITSLICE;
8469 kern_type = KERN_TYPE_DESCRYPT;
8470 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8471 parse_func = descrypt_parse_hash;
8472 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8473 opti_type = OPTI_TYPE_ZERO_BYTE
8474 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8475 dgst_pos0 = 0;
8476 dgst_pos1 = 1;
8477 dgst_pos2 = 2;
8478 dgst_pos3 = 3;
8479 break;
8480
8481 case 1600: hash_type = HASH_TYPE_MD5;
8482 salt_type = SALT_TYPE_EMBEDDED;
8483 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8484 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8485 kern_type = KERN_TYPE_APR1CRYPT;
8486 dgst_size = DGST_SIZE_4_4;
8487 parse_func = md5apr1_parse_hash;
8488 sort_by_digest = sort_by_digest_4_4;
8489 opti_type = OPTI_TYPE_ZERO_BYTE;
8490 dgst_pos0 = 0;
8491 dgst_pos1 = 1;
8492 dgst_pos2 = 2;
8493 dgst_pos3 = 3;
8494 break;
8495
8496 case 1700: hash_type = HASH_TYPE_SHA512;
8497 salt_type = SALT_TYPE_NONE;
8498 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8499 opts_type = OPTS_TYPE_PT_GENERATE_BE
8500 | OPTS_TYPE_PT_ADD80
8501 | OPTS_TYPE_PT_ADDBITS15;
8502 kern_type = KERN_TYPE_SHA512;
8503 dgst_size = DGST_SIZE_8_8;
8504 parse_func = sha512_parse_hash;
8505 sort_by_digest = sort_by_digest_8_8;
8506 opti_type = OPTI_TYPE_ZERO_BYTE
8507 | OPTI_TYPE_PRECOMPUTE_INIT
8508 | OPTI_TYPE_PRECOMPUTE_MERKLE
8509 | OPTI_TYPE_EARLY_SKIP
8510 | OPTI_TYPE_NOT_ITERATED
8511 | OPTI_TYPE_NOT_SALTED
8512 | OPTI_TYPE_USES_BITS_64
8513 | OPTI_TYPE_RAW_HASH;
8514 dgst_pos0 = 14;
8515 dgst_pos1 = 15;
8516 dgst_pos2 = 6;
8517 dgst_pos3 = 7;
8518 break;
8519
8520 case 1710: hash_type = HASH_TYPE_SHA512;
8521 salt_type = SALT_TYPE_INTERN;
8522 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8523 opts_type = OPTS_TYPE_PT_GENERATE_BE
8524 | OPTS_TYPE_ST_ADD80
8525 | OPTS_TYPE_ST_ADDBITS15;
8526 kern_type = KERN_TYPE_SHA512_PWSLT;
8527 dgst_size = DGST_SIZE_8_8;
8528 parse_func = sha512s_parse_hash;
8529 sort_by_digest = sort_by_digest_8_8;
8530 opti_type = OPTI_TYPE_ZERO_BYTE
8531 | OPTI_TYPE_PRECOMPUTE_INIT
8532 | OPTI_TYPE_PRECOMPUTE_MERKLE
8533 | OPTI_TYPE_EARLY_SKIP
8534 | OPTI_TYPE_NOT_ITERATED
8535 | OPTI_TYPE_APPENDED_SALT
8536 | OPTI_TYPE_USES_BITS_64
8537 | OPTI_TYPE_RAW_HASH;
8538 dgst_pos0 = 14;
8539 dgst_pos1 = 15;
8540 dgst_pos2 = 6;
8541 dgst_pos3 = 7;
8542 break;
8543
8544 case 1711: hash_type = HASH_TYPE_SHA512;
8545 salt_type = SALT_TYPE_EMBEDDED;
8546 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8547 opts_type = OPTS_TYPE_PT_GENERATE_BE
8548 | OPTS_TYPE_ST_ADD80
8549 | OPTS_TYPE_ST_ADDBITS15;
8550 kern_type = KERN_TYPE_SHA512_PWSLT;
8551 dgst_size = DGST_SIZE_8_8;
8552 parse_func = sha512b64s_parse_hash;
8553 sort_by_digest = sort_by_digest_8_8;
8554 opti_type = OPTI_TYPE_ZERO_BYTE
8555 | OPTI_TYPE_PRECOMPUTE_INIT
8556 | OPTI_TYPE_PRECOMPUTE_MERKLE
8557 | OPTI_TYPE_EARLY_SKIP
8558 | OPTI_TYPE_NOT_ITERATED
8559 | OPTI_TYPE_APPENDED_SALT
8560 | OPTI_TYPE_USES_BITS_64
8561 | OPTI_TYPE_RAW_HASH;
8562 dgst_pos0 = 14;
8563 dgst_pos1 = 15;
8564 dgst_pos2 = 6;
8565 dgst_pos3 = 7;
8566 break;
8567
8568 case 1720: hash_type = HASH_TYPE_SHA512;
8569 salt_type = SALT_TYPE_INTERN;
8570 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8571 opts_type = OPTS_TYPE_PT_GENERATE_BE
8572 | OPTS_TYPE_PT_ADD80
8573 | OPTS_TYPE_PT_ADDBITS15;
8574 kern_type = KERN_TYPE_SHA512_SLTPW;
8575 dgst_size = DGST_SIZE_8_8;
8576 parse_func = sha512s_parse_hash;
8577 sort_by_digest = sort_by_digest_8_8;
8578 opti_type = OPTI_TYPE_ZERO_BYTE
8579 | OPTI_TYPE_PRECOMPUTE_INIT
8580 | OPTI_TYPE_PRECOMPUTE_MERKLE
8581 | OPTI_TYPE_EARLY_SKIP
8582 | OPTI_TYPE_NOT_ITERATED
8583 | OPTI_TYPE_PREPENDED_SALT
8584 | OPTI_TYPE_USES_BITS_64
8585 | OPTI_TYPE_RAW_HASH;
8586 dgst_pos0 = 14;
8587 dgst_pos1 = 15;
8588 dgst_pos2 = 6;
8589 dgst_pos3 = 7;
8590 break;
8591
8592 case 1722: hash_type = HASH_TYPE_SHA512;
8593 salt_type = SALT_TYPE_EMBEDDED;
8594 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8595 opts_type = OPTS_TYPE_PT_GENERATE_BE
8596 | OPTS_TYPE_PT_ADD80
8597 | OPTS_TYPE_PT_ADDBITS15
8598 | OPTS_TYPE_ST_HEX;
8599 kern_type = KERN_TYPE_SHA512_SLTPW;
8600 dgst_size = DGST_SIZE_8_8;
8601 parse_func = osx512_parse_hash;
8602 sort_by_digest = sort_by_digest_8_8;
8603 opti_type = OPTI_TYPE_ZERO_BYTE
8604 | OPTI_TYPE_PRECOMPUTE_INIT
8605 | OPTI_TYPE_PRECOMPUTE_MERKLE
8606 | OPTI_TYPE_EARLY_SKIP
8607 | OPTI_TYPE_NOT_ITERATED
8608 | OPTI_TYPE_PREPENDED_SALT
8609 | OPTI_TYPE_USES_BITS_64
8610 | OPTI_TYPE_RAW_HASH;
8611 dgst_pos0 = 14;
8612 dgst_pos1 = 15;
8613 dgst_pos2 = 6;
8614 dgst_pos3 = 7;
8615 break;
8616
8617 case 1730: hash_type = HASH_TYPE_SHA512;
8618 salt_type = SALT_TYPE_INTERN;
8619 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8620 opts_type = OPTS_TYPE_PT_GENERATE_BE
8621 | OPTS_TYPE_PT_UNICODE
8622 | OPTS_TYPE_ST_ADD80
8623 | OPTS_TYPE_ST_ADDBITS15;
8624 kern_type = KERN_TYPE_SHA512_PWSLTU;
8625 dgst_size = DGST_SIZE_8_8;
8626 parse_func = sha512s_parse_hash;
8627 sort_by_digest = sort_by_digest_8_8;
8628 opti_type = OPTI_TYPE_ZERO_BYTE
8629 | OPTI_TYPE_PRECOMPUTE_INIT
8630 | OPTI_TYPE_PRECOMPUTE_MERKLE
8631 | OPTI_TYPE_EARLY_SKIP
8632 | OPTI_TYPE_NOT_ITERATED
8633 | OPTI_TYPE_APPENDED_SALT
8634 | OPTI_TYPE_USES_BITS_64
8635 | OPTI_TYPE_RAW_HASH;
8636 dgst_pos0 = 14;
8637 dgst_pos1 = 15;
8638 dgst_pos2 = 6;
8639 dgst_pos3 = 7;
8640 break;
8641
8642 case 1731: hash_type = HASH_TYPE_SHA512;
8643 salt_type = SALT_TYPE_EMBEDDED;
8644 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8645 opts_type = OPTS_TYPE_PT_GENERATE_BE
8646 | OPTS_TYPE_PT_UNICODE
8647 | OPTS_TYPE_ST_ADD80
8648 | OPTS_TYPE_ST_ADDBITS15
8649 | OPTS_TYPE_ST_HEX;
8650 kern_type = KERN_TYPE_SHA512_PWSLTU;
8651 dgst_size = DGST_SIZE_8_8;
8652 parse_func = mssql2012_parse_hash;
8653 sort_by_digest = sort_by_digest_8_8;
8654 opti_type = OPTI_TYPE_ZERO_BYTE
8655 | OPTI_TYPE_PRECOMPUTE_INIT
8656 | OPTI_TYPE_PRECOMPUTE_MERKLE
8657 | OPTI_TYPE_EARLY_SKIP
8658 | OPTI_TYPE_NOT_ITERATED
8659 | OPTI_TYPE_APPENDED_SALT
8660 | OPTI_TYPE_USES_BITS_64
8661 | OPTI_TYPE_RAW_HASH;
8662 dgst_pos0 = 14;
8663 dgst_pos1 = 15;
8664 dgst_pos2 = 6;
8665 dgst_pos3 = 7;
8666 break;
8667
8668 case 1740: hash_type = HASH_TYPE_SHA512;
8669 salt_type = SALT_TYPE_INTERN;
8670 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8671 opts_type = OPTS_TYPE_PT_GENERATE_BE
8672 | OPTS_TYPE_PT_ADD80
8673 | OPTS_TYPE_PT_ADDBITS15
8674 | OPTS_TYPE_PT_UNICODE;
8675 kern_type = KERN_TYPE_SHA512_SLTPWU;
8676 dgst_size = DGST_SIZE_8_8;
8677 parse_func = sha512s_parse_hash;
8678 sort_by_digest = sort_by_digest_8_8;
8679 opti_type = OPTI_TYPE_ZERO_BYTE
8680 | OPTI_TYPE_PRECOMPUTE_INIT
8681 | OPTI_TYPE_PRECOMPUTE_MERKLE
8682 | OPTI_TYPE_EARLY_SKIP
8683 | OPTI_TYPE_NOT_ITERATED
8684 | OPTI_TYPE_PREPENDED_SALT
8685 | OPTI_TYPE_USES_BITS_64
8686 | OPTI_TYPE_RAW_HASH;
8687 dgst_pos0 = 14;
8688 dgst_pos1 = 15;
8689 dgst_pos2 = 6;
8690 dgst_pos3 = 7;
8691 break;
8692
8693 case 1750: hash_type = HASH_TYPE_SHA512;
8694 salt_type = SALT_TYPE_INTERN;
8695 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8696 opts_type = OPTS_TYPE_PT_GENERATE_BE
8697 | OPTS_TYPE_ST_ADD80;
8698 kern_type = KERN_TYPE_HMACSHA512_PW;
8699 dgst_size = DGST_SIZE_8_8;
8700 parse_func = hmacsha512_parse_hash;
8701 sort_by_digest = sort_by_digest_8_8;
8702 opti_type = OPTI_TYPE_ZERO_BYTE
8703 | OPTI_TYPE_USES_BITS_64
8704 | OPTI_TYPE_NOT_ITERATED;
8705 dgst_pos0 = 14;
8706 dgst_pos1 = 15;
8707 dgst_pos2 = 6;
8708 dgst_pos3 = 7;
8709 break;
8710
8711 case 1760: hash_type = HASH_TYPE_SHA512;
8712 salt_type = SALT_TYPE_INTERN;
8713 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8714 opts_type = OPTS_TYPE_PT_GENERATE_BE
8715 | OPTS_TYPE_PT_ADD80
8716 | OPTS_TYPE_PT_ADDBITS15;
8717 kern_type = KERN_TYPE_HMACSHA512_SLT;
8718 dgst_size = DGST_SIZE_8_8;
8719 parse_func = hmacsha512_parse_hash;
8720 sort_by_digest = sort_by_digest_8_8;
8721 opti_type = OPTI_TYPE_ZERO_BYTE
8722 | OPTI_TYPE_USES_BITS_64
8723 | OPTI_TYPE_NOT_ITERATED;
8724 dgst_pos0 = 14;
8725 dgst_pos1 = 15;
8726 dgst_pos2 = 6;
8727 dgst_pos3 = 7;
8728 break;
8729
8730 case 1800: hash_type = HASH_TYPE_SHA512;
8731 salt_type = SALT_TYPE_EMBEDDED;
8732 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8733 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8734 kern_type = KERN_TYPE_SHA512CRYPT;
8735 dgst_size = DGST_SIZE_8_8;
8736 parse_func = sha512crypt_parse_hash;
8737 sort_by_digest = sort_by_digest_8_8;
8738 opti_type = OPTI_TYPE_ZERO_BYTE
8739 | OPTI_TYPE_USES_BITS_64;
8740 dgst_pos0 = 0;
8741 dgst_pos1 = 1;
8742 dgst_pos2 = 2;
8743 dgst_pos3 = 3;
8744 break;
8745
8746 case 2000: hash_type = HASH_TYPE_STDOUT;
8747 salt_type = SALT_TYPE_NONE;
8748 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8749 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8750 kern_type = KERN_TYPE_STDOUT;
8751 dgst_size = DGST_SIZE_4_4;
8752 parse_func = NULL;
8753 sort_by_digest = NULL;
8754 opti_type = 0;
8755 dgst_pos0 = 0;
8756 dgst_pos1 = 0;
8757 dgst_pos2 = 0;
8758 dgst_pos3 = 0;
8759 break;
8760
8761 case 2100: hash_type = HASH_TYPE_DCC2;
8762 salt_type = SALT_TYPE_EMBEDDED;
8763 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8764 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8765 | OPTS_TYPE_ST_LOWER
8766 | OPTS_TYPE_ST_UNICODE;
8767 kern_type = KERN_TYPE_DCC2;
8768 dgst_size = DGST_SIZE_4_4;
8769 parse_func = dcc2_parse_hash;
8770 sort_by_digest = sort_by_digest_4_4;
8771 opti_type = OPTI_TYPE_ZERO_BYTE
8772 | OPTI_TYPE_SLOW_HASH_SIMD;
8773 dgst_pos0 = 0;
8774 dgst_pos1 = 1;
8775 dgst_pos2 = 2;
8776 dgst_pos3 = 3;
8777 break;
8778
8779 case 2400: hash_type = HASH_TYPE_MD5;
8780 salt_type = SALT_TYPE_NONE;
8781 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8782 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8783 kern_type = KERN_TYPE_MD5PIX;
8784 dgst_size = DGST_SIZE_4_4;
8785 parse_func = md5pix_parse_hash;
8786 sort_by_digest = sort_by_digest_4_4;
8787 opti_type = OPTI_TYPE_ZERO_BYTE
8788 | OPTI_TYPE_PRECOMPUTE_INIT
8789 | OPTI_TYPE_PRECOMPUTE_MERKLE
8790 | OPTI_TYPE_EARLY_SKIP
8791 | OPTI_TYPE_NOT_ITERATED
8792 | OPTI_TYPE_NOT_SALTED;
8793 dgst_pos0 = 0;
8794 dgst_pos1 = 3;
8795 dgst_pos2 = 2;
8796 dgst_pos3 = 1;
8797 break;
8798
8799 case 2410: hash_type = HASH_TYPE_MD5;
8800 salt_type = SALT_TYPE_INTERN;
8801 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8802 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8803 kern_type = KERN_TYPE_MD5ASA;
8804 dgst_size = DGST_SIZE_4_4;
8805 parse_func = md5asa_parse_hash;
8806 sort_by_digest = sort_by_digest_4_4;
8807 opti_type = OPTI_TYPE_ZERO_BYTE
8808 | OPTI_TYPE_PRECOMPUTE_INIT
8809 | OPTI_TYPE_PRECOMPUTE_MERKLE
8810 | OPTI_TYPE_EARLY_SKIP
8811 | OPTI_TYPE_NOT_ITERATED;
8812 dgst_pos0 = 0;
8813 dgst_pos1 = 3;
8814 dgst_pos2 = 2;
8815 dgst_pos3 = 1;
8816 break;
8817
8818 case 2500: hash_type = HASH_TYPE_WPA;
8819 salt_type = SALT_TYPE_EMBEDDED;
8820 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8821 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8822 kern_type = KERN_TYPE_WPA;
8823 dgst_size = DGST_SIZE_4_4;
8824 parse_func = wpa_parse_hash;
8825 sort_by_digest = sort_by_digest_4_4;
8826 opti_type = OPTI_TYPE_ZERO_BYTE
8827 | OPTI_TYPE_SLOW_HASH_SIMD;
8828 dgst_pos0 = 0;
8829 dgst_pos1 = 1;
8830 dgst_pos2 = 2;
8831 dgst_pos3 = 3;
8832 break;
8833
8834 case 2600: hash_type = HASH_TYPE_MD5;
8835 salt_type = SALT_TYPE_VIRTUAL;
8836 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8837 opts_type = OPTS_TYPE_PT_GENERATE_LE
8838 | OPTS_TYPE_PT_ADD80
8839 | OPTS_TYPE_PT_ADDBITS14
8840 | OPTS_TYPE_ST_ADD80;
8841 kern_type = KERN_TYPE_MD55_PWSLT1;
8842 dgst_size = DGST_SIZE_4_4;
8843 parse_func = md5md5_parse_hash;
8844 sort_by_digest = sort_by_digest_4_4;
8845 opti_type = OPTI_TYPE_ZERO_BYTE
8846 | OPTI_TYPE_PRECOMPUTE_INIT
8847 | OPTI_TYPE_PRECOMPUTE_MERKLE
8848 | OPTI_TYPE_EARLY_SKIP;
8849 dgst_pos0 = 0;
8850 dgst_pos1 = 3;
8851 dgst_pos2 = 2;
8852 dgst_pos3 = 1;
8853 break;
8854
8855 case 2611: hash_type = HASH_TYPE_MD5;
8856 salt_type = SALT_TYPE_INTERN;
8857 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8858 opts_type = OPTS_TYPE_PT_GENERATE_LE
8859 | OPTS_TYPE_PT_ADD80
8860 | OPTS_TYPE_PT_ADDBITS14
8861 | OPTS_TYPE_ST_ADD80;
8862 kern_type = KERN_TYPE_MD55_PWSLT1;
8863 dgst_size = DGST_SIZE_4_4;
8864 parse_func = vb3_parse_hash;
8865 sort_by_digest = sort_by_digest_4_4;
8866 opti_type = OPTI_TYPE_ZERO_BYTE
8867 | OPTI_TYPE_PRECOMPUTE_INIT
8868 | OPTI_TYPE_PRECOMPUTE_MERKLE
8869 | OPTI_TYPE_EARLY_SKIP;
8870 dgst_pos0 = 0;
8871 dgst_pos1 = 3;
8872 dgst_pos2 = 2;
8873 dgst_pos3 = 1;
8874 break;
8875
8876 case 2612: hash_type = HASH_TYPE_MD5;
8877 salt_type = SALT_TYPE_EMBEDDED;
8878 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8879 opts_type = OPTS_TYPE_PT_GENERATE_LE
8880 | OPTS_TYPE_PT_ADD80
8881 | OPTS_TYPE_PT_ADDBITS14
8882 | OPTS_TYPE_ST_ADD80
8883 | OPTS_TYPE_ST_HEX;
8884 kern_type = KERN_TYPE_MD55_PWSLT1;
8885 dgst_size = DGST_SIZE_4_4;
8886 parse_func = phps_parse_hash;
8887 sort_by_digest = sort_by_digest_4_4;
8888 opti_type = OPTI_TYPE_ZERO_BYTE
8889 | OPTI_TYPE_PRECOMPUTE_INIT
8890 | OPTI_TYPE_PRECOMPUTE_MERKLE
8891 | OPTI_TYPE_EARLY_SKIP;
8892 dgst_pos0 = 0;
8893 dgst_pos1 = 3;
8894 dgst_pos2 = 2;
8895 dgst_pos3 = 1;
8896 break;
8897
8898 case 2711: hash_type = HASH_TYPE_MD5;
8899 salt_type = SALT_TYPE_INTERN;
8900 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8901 opts_type = OPTS_TYPE_PT_GENERATE_LE
8902 | OPTS_TYPE_PT_ADD80
8903 | OPTS_TYPE_PT_ADDBITS14
8904 | OPTS_TYPE_ST_ADD80;
8905 kern_type = KERN_TYPE_MD55_PWSLT2;
8906 dgst_size = DGST_SIZE_4_4;
8907 parse_func = vb30_parse_hash;
8908 sort_by_digest = sort_by_digest_4_4;
8909 opti_type = OPTI_TYPE_ZERO_BYTE
8910 | OPTI_TYPE_PRECOMPUTE_INIT
8911 | OPTI_TYPE_EARLY_SKIP;
8912 dgst_pos0 = 0;
8913 dgst_pos1 = 3;
8914 dgst_pos2 = 2;
8915 dgst_pos3 = 1;
8916 break;
8917
8918 case 2811: hash_type = HASH_TYPE_MD5;
8919 salt_type = SALT_TYPE_INTERN;
8920 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8921 opts_type = OPTS_TYPE_PT_GENERATE_LE
8922 | OPTS_TYPE_PT_ADD80
8923 | OPTS_TYPE_PT_ADDBITS14;
8924 kern_type = KERN_TYPE_MD55_SLTPW;
8925 dgst_size = DGST_SIZE_4_4;
8926 parse_func = ipb2_parse_hash;
8927 sort_by_digest = sort_by_digest_4_4;
8928 opti_type = OPTI_TYPE_ZERO_BYTE
8929 | OPTI_TYPE_PRECOMPUTE_INIT
8930 | OPTI_TYPE_EARLY_SKIP;
8931 dgst_pos0 = 0;
8932 dgst_pos1 = 3;
8933 dgst_pos2 = 2;
8934 dgst_pos3 = 1;
8935 break;
8936
8937 case 3000: hash_type = HASH_TYPE_LM;
8938 salt_type = SALT_TYPE_NONE;
8939 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8940 opts_type = OPTS_TYPE_PT_GENERATE_LE
8941 | OPTS_TYPE_PT_UPPER
8942 | OPTS_TYPE_PT_BITSLICE;
8943 kern_type = KERN_TYPE_LM;
8944 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8945 parse_func = lm_parse_hash;
8946 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8947 opti_type = OPTI_TYPE_ZERO_BYTE
8948 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8949 dgst_pos0 = 0;
8950 dgst_pos1 = 1;
8951 dgst_pos2 = 2;
8952 dgst_pos3 = 3;
8953 break;
8954
8955 case 3100: hash_type = HASH_TYPE_ORACLEH;
8956 salt_type = SALT_TYPE_INTERN;
8957 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8958 opts_type = OPTS_TYPE_PT_GENERATE_LE
8959 | OPTS_TYPE_PT_UPPER
8960 | OPTS_TYPE_ST_UPPER;
8961 kern_type = KERN_TYPE_ORACLEH;
8962 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8963 parse_func = oracleh_parse_hash;
8964 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8965 opti_type = OPTI_TYPE_ZERO_BYTE;
8966 dgst_pos0 = 0;
8967 dgst_pos1 = 1;
8968 dgst_pos2 = 2;
8969 dgst_pos3 = 3;
8970 break;
8971
8972 case 3200: hash_type = HASH_TYPE_BCRYPT;
8973 salt_type = SALT_TYPE_EMBEDDED;
8974 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8975 opts_type = OPTS_TYPE_PT_GENERATE_LE
8976 | OPTS_TYPE_ST_GENERATE_LE;
8977 kern_type = KERN_TYPE_BCRYPT;
8978 dgst_size = DGST_SIZE_4_6;
8979 parse_func = bcrypt_parse_hash;
8980 sort_by_digest = sort_by_digest_4_6;
8981 opti_type = OPTI_TYPE_ZERO_BYTE;
8982 dgst_pos0 = 0;
8983 dgst_pos1 = 1;
8984 dgst_pos2 = 2;
8985 dgst_pos3 = 3;
8986 break;
8987
8988 case 3710: hash_type = HASH_TYPE_MD5;
8989 salt_type = SALT_TYPE_INTERN;
8990 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8991 opts_type = OPTS_TYPE_PT_GENERATE_LE
8992 | OPTS_TYPE_PT_ADD80
8993 | OPTS_TYPE_PT_ADDBITS14;
8994 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8995 dgst_size = DGST_SIZE_4_4;
8996 parse_func = md5s_parse_hash;
8997 sort_by_digest = sort_by_digest_4_4;
8998 opti_type = OPTI_TYPE_ZERO_BYTE
8999 | OPTI_TYPE_PRECOMPUTE_INIT
9000 | OPTI_TYPE_PRECOMPUTE_MERKLE
9001 | OPTI_TYPE_EARLY_SKIP;
9002 dgst_pos0 = 0;
9003 dgst_pos1 = 3;
9004 dgst_pos2 = 2;
9005 dgst_pos3 = 1;
9006 break;
9007
9008 case 3711: hash_type = HASH_TYPE_MD5;
9009 salt_type = SALT_TYPE_EMBEDDED;
9010 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9011 opts_type = OPTS_TYPE_PT_GENERATE_LE
9012 | OPTS_TYPE_PT_ADD80
9013 | OPTS_TYPE_PT_ADDBITS14;
9014 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9015 dgst_size = DGST_SIZE_4_4;
9016 parse_func = mediawiki_b_parse_hash;
9017 sort_by_digest = sort_by_digest_4_4;
9018 opti_type = OPTI_TYPE_ZERO_BYTE
9019 | OPTI_TYPE_PRECOMPUTE_INIT
9020 | OPTI_TYPE_PRECOMPUTE_MERKLE
9021 | OPTI_TYPE_EARLY_SKIP;
9022 dgst_pos0 = 0;
9023 dgst_pos1 = 3;
9024 dgst_pos2 = 2;
9025 dgst_pos3 = 1;
9026 break;
9027
9028 case 3800: hash_type = HASH_TYPE_MD5;
9029 salt_type = SALT_TYPE_INTERN;
9030 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9031 opts_type = OPTS_TYPE_PT_GENERATE_LE
9032 | OPTS_TYPE_ST_ADDBITS14;
9033 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
9034 dgst_size = DGST_SIZE_4_4;
9035 parse_func = md5s_parse_hash;
9036 sort_by_digest = sort_by_digest_4_4;
9037 opti_type = OPTI_TYPE_ZERO_BYTE
9038 | OPTI_TYPE_PRECOMPUTE_INIT
9039 | OPTI_TYPE_PRECOMPUTE_MERKLE
9040 | OPTI_TYPE_EARLY_SKIP
9041 | OPTI_TYPE_NOT_ITERATED
9042 | OPTI_TYPE_RAW_HASH;
9043 dgst_pos0 = 0;
9044 dgst_pos1 = 3;
9045 dgst_pos2 = 2;
9046 dgst_pos3 = 1;
9047 break;
9048
9049 case 4300: hash_type = HASH_TYPE_MD5;
9050 salt_type = SALT_TYPE_VIRTUAL;
9051 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9052 opts_type = OPTS_TYPE_PT_GENERATE_LE
9053 | OPTS_TYPE_PT_ADD80
9054 | OPTS_TYPE_PT_ADDBITS14
9055 | OPTS_TYPE_ST_ADD80;
9056 kern_type = KERN_TYPE_MD5U5_PWSLT1;
9057 dgst_size = DGST_SIZE_4_4;
9058 parse_func = md5md5_parse_hash;
9059 sort_by_digest = sort_by_digest_4_4;
9060 opti_type = OPTI_TYPE_ZERO_BYTE
9061 | OPTI_TYPE_PRECOMPUTE_INIT
9062 | OPTI_TYPE_PRECOMPUTE_MERKLE
9063 | OPTI_TYPE_EARLY_SKIP;
9064 dgst_pos0 = 0;
9065 dgst_pos1 = 3;
9066 dgst_pos2 = 2;
9067 dgst_pos3 = 1;
9068 break;
9069
9070
9071 case 4400: hash_type = HASH_TYPE_MD5;
9072 salt_type = SALT_TYPE_NONE;
9073 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9074 opts_type = OPTS_TYPE_PT_GENERATE_BE
9075 | OPTS_TYPE_PT_ADD80
9076 | OPTS_TYPE_PT_ADDBITS15;
9077 kern_type = KERN_TYPE_MD5_SHA1;
9078 dgst_size = DGST_SIZE_4_4;
9079 parse_func = md5_parse_hash;
9080 sort_by_digest = sort_by_digest_4_4;
9081 opti_type = OPTI_TYPE_ZERO_BYTE
9082 | OPTI_TYPE_PRECOMPUTE_INIT
9083 | OPTI_TYPE_PRECOMPUTE_MERKLE
9084 | OPTI_TYPE_EARLY_SKIP
9085 | OPTI_TYPE_NOT_ITERATED
9086 | OPTI_TYPE_NOT_SALTED
9087 | OPTI_TYPE_RAW_HASH;
9088 dgst_pos0 = 0;
9089 dgst_pos1 = 3;
9090 dgst_pos2 = 2;
9091 dgst_pos3 = 1;
9092 break;
9093
9094 case 4500: hash_type = HASH_TYPE_SHA1;
9095 salt_type = SALT_TYPE_NONE;
9096 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9097 opts_type = OPTS_TYPE_PT_GENERATE_BE
9098 | OPTS_TYPE_PT_ADD80
9099 | OPTS_TYPE_PT_ADDBITS15;
9100 kern_type = KERN_TYPE_SHA11;
9101 dgst_size = DGST_SIZE_4_5;
9102 parse_func = sha1_parse_hash;
9103 sort_by_digest = sort_by_digest_4_5;
9104 opti_type = OPTI_TYPE_ZERO_BYTE
9105 | OPTI_TYPE_PRECOMPUTE_INIT
9106 | OPTI_TYPE_PRECOMPUTE_MERKLE
9107 | OPTI_TYPE_EARLY_SKIP
9108 | OPTI_TYPE_NOT_SALTED;
9109 dgst_pos0 = 3;
9110 dgst_pos1 = 4;
9111 dgst_pos2 = 2;
9112 dgst_pos3 = 1;
9113 break;
9114
9115 case 4700: hash_type = HASH_TYPE_SHA1;
9116 salt_type = SALT_TYPE_NONE;
9117 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9118 opts_type = OPTS_TYPE_PT_GENERATE_LE
9119 | OPTS_TYPE_PT_ADD80
9120 | OPTS_TYPE_PT_ADDBITS14;
9121 kern_type = KERN_TYPE_SHA1_MD5;
9122 dgst_size = DGST_SIZE_4_5;
9123 parse_func = sha1_parse_hash;
9124 sort_by_digest = sort_by_digest_4_5;
9125 opti_type = OPTI_TYPE_ZERO_BYTE
9126 | OPTI_TYPE_PRECOMPUTE_INIT
9127 | OPTI_TYPE_PRECOMPUTE_MERKLE
9128 | OPTI_TYPE_EARLY_SKIP
9129 | OPTI_TYPE_NOT_ITERATED
9130 | OPTI_TYPE_NOT_SALTED
9131 | OPTI_TYPE_RAW_HASH;
9132 dgst_pos0 = 3;
9133 dgst_pos1 = 4;
9134 dgst_pos2 = 2;
9135 dgst_pos3 = 1;
9136 break;
9137
9138 case 4800: hash_type = HASH_TYPE_MD5;
9139 salt_type = SALT_TYPE_EMBEDDED;
9140 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9141 opts_type = OPTS_TYPE_PT_GENERATE_LE
9142 | OPTS_TYPE_PT_ADDBITS14;
9143 kern_type = KERN_TYPE_MD5_CHAP;
9144 dgst_size = DGST_SIZE_4_4;
9145 parse_func = chap_parse_hash;
9146 sort_by_digest = sort_by_digest_4_4;
9147 opti_type = OPTI_TYPE_ZERO_BYTE
9148 | OPTI_TYPE_PRECOMPUTE_INIT
9149 | OPTI_TYPE_PRECOMPUTE_MERKLE
9150 | OPTI_TYPE_MEET_IN_MIDDLE
9151 | OPTI_TYPE_EARLY_SKIP
9152 | OPTI_TYPE_NOT_ITERATED
9153 | OPTI_TYPE_RAW_HASH;
9154 dgst_pos0 = 0;
9155 dgst_pos1 = 3;
9156 dgst_pos2 = 2;
9157 dgst_pos3 = 1;
9158 break;
9159
9160 case 4900: hash_type = HASH_TYPE_SHA1;
9161 salt_type = SALT_TYPE_INTERN;
9162 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9163 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9164 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9165 dgst_size = DGST_SIZE_4_5;
9166 parse_func = sha1s_parse_hash;
9167 sort_by_digest = sort_by_digest_4_5;
9168 opti_type = OPTI_TYPE_ZERO_BYTE
9169 | OPTI_TYPE_PRECOMPUTE_INIT
9170 | OPTI_TYPE_PRECOMPUTE_MERKLE
9171 | OPTI_TYPE_EARLY_SKIP;
9172 dgst_pos0 = 3;
9173 dgst_pos1 = 4;
9174 dgst_pos2 = 2;
9175 dgst_pos3 = 1;
9176 break;
9177
9178 case 5000: hash_type = HASH_TYPE_KECCAK;
9179 salt_type = SALT_TYPE_EMBEDDED;
9180 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9181 opts_type = OPTS_TYPE_PT_GENERATE_LE
9182 | OPTS_TYPE_PT_ADD01;
9183 kern_type = KERN_TYPE_KECCAK;
9184 dgst_size = DGST_SIZE_8_25;
9185 parse_func = keccak_parse_hash;
9186 sort_by_digest = sort_by_digest_8_25;
9187 opti_type = OPTI_TYPE_ZERO_BYTE
9188 | OPTI_TYPE_USES_BITS_64
9189 | OPTI_TYPE_RAW_HASH;
9190 dgst_pos0 = 2;
9191 dgst_pos1 = 3;
9192 dgst_pos2 = 4;
9193 dgst_pos3 = 5;
9194 break;
9195
9196 case 5100: hash_type = HASH_TYPE_MD5H;
9197 salt_type = SALT_TYPE_NONE;
9198 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9199 opts_type = OPTS_TYPE_PT_GENERATE_LE
9200 | OPTS_TYPE_PT_ADD80
9201 | OPTS_TYPE_PT_ADDBITS14;
9202 kern_type = KERN_TYPE_MD5H;
9203 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9204 parse_func = md5half_parse_hash;
9205 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9206 opti_type = OPTI_TYPE_ZERO_BYTE
9207 | OPTI_TYPE_RAW_HASH;
9208 dgst_pos0 = 0;
9209 dgst_pos1 = 1;
9210 dgst_pos2 = 2;
9211 dgst_pos3 = 3;
9212 break;
9213
9214 case 5200: hash_type = HASH_TYPE_SHA256;
9215 salt_type = SALT_TYPE_EMBEDDED;
9216 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9217 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9218 kern_type = KERN_TYPE_PSAFE3;
9219 dgst_size = DGST_SIZE_4_8;
9220 parse_func = psafe3_parse_hash;
9221 sort_by_digest = sort_by_digest_4_8;
9222 opti_type = OPTI_TYPE_ZERO_BYTE;
9223 dgst_pos0 = 0;
9224 dgst_pos1 = 1;
9225 dgst_pos2 = 2;
9226 dgst_pos3 = 3;
9227 break;
9228
9229 case 5300: hash_type = HASH_TYPE_MD5;
9230 salt_type = SALT_TYPE_EMBEDDED;
9231 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9232 opts_type = OPTS_TYPE_PT_GENERATE_LE
9233 | OPTS_TYPE_ST_ADD80;
9234 kern_type = KERN_TYPE_IKEPSK_MD5;
9235 dgst_size = DGST_SIZE_4_4;
9236 parse_func = ikepsk_md5_parse_hash;
9237 sort_by_digest = sort_by_digest_4_4;
9238 opti_type = OPTI_TYPE_ZERO_BYTE;
9239 dgst_pos0 = 0;
9240 dgst_pos1 = 3;
9241 dgst_pos2 = 2;
9242 dgst_pos3 = 1;
9243 break;
9244
9245 case 5400: hash_type = HASH_TYPE_SHA1;
9246 salt_type = SALT_TYPE_EMBEDDED;
9247 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9248 opts_type = OPTS_TYPE_PT_GENERATE_BE
9249 | OPTS_TYPE_ST_ADD80;
9250 kern_type = KERN_TYPE_IKEPSK_SHA1;
9251 dgst_size = DGST_SIZE_4_5;
9252 parse_func = ikepsk_sha1_parse_hash;
9253 sort_by_digest = sort_by_digest_4_5;
9254 opti_type = OPTI_TYPE_ZERO_BYTE;
9255 dgst_pos0 = 3;
9256 dgst_pos1 = 4;
9257 dgst_pos2 = 2;
9258 dgst_pos3 = 1;
9259 break;
9260
9261 case 5500: hash_type = HASH_TYPE_NETNTLM;
9262 salt_type = SALT_TYPE_EMBEDDED;
9263 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9264 opts_type = OPTS_TYPE_PT_GENERATE_LE
9265 | OPTS_TYPE_PT_ADD80
9266 | OPTS_TYPE_PT_ADDBITS14
9267 | OPTS_TYPE_PT_UNICODE
9268 | OPTS_TYPE_ST_HEX;
9269 kern_type = KERN_TYPE_NETNTLMv1;
9270 dgst_size = DGST_SIZE_4_4;
9271 parse_func = netntlmv1_parse_hash;
9272 sort_by_digest = sort_by_digest_4_4;
9273 opti_type = OPTI_TYPE_ZERO_BYTE
9274 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9275 dgst_pos0 = 0;
9276 dgst_pos1 = 1;
9277 dgst_pos2 = 2;
9278 dgst_pos3 = 3;
9279 break;
9280
9281 case 5600: hash_type = HASH_TYPE_MD5;
9282 salt_type = SALT_TYPE_EMBEDDED;
9283 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9284 opts_type = OPTS_TYPE_PT_GENERATE_LE
9285 | OPTS_TYPE_PT_ADD80
9286 | OPTS_TYPE_PT_ADDBITS14
9287 | OPTS_TYPE_PT_UNICODE;
9288 kern_type = KERN_TYPE_NETNTLMv2;
9289 dgst_size = DGST_SIZE_4_4;
9290 parse_func = netntlmv2_parse_hash;
9291 sort_by_digest = sort_by_digest_4_4;
9292 opti_type = OPTI_TYPE_ZERO_BYTE;
9293 dgst_pos0 = 0;
9294 dgst_pos1 = 3;
9295 dgst_pos2 = 2;
9296 dgst_pos3 = 1;
9297 break;
9298
9299 case 5700: hash_type = HASH_TYPE_SHA256;
9300 salt_type = SALT_TYPE_NONE;
9301 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9302 opts_type = OPTS_TYPE_PT_GENERATE_BE
9303 | OPTS_TYPE_PT_ADD80
9304 | OPTS_TYPE_PT_ADDBITS15;
9305 kern_type = KERN_TYPE_SHA256;
9306 dgst_size = DGST_SIZE_4_8;
9307 parse_func = cisco4_parse_hash;
9308 sort_by_digest = sort_by_digest_4_8;
9309 opti_type = OPTI_TYPE_ZERO_BYTE
9310 | OPTI_TYPE_PRECOMPUTE_INIT
9311 | OPTI_TYPE_PRECOMPUTE_MERKLE
9312 | OPTI_TYPE_EARLY_SKIP
9313 | OPTI_TYPE_NOT_ITERATED
9314 | OPTI_TYPE_NOT_SALTED
9315 | OPTI_TYPE_RAW_HASH;
9316 dgst_pos0 = 3;
9317 dgst_pos1 = 7;
9318 dgst_pos2 = 2;
9319 dgst_pos3 = 6;
9320 break;
9321
9322 case 5800: hash_type = HASH_TYPE_SHA1;
9323 salt_type = SALT_TYPE_INTERN;
9324 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9325 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9326 | OPTS_TYPE_ST_ADD80;
9327 kern_type = KERN_TYPE_ANDROIDPIN;
9328 dgst_size = DGST_SIZE_4_5;
9329 parse_func = androidpin_parse_hash;
9330 sort_by_digest = sort_by_digest_4_5;
9331 opti_type = OPTI_TYPE_ZERO_BYTE;
9332 dgst_pos0 = 0;
9333 dgst_pos1 = 1;
9334 dgst_pos2 = 2;
9335 dgst_pos3 = 3;
9336 break;
9337
9338 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9339 salt_type = SALT_TYPE_NONE;
9340 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9341 opts_type = OPTS_TYPE_PT_GENERATE_LE
9342 | OPTS_TYPE_PT_ADD80;
9343 kern_type = KERN_TYPE_RIPEMD160;
9344 dgst_size = DGST_SIZE_4_5;
9345 parse_func = ripemd160_parse_hash;
9346 sort_by_digest = sort_by_digest_4_5;
9347 opti_type = OPTI_TYPE_ZERO_BYTE;
9348 dgst_pos0 = 0;
9349 dgst_pos1 = 1;
9350 dgst_pos2 = 2;
9351 dgst_pos3 = 3;
9352 break;
9353
9354 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9355 salt_type = SALT_TYPE_NONE;
9356 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9357 opts_type = OPTS_TYPE_PT_GENERATE_BE
9358 | OPTS_TYPE_PT_ADD80;
9359 kern_type = KERN_TYPE_WHIRLPOOL;
9360 dgst_size = DGST_SIZE_4_16;
9361 parse_func = whirlpool_parse_hash;
9362 sort_by_digest = sort_by_digest_4_16;
9363 opti_type = OPTI_TYPE_ZERO_BYTE;
9364 dgst_pos0 = 0;
9365 dgst_pos1 = 1;
9366 dgst_pos2 = 2;
9367 dgst_pos3 = 3;
9368 break;
9369
9370 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9371 salt_type = SALT_TYPE_EMBEDDED;
9372 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9373 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9374 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9375 dgst_size = DGST_SIZE_4_5;
9376 parse_func = truecrypt_parse_hash_2k;
9377 sort_by_digest = sort_by_digest_4_5;
9378 opti_type = OPTI_TYPE_ZERO_BYTE;
9379 dgst_pos0 = 0;
9380 dgst_pos1 = 1;
9381 dgst_pos2 = 2;
9382 dgst_pos3 = 3;
9383 break;
9384
9385 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9386 salt_type = SALT_TYPE_EMBEDDED;
9387 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9388 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9389 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9390 dgst_size = DGST_SIZE_4_5;
9391 parse_func = truecrypt_parse_hash_2k;
9392 sort_by_digest = sort_by_digest_4_5;
9393 opti_type = OPTI_TYPE_ZERO_BYTE;
9394 dgst_pos0 = 0;
9395 dgst_pos1 = 1;
9396 dgst_pos2 = 2;
9397 dgst_pos3 = 3;
9398 break;
9399
9400 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9401 salt_type = SALT_TYPE_EMBEDDED;
9402 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9403 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9404 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9405 dgst_size = DGST_SIZE_4_5;
9406 parse_func = truecrypt_parse_hash_2k;
9407 sort_by_digest = sort_by_digest_4_5;
9408 opti_type = OPTI_TYPE_ZERO_BYTE;
9409 dgst_pos0 = 0;
9410 dgst_pos1 = 1;
9411 dgst_pos2 = 2;
9412 dgst_pos3 = 3;
9413 break;
9414
9415 case 6221: hash_type = HASH_TYPE_SHA512;
9416 salt_type = SALT_TYPE_EMBEDDED;
9417 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9418 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9419 kern_type = KERN_TYPE_TCSHA512_XTS512;
9420 dgst_size = DGST_SIZE_8_8;
9421 parse_func = truecrypt_parse_hash_1k;
9422 sort_by_digest = sort_by_digest_8_8;
9423 opti_type = OPTI_TYPE_ZERO_BYTE
9424 | OPTI_TYPE_USES_BITS_64;
9425 dgst_pos0 = 0;
9426 dgst_pos1 = 1;
9427 dgst_pos2 = 2;
9428 dgst_pos3 = 3;
9429 break;
9430
9431 case 6222: hash_type = HASH_TYPE_SHA512;
9432 salt_type = SALT_TYPE_EMBEDDED;
9433 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9434 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9435 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9436 dgst_size = DGST_SIZE_8_8;
9437 parse_func = truecrypt_parse_hash_1k;
9438 sort_by_digest = sort_by_digest_8_8;
9439 opti_type = OPTI_TYPE_ZERO_BYTE
9440 | OPTI_TYPE_USES_BITS_64;
9441 dgst_pos0 = 0;
9442 dgst_pos1 = 1;
9443 dgst_pos2 = 2;
9444 dgst_pos3 = 3;
9445 break;
9446
9447 case 6223: hash_type = HASH_TYPE_SHA512;
9448 salt_type = SALT_TYPE_EMBEDDED;
9449 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9450 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9451 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9452 dgst_size = DGST_SIZE_8_8;
9453 parse_func = truecrypt_parse_hash_1k;
9454 sort_by_digest = sort_by_digest_8_8;
9455 opti_type = OPTI_TYPE_ZERO_BYTE
9456 | OPTI_TYPE_USES_BITS_64;
9457 dgst_pos0 = 0;
9458 dgst_pos1 = 1;
9459 dgst_pos2 = 2;
9460 dgst_pos3 = 3;
9461 break;
9462
9463 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9464 salt_type = SALT_TYPE_EMBEDDED;
9465 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9466 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9467 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9468 dgst_size = DGST_SIZE_4_8;
9469 parse_func = truecrypt_parse_hash_1k;
9470 sort_by_digest = sort_by_digest_4_8;
9471 opti_type = OPTI_TYPE_ZERO_BYTE;
9472 dgst_pos0 = 0;
9473 dgst_pos1 = 1;
9474 dgst_pos2 = 2;
9475 dgst_pos3 = 3;
9476 break;
9477
9478 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9479 salt_type = SALT_TYPE_EMBEDDED;
9480 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9481 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9482 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9483 dgst_size = DGST_SIZE_4_8;
9484 parse_func = truecrypt_parse_hash_1k;
9485 sort_by_digest = sort_by_digest_4_8;
9486 opti_type = OPTI_TYPE_ZERO_BYTE;
9487 dgst_pos0 = 0;
9488 dgst_pos1 = 1;
9489 dgst_pos2 = 2;
9490 dgst_pos3 = 3;
9491 break;
9492
9493 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9494 salt_type = SALT_TYPE_EMBEDDED;
9495 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9496 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9497 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9498 dgst_size = DGST_SIZE_4_8;
9499 parse_func = truecrypt_parse_hash_1k;
9500 sort_by_digest = sort_by_digest_4_8;
9501 opti_type = OPTI_TYPE_ZERO_BYTE;
9502 dgst_pos0 = 0;
9503 dgst_pos1 = 1;
9504 dgst_pos2 = 2;
9505 dgst_pos3 = 3;
9506 break;
9507
9508 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9509 salt_type = SALT_TYPE_EMBEDDED;
9510 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9511 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9512 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9513 dgst_size = DGST_SIZE_4_5;
9514 parse_func = truecrypt_parse_hash_1k;
9515 sort_by_digest = sort_by_digest_4_5;
9516 opti_type = OPTI_TYPE_ZERO_BYTE;
9517 dgst_pos0 = 0;
9518 dgst_pos1 = 1;
9519 dgst_pos2 = 2;
9520 dgst_pos3 = 3;
9521 break;
9522
9523 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9524 salt_type = SALT_TYPE_EMBEDDED;
9525 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9526 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9527 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9528 dgst_size = DGST_SIZE_4_5;
9529 parse_func = truecrypt_parse_hash_1k;
9530 sort_by_digest = sort_by_digest_4_5;
9531 opti_type = OPTI_TYPE_ZERO_BYTE;
9532 dgst_pos0 = 0;
9533 dgst_pos1 = 1;
9534 dgst_pos2 = 2;
9535 dgst_pos3 = 3;
9536 break;
9537
9538 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9539 salt_type = SALT_TYPE_EMBEDDED;
9540 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9541 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9542 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9543 dgst_size = DGST_SIZE_4_5;
9544 parse_func = truecrypt_parse_hash_1k;
9545 sort_by_digest = sort_by_digest_4_5;
9546 opti_type = OPTI_TYPE_ZERO_BYTE;
9547 dgst_pos0 = 0;
9548 dgst_pos1 = 1;
9549 dgst_pos2 = 2;
9550 dgst_pos3 = 3;
9551 break;
9552
9553 case 6300: hash_type = HASH_TYPE_MD5;
9554 salt_type = SALT_TYPE_EMBEDDED;
9555 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9556 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9557 kern_type = KERN_TYPE_MD5AIX;
9558 dgst_size = DGST_SIZE_4_4;
9559 parse_func = md5aix_parse_hash;
9560 sort_by_digest = sort_by_digest_4_4;
9561 opti_type = OPTI_TYPE_ZERO_BYTE;
9562 dgst_pos0 = 0;
9563 dgst_pos1 = 1;
9564 dgst_pos2 = 2;
9565 dgst_pos3 = 3;
9566 break;
9567
9568 case 6400: hash_type = HASH_TYPE_SHA256;
9569 salt_type = SALT_TYPE_EMBEDDED;
9570 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9571 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9572 kern_type = KERN_TYPE_SHA256AIX;
9573 dgst_size = DGST_SIZE_4_8;
9574 parse_func = sha256aix_parse_hash;
9575 sort_by_digest = sort_by_digest_4_8;
9576 opti_type = OPTI_TYPE_ZERO_BYTE;
9577 dgst_pos0 = 0;
9578 dgst_pos1 = 1;
9579 dgst_pos2 = 2;
9580 dgst_pos3 = 3;
9581 break;
9582
9583 case 6500: hash_type = HASH_TYPE_SHA512;
9584 salt_type = SALT_TYPE_EMBEDDED;
9585 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9586 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9587 kern_type = KERN_TYPE_SHA512AIX;
9588 dgst_size = DGST_SIZE_8_8;
9589 parse_func = sha512aix_parse_hash;
9590 sort_by_digest = sort_by_digest_8_8;
9591 opti_type = OPTI_TYPE_ZERO_BYTE
9592 | OPTI_TYPE_USES_BITS_64;
9593 dgst_pos0 = 0;
9594 dgst_pos1 = 1;
9595 dgst_pos2 = 2;
9596 dgst_pos3 = 3;
9597 break;
9598
9599 case 6600: hash_type = HASH_TYPE_AES;
9600 salt_type = SALT_TYPE_EMBEDDED;
9601 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9602 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9603 kern_type = KERN_TYPE_AGILEKEY;
9604 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9605 parse_func = agilekey_parse_hash;
9606 sort_by_digest = sort_by_digest_4_5;
9607 opti_type = OPTI_TYPE_ZERO_BYTE;
9608 dgst_pos0 = 0;
9609 dgst_pos1 = 1;
9610 dgst_pos2 = 2;
9611 dgst_pos3 = 3;
9612 break;
9613
9614 case 6700: hash_type = HASH_TYPE_SHA1;
9615 salt_type = SALT_TYPE_EMBEDDED;
9616 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9617 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9618 kern_type = KERN_TYPE_SHA1AIX;
9619 dgst_size = DGST_SIZE_4_5;
9620 parse_func = sha1aix_parse_hash;
9621 sort_by_digest = sort_by_digest_4_5;
9622 opti_type = OPTI_TYPE_ZERO_BYTE;
9623 dgst_pos0 = 0;
9624 dgst_pos1 = 1;
9625 dgst_pos2 = 2;
9626 dgst_pos3 = 3;
9627 break;
9628
9629 case 6800: hash_type = HASH_TYPE_AES;
9630 salt_type = SALT_TYPE_EMBEDDED;
9631 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9632 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9633 kern_type = KERN_TYPE_LASTPASS;
9634 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9635 parse_func = lastpass_parse_hash;
9636 sort_by_digest = sort_by_digest_4_8;
9637 opti_type = OPTI_TYPE_ZERO_BYTE;
9638 dgst_pos0 = 0;
9639 dgst_pos1 = 1;
9640 dgst_pos2 = 2;
9641 dgst_pos3 = 3;
9642 break;
9643
9644 case 6900: hash_type = HASH_TYPE_GOST;
9645 salt_type = SALT_TYPE_NONE;
9646 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9647 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9648 kern_type = KERN_TYPE_GOST;
9649 dgst_size = DGST_SIZE_4_8;
9650 parse_func = gost_parse_hash;
9651 sort_by_digest = sort_by_digest_4_8;
9652 opti_type = OPTI_TYPE_ZERO_BYTE;
9653 dgst_pos0 = 0;
9654 dgst_pos1 = 1;
9655 dgst_pos2 = 2;
9656 dgst_pos3 = 3;
9657 break;
9658
9659 case 7100: hash_type = HASH_TYPE_SHA512;
9660 salt_type = SALT_TYPE_EMBEDDED;
9661 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9662 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9663 kern_type = KERN_TYPE_PBKDF2_SHA512;
9664 dgst_size = DGST_SIZE_8_16;
9665 parse_func = sha512osx_parse_hash;
9666 sort_by_digest = sort_by_digest_8_16;
9667 opti_type = OPTI_TYPE_ZERO_BYTE
9668 | OPTI_TYPE_USES_BITS_64
9669 | OPTI_TYPE_SLOW_HASH_SIMD;
9670 dgst_pos0 = 0;
9671 dgst_pos1 = 1;
9672 dgst_pos2 = 2;
9673 dgst_pos3 = 3;
9674 break;
9675
9676 case 7200: hash_type = HASH_TYPE_SHA512;
9677 salt_type = SALT_TYPE_EMBEDDED;
9678 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9679 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9680 kern_type = KERN_TYPE_PBKDF2_SHA512;
9681 dgst_size = DGST_SIZE_8_16;
9682 parse_func = sha512grub_parse_hash;
9683 sort_by_digest = sort_by_digest_8_16;
9684 opti_type = OPTI_TYPE_ZERO_BYTE
9685 | OPTI_TYPE_USES_BITS_64
9686 | OPTI_TYPE_SLOW_HASH_SIMD;
9687 dgst_pos0 = 0;
9688 dgst_pos1 = 1;
9689 dgst_pos2 = 2;
9690 dgst_pos3 = 3;
9691 break;
9692
9693 case 7300: hash_type = HASH_TYPE_SHA1;
9694 salt_type = SALT_TYPE_EMBEDDED;
9695 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9696 opts_type = OPTS_TYPE_PT_GENERATE_BE
9697 | OPTS_TYPE_ST_ADD80
9698 | OPTS_TYPE_ST_ADDBITS15;
9699 kern_type = KERN_TYPE_RAKP;
9700 dgst_size = DGST_SIZE_4_5;
9701 parse_func = rakp_parse_hash;
9702 sort_by_digest = sort_by_digest_4_5;
9703 opti_type = OPTI_TYPE_ZERO_BYTE
9704 | OPTI_TYPE_NOT_ITERATED;
9705 dgst_pos0 = 3;
9706 dgst_pos1 = 4;
9707 dgst_pos2 = 2;
9708 dgst_pos3 = 1;
9709 break;
9710
9711 case 7400: hash_type = HASH_TYPE_SHA256;
9712 salt_type = SALT_TYPE_EMBEDDED;
9713 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9714 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9715 kern_type = KERN_TYPE_SHA256CRYPT;
9716 dgst_size = DGST_SIZE_4_8;
9717 parse_func = sha256crypt_parse_hash;
9718 sort_by_digest = sort_by_digest_4_8;
9719 opti_type = OPTI_TYPE_ZERO_BYTE;
9720 dgst_pos0 = 0;
9721 dgst_pos1 = 1;
9722 dgst_pos2 = 2;
9723 dgst_pos3 = 3;
9724 break;
9725
9726 case 7500: hash_type = HASH_TYPE_KRB5PA;
9727 salt_type = SALT_TYPE_EMBEDDED;
9728 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9729 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9730 kern_type = KERN_TYPE_KRB5PA;
9731 dgst_size = DGST_SIZE_4_4;
9732 parse_func = krb5pa_parse_hash;
9733 sort_by_digest = sort_by_digest_4_4;
9734 opti_type = OPTI_TYPE_ZERO_BYTE
9735 | OPTI_TYPE_NOT_ITERATED;
9736 dgst_pos0 = 0;
9737 dgst_pos1 = 1;
9738 dgst_pos2 = 2;
9739 dgst_pos3 = 3;
9740 break;
9741
9742 case 7600: hash_type = HASH_TYPE_SHA1;
9743 salt_type = SALT_TYPE_INTERN;
9744 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9745 opts_type = OPTS_TYPE_PT_GENERATE_BE
9746 | OPTS_TYPE_PT_ADD80
9747 | OPTS_TYPE_PT_ADDBITS15;
9748 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9749 dgst_size = DGST_SIZE_4_5;
9750 parse_func = redmine_parse_hash;
9751 sort_by_digest = sort_by_digest_4_5;
9752 opti_type = OPTI_TYPE_ZERO_BYTE
9753 | OPTI_TYPE_PRECOMPUTE_INIT
9754 | OPTI_TYPE_EARLY_SKIP
9755 | OPTI_TYPE_NOT_ITERATED
9756 | OPTI_TYPE_PREPENDED_SALT;
9757 dgst_pos0 = 3;
9758 dgst_pos1 = 4;
9759 dgst_pos2 = 2;
9760 dgst_pos3 = 1;
9761 break;
9762
9763 case 7700: hash_type = HASH_TYPE_SAPB;
9764 salt_type = SALT_TYPE_EMBEDDED;
9765 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9766 opts_type = OPTS_TYPE_PT_GENERATE_LE
9767 | OPTS_TYPE_PT_UPPER
9768 | OPTS_TYPE_ST_UPPER;
9769 kern_type = KERN_TYPE_SAPB;
9770 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9771 parse_func = sapb_parse_hash;
9772 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9773 opti_type = OPTI_TYPE_ZERO_BYTE
9774 | OPTI_TYPE_PRECOMPUTE_INIT
9775 | OPTI_TYPE_NOT_ITERATED;
9776 dgst_pos0 = 0;
9777 dgst_pos1 = 1;
9778 dgst_pos2 = 2;
9779 dgst_pos3 = 3;
9780 break;
9781
9782 case 7800: hash_type = HASH_TYPE_SAPG;
9783 salt_type = SALT_TYPE_EMBEDDED;
9784 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9785 opts_type = OPTS_TYPE_PT_GENERATE_BE
9786 | OPTS_TYPE_ST_ADD80
9787 | OPTS_TYPE_ST_UPPER;
9788 kern_type = KERN_TYPE_SAPG;
9789 dgst_size = DGST_SIZE_4_5;
9790 parse_func = sapg_parse_hash;
9791 sort_by_digest = sort_by_digest_4_5;
9792 opti_type = OPTI_TYPE_ZERO_BYTE
9793 | OPTI_TYPE_PRECOMPUTE_INIT
9794 | OPTI_TYPE_NOT_ITERATED;
9795 dgst_pos0 = 3;
9796 dgst_pos1 = 4;
9797 dgst_pos2 = 2;
9798 dgst_pos3 = 1;
9799 break;
9800
9801 case 7900: hash_type = HASH_TYPE_SHA512;
9802 salt_type = SALT_TYPE_EMBEDDED;
9803 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9804 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9805 kern_type = KERN_TYPE_DRUPAL7;
9806 dgst_size = DGST_SIZE_8_8;
9807 parse_func = drupal7_parse_hash;
9808 sort_by_digest = sort_by_digest_8_8;
9809 opti_type = OPTI_TYPE_ZERO_BYTE
9810 | OPTI_TYPE_USES_BITS_64;
9811 dgst_pos0 = 0;
9812 dgst_pos1 = 1;
9813 dgst_pos2 = 2;
9814 dgst_pos3 = 3;
9815 break;
9816
9817 case 8000: hash_type = HASH_TYPE_SHA256;
9818 salt_type = SALT_TYPE_EMBEDDED;
9819 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9820 opts_type = OPTS_TYPE_PT_GENERATE_BE
9821 | OPTS_TYPE_PT_UNICODE
9822 | OPTS_TYPE_ST_ADD80
9823 | OPTS_TYPE_ST_HEX;
9824 kern_type = KERN_TYPE_SYBASEASE;
9825 dgst_size = DGST_SIZE_4_8;
9826 parse_func = sybasease_parse_hash;
9827 sort_by_digest = sort_by_digest_4_8;
9828 opti_type = OPTI_TYPE_ZERO_BYTE
9829 | OPTI_TYPE_PRECOMPUTE_INIT
9830 | OPTI_TYPE_EARLY_SKIP
9831 | OPTI_TYPE_NOT_ITERATED
9832 | OPTI_TYPE_RAW_HASH;
9833 dgst_pos0 = 3;
9834 dgst_pos1 = 7;
9835 dgst_pos2 = 2;
9836 dgst_pos3 = 6;
9837 break;
9838
9839 case 8100: hash_type = HASH_TYPE_SHA1;
9840 salt_type = SALT_TYPE_EMBEDDED;
9841 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9842 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9843 kern_type = KERN_TYPE_NETSCALER;
9844 dgst_size = DGST_SIZE_4_5;
9845 parse_func = netscaler_parse_hash;
9846 sort_by_digest = sort_by_digest_4_5;
9847 opti_type = OPTI_TYPE_ZERO_BYTE
9848 | OPTI_TYPE_PRECOMPUTE_INIT
9849 | OPTI_TYPE_PRECOMPUTE_MERKLE
9850 | OPTI_TYPE_EARLY_SKIP
9851 | OPTI_TYPE_NOT_ITERATED
9852 | OPTI_TYPE_PREPENDED_SALT
9853 | OPTI_TYPE_RAW_HASH;
9854 dgst_pos0 = 3;
9855 dgst_pos1 = 4;
9856 dgst_pos2 = 2;
9857 dgst_pos3 = 1;
9858 break;
9859
9860 case 8200: hash_type = HASH_TYPE_SHA256;
9861 salt_type = SALT_TYPE_EMBEDDED;
9862 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9863 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9864 kern_type = KERN_TYPE_CLOUDKEY;
9865 dgst_size = DGST_SIZE_4_8;
9866 parse_func = cloudkey_parse_hash;
9867 sort_by_digest = sort_by_digest_4_8;
9868 opti_type = OPTI_TYPE_ZERO_BYTE;
9869 dgst_pos0 = 0;
9870 dgst_pos1 = 1;
9871 dgst_pos2 = 2;
9872 dgst_pos3 = 3;
9873 break;
9874
9875 case 8300: hash_type = HASH_TYPE_SHA1;
9876 salt_type = SALT_TYPE_EMBEDDED;
9877 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9878 opts_type = OPTS_TYPE_PT_GENERATE_BE
9879 | OPTS_TYPE_ST_HEX
9880 | OPTS_TYPE_ST_ADD80;
9881 kern_type = KERN_TYPE_NSEC3;
9882 dgst_size = DGST_SIZE_4_5;
9883 parse_func = nsec3_parse_hash;
9884 sort_by_digest = sort_by_digest_4_5;
9885 opti_type = OPTI_TYPE_ZERO_BYTE;
9886 dgst_pos0 = 3;
9887 dgst_pos1 = 4;
9888 dgst_pos2 = 2;
9889 dgst_pos3 = 1;
9890 break;
9891
9892 case 8400: hash_type = HASH_TYPE_SHA1;
9893 salt_type = SALT_TYPE_INTERN;
9894 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9895 opts_type = OPTS_TYPE_PT_GENERATE_BE
9896 | OPTS_TYPE_PT_ADD80
9897 | OPTS_TYPE_PT_ADDBITS15;
9898 kern_type = KERN_TYPE_WBB3;
9899 dgst_size = DGST_SIZE_4_5;
9900 parse_func = wbb3_parse_hash;
9901 sort_by_digest = sort_by_digest_4_5;
9902 opti_type = OPTI_TYPE_ZERO_BYTE
9903 | OPTI_TYPE_PRECOMPUTE_INIT
9904 | OPTI_TYPE_NOT_ITERATED;
9905 dgst_pos0 = 3;
9906 dgst_pos1 = 4;
9907 dgst_pos2 = 2;
9908 dgst_pos3 = 1;
9909 break;
9910
9911 case 8500: hash_type = HASH_TYPE_DESRACF;
9912 salt_type = SALT_TYPE_EMBEDDED;
9913 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9914 opts_type = OPTS_TYPE_PT_GENERATE_LE
9915 | OPTS_TYPE_ST_UPPER;
9916 kern_type = KERN_TYPE_RACF;
9917 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9918 parse_func = racf_parse_hash;
9919 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9920 opti_type = OPTI_TYPE_ZERO_BYTE
9921 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9922 dgst_pos0 = 0;
9923 dgst_pos1 = 1;
9924 dgst_pos2 = 2;
9925 dgst_pos3 = 3;
9926 break;
9927
9928 case 8600: hash_type = HASH_TYPE_LOTUS5;
9929 salt_type = SALT_TYPE_NONE;
9930 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9931 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9932 kern_type = KERN_TYPE_LOTUS5;
9933 dgst_size = DGST_SIZE_4_4;
9934 parse_func = lotus5_parse_hash;
9935 sort_by_digest = sort_by_digest_4_4;
9936 opti_type = OPTI_TYPE_EARLY_SKIP
9937 | OPTI_TYPE_NOT_ITERATED
9938 | OPTI_TYPE_NOT_SALTED
9939 | OPTI_TYPE_RAW_HASH;
9940 dgst_pos0 = 0;
9941 dgst_pos1 = 1;
9942 dgst_pos2 = 2;
9943 dgst_pos3 = 3;
9944 break;
9945
9946 case 8700: hash_type = HASH_TYPE_LOTUS6;
9947 salt_type = SALT_TYPE_EMBEDDED;
9948 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9949 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9950 kern_type = KERN_TYPE_LOTUS6;
9951 dgst_size = DGST_SIZE_4_4;
9952 parse_func = lotus6_parse_hash;
9953 sort_by_digest = sort_by_digest_4_4;
9954 opti_type = OPTI_TYPE_EARLY_SKIP
9955 | OPTI_TYPE_NOT_ITERATED
9956 | OPTI_TYPE_RAW_HASH;
9957 dgst_pos0 = 0;
9958 dgst_pos1 = 1;
9959 dgst_pos2 = 2;
9960 dgst_pos3 = 3;
9961 break;
9962
9963 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9964 salt_type = SALT_TYPE_EMBEDDED;
9965 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9966 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9967 kern_type = KERN_TYPE_ANDROIDFDE;
9968 dgst_size = DGST_SIZE_4_4;
9969 parse_func = androidfde_parse_hash;
9970 sort_by_digest = sort_by_digest_4_4;
9971 opti_type = OPTI_TYPE_ZERO_BYTE;
9972 dgst_pos0 = 0;
9973 dgst_pos1 = 1;
9974 dgst_pos2 = 2;
9975 dgst_pos3 = 3;
9976 break;
9977
9978 case 8900: hash_type = HASH_TYPE_SCRYPT;
9979 salt_type = SALT_TYPE_EMBEDDED;
9980 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9981 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9982 kern_type = KERN_TYPE_SCRYPT;
9983 dgst_size = DGST_SIZE_4_8;
9984 parse_func = scrypt_parse_hash;
9985 sort_by_digest = sort_by_digest_4_8;
9986 opti_type = OPTI_TYPE_ZERO_BYTE;
9987 dgst_pos0 = 0;
9988 dgst_pos1 = 1;
9989 dgst_pos2 = 2;
9990 dgst_pos3 = 3;
9991 break;
9992
9993 case 9000: hash_type = HASH_TYPE_SHA1;
9994 salt_type = SALT_TYPE_EMBEDDED;
9995 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9996 opts_type = OPTS_TYPE_PT_GENERATE_LE
9997 | OPTS_TYPE_ST_GENERATE_LE;
9998 kern_type = KERN_TYPE_PSAFE2;
9999 dgst_size = DGST_SIZE_4_5;
10000 parse_func = psafe2_parse_hash;
10001 sort_by_digest = sort_by_digest_4_5;
10002 opti_type = OPTI_TYPE_ZERO_BYTE;
10003 dgst_pos0 = 0;
10004 dgst_pos1 = 1;
10005 dgst_pos2 = 2;
10006 dgst_pos3 = 3;
10007 break;
10008
10009 case 9100: hash_type = HASH_TYPE_LOTUS8;
10010 salt_type = SALT_TYPE_EMBEDDED;
10011 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10012 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10013 kern_type = KERN_TYPE_LOTUS8;
10014 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10015 parse_func = lotus8_parse_hash;
10016 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10017 opti_type = OPTI_TYPE_ZERO_BYTE;
10018 dgst_pos0 = 0;
10019 dgst_pos1 = 1;
10020 dgst_pos2 = 2;
10021 dgst_pos3 = 3;
10022 break;
10023
10024 case 9200: hash_type = HASH_TYPE_SHA256;
10025 salt_type = SALT_TYPE_EMBEDDED;
10026 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10027 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10028 kern_type = KERN_TYPE_PBKDF2_SHA256;
10029 dgst_size = DGST_SIZE_4_32;
10030 parse_func = cisco8_parse_hash;
10031 sort_by_digest = sort_by_digest_4_32;
10032 opti_type = OPTI_TYPE_ZERO_BYTE
10033 | OPTI_TYPE_SLOW_HASH_SIMD;
10034 dgst_pos0 = 0;
10035 dgst_pos1 = 1;
10036 dgst_pos2 = 2;
10037 dgst_pos3 = 3;
10038 break;
10039
10040 case 9300: hash_type = HASH_TYPE_SCRYPT;
10041 salt_type = SALT_TYPE_EMBEDDED;
10042 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10043 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10044 kern_type = KERN_TYPE_SCRYPT;
10045 dgst_size = DGST_SIZE_4_8;
10046 parse_func = cisco9_parse_hash;
10047 sort_by_digest = sort_by_digest_4_8;
10048 opti_type = OPTI_TYPE_ZERO_BYTE;
10049 dgst_pos0 = 0;
10050 dgst_pos1 = 1;
10051 dgst_pos2 = 2;
10052 dgst_pos3 = 3;
10053 break;
10054
10055 case 9400: hash_type = HASH_TYPE_OFFICE2007;
10056 salt_type = SALT_TYPE_EMBEDDED;
10057 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10058 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10059 kern_type = KERN_TYPE_OFFICE2007;
10060 dgst_size = DGST_SIZE_4_4;
10061 parse_func = office2007_parse_hash;
10062 sort_by_digest = sort_by_digest_4_4;
10063 opti_type = OPTI_TYPE_ZERO_BYTE;
10064 dgst_pos0 = 0;
10065 dgst_pos1 = 1;
10066 dgst_pos2 = 2;
10067 dgst_pos3 = 3;
10068 break;
10069
10070 case 9500: hash_type = HASH_TYPE_OFFICE2010;
10071 salt_type = SALT_TYPE_EMBEDDED;
10072 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10073 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10074 kern_type = KERN_TYPE_OFFICE2010;
10075 dgst_size = DGST_SIZE_4_4;
10076 parse_func = office2010_parse_hash;
10077 sort_by_digest = sort_by_digest_4_4;
10078 opti_type = OPTI_TYPE_ZERO_BYTE;
10079 dgst_pos0 = 0;
10080 dgst_pos1 = 1;
10081 dgst_pos2 = 2;
10082 dgst_pos3 = 3;
10083 break;
10084
10085 case 9600: hash_type = HASH_TYPE_OFFICE2013;
10086 salt_type = SALT_TYPE_EMBEDDED;
10087 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10088 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10089 kern_type = KERN_TYPE_OFFICE2013;
10090 dgst_size = DGST_SIZE_4_4;
10091 parse_func = office2013_parse_hash;
10092 sort_by_digest = sort_by_digest_4_4;
10093 opti_type = OPTI_TYPE_ZERO_BYTE;
10094 dgst_pos0 = 0;
10095 dgst_pos1 = 1;
10096 dgst_pos2 = 2;
10097 dgst_pos3 = 3;
10098 break;
10099
10100 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
10101 salt_type = SALT_TYPE_EMBEDDED;
10102 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10103 opts_type = OPTS_TYPE_PT_GENERATE_LE
10104 | OPTS_TYPE_PT_ADD80
10105 | OPTS_TYPE_PT_UNICODE;
10106 kern_type = KERN_TYPE_OLDOFFICE01;
10107 dgst_size = DGST_SIZE_4_4;
10108 parse_func = oldoffice01_parse_hash;
10109 sort_by_digest = sort_by_digest_4_4;
10110 opti_type = OPTI_TYPE_ZERO_BYTE
10111 | OPTI_TYPE_PRECOMPUTE_INIT
10112 | OPTI_TYPE_NOT_ITERATED;
10113 dgst_pos0 = 0;
10114 dgst_pos1 = 1;
10115 dgst_pos2 = 2;
10116 dgst_pos3 = 3;
10117 break;
10118
10119 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
10120 salt_type = SALT_TYPE_EMBEDDED;
10121 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10122 opts_type = OPTS_TYPE_PT_GENERATE_LE
10123 | OPTS_TYPE_PT_ADD80;
10124 kern_type = KERN_TYPE_OLDOFFICE01CM1;
10125 dgst_size = DGST_SIZE_4_4;
10126 parse_func = oldoffice01cm1_parse_hash;
10127 sort_by_digest = sort_by_digest_4_4;
10128 opti_type = OPTI_TYPE_ZERO_BYTE
10129 | OPTI_TYPE_PRECOMPUTE_INIT
10130 | OPTI_TYPE_NOT_ITERATED;
10131 dgst_pos0 = 0;
10132 dgst_pos1 = 1;
10133 dgst_pos2 = 2;
10134 dgst_pos3 = 3;
10135 break;
10136
10137 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
10138 salt_type = SALT_TYPE_EMBEDDED;
10139 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10140 opts_type = OPTS_TYPE_PT_GENERATE_LE
10141 | OPTS_TYPE_PT_ADD80
10142 | OPTS_TYPE_PT_UNICODE
10143 | OPTS_TYPE_PT_NEVERCRACK;
10144 kern_type = KERN_TYPE_OLDOFFICE01CM2;
10145 dgst_size = DGST_SIZE_4_4;
10146 parse_func = oldoffice01cm2_parse_hash;
10147 sort_by_digest = sort_by_digest_4_4;
10148 opti_type = OPTI_TYPE_ZERO_BYTE
10149 | OPTI_TYPE_PRECOMPUTE_INIT
10150 | OPTI_TYPE_NOT_ITERATED;
10151 dgst_pos0 = 0;
10152 dgst_pos1 = 1;
10153 dgst_pos2 = 2;
10154 dgst_pos3 = 3;
10155 break;
10156
10157 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
10158 salt_type = SALT_TYPE_EMBEDDED;
10159 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10160 opts_type = OPTS_TYPE_PT_GENERATE_BE
10161 | OPTS_TYPE_PT_ADD80
10162 | OPTS_TYPE_PT_UNICODE;
10163 kern_type = KERN_TYPE_OLDOFFICE34;
10164 dgst_size = DGST_SIZE_4_4;
10165 parse_func = oldoffice34_parse_hash;
10166 sort_by_digest = sort_by_digest_4_4;
10167 opti_type = OPTI_TYPE_ZERO_BYTE
10168 | OPTI_TYPE_PRECOMPUTE_INIT
10169 | OPTI_TYPE_NOT_ITERATED;
10170 dgst_pos0 = 0;
10171 dgst_pos1 = 1;
10172 dgst_pos2 = 2;
10173 dgst_pos3 = 3;
10174 break;
10175
10176 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10177 salt_type = SALT_TYPE_EMBEDDED;
10178 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10179 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10180 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10181 dgst_size = DGST_SIZE_4_4;
10182 parse_func = oldoffice34cm1_parse_hash;
10183 sort_by_digest = sort_by_digest_4_4;
10184 opti_type = OPTI_TYPE_ZERO_BYTE
10185 | OPTI_TYPE_PRECOMPUTE_INIT
10186 | OPTI_TYPE_NOT_ITERATED;
10187 dgst_pos0 = 0;
10188 dgst_pos1 = 1;
10189 dgst_pos2 = 2;
10190 dgst_pos3 = 3;
10191 break;
10192
10193 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10194 salt_type = SALT_TYPE_EMBEDDED;
10195 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10196 opts_type = OPTS_TYPE_PT_GENERATE_BE
10197 | OPTS_TYPE_PT_ADD80
10198 | OPTS_TYPE_PT_UNICODE
10199 | OPTS_TYPE_PT_NEVERCRACK;
10200 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10201 dgst_size = DGST_SIZE_4_4;
10202 parse_func = oldoffice34cm2_parse_hash;
10203 sort_by_digest = sort_by_digest_4_4;
10204 opti_type = OPTI_TYPE_ZERO_BYTE
10205 | OPTI_TYPE_PRECOMPUTE_INIT
10206 | OPTI_TYPE_NOT_ITERATED;
10207 dgst_pos0 = 0;
10208 dgst_pos1 = 1;
10209 dgst_pos2 = 2;
10210 dgst_pos3 = 3;
10211 break;
10212
10213 case 9900: hash_type = HASH_TYPE_MD5;
10214 salt_type = SALT_TYPE_NONE;
10215 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10216 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10217 kern_type = KERN_TYPE_RADMIN2;
10218 dgst_size = DGST_SIZE_4_4;
10219 parse_func = radmin2_parse_hash;
10220 sort_by_digest = sort_by_digest_4_4;
10221 opti_type = OPTI_TYPE_ZERO_BYTE
10222 | OPTI_TYPE_PRECOMPUTE_INIT
10223 | OPTI_TYPE_EARLY_SKIP
10224 | OPTI_TYPE_NOT_ITERATED
10225 | OPTI_TYPE_NOT_SALTED;
10226 dgst_pos0 = 0;
10227 dgst_pos1 = 3;
10228 dgst_pos2 = 2;
10229 dgst_pos3 = 1;
10230 break;
10231
10232 case 10000: hash_type = HASH_TYPE_SHA256;
10233 salt_type = SALT_TYPE_EMBEDDED;
10234 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10235 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10236 kern_type = KERN_TYPE_PBKDF2_SHA256;
10237 dgst_size = DGST_SIZE_4_32;
10238 parse_func = djangopbkdf2_parse_hash;
10239 sort_by_digest = sort_by_digest_4_32;
10240 opti_type = OPTI_TYPE_ZERO_BYTE
10241 | OPTI_TYPE_SLOW_HASH_SIMD;
10242 dgst_pos0 = 0;
10243 dgst_pos1 = 1;
10244 dgst_pos2 = 2;
10245 dgst_pos3 = 3;
10246 break;
10247
10248 case 10100: hash_type = HASH_TYPE_SIPHASH;
10249 salt_type = SALT_TYPE_EMBEDDED;
10250 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10251 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10252 kern_type = KERN_TYPE_SIPHASH;
10253 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10254 parse_func = siphash_parse_hash;
10255 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10256 opti_type = OPTI_TYPE_ZERO_BYTE
10257 | OPTI_TYPE_NOT_ITERATED
10258 | OPTI_TYPE_RAW_HASH;
10259 dgst_pos0 = 0;
10260 dgst_pos1 = 1;
10261 dgst_pos2 = 2;
10262 dgst_pos3 = 3;
10263 break;
10264
10265 case 10200: hash_type = HASH_TYPE_MD5;
10266 salt_type = SALT_TYPE_EMBEDDED;
10267 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10268 opts_type = OPTS_TYPE_PT_GENERATE_LE
10269 | OPTS_TYPE_ST_ADD80
10270 | OPTS_TYPE_ST_ADDBITS14;
10271 kern_type = KERN_TYPE_HMACMD5_PW;
10272 dgst_size = DGST_SIZE_4_4;
10273 parse_func = crammd5_parse_hash;
10274 sort_by_digest = sort_by_digest_4_4;
10275 opti_type = OPTI_TYPE_ZERO_BYTE
10276 | OPTI_TYPE_NOT_ITERATED;
10277 dgst_pos0 = 0;
10278 dgst_pos1 = 3;
10279 dgst_pos2 = 2;
10280 dgst_pos3 = 1;
10281 break;
10282
10283 case 10300: hash_type = HASH_TYPE_SHA1;
10284 salt_type = SALT_TYPE_EMBEDDED;
10285 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10286 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10287 kern_type = KERN_TYPE_SAPH_SHA1;
10288 dgst_size = DGST_SIZE_4_5;
10289 parse_func = saph_sha1_parse_hash;
10290 sort_by_digest = sort_by_digest_4_5;
10291 opti_type = OPTI_TYPE_ZERO_BYTE;
10292 dgst_pos0 = 0;
10293 dgst_pos1 = 1;
10294 dgst_pos2 = 2;
10295 dgst_pos3 = 3;
10296 break;
10297
10298 case 10400: hash_type = HASH_TYPE_PDFU16;
10299 salt_type = SALT_TYPE_EMBEDDED;
10300 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10301 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10302 kern_type = KERN_TYPE_PDF11;
10303 dgst_size = DGST_SIZE_4_4;
10304 parse_func = pdf11_parse_hash;
10305 sort_by_digest = sort_by_digest_4_4;
10306 opti_type = OPTI_TYPE_ZERO_BYTE
10307 | OPTI_TYPE_NOT_ITERATED;
10308 dgst_pos0 = 0;
10309 dgst_pos1 = 1;
10310 dgst_pos2 = 2;
10311 dgst_pos3 = 3;
10312 break;
10313
10314 case 10410: hash_type = HASH_TYPE_PDFU16;
10315 salt_type = SALT_TYPE_EMBEDDED;
10316 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10317 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10318 kern_type = KERN_TYPE_PDF11CM1;
10319 dgst_size = DGST_SIZE_4_4;
10320 parse_func = pdf11cm1_parse_hash;
10321 sort_by_digest = sort_by_digest_4_4;
10322 opti_type = OPTI_TYPE_ZERO_BYTE
10323 | OPTI_TYPE_NOT_ITERATED;
10324 dgst_pos0 = 0;
10325 dgst_pos1 = 1;
10326 dgst_pos2 = 2;
10327 dgst_pos3 = 3;
10328 break;
10329
10330 case 10420: hash_type = HASH_TYPE_PDFU16;
10331 salt_type = SALT_TYPE_EMBEDDED;
10332 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10333 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10334 kern_type = KERN_TYPE_PDF11CM2;
10335 dgst_size = DGST_SIZE_4_4;
10336 parse_func = pdf11cm2_parse_hash;
10337 sort_by_digest = sort_by_digest_4_4;
10338 opti_type = OPTI_TYPE_ZERO_BYTE
10339 | OPTI_TYPE_NOT_ITERATED;
10340 dgst_pos0 = 0;
10341 dgst_pos1 = 1;
10342 dgst_pos2 = 2;
10343 dgst_pos3 = 3;
10344 break;
10345
10346 case 10500: hash_type = HASH_TYPE_PDFU16;
10347 salt_type = SALT_TYPE_EMBEDDED;
10348 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10349 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10350 kern_type = KERN_TYPE_PDF14;
10351 dgst_size = DGST_SIZE_4_4;
10352 parse_func = pdf14_parse_hash;
10353 sort_by_digest = sort_by_digest_4_4;
10354 opti_type = OPTI_TYPE_ZERO_BYTE
10355 | OPTI_TYPE_NOT_ITERATED;
10356 dgst_pos0 = 0;
10357 dgst_pos1 = 1;
10358 dgst_pos2 = 2;
10359 dgst_pos3 = 3;
10360 break;
10361
10362 case 10600: hash_type = HASH_TYPE_SHA256;
10363 salt_type = SALT_TYPE_EMBEDDED;
10364 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10365 opts_type = OPTS_TYPE_PT_GENERATE_BE
10366 | OPTS_TYPE_ST_ADD80
10367 | OPTS_TYPE_ST_ADDBITS15
10368 | OPTS_TYPE_HASH_COPY;
10369 kern_type = KERN_TYPE_SHA256_PWSLT;
10370 dgst_size = DGST_SIZE_4_8;
10371 parse_func = pdf17l3_parse_hash;
10372 sort_by_digest = sort_by_digest_4_8;
10373 opti_type = OPTI_TYPE_ZERO_BYTE
10374 | OPTI_TYPE_PRECOMPUTE_INIT
10375 | OPTI_TYPE_PRECOMPUTE_MERKLE
10376 | OPTI_TYPE_EARLY_SKIP
10377 | OPTI_TYPE_NOT_ITERATED
10378 | OPTI_TYPE_APPENDED_SALT
10379 | OPTI_TYPE_RAW_HASH;
10380 dgst_pos0 = 3;
10381 dgst_pos1 = 7;
10382 dgst_pos2 = 2;
10383 dgst_pos3 = 6;
10384 break;
10385
10386 case 10700: hash_type = HASH_TYPE_PDFU32;
10387 salt_type = SALT_TYPE_EMBEDDED;
10388 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10389 opts_type = OPTS_TYPE_PT_GENERATE_LE
10390 | OPTS_TYPE_HASH_COPY;
10391 kern_type = KERN_TYPE_PDF17L8;
10392 dgst_size = DGST_SIZE_4_8;
10393 parse_func = pdf17l8_parse_hash;
10394 sort_by_digest = sort_by_digest_4_8;
10395 opti_type = OPTI_TYPE_ZERO_BYTE
10396 | OPTI_TYPE_NOT_ITERATED;
10397 dgst_pos0 = 0;
10398 dgst_pos1 = 1;
10399 dgst_pos2 = 2;
10400 dgst_pos3 = 3;
10401 break;
10402
10403 case 10800: hash_type = HASH_TYPE_SHA384;
10404 salt_type = SALT_TYPE_NONE;
10405 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10406 opts_type = OPTS_TYPE_PT_GENERATE_BE
10407 | OPTS_TYPE_PT_ADD80
10408 | OPTS_TYPE_PT_ADDBITS15;
10409 kern_type = KERN_TYPE_SHA384;
10410 dgst_size = DGST_SIZE_8_8;
10411 parse_func = sha384_parse_hash;
10412 sort_by_digest = sort_by_digest_8_8;
10413 opti_type = OPTI_TYPE_ZERO_BYTE
10414 | OPTI_TYPE_PRECOMPUTE_INIT
10415 | OPTI_TYPE_PRECOMPUTE_MERKLE
10416 | OPTI_TYPE_EARLY_SKIP
10417 | OPTI_TYPE_NOT_ITERATED
10418 | OPTI_TYPE_NOT_SALTED
10419 | OPTI_TYPE_USES_BITS_64
10420 | OPTI_TYPE_RAW_HASH;
10421 dgst_pos0 = 6;
10422 dgst_pos1 = 7;
10423 dgst_pos2 = 4;
10424 dgst_pos3 = 5;
10425 break;
10426
10427 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10428 salt_type = SALT_TYPE_EMBEDDED;
10429 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10430 opts_type = OPTS_TYPE_PT_GENERATE_LE
10431 | OPTS_TYPE_ST_BASE64
10432 | OPTS_TYPE_HASH_COPY;
10433 kern_type = KERN_TYPE_PBKDF2_SHA256;
10434 dgst_size = DGST_SIZE_4_32;
10435 parse_func = pbkdf2_sha256_parse_hash;
10436 sort_by_digest = sort_by_digest_4_32;
10437 opti_type = OPTI_TYPE_ZERO_BYTE
10438 | OPTI_TYPE_SLOW_HASH_SIMD;
10439 dgst_pos0 = 0;
10440 dgst_pos1 = 1;
10441 dgst_pos2 = 2;
10442 dgst_pos3 = 3;
10443 break;
10444
10445 case 11000: hash_type = HASH_TYPE_MD5;
10446 salt_type = SALT_TYPE_INTERN;
10447 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10448 opts_type = OPTS_TYPE_PT_GENERATE_LE
10449 | OPTS_TYPE_PT_ADD80;
10450 kern_type = KERN_TYPE_PRESTASHOP;
10451 dgst_size = DGST_SIZE_4_4;
10452 parse_func = prestashop_parse_hash;
10453 sort_by_digest = sort_by_digest_4_4;
10454 opti_type = OPTI_TYPE_ZERO_BYTE
10455 | OPTI_TYPE_PRECOMPUTE_INIT
10456 | OPTI_TYPE_NOT_ITERATED
10457 | OPTI_TYPE_PREPENDED_SALT;
10458 dgst_pos0 = 0;
10459 dgst_pos1 = 3;
10460 dgst_pos2 = 2;
10461 dgst_pos3 = 1;
10462 break;
10463
10464 case 11100: hash_type = HASH_TYPE_MD5;
10465 salt_type = SALT_TYPE_EMBEDDED;
10466 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10467 opts_type = OPTS_TYPE_PT_GENERATE_LE
10468 | OPTS_TYPE_ST_ADD80;
10469 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10470 dgst_size = DGST_SIZE_4_4;
10471 parse_func = postgresql_auth_parse_hash;
10472 sort_by_digest = sort_by_digest_4_4;
10473 opti_type = OPTI_TYPE_ZERO_BYTE
10474 | OPTI_TYPE_PRECOMPUTE_INIT
10475 | OPTI_TYPE_PRECOMPUTE_MERKLE
10476 | OPTI_TYPE_EARLY_SKIP;
10477 dgst_pos0 = 0;
10478 dgst_pos1 = 3;
10479 dgst_pos2 = 2;
10480 dgst_pos3 = 1;
10481 break;
10482
10483 case 11200: hash_type = HASH_TYPE_SHA1;
10484 salt_type = SALT_TYPE_EMBEDDED;
10485 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10486 opts_type = OPTS_TYPE_PT_GENERATE_BE
10487 | OPTS_TYPE_PT_ADD80
10488 | OPTS_TYPE_ST_HEX;
10489 kern_type = KERN_TYPE_MYSQL_AUTH;
10490 dgst_size = DGST_SIZE_4_5;
10491 parse_func = mysql_auth_parse_hash;
10492 sort_by_digest = sort_by_digest_4_5;
10493 opti_type = OPTI_TYPE_ZERO_BYTE
10494 | OPTI_TYPE_EARLY_SKIP;
10495 dgst_pos0 = 3;
10496 dgst_pos1 = 4;
10497 dgst_pos2 = 2;
10498 dgst_pos3 = 1;
10499 break;
10500
10501 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10502 salt_type = SALT_TYPE_EMBEDDED;
10503 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10504 opts_type = OPTS_TYPE_PT_GENERATE_LE
10505 | OPTS_TYPE_ST_HEX
10506 | OPTS_TYPE_ST_ADD80;
10507 kern_type = KERN_TYPE_BITCOIN_WALLET;
10508 dgst_size = DGST_SIZE_4_4;
10509 parse_func = bitcoin_wallet_parse_hash;
10510 sort_by_digest = sort_by_digest_4_4;
10511 opti_type = OPTI_TYPE_ZERO_BYTE;
10512 dgst_pos0 = 0;
10513 dgst_pos1 = 1;
10514 dgst_pos2 = 2;
10515 dgst_pos3 = 3;
10516 break;
10517
10518 case 11400: hash_type = HASH_TYPE_MD5;
10519 salt_type = SALT_TYPE_EMBEDDED;
10520 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10521 opts_type = OPTS_TYPE_PT_GENERATE_LE
10522 | OPTS_TYPE_PT_ADD80
10523 | OPTS_TYPE_HASH_COPY;
10524 kern_type = KERN_TYPE_SIP_AUTH;
10525 dgst_size = DGST_SIZE_4_4;
10526 parse_func = sip_auth_parse_hash;
10527 sort_by_digest = sort_by_digest_4_4;
10528 opti_type = OPTI_TYPE_ZERO_BYTE;
10529 dgst_pos0 = 0;
10530 dgst_pos1 = 3;
10531 dgst_pos2 = 2;
10532 dgst_pos3 = 1;
10533 break;
10534
10535 case 11500: hash_type = HASH_TYPE_CRC32;
10536 salt_type = SALT_TYPE_INTERN;
10537 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10538 opts_type = OPTS_TYPE_PT_GENERATE_LE
10539 | OPTS_TYPE_ST_GENERATE_LE
10540 | OPTS_TYPE_ST_HEX;
10541 kern_type = KERN_TYPE_CRC32;
10542 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10543 parse_func = crc32_parse_hash;
10544 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10545 opti_type = OPTI_TYPE_ZERO_BYTE;
10546 dgst_pos0 = 0;
10547 dgst_pos1 = 1;
10548 dgst_pos2 = 2;
10549 dgst_pos3 = 3;
10550 break;
10551
10552 case 11600: hash_type = HASH_TYPE_AES;
10553 salt_type = SALT_TYPE_EMBEDDED;
10554 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10555 opts_type = OPTS_TYPE_PT_GENERATE_LE
10556 | OPTS_TYPE_PT_NEVERCRACK;
10557 kern_type = KERN_TYPE_SEVEN_ZIP;
10558 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10559 parse_func = seven_zip_parse_hash;
10560 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10561 opti_type = OPTI_TYPE_ZERO_BYTE;
10562 dgst_pos0 = 0;
10563 dgst_pos1 = 1;
10564 dgst_pos2 = 2;
10565 dgst_pos3 = 3;
10566 break;
10567
10568 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10569 salt_type = SALT_TYPE_NONE;
10570 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10571 opts_type = OPTS_TYPE_PT_GENERATE_LE
10572 | OPTS_TYPE_PT_ADD01;
10573 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10574 dgst_size = DGST_SIZE_4_8;
10575 parse_func = gost2012sbog_256_parse_hash;
10576 sort_by_digest = sort_by_digest_4_8;
10577 opti_type = OPTI_TYPE_ZERO_BYTE;
10578 dgst_pos0 = 0;
10579 dgst_pos1 = 1;
10580 dgst_pos2 = 2;
10581 dgst_pos3 = 3;
10582 break;
10583
10584 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10585 salt_type = SALT_TYPE_NONE;
10586 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10587 opts_type = OPTS_TYPE_PT_GENERATE_LE
10588 | OPTS_TYPE_PT_ADD01;
10589 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10590 dgst_size = DGST_SIZE_4_16;
10591 parse_func = gost2012sbog_512_parse_hash;
10592 sort_by_digest = sort_by_digest_4_16;
10593 opti_type = OPTI_TYPE_ZERO_BYTE;
10594 dgst_pos0 = 0;
10595 dgst_pos1 = 1;
10596 dgst_pos2 = 2;
10597 dgst_pos3 = 3;
10598 break;
10599
10600 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10601 salt_type = SALT_TYPE_EMBEDDED;
10602 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10603 opts_type = OPTS_TYPE_PT_GENERATE_LE
10604 | OPTS_TYPE_ST_BASE64
10605 | OPTS_TYPE_HASH_COPY;
10606 kern_type = KERN_TYPE_PBKDF2_MD5;
10607 dgst_size = DGST_SIZE_4_32;
10608 parse_func = pbkdf2_md5_parse_hash;
10609 sort_by_digest = sort_by_digest_4_32;
10610 opti_type = OPTI_TYPE_ZERO_BYTE
10611 | OPTI_TYPE_SLOW_HASH_SIMD;
10612 dgst_pos0 = 0;
10613 dgst_pos1 = 1;
10614 dgst_pos2 = 2;
10615 dgst_pos3 = 3;
10616 break;
10617
10618 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10619 salt_type = SALT_TYPE_EMBEDDED;
10620 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10621 opts_type = OPTS_TYPE_PT_GENERATE_LE
10622 | OPTS_TYPE_ST_BASE64
10623 | OPTS_TYPE_HASH_COPY;
10624 kern_type = KERN_TYPE_PBKDF2_SHA1;
10625 dgst_size = DGST_SIZE_4_32;
10626 parse_func = pbkdf2_sha1_parse_hash;
10627 sort_by_digest = sort_by_digest_4_32;
10628 opti_type = OPTI_TYPE_ZERO_BYTE
10629 | OPTI_TYPE_SLOW_HASH_SIMD;
10630 dgst_pos0 = 0;
10631 dgst_pos1 = 1;
10632 dgst_pos2 = 2;
10633 dgst_pos3 = 3;
10634 break;
10635
10636 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10637 salt_type = SALT_TYPE_EMBEDDED;
10638 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10639 opts_type = OPTS_TYPE_PT_GENERATE_LE
10640 | OPTS_TYPE_ST_BASE64
10641 | OPTS_TYPE_HASH_COPY;
10642 kern_type = KERN_TYPE_PBKDF2_SHA512;
10643 dgst_size = DGST_SIZE_8_16;
10644 parse_func = pbkdf2_sha512_parse_hash;
10645 sort_by_digest = sort_by_digest_8_16;
10646 opti_type = OPTI_TYPE_ZERO_BYTE
10647 | OPTI_TYPE_USES_BITS_64
10648 | OPTI_TYPE_SLOW_HASH_SIMD;
10649 dgst_pos0 = 0;
10650 dgst_pos1 = 1;
10651 dgst_pos2 = 2;
10652 dgst_pos3 = 3;
10653 break;
10654
10655 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10656 salt_type = SALT_TYPE_EMBEDDED;
10657 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10658 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10659 kern_type = KERN_TYPE_ECRYPTFS;
10660 dgst_size = DGST_SIZE_8_8;
10661 parse_func = ecryptfs_parse_hash;
10662 sort_by_digest = sort_by_digest_8_8;
10663 opti_type = OPTI_TYPE_ZERO_BYTE
10664 | OPTI_TYPE_USES_BITS_64;
10665 dgst_pos0 = 0;
10666 dgst_pos1 = 1;
10667 dgst_pos2 = 2;
10668 dgst_pos3 = 3;
10669 break;
10670
10671 case 12300: hash_type = HASH_TYPE_ORACLET;
10672 salt_type = SALT_TYPE_EMBEDDED;
10673 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10674 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10675 kern_type = KERN_TYPE_ORACLET;
10676 dgst_size = DGST_SIZE_8_16;
10677 parse_func = oraclet_parse_hash;
10678 sort_by_digest = sort_by_digest_8_16;
10679 opti_type = OPTI_TYPE_ZERO_BYTE
10680 | OPTI_TYPE_USES_BITS_64;
10681 dgst_pos0 = 0;
10682 dgst_pos1 = 1;
10683 dgst_pos2 = 2;
10684 dgst_pos3 = 3;
10685 break;
10686
10687 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10688 salt_type = SALT_TYPE_EMBEDDED;
10689 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10690 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10691 kern_type = KERN_TYPE_BSDICRYPT;
10692 dgst_size = DGST_SIZE_4_4;
10693 parse_func = bsdicrypt_parse_hash;
10694 sort_by_digest = sort_by_digest_4_4;
10695 opti_type = OPTI_TYPE_ZERO_BYTE
10696 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10697 dgst_pos0 = 0;
10698 dgst_pos1 = 1;
10699 dgst_pos2 = 2;
10700 dgst_pos3 = 3;
10701 break;
10702
10703 case 12500: hash_type = HASH_TYPE_RAR3HP;
10704 salt_type = SALT_TYPE_EMBEDDED;
10705 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10706 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10707 kern_type = KERN_TYPE_RAR3;
10708 dgst_size = DGST_SIZE_4_4;
10709 parse_func = rar3hp_parse_hash;
10710 sort_by_digest = sort_by_digest_4_4;
10711 opti_type = OPTI_TYPE_ZERO_BYTE;
10712 dgst_pos0 = 0;
10713 dgst_pos1 = 1;
10714 dgst_pos2 = 2;
10715 dgst_pos3 = 3;
10716 break;
10717
10718 case 12600: hash_type = HASH_TYPE_SHA256;
10719 salt_type = SALT_TYPE_INTERN;
10720 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10721 opts_type = OPTS_TYPE_PT_GENERATE_BE
10722 | OPTS_TYPE_PT_ADD80;
10723 kern_type = KERN_TYPE_CF10;
10724 dgst_size = DGST_SIZE_4_8;
10725 parse_func = cf10_parse_hash;
10726 sort_by_digest = sort_by_digest_4_8;
10727 opti_type = OPTI_TYPE_ZERO_BYTE
10728 | OPTI_TYPE_PRECOMPUTE_INIT
10729 | OPTI_TYPE_EARLY_SKIP
10730 | OPTI_TYPE_NOT_ITERATED;
10731 dgst_pos0 = 3;
10732 dgst_pos1 = 7;
10733 dgst_pos2 = 2;
10734 dgst_pos3 = 6;
10735 break;
10736
10737 case 12700: hash_type = HASH_TYPE_AES;
10738 salt_type = SALT_TYPE_EMBEDDED;
10739 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10740 opts_type = OPTS_TYPE_PT_GENERATE_LE
10741 | OPTS_TYPE_HASH_COPY;
10742 kern_type = KERN_TYPE_MYWALLET;
10743 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10744 parse_func = mywallet_parse_hash;
10745 sort_by_digest = sort_by_digest_4_5;
10746 opti_type = OPTI_TYPE_ZERO_BYTE;
10747 dgst_pos0 = 0;
10748 dgst_pos1 = 1;
10749 dgst_pos2 = 2;
10750 dgst_pos3 = 3;
10751 break;
10752
10753 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10754 salt_type = SALT_TYPE_EMBEDDED;
10755 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10756 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10757 kern_type = KERN_TYPE_MS_DRSR;
10758 dgst_size = DGST_SIZE_4_8;
10759 parse_func = ms_drsr_parse_hash;
10760 sort_by_digest = sort_by_digest_4_8;
10761 opti_type = OPTI_TYPE_ZERO_BYTE;
10762 dgst_pos0 = 0;
10763 dgst_pos1 = 1;
10764 dgst_pos2 = 2;
10765 dgst_pos3 = 3;
10766 break;
10767
10768 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10769 salt_type = SALT_TYPE_EMBEDDED;
10770 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10771 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10772 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10773 dgst_size = DGST_SIZE_4_8;
10774 parse_func = androidfde_samsung_parse_hash;
10775 sort_by_digest = sort_by_digest_4_8;
10776 opti_type = OPTI_TYPE_ZERO_BYTE;
10777 dgst_pos0 = 0;
10778 dgst_pos1 = 1;
10779 dgst_pos2 = 2;
10780 dgst_pos3 = 3;
10781 break;
10782
10783 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10784 salt_type = SALT_TYPE_EMBEDDED;
10785 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10786 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10787 kern_type = KERN_TYPE_RAR5;
10788 dgst_size = DGST_SIZE_4_4;
10789 parse_func = rar5_parse_hash;
10790 sort_by_digest = sort_by_digest_4_4;
10791 opti_type = OPTI_TYPE_ZERO_BYTE;
10792 dgst_pos0 = 0;
10793 dgst_pos1 = 1;
10794 dgst_pos2 = 2;
10795 dgst_pos3 = 3;
10796 break;
10797
10798 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10799 salt_type = SALT_TYPE_EMBEDDED;
10800 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10801 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10802 kern_type = KERN_TYPE_KRB5TGS;
10803 dgst_size = DGST_SIZE_4_4;
10804 parse_func = krb5tgs_parse_hash;
10805 sort_by_digest = sort_by_digest_4_4;
10806 opti_type = OPTI_TYPE_ZERO_BYTE
10807 | OPTI_TYPE_NOT_ITERATED;
10808 dgst_pos0 = 0;
10809 dgst_pos1 = 1;
10810 dgst_pos2 = 2;
10811 dgst_pos3 = 3;
10812 break;
10813
10814 case 13200: hash_type = HASH_TYPE_AES;
10815 salt_type = SALT_TYPE_EMBEDDED;
10816 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10817 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10818 kern_type = KERN_TYPE_AXCRYPT;
10819 dgst_size = DGST_SIZE_4_4;
10820 parse_func = axcrypt_parse_hash;
10821 sort_by_digest = sort_by_digest_4_4;
10822 opti_type = OPTI_TYPE_ZERO_BYTE;
10823 dgst_pos0 = 0;
10824 dgst_pos1 = 1;
10825 dgst_pos2 = 2;
10826 dgst_pos3 = 3;
10827 break;
10828
10829 case 13300: hash_type = HASH_TYPE_SHA1;
10830 salt_type = SALT_TYPE_NONE;
10831 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10832 opts_type = OPTS_TYPE_PT_GENERATE_BE
10833 | OPTS_TYPE_PT_ADD80
10834 | OPTS_TYPE_PT_ADDBITS15;
10835 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10836 dgst_size = DGST_SIZE_4_5;
10837 parse_func = sha1axcrypt_parse_hash;
10838 sort_by_digest = sort_by_digest_4_5;
10839 opti_type = OPTI_TYPE_ZERO_BYTE
10840 | OPTI_TYPE_PRECOMPUTE_INIT
10841 | OPTI_TYPE_EARLY_SKIP
10842 | OPTI_TYPE_NOT_ITERATED
10843 | OPTI_TYPE_NOT_SALTED;
10844 dgst_pos0 = 0;
10845 dgst_pos1 = 4;
10846 dgst_pos2 = 3;
10847 dgst_pos3 = 2;
10848 break;
10849
10850 case 13400: hash_type = HASH_TYPE_AES;
10851 salt_type = SALT_TYPE_EMBEDDED;
10852 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10853 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10854 kern_type = KERN_TYPE_KEEPASS;
10855 dgst_size = DGST_SIZE_4_4;
10856 parse_func = keepass_parse_hash;
10857 sort_by_digest = sort_by_digest_4_4;
10858 opti_type = OPTI_TYPE_ZERO_BYTE;
10859 dgst_pos0 = 0;
10860 dgst_pos1 = 1;
10861 dgst_pos2 = 2;
10862 dgst_pos3 = 3;
10863 break;
10864
10865 case 13500: hash_type = HASH_TYPE_SHA1;
10866 salt_type = SALT_TYPE_EMBEDDED;
10867 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10868 opts_type = OPTS_TYPE_PT_GENERATE_BE
10869 | OPTS_TYPE_PT_UNICODE
10870 | OPTS_TYPE_PT_ADD80;
10871 kern_type = KERN_TYPE_PSTOKEN;
10872 dgst_size = DGST_SIZE_4_5;
10873 parse_func = pstoken_parse_hash;
10874 sort_by_digest = sort_by_digest_4_5;
10875 opti_type = OPTI_TYPE_ZERO_BYTE
10876 | OPTI_TYPE_PRECOMPUTE_INIT
10877 | OPTI_TYPE_EARLY_SKIP
10878 | OPTI_TYPE_NOT_ITERATED
10879 | OPTI_TYPE_PREPENDED_SALT
10880 | OPTI_TYPE_RAW_HASH;
10881 dgst_pos0 = 3;
10882 dgst_pos1 = 4;
10883 dgst_pos2 = 2;
10884 dgst_pos3 = 1;
10885 break;
10886
10887 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10888 salt_type = SALT_TYPE_EMBEDDED;
10889 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10890 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10891 kern_type = KERN_TYPE_ZIP2;
10892 dgst_size = DGST_SIZE_4_4;
10893 parse_func = zip2_parse_hash;
10894 sort_by_digest = sort_by_digest_4_4;
10895 opti_type = OPTI_TYPE_ZERO_BYTE;
10896 dgst_pos0 = 0;
10897 dgst_pos1 = 1;
10898 dgst_pos2 = 2;
10899 dgst_pos3 = 3;
10900 break;
10901
10902 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10903 salt_type = SALT_TYPE_EMBEDDED;
10904 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10905 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10906 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10907 dgst_size = DGST_SIZE_4_5;
10908 parse_func = veracrypt_parse_hash_655331;
10909 sort_by_digest = sort_by_digest_4_5;
10910 opti_type = OPTI_TYPE_ZERO_BYTE;
10911 dgst_pos0 = 0;
10912 dgst_pos1 = 1;
10913 dgst_pos2 = 2;
10914 dgst_pos3 = 3;
10915 break;
10916
10917 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10918 salt_type = SALT_TYPE_EMBEDDED;
10919 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10920 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10921 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10922 dgst_size = DGST_SIZE_4_5;
10923 parse_func = veracrypt_parse_hash_655331;
10924 sort_by_digest = sort_by_digest_4_5;
10925 opti_type = OPTI_TYPE_ZERO_BYTE;
10926 dgst_pos0 = 0;
10927 dgst_pos1 = 1;
10928 dgst_pos2 = 2;
10929 dgst_pos3 = 3;
10930 break;
10931
10932 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10933 salt_type = SALT_TYPE_EMBEDDED;
10934 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10935 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10936 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10937 dgst_size = DGST_SIZE_4_5;
10938 parse_func = veracrypt_parse_hash_655331;
10939 sort_by_digest = sort_by_digest_4_5;
10940 opti_type = OPTI_TYPE_ZERO_BYTE;
10941 dgst_pos0 = 0;
10942 dgst_pos1 = 1;
10943 dgst_pos2 = 2;
10944 dgst_pos3 = 3;
10945 break;
10946
10947 case 13721: hash_type = HASH_TYPE_SHA512;
10948 salt_type = SALT_TYPE_EMBEDDED;
10949 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10950 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10951 kern_type = KERN_TYPE_TCSHA512_XTS512;
10952 dgst_size = DGST_SIZE_8_8;
10953 parse_func = veracrypt_parse_hash_500000;
10954 sort_by_digest = sort_by_digest_8_8;
10955 opti_type = OPTI_TYPE_ZERO_BYTE
10956 | OPTI_TYPE_USES_BITS_64;
10957 dgst_pos0 = 0;
10958 dgst_pos1 = 1;
10959 dgst_pos2 = 2;
10960 dgst_pos3 = 3;
10961 break;
10962
10963 case 13722: hash_type = HASH_TYPE_SHA512;
10964 salt_type = SALT_TYPE_EMBEDDED;
10965 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10966 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10967 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10968 dgst_size = DGST_SIZE_8_8;
10969 parse_func = veracrypt_parse_hash_500000;
10970 sort_by_digest = sort_by_digest_8_8;
10971 opti_type = OPTI_TYPE_ZERO_BYTE
10972 | OPTI_TYPE_USES_BITS_64;
10973 dgst_pos0 = 0;
10974 dgst_pos1 = 1;
10975 dgst_pos2 = 2;
10976 dgst_pos3 = 3;
10977 break;
10978
10979 case 13723: hash_type = HASH_TYPE_SHA512;
10980 salt_type = SALT_TYPE_EMBEDDED;
10981 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10982 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10983 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10984 dgst_size = DGST_SIZE_8_8;
10985 parse_func = veracrypt_parse_hash_500000;
10986 sort_by_digest = sort_by_digest_8_8;
10987 opti_type = OPTI_TYPE_ZERO_BYTE
10988 | OPTI_TYPE_USES_BITS_64;
10989 dgst_pos0 = 0;
10990 dgst_pos1 = 1;
10991 dgst_pos2 = 2;
10992 dgst_pos3 = 3;
10993 break;
10994
10995 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10996 salt_type = SALT_TYPE_EMBEDDED;
10997 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10998 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10999 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
11000 dgst_size = DGST_SIZE_4_8;
11001 parse_func = veracrypt_parse_hash_500000;
11002 sort_by_digest = sort_by_digest_4_8;
11003 opti_type = OPTI_TYPE_ZERO_BYTE;
11004 dgst_pos0 = 0;
11005 dgst_pos1 = 1;
11006 dgst_pos2 = 2;
11007 dgst_pos3 = 3;
11008 break;
11009
11010 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
11011 salt_type = SALT_TYPE_EMBEDDED;
11012 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11013 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11014 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
11015 dgst_size = DGST_SIZE_4_8;
11016 parse_func = veracrypt_parse_hash_500000;
11017 sort_by_digest = sort_by_digest_4_8;
11018 opti_type = OPTI_TYPE_ZERO_BYTE;
11019 dgst_pos0 = 0;
11020 dgst_pos1 = 1;
11021 dgst_pos2 = 2;
11022 dgst_pos3 = 3;
11023 break;
11024
11025 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
11026 salt_type = SALT_TYPE_EMBEDDED;
11027 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11028 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11029 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
11030 dgst_size = DGST_SIZE_4_8;
11031 parse_func = veracrypt_parse_hash_500000;
11032 sort_by_digest = sort_by_digest_4_8;
11033 opti_type = OPTI_TYPE_ZERO_BYTE;
11034 dgst_pos0 = 0;
11035 dgst_pos1 = 1;
11036 dgst_pos2 = 2;
11037 dgst_pos3 = 3;
11038 break;
11039
11040 case 13741: hash_type = HASH_TYPE_RIPEMD160;
11041 salt_type = SALT_TYPE_EMBEDDED;
11042 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11043 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11044 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
11045 dgst_size = DGST_SIZE_4_5;
11046 parse_func = veracrypt_parse_hash_327661;
11047 sort_by_digest = sort_by_digest_4_5;
11048 opti_type = OPTI_TYPE_ZERO_BYTE;
11049 dgst_pos0 = 0;
11050 dgst_pos1 = 1;
11051 dgst_pos2 = 2;
11052 dgst_pos3 = 3;
11053 break;
11054
11055 case 13742: hash_type = HASH_TYPE_RIPEMD160;
11056 salt_type = SALT_TYPE_EMBEDDED;
11057 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11058 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11059 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
11060 dgst_size = DGST_SIZE_4_5;
11061 parse_func = veracrypt_parse_hash_327661;
11062 sort_by_digest = sort_by_digest_4_5;
11063 opti_type = OPTI_TYPE_ZERO_BYTE;
11064 dgst_pos0 = 0;
11065 dgst_pos1 = 1;
11066 dgst_pos2 = 2;
11067 dgst_pos3 = 3;
11068 break;
11069
11070 case 13743: hash_type = HASH_TYPE_RIPEMD160;
11071 salt_type = SALT_TYPE_EMBEDDED;
11072 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11073 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11074 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11075 dgst_size = DGST_SIZE_4_5;
11076 parse_func = veracrypt_parse_hash_327661;
11077 sort_by_digest = sort_by_digest_4_5;
11078 opti_type = OPTI_TYPE_ZERO_BYTE;
11079 dgst_pos0 = 0;
11080 dgst_pos1 = 1;
11081 dgst_pos2 = 2;
11082 dgst_pos3 = 3;
11083 break;
11084
11085 case 13751: hash_type = HASH_TYPE_SHA256;
11086 salt_type = SALT_TYPE_EMBEDDED;
11087 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11088 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11089 kern_type = KERN_TYPE_VCSHA256_XTS512;
11090 dgst_size = DGST_SIZE_4_8;
11091 parse_func = veracrypt_parse_hash_500000;
11092 sort_by_digest = sort_by_digest_4_8;
11093 opti_type = OPTI_TYPE_ZERO_BYTE;
11094 dgst_pos0 = 0;
11095 dgst_pos1 = 1;
11096 dgst_pos2 = 2;
11097 dgst_pos3 = 3;
11098 break;
11099
11100 case 13752: hash_type = HASH_TYPE_SHA256;
11101 salt_type = SALT_TYPE_EMBEDDED;
11102 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11103 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11104 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11105 dgst_size = DGST_SIZE_4_8;
11106 parse_func = veracrypt_parse_hash_500000;
11107 sort_by_digest = sort_by_digest_4_8;
11108 opti_type = OPTI_TYPE_ZERO_BYTE;
11109 dgst_pos0 = 0;
11110 dgst_pos1 = 1;
11111 dgst_pos2 = 2;
11112 dgst_pos3 = 3;
11113 break;
11114
11115 case 13753: hash_type = HASH_TYPE_SHA256;
11116 salt_type = SALT_TYPE_EMBEDDED;
11117 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11118 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11119 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11120 dgst_size = DGST_SIZE_4_8;
11121 parse_func = veracrypt_parse_hash_500000;
11122 sort_by_digest = sort_by_digest_4_8;
11123 opti_type = OPTI_TYPE_ZERO_BYTE;
11124 dgst_pos0 = 0;
11125 dgst_pos1 = 1;
11126 dgst_pos2 = 2;
11127 dgst_pos3 = 3;
11128 break;
11129
11130 case 13761: hash_type = HASH_TYPE_SHA256;
11131 salt_type = SALT_TYPE_EMBEDDED;
11132 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11133 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11134 kern_type = KERN_TYPE_VCSHA256_XTS512;
11135 dgst_size = DGST_SIZE_4_8;
11136 parse_func = veracrypt_parse_hash_200000;
11137 sort_by_digest = sort_by_digest_4_8;
11138 opti_type = OPTI_TYPE_ZERO_BYTE;
11139 dgst_pos0 = 0;
11140 dgst_pos1 = 1;
11141 dgst_pos2 = 2;
11142 dgst_pos3 = 3;
11143 break;
11144
11145 case 13762: hash_type = HASH_TYPE_SHA256;
11146 salt_type = SALT_TYPE_EMBEDDED;
11147 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11148 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11149 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11150 dgst_size = DGST_SIZE_4_8;
11151 parse_func = veracrypt_parse_hash_200000;
11152 sort_by_digest = sort_by_digest_4_8;
11153 opti_type = OPTI_TYPE_ZERO_BYTE;
11154 dgst_pos0 = 0;
11155 dgst_pos1 = 1;
11156 dgst_pos2 = 2;
11157 dgst_pos3 = 3;
11158 break;
11159
11160 case 13763: hash_type = HASH_TYPE_SHA256;
11161 salt_type = SALT_TYPE_EMBEDDED;
11162 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11163 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11164 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11165 dgst_size = DGST_SIZE_4_8;
11166 parse_func = veracrypt_parse_hash_200000;
11167 sort_by_digest = sort_by_digest_4_8;
11168 opti_type = OPTI_TYPE_ZERO_BYTE;
11169 dgst_pos0 = 0;
11170 dgst_pos1 = 1;
11171 dgst_pos2 = 2;
11172 dgst_pos3 = 3;
11173 break;
11174
11175 case 13800: hash_type = HASH_TYPE_SHA256;
11176 salt_type = SALT_TYPE_EMBEDDED;
11177 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11178 opts_type = OPTS_TYPE_PT_GENERATE_BE
11179 | OPTS_TYPE_PT_UNICODE;
11180 kern_type = KERN_TYPE_WIN8PHONE;
11181 dgst_size = DGST_SIZE_4_8;
11182 parse_func = win8phone_parse_hash;
11183 sort_by_digest = sort_by_digest_4_8;
11184 opti_type = OPTI_TYPE_ZERO_BYTE
11185 | OPTI_TYPE_PRECOMPUTE_INIT
11186 | OPTI_TYPE_EARLY_SKIP
11187 | OPTI_TYPE_NOT_ITERATED
11188 | OPTI_TYPE_RAW_HASH;
11189 dgst_pos0 = 3;
11190 dgst_pos1 = 7;
11191 dgst_pos2 = 2;
11192 dgst_pos3 = 6;
11193 break;
11194
11195 default: usage_mini_print (PROGNAME); return (-1);
11196 }
11197
11198 /**
11199 * parser
11200 */
11201
11202 data.parse_func = parse_func;
11203
11204 /**
11205 * misc stuff
11206 */
11207
11208 if (hex_salt)
11209 {
11210 if (salt_type == SALT_TYPE_INTERN)
11211 {
11212 opts_type |= OPTS_TYPE_ST_HEX;
11213 }
11214 else
11215 {
11216 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11217
11218 return (-1);
11219 }
11220 }
11221
11222 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11223 | (salt_type == SALT_TYPE_EXTERN)
11224 | (salt_type == SALT_TYPE_EMBEDDED)
11225 | (salt_type == SALT_TYPE_VIRTUAL));
11226
11227 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
11228
11229 data.hash_type = hash_type;
11230 data.attack_mode = attack_mode;
11231 data.attack_kern = attack_kern;
11232 data.attack_exec = attack_exec;
11233 data.kern_type = kern_type;
11234 data.opts_type = opts_type;
11235 data.dgst_size = dgst_size;
11236 data.salt_type = salt_type;
11237 data.isSalted = isSalted;
11238 data.sort_by_digest = sort_by_digest;
11239 data.dgst_pos0 = dgst_pos0;
11240 data.dgst_pos1 = dgst_pos1;
11241 data.dgst_pos2 = dgst_pos2;
11242 data.dgst_pos3 = dgst_pos3;
11243
11244 esalt_size = 0;
11245
11246 switch (hash_mode)
11247 {
11248 case 2500: esalt_size = sizeof (wpa_t); break;
11249 case 5300: esalt_size = sizeof (ikepsk_t); break;
11250 case 5400: esalt_size = sizeof (ikepsk_t); break;
11251 case 5500: esalt_size = sizeof (netntlm_t); break;
11252 case 5600: esalt_size = sizeof (netntlm_t); break;
11253 case 6211: esalt_size = sizeof (tc_t); break;
11254 case 6212: esalt_size = sizeof (tc_t); break;
11255 case 6213: esalt_size = sizeof (tc_t); break;
11256 case 6221: esalt_size = sizeof (tc_t); break;
11257 case 6222: esalt_size = sizeof (tc_t); break;
11258 case 6223: esalt_size = sizeof (tc_t); break;
11259 case 6231: esalt_size = sizeof (tc_t); break;
11260 case 6232: esalt_size = sizeof (tc_t); break;
11261 case 6233: esalt_size = sizeof (tc_t); break;
11262 case 6241: esalt_size = sizeof (tc_t); break;
11263 case 6242: esalt_size = sizeof (tc_t); break;
11264 case 6243: esalt_size = sizeof (tc_t); break;
11265 case 6600: esalt_size = sizeof (agilekey_t); break;
11266 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11267 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
11268 case 7300: esalt_size = sizeof (rakp_t); break;
11269 case 7500: esalt_size = sizeof (krb5pa_t); break;
11270 case 8200: esalt_size = sizeof (cloudkey_t); break;
11271 case 8800: esalt_size = sizeof (androidfde_t); break;
11272 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
11273 case 9400: esalt_size = sizeof (office2007_t); break;
11274 case 9500: esalt_size = sizeof (office2010_t); break;
11275 case 9600: esalt_size = sizeof (office2013_t); break;
11276 case 9700: esalt_size = sizeof (oldoffice01_t); break;
11277 case 9710: esalt_size = sizeof (oldoffice01_t); break;
11278 case 9720: esalt_size = sizeof (oldoffice01_t); break;
11279 case 9800: esalt_size = sizeof (oldoffice34_t); break;
11280 case 9810: esalt_size = sizeof (oldoffice34_t); break;
11281 case 9820: esalt_size = sizeof (oldoffice34_t); break;
11282 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
11283 case 10200: esalt_size = sizeof (cram_md5_t); break;
11284 case 10400: esalt_size = sizeof (pdf_t); break;
11285 case 10410: esalt_size = sizeof (pdf_t); break;
11286 case 10420: esalt_size = sizeof (pdf_t); break;
11287 case 10500: esalt_size = sizeof (pdf_t); break;
11288 case 10600: esalt_size = sizeof (pdf_t); break;
11289 case 10700: esalt_size = sizeof (pdf_t); break;
11290 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
11291 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
11292 case 11400: esalt_size = sizeof (sip_t); break;
11293 case 11600: esalt_size = sizeof (seven_zip_t); break;
11294 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
11295 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
11296 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11297 case 13000: esalt_size = sizeof (rar5_t); break;
11298 case 13100: esalt_size = sizeof (krb5tgs_t); break;
11299 case 13400: esalt_size = sizeof (keepass_t); break;
11300 case 13500: esalt_size = sizeof (pstoken_t); break;
11301 case 13600: esalt_size = sizeof (zip2_t); break;
11302 case 13711: esalt_size = sizeof (tc_t); break;
11303 case 13712: esalt_size = sizeof (tc_t); break;
11304 case 13713: esalt_size = sizeof (tc_t); break;
11305 case 13721: esalt_size = sizeof (tc_t); break;
11306 case 13722: esalt_size = sizeof (tc_t); break;
11307 case 13723: esalt_size = sizeof (tc_t); break;
11308 case 13731: esalt_size = sizeof (tc_t); break;
11309 case 13732: esalt_size = sizeof (tc_t); break;
11310 case 13733: esalt_size = sizeof (tc_t); break;
11311 case 13741: esalt_size = sizeof (tc_t); break;
11312 case 13742: esalt_size = sizeof (tc_t); break;
11313 case 13743: esalt_size = sizeof (tc_t); break;
11314 case 13751: esalt_size = sizeof (tc_t); break;
11315 case 13752: esalt_size = sizeof (tc_t); break;
11316 case 13753: esalt_size = sizeof (tc_t); break;
11317 case 13761: esalt_size = sizeof (tc_t); break;
11318 case 13762: esalt_size = sizeof (tc_t); break;
11319 case 13763: esalt_size = sizeof (tc_t); break;
11320 case 13800: esalt_size = sizeof (win8phone_t); break;
11321 }
11322
11323 data.esalt_size = esalt_size;
11324
11325 /**
11326 * choose dictionary parser
11327 */
11328
11329 if (hash_type == HASH_TYPE_LM)
11330 {
11331 get_next_word_func = get_next_word_lm;
11332 }
11333 else if (opts_type & OPTS_TYPE_PT_UPPER)
11334 {
11335 get_next_word_func = get_next_word_uc;
11336 }
11337 else
11338 {
11339 get_next_word_func = get_next_word_std;
11340 }
11341
11342 /**
11343 * dictstat
11344 */
11345
11346 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11347
11348 #ifdef _POSIX
11349 size_t dictstat_nmemb = 0;
11350 #endif
11351
11352 #ifdef _WIN
11353 uint dictstat_nmemb = 0;
11354 #endif
11355
11356 char dictstat[256] = { 0 };
11357
11358 FILE *dictstat_fp = NULL;
11359
11360 if (keyspace == 0)
11361 {
11362 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11363
11364 dictstat_fp = fopen (dictstat, "rb");
11365
11366 if (dictstat_fp)
11367 {
11368 #ifdef _POSIX
11369 struct stat tmpstat;
11370
11371 fstat (fileno (dictstat_fp), &tmpstat);
11372 #endif
11373
11374 #ifdef _WIN
11375 struct stat64 tmpstat;
11376
11377 _fstat64 (fileno (dictstat_fp), &tmpstat);
11378 #endif
11379
11380 if (tmpstat.st_mtime < COMPTIME)
11381 {
11382 /* with v0.15 the format changed so we have to ensure user is using a good version
11383 since there is no version-header in the dictstat file */
11384
11385 fclose (dictstat_fp);
11386
11387 unlink (dictstat);
11388 }
11389 else
11390 {
11391 while (!feof (dictstat_fp))
11392 {
11393 dictstat_t d;
11394
11395 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11396
11397 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11398
11399 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11400 {
11401 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11402
11403 return -1;
11404 }
11405 }
11406
11407 fclose (dictstat_fp);
11408 }
11409 }
11410 }
11411
11412 /**
11413 * potfile
11414 */
11415
11416 char potfile[256] = { 0 };
11417
11418 if (potfile_path == NULL)
11419 {
11420 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11421 }
11422 else
11423 {
11424 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11425 }
11426
11427 data.pot_fp = NULL;
11428
11429 FILE *out_fp = NULL;
11430 FILE *pot_fp = NULL;
11431
11432 if (show == 1 || left == 1)
11433 {
11434 pot_fp = fopen (potfile, "rb");
11435
11436 if (pot_fp == NULL)
11437 {
11438 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11439
11440 return (-1);
11441 }
11442
11443 if (outfile != NULL)
11444 {
11445 if ((out_fp = fopen (outfile, "ab")) == NULL)
11446 {
11447 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11448
11449 fclose (pot_fp);
11450
11451 return (-1);
11452 }
11453 }
11454 else
11455 {
11456 out_fp = stdout;
11457 }
11458 }
11459 else
11460 {
11461 if (potfile_disable == 0)
11462 {
11463 pot_fp = fopen (potfile, "ab");
11464
11465 if (pot_fp == NULL)
11466 {
11467 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11468
11469 return (-1);
11470 }
11471
11472 data.pot_fp = pot_fp;
11473 }
11474 }
11475
11476 pot_t *pot = NULL;
11477
11478 uint pot_cnt = 0;
11479 uint pot_avail = 0;
11480
11481 if (show == 1 || left == 1)
11482 {
11483 SUPPRESS_OUTPUT = 1;
11484
11485 pot_avail = count_lines (pot_fp);
11486
11487 rewind (pot_fp);
11488
11489 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11490
11491 uint pot_hashes_avail = 0;
11492
11493 uint line_num = 0;
11494
11495 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11496
11497 while (!feof (pot_fp))
11498 {
11499 line_num++;
11500
11501 int line_len = fgetl (pot_fp, line_buf);
11502
11503 if (line_len == 0) continue;
11504
11505 char *plain_buf = line_buf + line_len;
11506
11507 pot_t *pot_ptr = &pot[pot_cnt];
11508
11509 hash_t *hashes_buf = &pot_ptr->hash;
11510
11511 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11512 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11513
11514 if (pot_cnt == pot_hashes_avail)
11515 {
11516 uint pos = 0;
11517
11518 for (pos = 0; pos < INCR_POT; pos++)
11519 {
11520 if ((pot_cnt + pos) >= pot_avail) break;
11521
11522 pot_t *tmp_pot = &pot[pot_cnt + pos];
11523
11524 hash_t *tmp_hash = &tmp_pot->hash;
11525
11526 tmp_hash->digest = mymalloc (dgst_size);
11527
11528 if (isSalted)
11529 {
11530 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11531 }
11532
11533 if (esalt_size)
11534 {
11535 tmp_hash->esalt = mymalloc (esalt_size);
11536 }
11537
11538 pot_hashes_avail++;
11539 }
11540 }
11541
11542 int plain_len = 0;
11543
11544 int parser_status;
11545
11546 int iter = MAX_CUT_TRIES;
11547
11548 do
11549 {
11550 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11551 {
11552 if (line_buf[i] == ':')
11553 {
11554 line_len--;
11555
11556 break;
11557 }
11558 }
11559
11560 if (data.hash_mode != 2500)
11561 {
11562 parser_status = parse_func (line_buf, line_len, hashes_buf);
11563 }
11564 else
11565 {
11566 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11567
11568 if (line_len > max_salt_size)
11569 {
11570 parser_status = PARSER_GLOBAL_LENGTH;
11571 }
11572 else
11573 {
11574 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11575
11576 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11577
11578 hashes_buf->salt->salt_len = line_len;
11579
11580 parser_status = PARSER_OK;
11581 }
11582 }
11583
11584 // if NOT parsed without error, we add the ":" to the plain
11585
11586 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11587 {
11588 plain_len++;
11589 plain_buf--;
11590 }
11591
11592 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11593
11594 if (parser_status < PARSER_GLOBAL_ZERO)
11595 {
11596 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11597
11598 continue;
11599 }
11600
11601 if (plain_len >= 255) continue;
11602
11603 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11604
11605 pot_ptr->plain_len = plain_len;
11606
11607 pot_cnt++;
11608 }
11609
11610 myfree (line_buf);
11611
11612 fclose (pot_fp);
11613
11614 SUPPRESS_OUTPUT = 0;
11615
11616 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11617 }
11618
11619 /**
11620 * word len
11621 */
11622
11623 uint pw_min = PW_MIN;
11624 uint pw_max = PW_MAX;
11625
11626 switch (hash_mode)
11627 {
11628 case 125: if (pw_max > 32) pw_max = 32;
11629 break;
11630 case 400: if (pw_max > 40) pw_max = 40;
11631 break;
11632 case 500: if (pw_max > 16) pw_max = 16;
11633 break;
11634 case 1500: if (pw_max > 8) pw_max = 8;
11635 break;
11636 case 1600: if (pw_max > 16) pw_max = 16;
11637 break;
11638 case 1800: if (pw_max > 16) pw_max = 16;
11639 break;
11640 case 2100: if (pw_max > 16) pw_max = 16;
11641 break;
11642 case 2500: if (pw_min < 8) pw_min = 8;
11643 break;
11644 case 3000: if (pw_max > 7) pw_max = 7;
11645 break;
11646 case 5200: if (pw_max > 24) pw_max = 24;
11647 break;
11648 case 5800: if (pw_max > 16) pw_max = 16;
11649 break;
11650 case 6300: if (pw_max > 16) pw_max = 16;
11651 break;
11652 case 7400: if (pw_max > 16) pw_max = 16;
11653 break;
11654 case 7700: if (pw_max > 8) pw_max = 8;
11655 break;
11656 case 7900: if (pw_max > 48) pw_max = 48;
11657 break;
11658 case 8500: if (pw_max > 8) pw_max = 8;
11659 break;
11660 case 8600: if (pw_max > 16) pw_max = 16;
11661 break;
11662 case 9710: pw_min = 5;
11663 pw_max = 5;
11664 break;
11665 case 9810: pw_min = 5;
11666 pw_max = 5;
11667 break;
11668 case 10410: pw_min = 5;
11669 pw_max = 5;
11670 break;
11671 case 10300: if (pw_max < 3) pw_min = 3;
11672 if (pw_max > 40) pw_max = 40;
11673 break;
11674 case 10500: if (pw_max < 3) pw_min = 3;
11675 if (pw_max > 40) pw_max = 40;
11676 break;
11677 case 10700: if (pw_max > 16) pw_max = 16;
11678 break;
11679 case 11300: if (pw_max > 40) pw_max = 40;
11680 break;
11681 case 11600: if (pw_max > 32) pw_max = 32;
11682 break;
11683 case 12500: if (pw_max > 20) pw_max = 20;
11684 break;
11685 case 12800: if (pw_max > 24) pw_max = 24;
11686 break;
11687 }
11688
11689 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11690 {
11691 switch (attack_kern)
11692 {
11693 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11694 break;
11695 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11696 break;
11697 }
11698 }
11699
11700 /**
11701 * charsets : keep them together for more easy maintainnce
11702 */
11703
11704 cs_t mp_sys[6] = { { { 0 }, 0 } };
11705 cs_t mp_usr[4] = { { { 0 }, 0 } };
11706
11707 mp_setup_sys (mp_sys);
11708
11709 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11710 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11711 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11712 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11713
11714 /**
11715 * load hashes, part I: find input mode, count hashes
11716 */
11717
11718 uint hashlist_mode = 0;
11719 uint hashlist_format = HLFMT_HASHCAT;
11720
11721 uint hashes_avail = 0;
11722
11723 if ((benchmark == 0) && (stdout_flag == 0))
11724 {
11725 struct stat f;
11726
11727 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11728
11729 if ((hash_mode == 2500) ||
11730 (hash_mode == 5200) ||
11731 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11732 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11733 (hash_mode == 9000))
11734 {
11735 hashlist_mode = HL_MODE_ARG;
11736
11737 char *hashfile = myargv[optind];
11738
11739 data.hashfile = hashfile;
11740
11741 logfile_top_var_string ("target", hashfile);
11742 }
11743
11744 if (hashlist_mode == HL_MODE_ARG)
11745 {
11746 if (hash_mode == 2500)
11747 {
11748 struct stat st;
11749
11750 if (stat (data.hashfile, &st) == -1)
11751 {
11752 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11753
11754 return (-1);
11755 }
11756
11757 hashes_avail = st.st_size / sizeof (hccap_t);
11758 }
11759 else
11760 {
11761 hashes_avail = 1;
11762 }
11763 }
11764 else if (hashlist_mode == HL_MODE_FILE)
11765 {
11766 char *hashfile = myargv[optind];
11767
11768 data.hashfile = hashfile;
11769
11770 logfile_top_var_string ("target", hashfile);
11771
11772 FILE *fp = NULL;
11773
11774 if ((fp = fopen (hashfile, "rb")) == NULL)
11775 {
11776 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11777
11778 return (-1);
11779 }
11780
11781 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11782
11783 hashes_avail = count_lines (fp);
11784
11785 rewind (fp);
11786
11787 if (hashes_avail == 0)
11788 {
11789 log_error ("ERROR: hashfile is empty or corrupt");
11790
11791 fclose (fp);
11792
11793 return (-1);
11794 }
11795
11796 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11797
11798 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11799 {
11800 log_error ("ERROR: remove not supported in native hashfile-format mode");
11801
11802 fclose (fp);
11803
11804 return (-1);
11805 }
11806
11807 fclose (fp);
11808 }
11809 }
11810 else
11811 {
11812 hashlist_mode = HL_MODE_ARG;
11813
11814 hashes_avail = 1;
11815 }
11816
11817 if (hash_mode == 3000) hashes_avail *= 2;
11818
11819 data.hashlist_mode = hashlist_mode;
11820 data.hashlist_format = hashlist_format;
11821
11822 logfile_top_uint (hashlist_mode);
11823 logfile_top_uint (hashlist_format);
11824
11825 /**
11826 * load hashes, part II: allocate required memory, set pointers
11827 */
11828
11829 hash_t *hashes_buf = NULL;
11830 void *digests_buf = NULL;
11831 salt_t *salts_buf = NULL;
11832 void *esalts_buf = NULL;
11833
11834 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11835
11836 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11837
11838 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11839 {
11840 u32 hash_pos;
11841
11842 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11843 {
11844 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11845
11846 hashes_buf[hash_pos].hash_info = hash_info;
11847
11848 if (username && (remove || show || left))
11849 {
11850 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11851 }
11852
11853 if (benchmark)
11854 {
11855 hash_info->orighash = (char *) mymalloc (256);
11856 }
11857 }
11858 }
11859
11860 if (isSalted)
11861 {
11862 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11863
11864 if (esalt_size)
11865 {
11866 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11867 }
11868 }
11869 else
11870 {
11871 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11872 }
11873
11874 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11875 {
11876 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11877
11878 if (isSalted)
11879 {
11880 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11881
11882 if (esalt_size)
11883 {
11884 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11885 }
11886 }
11887 else
11888 {
11889 hashes_buf[hash_pos].salt = &salts_buf[0];
11890 }
11891 }
11892
11893 /**
11894 * load hashes, part III: parse hashes or generate them if benchmark
11895 */
11896
11897 uint hashes_cnt = 0;
11898
11899 if (benchmark == 0)
11900 {
11901 if (keyspace == 1)
11902 {
11903 // useless to read hash file for keyspace, cheat a little bit w/ optind
11904 }
11905 else if (stdout_flag == 1)
11906 {
11907 // useless to read hash file for stdout, cheat a little bit w/ optind
11908 }
11909 else if (hashes_avail == 0)
11910 {
11911 }
11912 else if (hashlist_mode == HL_MODE_ARG)
11913 {
11914 char *input_buf = myargv[optind];
11915
11916 uint input_len = strlen (input_buf);
11917
11918 logfile_top_var_string ("target", input_buf);
11919
11920 char *hash_buf = NULL;
11921 int hash_len = 0;
11922
11923 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11924
11925 bool hash_fmt_error = 0;
11926
11927 if (hash_len < 1) hash_fmt_error = 1;
11928 if (hash_buf == NULL) hash_fmt_error = 1;
11929
11930 if (hash_fmt_error)
11931 {
11932 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11933 }
11934 else
11935 {
11936 if (opts_type & OPTS_TYPE_HASH_COPY)
11937 {
11938 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11939
11940 hash_info_tmp->orighash = mystrdup (hash_buf);
11941 }
11942
11943 if (isSalted)
11944 {
11945 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11946 }
11947
11948 int parser_status = PARSER_OK;
11949
11950 if (hash_mode == 2500)
11951 {
11952 if (hash_len == 0)
11953 {
11954 log_error ("ERROR: hccap file not specified");
11955
11956 return (-1);
11957 }
11958
11959 hashlist_mode = HL_MODE_FILE;
11960
11961 data.hashlist_mode = hashlist_mode;
11962
11963 FILE *fp = fopen (hash_buf, "rb");
11964
11965 if (fp == NULL)
11966 {
11967 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11968
11969 return (-1);
11970 }
11971
11972 if (hashes_avail < 1)
11973 {
11974 log_error ("ERROR: hccap file is empty or corrupt");
11975
11976 fclose (fp);
11977
11978 return (-1);
11979 }
11980
11981 uint hccap_size = sizeof (hccap_t);
11982
11983 char *in = (char *) mymalloc (hccap_size);
11984
11985 while (!feof (fp))
11986 {
11987 int n = fread (in, hccap_size, 1, fp);
11988
11989 if (n != 1)
11990 {
11991 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11992
11993 break;
11994 }
11995
11996 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11997
11998 if (parser_status != PARSER_OK)
11999 {
12000 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
12001
12002 continue;
12003 }
12004
12005 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
12006
12007 if ((show == 1) || (left == 1))
12008 {
12009 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
12010
12011 char *salt_ptr = (char *) tmp_salt->salt_buf;
12012
12013 int cur_pos = tmp_salt->salt_len;
12014 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12015
12016 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
12017
12018 // do the appending task
12019
12020 snprintf (salt_ptr + cur_pos,
12021 rem_len,
12022 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
12023 wpa->orig_mac1[0],
12024 wpa->orig_mac1[1],
12025 wpa->orig_mac1[2],
12026 wpa->orig_mac1[3],
12027 wpa->orig_mac1[4],
12028 wpa->orig_mac1[5],
12029 wpa->orig_mac2[0],
12030 wpa->orig_mac2[1],
12031 wpa->orig_mac2[2],
12032 wpa->orig_mac2[3],
12033 wpa->orig_mac2[4],
12034 wpa->orig_mac2[5]);
12035
12036 // memset () the remaining part of the salt
12037
12038 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
12039 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12040
12041 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
12042
12043 tmp_salt->salt_len += 1 + 12 + 1 + 12;
12044 }
12045
12046 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);
12047 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);
12048
12049 hashes_cnt++;
12050 }
12051
12052 fclose (fp);
12053
12054 myfree (in);
12055 }
12056 else if (hash_mode == 3000)
12057 {
12058 if (hash_len == 32)
12059 {
12060 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12061
12062 hash_t *lm_hash_left = NULL;
12063
12064 if (parser_status == PARSER_OK)
12065 {
12066 lm_hash_left = &hashes_buf[hashes_cnt];
12067
12068 hashes_cnt++;
12069 }
12070 else
12071 {
12072 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12073 }
12074
12075 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12076
12077 hash_t *lm_hash_right = NULL;
12078
12079 if (parser_status == PARSER_OK)
12080 {
12081 lm_hash_right = &hashes_buf[hashes_cnt];
12082
12083 hashes_cnt++;
12084 }
12085 else
12086 {
12087 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12088 }
12089
12090 // show / left
12091
12092 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12093 {
12094 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);
12095 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);
12096 }
12097 }
12098 else
12099 {
12100 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12101
12102 if (parser_status == PARSER_OK)
12103 {
12104 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12105 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12106 }
12107
12108 if (parser_status == PARSER_OK)
12109 {
12110 hashes_cnt++;
12111 }
12112 else
12113 {
12114 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12115 }
12116 }
12117 }
12118 else
12119 {
12120 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12121
12122 if (parser_status == PARSER_OK)
12123 {
12124 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12125 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12126 }
12127
12128 if (parser_status == PARSER_OK)
12129 {
12130 hashes_cnt++;
12131 }
12132 else
12133 {
12134 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12135 }
12136 }
12137 }
12138 }
12139 else if (hashlist_mode == HL_MODE_FILE)
12140 {
12141 char *hashfile = data.hashfile;
12142
12143 FILE *fp;
12144
12145 if ((fp = fopen (hashfile, "rb")) == NULL)
12146 {
12147 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12148
12149 return (-1);
12150 }
12151
12152 uint line_num = 0;
12153
12154 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12155
12156 while (!feof (fp))
12157 {
12158 line_num++;
12159
12160 int line_len = fgetl (fp, line_buf);
12161
12162 if (line_len == 0) continue;
12163
12164 char *hash_buf = NULL;
12165 int hash_len = 0;
12166
12167 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12168
12169 bool hash_fmt_error = 0;
12170
12171 if (hash_len < 1) hash_fmt_error = 1;
12172 if (hash_buf == NULL) hash_fmt_error = 1;
12173
12174 if (hash_fmt_error)
12175 {
12176 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12177
12178 continue;
12179 }
12180
12181 if (username)
12182 {
12183 char *user_buf = NULL;
12184 int user_len = 0;
12185
12186 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12187
12188 if (remove || show)
12189 {
12190 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12191
12192 *user = (user_t *) mymalloc (sizeof (user_t));
12193
12194 user_t *user_ptr = *user;
12195
12196 if (user_buf != NULL)
12197 {
12198 user_ptr->user_name = mystrdup (user_buf);
12199 }
12200 else
12201 {
12202 user_ptr->user_name = mystrdup ("");
12203 }
12204
12205 user_ptr->user_len = user_len;
12206 }
12207 }
12208
12209 if (opts_type & OPTS_TYPE_HASH_COPY)
12210 {
12211 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12212
12213 hash_info_tmp->orighash = mystrdup (hash_buf);
12214 }
12215
12216 if (isSalted)
12217 {
12218 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12219 }
12220
12221 if (hash_mode == 3000)
12222 {
12223 if (hash_len == 32)
12224 {
12225 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12226
12227 if (parser_status < PARSER_GLOBAL_ZERO)
12228 {
12229 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12230
12231 continue;
12232 }
12233
12234 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12235
12236 hashes_cnt++;
12237
12238 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12239
12240 if (parser_status < PARSER_GLOBAL_ZERO)
12241 {
12242 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12243
12244 continue;
12245 }
12246
12247 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12248
12249 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);
12250
12251 hashes_cnt++;
12252
12253 // show / left
12254
12255 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);
12256 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);
12257 }
12258 else
12259 {
12260 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12261
12262 if (parser_status < PARSER_GLOBAL_ZERO)
12263 {
12264 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12265
12266 continue;
12267 }
12268
12269 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);
12270
12271 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12272 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12273
12274 hashes_cnt++;
12275 }
12276 }
12277 else
12278 {
12279 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12280
12281 if (parser_status < PARSER_GLOBAL_ZERO)
12282 {
12283 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12284
12285 continue;
12286 }
12287
12288 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);
12289
12290 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12291 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12292
12293 hashes_cnt++;
12294 }
12295 }
12296
12297 myfree (line_buf);
12298
12299 fclose (fp);
12300
12301 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12302
12303 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12304 }
12305 }
12306 else
12307 {
12308 if (isSalted)
12309 {
12310 hashes_buf[0].salt->salt_len = 8;
12311
12312 // special salt handling
12313
12314 switch (hash_mode)
12315 {
12316 case 1500: hashes_buf[0].salt->salt_len = 2;
12317 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12318 break;
12319 case 1731: hashes_buf[0].salt->salt_len = 4;
12320 break;
12321 case 2410: hashes_buf[0].salt->salt_len = 4;
12322 break;
12323 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12324 break;
12325 case 3100: hashes_buf[0].salt->salt_len = 1;
12326 break;
12327 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
12328 break;
12329 case 5800: hashes_buf[0].salt->salt_len = 16;
12330 break;
12331 case 6800: hashes_buf[0].salt->salt_len = 32;
12332 break;
12333 case 8400: hashes_buf[0].salt->salt_len = 40;
12334 break;
12335 case 8800: hashes_buf[0].salt->salt_len = 16;
12336 break;
12337 case 8900: hashes_buf[0].salt->salt_len = 16;
12338 hashes_buf[0].salt->scrypt_N = 1024;
12339 hashes_buf[0].salt->scrypt_r = 1;
12340 hashes_buf[0].salt->scrypt_p = 1;
12341 break;
12342 case 9100: hashes_buf[0].salt->salt_len = 16;
12343 break;
12344 case 9300: hashes_buf[0].salt->salt_len = 14;
12345 hashes_buf[0].salt->scrypt_N = 16384;
12346 hashes_buf[0].salt->scrypt_r = 1;
12347 hashes_buf[0].salt->scrypt_p = 1;
12348 break;
12349 case 9400: hashes_buf[0].salt->salt_len = 16;
12350 break;
12351 case 9500: hashes_buf[0].salt->salt_len = 16;
12352 break;
12353 case 9600: hashes_buf[0].salt->salt_len = 16;
12354 break;
12355 case 9700: hashes_buf[0].salt->salt_len = 16;
12356 break;
12357 case 9710: hashes_buf[0].salt->salt_len = 16;
12358 break;
12359 case 9720: hashes_buf[0].salt->salt_len = 16;
12360 break;
12361 case 9800: hashes_buf[0].salt->salt_len = 16;
12362 break;
12363 case 9810: hashes_buf[0].salt->salt_len = 16;
12364 break;
12365 case 9820: hashes_buf[0].salt->salt_len = 16;
12366 break;
12367 case 10300: hashes_buf[0].salt->salt_len = 12;
12368 break;
12369 case 11500: hashes_buf[0].salt->salt_len = 4;
12370 break;
12371 case 11600: hashes_buf[0].salt->salt_len = 4;
12372 break;
12373 case 12400: hashes_buf[0].salt->salt_len = 4;
12374 break;
12375 case 12500: hashes_buf[0].salt->salt_len = 8;
12376 break;
12377 case 12600: hashes_buf[0].salt->salt_len = 64;
12378 break;
12379 }
12380
12381 // special esalt handling
12382
12383 switch (hash_mode)
12384 {
12385 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12386 break;
12387 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12388 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12389 break;
12390 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12391 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12392 break;
12393 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12394 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12395 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12396 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12397 break;
12398 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12399 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12400 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12401 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12402 break;
12403 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12404 break;
12405 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12406 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12407 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12408 break;
12409 case 10410: ((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 10420: ((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 10500: ((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 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12422 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12423 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12424 break;
12425 case 10700: ((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 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12430 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12431 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12432 break;
12433 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12434 break;
12435 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12436 break;
12437 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12438 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12439 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12440 break;
12441 }
12442 }
12443
12444 // set hashfile
12445
12446 switch (hash_mode)
12447 {
12448 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12449 break;
12450 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12451 break;
12452 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12453 break;
12454 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12455 break;
12456 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12457 break;
12458 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12459 break;
12460 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12461 break;
12462 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12463 break;
12464 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12465 break;
12466 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12467 break;
12468 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12469 break;
12470 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12471 break;
12472 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12473 break;
12474 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12475 break;
12476 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12477 break;
12478 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12479 break;
12480 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12481 break;
12482 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12483 break;
12484 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12485 break;
12486 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12487 break;
12488 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12489 break;
12490 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12491 break;
12492 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12493 break;
12494 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12495 break;
12496 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12497 break;
12498 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12499 break;
12500 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12501 break;
12502 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12503 break;
12504 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12505 break;
12506 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12507 break;
12508 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12509 break;
12510 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12511 break;
12512 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12513 break;
12514 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12515 break;
12516 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12517 break;
12518 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12519 break;
12520 }
12521
12522 // set default iterations
12523
12524 switch (hash_mode)
12525 {
12526 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12527 break;
12528 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12529 break;
12530 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12531 break;
12532 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12533 break;
12534 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12535 break;
12536 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12537 break;
12538 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12539 break;
12540 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12541 break;
12542 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12543 break;
12544 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12545 break;
12546 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12547 break;
12548 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12549 break;
12550 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12551 break;
12552 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12553 break;
12554 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12555 break;
12556 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12557 break;
12558 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12559 break;
12560 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12561 break;
12562 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12563 break;
12564 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12565 break;
12566 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12567 break;
12568 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12569 break;
12570 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12571 break;
12572 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12573 break;
12574 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12575 break;
12576 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12577 break;
12578 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12579 break;
12580 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12581 break;
12582 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12583 break;
12584 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12585 break;
12586 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12587 break;
12588 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12589 break;
12590 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12591 break;
12592 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12593 break;
12594 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12595 break;
12596 case 8900: hashes_buf[0].salt->salt_iter = 1;
12597 break;
12598 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12599 break;
12600 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12601 break;
12602 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12603 break;
12604 case 9300: hashes_buf[0].salt->salt_iter = 1;
12605 break;
12606 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12607 break;
12608 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12609 break;
12610 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12611 break;
12612 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12613 break;
12614 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12615 break;
12616 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12617 break;
12618 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12619 break;
12620 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12621 break;
12622 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12623 break;
12624 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12625 break;
12626 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12627 break;
12628 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12629 break;
12630 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12631 break;
12632 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12633 break;
12634 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12635 break;
12636 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12637 break;
12638 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12639 break;
12640 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12641 break;
12642 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12643 break;
12644 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12645 break;
12646 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12647 break;
12648 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12649 break;
12650 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12651 break;
12652 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12653 break;
12654 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12655 break;
12656 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12657 break;
12658 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12659 break;
12660 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12661 break;
12662 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12663 break;
12664 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12665 break;
12666 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12667 break;
12668 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12669 break;
12670 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12671 break;
12672 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12673 break;
12674 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12675 break;
12676 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12677 break;
12678 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12679 break;
12680 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12681 break;
12682 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12683 break;
12684 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12685 break;
12686 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12687 break;
12688 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12689 break;
12690 }
12691
12692 hashes_cnt = 1;
12693 }
12694
12695 if (show == 1 || left == 1)
12696 {
12697 for (uint i = 0; i < pot_cnt; i++)
12698 {
12699 pot_t *pot_ptr = &pot[i];
12700
12701 hash_t *hashes_buf = &pot_ptr->hash;
12702
12703 local_free (hashes_buf->digest);
12704
12705 if (isSalted)
12706 {
12707 local_free (hashes_buf->salt);
12708 }
12709 }
12710
12711 local_free (pot);
12712
12713 if (data.quiet == 0) log_info_nn ("");
12714
12715 return (0);
12716 }
12717
12718 if ((keyspace == 0) && (stdout_flag == 0))
12719 {
12720 if (hashes_cnt == 0)
12721 {
12722 log_error ("ERROR: No hashes loaded");
12723
12724 return (-1);
12725 }
12726 }
12727
12728 /**
12729 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12730 */
12731
12732 if (data.outfile != NULL)
12733 {
12734 if (data.hashfile != NULL)
12735 {
12736 #ifdef _POSIX
12737 struct stat tmpstat_outfile;
12738 struct stat tmpstat_hashfile;
12739 #endif
12740
12741 #ifdef _WIN
12742 struct stat64 tmpstat_outfile;
12743 struct stat64 tmpstat_hashfile;
12744 #endif
12745
12746 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12747
12748 if (tmp_outfile_fp)
12749 {
12750 #ifdef _POSIX
12751 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12752 #endif
12753
12754 #ifdef _WIN
12755 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12756 #endif
12757
12758 fclose (tmp_outfile_fp);
12759 }
12760
12761 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12762
12763 if (tmp_hashfile_fp)
12764 {
12765 #ifdef _POSIX
12766 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12767 #endif
12768
12769 #ifdef _WIN
12770 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12771 #endif
12772
12773 fclose (tmp_hashfile_fp);
12774 }
12775
12776 if (tmp_outfile_fp && tmp_outfile_fp)
12777 {
12778 tmpstat_outfile.st_mode = 0;
12779 tmpstat_outfile.st_nlink = 0;
12780 tmpstat_outfile.st_uid = 0;
12781 tmpstat_outfile.st_gid = 0;
12782 tmpstat_outfile.st_rdev = 0;
12783 tmpstat_outfile.st_atime = 0;
12784
12785 tmpstat_hashfile.st_mode = 0;
12786 tmpstat_hashfile.st_nlink = 0;
12787 tmpstat_hashfile.st_uid = 0;
12788 tmpstat_hashfile.st_gid = 0;
12789 tmpstat_hashfile.st_rdev = 0;
12790 tmpstat_hashfile.st_atime = 0;
12791
12792 #ifdef _POSIX
12793 tmpstat_outfile.st_blksize = 0;
12794 tmpstat_outfile.st_blocks = 0;
12795
12796 tmpstat_hashfile.st_blksize = 0;
12797 tmpstat_hashfile.st_blocks = 0;
12798 #endif
12799
12800 #ifdef _POSIX
12801 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12802 {
12803 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12804
12805 return (-1);
12806 }
12807 #endif
12808
12809 #ifdef _WIN
12810 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12811 {
12812 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12813
12814 return (-1);
12815 }
12816 #endif
12817 }
12818 }
12819 }
12820
12821 /**
12822 * Remove duplicates
12823 */
12824
12825 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12826
12827 if (isSalted)
12828 {
12829 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12830 }
12831 else
12832 {
12833 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12834 }
12835
12836 uint hashes_cnt_orig = hashes_cnt;
12837
12838 hashes_cnt = 1;
12839
12840 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12841 {
12842 if (isSalted)
12843 {
12844 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12845 {
12846 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12847 }
12848 }
12849 else
12850 {
12851 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12852 }
12853
12854 if (hashes_pos > hashes_cnt)
12855 {
12856 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12857 }
12858
12859 hashes_cnt++;
12860 }
12861
12862 /**
12863 * Potfile removes
12864 */
12865
12866 uint potfile_remove_cracks = 0;
12867
12868 if (potfile_disable == 0)
12869 {
12870 hash_t hash_buf;
12871
12872 hash_buf.digest = mymalloc (dgst_size);
12873 hash_buf.salt = NULL;
12874 hash_buf.esalt = NULL;
12875 hash_buf.hash_info = NULL;
12876 hash_buf.cracked = 0;
12877
12878 if (isSalted)
12879 {
12880 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12881 }
12882
12883 if (esalt_size)
12884 {
12885 hash_buf.esalt = mymalloc (esalt_size);
12886 }
12887
12888 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12889
12890 // no solution for these special hash types (for instane because they use hashfile in output etc)
12891 if ((hash_mode != 5200) &&
12892 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12893 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12894 (hash_mode != 9000))
12895 {
12896 FILE *fp = fopen (potfile, "rb");
12897
12898 if (fp != NULL)
12899 {
12900 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12901
12902 // to be safe work with a copy (because of line_len loop, i etc)
12903 // moved up here because it's easier to handle continue case
12904 // it's just 64kb
12905
12906 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12907
12908 while (!feof (fp))
12909 {
12910 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12911
12912 if (ptr == NULL) break;
12913
12914 int line_len = strlen (line_buf);
12915
12916 if (line_len == 0) continue;
12917
12918 int iter = MAX_CUT_TRIES;
12919
12920 for (int i = line_len - 1; i && iter; i--, line_len--)
12921 {
12922 if (line_buf[i] != ':') continue;
12923
12924 if (isSalted)
12925 {
12926 memset (hash_buf.salt, 0, sizeof (salt_t));
12927 }
12928
12929 hash_t *found = NULL;
12930
12931 if (hash_mode == 6800)
12932 {
12933 if (i < 64) // 64 = 16 * uint in salt_buf[]
12934 {
12935 // manipulate salt_buf
12936 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12937
12938 hash_buf.salt->salt_len = i;
12939
12940 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12941 }
12942 }
12943 else if (hash_mode == 2500)
12944 {
12945 if (i < 64) // 64 = 16 * uint in salt_buf[]
12946 {
12947 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12948 // manipulate salt_buf
12949
12950 memcpy (line_buf_cpy, line_buf, i);
12951
12952 char *mac2_pos = strrchr (line_buf_cpy, ':');
12953
12954 if (mac2_pos == NULL) continue;
12955
12956 mac2_pos[0] = 0;
12957 mac2_pos++;
12958
12959 if (strlen (mac2_pos) != 12) continue;
12960
12961 char *mac1_pos = strrchr (line_buf_cpy, ':');
12962
12963 if (mac1_pos == NULL) continue;
12964
12965 mac1_pos[0] = 0;
12966 mac1_pos++;
12967
12968 if (strlen (mac1_pos) != 12) continue;
12969
12970 uint essid_length = mac1_pos - line_buf_cpy - 1;
12971
12972 // here we need the ESSID
12973 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12974
12975 hash_buf.salt->salt_len = essid_length;
12976
12977 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12978
12979 if (found)
12980 {
12981 wpa_t *wpa = (wpa_t *) found->esalt;
12982
12983 // compare hex string(s) vs binary MAC address(es)
12984
12985 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12986 {
12987 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12988 {
12989 found = NULL;
12990
12991 break;
12992 }
12993 }
12994
12995 // early skip ;)
12996 if (!found) continue;
12997
12998 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12999 {
13000 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
13001 {
13002 found = NULL;
13003
13004 break;
13005 }
13006 }
13007 }
13008 }
13009 }
13010 else
13011 {
13012 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
13013
13014 if (parser_status == PARSER_OK)
13015 {
13016 if (isSalted)
13017 {
13018 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
13019 }
13020 else
13021 {
13022 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
13023 }
13024 }
13025 }
13026
13027 if (found == NULL) continue;
13028
13029 if (!found->cracked) potfile_remove_cracks++;
13030
13031 found->cracked = 1;
13032
13033 if (found) break;
13034
13035 iter--;
13036 }
13037 }
13038
13039 myfree (line_buf_cpy);
13040
13041 myfree (line_buf);
13042
13043 fclose (fp);
13044 }
13045 }
13046
13047 if (esalt_size)
13048 {
13049 local_free (hash_buf.esalt);
13050 }
13051
13052 if (isSalted)
13053 {
13054 local_free (hash_buf.salt);
13055 }
13056
13057 local_free (hash_buf.digest);
13058 }
13059
13060 /**
13061 * Now generate all the buffers required for later
13062 */
13063
13064 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
13065
13066 salt_t *salts_buf_new = NULL;
13067 void *esalts_buf_new = NULL;
13068
13069 if (isSalted)
13070 {
13071 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
13072
13073 if (esalt_size)
13074 {
13075 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
13076 }
13077 }
13078 else
13079 {
13080 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13081 }
13082
13083 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13084
13085 uint digests_cnt = hashes_cnt;
13086 uint digests_done = 0;
13087
13088 size_t size_digests = digests_cnt * dgst_size;
13089 size_t size_shown = digests_cnt * sizeof (uint);
13090
13091 uint *digests_shown = (uint *) mymalloc (size_shown);
13092 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13093
13094 uint salts_cnt = 0;
13095 uint salts_done = 0;
13096
13097 hashinfo_t **hash_info = NULL;
13098
13099 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13100 {
13101 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13102
13103 if (username && (remove || show))
13104 {
13105 uint user_pos;
13106
13107 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13108 {
13109 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13110
13111 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13112 }
13113 }
13114 }
13115
13116 uint *salts_shown = (uint *) mymalloc (size_shown);
13117
13118 salt_t *salt_buf;
13119
13120 {
13121 // copied from inner loop
13122
13123 salt_buf = &salts_buf_new[salts_cnt];
13124
13125 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13126
13127 if (esalt_size)
13128 {
13129 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13130 }
13131
13132 salt_buf->digests_cnt = 0;
13133 salt_buf->digests_done = 0;
13134 salt_buf->digests_offset = 0;
13135
13136 salts_cnt++;
13137 }
13138
13139 if (hashes_buf[0].cracked == 1)
13140 {
13141 digests_shown[0] = 1;
13142
13143 digests_done++;
13144
13145 salt_buf->digests_done++;
13146 }
13147
13148 salt_buf->digests_cnt++;
13149
13150 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13151
13152 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13153 {
13154 hash_info[0] = hashes_buf[0].hash_info;
13155 }
13156
13157 // copy from inner loop
13158
13159 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13160 {
13161 if (isSalted)
13162 {
13163 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13164 {
13165 salt_buf = &salts_buf_new[salts_cnt];
13166
13167 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13168
13169 if (esalt_size)
13170 {
13171 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13172 }
13173
13174 salt_buf->digests_cnt = 0;
13175 salt_buf->digests_done = 0;
13176 salt_buf->digests_offset = hashes_pos;
13177
13178 salts_cnt++;
13179 }
13180 }
13181
13182 if (hashes_buf[hashes_pos].cracked == 1)
13183 {
13184 digests_shown[hashes_pos] = 1;
13185
13186 digests_done++;
13187
13188 salt_buf->digests_done++;
13189 }
13190
13191 salt_buf->digests_cnt++;
13192
13193 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13194
13195 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13196 {
13197 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13198 }
13199 }
13200
13201 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13202 {
13203 salt_t *salt_buf = &salts_buf_new[salt_pos];
13204
13205 if (salt_buf->digests_done == salt_buf->digests_cnt)
13206 {
13207 salts_shown[salt_pos] = 1;
13208
13209 salts_done++;
13210 }
13211
13212 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13213 }
13214
13215 local_free (digests_buf);
13216 local_free (salts_buf);
13217 local_free (esalts_buf);
13218
13219 digests_buf = digests_buf_new;
13220 salts_buf = salts_buf_new;
13221 esalts_buf = esalts_buf_new;
13222
13223 local_free (hashes_buf);
13224
13225 /**
13226 * special modification not set from parser
13227 */
13228
13229 switch (hash_mode)
13230 {
13231 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13232 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13233 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13234 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13235 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13236 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13237 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13238 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13239 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13240 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13241 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13242 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13243 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13244 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13245 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13246 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13247 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13248 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13249 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13250 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13251 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13252 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13253 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13254 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13255 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13256 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13257 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13258 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13259 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13260 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13261 }
13262
13263 if (truecrypt_keyfiles)
13264 {
13265 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13266
13267 char *keyfiles = strdup (truecrypt_keyfiles);
13268
13269 char *keyfile = strtok (keyfiles, ",");
13270
13271 do
13272 {
13273 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13274
13275 } while ((keyfile = strtok (NULL, ",")) != NULL);
13276
13277 free (keyfiles);
13278 }
13279
13280 if (veracrypt_keyfiles)
13281 {
13282 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13283
13284 char *keyfiles = strdup (veracrypt_keyfiles);
13285
13286 char *keyfile = strtok (keyfiles, ",");
13287
13288 do
13289 {
13290 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13291
13292 } while ((keyfile = strtok (NULL, ",")) != NULL);
13293
13294 free (keyfiles);
13295 }
13296
13297 data.digests_cnt = digests_cnt;
13298 data.digests_done = digests_done;
13299 data.digests_buf = digests_buf;
13300 data.digests_shown = digests_shown;
13301 data.digests_shown_tmp = digests_shown_tmp;
13302
13303 data.salts_cnt = salts_cnt;
13304 data.salts_done = salts_done;
13305 data.salts_buf = salts_buf;
13306 data.salts_shown = salts_shown;
13307
13308 data.esalts_buf = esalts_buf;
13309 data.hash_info = hash_info;
13310
13311 /**
13312 * Automatic Optimizers
13313 */
13314
13315 if (salts_cnt == 1)
13316 opti_type |= OPTI_TYPE_SINGLE_SALT;
13317
13318 if (digests_cnt == 1)
13319 opti_type |= OPTI_TYPE_SINGLE_HASH;
13320
13321 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13322 opti_type |= OPTI_TYPE_NOT_ITERATED;
13323
13324 if (attack_mode == ATTACK_MODE_BF)
13325 opti_type |= OPTI_TYPE_BRUTE_FORCE;
13326
13327 data.opti_type = opti_type;
13328
13329 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13330 {
13331 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13332 {
13333 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13334 {
13335 if (opts_type & OPTS_TYPE_ST_ADD80)
13336 {
13337 opts_type &= ~OPTS_TYPE_ST_ADD80;
13338 opts_type |= OPTS_TYPE_PT_ADD80;
13339 }
13340
13341 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13342 {
13343 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13344 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13345 }
13346
13347 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13348 {
13349 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13350 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13351 }
13352 }
13353 }
13354 }
13355
13356 /**
13357 * Some algorithm, like descrypt, can benefit from JIT compilation
13358 */
13359
13360 int force_jit_compilation = -1;
13361
13362 if (hash_mode == 8900)
13363 {
13364 force_jit_compilation = 8900;
13365 }
13366 else if (hash_mode == 9300)
13367 {
13368 force_jit_compilation = 8900;
13369 }
13370 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13371 {
13372 force_jit_compilation = 1500;
13373 }
13374
13375 /**
13376 * generate bitmap tables
13377 */
13378
13379 const uint bitmap_shift1 = 5;
13380 const uint bitmap_shift2 = 13;
13381
13382 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13383
13384 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13385 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13386 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13387 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13388 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13389 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13390 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13391 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13392
13393 uint bitmap_bits;
13394 uint bitmap_nums;
13395 uint bitmap_mask;
13396 uint bitmap_size;
13397
13398 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13399 {
13400 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13401
13402 bitmap_nums = 1 << bitmap_bits;
13403
13404 bitmap_mask = bitmap_nums - 1;
13405
13406 bitmap_size = bitmap_nums * sizeof (uint);
13407
13408 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13409
13410 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;
13411 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;
13412
13413 break;
13414 }
13415
13416 bitmap_nums = 1 << bitmap_bits;
13417
13418 bitmap_mask = bitmap_nums - 1;
13419
13420 bitmap_size = bitmap_nums * sizeof (uint);
13421
13422 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);
13423 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);
13424
13425 /**
13426 * prepare quick rule
13427 */
13428
13429 data.rule_buf_l = rule_buf_l;
13430 data.rule_buf_r = rule_buf_r;
13431
13432 int rule_len_l = (int) strlen (rule_buf_l);
13433 int rule_len_r = (int) strlen (rule_buf_r);
13434
13435 data.rule_len_l = rule_len_l;
13436 data.rule_len_r = rule_len_r;
13437
13438 /**
13439 * load rules
13440 */
13441
13442 uint *all_kernel_rules_cnt = NULL;
13443
13444 kernel_rule_t **all_kernel_rules_buf = NULL;
13445
13446 if (rp_files_cnt)
13447 {
13448 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13449
13450 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13451 }
13452
13453 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13454
13455 int rule_len = 0;
13456
13457 for (uint i = 0; i < rp_files_cnt; i++)
13458 {
13459 uint kernel_rules_avail = 0;
13460
13461 uint kernel_rules_cnt = 0;
13462
13463 kernel_rule_t *kernel_rules_buf = NULL;
13464
13465 char *rp_file = rp_files[i];
13466
13467 char in[BLOCK_SIZE] = { 0 };
13468 char out[BLOCK_SIZE] = { 0 };
13469
13470 FILE *fp = NULL;
13471
13472 uint rule_line = 0;
13473
13474 if ((fp = fopen (rp_file, "rb")) == NULL)
13475 {
13476 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13477
13478 return (-1);
13479 }
13480
13481 while (!feof (fp))
13482 {
13483 memset (rule_buf, 0, HCBUFSIZ);
13484
13485 rule_len = fgetl (fp, rule_buf);
13486
13487 rule_line++;
13488
13489 if (rule_len == 0) continue;
13490
13491 if (rule_buf[0] == '#') continue;
13492
13493 if (kernel_rules_avail == kernel_rules_cnt)
13494 {
13495 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13496
13497 kernel_rules_avail += INCR_RULES;
13498 }
13499
13500 memset (in, 0, BLOCK_SIZE);
13501 memset (out, 0, BLOCK_SIZE);
13502
13503 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13504
13505 if (result == -1)
13506 {
13507 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13508
13509 continue;
13510 }
13511
13512 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13513 {
13514 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13515
13516 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13517
13518 continue;
13519 }
13520
13521 /* its so slow
13522 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13523 {
13524 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13525
13526 continue;
13527 }
13528 */
13529
13530 kernel_rules_cnt++;
13531 }
13532
13533 fclose (fp);
13534
13535 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13536
13537 all_kernel_rules_buf[i] = kernel_rules_buf;
13538 }
13539
13540 /**
13541 * merge rules or automatic rule generator
13542 */
13543
13544 uint kernel_rules_cnt = 0;
13545
13546 kernel_rule_t *kernel_rules_buf = NULL;
13547
13548 if (attack_mode == ATTACK_MODE_STRAIGHT)
13549 {
13550 if (rp_files_cnt)
13551 {
13552 kernel_rules_cnt = 1;
13553
13554 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13555
13556 repeats[0] = kernel_rules_cnt;
13557
13558 for (uint i = 0; i < rp_files_cnt; i++)
13559 {
13560 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13561
13562 repeats[i + 1] = kernel_rules_cnt;
13563 }
13564
13565 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13566
13567 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13568
13569 for (uint i = 0; i < kernel_rules_cnt; i++)
13570 {
13571 uint out_pos = 0;
13572
13573 kernel_rule_t *out = &kernel_rules_buf[i];
13574
13575 for (uint j = 0; j < rp_files_cnt; j++)
13576 {
13577 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13578 uint in_pos;
13579
13580 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13581
13582 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13583 {
13584 if (out_pos == RULES_MAX - 1)
13585 {
13586 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13587
13588 break;
13589 }
13590
13591 out->cmds[out_pos] = in->cmds[in_pos];
13592 }
13593 }
13594 }
13595
13596 local_free (repeats);
13597 }
13598 else if (rp_gen)
13599 {
13600 uint kernel_rules_avail = 0;
13601
13602 while (kernel_rules_cnt < rp_gen)
13603 {
13604 if (kernel_rules_avail == kernel_rules_cnt)
13605 {
13606 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13607
13608 kernel_rules_avail += INCR_RULES;
13609 }
13610
13611 memset (rule_buf, 0, HCBUFSIZ);
13612
13613 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13614
13615 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13616
13617 kernel_rules_cnt++;
13618 }
13619 }
13620 }
13621
13622 myfree (rule_buf);
13623
13624 /**
13625 * generate NOP rules
13626 */
13627
13628 if (kernel_rules_cnt == 0)
13629 {
13630 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13631
13632 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13633
13634 kernel_rules_cnt++;
13635 }
13636
13637 data.kernel_rules_cnt = kernel_rules_cnt;
13638 data.kernel_rules_buf = kernel_rules_buf;
13639
13640 /**
13641 * OpenCL platforms: detect
13642 */
13643
13644 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13645 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13646
13647 cl_uint platforms_cnt = 0;
13648 cl_uint platform_devices_cnt = 0;
13649
13650 if (keyspace == 0)
13651 {
13652 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13653
13654 if (platforms_cnt == 0)
13655 {
13656 log_info ("");
13657 log_info ("ATTENTION! No OpenCL compatible platform found");
13658 log_info ("");
13659 log_info ("You're probably missing the OpenCL runtime installation");
13660 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13661 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13662 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13663 log_info ("");
13664
13665 return (-1);
13666 }
13667
13668 if (opencl_platforms_filter != (uint) -1)
13669 {
13670 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13671
13672 if (opencl_platforms_filter > platform_cnt_mask)
13673 {
13674 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13675
13676 return (-1);
13677 }
13678 }
13679 }
13680
13681 if (opencl_device_types == NULL)
13682 {
13683 /**
13684 * OpenCL device types:
13685 * 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.
13686 */
13687
13688 cl_device_type device_types_all = 0;
13689
13690 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13691 {
13692 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13693
13694 cl_platform_id platform = platforms[platform_id];
13695
13696 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13697
13698 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13699 {
13700 cl_device_id device = platform_devices[platform_devices_id];
13701
13702 cl_device_type device_type;
13703
13704 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13705
13706 device_types_all |= device_type;
13707 }
13708 }
13709
13710 // In such a case, automatically enable CPU device type support, since it's disabled by default.
13711
13712 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13713 {
13714 device_types_filter |= CL_DEVICE_TYPE_CPU;
13715 }
13716
13717 // In another case, when the user uses --stdout, using CPU devices is much faster to setup
13718 // If we have a CPU device, force it to be used
13719
13720 if (stdout_flag == 1)
13721 {
13722 if (device_types_all & CL_DEVICE_TYPE_CPU)
13723 {
13724 device_types_filter = CL_DEVICE_TYPE_CPU;
13725 }
13726 }
13727 }
13728
13729 /**
13730 * OpenCL devices: simply push all devices from all platforms into the same device array
13731 */
13732
13733 int need_adl = 0;
13734 int need_nvapi = 0;
13735 int need_nvml = 0;
13736 int need_xnvctrl = 0;
13737
13738 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13739
13740 data.devices_param = devices_param;
13741
13742 uint devices_cnt = 0;
13743
13744 uint devices_active = 0;
13745
13746 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13747 {
13748 cl_platform_id platform = platforms[platform_id];
13749
13750 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13751
13752 char platform_vendor[INFOSZ] = { 0 };
13753
13754 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13755
13756 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13757 // this causes trouble with vendor id based macros
13758 // we'll assign generic to those without special optimization available
13759
13760 cl_uint platform_vendor_id = 0;
13761
13762 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13763 {
13764 platform_vendor_id = VENDOR_ID_AMD;
13765 }
13766 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13767 {
13768 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13769 }
13770 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13771 {
13772 platform_vendor_id = VENDOR_ID_APPLE;
13773 }
13774 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13775 {
13776 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13777 }
13778 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13779 {
13780 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13781 }
13782 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13783 {
13784 platform_vendor_id = VENDOR_ID_MESA;
13785 }
13786 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13787 {
13788 platform_vendor_id = VENDOR_ID_NV;
13789 }
13790 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13791 {
13792 platform_vendor_id = VENDOR_ID_POCL;
13793 }
13794 else
13795 {
13796 platform_vendor_id = VENDOR_ID_GENERIC;
13797 }
13798
13799 const uint platform_skipped = ((opencl_platforms_filter & (1 << platform_id)) == 0);
13800
13801 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13802 {
13803 if (machine_readable == 0)
13804 {
13805 if (platform_skipped == 0)
13806 {
13807 const int len = log_info ("OpenCL Platform #%u: %s", platform_id + 1, platform_vendor);
13808
13809 char line[256] = { 0 };
13810
13811 for (int i = 0; i < len; i++) line[i] = '=';
13812
13813 log_info (line);
13814 }
13815 else
13816 {
13817 log_info ("OpenCL Platform #%u: %s, skipped", platform_id + 1, platform_vendor);
13818 log_info ("");
13819 }
13820 }
13821 }
13822
13823 if (platform_skipped == 1) continue;
13824
13825 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13826 {
13827 size_t param_value_size = 0;
13828
13829 const uint device_id = devices_cnt;
13830
13831 hc_device_param_t *device_param = &data.devices_param[device_id];
13832
13833 device_param->platform_vendor_id = platform_vendor_id;
13834
13835 device_param->device = platform_devices[platform_devices_id];
13836
13837 device_param->device_id = device_id;
13838
13839 device_param->platform_devices_id = platform_devices_id;
13840
13841 // device_type
13842
13843 cl_device_type device_type;
13844
13845 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13846
13847 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13848
13849 device_param->device_type = device_type;
13850
13851 // device_name
13852
13853 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13854
13855 char *device_name = (char *) mymalloc (param_value_size);
13856
13857 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13858
13859 device_param->device_name = device_name;
13860
13861 // device_vendor
13862
13863 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13864
13865 char *device_vendor = (char *) mymalloc (param_value_size);
13866
13867 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13868
13869 device_param->device_vendor = device_vendor;
13870
13871 cl_uint device_vendor_id = 0;
13872
13873 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13874 {
13875 device_vendor_id = VENDOR_ID_AMD;
13876 }
13877 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13878 {
13879 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13880 }
13881 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13882 {
13883 device_vendor_id = VENDOR_ID_APPLE;
13884 }
13885 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13886 {
13887 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13888 }
13889 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13890 {
13891 device_vendor_id = VENDOR_ID_INTEL_SDK;
13892 }
13893 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13894 {
13895 device_vendor_id = VENDOR_ID_MESA;
13896 }
13897 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13898 {
13899 device_vendor_id = VENDOR_ID_NV;
13900 }
13901 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13902 {
13903 device_vendor_id = VENDOR_ID_POCL;
13904 }
13905 else
13906 {
13907 device_vendor_id = VENDOR_ID_GENERIC;
13908 }
13909
13910 device_param->device_vendor_id = device_vendor_id;
13911
13912 // tuning db
13913
13914 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13915
13916 // device_version
13917
13918 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13919
13920 char *device_version = (char *) mymalloc (param_value_size);
13921
13922 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13923
13924 device_param->device_version = device_version;
13925
13926 // device_opencl_version
13927
13928 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13929
13930 char *device_opencl_version = (char *) mymalloc (param_value_size);
13931
13932 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13933
13934 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13935
13936 myfree (device_opencl_version);
13937
13938 // vector_width
13939
13940 cl_uint vector_width;
13941
13942 if (opencl_vector_width_chgd == 0)
13943 {
13944 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13945 {
13946 if (opti_type & OPTI_TYPE_USES_BITS_64)
13947 {
13948 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13949 }
13950 else
13951 {
13952 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13953 }
13954 }
13955 else
13956 {
13957 vector_width = (cl_uint) tuningdb_entry->vector_width;
13958 }
13959 }
13960 else
13961 {
13962 vector_width = opencl_vector_width;
13963 }
13964
13965 if (vector_width > 16) vector_width = 16;
13966
13967 device_param->vector_width = vector_width;
13968
13969 // max_compute_units
13970
13971 cl_uint device_processors;
13972
13973 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13974
13975 device_param->device_processors = device_processors;
13976
13977 // device_maxmem_alloc
13978 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13979
13980 cl_ulong device_maxmem_alloc;
13981
13982 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13983
13984 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13985
13986 // device_global_mem
13987
13988 cl_ulong device_global_mem;
13989
13990 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13991
13992 device_param->device_global_mem = device_global_mem;
13993
13994 // max_work_group_size
13995
13996 size_t device_maxworkgroup_size;
13997
13998 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13999
14000 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
14001
14002 // max_clock_frequency
14003
14004 cl_uint device_maxclock_frequency;
14005
14006 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
14007
14008 device_param->device_maxclock_frequency = device_maxclock_frequency;
14009
14010 // device_endian_little
14011
14012 cl_bool device_endian_little;
14013
14014 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
14015
14016 if (device_endian_little == CL_FALSE)
14017 {
14018 log_info ("- Device #%u: WARNING: not little endian device", device_id + 1);
14019
14020 device_param->skipped = 1;
14021 }
14022
14023 // device_available
14024
14025 cl_bool device_available;
14026
14027 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
14028
14029 if (device_available == CL_FALSE)
14030 {
14031 log_info ("- Device #%u: WARNING: device not available", device_id + 1);
14032
14033 device_param->skipped = 1;
14034 }
14035
14036 // device_compiler_available
14037
14038 cl_bool device_compiler_available;
14039
14040 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
14041
14042 if (device_compiler_available == CL_FALSE)
14043 {
14044 log_info ("- Device #%u: WARNING: device no compiler available", device_id + 1);
14045
14046 device_param->skipped = 1;
14047 }
14048
14049 // device_execution_capabilities
14050
14051 cl_device_exec_capabilities device_execution_capabilities;
14052
14053 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
14054
14055 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
14056 {
14057 log_info ("- Device #%u: WARNING: device does not support executing kernels", device_id + 1);
14058
14059 device_param->skipped = 1;
14060 }
14061
14062 // device_extensions
14063
14064 size_t device_extensions_size;
14065
14066 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
14067
14068 char *device_extensions = mymalloc (device_extensions_size + 1);
14069
14070 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
14071
14072 if (strstr (device_extensions, "base_atomics") == 0)
14073 {
14074 log_info ("- Device #%u: WARNING: device does not support base atomics", device_id + 1);
14075
14076 device_param->skipped = 1;
14077 }
14078
14079 if (strstr (device_extensions, "byte_addressable_store") == 0)
14080 {
14081 log_info ("- Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
14082
14083 device_param->skipped = 1;
14084 }
14085
14086 myfree (device_extensions);
14087
14088 // device_local_mem_size
14089
14090 cl_ulong device_local_mem_size;
14091
14092 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
14093
14094 if (device_local_mem_size < 32768)
14095 {
14096 log_info ("- Device #%u: WARNING: device local mem size is too small", device_id + 1);
14097
14098 device_param->skipped = 1;
14099 }
14100
14101 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
14102 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
14103 // This results in both utilizing it for 50%
14104 // However, Intel has much better SIMD control over their own hardware
14105 // It makes sense to give them full control over their own hardware
14106
14107 if (device_type & CL_DEVICE_TYPE_CPU)
14108 {
14109 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14110 {
14111 if (data.force == 0)
14112 {
14113 if (algorithm_pos == 0)
14114 {
14115 log_info ("- Device #%u: WARNING: not native intel opencl runtime, expect massive speed loss", device_id + 1);
14116 log_info (" You can use --force to override this but do not post error reports if you do so");
14117 }
14118
14119 device_param->skipped = 1;
14120 }
14121 }
14122 }
14123
14124 // skipped
14125
14126 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14127 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14128
14129 // driver_version
14130
14131 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14132
14133 char *driver_version = (char *) mymalloc (param_value_size);
14134
14135 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14136
14137 device_param->driver_version = driver_version;
14138
14139 // device_name_chksum
14140
14141 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14142
14143 #if __x86_64__
14144 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);
14145 #else
14146 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);
14147 #endif
14148
14149 uint device_name_digest[4] = { 0 };
14150
14151 md5_64 ((uint *) device_name_chksum, device_name_digest);
14152
14153 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14154
14155 device_param->device_name_chksum = device_name_chksum;
14156
14157 // device_processor_cores
14158
14159 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14160 {
14161 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14162 {
14163 need_adl = 1;
14164 }
14165
14166 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14167 {
14168 need_nvml = 1;
14169
14170 #ifdef LINUX
14171 need_xnvctrl = 1;
14172 #endif
14173
14174 #ifdef WIN
14175 need_nvapi = 1;
14176 #endif
14177 }
14178 }
14179
14180 // device_processor_cores
14181
14182 if (device_type & CL_DEVICE_TYPE_CPU)
14183 {
14184 cl_uint device_processor_cores = 1;
14185
14186 device_param->device_processor_cores = device_processor_cores;
14187 }
14188
14189 if (device_type & CL_DEVICE_TYPE_GPU)
14190 {
14191 if (device_vendor_id == VENDOR_ID_AMD)
14192 {
14193 cl_uint device_processor_cores = 0;
14194
14195 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
14196
14197 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
14198
14199 device_param->device_processor_cores = device_processor_cores;
14200 }
14201 else if (device_vendor_id == VENDOR_ID_NV)
14202 {
14203 cl_uint kernel_exec_timeout = 0;
14204
14205 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14206
14207 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14208
14209 device_param->kernel_exec_timeout = kernel_exec_timeout;
14210
14211 cl_uint device_processor_cores = 0;
14212
14213 #define CL_DEVICE_WARP_SIZE_NV 0x4003
14214
14215 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
14216
14217 device_param->device_processor_cores = device_processor_cores;
14218
14219 cl_uint sm_minor = 0;
14220 cl_uint sm_major = 0;
14221
14222 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14223 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14224
14225 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14226 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14227
14228 device_param->sm_minor = sm_minor;
14229 device_param->sm_major = sm_major;
14230
14231 // CPU burning loop damper
14232 // Value is given as number between 0-100
14233 // By default 100%
14234
14235 device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14236
14237 if (nvidia_spin_damp_chgd == 0)
14238 {
14239 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14240 {
14241 /**
14242 * the workaround is not a friend of rule based attacks
14243 * the words from the wordlist combined with fast and slow rules cause
14244 * fluctuations which cause inaccurate wait time estimations
14245 * using a reduced damping percentage almost compensates this
14246 */
14247
14248 device_param->nvidia_spin_damp = 64;
14249 }
14250 }
14251
14252 device_param->nvidia_spin_damp /= 100;
14253 }
14254 else
14255 {
14256 cl_uint device_processor_cores = 1;
14257
14258 device_param->device_processor_cores = device_processor_cores;
14259 }
14260 }
14261
14262 // display results
14263
14264 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14265 {
14266 if (machine_readable == 0)
14267 {
14268 if (device_param->skipped == 0)
14269 {
14270 log_info ("- Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14271 device_id + 1,
14272 device_name,
14273 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14274 (unsigned int) (device_global_mem / 1024 / 1024),
14275 (unsigned int) device_processors);
14276 }
14277 else
14278 {
14279 log_info ("- Device #%u: %s, skipped",
14280 device_id + 1,
14281 device_name);
14282 }
14283 }
14284 }
14285
14286 // common driver check
14287
14288 if (device_param->skipped == 0)
14289 {
14290 if (device_type & CL_DEVICE_TYPE_GPU)
14291 {
14292 if (platform_vendor_id == VENDOR_ID_AMD)
14293 {
14294 int catalyst_check = (force == 1) ? 0 : 1;
14295
14296 int catalyst_warn = 0;
14297
14298 int catalyst_broken = 0;
14299
14300 if (catalyst_check == 1)
14301 {
14302 catalyst_warn = 1;
14303
14304 // v14.9 and higher
14305 if (atoi (device_param->driver_version) >= 1573)
14306 {
14307 catalyst_warn = 0;
14308 }
14309
14310 catalyst_check = 0;
14311 }
14312
14313 if (catalyst_broken == 1)
14314 {
14315 log_info ("");
14316 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
14317 log_info ("It will pass over cracked hashes and does not report them as cracked");
14318 log_info ("You are STRONGLY encouraged not to use it");
14319 log_info ("You can use --force to override this but do not post error reports if you do so");
14320 log_info ("");
14321
14322 return (-1);
14323 }
14324
14325 if (catalyst_warn == 1)
14326 {
14327 log_info ("");
14328 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
14329 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
14330 log_info ("See hashcat's homepage for official supported catalyst drivers");
14331 #ifdef _WIN
14332 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14333 #endif
14334 log_info ("You can use --force to override this but do not post error reports if you do so");
14335 log_info ("");
14336
14337 return (-1);
14338 }
14339 }
14340 else if (platform_vendor_id == VENDOR_ID_NV)
14341 {
14342 if (device_param->kernel_exec_timeout != 0)
14343 {
14344 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);
14345 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14346 }
14347 }
14348 }
14349
14350 /* turns out pocl still creates segfaults (because of llvm)
14351 if (device_type & CL_DEVICE_TYPE_CPU)
14352 {
14353 if (platform_vendor_id == VENDOR_ID_AMD)
14354 {
14355 if (force == 0)
14356 {
14357 log_info ("");
14358 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14359 log_info ("You are STRONGLY encouraged not to use it");
14360 log_info ("You can use --force to override this but do not post error reports if you do so");
14361 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14362 log_info ("");
14363
14364 return (-1);
14365 }
14366 }
14367 }
14368 */
14369
14370 /**
14371 * kernel accel and loops tuning db adjustment
14372 */
14373
14374 device_param->kernel_accel_min = 1;
14375 device_param->kernel_accel_max = 1024;
14376
14377 device_param->kernel_loops_min = 1;
14378 device_param->kernel_loops_max = 1024;
14379
14380 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14381
14382 if (tuningdb_entry)
14383 {
14384 u32 _kernel_accel = tuningdb_entry->kernel_accel;
14385 u32 _kernel_loops = tuningdb_entry->kernel_loops;
14386
14387 if (_kernel_accel)
14388 {
14389 device_param->kernel_accel_min = _kernel_accel;
14390 device_param->kernel_accel_max = _kernel_accel;
14391 }
14392
14393 if (_kernel_loops)
14394 {
14395 if (workload_profile == 1)
14396 {
14397 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14398 }
14399 else if (workload_profile == 2)
14400 {
14401 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14402 }
14403
14404 device_param->kernel_loops_min = _kernel_loops;
14405 device_param->kernel_loops_max = _kernel_loops;
14406 }
14407 }
14408
14409 // commandline parameters overwrite tuningdb entries
14410
14411 if (kernel_accel)
14412 {
14413 device_param->kernel_accel_min = kernel_accel;
14414 device_param->kernel_accel_max = kernel_accel;
14415 }
14416
14417 if (kernel_loops)
14418 {
14419 device_param->kernel_loops_min = kernel_loops;
14420 device_param->kernel_loops_max = kernel_loops;
14421 }
14422
14423 /**
14424 * activate device
14425 */
14426
14427 devices_active++;
14428 }
14429
14430 // next please
14431
14432 devices_cnt++;
14433 }
14434
14435 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14436 {
14437 if (machine_readable == 0)
14438 {
14439 log_info ("");
14440 }
14441 }
14442 }
14443
14444 if (keyspace == 0 && devices_active == 0)
14445 {
14446 log_error ("ERROR: No devices found/left");
14447
14448 return (-1);
14449 }
14450
14451 // 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)
14452
14453 if (devices_filter != (uint) -1)
14454 {
14455 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14456
14457 if (devices_filter > devices_cnt_mask)
14458 {
14459 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14460
14461 return (-1);
14462 }
14463 }
14464
14465 data.devices_cnt = devices_cnt;
14466
14467 data.devices_active = devices_active;
14468
14469 /**
14470 * HM devices: init
14471 */
14472
14473 #ifdef HAVE_HWMON
14474 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14475 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14476 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14477 hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX] = { { 0 } };
14478
14479 if (gpu_temp_disable == 0)
14480 {
14481 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14482 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14483 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14484 XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));
14485
14486 data.hm_adl = NULL;
14487 data.hm_nvapi = NULL;
14488 data.hm_nvml = NULL;
14489 data.hm_xnvctrl = NULL;
14490
14491 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14492 {
14493 data.hm_nvml = nvml;
14494 }
14495
14496 if (data.hm_nvml)
14497 {
14498 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14499 {
14500 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14501
14502 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14503
14504 int tmp_out = 0;
14505
14506 for (int i = 0; i < tmp_in; i++)
14507 {
14508 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14509 }
14510
14511 for (int i = 0; i < tmp_out; i++)
14512 {
14513 unsigned int speed;
14514
14515 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14516
14517 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14518
14519 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14520 }
14521 }
14522 }
14523
14524 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14525 {
14526 data.hm_nvapi = nvapi;
14527 }
14528
14529 if (data.hm_nvapi)
14530 {
14531 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14532 {
14533 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14534
14535 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14536
14537 int tmp_out = 0;
14538
14539 for (int i = 0; i < tmp_in; i++)
14540 {
14541 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14542 }
14543 }
14544 }
14545
14546 if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0))
14547 {
14548 data.hm_xnvctrl = xnvctrl;
14549 }
14550
14551 if (data.hm_xnvctrl)
14552 {
14553 if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
14554 {
14555 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14556 {
14557 hc_device_param_t *device_param = &data.devices_param[device_id];
14558
14559 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14560
14561 hm_adapters_xnvctrl[device_id].xnvctrl = device_id;
14562
14563 int speed = 0;
14564
14565 if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
14566 }
14567 }
14568 }
14569
14570 if ((need_adl == 1) && (adl_init (adl) == 0))
14571 {
14572 data.hm_adl = adl;
14573 }
14574
14575 if (data.hm_adl)
14576 {
14577 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14578 {
14579 // total number of adapters
14580
14581 int hm_adapters_num;
14582
14583 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14584
14585 // adapter info
14586
14587 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14588
14589 if (lpAdapterInfo == NULL) return (-1);
14590
14591 // get a list (of ids of) valid/usable adapters
14592
14593 int num_adl_adapters = 0;
14594
14595 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14596
14597 if (num_adl_adapters > 0)
14598 {
14599 hc_thread_mutex_lock (mux_adl);
14600
14601 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14602
14603 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14604
14605 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14606 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14607
14608 hc_thread_mutex_unlock (mux_adl);
14609 }
14610
14611 myfree (valid_adl_device_list);
14612 myfree (lpAdapterInfo);
14613 }
14614 }
14615
14616 if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14617 {
14618 gpu_temp_disable = 1;
14619 }
14620 }
14621
14622 /**
14623 * OpenCL devices: allocate buffer for device specific information
14624 */
14625
14626 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14627 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14628
14629 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14630
14631 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14632
14633 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14634
14635 /**
14636 * User-defined GPU temp handling
14637 */
14638
14639 if (gpu_temp_disable == 1)
14640 {
14641 gpu_temp_abort = 0;
14642 gpu_temp_retain = 0;
14643 }
14644
14645 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14646 {
14647 if (gpu_temp_abort < gpu_temp_retain)
14648 {
14649 log_error ("ERROR: Invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14650
14651 return (-1);
14652 }
14653 }
14654
14655 data.gpu_temp_disable = gpu_temp_disable;
14656 data.gpu_temp_abort = gpu_temp_abort;
14657 data.gpu_temp_retain = gpu_temp_retain;
14658 #endif
14659
14660 /**
14661 * enable custom signal handler(s)
14662 */
14663
14664 if (benchmark == 0)
14665 {
14666 hc_signal (sigHandler_default);
14667 }
14668 else
14669 {
14670 hc_signal (sigHandler_benchmark);
14671 }
14672
14673 /**
14674 * inform the user
14675 */
14676
14677 if (data.quiet == 0)
14678 {
14679 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14680
14681 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);
14682
14683 if (attack_mode == ATTACK_MODE_STRAIGHT)
14684 {
14685 log_info ("Rules: %u", kernel_rules_cnt);
14686 }
14687
14688 if (opti_type)
14689 {
14690 log_info ("Applicable Optimizers:");
14691
14692 for (uint i = 0; i < 32; i++)
14693 {
14694 const uint opti_bit = 1u << i;
14695
14696 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14697 }
14698 }
14699
14700 /**
14701 * Watchdog and Temperature balance
14702 */
14703
14704 #ifdef HAVE_HWMON
14705 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14706 {
14707 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14708 }
14709
14710 if (gpu_temp_abort == 0)
14711 {
14712 log_info ("Watchdog: Temperature abort trigger disabled");
14713 }
14714 else
14715 {
14716 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14717 }
14718
14719 if (gpu_temp_retain == 0)
14720 {
14721 log_info ("Watchdog: Temperature retain trigger disabled");
14722 }
14723 else
14724 {
14725 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14726 }
14727
14728 if (data.quiet == 0) log_info ("");
14729 #endif
14730 }
14731
14732 #ifdef HAVE_HWMON
14733
14734 /**
14735 * HM devices: copy
14736 */
14737
14738 if (gpu_temp_disable == 0)
14739 {
14740 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14741 {
14742 hc_device_param_t *device_param = &data.devices_param[device_id];
14743
14744 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14745
14746 if (device_param->skipped) continue;
14747
14748 const uint platform_devices_id = device_param->platform_devices_id;
14749
14750 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14751 {
14752 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14753 data.hm_device[device_id].nvapi = 0;
14754 data.hm_device[device_id].nvml = 0;
14755 data.hm_device[device_id].xnvctrl = 0;
14756 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14757 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14758 data.hm_device[device_id].fan_set_supported = 0;
14759 }
14760
14761 if (device_param->device_vendor_id == VENDOR_ID_NV)
14762 {
14763 data.hm_device[device_id].adl = 0;
14764 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14765 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14766 data.hm_device[device_id].xnvctrl = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
14767 data.hm_device[device_id].od_version = 0;
14768 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14769 data.hm_device[device_id].fan_set_supported = 0;
14770 }
14771 }
14772 }
14773
14774 /**
14775 * powertune on user request
14776 */
14777
14778 if (powertune_enable == 1)
14779 {
14780 hc_thread_mutex_lock (mux_adl);
14781
14782 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14783 {
14784 hc_device_param_t *device_param = &data.devices_param[device_id];
14785
14786 if (device_param->skipped) continue;
14787
14788 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14789 {
14790 /**
14791 * Temporary fix:
14792 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14793 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14794 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14795 * Driver / ADL bug?
14796 */
14797
14798 if (data.hm_device[device_id].od_version == 6)
14799 {
14800 int ADL_rc;
14801
14802 // check powertune capabilities first, if not available then skip device
14803
14804 int powertune_supported = 0;
14805
14806 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14807 {
14808 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14809
14810 return (-1);
14811 }
14812
14813 // first backup current value, we will restore it later
14814
14815 if (powertune_supported != 0)
14816 {
14817 // powercontrol settings
14818
14819 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14820
14821 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14822 {
14823 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14824 }
14825
14826 if (ADL_rc != ADL_OK)
14827 {
14828 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14829
14830 return (-1);
14831 }
14832
14833 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14834 {
14835 log_error ("ERROR: Failed to set new ADL PowerControl values");
14836
14837 return (-1);
14838 }
14839
14840 // clocks
14841
14842 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14843
14844 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14845
14846 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)
14847 {
14848 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14849
14850 return (-1);
14851 }
14852
14853 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14854
14855 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14856
14857 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14858 {
14859 log_error ("ERROR: Failed to get ADL device capabilities");
14860
14861 return (-1);
14862 }
14863
14864 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14865 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14866
14867 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14868 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14869
14870 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14871 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14872
14873 // warning if profile has too low max values
14874
14875 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14876 {
14877 log_info ("WARN: The custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14878 }
14879
14880 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14881 {
14882 log_info ("WARN: The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14883 }
14884
14885 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14886
14887 performance_state->iNumberOfPerformanceLevels = 2;
14888
14889 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14890 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14891 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14892 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14893
14894 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)
14895 {
14896 log_info ("ERROR: Failed to set ADL performance state");
14897
14898 return (-1);
14899 }
14900
14901 local_free (performance_state);
14902 }
14903
14904 // set powertune value only
14905
14906 if (powertune_supported != 0)
14907 {
14908 // powertune set
14909 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14910
14911 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14912 {
14913 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14914
14915 return (-1);
14916 }
14917
14918 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14919 {
14920 log_error ("ERROR: Failed to set new ADL PowerControl values");
14921
14922 return (-1);
14923 }
14924 }
14925 }
14926 }
14927
14928 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14929 {
14930 // first backup current value, we will restore it later
14931
14932 unsigned int limit;
14933
14934 int powertune_supported = 0;
14935
14936 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14937 {
14938 powertune_supported = 1;
14939 }
14940
14941 // if backup worked, activate the maximum allowed
14942
14943 if (powertune_supported != 0)
14944 {
14945 unsigned int minLimit;
14946 unsigned int maxLimit;
14947
14948 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14949 {
14950 if (maxLimit > 0)
14951 {
14952 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14953 {
14954 // now we can be sure we need to reset later
14955
14956 nvml_power_limit[device_id] = limit;
14957 }
14958 }
14959 }
14960 }
14961 }
14962 }
14963
14964 hc_thread_mutex_unlock (mux_adl);
14965 }
14966
14967 #endif // HAVE_HWMON
14968
14969 #ifdef DEBUG
14970 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14971 #endif
14972
14973 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14974
14975 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14976 {
14977 /**
14978 * host buffer
14979 */
14980
14981 hc_device_param_t *device_param = &data.devices_param[device_id];
14982
14983 if (device_param->skipped) continue;
14984
14985 /**
14986 * device properties
14987 */
14988
14989 const char *device_name_chksum = device_param->device_name_chksum;
14990 const u32 device_processors = device_param->device_processors;
14991 const u32 device_processor_cores = device_param->device_processor_cores;
14992
14993 /**
14994 * create context for each device
14995 */
14996
14997 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14998
14999 /**
15000 * create command-queue
15001 */
15002
15003 // not supported with NV
15004 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
15005
15006 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
15007
15008 /**
15009 * kernel threads: some algorithms need a fixed kernel-threads count
15010 * because of shared memory usage or bitslice
15011 * there needs to be some upper limit, otherwise there's too much overhead
15012 */
15013
15014 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
15015
15016 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
15017 {
15018 kernel_threads = KERNEL_THREADS_MAX_CPU;
15019 }
15020
15021 if (hash_mode == 1500) kernel_threads = 64; // DES
15022 if (hash_mode == 3000) kernel_threads = 64; // DES
15023 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
15024 if (hash_mode == 7500) kernel_threads = 64; // RC4
15025 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
15026 if (hash_mode == 9700) kernel_threads = 64; // RC4
15027 if (hash_mode == 9710) kernel_threads = 64; // RC4
15028 if (hash_mode == 9800) kernel_threads = 64; // RC4
15029 if (hash_mode == 9810) kernel_threads = 64; // RC4
15030 if (hash_mode == 10400) kernel_threads = 64; // RC4
15031 if (hash_mode == 10410) kernel_threads = 64; // RC4
15032 if (hash_mode == 10500) kernel_threads = 64; // RC4
15033 if (hash_mode == 13100) kernel_threads = 64; // RC4
15034
15035 device_param->kernel_threads = kernel_threads;
15036
15037 device_param->hardware_power = device_processors * kernel_threads;
15038
15039 /**
15040 * create input buffers on device : calculate size of fixed memory buffers
15041 */
15042
15043 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
15044 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
15045
15046 device_param->size_root_css = size_root_css;
15047 device_param->size_markov_css = size_markov_css;
15048
15049 size_t size_results = sizeof (uint);
15050
15051 device_param->size_results = size_results;
15052
15053 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
15054 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
15055
15056 size_t size_plains = digests_cnt * sizeof (plain_t);
15057 size_t size_salts = salts_cnt * sizeof (salt_t);
15058 size_t size_esalts = salts_cnt * esalt_size;
15059
15060 device_param->size_plains = size_plains;
15061 device_param->size_digests = size_digests;
15062 device_param->size_shown = size_shown;
15063 device_param->size_salts = size_salts;
15064
15065 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
15066 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
15067 size_t size_tm = 32 * sizeof (bs_word_t);
15068
15069 // scryptV stuff
15070
15071 size_t size_scryptV = 1;
15072
15073 if ((hash_mode == 8900) || (hash_mode == 9300))
15074 {
15075 uint tmto_start = 0;
15076 uint tmto_stop = 10;
15077
15078 if (scrypt_tmto)
15079 {
15080 tmto_start = scrypt_tmto;
15081 }
15082 else
15083 {
15084 // in case the user did not specify the tmto manually
15085 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
15086 // but set the lower end only in case the user has a device with too less memory
15087
15088 if (hash_mode == 8900)
15089 {
15090 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15091 {
15092 tmto_start = 1;
15093 }
15094 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15095 {
15096 tmto_start = 2;
15097 }
15098 }
15099 else if (hash_mode == 9300)
15100 {
15101 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15102 {
15103 tmto_start = 2;
15104 }
15105 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15106 {
15107 tmto_start = 2;
15108 }
15109 }
15110 }
15111
15112 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
15113 {
15114 // TODO: in theory the following calculation needs to be done per salt, not global
15115 // we assume all hashes have the same scrypt settings
15116
15117 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
15118
15119 size_scryptV /= 1 << tmto;
15120
15121 size_scryptV *= device_processors * device_processor_cores;
15122
15123 if (size_scryptV > device_param->device_maxmem_alloc)
15124 {
15125 if (quiet == 0) log_info ("WARNING: Not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15126
15127 continue;
15128 }
15129
15130 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
15131 {
15132 data.salts_buf[salts_pos].scrypt_tmto = tmto;
15133 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
15134 }
15135
15136 break;
15137 }
15138
15139 if (data.salts_buf[0].scrypt_phy == 0)
15140 {
15141 log_error ("ERROR: Can't allocate enough device memory");
15142
15143 return -1;
15144 }
15145
15146 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
15147 }
15148
15149 /**
15150 * some algorithms need a fixed kernel-loops count
15151 */
15152
15153 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15154 {
15155 const u32 kernel_loops_fixed = 1024;
15156
15157 device_param->kernel_loops_min = kernel_loops_fixed;
15158 device_param->kernel_loops_max = kernel_loops_fixed;
15159 }
15160
15161 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15162 {
15163 const u32 kernel_loops_fixed = 1024;
15164
15165 device_param->kernel_loops_min = kernel_loops_fixed;
15166 device_param->kernel_loops_max = kernel_loops_fixed;
15167 }
15168
15169 if (hash_mode == 8900)
15170 {
15171 const u32 kernel_loops_fixed = 1;
15172
15173 device_param->kernel_loops_min = kernel_loops_fixed;
15174 device_param->kernel_loops_max = kernel_loops_fixed;
15175 }
15176
15177 if (hash_mode == 9300)
15178 {
15179 const u32 kernel_loops_fixed = 1;
15180
15181 device_param->kernel_loops_min = kernel_loops_fixed;
15182 device_param->kernel_loops_max = kernel_loops_fixed;
15183 }
15184
15185 if (hash_mode == 12500)
15186 {
15187 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15188
15189 device_param->kernel_loops_min = kernel_loops_fixed;
15190 device_param->kernel_loops_max = kernel_loops_fixed;
15191 }
15192
15193 /**
15194 * some algorithms have a maximum kernel-loops count
15195 */
15196
15197 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15198 {
15199 u32 innerloop_cnt = 0;
15200
15201 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15202 {
15203 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15204 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15205 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15206 }
15207 else
15208 {
15209 innerloop_cnt = data.salts_buf[0].salt_iter;
15210 }
15211
15212 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15213 (innerloop_cnt <= device_param->kernel_loops_max))
15214 {
15215 device_param->kernel_loops_max = innerloop_cnt;
15216 }
15217 }
15218
15219 u32 kernel_accel_min = device_param->kernel_accel_min;
15220 u32 kernel_accel_max = device_param->kernel_accel_max;
15221
15222 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15223
15224 size_t size_pws = 4;
15225 size_t size_tmps = 4;
15226 size_t size_hooks = 4;
15227
15228 while (kernel_accel_max >= kernel_accel_min)
15229 {
15230 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15231
15232 // size_pws
15233
15234 size_pws = kernel_power_max * sizeof (pw_t);
15235
15236 // size_tmps
15237
15238 switch (hash_mode)
15239 {
15240 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15241 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15242 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15243 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15244 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15245 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15246 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15247 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15248 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15249 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15250 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15251 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15252 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15253 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15254 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15255 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15256 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15257 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15258 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15259 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15260 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15261 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15262 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15263 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
15264 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
15265 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
15266 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
15267 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
15268 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15269 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15270 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
15271 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
15272 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15273 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
15274 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15275 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
15276 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
15277 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15278 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15279 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
15280 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
15281 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
15282 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15283 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
15284 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
15285 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
15286 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
15287 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15288 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
15289 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
15290 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
15291 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15292 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15293 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
15294 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
15295 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
15296 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
15297 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
15298 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15299 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15300 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15301 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
15302 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
15303 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15304 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15305 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15306 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15307 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15308 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15309 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15310 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15311 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15312 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15313 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15314 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15315 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15316 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15317 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15318 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15319 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15320 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15321 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15322 };
15323
15324 // size_hooks
15325
15326 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15327 {
15328 switch (hash_mode)
15329 {
15330 }
15331 }
15332
15333 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15334 // if not, decrease amplifier and try again
15335
15336 int skip = 0;
15337
15338 const u64 size_total
15339 = bitmap_size
15340 + bitmap_size
15341 + bitmap_size
15342 + bitmap_size
15343 + bitmap_size
15344 + bitmap_size
15345 + bitmap_size
15346 + bitmap_size
15347 + size_bfs
15348 + size_combs
15349 + size_digests
15350 + size_esalts
15351 + size_hooks
15352 + size_markov_css
15353 + size_plains
15354 + size_pws
15355 + size_pws // not a bug
15356 + size_results
15357 + size_root_css
15358 + size_rules
15359 + size_rules_c
15360 + size_salts
15361 + size_scryptV
15362 + size_shown
15363 + size_tm
15364 + size_tmps;
15365
15366 // Don't ask me, ask AMD!
15367
15368 if (size_total > device_param->device_maxmem_alloc) skip = 1;
15369 if (size_total > device_param->device_global_mem) skip = 1;
15370
15371 if (skip == 1)
15372 {
15373 kernel_accel_max--;
15374
15375 continue;
15376 }
15377
15378 break;
15379 }
15380
15381 /*
15382 if (kernel_accel_max == 0)
15383 {
15384 log_error ("- Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
15385
15386 return -1;
15387 }
15388 */
15389
15390 device_param->kernel_accel_min = kernel_accel_min;
15391 device_param->kernel_accel_max = kernel_accel_max;
15392
15393 /*
15394 if (kernel_accel_max < kernel_accel)
15395 {
15396 if (quiet == 0) log_info ("- Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
15397
15398 device_param->kernel_accel = kernel_accel_max;
15399 }
15400 */
15401
15402 device_param->size_bfs = size_bfs;
15403 device_param->size_combs = size_combs;
15404 device_param->size_rules = size_rules;
15405 device_param->size_rules_c = size_rules_c;
15406 device_param->size_pws = size_pws;
15407 device_param->size_tmps = size_tmps;
15408 device_param->size_hooks = size_hooks;
15409
15410 /**
15411 * default building options
15412 */
15413
15414 char build_opts[1024] = { 0 };
15415
15416 // we don't have sm_* on vendors not NV but it doesn't matter
15417
15418 #if _WIN
15419 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);
15420 #else
15421 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);
15422 #endif
15423
15424 char build_opts_new[1024] = { 0 };
15425
15426 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);
15427
15428 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
15429
15430 /*
15431 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
15432 {
15433 // we do vectorizing much better than the auto-vectorizer
15434
15435 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
15436
15437 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
15438 }
15439 */
15440
15441 #ifdef DEBUG
15442 log_info ("- Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15443 #endif
15444
15445 /**
15446 * main kernel
15447 */
15448
15449 {
15450 /**
15451 * kernel source filename
15452 */
15453
15454 char source_file[256] = { 0 };
15455
15456 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15457
15458 struct stat sst;
15459
15460 if (stat (source_file, &sst) == -1)
15461 {
15462 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15463
15464 return -1;
15465 }
15466
15467 /**
15468 * kernel cached filename
15469 */
15470
15471 char cached_file[256] = { 0 };
15472
15473 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15474
15475 int cached = 1;
15476
15477 struct stat cst;
15478
15479 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15480 {
15481 cached = 0;
15482 }
15483
15484 /**
15485 * kernel compile or load
15486 */
15487
15488 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15489
15490 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15491
15492 if (force_jit_compilation == -1)
15493 {
15494 if (cached == 0)
15495 {
15496 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));
15497
15498 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15499
15500 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15501
15502 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15503
15504 #ifdef DEBUG
15505 size_t build_log_size = 0;
15506
15507 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15508
15509 if (build_log_size > 1)
15510 {
15511 char *build_log = (char *) malloc (build_log_size + 1);
15512
15513 memset (build_log, 0, build_log_size + 1);
15514
15515 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15516
15517 puts (build_log);
15518
15519 free (build_log);
15520 }
15521 #endif
15522
15523 if (rc != 0)
15524 {
15525 device_param->skipped = true;
15526
15527 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15528
15529 continue;
15530 }
15531
15532 size_t binary_size;
15533
15534 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15535
15536 u8 *binary = (u8 *) mymalloc (binary_size);
15537
15538 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15539
15540 writeProgramBin (cached_file, binary, binary_size);
15541
15542 local_free (binary);
15543 }
15544 else
15545 {
15546 #ifdef DEBUG
15547 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15548 #endif
15549
15550 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15551
15552 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15553
15554 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15555 }
15556 }
15557 else
15558 {
15559 #ifdef DEBUG
15560 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15561 #endif
15562
15563 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15564
15565 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15566
15567 char build_opts_update[1024] = { 0 };
15568
15569 if (force_jit_compilation == 1500)
15570 {
15571 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15572 }
15573 else if (force_jit_compilation == 8900)
15574 {
15575 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);
15576 }
15577 else
15578 {
15579 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15580 }
15581
15582 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15583
15584 #ifdef DEBUG
15585 size_t build_log_size = 0;
15586
15587 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15588
15589 if (build_log_size > 1)
15590 {
15591 char *build_log = (char *) malloc (build_log_size + 1);
15592
15593 memset (build_log, 0, build_log_size + 1);
15594
15595 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15596
15597 puts (build_log);
15598
15599 free (build_log);
15600 }
15601 #endif
15602
15603 if (rc != 0)
15604 {
15605 device_param->skipped = true;
15606
15607 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15608 }
15609 }
15610
15611 local_free (kernel_lengths);
15612 local_free (kernel_sources[0]);
15613 local_free (kernel_sources);
15614 }
15615
15616 /**
15617 * word generator kernel
15618 */
15619
15620 if (attack_mode != ATTACK_MODE_STRAIGHT)
15621 {
15622 /**
15623 * kernel mp source filename
15624 */
15625
15626 char source_file[256] = { 0 };
15627
15628 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15629
15630 struct stat sst;
15631
15632 if (stat (source_file, &sst) == -1)
15633 {
15634 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15635
15636 return -1;
15637 }
15638
15639 /**
15640 * kernel mp cached filename
15641 */
15642
15643 char cached_file[256] = { 0 };
15644
15645 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15646
15647 int cached = 1;
15648
15649 struct stat cst;
15650
15651 if (stat (cached_file, &cst) == -1)
15652 {
15653 cached = 0;
15654 }
15655
15656 /**
15657 * kernel compile or load
15658 */
15659
15660 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15661
15662 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15663
15664 if (cached == 0)
15665 {
15666 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));
15667 if (quiet == 0) log_info ("");
15668
15669 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15670
15671 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15672
15673 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15674
15675 if (rc != 0)
15676 {
15677 device_param->skipped = true;
15678
15679 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15680
15681 continue;
15682 }
15683
15684 size_t binary_size;
15685
15686 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15687
15688 u8 *binary = (u8 *) mymalloc (binary_size);
15689
15690 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15691
15692 writeProgramBin (cached_file, binary, binary_size);
15693
15694 local_free (binary);
15695 }
15696 else
15697 {
15698 #ifdef DEBUG
15699 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15700 #endif
15701
15702 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15703
15704 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15705
15706 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15707 }
15708
15709 local_free (kernel_lengths);
15710 local_free (kernel_sources[0]);
15711 local_free (kernel_sources);
15712 }
15713
15714 /**
15715 * amplifier kernel
15716 */
15717
15718 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15719 {
15720
15721 }
15722 else
15723 {
15724 /**
15725 * kernel amp source filename
15726 */
15727
15728 char source_file[256] = { 0 };
15729
15730 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15731
15732 struct stat sst;
15733
15734 if (stat (source_file, &sst) == -1)
15735 {
15736 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15737
15738 return -1;
15739 }
15740
15741 /**
15742 * kernel amp cached filename
15743 */
15744
15745 char cached_file[256] = { 0 };
15746
15747 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15748
15749 int cached = 1;
15750
15751 struct stat cst;
15752
15753 if (stat (cached_file, &cst) == -1)
15754 {
15755 cached = 0;
15756 }
15757
15758 /**
15759 * kernel compile or load
15760 */
15761
15762 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15763
15764 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15765
15766 if (cached == 0)
15767 {
15768 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));
15769 if (quiet == 0) log_info ("");
15770
15771 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15772
15773 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15774
15775 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15776
15777 if (rc != 0)
15778 {
15779 device_param->skipped = true;
15780
15781 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15782
15783 continue;
15784 }
15785
15786 size_t binary_size;
15787
15788 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15789
15790 u8 *binary = (u8 *) mymalloc (binary_size);
15791
15792 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15793
15794 writeProgramBin (cached_file, binary, binary_size);
15795
15796 local_free (binary);
15797 }
15798 else
15799 {
15800 #ifdef DEBUG
15801 if (quiet == 0) log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15802 #endif
15803
15804 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15805
15806 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15807
15808 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15809 }
15810
15811 local_free (kernel_lengths);
15812 local_free (kernel_sources[0]);
15813 local_free (kernel_sources);
15814 }
15815
15816 // some algorithm collide too fast, make that impossible
15817
15818 if (benchmark == 1)
15819 {
15820 ((uint *) digests_buf)[0] = -1;
15821 ((uint *) digests_buf)[1] = -1;
15822 ((uint *) digests_buf)[2] = -1;
15823 ((uint *) digests_buf)[3] = -1;
15824 }
15825
15826 /**
15827 * global buffers
15828 */
15829
15830 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15831 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15832 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15833 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15834 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15835 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15836 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15837 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15838 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15839 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15840 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15841 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15842 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15843 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15844 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15845 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15846 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15847 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15848
15849 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);
15850 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);
15851 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);
15852 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);
15853 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);
15854 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);
15855 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);
15856 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);
15857 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15858 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15859 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15860
15861 /**
15862 * special buffers
15863 */
15864
15865 if (attack_kern == ATTACK_KERN_STRAIGHT)
15866 {
15867 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15868 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15869
15870 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15871 }
15872 else if (attack_kern == ATTACK_KERN_COMBI)
15873 {
15874 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15875 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15876 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15877 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15878 }
15879 else if (attack_kern == ATTACK_KERN_BF)
15880 {
15881 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15882 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15883 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15884 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15885 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15886 }
15887
15888 if (size_esalts)
15889 {
15890 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15891
15892 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15893 }
15894
15895 /**
15896 * main host data
15897 */
15898
15899 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15900
15901 device_param->pws_buf = pws_buf;
15902
15903 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15904
15905 device_param->combs_buf = combs_buf;
15906
15907 void *hooks_buf = mymalloc (size_hooks);
15908
15909 device_param->hooks_buf = hooks_buf;
15910
15911 /**
15912 * kernel args
15913 */
15914
15915 device_param->kernel_params_buf32[21] = bitmap_mask;
15916 device_param->kernel_params_buf32[22] = bitmap_shift1;
15917 device_param->kernel_params_buf32[23] = bitmap_shift2;
15918 device_param->kernel_params_buf32[24] = 0; // salt_pos
15919 device_param->kernel_params_buf32[25] = 0; // loop_pos
15920 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15921 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15922 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15923 device_param->kernel_params_buf32[29] = 0; // digests_offset
15924 device_param->kernel_params_buf32[30] = 0; // combs_mode
15925 device_param->kernel_params_buf32[31] = 0; // gid_max
15926
15927 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15928 ? &device_param->d_pws_buf
15929 : &device_param->d_pws_amp_buf;
15930 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15931 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15932 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15933 device_param->kernel_params[ 4] = &device_param->d_tmps;
15934 device_param->kernel_params[ 5] = &device_param->d_hooks;
15935 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15936 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15937 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15938 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15939 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15940 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15941 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15942 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15943 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15944 device_param->kernel_params[15] = &device_param->d_digests_buf;
15945 device_param->kernel_params[16] = &device_param->d_digests_shown;
15946 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15947 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15948 device_param->kernel_params[19] = &device_param->d_result;
15949 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15950 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15951 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15952 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15953 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15954 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15955 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15956 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15957 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15958 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15959 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15960 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15961
15962 device_param->kernel_params_mp_buf64[3] = 0;
15963 device_param->kernel_params_mp_buf32[4] = 0;
15964 device_param->kernel_params_mp_buf32[5] = 0;
15965 device_param->kernel_params_mp_buf32[6] = 0;
15966 device_param->kernel_params_mp_buf32[7] = 0;
15967 device_param->kernel_params_mp_buf32[8] = 0;
15968
15969 device_param->kernel_params_mp[0] = NULL;
15970 device_param->kernel_params_mp[1] = NULL;
15971 device_param->kernel_params_mp[2] = NULL;
15972 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15973 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15974 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15975 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15976 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15977 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15978
15979 device_param->kernel_params_mp_l_buf64[3] = 0;
15980 device_param->kernel_params_mp_l_buf32[4] = 0;
15981 device_param->kernel_params_mp_l_buf32[5] = 0;
15982 device_param->kernel_params_mp_l_buf32[6] = 0;
15983 device_param->kernel_params_mp_l_buf32[7] = 0;
15984 device_param->kernel_params_mp_l_buf32[8] = 0;
15985 device_param->kernel_params_mp_l_buf32[9] = 0;
15986
15987 device_param->kernel_params_mp_l[0] = NULL;
15988 device_param->kernel_params_mp_l[1] = NULL;
15989 device_param->kernel_params_mp_l[2] = NULL;
15990 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15991 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15992 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15993 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15994 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15995 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15996 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15997
15998 device_param->kernel_params_mp_r_buf64[3] = 0;
15999 device_param->kernel_params_mp_r_buf32[4] = 0;
16000 device_param->kernel_params_mp_r_buf32[5] = 0;
16001 device_param->kernel_params_mp_r_buf32[6] = 0;
16002 device_param->kernel_params_mp_r_buf32[7] = 0;
16003 device_param->kernel_params_mp_r_buf32[8] = 0;
16004
16005 device_param->kernel_params_mp_r[0] = NULL;
16006 device_param->kernel_params_mp_r[1] = NULL;
16007 device_param->kernel_params_mp_r[2] = NULL;
16008 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
16009 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
16010 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
16011 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
16012 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
16013 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
16014
16015 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
16016 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
16017
16018 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
16019 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
16020 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
16021 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
16022 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
16023 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
16024 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
16025
16026 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
16027 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
16028
16029 device_param->kernel_params_memset_buf32[1] = 0; // value
16030 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
16031
16032 device_param->kernel_params_memset[0] = NULL;
16033 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
16034 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
16035
16036 /**
16037 * kernel name
16038 */
16039
16040 size_t kernel_wgs_tmp;
16041
16042 char kernel_name[64] = { 0 };
16043
16044 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16045 {
16046 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16047 {
16048 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
16049
16050 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16051
16052 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
16053
16054 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16055
16056 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
16057
16058 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16059 }
16060 else
16061 {
16062 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
16063
16064 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16065
16066 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
16067
16068 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16069
16070 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
16071
16072 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16073 }
16074
16075 if (data.attack_mode == ATTACK_MODE_BF)
16076 {
16077 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16078 {
16079 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
16080
16081 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16082
16083 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);
16084 }
16085 }
16086 }
16087 else
16088 {
16089 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
16090
16091 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16092
16093 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
16094
16095 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16096
16097 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
16098
16099 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16100
16101 if (opts_type & OPTS_TYPE_HOOK12)
16102 {
16103 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
16104
16105 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16106
16107 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);
16108 }
16109
16110 if (opts_type & OPTS_TYPE_HOOK23)
16111 {
16112 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
16113
16114 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16115
16116 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);
16117 }
16118 }
16119
16120 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);
16121 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);
16122 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);
16123
16124 for (uint i = 0; i <= 20; i++)
16125 {
16126 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
16127 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
16128 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
16129
16130 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
16131 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
16132 }
16133
16134 for (uint i = 21; i <= 31; i++)
16135 {
16136 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
16137 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
16138 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
16139
16140 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
16141 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
16142 }
16143
16144 // GPU memset
16145
16146 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
16147
16148 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);
16149
16150 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
16151 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
16152 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
16153
16154 // MP start
16155
16156 if (attack_mode == ATTACK_MODE_BF)
16157 {
16158 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
16159 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
16160
16161 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);
16162 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);
16163
16164 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16165 {
16166 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
16167 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
16168 }
16169 }
16170 else if (attack_mode == ATTACK_MODE_HYBRID1)
16171 {
16172 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16173
16174 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);
16175 }
16176 else if (attack_mode == ATTACK_MODE_HYBRID2)
16177 {
16178 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16179
16180 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);
16181 }
16182
16183 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16184 {
16185 // nothing to do
16186 }
16187 else
16188 {
16189 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
16190
16191 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);
16192 }
16193
16194 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16195 {
16196 // nothing to do
16197 }
16198 else
16199 {
16200 for (uint i = 0; i < 5; i++)
16201 {
16202 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
16203 }
16204
16205 for (uint i = 5; i < 7; i++)
16206 {
16207 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
16208 }
16209 }
16210
16211 // maybe this has been updated by clGetKernelWorkGroupInfo()
16212 // value can only be decreased, so we don't need to reallocate buffers
16213
16214 device_param->kernel_threads = kernel_threads;
16215
16216 // zero some data buffers
16217
16218 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
16219 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
16220 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
16221 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
16222 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
16223 run_kernel_bzero (device_param, device_param->d_result, size_results);
16224
16225 /**
16226 * special buffers
16227 */
16228
16229 if (attack_kern == ATTACK_KERN_STRAIGHT)
16230 {
16231 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
16232 }
16233 else if (attack_kern == ATTACK_KERN_COMBI)
16234 {
16235 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
16236 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
16237 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16238 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16239 }
16240 else if (attack_kern == ATTACK_KERN_BF)
16241 {
16242 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
16243 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
16244 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
16245 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16246 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16247 }
16248
16249 #if defined(HAVE_HWMON)
16250
16251 /**
16252 * Store initial fanspeed if gpu_temp_retain is enabled
16253 */
16254
16255 if (gpu_temp_disable == 0)
16256 {
16257 if (gpu_temp_retain != 0)
16258 {
16259 hc_thread_mutex_lock (mux_adl);
16260
16261 if (data.hm_device[device_id].fan_get_supported == 1)
16262 {
16263 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
16264 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
16265
16266 temp_retain_fanspeed_value[device_id] = fanspeed;
16267 temp_retain_fanpolicy_value[device_id] = fanpolicy;
16268
16269 // we also set it to tell the OS we take control over the fan and it's automatic controller
16270 // if it was set to automatic. we do not control user-defined fanspeeds.
16271
16272 if (fanpolicy == 1)
16273 {
16274 data.hm_device[device_id].fan_set_supported = 1;
16275
16276 int rc = -1;
16277
16278 if (device_param->device_vendor_id == VENDOR_ID_AMD)
16279 {
16280 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
16281 }
16282 else if (device_param->device_vendor_id == VENDOR_ID_NV)
16283 {
16284 #ifdef LINUX
16285 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE);
16286 #endif
16287
16288 #ifdef WIN
16289 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
16290 #endif
16291 }
16292
16293 if (rc == 0)
16294 {
16295 data.hm_device[device_id].fan_set_supported = 1;
16296 }
16297 else
16298 {
16299 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
16300
16301 data.hm_device[device_id].fan_set_supported = 0;
16302 }
16303 }
16304 else
16305 {
16306 data.hm_device[device_id].fan_set_supported = 0;
16307 }
16308 }
16309
16310 hc_thread_mutex_unlock (mux_adl);
16311 }
16312 }
16313
16314 #endif // HAVE_HWMON
16315 }
16316
16317 if (data.quiet == 0) log_info_nn ("");
16318
16319 /**
16320 * In benchmark-mode, inform user which algorithm is checked
16321 */
16322
16323 if (benchmark == 1)
16324 {
16325 if (machine_readable == 0)
16326 {
16327 quiet = 0;
16328
16329 data.quiet = quiet;
16330
16331 char *hash_type = strhashtype (data.hash_mode); // not a bug
16332
16333 log_info ("Hashtype: %s", hash_type);
16334 log_info ("");
16335 }
16336 }
16337
16338 /**
16339 * keep track of the progress
16340 */
16341
16342 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16343 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16344 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16345
16346 /**
16347 * open filehandles
16348 */
16349
16350 #if _WIN
16351 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
16352 {
16353 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
16354
16355 return (-1);
16356 }
16357
16358 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
16359 {
16360 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
16361
16362 return (-1);
16363 }
16364
16365 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
16366 {
16367 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
16368
16369 return (-1);
16370 }
16371 #endif
16372
16373 /**
16374 * dictionary pad
16375 */
16376
16377 segment_size *= (1024 * 1024);
16378
16379 data.segment_size = segment_size;
16380
16381 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
16382
16383 wl_data->buf = (char *) mymalloc (segment_size);
16384 wl_data->avail = segment_size;
16385 wl_data->incr = segment_size;
16386 wl_data->cnt = 0;
16387 wl_data->pos = 0;
16388
16389 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
16390
16391 data.wordlist_mode = wordlist_mode;
16392
16393 cs_t *css_buf = NULL;
16394 uint css_cnt = 0;
16395 uint dictcnt = 0;
16396 uint maskcnt = 1;
16397 char **masks = NULL;
16398 char **dictfiles = NULL;
16399
16400 uint mask_from_file = 0;
16401
16402 if (attack_mode == ATTACK_MODE_STRAIGHT)
16403 {
16404 if (wordlist_mode == WL_MODE_FILE)
16405 {
16406 int wls_left = myargc - (optind + 1);
16407
16408 for (int i = 0; i < wls_left; i++)
16409 {
16410 char *l0_filename = myargv[optind + 1 + i];
16411
16412 struct stat l0_stat;
16413
16414 if (stat (l0_filename, &l0_stat) == -1)
16415 {
16416 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
16417
16418 return (-1);
16419 }
16420
16421 uint is_dir = S_ISDIR (l0_stat.st_mode);
16422
16423 if (is_dir == 0)
16424 {
16425 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16426
16427 dictcnt++;
16428
16429 dictfiles[dictcnt - 1] = l0_filename;
16430 }
16431 else
16432 {
16433 // do not allow --keyspace w/ a directory
16434
16435 if (keyspace == 1)
16436 {
16437 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16438
16439 return (-1);
16440 }
16441
16442 char **dictionary_files = NULL;
16443
16444 dictionary_files = scan_directory (l0_filename);
16445
16446 if (dictionary_files != NULL)
16447 {
16448 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16449
16450 for (int d = 0; dictionary_files[d] != NULL; d++)
16451 {
16452 char *l1_filename = dictionary_files[d];
16453
16454 struct stat l1_stat;
16455
16456 if (stat (l1_filename, &l1_stat) == -1)
16457 {
16458 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16459
16460 return (-1);
16461 }
16462
16463 if (S_ISREG (l1_stat.st_mode))
16464 {
16465 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16466
16467 dictcnt++;
16468
16469 dictfiles[dictcnt - 1] = strdup (l1_filename);
16470 }
16471 }
16472 }
16473
16474 local_free (dictionary_files);
16475 }
16476 }
16477
16478 if (dictcnt < 1)
16479 {
16480 log_error ("ERROR: No usable dictionary file found.");
16481
16482 return (-1);
16483 }
16484 }
16485 else if (wordlist_mode == WL_MODE_STDIN)
16486 {
16487 dictcnt = 1;
16488 }
16489 }
16490 else if (attack_mode == ATTACK_MODE_COMBI)
16491 {
16492 // display
16493
16494 char *dictfile1 = myargv[optind + 1 + 0];
16495 char *dictfile2 = myargv[optind + 1 + 1];
16496
16497 // find the bigger dictionary and use as base
16498
16499 FILE *fp1 = NULL;
16500 FILE *fp2 = NULL;
16501
16502 struct stat tmp_stat;
16503
16504 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16505 {
16506 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16507
16508 return (-1);
16509 }
16510
16511 if (stat (dictfile1, &tmp_stat) == -1)
16512 {
16513 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16514
16515 fclose (fp1);
16516
16517 return (-1);
16518 }
16519
16520 if (S_ISDIR (tmp_stat.st_mode))
16521 {
16522 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16523
16524 fclose (fp1);
16525
16526 return (-1);
16527 }
16528
16529 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16530 {
16531 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16532
16533 fclose (fp1);
16534
16535 return (-1);
16536 }
16537
16538 if (stat (dictfile2, &tmp_stat) == -1)
16539 {
16540 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16541
16542 fclose (fp1);
16543 fclose (fp2);
16544
16545 return (-1);
16546 }
16547
16548 if (S_ISDIR (tmp_stat.st_mode))
16549 {
16550 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16551
16552 fclose (fp1);
16553 fclose (fp2);
16554
16555 return (-1);
16556 }
16557
16558 data.combs_cnt = 1;
16559
16560 data.quiet = 1;
16561
16562 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16563
16564 data.quiet = quiet;
16565
16566 if (words1_cnt == 0)
16567 {
16568 log_error ("ERROR: %s: empty file", dictfile1);
16569
16570 fclose (fp1);
16571 fclose (fp2);
16572
16573 return (-1);
16574 }
16575
16576 data.combs_cnt = 1;
16577
16578 data.quiet = 1;
16579
16580 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16581
16582 data.quiet = quiet;
16583
16584 if (words2_cnt == 0)
16585 {
16586 log_error ("ERROR: %s: empty file", dictfile2);
16587
16588 fclose (fp1);
16589 fclose (fp2);
16590
16591 return (-1);
16592 }
16593
16594 fclose (fp1);
16595 fclose (fp2);
16596
16597 data.dictfile = dictfile1;
16598 data.dictfile2 = dictfile2;
16599
16600 if (words1_cnt >= words2_cnt)
16601 {
16602 data.combs_cnt = words2_cnt;
16603 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16604
16605 dictfiles = &data.dictfile;
16606
16607 dictcnt = 1;
16608 }
16609 else
16610 {
16611 data.combs_cnt = words1_cnt;
16612 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16613
16614 dictfiles = &data.dictfile2;
16615
16616 dictcnt = 1;
16617
16618 // we also have to switch wordlist related rules!
16619
16620 char *tmpc = data.rule_buf_l;
16621
16622 data.rule_buf_l = data.rule_buf_r;
16623 data.rule_buf_r = tmpc;
16624
16625 int tmpi = data.rule_len_l;
16626
16627 data.rule_len_l = data.rule_len_r;
16628 data.rule_len_r = tmpi;
16629 }
16630 }
16631 else if (attack_mode == ATTACK_MODE_BF)
16632 {
16633 char *mask = NULL;
16634
16635 maskcnt = 0;
16636
16637 if (benchmark == 0)
16638 {
16639 mask = myargv[optind + 1];
16640
16641 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16642
16643 if ((optind + 2) <= myargc)
16644 {
16645 struct stat file_stat;
16646
16647 if (stat (mask, &file_stat) == -1)
16648 {
16649 maskcnt = 1;
16650
16651 masks[maskcnt - 1] = mystrdup (mask);
16652 }
16653 else
16654 {
16655 int wls_left = myargc - (optind + 1);
16656
16657 uint masks_avail = INCR_MASKS;
16658
16659 for (int i = 0; i < wls_left; i++)
16660 {
16661 if (i != 0)
16662 {
16663 mask = myargv[optind + 1 + i];
16664
16665 if (stat (mask, &file_stat) == -1)
16666 {
16667 log_error ("ERROR: %s: %s", mask, strerror (errno));
16668
16669 return (-1);
16670 }
16671 }
16672
16673 uint is_file = S_ISREG (file_stat.st_mode);
16674
16675 if (is_file == 1)
16676 {
16677 FILE *mask_fp;
16678
16679 if ((mask_fp = fopen (mask, "r")) == NULL)
16680 {
16681 log_error ("ERROR: %s: %s", mask, strerror (errno));
16682
16683 return (-1);
16684 }
16685
16686 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16687
16688 while (!feof (mask_fp))
16689 {
16690 memset (line_buf, 0, HCBUFSIZ);
16691
16692 int line_len = fgetl (mask_fp, line_buf);
16693
16694 if (line_len == 0) continue;
16695
16696 if (line_buf[0] == '#') continue;
16697
16698 if (masks_avail == maskcnt)
16699 {
16700 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16701
16702 masks_avail += INCR_MASKS;
16703 }
16704
16705 masks[maskcnt] = mystrdup (line_buf);
16706
16707 maskcnt++;
16708 }
16709
16710 myfree (line_buf);
16711
16712 fclose (mask_fp);
16713 }
16714 else
16715 {
16716 log_error ("ERROR: %s: unsupported file-type", mask);
16717
16718 return (-1);
16719 }
16720 }
16721
16722 mask_from_file = 1;
16723 }
16724 }
16725 else
16726 {
16727 custom_charset_1 = (char *) "?l?d?u";
16728 custom_charset_2 = (char *) "?l?d";
16729 custom_charset_3 = (char *) "?l?d*!$@_";
16730
16731 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16732 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16733 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16734
16735 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16736
16737 wordlist_mode = WL_MODE_MASK;
16738
16739 data.wordlist_mode = wordlist_mode;
16740
16741 increment = 1;
16742
16743 maskcnt = 1;
16744 }
16745 }
16746 else
16747 {
16748 /**
16749 * generate full masks and charsets
16750 */
16751
16752 masks = (char **) mymalloc (sizeof (char *));
16753
16754 switch (hash_mode)
16755 {
16756 case 1731: pw_min = 5;
16757 pw_max = 5;
16758 mask = mystrdup ("?b?b?b?b?b");
16759 break;
16760 case 12500: pw_min = 5;
16761 pw_max = 5;
16762 mask = mystrdup ("?b?b?b?b?b");
16763 break;
16764 default: pw_min = 7;
16765 pw_max = 7;
16766 mask = mystrdup ("?b?b?b?b?b?b?b");
16767 break;
16768 }
16769
16770 maskcnt = 1;
16771
16772 masks[maskcnt - 1] = mystrdup (mask);
16773
16774 wordlist_mode = WL_MODE_MASK;
16775
16776 data.wordlist_mode = wordlist_mode;
16777
16778 increment = 1;
16779 }
16780
16781 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16782
16783 if (increment)
16784 {
16785 if (increment_min > pw_min) pw_min = increment_min;
16786
16787 if (increment_max < pw_max) pw_max = increment_max;
16788 }
16789 }
16790 else if (attack_mode == ATTACK_MODE_HYBRID1)
16791 {
16792 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16793
16794 // display
16795
16796 char *mask = myargv[myargc - 1];
16797
16798 maskcnt = 0;
16799
16800 masks = (char **) mymalloc (1 * sizeof (char *));
16801
16802 // mod
16803
16804 struct stat file_stat;
16805
16806 if (stat (mask, &file_stat) == -1)
16807 {
16808 maskcnt = 1;
16809
16810 masks[maskcnt - 1] = mystrdup (mask);
16811 }
16812 else
16813 {
16814 uint is_file = S_ISREG (file_stat.st_mode);
16815
16816 if (is_file == 1)
16817 {
16818 FILE *mask_fp;
16819
16820 if ((mask_fp = fopen (mask, "r")) == NULL)
16821 {
16822 log_error ("ERROR: %s: %s", mask, strerror (errno));
16823
16824 return (-1);
16825 }
16826
16827 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16828
16829 uint masks_avail = 1;
16830
16831 while (!feof (mask_fp))
16832 {
16833 memset (line_buf, 0, HCBUFSIZ);
16834
16835 int line_len = fgetl (mask_fp, line_buf);
16836
16837 if (line_len == 0) continue;
16838
16839 if (line_buf[0] == '#') continue;
16840
16841 if (masks_avail == maskcnt)
16842 {
16843 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16844
16845 masks_avail += INCR_MASKS;
16846 }
16847
16848 masks[maskcnt] = mystrdup (line_buf);
16849
16850 maskcnt++;
16851 }
16852
16853 myfree (line_buf);
16854
16855 fclose (mask_fp);
16856
16857 mask_from_file = 1;
16858 }
16859 else
16860 {
16861 maskcnt = 1;
16862
16863 masks[maskcnt - 1] = mystrdup (mask);
16864 }
16865 }
16866
16867 // base
16868
16869 int wls_left = myargc - (optind + 2);
16870
16871 for (int i = 0; i < wls_left; i++)
16872 {
16873 char *filename = myargv[optind + 1 + i];
16874
16875 struct stat file_stat;
16876
16877 if (stat (filename, &file_stat) == -1)
16878 {
16879 log_error ("ERROR: %s: %s", filename, strerror (errno));
16880
16881 return (-1);
16882 }
16883
16884 uint is_dir = S_ISDIR (file_stat.st_mode);
16885
16886 if (is_dir == 0)
16887 {
16888 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16889
16890 dictcnt++;
16891
16892 dictfiles[dictcnt - 1] = filename;
16893 }
16894 else
16895 {
16896 // do not allow --keyspace w/ a directory
16897
16898 if (keyspace == 1)
16899 {
16900 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16901
16902 return (-1);
16903 }
16904
16905 char **dictionary_files = NULL;
16906
16907 dictionary_files = scan_directory (filename);
16908
16909 if (dictionary_files != NULL)
16910 {
16911 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16912
16913 for (int d = 0; dictionary_files[d] != NULL; d++)
16914 {
16915 char *l1_filename = dictionary_files[d];
16916
16917 struct stat l1_stat;
16918
16919 if (stat (l1_filename, &l1_stat) == -1)
16920 {
16921 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16922
16923 return (-1);
16924 }
16925
16926 if (S_ISREG (l1_stat.st_mode))
16927 {
16928 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16929
16930 dictcnt++;
16931
16932 dictfiles[dictcnt - 1] = strdup (l1_filename);
16933 }
16934 }
16935 }
16936
16937 local_free (dictionary_files);
16938 }
16939 }
16940
16941 if (dictcnt < 1)
16942 {
16943 log_error ("ERROR: No usable dictionary file found.");
16944
16945 return (-1);
16946 }
16947
16948 if (increment)
16949 {
16950 maskcnt = 0;
16951
16952 uint mask_min = increment_min; // we can't reject smaller masks here
16953 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16954
16955 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16956 {
16957 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16958
16959 if (cur_mask == NULL) break;
16960
16961 masks[maskcnt] = cur_mask;
16962
16963 maskcnt++;
16964
16965 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16966 }
16967 }
16968 }
16969 else if (attack_mode == ATTACK_MODE_HYBRID2)
16970 {
16971 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16972
16973 // display
16974
16975 char *mask = myargv[optind + 1 + 0];
16976
16977 maskcnt = 0;
16978
16979 masks = (char **) mymalloc (1 * sizeof (char *));
16980
16981 // mod
16982
16983 struct stat file_stat;
16984
16985 if (stat (mask, &file_stat) == -1)
16986 {
16987 maskcnt = 1;
16988
16989 masks[maskcnt - 1] = mystrdup (mask);
16990 }
16991 else
16992 {
16993 uint is_file = S_ISREG (file_stat.st_mode);
16994
16995 if (is_file == 1)
16996 {
16997 FILE *mask_fp;
16998
16999 if ((mask_fp = fopen (mask, "r")) == NULL)
17000 {
17001 log_error ("ERROR: %s: %s", mask, strerror (errno));
17002
17003 return (-1);
17004 }
17005
17006 char *line_buf = (char *) mymalloc (HCBUFSIZ);
17007
17008 uint masks_avail = 1;
17009
17010 while (!feof (mask_fp))
17011 {
17012 memset (line_buf, 0, HCBUFSIZ);
17013
17014 int line_len = fgetl (mask_fp, line_buf);
17015
17016 if (line_len == 0) continue;
17017
17018 if (line_buf[0] == '#') continue;
17019
17020 if (masks_avail == maskcnt)
17021 {
17022 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
17023
17024 masks_avail += INCR_MASKS;
17025 }
17026
17027 masks[maskcnt] = mystrdup (line_buf);
17028
17029 maskcnt++;
17030 }
17031
17032 myfree (line_buf);
17033
17034 fclose (mask_fp);
17035
17036 mask_from_file = 1;
17037 }
17038 else
17039 {
17040 maskcnt = 1;
17041
17042 masks[maskcnt - 1] = mystrdup (mask);
17043 }
17044 }
17045
17046 // base
17047
17048 int wls_left = myargc - (optind + 2);
17049
17050 for (int i = 0; i < wls_left; i++)
17051 {
17052 char *filename = myargv[optind + 2 + i];
17053
17054 struct stat file_stat;
17055
17056 if (stat (filename, &file_stat) == -1)
17057 {
17058 log_error ("ERROR: %s: %s", filename, strerror (errno));
17059
17060 return (-1);
17061 }
17062
17063 uint is_dir = S_ISDIR (file_stat.st_mode);
17064
17065 if (is_dir == 0)
17066 {
17067 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17068
17069 dictcnt++;
17070
17071 dictfiles[dictcnt - 1] = filename;
17072 }
17073 else
17074 {
17075 // do not allow --keyspace w/ a directory
17076
17077 if (keyspace == 1)
17078 {
17079 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17080
17081 return (-1);
17082 }
17083
17084 char **dictionary_files = NULL;
17085
17086 dictionary_files = scan_directory (filename);
17087
17088 if (dictionary_files != NULL)
17089 {
17090 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17091
17092 for (int d = 0; dictionary_files[d] != NULL; d++)
17093 {
17094 char *l1_filename = dictionary_files[d];
17095
17096 struct stat l1_stat;
17097
17098 if (stat (l1_filename, &l1_stat) == -1)
17099 {
17100 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17101
17102 return (-1);
17103 }
17104
17105 if (S_ISREG (l1_stat.st_mode))
17106 {
17107 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17108
17109 dictcnt++;
17110
17111 dictfiles[dictcnt - 1] = strdup (l1_filename);
17112 }
17113 }
17114 }
17115
17116 local_free (dictionary_files);
17117 }
17118 }
17119
17120 if (dictcnt < 1)
17121 {
17122 log_error ("ERROR: No usable dictionary file found.");
17123
17124 return (-1);
17125 }
17126
17127 if (increment)
17128 {
17129 maskcnt = 0;
17130
17131 uint mask_min = increment_min; // we can't reject smaller masks here
17132 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17133
17134 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17135 {
17136 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17137
17138 if (cur_mask == NULL) break;
17139
17140 masks[maskcnt] = cur_mask;
17141
17142 maskcnt++;
17143
17144 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17145 }
17146 }
17147 }
17148
17149 data.pw_min = pw_min;
17150 data.pw_max = pw_max;
17151
17152 /**
17153 * weak hash check
17154 */
17155
17156 if (weak_hash_threshold >= salts_cnt)
17157 {
17158 hc_device_param_t *device_param = NULL;
17159
17160 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17161 {
17162 device_param = &data.devices_param[device_id];
17163
17164 if (device_param->skipped) continue;
17165
17166 break;
17167 }
17168
17169 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
17170
17171 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
17172 {
17173 weak_hash_check (device_param, salt_pos);
17174 }
17175
17176 // Display hack, guarantee that there is at least one \r before real start
17177
17178 //if (data.quiet == 0) log_info ("");
17179 }
17180
17181 /**
17182 * status and monitor threads
17183 */
17184
17185 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
17186
17187 uint i_threads_cnt = 0;
17188
17189 hc_thread_t *i_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17190
17191 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17192 {
17193 if (stdout_flag == 0)
17194 {
17195 hc_thread_create (i_threads[i_threads_cnt], thread_keypress, &benchmark);
17196
17197 i_threads_cnt++;
17198 }
17199 }
17200
17201 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
17202
17203 uint ni_threads_cnt = 0;
17204
17205 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17206
17207 if (stdout_flag == 0)
17208 {
17209 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
17210
17211 ni_threads_cnt++;
17212 }
17213
17214 /**
17215 * Outfile remove
17216 */
17217
17218 if (keyspace == 0)
17219 {
17220 if (outfile_check_timer != 0)
17221 {
17222 if (data.outfile_check_directory != NULL)
17223 {
17224 if ((hash_mode != 5200) &&
17225 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
17226 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
17227 (hash_mode != 9000))
17228 {
17229 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
17230
17231 ni_threads_cnt++;
17232 }
17233 else
17234 {
17235 outfile_check_timer = 0;
17236 }
17237 }
17238 else
17239 {
17240 outfile_check_timer = 0;
17241 }
17242 }
17243 }
17244
17245 /**
17246 * Inform the user if we got some hashes remove because of the pot file remove feature
17247 */
17248
17249 if (data.quiet == 0)
17250 {
17251 if (potfile_remove_cracks > 0)
17252 {
17253 if (potfile_remove_cracks == 1) log_info ("INFO: Removed 1 hash found in pot file\n");
17254 else log_info ("INFO: Removed %u hashes found in pot file\n", potfile_remove_cracks);
17255 }
17256 }
17257
17258 data.outfile_check_timer = outfile_check_timer;
17259
17260 /**
17261 * main loop
17262 */
17263
17264 char **induction_dictionaries = NULL;
17265
17266 int induction_dictionaries_cnt = 0;
17267
17268 hcstat_table_t *root_table_buf = NULL;
17269 hcstat_table_t *markov_table_buf = NULL;
17270
17271 uint initial_restore_done = 0;
17272
17273 data.maskcnt = maskcnt;
17274
17275 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
17276 {
17277 if (data.devices_status == STATUS_CRACKED) break;
17278
17279 data.devices_status = STATUS_INIT;
17280
17281 if (maskpos > rd->maskpos)
17282 {
17283 rd->dictpos = 0;
17284 }
17285
17286 rd->maskpos = maskpos;
17287 data.maskpos = maskpos;
17288
17289 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
17290 {
17291 char *mask = masks[maskpos];
17292
17293 if (mask_from_file == 1)
17294 {
17295 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
17296
17297 char *str_ptr;
17298 uint str_pos;
17299
17300 uint mask_offset = 0;
17301
17302 uint separator_cnt;
17303
17304 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
17305 {
17306 str_ptr = strstr (mask + mask_offset, ",");
17307
17308 if (str_ptr == NULL) break;
17309
17310 str_pos = str_ptr - mask;
17311
17312 // escaped separator, i.e. "\,"
17313
17314 if (str_pos > 0)
17315 {
17316 if (mask[str_pos - 1] == '\\')
17317 {
17318 separator_cnt --;
17319
17320 mask_offset = str_pos + 1;
17321
17322 continue;
17323 }
17324 }
17325
17326 // reset the offset
17327
17328 mask_offset = 0;
17329
17330 mask[str_pos] = '\0';
17331
17332 switch (separator_cnt)
17333 {
17334 case 0:
17335 mp_reset_usr (mp_usr, 0);
17336
17337 custom_charset_1 = mask;
17338 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17339 break;
17340
17341 case 1:
17342 mp_reset_usr (mp_usr, 1);
17343
17344 custom_charset_2 = mask;
17345 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17346 break;
17347
17348 case 2:
17349 mp_reset_usr (mp_usr, 2);
17350
17351 custom_charset_3 = mask;
17352 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17353 break;
17354
17355 case 3:
17356 mp_reset_usr (mp_usr, 3);
17357
17358 custom_charset_4 = mask;
17359 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
17360 break;
17361 }
17362
17363 mask = mask + str_pos + 1;
17364 }
17365 }
17366
17367 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17368 {
17369 if (maskpos > 0)
17370 {
17371 local_free (css_buf);
17372 local_free (data.root_css_buf);
17373 local_free (data.markov_css_buf);
17374
17375 local_free (masks[maskpos - 1]);
17376 }
17377
17378 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17379
17380 data.mask = mask;
17381 data.css_cnt = css_cnt;
17382 data.css_buf = css_buf;
17383
17384 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17385
17386 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17387
17388 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17389 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17390
17391 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17392
17393 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17394
17395 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17396 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17397
17398 data.root_css_buf = root_css_buf;
17399 data.markov_css_buf = markov_css_buf;
17400
17401 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17402
17403 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17404
17405 local_free (root_table_buf);
17406 local_free (markov_table_buf);
17407
17408 // args
17409
17410 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17411 {
17412 hc_device_param_t *device_param = &data.devices_param[device_id];
17413
17414 if (device_param->skipped) continue;
17415
17416 device_param->kernel_params_mp[0] = &device_param->d_combs;
17417 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
17418 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
17419
17420 device_param->kernel_params_mp_buf64[3] = 0;
17421 device_param->kernel_params_mp_buf32[4] = css_cnt;
17422 device_param->kernel_params_mp_buf32[5] = 0;
17423 device_param->kernel_params_mp_buf32[6] = 0;
17424 device_param->kernel_params_mp_buf32[7] = 0;
17425
17426 if (attack_mode == ATTACK_MODE_HYBRID1)
17427 {
17428 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
17429 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
17430 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
17431 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
17432 }
17433 else if (attack_mode == ATTACK_MODE_HYBRID2)
17434 {
17435 device_param->kernel_params_mp_buf32[5] = 0;
17436 device_param->kernel_params_mp_buf32[6] = 0;
17437 device_param->kernel_params_mp_buf32[7] = 0;
17438 }
17439
17440 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]);
17441 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]);
17442 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]);
17443
17444 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);
17445 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);
17446 }
17447 }
17448 else if (attack_mode == ATTACK_MODE_BF)
17449 {
17450 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
17451
17452 if (increment)
17453 {
17454 for (uint i = 0; i < dictcnt; i++)
17455 {
17456 local_free (dictfiles[i]);
17457 }
17458
17459 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17460 {
17461 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17462
17463 if (l1_filename == NULL) break;
17464
17465 dictcnt++;
17466
17467 dictfiles[dictcnt - 1] = l1_filename;
17468 }
17469 }
17470 else
17471 {
17472 dictcnt++;
17473
17474 dictfiles[dictcnt - 1] = mask;
17475 }
17476
17477 if (dictcnt == 0)
17478 {
17479 log_error ("ERROR: Mask is too small");
17480
17481 return (-1);
17482 }
17483 }
17484 }
17485
17486 free (induction_dictionaries);
17487
17488 // induction_dictionaries_cnt = 0; // implied
17489
17490 if (attack_mode != ATTACK_MODE_BF)
17491 {
17492 if (keyspace == 0)
17493 {
17494 induction_dictionaries = scan_directory (induction_directory);
17495
17496 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17497 }
17498 }
17499
17500 if (induction_dictionaries_cnt)
17501 {
17502 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17503 }
17504
17505 /**
17506 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17507 */
17508 if (keyspace == 1)
17509 {
17510 if ((maskcnt > 1) || (dictcnt > 1))
17511 {
17512 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17513
17514 return (-1);
17515 }
17516 }
17517
17518 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17519 {
17520 char *subid = logfile_generate_subid ();
17521
17522 data.subid = subid;
17523
17524 logfile_sub_msg ("START");
17525
17526 data.devices_status = STATUS_INIT;
17527
17528 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17529 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17530 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17531
17532 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17533
17534 data.cpt_pos = 0;
17535
17536 data.cpt_start = time (NULL);
17537
17538 data.cpt_total = 0;
17539
17540 if (data.restore == 0)
17541 {
17542 rd->words_cur = skip;
17543
17544 skip = 0;
17545
17546 data.skip = 0;
17547 }
17548
17549 data.ms_paused = 0;
17550
17551 data.kernel_power_final = 0;
17552
17553 data.words_cur = rd->words_cur;
17554
17555 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17556 {
17557 hc_device_param_t *device_param = &data.devices_param[device_id];
17558
17559 if (device_param->skipped) continue;
17560
17561 device_param->speed_pos = 0;
17562
17563 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17564 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17565
17566 device_param->exec_pos = 0;
17567
17568 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17569
17570 device_param->outerloop_pos = 0;
17571 device_param->outerloop_left = 0;
17572 device_param->innerloop_pos = 0;
17573 device_param->innerloop_left = 0;
17574
17575 // some more resets:
17576
17577 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17578
17579 device_param->pws_cnt = 0;
17580
17581 device_param->words_off = 0;
17582 device_param->words_done = 0;
17583 }
17584
17585 // figure out some workload
17586
17587 if (attack_mode == ATTACK_MODE_STRAIGHT)
17588 {
17589 if (data.wordlist_mode == WL_MODE_FILE)
17590 {
17591 char *dictfile = NULL;
17592
17593 if (induction_dictionaries_cnt)
17594 {
17595 dictfile = induction_dictionaries[0];
17596 }
17597 else
17598 {
17599 dictfile = dictfiles[dictpos];
17600 }
17601
17602 data.dictfile = dictfile;
17603
17604 logfile_sub_string (dictfile);
17605
17606 for (uint i = 0; i < rp_files_cnt; i++)
17607 {
17608 logfile_sub_var_string ("rulefile", rp_files[i]);
17609 }
17610
17611 FILE *fd2 = fopen (dictfile, "rb");
17612
17613 if (fd2 == NULL)
17614 {
17615 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17616
17617 return (-1);
17618 }
17619
17620 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17621
17622 fclose (fd2);
17623
17624 if (data.words_cnt == 0)
17625 {
17626 if (data.devices_status == STATUS_CRACKED) break;
17627 if (data.devices_status == STATUS_ABORTED) break;
17628
17629 dictpos++;
17630
17631 continue;
17632 }
17633 }
17634 }
17635 else if (attack_mode == ATTACK_MODE_COMBI)
17636 {
17637 char *dictfile = data.dictfile;
17638 char *dictfile2 = data.dictfile2;
17639
17640 logfile_sub_string (dictfile);
17641 logfile_sub_string (dictfile2);
17642
17643 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17644 {
17645 FILE *fd2 = fopen (dictfile, "rb");
17646
17647 if (fd2 == NULL)
17648 {
17649 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17650
17651 return (-1);
17652 }
17653
17654 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17655
17656 fclose (fd2);
17657 }
17658 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17659 {
17660 FILE *fd2 = fopen (dictfile2, "rb");
17661
17662 if (fd2 == NULL)
17663 {
17664 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17665
17666 return (-1);
17667 }
17668
17669 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17670
17671 fclose (fd2);
17672 }
17673
17674 if (data.words_cnt == 0)
17675 {
17676 if (data.devices_status == STATUS_CRACKED) break;
17677 if (data.devices_status == STATUS_ABORTED) break;
17678
17679 dictpos++;
17680
17681 continue;
17682 }
17683 }
17684 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17685 {
17686 char *dictfile = NULL;
17687
17688 if (induction_dictionaries_cnt)
17689 {
17690 dictfile = induction_dictionaries[0];
17691 }
17692 else
17693 {
17694 dictfile = dictfiles[dictpos];
17695 }
17696
17697 data.dictfile = dictfile;
17698
17699 char *mask = data.mask;
17700
17701 logfile_sub_string (dictfile);
17702 logfile_sub_string (mask);
17703
17704 FILE *fd2 = fopen (dictfile, "rb");
17705
17706 if (fd2 == NULL)
17707 {
17708 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17709
17710 return (-1);
17711 }
17712
17713 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17714
17715 fclose (fd2);
17716
17717 if (data.words_cnt == 0)
17718 {
17719 if (data.devices_status == STATUS_CRACKED) break;
17720 if (data.devices_status == STATUS_ABORTED) break;
17721
17722 dictpos++;
17723
17724 continue;
17725 }
17726 }
17727 else if (attack_mode == ATTACK_MODE_BF)
17728 {
17729 local_free (css_buf);
17730 local_free (data.root_css_buf);
17731 local_free (data.markov_css_buf);
17732
17733 char *mask = dictfiles[dictpos];
17734
17735 logfile_sub_string (mask);
17736
17737 // base
17738
17739 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17740
17741 if (opts_type & OPTS_TYPE_PT_UNICODE)
17742 {
17743 uint css_cnt_unicode = css_cnt * 2;
17744
17745 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17746
17747 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17748 {
17749 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17750
17751 css_buf_unicode[j + 1].cs_buf[0] = 0;
17752 css_buf_unicode[j + 1].cs_len = 1;
17753 }
17754
17755 free (css_buf);
17756
17757 css_buf = css_buf_unicode;
17758 css_cnt = css_cnt_unicode;
17759 }
17760
17761 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17762
17763 uint mask_min = pw_min;
17764 uint mask_max = pw_max;
17765
17766 if (opts_type & OPTS_TYPE_PT_UNICODE)
17767 {
17768 mask_min *= 2;
17769 mask_max *= 2;
17770 }
17771
17772 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17773 {
17774 if (css_cnt < mask_min)
17775 {
17776 log_info ("WARNING: Skipping mask '%s' because it is smaller than the minimum password length", mask);
17777 }
17778
17779 if (css_cnt > mask_max)
17780 {
17781 log_info ("WARNING: Skipping mask '%s' because it is larger than the maximum password length", mask);
17782 }
17783
17784 // skip to next mask
17785
17786 dictpos++;
17787
17788 rd->dictpos = dictpos;
17789
17790 logfile_sub_msg ("STOP");
17791
17792 continue;
17793 }
17794
17795 uint save_css_cnt = css_cnt;
17796
17797 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17798 {
17799 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17800 {
17801 uint salt_len = (uint) data.salts_buf[0].salt_len;
17802 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17803
17804 uint css_cnt_salt = css_cnt + salt_len;
17805
17806 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17807
17808 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17809
17810 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17811 {
17812 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17813 css_buf_salt[j].cs_len = 1;
17814 }
17815
17816 free (css_buf);
17817
17818 css_buf = css_buf_salt;
17819 css_cnt = css_cnt_salt;
17820 }
17821 }
17822
17823 data.mask = mask;
17824 data.css_cnt = css_cnt;
17825 data.css_buf = css_buf;
17826
17827 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17828
17829 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17830
17831 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17832
17833 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17834 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17835
17836 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17837
17838 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17839
17840 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17841 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17842
17843 data.root_css_buf = root_css_buf;
17844 data.markov_css_buf = markov_css_buf;
17845
17846 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17847
17848 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17849
17850 local_free (root_table_buf);
17851 local_free (markov_table_buf);
17852
17853 // copy + args
17854
17855 uint css_cnt_l = css_cnt;
17856 uint css_cnt_r;
17857
17858 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17859 {
17860 if (save_css_cnt < 6)
17861 {
17862 css_cnt_r = 1;
17863 }
17864 else if (save_css_cnt == 6)
17865 {
17866 css_cnt_r = 2;
17867 }
17868 else
17869 {
17870 if (opts_type & OPTS_TYPE_PT_UNICODE)
17871 {
17872 if (save_css_cnt == 8 || save_css_cnt == 10)
17873 {
17874 css_cnt_r = 2;
17875 }
17876 else
17877 {
17878 css_cnt_r = 4;
17879 }
17880 }
17881 else
17882 {
17883 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17884 {
17885 css_cnt_r = 3;
17886 }
17887 else
17888 {
17889 css_cnt_r = 4;
17890 }
17891 }
17892 }
17893 }
17894 else
17895 {
17896 css_cnt_r = 1;
17897
17898 /* unfinished code?
17899 int sum = css_buf[css_cnt_r - 1].cs_len;
17900
17901 for (uint i = 1; i < 4 && i < css_cnt; i++)
17902 {
17903 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17904
17905 css_cnt_r++;
17906
17907 sum *= css_buf[css_cnt_r - 1].cs_len;
17908 }
17909 */
17910 }
17911
17912 css_cnt_l -= css_cnt_r;
17913
17914 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17915
17916 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17917 {
17918 hc_device_param_t *device_param = &data.devices_param[device_id];
17919
17920 if (device_param->skipped) continue;
17921
17922 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17923 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17924 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17925
17926 device_param->kernel_params_mp_l_buf64[3] = 0;
17927 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17928 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17929 device_param->kernel_params_mp_l_buf32[6] = 0;
17930 device_param->kernel_params_mp_l_buf32[7] = 0;
17931 device_param->kernel_params_mp_l_buf32[8] = 0;
17932
17933 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17934 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17935 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17936 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17937
17938 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17939 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17940 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17941
17942 device_param->kernel_params_mp_r_buf64[3] = 0;
17943 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17944 device_param->kernel_params_mp_r_buf32[5] = 0;
17945 device_param->kernel_params_mp_r_buf32[6] = 0;
17946 device_param->kernel_params_mp_r_buf32[7] = 0;
17947
17948 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]);
17949 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]);
17950 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]);
17951
17952 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]);
17953 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]);
17954 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]);
17955
17956 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);
17957 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);
17958 }
17959 }
17960
17961 u64 words_base = data.words_cnt;
17962
17963 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17964 {
17965 if (data.kernel_rules_cnt)
17966 {
17967 words_base /= data.kernel_rules_cnt;
17968 }
17969 }
17970 else if (data.attack_kern == ATTACK_KERN_COMBI)
17971 {
17972 if (data.combs_cnt)
17973 {
17974 words_base /= data.combs_cnt;
17975 }
17976 }
17977 else if (data.attack_kern == ATTACK_KERN_BF)
17978 {
17979 if (data.bfs_cnt)
17980 {
17981 words_base /= data.bfs_cnt;
17982 }
17983 }
17984
17985 data.words_base = words_base;
17986
17987 if (keyspace == 1)
17988 {
17989 log_info ("%llu", (unsigned long long int) words_base);
17990
17991 return (0);
17992 }
17993
17994 if (data.words_cur > data.words_base)
17995 {
17996 log_error ("ERROR: Restore value greater keyspace");
17997
17998 return (-1);
17999 }
18000
18001 if (data.words_cur)
18002 {
18003 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18004 {
18005 for (uint i = 0; i < data.salts_cnt; i++)
18006 {
18007 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
18008 }
18009 }
18010 else if (data.attack_kern == ATTACK_KERN_COMBI)
18011 {
18012 for (uint i = 0; i < data.salts_cnt; i++)
18013 {
18014 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
18015 }
18016 }
18017 else if (data.attack_kern == ATTACK_KERN_BF)
18018 {
18019 for (uint i = 0; i < data.salts_cnt; i++)
18020 {
18021 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
18022 }
18023 }
18024 }
18025
18026 /*
18027 * Update loopback file
18028 */
18029
18030 if (loopback == 1)
18031 {
18032 time_t now;
18033
18034 time (&now);
18035
18036 uint random_num = get_random_num (0, 9999);
18037
18038 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
18039
18040 data.loopback_file = loopback_file;
18041 }
18042
18043 /*
18044 * Update dictionary statistic
18045 */
18046
18047 if (keyspace == 0)
18048 {
18049 dictstat_fp = fopen (dictstat, "wb");
18050
18051 if (dictstat_fp)
18052 {
18053 lock_file (dictstat_fp);
18054
18055 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
18056
18057 fclose (dictstat_fp);
18058 }
18059 }
18060
18061 /**
18062 * create autotune threads
18063 */
18064
18065 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
18066
18067 data.devices_status = STATUS_AUTOTUNE;
18068
18069 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18070 {
18071 hc_device_param_t *device_param = &devices_param[device_id];
18072
18073 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
18074 }
18075
18076 hc_thread_wait (data.devices_cnt, c_threads);
18077
18078 /*
18079 * Inform user about possible slow speeds
18080 */
18081
18082 uint hardware_power_all = 0;
18083
18084 uint kernel_power_all = 0;
18085
18086 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18087 {
18088 hc_device_param_t *device_param = &devices_param[device_id];
18089
18090 hardware_power_all += device_param->hardware_power;
18091
18092 kernel_power_all += device_param->kernel_power;
18093 }
18094
18095 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
18096
18097 data.kernel_power_all = kernel_power_all;
18098
18099 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18100 {
18101 if (data.words_base < kernel_power_all)
18102 {
18103 if (quiet == 0)
18104 {
18105 log_info ("ATTENTION!");
18106 log_info (" The wordlist or mask you are using is too small.");
18107 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
18108 log_info (" The cracking speed will drop.");
18109 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
18110 log_info ("");
18111 }
18112 }
18113 }
18114
18115 /**
18116 * create cracker threads
18117 */
18118
18119 data.devices_status = STATUS_RUNNING;
18120
18121 if (initial_restore_done == 0)
18122 {
18123 if (data.restore_disable == 0) cycle_restore ();
18124
18125 initial_restore_done = 1;
18126 }
18127
18128 hc_timer_set (&data.timer_running);
18129
18130 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18131 {
18132 if ((quiet == 0) && (status == 0) && (benchmark == 0))
18133 {
18134 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
18135 if (quiet == 0) fflush (stdout);
18136 }
18137 }
18138 else if (wordlist_mode == WL_MODE_STDIN)
18139 {
18140 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
18141 if (data.quiet == 0) log_info ("");
18142 }
18143
18144 time_t runtime_start;
18145
18146 time (&runtime_start);
18147
18148 data.runtime_start = runtime_start;
18149
18150 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18151 {
18152 hc_device_param_t *device_param = &devices_param[device_id];
18153
18154 if (wordlist_mode == WL_MODE_STDIN)
18155 {
18156 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
18157 }
18158 else
18159 {
18160 hc_thread_create (c_threads[device_id], thread_calc, device_param);
18161 }
18162 }
18163
18164 hc_thread_wait (data.devices_cnt, c_threads);
18165
18166 local_free (c_threads);
18167
18168 data.restore = 0;
18169
18170 // finalize task
18171
18172 logfile_sub_var_uint ("status-after-work", data.devices_status);
18173
18174 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18175
18176 if (data.devices_status == STATUS_CRACKED) break;
18177 if (data.devices_status == STATUS_ABORTED) break;
18178
18179 if (data.devices_status == STATUS_BYPASS)
18180 {
18181 data.devices_status = STATUS_RUNNING;
18182 }
18183
18184 if (induction_dictionaries_cnt)
18185 {
18186 unlink (induction_dictionaries[0]);
18187 }
18188
18189 free (induction_dictionaries);
18190
18191 if (attack_mode != ATTACK_MODE_BF)
18192 {
18193 induction_dictionaries = scan_directory (induction_directory);
18194
18195 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18196 }
18197
18198 if (benchmark == 0)
18199 {
18200 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
18201 {
18202 if (quiet == 0) clear_prompt ();
18203
18204 if (quiet == 0) log_info ("");
18205
18206 if (status == 1)
18207 {
18208 status_display ();
18209 }
18210 else
18211 {
18212 if (quiet == 0) status_display ();
18213 }
18214
18215 if (quiet == 0) log_info ("");
18216 }
18217 }
18218
18219 if (attack_mode == ATTACK_MODE_BF)
18220 {
18221 dictpos++;
18222
18223 rd->dictpos = dictpos;
18224 }
18225 else
18226 {
18227 if (induction_dictionaries_cnt)
18228 {
18229 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18230 }
18231 else
18232 {
18233 dictpos++;
18234
18235 rd->dictpos = dictpos;
18236 }
18237 }
18238
18239 time_t runtime_stop;
18240
18241 time (&runtime_stop);
18242
18243 data.runtime_stop = runtime_stop;
18244
18245 logfile_sub_uint (runtime_start);
18246 logfile_sub_uint (runtime_stop);
18247
18248 logfile_sub_msg ("STOP");
18249
18250 global_free (subid);
18251 }
18252
18253 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18254
18255 if (data.devices_status == STATUS_CRACKED) break;
18256 if (data.devices_status == STATUS_ABORTED) break;
18257 if (data.devices_status == STATUS_QUIT) break;
18258
18259 if (data.devices_status == STATUS_BYPASS)
18260 {
18261 data.devices_status = STATUS_RUNNING;
18262 }
18263 }
18264
18265 // 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
18266
18267 if (attack_mode == ATTACK_MODE_STRAIGHT)
18268 {
18269 if (data.wordlist_mode == WL_MODE_FILE)
18270 {
18271 if (data.dictfile == NULL)
18272 {
18273 if (dictfiles != NULL)
18274 {
18275 data.dictfile = dictfiles[0];
18276
18277 hc_timer_set (&data.timer_running);
18278 }
18279 }
18280 }
18281 }
18282 // NOTE: combi is okay because it is already set beforehand
18283 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
18284 {
18285 if (data.dictfile == NULL)
18286 {
18287 if (dictfiles != NULL)
18288 {
18289 hc_timer_set (&data.timer_running);
18290
18291 data.dictfile = dictfiles[0];
18292 }
18293 }
18294 }
18295 else if (attack_mode == ATTACK_MODE_BF)
18296 {
18297 if (data.mask == NULL)
18298 {
18299 hc_timer_set (&data.timer_running);
18300
18301 data.mask = masks[0];
18302 }
18303 }
18304
18305 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18306 {
18307 data.devices_status = STATUS_EXHAUSTED;
18308 }
18309
18310 // if cracked / aborted remove last induction dictionary
18311
18312 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
18313 {
18314 struct stat induct_stat;
18315
18316 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
18317 {
18318 unlink (induction_dictionaries[file_pos]);
18319 }
18320 }
18321
18322 // wait for non-interactive threads
18323
18324 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
18325 {
18326 hc_thread_wait (1, &ni_threads[thread_idx]);
18327 }
18328
18329 local_free (ni_threads);
18330
18331 // wait for interactive threads
18332
18333 for (uint thread_idx = 0; thread_idx < i_threads_cnt; thread_idx++)
18334 {
18335 hc_thread_wait (1, &i_threads[thread_idx]);
18336 }
18337
18338 local_free (i_threads);
18339
18340 // we dont need restore file anymore
18341 if (data.restore_disable == 0)
18342 {
18343 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
18344 {
18345 unlink (eff_restore_file);
18346 unlink (new_restore_file);
18347 }
18348 else
18349 {
18350 cycle_restore ();
18351 }
18352 }
18353
18354 // finally save left hashes
18355
18356 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
18357 {
18358 save_hash ();
18359 }
18360
18361 /**
18362 * Clean up
18363 */
18364
18365 if (benchmark == 1)
18366 {
18367 status_benchmark ();
18368
18369 if (machine_readable == 0)
18370 {
18371 log_info ("");
18372 }
18373 }
18374 else
18375 {
18376 if (quiet == 0) clear_prompt ();
18377
18378 if (quiet == 0) log_info ("");
18379
18380 if (status == 1)
18381 {
18382 status_display ();
18383 }
18384 else
18385 {
18386 if (quiet == 0) status_display ();
18387 }
18388
18389 if (quiet == 0) log_info ("");
18390 }
18391
18392 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18393 {
18394 hc_device_param_t *device_param = &data.devices_param[device_id];
18395
18396 if (device_param->skipped) continue;
18397
18398 local_free (device_param->combs_buf);
18399
18400 local_free (device_param->hooks_buf);
18401
18402 local_free (device_param->device_name);
18403
18404 local_free (device_param->device_name_chksum);
18405
18406 local_free (device_param->device_version);
18407
18408 local_free (device_param->driver_version);
18409
18410 if (device_param->pws_buf) myfree (device_param->pws_buf);
18411 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
18412 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
18413 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
18414 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
18415 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
18416 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
18417 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
18418 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
18419 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
18420 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
18421 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
18422 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
18423 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
18424 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
18425 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
18426 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
18427 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
18428 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
18429 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
18430 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
18431 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
18432 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
18433 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
18434 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
18435 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
18436 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
18437 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
18438 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
18439
18440 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
18441 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
18442 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
18443 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
18444 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
18445 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
18446 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
18447 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
18448 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
18449 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
18450 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
18451
18452 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
18453 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
18454 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
18455
18456 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
18457 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
18458 }
18459
18460 // reset default fan speed
18461
18462 #ifdef HAVE_HWMON
18463 if (gpu_temp_disable == 0)
18464 {
18465 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
18466 {
18467 hc_thread_mutex_lock (mux_adl);
18468
18469 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18470 {
18471 hc_device_param_t *device_param = &data.devices_param[device_id];
18472
18473 if (device_param->skipped) continue;
18474
18475 if (data.hm_device[device_id].fan_set_supported == 1)
18476 {
18477 int fanspeed = temp_retain_fanspeed_value[device_id];
18478 int fanpolicy = temp_retain_fanpolicy_value[device_id];
18479
18480 if (fanpolicy == 1)
18481 {
18482 int rc = -1;
18483
18484 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18485 {
18486 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
18487 }
18488 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18489 {
18490 #ifdef LINUX
18491 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE);
18492 #endif
18493
18494 #ifdef WIN
18495 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, fanpolicy);
18496 #endif
18497 }
18498
18499 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18500 }
18501 }
18502 }
18503
18504 hc_thread_mutex_unlock (mux_adl);
18505 }
18506 }
18507
18508 // reset power tuning
18509
18510 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
18511 {
18512 hc_thread_mutex_lock (mux_adl);
18513
18514 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18515 {
18516 hc_device_param_t *device_param = &data.devices_param[device_id];
18517
18518 if (device_param->skipped) continue;
18519
18520 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18521 {
18522 if (data.hm_device[device_id].od_version == 6)
18523 {
18524 // check powertune capabilities first, if not available then skip device
18525
18526 int powertune_supported = 0;
18527
18528 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18529 {
18530 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18531
18532 return (-1);
18533 }
18534
18535 if (powertune_supported != 0)
18536 {
18537 // powercontrol settings
18538
18539 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18540 {
18541 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18542
18543 return (-1);
18544 }
18545
18546 // clocks
18547
18548 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18549
18550 performance_state->iNumberOfPerformanceLevels = 2;
18551
18552 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18553 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18554 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18555 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18556
18557 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18558 {
18559 log_info ("ERROR: Failed to restore ADL performance state");
18560
18561 return (-1);
18562 }
18563
18564 local_free (performance_state);
18565 }
18566 }
18567 }
18568
18569 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18570 {
18571 unsigned int limit = nvml_power_limit[device_id];
18572
18573 if (limit > 0)
18574 {
18575 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18576 }
18577 }
18578 }
18579
18580 hc_thread_mutex_unlock (mux_adl);
18581 }
18582
18583 if (gpu_temp_disable == 0)
18584 {
18585 if (data.hm_nvml)
18586 {
18587 hm_NVML_nvmlShutdown (data.hm_nvml);
18588
18589 nvml_close (data.hm_nvml);
18590
18591 data.hm_nvml = NULL;
18592 }
18593
18594 if (data.hm_nvapi)
18595 {
18596 hm_NvAPI_Unload (data.hm_nvapi);
18597
18598 nvapi_close (data.hm_nvapi);
18599
18600 data.hm_nvapi = NULL;
18601 }
18602
18603 if (data.hm_xnvctrl)
18604 {
18605 hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);
18606
18607 xnvctrl_close (data.hm_xnvctrl);
18608
18609 data.hm_xnvctrl = NULL;
18610 }
18611
18612 if (data.hm_adl)
18613 {
18614 hm_ADL_Main_Control_Destroy (data.hm_adl);
18615
18616 adl_close (data.hm_adl);
18617
18618 data.hm_adl = NULL;
18619 }
18620 }
18621 #endif // HAVE_HWMON
18622
18623 // free memory
18624
18625 local_free (masks);
18626
18627 local_free (dictstat_base);
18628
18629 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18630 {
18631 pot_t *pot_ptr = &pot[pot_pos];
18632
18633 hash_t *hash = &pot_ptr->hash;
18634
18635 local_free (hash->digest);
18636
18637 if (isSalted)
18638 {
18639 local_free (hash->salt);
18640 }
18641 }
18642
18643 local_free (pot);
18644
18645 local_free (all_kernel_rules_cnt);
18646 local_free (all_kernel_rules_buf);
18647
18648 local_free (wl_data->buf);
18649 local_free (wl_data);
18650
18651 local_free (bitmap_s1_a);
18652 local_free (bitmap_s1_b);
18653 local_free (bitmap_s1_c);
18654 local_free (bitmap_s1_d);
18655 local_free (bitmap_s2_a);
18656 local_free (bitmap_s2_b);
18657 local_free (bitmap_s2_c);
18658 local_free (bitmap_s2_d);
18659
18660 #ifdef HAVE_HWMON
18661 local_free (temp_retain_fanspeed_value);
18662 local_free (od_clock_mem_status);
18663 local_free (od_power_control_status);
18664 local_free (nvml_power_limit);
18665 #endif
18666
18667 global_free (devices_param);
18668
18669 global_free (kernel_rules_buf);
18670
18671 global_free (root_css_buf);
18672 global_free (markov_css_buf);
18673
18674 global_free (digests_buf);
18675 global_free (digests_shown);
18676 global_free (digests_shown_tmp);
18677
18678 global_free (salts_buf);
18679 global_free (salts_shown);
18680
18681 global_free (esalts_buf);
18682
18683 global_free (words_progress_done);
18684 global_free (words_progress_rejected);
18685 global_free (words_progress_restored);
18686
18687 if (pot_fp) fclose (pot_fp);
18688
18689 if (data.devices_status == STATUS_QUIT) break;
18690 }
18691
18692 // destroy others mutex
18693
18694 hc_thread_mutex_delete (mux_dispatcher);
18695 hc_thread_mutex_delete (mux_counter);
18696 hc_thread_mutex_delete (mux_display);
18697 hc_thread_mutex_delete (mux_adl);
18698
18699 // free memory
18700
18701 local_free (eff_restore_file);
18702 local_free (new_restore_file);
18703
18704 local_free (rd);
18705
18706 // tuning db
18707
18708 tuning_db_destroy (tuning_db);
18709
18710 // loopback
18711
18712 local_free (loopback_file);
18713
18714 if (loopback == 1) unlink (loopback_file);
18715
18716 // induction directory
18717
18718 if (induction_dir == NULL)
18719 {
18720 if (attack_mode != ATTACK_MODE_BF)
18721 {
18722 if (rmdir (induction_directory) == -1)
18723 {
18724 if (errno == ENOENT)
18725 {
18726 // good, we can ignore
18727 }
18728 else if (errno == ENOTEMPTY)
18729 {
18730 // good, we can ignore
18731 }
18732 else
18733 {
18734 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18735
18736 return (-1);
18737 }
18738 }
18739
18740 local_free (induction_directory);
18741 }
18742 }
18743
18744 // outfile-check directory
18745
18746 if (outfile_check_dir == NULL)
18747 {
18748 if (rmdir (outfile_check_directory) == -1)
18749 {
18750 if (errno == ENOENT)
18751 {
18752 // good, we can ignore
18753 }
18754 else if (errno == ENOTEMPTY)
18755 {
18756 // good, we can ignore
18757 }
18758 else
18759 {
18760 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18761
18762 return (-1);
18763 }
18764 }
18765
18766 local_free (outfile_check_directory);
18767 }
18768
18769 time_t proc_stop;
18770
18771 time (&proc_stop);
18772
18773 logfile_top_uint (proc_start);
18774 logfile_top_uint (proc_stop);
18775
18776 logfile_top_msg ("STOP");
18777
18778 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18779 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18780
18781 if (data.ocl) ocl_close (data.ocl);
18782
18783 if (data.devices_status == STATUS_ABORTED) return 2;
18784 if (data.devices_status == STATUS_QUIT) return 2;
18785 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18786 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18787 if (data.devices_status == STATUS_CRACKED) return 0;
18788
18789 return -1;
18790 }
Hashcat additions to support pwdhash