projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Limit scrypt to 64 threads has no performance impact but makes it easier to handle
[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 DARWIN
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 75
82 #define WORKLOAD_PROFILE 2
83 #define KERNEL_ACCEL 0
84 #define KERNEL_LOOPS 0
85 #define KERNEL_RULES 1024
86 #define KERNEL_COMBS 1024
87 #define KERNEL_BFS 1024
88 #define KERNEL_THREADS_MAX 256
89 #define KERNEL_THREADS_MAX_CPU 16
90 #define POWERTUNE_ENABLE 0
91 #define LOGFILE_DISABLE 0
92 #define SCRYPT_TMTO 0
93 #define OPENCL_VECTOR_WIDTH 0
94
95 #define WL_MODE_STDIN 1
96 #define WL_MODE_FILE 2
97 #define WL_MODE_MASK 3
98
99 #define HL_MODE_FILE 4
100 #define HL_MODE_ARG 5
101
102 #define HLFMTS_CNT 11
103 #define HLFMT_HASHCAT 0
104 #define HLFMT_PWDUMP 1
105 #define HLFMT_PASSWD 2
106 #define HLFMT_SHADOW 3
107 #define HLFMT_DCC 4
108 #define HLFMT_DCC2 5
109 #define HLFMT_NETNTLM1 7
110 #define HLFMT_NETNTLM2 8
111 #define HLFMT_NSLDAP 9
112 #define HLFMT_NSLDAPS 10
113
114 #define HLFMT_TEXT_HASHCAT "native hashcat"
115 #define HLFMT_TEXT_PWDUMP "pwdump"
116 #define HLFMT_TEXT_PASSWD "passwd"
117 #define HLFMT_TEXT_SHADOW "shadow"
118 #define HLFMT_TEXT_DCC "DCC"
119 #define HLFMT_TEXT_DCC2 "DCC 2"
120 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
121 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
122 #define HLFMT_TEXT_NSLDAP "nsldap"
123 #define HLFMT_TEXT_NSLDAPS "nsldaps"
124
125 #define ATTACK_MODE_STRAIGHT 0
126 #define ATTACK_MODE_COMBI 1
127 #define ATTACK_MODE_TOGGLE 2
128 #define ATTACK_MODE_BF 3
129 #define ATTACK_MODE_PERM 4
130 #define ATTACK_MODE_TABLE 5
131 #define ATTACK_MODE_HYBRID1 6
132 #define ATTACK_MODE_HYBRID2 7
133 #define ATTACK_MODE_NONE 100
134
135 #define ATTACK_KERN_STRAIGHT 0
136 #define ATTACK_KERN_COMBI 1
137 #define ATTACK_KERN_BF 3
138 #define ATTACK_KERN_NONE 100
139
140 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
141 #define ATTACK_EXEC_INSIDE_KERNEL 11
142
143 #define COMBINATOR_MODE_BASE_LEFT 10001
144 #define COMBINATOR_MODE_BASE_RIGHT 10002
145
146 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
147 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
148
149 #define MAX_CUT_TRIES 4
150
151 #define MAX_DICTSTAT 10000
152
153 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
154
155 #define NVIDIA_100PERCENTCPU_WORKAROUND 100
156
157 #define global_free(attr) \
158 { \
159 myfree ((void *) data.attr); \
160 \
161 data.attr = NULL; \
162 }
163
164 #define local_free(attr) \
165 { \
166 myfree ((void *) attr); \
167 \
168 attr = NULL; \
169 }
170
171 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
172 #define HC_API_CALL __stdcall
173 #else
174 #define HC_API_CALL
175 #endif
176
177 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
178 {
179 900,
180 0,
181 5100,
182 100,
183 1400,
184 10800,
185 1700,
186 5000,
187 10100,
188 6000,
189 6100,
190 6900,
191 11700,
192 11800,
193 400,
194 8900,
195 11900,
196 12000,
197 10900,
198 12100,
199 23,
200 2500,
201 5300,
202 5400,
203 5500,
204 5600,
205 7300,
206 7500,
207 13100,
208 8300,
209 11100,
210 11200,
211 11400,
212 121,
213 2611,
214 2711,
215 2811,
216 8400,
217 11,
218 2612,
219 7900,
220 21,
221 11000,
222 124,
223 10000,
224 3711,
225 7600,
226 12,
227 131,
228 132,
229 1731,
230 200,
231 300,
232 3100,
233 112,
234 12300,
235 8000,
236 141,
237 1441,
238 1600,
239 12600,
240 1421,
241 101,
242 111,
243 1711,
244 3000,
245 1000,
246 1100,
247 2100,
248 12800,
249 1500,
250 12400,
251 500,
252 3200,
253 7400,
254 1800,
255 122,
256 1722,
257 7100,
258 6300,
259 6700,
260 6400,
261 6500,
262 2400,
263 2410,
264 5700,
265 9200,
266 9300,
267 22,
268 501,
269 5800,
270 8100,
271 8500,
272 7200,
273 9900,
274 7700,
275 7800,
276 10300,
277 8600,
278 8700,
279 9100,
280 133,
281 13500,
282 11600,
283 13600,
284 12500,
285 13000,
286 13200,
287 13300,
288 6211,
289 6221,
290 6231,
291 6241,
292 13711,
293 13721,
294 13731,
295 13741,
296 13751,
297 13761,
298 8800,
299 12900,
300 12200,
301 9700,
302 9710,
303 9800,
304 9810,
305 9400,
306 9500,
307 9600,
308 10400,
309 10410,
310 10500,
311 10600,
312 10700,
313 9000,
314 5200,
315 6800,
316 6600,
317 8200,
318 11300,
319 12700,
320 13400,
321 125
322 };
323
324 /**
325 * types
326 */
327
328 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
329
330 /**
331 * globals
332 */
333
334 static unsigned int full01 = 0x01010101;
335 static unsigned int full80 = 0x80808080;
336
337 int SUPPRESS_OUTPUT = 0;
338
339 hc_thread_mutex_t mux_adl;
340 hc_thread_mutex_t mux_counter;
341 hc_thread_mutex_t mux_dispatcher;
342 hc_thread_mutex_t mux_display;
343
344 hc_global_data_t data;
345
346 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
347
348 const char *USAGE_MINI[] =
349 {
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "Try --help for more help.",
353 NULL
354 };
355
356 const char *USAGE_BIG[] =
357 {
358 "%s, advanced password recovery",
359 "",
360 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
361 "",
362 "- [ Options ] -",
363 "",
364 " Options Short / Long | Type | Description | Example",
365 "===============================+======+======================================================+=======================",
366 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
367 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
368 " -V, --version | | Print version |",
369 " -h, --help | | Print help |",
370 " --quiet | | Suppress output |",
371 " --hex-charset | | Assume charset is given in hex |",
372 " --hex-salt | | Assume salt is given in hex |",
373 " --hex-wordlist | | Assume words in wordlist is given in hex |",
374 " --force | | Ignore warnings |",
375 " --status | | Enable automatic update of the status-screen |",
376 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
377 " --machine-readable | | Display the status view in a machine readable format |",
378 " --loopback | | Add new plains to induct directory |",
379 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
380 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
381 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
382 " --markov-classic | | Enables classic markov-chains, no per-position |",
383 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
384 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
385 " --session | Str | Define specific session name | --session=mysession",
386 " --restore | | Restore session from --session |",
387 " --restore-disable | | Do not write restore file |",
388 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
389 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
390 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
391 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
392 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
393 " --stdout | | Do not crack a hash, instead print candidates only |",
394 " --show | | Compare hashlist with potfile; Show cracked hashes |",
395 " --left | | Compare hashlist with potfile; Show uncracked hashes |",
396 " --username | | Enable ignoring of usernames in hashfile |",
397 " --remove | | Enable remove of hash once it is cracked |",
398 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
399 " --potfile-disable | | Do not write potfile |",
400 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
401 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
402 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
403 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
404 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
405 " --logfile-disable | | Disable the logfile |",
406 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
407 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
408 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
409 " -b, --benchmark | | Run benchmark |",
410 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
411 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
412 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
413 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
414 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
415 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
416 " -D, --opencl-device-types | Str | OpenCL device-types to use, separate with comma | -D 1",
417 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
418 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
419 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
420 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
421 " --nvidia-spin-damp | Num | Workaround NVidias CPU burning loop bug, in percent | --nvidia-spin-damp=50",
422 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
423 #ifdef HAVE_HWMON
424 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
425 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
426 " --powertune-enable | | Enable power tuning, restores settings when finished |",
427 #endif
428 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
429 " -s, --skip | Num | Skip X words from the start | -s 1000000",
430 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
431 " --keyspace | | Show keyspace base:mod values and quit |",
432 " -j, --rule-left | Rule | Single rule applied to each word from left wordlist | -j 'c'",
433 " -k, --rule-right | Rule | Single rule applied to each word from right wordlist | -k '^-'",
434 " -r, --rules-file | File | Multiple rules applied to each word from wordlists | -r rules/best64.rule",
435 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
436 " --generate-rules-func-min | Num | Force min X funcs per rule |",
437 " --generate-rules-func-max | Num | Force max X funcs per rule |",
438 " --generate-rules-seed | Num | Force RNG seed set to X |",
439 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
440 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
441 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
442 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
443 " -i, --increment | | Enable mask increment mode |",
444 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
445 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
446 "",
447 "- [ Hash modes ] -",
448 "",
449 " # | Name | Category",
450 " ======+==================================================+======================================",
451 " 900 | MD4 | Raw Hash",
452 " 0 | MD5 | Raw Hash",
453 " 5100 | Half MD5 | Raw Hash",
454 " 100 | SHA1 | Raw Hash",
455 " 10800 | SHA-384 | Raw Hash",
456 " 1400 | SHA-256 | Raw Hash",
457 " 1700 | SHA-512 | Raw Hash",
458 " 5000 | SHA-3(Keccak) | Raw Hash",
459 " 10100 | SipHash | Raw Hash",
460 " 6000 | RipeMD160 | Raw Hash",
461 " 6100 | Whirlpool | Raw Hash",
462 " 6900 | GOST R 34.11-94 | Raw Hash",
463 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
464 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
465 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
466 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
467 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
468 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
469 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
470 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
471 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
472 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
473 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
474 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
475 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
476 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
477 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
478 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
479 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
480 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
481 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
482 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
483 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
484 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
485 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
486 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
487 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
488 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
489 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
490 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
491 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
492 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
493 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
494 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
495 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
496 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
497 " 400 | phpass | Generic KDF",
498 " 8900 | scrypt | Generic KDF",
499 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
500 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
501 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
502 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
503 " 23 | Skype | Network protocols",
504 " 2500 | WPA/WPA2 | Network protocols",
505 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
506 " 5300 | IKE-PSK MD5 | Network protocols",
507 " 5400 | IKE-PSK SHA1 | Network protocols",
508 " 5500 | NetNTLMv1 | Network protocols",
509 " 5500 | NetNTLMv1 + ESS | Network protocols",
510 " 5600 | NetNTLMv2 | Network protocols",
511 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
512 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
513 " 8300 | DNSSEC (NSEC3) | Network protocols",
514 " 10200 | Cram MD5 | Network protocols",
515 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
516 " 11200 | MySQL CRAM (SHA1) | Network protocols",
517 " 11400 | SIP digest authentication (MD5) | Network protocols",
518 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
519 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
520 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
521 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
522 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
523 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
524 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
525 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
526 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
527 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
528 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
529 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
530 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
531 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
532 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
533 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
534 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
535 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
536 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
537 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
538 " 12 | PostgreSQL | Database Server",
539 " 131 | MSSQL(2000) | Database Server",
540 " 132 | MSSQL(2005) | Database Server",
541 " 1731 | MSSQL(2012) | Database Server",
542 " 1731 | MSSQL(2014) | Database Server",
543 " 200 | MySQL323 | Database Server",
544 " 300 | MySQL4.1/MySQL5 | Database Server",
545 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
546 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
547 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
548 " 8000 | Sybase ASE | Database Server",
549 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
550 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
551 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
552 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
553 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
554 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
555 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
556 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
557 " 11500 | CRC32 | Checksums",
558 " 3000 | LM | Operating-Systems",
559 " 1000 | NTLM | Operating-Systems",
560 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
561 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
562 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
563 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
564 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
565 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
566 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
567 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
568 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
569 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
570 " 1722 | OSX v10.7 | Operating-Systems",
571 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
572 " 6300 | AIX {smd5} | Operating-Systems",
573 " 6700 | AIX {ssha1} | Operating-Systems",
574 " 6400 | AIX {ssha256} | Operating-Systems",
575 " 6500 | AIX {ssha512} | Operating-Systems",
576 " 2400 | Cisco-PIX | Operating-Systems",
577 " 2410 | Cisco-ASA | Operating-Systems",
578 " 500 | Cisco-IOS $1$ | Operating-Systems",
579 " 5700 | Cisco-IOS $4$ | Operating-Systems",
580 " 9200 | Cisco-IOS $8$ | Operating-Systems",
581 " 9300 | Cisco-IOS $9$ | Operating-Systems",
582 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
583 " 501 | Juniper IVE | Operating-Systems",
584 " 5800 | Android PIN | Operating-Systems",
585 " 13800 | Windows 8+ phone PIN/Password | Operating-Systems",
586 " 8100 | Citrix Netscaler | Operating-Systems",
587 " 8500 | RACF | Operating-Systems",
588 " 7200 | GRUB 2 | Operating-Systems",
589 " 9900 | Radmin2 | Operating-Systems",
590 " 125 | ArubaOS | Operating-Systems",
591 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
592 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
593 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
594 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
595 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
596 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
597 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
598 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
599 " 11600 | 7-Zip | Archives",
600 " 12500 | RAR3-hp | Archives",
601 " 13000 | RAR5 | Archives",
602 " 13200 | AxCrypt | Archives",
603 " 13300 | AxCrypt in memory SHA1 | Archives",
604 " 13600 | WinZip | Archives",
605 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
606 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
607 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
608 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
609 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
610 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
611 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
612 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
613 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
614 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
615 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
616 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
617 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
618 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
619 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
620 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
621 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
622 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
623 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
624 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
625 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
626 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
627 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
628 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
629 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
630 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
631 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
632 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
633 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
634 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
635 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
636 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
637 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
638 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
639 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
640 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
641 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
642 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
643 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
644 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
645 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
646 " 9400 | MS Office 2007 | Documents",
647 " 9500 | MS Office 2010 | Documents",
648 " 9600 | MS Office 2013 | Documents",
649 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
650 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
651 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
652 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
653 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
654 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
655 " 9000 | Password Safe v2 | Password Managers",
656 " 5200 | Password Safe v3 | Password Managers",
657 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
658 " 6600 | 1Password, agilekeychain | Password Managers",
659 " 8200 | 1Password, cloudkeychain | Password Managers",
660 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
661 " 12700 | Blockchain, My Wallet | Password Managers",
662 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
663 "",
664 "- [ Outfile Formats ] -",
665 "",
666 " # | Format",
667 " ===+========",
668 " 1 | hash[:salt]",
669 " 2 | plain",
670 " 3 | hash[:salt]:plain",
671 " 4 | hex_plain",
672 " 5 | hash[:salt]:hex_plain",
673 " 6 | plain:hex_plain",
674 " 7 | hash[:salt]:plain:hex_plain",
675 " 8 | crackpos",
676 " 9 | hash[:salt]:crack_pos",
677 " 10 | plain:crack_pos",
678 " 11 | hash[:salt]:plain:crack_pos",
679 " 12 | hex_plain:crack_pos",
680 " 13 | hash[:salt]:hex_plain:crack_pos",
681 " 14 | plain:hex_plain:crack_pos",
682 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
683 "",
684 "- [ Rule Debugging Modes ] -",
685 "",
686 " # | Format",
687 " ===+========",
688 " 1 | Finding-Rule",
689 " 2 | Original-Word",
690 " 3 | Original-Word:Finding-Rule",
691 " 4 | Original-Word:Finding-Rule:Processed-Word",
692 "",
693 "- [ Attack Modes ] -",
694 "",
695 " # | Mode",
696 " ===+======",
697 " 0 | Straight",
698 " 1 | Combination",
699 " 3 | Brute-force",
700 " 6 | Hybrid Wordlist + Mask",
701 " 7 | Hybrid Mask + Wordlist",
702 "",
703 "- [ Built-in Charsets ] -",
704 "",
705 " ? | Charset",
706 " ===+=========",
707 " l | abcdefghijklmnopqrstuvwxyz",
708 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
709 " d | 0123456789",
710 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
711 " a | ?l?u?d?s",
712 " b | 0x00 - 0xff",
713 "",
714 "- [ OpenCL Device Types ] -",
715 "",
716 " # | Device Type",
717 " ===+=============",
718 " 1 | CPU",
719 " 2 | GPU",
720 " 3 | FPGA, DSP, Co-Processor",
721 "",
722 "- [ Workload Profiles ] -",
723 "",
724 " # | Performance | Runtime | Power Consumption | Desktop Impact",
725 " ===+=============+=========+===================+=================",
726 " 1 | Low | 2 ms | Low | Minimal",
727 " 2 | Default | 12 ms | Economic | Noticeable",
728 " 3 | High | 96 ms | High | Unresponsive",
729 " 4 | Nightmare | 480 ms | Insane | Headless",
730 "",
731 "- [ Basic Examples ] -",
732 "",
733 " Attack- | Hash- |",
734 " Mode | Type | Example command",
735 " ==================+=======+==================================================================",
736 " Wordlist | $P$ | %s -a 0 -m 400 example400.hash example.dict",
737 " Wordlist + Rules | MD5 | %s -a 0 -m 0 example0.hash example.dict -r rules/best64.rule",
738 " Brute-Force | MD5 | %s -a 3 -m 0 example0.hash ?a?a?a?a?a?a",
739 " Combinator | MD5 | %s -a 1 -m 0 example0.hash example.dict example.dict",
740 "",
741 "If you still have no idea what just happened try following pages:",
742 "",
743 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
744 "* https://hashcat.net/wiki/#frequently_asked_questions",
745 NULL
746 };
747
748 /**
749 * hashcat specific functions
750 */
751
752 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
753 {
754 int exec_pos = (int) device_param->exec_pos - last_num_entries;
755
756 if (exec_pos < 0) exec_pos += EXEC_CACHE;
757
758 double exec_ms_sum = 0;
759
760 int exec_ms_cnt = 0;
761
762 for (int i = 0; i < last_num_entries; i++)
763 {
764 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
765
766 if (exec_ms)
767 {
768 exec_ms_sum += exec_ms;
769
770 exec_ms_cnt++;
771 }
772 }
773
774 if (exec_ms_cnt == 0) return 0;
775
776 return exec_ms_sum / exec_ms_cnt;
777 }
778
779 void status_display_machine_readable ()
780 {
781 FILE *out = stdout;
782
783 fprintf (out, "STATUS\t%u\t", data.devices_status);
784
785 /**
786 * speed new
787 */
788
789 fprintf (out, "SPEED\t");
790
791 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
792 {
793 hc_device_param_t *device_param = &data.devices_param[device_id];
794
795 if (device_param->skipped) continue;
796
797 u64 speed_cnt = 0;
798 double speed_ms = 0;
799
800 for (int i = 0; i < SPEED_CACHE; i++)
801 {
802 speed_cnt += device_param->speed_cnt[i];
803 speed_ms += device_param->speed_ms[i];
804 }
805
806 speed_cnt /= SPEED_CACHE;
807 speed_ms /= SPEED_CACHE;
808
809 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
810 }
811
812 /**
813 * exec time
814 */
815
816 fprintf (out, "EXEC_RUNTIME\t");
817
818 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
819 {
820 hc_device_param_t *device_param = &data.devices_param[device_id];
821
822 if (device_param->skipped) continue;
823
824 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
825
826 fprintf (out, "%f\t", exec_ms_avg);
827 }
828
829 /**
830 * words_cur
831 */
832
833 u64 words_cur = get_lowest_words_done ();
834
835 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
836
837 /**
838 * counter
839 */
840
841 u64 progress_total = data.words_cnt * data.salts_cnt;
842
843 u64 all_done = 0;
844 u64 all_rejected = 0;
845 u64 all_restored = 0;
846
847 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
848 {
849 all_done += data.words_progress_done[salt_pos];
850 all_rejected += data.words_progress_rejected[salt_pos];
851 all_restored += data.words_progress_restored[salt_pos];
852 }
853
854 u64 progress_cur = all_restored + all_done + all_rejected;
855 u64 progress_end = progress_total;
856
857 u64 progress_skip = 0;
858
859 if (data.skip)
860 {
861 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
862
863 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
864 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
865 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
866 }
867
868 if (data.limit)
869 {
870 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
871
872 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
873 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
874 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
875 }
876
877 u64 progress_cur_relative_skip = progress_cur - progress_skip;
878 u64 progress_end_relative_skip = progress_end - progress_skip;
879
880 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
881
882 /**
883 * cracks
884 */
885
886 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
887 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
888
889 /**
890 * temperature
891 */
892
893 #ifdef HAVE_HWMON
894 if (data.gpu_temp_disable == 0)
895 {
896 fprintf (out, "TEMP\t");
897
898 hc_thread_mutex_lock (mux_adl);
899
900 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
901 {
902 hc_device_param_t *device_param = &data.devices_param[device_id];
903
904 if (device_param->skipped) continue;
905
906 int temp = hm_get_temperature_with_device_id (device_id);
907
908 fprintf (out, "%d\t", temp);
909 }
910
911 hc_thread_mutex_unlock (mux_adl);
912 }
913 #endif // HAVE_HWMON
914
915 /**
916 * flush
917 */
918
919 fputs (EOL, out);
920 fflush (out);
921 }
922
923 void status_display ()
924 {
925 if (data.devices_status == STATUS_INIT) return;
926 if (data.devices_status == STATUS_STARTING) 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
1686 if (data.machine_readable == 1)
1687 {
1688 status_benchmark_automate ();
1689
1690 return;
1691 }
1692
1693 u64 speed_cnt[DEVICES_MAX] = { 0 };
1694 double speed_ms[DEVICES_MAX] = { 0 };
1695
1696 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1697 {
1698 hc_device_param_t *device_param = &data.devices_param[device_id];
1699
1700 if (device_param->skipped) continue;
1701
1702 speed_cnt[device_id] = device_param->speed_cnt[0];
1703 speed_ms[device_id] = device_param->speed_ms[0];
1704 }
1705
1706 double hashes_all_ms = 0;
1707
1708 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1709
1710 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1711 {
1712 hc_device_param_t *device_param = &data.devices_param[device_id];
1713
1714 if (device_param->skipped) continue;
1715
1716 hashes_dev_ms[device_id] = 0;
1717
1718 if (speed_ms[device_id])
1719 {
1720 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1721
1722 hashes_all_ms += hashes_dev_ms[device_id];
1723 }
1724 }
1725
1726 /**
1727 * exec time
1728 */
1729
1730 double exec_all_ms[DEVICES_MAX] = { 0 };
1731
1732 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1733 {
1734 hc_device_param_t *device_param = &data.devices_param[device_id];
1735
1736 if (device_param->skipped) continue;
1737
1738 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1739
1740 exec_all_ms[device_id] = exec_ms_avg;
1741 }
1742
1743 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1744 {
1745 hc_device_param_t *device_param = &data.devices_param[device_id];
1746
1747 if (device_param->skipped) continue;
1748
1749 char display_dev_cur[16] = { 0 };
1750
1751 strncpy (display_dev_cur, "0.00", 4);
1752
1753 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1754
1755 if (data.devices_active >= 10)
1756 {
1757 log_info ("Speed.Dev.#%d: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1758 }
1759 else
1760 {
1761 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1762 }
1763 }
1764
1765 char display_all_cur[16] = { 0 };
1766
1767 strncpy (display_all_cur, "0.00", 4);
1768
1769 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1770
1771 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1772 }
1773
1774 /**
1775 * hashcat -only- functions
1776 */
1777
1778 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1779 {
1780 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1781 {
1782 if (attack_kern == ATTACK_KERN_STRAIGHT)
1783 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1784 else if (attack_kern == ATTACK_KERN_COMBI)
1785 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1786 else if (attack_kern == ATTACK_KERN_BF)
1787 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1788 }
1789 else
1790 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1791 }
1792
1793 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)
1794 {
1795 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1796 {
1797 if (attack_kern == ATTACK_KERN_STRAIGHT)
1798 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1799 else if (attack_kern == ATTACK_KERN_COMBI)
1800 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1801 else if (attack_kern == ATTACK_KERN_BF)
1802 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1803 }
1804 else
1805 {
1806 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1807 }
1808 }
1809
1810 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1811 {
1812 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1813 {
1814 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1815 }
1816 else
1817 {
1818 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1819 }
1820 }
1821
1822 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)
1823 {
1824 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1825 {
1826 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1827 }
1828 else
1829 {
1830 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1831 }
1832 }
1833
1834 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1835 {
1836 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1837 }
1838
1839 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1840 {
1841 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1842 }
1843
1844 static char *filename_from_filepath (char *filepath)
1845 {
1846 char *ptr = NULL;
1847
1848 if ((ptr = strrchr (filepath, '/')) != NULL)
1849 {
1850 ptr++;
1851 }
1852 else if ((ptr = strrchr (filepath, '\\')) != NULL)
1853 {
1854 ptr++;
1855 }
1856 else
1857 {
1858 ptr = filepath;
1859 }
1860
1861 return ptr;
1862 }
1863
1864 static uint convert_from_hex (char *line_buf, const uint line_len)
1865 {
1866 if (line_len & 1) return (line_len); // not in hex
1867
1868 if (data.hex_wordlist == 1)
1869 {
1870 uint i;
1871 uint j;
1872
1873 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1874 {
1875 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1876 }
1877
1878 memset (line_buf + i, 0, line_len - i);
1879
1880 return (i);
1881 }
1882 else if (line_len >= 6) // $HEX[] = 6
1883 {
1884 if (line_buf[0] != '$') return (line_len);
1885 if (line_buf[1] != 'H') return (line_len);
1886 if (line_buf[2] != 'E') return (line_len);
1887 if (line_buf[3] != 'X') return (line_len);
1888 if (line_buf[4] != '[') return (line_len);
1889 if (line_buf[line_len - 1] != ']') return (line_len);
1890
1891 uint i;
1892 uint j;
1893
1894 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1895 {
1896 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1897 }
1898
1899 memset (line_buf + i, 0, line_len - i);
1900
1901 return (i);
1902 }
1903
1904 return (line_len);
1905 }
1906
1907 static void clear_prompt ()
1908 {
1909 fputc ('\r', stdout);
1910
1911 for (size_t i = 0; i < strlen (PROMPT); i++)
1912 {
1913 fputc (' ', stdout);
1914 }
1915
1916 fputc ('\r', stdout);
1917
1918 fflush (stdout);
1919 }
1920
1921 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1922 {
1923 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);
1924 }
1925
1926 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1927 {
1928 char *outfile = data.outfile;
1929 uint quiet = data.quiet;
1930 FILE *pot_fp = data.pot_fp;
1931 uint loopback = data.loopback;
1932 uint debug_mode = data.debug_mode;
1933 char *debug_file = data.debug_file;
1934
1935 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1936 int debug_rule_len = 0; // -1 error
1937 uint debug_plain_len = 0;
1938
1939 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1940
1941 // hash
1942
1943 char out_buf[HCBUFSIZ] = { 0 };
1944
1945 const u32 salt_pos = plain->salt_pos;
1946 const u32 digest_pos = plain->digest_pos; // relative
1947 const u32 gidvid = plain->gidvid;
1948 const u32 il_pos = plain->il_pos;
1949
1950 ascii_digest (out_buf, salt_pos, digest_pos);
1951
1952 // plain
1953
1954 u64 crackpos = device_param->words_off;
1955
1956 uint plain_buf[16] = { 0 };
1957
1958 u8 *plain_ptr = (u8 *) plain_buf;
1959
1960 unsigned int plain_len = 0;
1961
1962 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1963 {
1964 pw_t pw;
1965
1966 gidd_to_pw_t (device_param, gidvid, &pw);
1967
1968 for (int i = 0; i < 16; i++)
1969 {
1970 plain_buf[i] = pw.i[i];
1971 }
1972
1973 plain_len = pw.pw_len;
1974
1975 const uint off = device_param->innerloop_pos + il_pos;
1976
1977 if (debug_mode > 0)
1978 {
1979 debug_rule_len = 0;
1980
1981 // save rule
1982 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1983 {
1984 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1985
1986 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1987 }
1988
1989 // save plain
1990 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1991 {
1992 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1993
1994 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1995
1996 debug_plain_len = plain_len;
1997 }
1998 }
1999
2000 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2001
2002 crackpos += gidvid;
2003 crackpos *= data.kernel_rules_cnt;
2004 crackpos += device_param->innerloop_pos + il_pos;
2005
2006 if (plain_len > data.pw_max) plain_len = data.pw_max;
2007 }
2008 else if (data.attack_mode == ATTACK_MODE_COMBI)
2009 {
2010 pw_t pw;
2011
2012 gidd_to_pw_t (device_param, gidvid, &pw);
2013
2014 for (int i = 0; i < 16; i++)
2015 {
2016 plain_buf[i] = pw.i[i];
2017 }
2018
2019 plain_len = pw.pw_len;
2020
2021 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2022 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2023
2024 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2025 {
2026 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2027 }
2028 else
2029 {
2030 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2031
2032 memcpy (plain_ptr, comb_buf, comb_len);
2033 }
2034
2035 plain_len += comb_len;
2036
2037 crackpos += gidvid;
2038 crackpos *= data.combs_cnt;
2039 crackpos += device_param->innerloop_pos + il_pos;
2040
2041 if (data.pw_max != PW_DICTMAX1)
2042 {
2043 if (plain_len > data.pw_max) plain_len = data.pw_max;
2044 }
2045 }
2046 else if (data.attack_mode == ATTACK_MODE_BF)
2047 {
2048 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2049 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2050
2051 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2052 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2053
2054 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2055 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2056
2057 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2058 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2059
2060 plain_len = data.css_cnt;
2061
2062 crackpos += gidvid;
2063 crackpos *= data.bfs_cnt;
2064 crackpos += device_param->innerloop_pos + il_pos;
2065 }
2066 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2067 {
2068 pw_t pw;
2069
2070 gidd_to_pw_t (device_param, gidvid, &pw);
2071
2072 for (int i = 0; i < 16; i++)
2073 {
2074 plain_buf[i] = pw.i[i];
2075 }
2076
2077 plain_len = pw.pw_len;
2078
2079 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2080
2081 uint start = 0;
2082 uint stop = device_param->kernel_params_mp_buf32[4];
2083
2084 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2085
2086 plain_len += start + stop;
2087
2088 crackpos += gidvid;
2089 crackpos *= data.combs_cnt;
2090 crackpos += device_param->innerloop_pos + il_pos;
2091
2092 if (data.pw_max != PW_DICTMAX1)
2093 {
2094 if (plain_len > data.pw_max) plain_len = data.pw_max;
2095 }
2096 }
2097 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2098 {
2099 pw_t pw;
2100
2101 gidd_to_pw_t (device_param, gidvid, &pw);
2102
2103 for (int i = 0; i < 16; i++)
2104 {
2105 plain_buf[i] = pw.i[i];
2106 }
2107
2108 plain_len = pw.pw_len;
2109
2110 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2111
2112 uint start = 0;
2113 uint stop = device_param->kernel_params_mp_buf32[4];
2114
2115 memmove (plain_ptr + stop, plain_ptr, plain_len);
2116
2117 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2118
2119 plain_len += start + stop;
2120
2121 crackpos += gidvid;
2122 crackpos *= data.combs_cnt;
2123 crackpos += device_param->innerloop_pos + il_pos;
2124
2125 if (data.pw_max != PW_DICTMAX1)
2126 {
2127 if (plain_len > data.pw_max) plain_len = data.pw_max;
2128 }
2129 }
2130
2131 if (data.attack_mode == ATTACK_MODE_BF)
2132 {
2133 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2134 {
2135 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2136 {
2137 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2138 {
2139 plain_len = plain_len - data.salts_buf[0].salt_len;
2140 }
2141 }
2142
2143 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2144 {
2145 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2146 {
2147 plain_ptr[j] = plain_ptr[i];
2148 }
2149
2150 plain_len = plain_len / 2;
2151 }
2152 }
2153 }
2154
2155 // if enabled, update also the potfile
2156
2157 if (pot_fp)
2158 {
2159 lock_file (pot_fp);
2160
2161 fprintf (pot_fp, "%s:", out_buf);
2162
2163 format_plain (pot_fp, plain_ptr, plain_len, 1);
2164
2165 fputc ('\n', pot_fp);
2166
2167 fflush (pot_fp);
2168
2169 unlock_file (pot_fp);
2170 }
2171
2172 // outfile
2173
2174 FILE *out_fp = NULL;
2175
2176 if (outfile != NULL)
2177 {
2178 if ((out_fp = fopen (outfile, "ab")) == NULL)
2179 {
2180 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2181
2182 out_fp = stdout;
2183 }
2184
2185 lock_file (out_fp);
2186 }
2187 else
2188 {
2189 out_fp = stdout;
2190
2191 if (quiet == 0) clear_prompt ();
2192 }
2193
2194 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2195
2196 if (outfile != NULL)
2197 {
2198 if (out_fp != stdout)
2199 {
2200 fclose (out_fp);
2201 }
2202 }
2203 else
2204 {
2205 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2206 {
2207 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2208 {
2209 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2210 if (quiet == 0) fflush (stdout);
2211 }
2212 }
2213 }
2214
2215 // loopback
2216
2217 if (loopback)
2218 {
2219 char *loopback_file = data.loopback_file;
2220
2221 FILE *fb_fp = NULL;
2222
2223 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2224 {
2225 lock_file (fb_fp);
2226
2227 format_plain (fb_fp, plain_ptr, plain_len, 1);
2228
2229 fputc ('\n', fb_fp);
2230
2231 fclose (fb_fp);
2232 }
2233 }
2234
2235 // (rule) debug mode
2236
2237 // the next check implies that:
2238 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2239 // - debug_mode > 0
2240
2241 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2242 {
2243 if (debug_rule_len < 0) debug_rule_len = 0;
2244
2245 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2246
2247 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2248
2249 if ((quiet == 0) && (debug_file == NULL))
2250 {
2251 fprintf (stdout, "%s", PROMPT);
2252
2253 fflush (stdout);
2254 }
2255 }
2256 }
2257
2258 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2259 {
2260 salt_t *salt_buf = &data.salts_buf[salt_pos];
2261
2262 u32 num_cracked;
2263
2264 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2265
2266 if (num_cracked)
2267 {
2268 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2269
2270 log_info_nn ("");
2271
2272 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2273
2274 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);
2275
2276 uint cpt_cracked = 0;
2277
2278 hc_thread_mutex_lock (mux_display);
2279
2280 for (uint i = 0; i < num_cracked; i++)
2281 {
2282 const uint hash_pos = cracked[i].hash_pos;
2283
2284 if (data.digests_shown[hash_pos] == 1) continue;
2285
2286 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2287 {
2288 data.digests_shown[hash_pos] = 1;
2289
2290 data.digests_done++;
2291
2292 cpt_cracked++;
2293
2294 salt_buf->digests_done++;
2295
2296 if (salt_buf->digests_done == salt_buf->digests_cnt)
2297 {
2298 data.salts_shown[salt_pos] = 1;
2299
2300 data.salts_done++;
2301 }
2302 }
2303
2304 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2305
2306 check_hash (device_param, &cracked[i]);
2307 }
2308
2309 hc_thread_mutex_unlock (mux_display);
2310
2311 myfree (cracked);
2312
2313 if (cpt_cracked > 0)
2314 {
2315 hc_thread_mutex_lock (mux_display);
2316
2317 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2318 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2319
2320 data.cpt_pos++;
2321
2322 data.cpt_total += cpt_cracked;
2323
2324 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2325
2326 hc_thread_mutex_unlock (mux_display);
2327 }
2328
2329 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2330 {
2331 // we need to reset cracked state on the device
2332 // otherwise host thinks again and again the hash was cracked
2333 // and returns invalid password each time
2334
2335 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2336
2337 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);
2338 }
2339
2340 num_cracked = 0;
2341
2342 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2343 }
2344 }
2345
2346 // stolen from princeprocessor ;)
2347
2348 typedef struct
2349 {
2350 FILE *fp;
2351
2352 char buf[BUFSIZ];
2353 int len;
2354
2355 } out_t;
2356
2357 static void out_flush (out_t *out)
2358 {
2359 fwrite (out->buf, 1, out->len, out->fp);
2360
2361 out->len = 0;
2362 }
2363
2364 static void out_push (out_t *out, const u8 *pw_buf, const int pw_len)
2365 {
2366 char *ptr = out->buf + out->len;
2367
2368 memcpy (ptr, pw_buf, pw_len);
2369
2370 ptr[pw_len] = '\n';
2371
2372 out->len += pw_len + 1;
2373
2374 if (out->len >= BUFSIZ - 100)
2375 {
2376 out_flush (out);
2377 }
2378 }
2379
2380 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2381 {
2382 out_t out;
2383
2384 out.fp = stdout;
2385 out.len = 0;
2386
2387 uint plain_buf[16] = { 0 };
2388
2389 u8 *plain_ptr = (u8 *) plain_buf;
2390
2391 uint plain_len = 0;
2392
2393 const uint il_cnt = device_param->kernel_params_buf32[30]; // ugly, i know
2394
2395 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2396 {
2397 pw_t pw;
2398
2399 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2400 {
2401 gidd_to_pw_t (device_param, gidvid, &pw);
2402
2403 const uint pos = device_param->innerloop_pos;
2404
2405 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2406 {
2407 for (int i = 0; i < 8; i++)
2408 {
2409 plain_buf[i] = pw.i[i];
2410 }
2411
2412 plain_len = pw.pw_len;
2413
2414 plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2415
2416 if (plain_len > data.pw_max) plain_len = data.pw_max;
2417
2418 out_push (&out, plain_ptr, plain_len);
2419 }
2420 }
2421 }
2422 else if (data.attack_mode == ATTACK_MODE_COMBI)
2423 {
2424 pw_t pw;
2425
2426 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2427 {
2428 gidd_to_pw_t (device_param, gidvid, &pw);
2429
2430 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2431 {
2432 for (int i = 0; i < 8; i++)
2433 {
2434 plain_buf[i] = pw.i[i];
2435 }
2436
2437 plain_len = pw.pw_len;
2438
2439 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2440 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2441
2442 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2443 {
2444 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2445 }
2446 else
2447 {
2448 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2449
2450 memcpy (plain_ptr, comb_buf, comb_len);
2451 }
2452
2453 plain_len += comb_len;
2454
2455 if (data.pw_max != PW_DICTMAX1)
2456 {
2457 if (plain_len > data.pw_max) plain_len = data.pw_max;
2458 }
2459
2460 out_push (&out, plain_ptr, plain_len);
2461 }
2462 }
2463 }
2464 else if (data.attack_mode == ATTACK_MODE_BF)
2465 {
2466 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2467 {
2468 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2469 {
2470 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2471 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2472
2473 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2474 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2475
2476 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2477 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2478
2479 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2480 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2481
2482 plain_len = data.css_cnt;
2483
2484 out_push (&out, plain_ptr, plain_len);
2485 }
2486 }
2487 }
2488 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2489 {
2490 pw_t pw;
2491
2492 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2493 {
2494 gidd_to_pw_t (device_param, gidvid, &pw);
2495
2496 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2497 {
2498 for (int i = 0; i < 8; i++)
2499 {
2500 plain_buf[i] = pw.i[i];
2501 }
2502
2503 plain_len = pw.pw_len;
2504
2505 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2506
2507 uint start = 0;
2508 uint stop = device_param->kernel_params_mp_buf32[4];
2509
2510 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2511
2512 plain_len += start + stop;
2513
2514 out_push (&out, plain_ptr, plain_len);
2515 }
2516 }
2517 }
2518 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2519 {
2520 pw_t pw;
2521
2522 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2523 {
2524 gidd_to_pw_t (device_param, gidvid, &pw);
2525
2526 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2527 {
2528 for (int i = 0; i < 8; i++)
2529 {
2530 plain_buf[i] = pw.i[i];
2531 }
2532
2533 plain_len = pw.pw_len;
2534
2535 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2536
2537 uint start = 0;
2538 uint stop = device_param->kernel_params_mp_buf32[4];
2539
2540 memmove (plain_ptr + stop, plain_ptr, plain_len);
2541
2542 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2543
2544 plain_len += start + stop;
2545
2546 out_push (&out, plain_ptr, plain_len);
2547 }
2548 }
2549 }
2550
2551 out_flush (&out);
2552 }
2553
2554 static void save_hash ()
2555 {
2556 char *hashfile = data.hashfile;
2557
2558 char new_hashfile[256] = { 0 };
2559 char old_hashfile[256] = { 0 };
2560
2561 snprintf (new_hashfile, 255, "%s.new", hashfile);
2562 snprintf (old_hashfile, 255, "%s.old", hashfile);
2563
2564 unlink (new_hashfile);
2565
2566 char separator = data.separator;
2567
2568 FILE *fp = fopen (new_hashfile, "wb");
2569
2570 if (fp == NULL)
2571 {
2572 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2573
2574 exit (-1);
2575 }
2576
2577 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2578 {
2579 if (data.salts_shown[salt_pos] == 1) continue;
2580
2581 salt_t *salt_buf = &data.salts_buf[salt_pos];
2582
2583 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2584 {
2585 uint idx = salt_buf->digests_offset + digest_pos;
2586
2587 if (data.digests_shown[idx] == 1) continue;
2588
2589 if (data.hash_mode != 2500)
2590 {
2591 if (data.username == 1)
2592 {
2593 user_t *user = data.hash_info[idx]->user;
2594
2595 uint i;
2596
2597 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2598
2599 fputc (separator, fp);
2600 }
2601
2602 char out_buf[HCBUFSIZ]; // scratch buffer
2603
2604 out_buf[0] = 0;
2605
2606 ascii_digest (out_buf, salt_pos, digest_pos);
2607
2608 fputs (out_buf, fp);
2609
2610 fputc ('\n', fp);
2611 }
2612 else
2613 {
2614 hccap_t hccap;
2615
2616 to_hccap_t (&hccap, salt_pos, digest_pos);
2617
2618 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2619 }
2620 }
2621 }
2622
2623 fflush (fp);
2624
2625 fclose (fp);
2626
2627 unlink (old_hashfile);
2628
2629 if (rename (hashfile, old_hashfile) != 0)
2630 {
2631 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2632
2633 exit (-1);
2634 }
2635
2636 unlink (hashfile);
2637
2638 if (rename (new_hashfile, hashfile) != 0)
2639 {
2640 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2641
2642 exit (-1);
2643 }
2644
2645 unlink (old_hashfile);
2646 }
2647
2648 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2649 {
2650 uint num_elements = num;
2651
2652 device_param->kernel_params_buf32[33] = data.combs_mode;
2653 device_param->kernel_params_buf32[34] = num;
2654
2655 uint kernel_threads = device_param->kernel_threads;
2656
2657 while (num_elements % kernel_threads) num_elements++;
2658
2659 cl_kernel kernel = NULL;
2660
2661 switch (kern_run)
2662 {
2663 case KERN_RUN_1: kernel = device_param->kernel1; break;
2664 case KERN_RUN_12: kernel = device_param->kernel12; break;
2665 case KERN_RUN_2: kernel = device_param->kernel2; break;
2666 case KERN_RUN_23: kernel = device_param->kernel23; break;
2667 case KERN_RUN_3: kernel = device_param->kernel3; break;
2668 }
2669
2670 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2671 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2672 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2673 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2674 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2675 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2676 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2677 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2678 hc_clSetKernelArg (data.ocl, kernel, 32, sizeof (cl_uint), device_param->kernel_params[32]);
2679 hc_clSetKernelArg (data.ocl, kernel, 33, sizeof (cl_uint), device_param->kernel_params[33]);
2680 hc_clSetKernelArg (data.ocl, kernel, 34, sizeof (cl_uint), device_param->kernel_params[34]);
2681
2682 cl_event event;
2683
2684 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2685 {
2686 const size_t global_work_size[3] = { num_elements, 32, 1 };
2687 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2688
2689 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2690 }
2691 else
2692 {
2693 if (kern_run == KERN_RUN_2)
2694 {
2695 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2696 {
2697 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2698 }
2699 }
2700
2701 while (num_elements % kernel_threads) num_elements++;
2702
2703 const size_t global_work_size[3] = { num_elements, 1, 1 };
2704 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2705
2706 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2707 }
2708
2709 hc_clFlush (data.ocl, device_param->command_queue);
2710
2711 if (device_param->nvidia_spin_damp)
2712 {
2713 if (data.devices_status == STATUS_RUNNING)
2714 {
2715 if (iteration < EXPECTED_ITERATIONS)
2716 {
2717 switch (kern_run)
2718 {
2719 case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration] * device_param->nvidia_spin_damp); break;
2720 case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration] * device_param->nvidia_spin_damp); break;
2721 case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration] * device_param->nvidia_spin_damp); break;
2722 }
2723 }
2724 }
2725 }
2726
2727 hc_clWaitForEvents (data.ocl, 1, &event);
2728
2729 cl_ulong time_start;
2730 cl_ulong time_end;
2731
2732 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2733 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2734
2735 const double exec_us = (double) (time_end - time_start) / 1000;
2736
2737 if (data.devices_status == STATUS_RUNNING)
2738 {
2739 if (iteration < EXPECTED_ITERATIONS)
2740 {
2741 switch (kern_run)
2742 {
2743 case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2744 case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2745 case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2746 }
2747 }
2748 }
2749
2750 if (event_update)
2751 {
2752 uint exec_pos = device_param->exec_pos;
2753
2754 device_param->exec_ms[exec_pos] = exec_us / 1000;
2755
2756 exec_pos++;
2757
2758 if (exec_pos == EXEC_CACHE)
2759 {
2760 exec_pos = 0;
2761 }
2762
2763 device_param->exec_pos = exec_pos;
2764 }
2765
2766 hc_clReleaseEvent (data.ocl, event);
2767
2768 hc_clFinish (data.ocl, device_param->command_queue);
2769 }
2770
2771 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2772 {
2773 uint num_elements = num;
2774
2775 switch (kern_run)
2776 {
2777 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2778 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2779 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2780 }
2781
2782 // causes problems with special threads like in bcrypt
2783 // const uint kernel_threads = device_param->kernel_threads;
2784
2785 uint kernel_threads = device_param->kernel_threads;
2786
2787 while (num_elements % kernel_threads) num_elements++;
2788
2789 cl_kernel kernel = NULL;
2790
2791 switch (kern_run)
2792 {
2793 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2794 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2795 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2796 }
2797
2798 switch (kern_run)
2799 {
2800 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2801 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2802 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2803 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2804 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2805 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2806 break;
2807 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2808 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2809 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2810 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2811 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2812 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2813 break;
2814 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2815 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2816 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2817 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2818 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2819 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2820 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2821 break;
2822 }
2823
2824 const size_t global_work_size[3] = { num_elements, 1, 1 };
2825 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2826
2827 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2828
2829 hc_clFlush (data.ocl, device_param->command_queue);
2830
2831 hc_clFinish (data.ocl, device_param->command_queue);
2832 }
2833
2834 static void run_kernel_tm (hc_device_param_t *device_param)
2835 {
2836 const uint num_elements = 1024; // fixed
2837
2838 uint kernel_threads = 32;
2839
2840 cl_kernel kernel = device_param->kernel_tm;
2841
2842 const size_t global_work_size[3] = { num_elements, 1, 1 };
2843 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2844
2845 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2846
2847 hc_clFlush (data.ocl, device_param->command_queue);
2848
2849 hc_clFinish (data.ocl, device_param->command_queue);
2850 }
2851
2852 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2853 {
2854 uint num_elements = num;
2855
2856 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2857 device_param->kernel_params_amp_buf32[6] = num_elements;
2858
2859 // causes problems with special threads like in bcrypt
2860 // const uint kernel_threads = device_param->kernel_threads;
2861
2862 uint kernel_threads = device_param->kernel_threads;
2863
2864 while (num_elements % kernel_threads) num_elements++;
2865
2866 cl_kernel kernel = device_param->kernel_amp;
2867
2868 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2869 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2870
2871 const size_t global_work_size[3] = { num_elements, 1, 1 };
2872 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2873
2874 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2875
2876 hc_clFlush (data.ocl, device_param->command_queue);
2877
2878 hc_clFinish (data.ocl, device_param->command_queue);
2879 }
2880
2881 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2882 {
2883 const u32 num16d = num / 16;
2884 const u32 num16m = num % 16;
2885
2886 if (num16d)
2887 {
2888 device_param->kernel_params_memset_buf32[1] = value;
2889 device_param->kernel_params_memset_buf32[2] = num16d;
2890
2891 uint kernel_threads = device_param->kernel_threads;
2892
2893 uint num_elements = num16d;
2894
2895 while (num_elements % kernel_threads) num_elements++;
2896
2897 cl_kernel kernel = device_param->kernel_memset;
2898
2899 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2900 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2901 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2902
2903 const size_t global_work_size[3] = { num_elements, 1, 1 };
2904 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2905
2906 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2907
2908 hc_clFlush (data.ocl, device_param->command_queue);
2909
2910 hc_clFinish (data.ocl, device_param->command_queue);
2911 }
2912
2913 if (num16m)
2914 {
2915 u32 tmp[4];
2916
2917 tmp[0] = value;
2918 tmp[1] = value;
2919 tmp[2] = value;
2920 tmp[3] = value;
2921
2922 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2923 }
2924 }
2925
2926 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2927 {
2928 run_kernel_memset (device_param, buf, 0, size);
2929
2930 /*
2931 int rc = -1;
2932
2933 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2934 {
2935 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2936
2937 const cl_uchar zero = 0;
2938
2939 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2940 }
2941
2942 if (rc != 0)
2943 {
2944 // NOTE: clEnqueueFillBuffer () always fails with -59
2945 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2946 // How's that possible, OpenCL 1.2 support is advertised??
2947 // We need to workaround...
2948
2949 #define FILLSZ 0x100000
2950
2951 char *tmp = (char *) mymalloc (FILLSZ);
2952
2953 for (size_t i = 0; i < size; i += FILLSZ)
2954 {
2955 const size_t left = size - i;
2956
2957 const size_t fillsz = MIN (FILLSZ, left);
2958
2959 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2960 }
2961
2962 myfree (tmp);
2963 }
2964 */
2965 }
2966
2967 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)
2968 {
2969 if (data.hash_mode == 2000)
2970 {
2971 process_stdout (device_param, pws_cnt);
2972
2973 return;
2974 }
2975
2976 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2977 {
2978 if (attack_mode == ATTACK_MODE_BF)
2979 {
2980 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2981 {
2982 const uint size_tm = 32 * sizeof (bs_word_t);
2983
2984 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2985
2986 run_kernel_tm (device_param);
2987
2988 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);
2989 }
2990 }
2991
2992 if (highest_pw_len < 16)
2993 {
2994 run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
2995 }
2996 else if (highest_pw_len < 32)
2997 {
2998 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
2999 }
3000 else
3001 {
3002 run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
3003 }
3004 }
3005 else
3006 {
3007 run_kernel_amp (device_param, pws_cnt);
3008
3009 run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
3010
3011 if (opts_type & OPTS_TYPE_HOOK12)
3012 {
3013 run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
3014
3015 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);
3016
3017 // do something with data
3018
3019 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);
3020 }
3021
3022 uint iter = salt_buf->salt_iter;
3023
3024 uint loop_step = device_param->kernel_loops;
3025
3026 for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
3027 {
3028 uint loop_left = iter - loop_pos;
3029
3030 loop_left = MIN (loop_left, loop_step);
3031
3032 device_param->kernel_params_buf32[28] = loop_pos;
3033 device_param->kernel_params_buf32[29] = loop_left;
3034
3035 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
3036
3037 if (data.devices_status == STATUS_CRACKED) break;
3038 if (data.devices_status == STATUS_ABORTED) break;
3039 if (data.devices_status == STATUS_QUIT) break;
3040 if (data.devices_status == STATUS_BYPASS) break;
3041
3042 /**
3043 * speed
3044 */
3045
3046 const float iter_part = (float) (loop_pos + loop_left) / iter;
3047
3048 const u64 perf_sum_all = pws_cnt * iter_part;
3049
3050 double speed_ms;
3051
3052 hc_timer_get (device_param->timer_speed, speed_ms);
3053
3054 const u32 speed_pos = device_param->speed_pos;
3055
3056 device_param->speed_cnt[speed_pos] = perf_sum_all;
3057
3058 device_param->speed_ms[speed_pos] = speed_ms;
3059
3060 if (data.benchmark == 1)
3061 {
3062 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
3063 }
3064 }
3065
3066 if (opts_type & OPTS_TYPE_HOOK23)
3067 {
3068 run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
3069
3070 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
3071
3072 // do something with data
3073
3074 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
3075 }
3076
3077 run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3078 }
3079 }
3080
3081 static int run_rule_engine (const int rule_len, const char *rule_buf)
3082 {
3083 if (rule_len == 0)
3084 {
3085 return 0;
3086 }
3087 else if (rule_len == 1)
3088 {
3089 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3090 }
3091
3092 return 1;
3093 }
3094
3095 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3096 {
3097 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3098 {
3099 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3100 }
3101 else if (data.attack_kern == ATTACK_KERN_COMBI)
3102 {
3103 if (data.attack_mode == ATTACK_MODE_COMBI)
3104 {
3105 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3106 {
3107 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3108 {
3109 for (u32 i = 0; i < pws_cnt; i++)
3110 {
3111 const u32 pw_len = device_param->pws_buf[i].pw_len;
3112
3113 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3114
3115 ptr[pw_len] = 0x01;
3116 }
3117 }
3118 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3119 {
3120 for (u32 i = 0; i < pws_cnt; i++)
3121 {
3122 const u32 pw_len = device_param->pws_buf[i].pw_len;
3123
3124 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3125
3126 ptr[pw_len] = 0x80;
3127 }
3128 }
3129 }
3130 }
3131 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3132 {
3133 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3134 {
3135 for (u32 i = 0; i < pws_cnt; i++)
3136 {
3137 const u32 pw_len = device_param->pws_buf[i].pw_len;
3138
3139 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3140
3141 ptr[pw_len] = 0x01;
3142 }
3143 }
3144 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3145 {
3146 for (u32 i = 0; i < pws_cnt; i++)
3147 {
3148 const u32 pw_len = device_param->pws_buf[i].pw_len;
3149
3150 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3151
3152 ptr[pw_len] = 0x80;
3153 }
3154 }
3155 }
3156
3157 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3158 }
3159 else if (data.attack_kern == ATTACK_KERN_BF)
3160 {
3161 const u64 off = device_param->words_off;
3162
3163 device_param->kernel_params_mp_l_buf64[3] = off;
3164
3165 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3166 }
3167 }
3168
3169 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3170 {
3171 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3172
3173 device_param->kernel_params_buf32[28] = 0;
3174 device_param->kernel_params_buf32[29] = kernel_loops; // not a bug, both need to be set
3175 device_param->kernel_params_buf32[30] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3176
3177 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3178 {
3179 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3180 }
3181 else
3182 {
3183 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3184 }
3185
3186 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3187
3188 return exec_ms_prev;
3189 }
3190
3191 static void autotune (hc_device_param_t *device_param)
3192 {
3193 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3194
3195 const u32 kernel_accel_min = device_param->kernel_accel_min;
3196 const u32 kernel_accel_max = device_param->kernel_accel_max;
3197
3198 const u32 kernel_loops_min = device_param->kernel_loops_min;
3199 const u32 kernel_loops_max = device_param->kernel_loops_max;
3200
3201 u32 kernel_accel = kernel_accel_min;
3202 u32 kernel_loops = kernel_loops_min;
3203
3204 // in this case the user specified a fixed -u and -n on the commandline
3205 // no way to tune anything
3206 // but we need to run a few caching rounds
3207
3208 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3209 {
3210 if (data.hash_mode != 2000)
3211 {
3212 try_run (device_param, kernel_accel, kernel_loops);
3213 try_run (device_param, kernel_accel, kernel_loops);
3214 try_run (device_param, kernel_accel, kernel_loops);
3215 try_run (device_param, kernel_accel, kernel_loops);
3216 }
3217
3218 device_param->kernel_accel = kernel_accel;
3219 device_param->kernel_loops = kernel_loops;
3220
3221 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3222
3223 device_param->kernel_power = kernel_power;
3224
3225 return;
3226 }
3227
3228 // from here it's clear we are allowed to autotune
3229 // so let's init some fake words
3230
3231 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3232
3233 if (data.attack_kern == ATTACK_KERN_BF)
3234 {
3235 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3236 }
3237 else
3238 {
3239 for (u32 i = 0; i < kernel_power_max; i++)
3240 {
3241 device_param->pws_buf[i].i[0] = i;
3242 device_param->pws_buf[i].i[1] = 0x01234567;
3243 device_param->pws_buf[i].pw_len = 7 + (i & 7);
3244 }
3245
3246 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3247 }
3248
3249 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3250 {
3251 if (data.kernel_rules_cnt > 1)
3252 {
3253 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, 0, 0, MIN (kernel_loops_max, KERNEL_RULES) * sizeof (kernel_rule_t), 0, NULL, NULL);
3254 }
3255 }
3256 else
3257 {
3258 run_kernel_amp (device_param, kernel_power_max);
3259 }
3260
3261 #define VERIFIER_CNT 1
3262
3263 // first find out highest kernel-loops that stays below target_ms
3264
3265 if (kernel_loops_min < kernel_loops_max)
3266 {
3267 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3268 {
3269 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3270
3271 for (int i = 0; i < VERIFIER_CNT; i++)
3272 {
3273 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3274
3275 exec_ms = MIN (exec_ms, exec_ms_v);
3276 }
3277
3278 if (exec_ms < target_ms) break;
3279 }
3280 }
3281
3282 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3283
3284 #define STEPS_CNT 10
3285
3286 if (kernel_accel_min < kernel_accel_max)
3287 {
3288 for (int i = 0; i < STEPS_CNT; i++)
3289 {
3290 const u32 kernel_accel_try = 1 << i;
3291
3292 if (kernel_accel_try < kernel_accel_min) continue;
3293 if (kernel_accel_try > kernel_accel_max) break;
3294
3295 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3296
3297 for (int i = 0; i < VERIFIER_CNT; i++)
3298 {
3299 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3300
3301 exec_ms = MIN (exec_ms, exec_ms_v);
3302 }
3303
3304 if (exec_ms > target_ms) break;
3305
3306 kernel_accel = kernel_accel_try;
3307 }
3308 }
3309
3310 // at this point we want to know the actual runtime for the following reason:
3311 // we need a reference for the balancing loop following up, and this
3312 // the balancing loop can have an effect that the creates a new opportunity, for example:
3313 // if the target is 95 ms and the current runtime is 48ms the above loop
3314 // stopped the execution because the previous exec_ms was > 95ms
3315 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3316 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3317
3318 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3319
3320 for (int i = 0; i < VERIFIER_CNT; i++)
3321 {
3322 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3323
3324 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3325 }
3326
3327 u32 diff = kernel_loops - kernel_accel;
3328
3329 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3330 {
3331 u32 kernel_accel_orig = kernel_accel;
3332 u32 kernel_loops_orig = kernel_loops;
3333
3334 for (u32 f = 1; f < 1024; f++)
3335 {
3336 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3337 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3338
3339 if (kernel_accel_try > kernel_accel_max) break;
3340 if (kernel_loops_try < kernel_loops_min) break;
3341
3342 u32 diff_new = kernel_loops_try - kernel_accel_try;
3343
3344 if (diff_new > diff) break;
3345
3346 diff_new = diff;
3347
3348 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3349
3350 for (int i = 0; i < VERIFIER_CNT; i++)
3351 {
3352 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3353
3354 exec_ms = MIN (exec_ms, exec_ms_v);
3355 }
3356
3357 if (exec_ms < exec_ms_pre_final)
3358 {
3359 exec_ms_pre_final = exec_ms;
3360
3361 kernel_accel = kernel_accel_try;
3362 kernel_loops = kernel_loops_try;
3363 }
3364 }
3365 }
3366
3367 const double exec_left = target_ms / exec_ms_pre_final;
3368
3369 const double accel_left = kernel_accel_max / kernel_accel;
3370
3371 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3372
3373 if (exec_accel_min >= 1.0)
3374 {
3375 // this is safe to not overflow kernel_accel_max because of accel_left
3376
3377 kernel_accel = (double) kernel_accel * exec_accel_min;
3378 }
3379
3380 // reset them fake words
3381
3382 /*
3383 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3384
3385 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3386 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3387 */
3388
3389 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3390
3391 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3392 {
3393 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3394 }
3395
3396 // reset timer
3397
3398 device_param->exec_pos = 0;
3399
3400 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3401
3402 memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3403 memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3404 memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3405
3406 // store
3407
3408 device_param->kernel_accel = kernel_accel;
3409 device_param->kernel_loops = kernel_loops;
3410
3411 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3412
3413 device_param->kernel_power = kernel_power;
3414
3415 #ifdef DEBUG
3416
3417 if (data.quiet == 0)
3418 {
3419 clear_prompt ();
3420
3421 log_info ("- Device #%u: autotuned kernel-accel to %u\n"
3422 "- Device #%u: autotuned kernel-loops to %u\n",
3423 device_param->device_id + 1, kernel_accel,
3424 device_param->device_id + 1, kernel_loops);
3425
3426 fprintf (stdout, "%s", PROMPT);
3427
3428 fflush (stdout);
3429 }
3430
3431 #endif
3432 }
3433
3434 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3435 {
3436 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3437
3438 // init speed timer
3439
3440 uint speed_pos = device_param->speed_pos;
3441
3442 #ifdef _POSIX
3443 if (device_param->timer_speed.tv_sec == 0)
3444 {
3445 hc_timer_set (&device_param->timer_speed);
3446 }
3447 #endif
3448
3449 #ifdef _WIN
3450 if (device_param->timer_speed.QuadPart == 0)
3451 {
3452 hc_timer_set (&device_param->timer_speed);
3453 }
3454 #endif
3455
3456 // find higest password length, this is for optimization stuff
3457
3458 uint highest_pw_len = 0;
3459
3460 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3461 {
3462 }
3463 else if (data.attack_kern == ATTACK_KERN_COMBI)
3464 {
3465 }
3466 else if (data.attack_kern == ATTACK_KERN_BF)
3467 {
3468 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3469 + device_param->kernel_params_mp_l_buf32[5];
3470 }
3471
3472 // iteration type
3473
3474 uint innerloop_step = 0;
3475 uint innerloop_cnt = 0;
3476
3477 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3478 else innerloop_step = 1;
3479
3480 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3481 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3482 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3483
3484 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3485
3486 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3487 {
3488 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3489
3490 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3491
3492 if (data.devices_status == STATUS_CRACKED) break;
3493 if (data.devices_status == STATUS_ABORTED) break;
3494 if (data.devices_status == STATUS_QUIT) break;
3495 if (data.devices_status == STATUS_BYPASS) break;
3496
3497 salt_t *salt_buf = &data.salts_buf[salt_pos];
3498
3499 device_param->kernel_params_buf32[27] = salt_pos;
3500 device_param->kernel_params_buf32[31] = salt_buf->digests_cnt;
3501 device_param->kernel_params_buf32[32] = salt_buf->digests_offset;
3502
3503 FILE *combs_fp = device_param->combs_fp;
3504
3505 if (data.attack_mode == ATTACK_MODE_COMBI)
3506 {
3507 rewind (combs_fp);
3508 }
3509
3510 // innerloops
3511
3512 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3513 {
3514 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3515
3516 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3517
3518 if (data.devices_status == STATUS_CRACKED) break;
3519 if (data.devices_status == STATUS_ABORTED) break;
3520 if (data.devices_status == STATUS_QUIT) break;
3521 if (data.devices_status == STATUS_BYPASS) break;
3522
3523 uint fast_iteration = 0;
3524
3525 uint innerloop_left = innerloop_cnt - innerloop_pos;
3526
3527 if (innerloop_left > innerloop_step)
3528 {
3529 innerloop_left = innerloop_step;
3530
3531 fast_iteration = 1;
3532 }
3533
3534 device_param->innerloop_pos = innerloop_pos;
3535 device_param->innerloop_left = innerloop_left;
3536
3537 device_param->kernel_params_buf32[30] = innerloop_left;
3538
3539 // i think we can get rid of this
3540 if (innerloop_left == 0)
3541 {
3542 puts ("bug, how should this happen????\n");
3543
3544 continue;
3545 }
3546
3547 if (data.salts_shown[salt_pos] == 1)
3548 {
3549 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3550
3551 continue;
3552 }
3553
3554 // initialize amplifiers
3555
3556 if (data.attack_mode == ATTACK_MODE_COMBI)
3557 {
3558 uint i = 0;
3559
3560 while (i < innerloop_left)
3561 {
3562 if (feof (combs_fp)) break;
3563
3564 int line_len = fgetl (combs_fp, line_buf);
3565
3566 if (line_len >= PW_MAX1) continue;
3567
3568 line_len = convert_from_hex (line_buf, line_len);
3569
3570 char *line_buf_new = line_buf;
3571
3572 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3573 {
3574 char rule_buf_out[BLOCK_SIZE] = { 0 };
3575
3576 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3577
3578 if (rule_len_out < 0)
3579 {
3580 data.words_progress_rejected[salt_pos] += pws_cnt;
3581
3582 continue;
3583 }
3584
3585 line_len = rule_len_out;
3586
3587 line_buf_new = rule_buf_out;
3588 }
3589
3590 line_len = MIN (line_len, PW_DICTMAX);
3591
3592 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3593
3594 memcpy (ptr, line_buf_new, line_len);
3595
3596 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3597
3598 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3599 {
3600 uppercase (ptr, line_len);
3601 }
3602
3603 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3604 {
3605 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3606 {
3607 ptr[line_len] = 0x80;
3608 }
3609
3610 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3611 {
3612 ptr[line_len] = 0x01;
3613 }
3614 }
3615
3616 device_param->combs_buf[i].pw_len = line_len;
3617
3618 i++;
3619 }
3620
3621 for (uint j = i; j < innerloop_left; j++)
3622 {
3623 device_param->combs_buf[j].i[0] = 0;
3624 device_param->combs_buf[j].i[1] = 0;
3625 device_param->combs_buf[j].i[2] = 0;
3626 device_param->combs_buf[j].i[3] = 0;
3627 device_param->combs_buf[j].i[4] = 0;
3628 device_param->combs_buf[j].i[5] = 0;
3629 device_param->combs_buf[j].i[6] = 0;
3630 device_param->combs_buf[j].i[7] = 0;
3631
3632 device_param->combs_buf[j].pw_len = 0;
3633 }
3634
3635 innerloop_left = i;
3636 }
3637 else if (data.attack_mode == ATTACK_MODE_BF)
3638 {
3639 u64 off = innerloop_pos;
3640
3641 device_param->kernel_params_mp_r_buf64[3] = off;
3642
3643 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3644 }
3645 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3646 {
3647 u64 off = innerloop_pos;
3648
3649 device_param->kernel_params_mp_buf64[3] = off;
3650
3651 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3652 }
3653 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3654 {
3655 u64 off = innerloop_pos;
3656
3657 device_param->kernel_params_mp_buf64[3] = off;
3658
3659 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3660 }
3661
3662 // copy amplifiers
3663
3664 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3665 {
3666 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
3667 }
3668 else if (data.attack_mode == ATTACK_MODE_COMBI)
3669 {
3670 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
3671 }
3672 else if (data.attack_mode == ATTACK_MODE_BF)
3673 {
3674 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
3675 }
3676 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3677 {
3678 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3679 }
3680 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3681 {
3682 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3683 }
3684
3685 if (data.benchmark == 1)
3686 {
3687 hc_timer_set (&device_param->timer_speed);
3688 }
3689
3690 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
3691
3692 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3693
3694 if (data.devices_status == STATUS_CRACKED) break;
3695 if (data.devices_status == STATUS_ABORTED) break;
3696 if (data.devices_status == STATUS_QUIT) break;
3697 if (data.devices_status == STATUS_BYPASS) break;
3698
3699 /**
3700 * result
3701 */
3702
3703 if (data.benchmark == 0)
3704 {
3705 check_cracked (device_param, salt_pos);
3706 }
3707
3708 /**
3709 * progress
3710 */
3711
3712 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3713
3714 hc_thread_mutex_lock (mux_counter);
3715
3716 data.words_progress_done[salt_pos] += perf_sum_all;
3717
3718 hc_thread_mutex_unlock (mux_counter);
3719
3720 /**
3721 * speed
3722 */
3723
3724 double speed_ms;
3725
3726 hc_timer_get (device_param->timer_speed, speed_ms);
3727
3728 hc_timer_set (&device_param->timer_speed);
3729
3730 // current speed
3731
3732 //hc_thread_mutex_lock (mux_display);
3733
3734 device_param->speed_cnt[speed_pos] = perf_sum_all;
3735
3736 device_param->speed_ms[speed_pos] = speed_ms;
3737
3738 //hc_thread_mutex_unlock (mux_display);
3739
3740 speed_pos++;
3741
3742 if (speed_pos == SPEED_CACHE)
3743 {
3744 speed_pos = 0;
3745 }
3746
3747 /**
3748 * benchmark
3749 */
3750
3751 if (data.benchmark == 1) break;
3752 }
3753 }
3754
3755 device_param->speed_pos = speed_pos;
3756
3757 myfree (line_buf);
3758 }
3759
3760 static void load_segment (wl_data_t *wl_data, FILE *fd)
3761 {
3762 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3763
3764 wl_data->pos = 0;
3765
3766 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3767
3768 wl_data->buf[wl_data->cnt] = 0;
3769
3770 if (wl_data->cnt == 0) return;
3771
3772 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3773
3774 while (!feof (fd))
3775 {
3776 if (wl_data->cnt == wl_data->avail)
3777 {
3778 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3779
3780 wl_data->avail += wl_data->incr;
3781 }
3782
3783 const int c = fgetc (fd);
3784
3785 if (c == EOF) break;
3786
3787 wl_data->buf[wl_data->cnt] = (char) c;
3788
3789 wl_data->cnt++;
3790
3791 if (c == '\n') break;
3792 }
3793
3794 // ensure stream ends with a newline
3795
3796 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3797 {
3798 wl_data->cnt++;
3799
3800 wl_data->buf[wl_data->cnt - 1] = '\n';
3801 }
3802
3803 return;
3804 }
3805
3806 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3807 {
3808 char *ptr = buf;
3809
3810 for (u32 i = 0; i < sz; i++, ptr++)
3811 {
3812 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3813
3814 if (i == 7)
3815 {
3816 *off = i;
3817 *len = i;
3818
3819 return;
3820 }
3821
3822 if (*ptr != '\n') continue;
3823
3824 *off = i + 1;
3825
3826 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3827
3828 *len = i;
3829
3830 return;
3831 }
3832
3833 *off = sz;
3834 *len = sz;
3835 }
3836
3837 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3838 {
3839 char *ptr = buf;
3840
3841 for (u32 i = 0; i < sz; i++, ptr++)
3842 {
3843 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3844
3845 if (*ptr != '\n') continue;
3846
3847 *off = i + 1;
3848
3849 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3850
3851 *len = i;
3852
3853 return;
3854 }
3855
3856 *off = sz;
3857 *len = sz;
3858 }
3859
3860 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3861 {
3862 char *ptr = buf;
3863
3864 for (u32 i = 0; i < sz; i++, ptr++)
3865 {
3866 if (*ptr != '\n') continue;
3867
3868 *off = i + 1;
3869
3870 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3871
3872 *len = i;
3873
3874 return;
3875 }
3876
3877 *off = sz;
3878 *len = sz;
3879 }
3880
3881 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3882 {
3883 while (wl_data->pos < wl_data->cnt)
3884 {
3885 uint off;
3886 uint len;
3887
3888 char *ptr = wl_data->buf + wl_data->pos;
3889
3890 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3891
3892 wl_data->pos += off;
3893
3894 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3895 {
3896 char rule_buf_out[BLOCK_SIZE] = { 0 };
3897
3898 int rule_len_out = -1;
3899
3900 if (len < BLOCK_SIZE)
3901 {
3902 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3903 }
3904
3905 if (rule_len_out < 0)
3906 {
3907 continue;
3908 }
3909
3910 if (rule_len_out > PW_MAX)
3911 {
3912 continue;
3913 }
3914 }
3915 else
3916 {
3917 if (len > PW_MAX)
3918 {
3919 continue;
3920 }
3921 }
3922
3923 *out_buf = ptr;
3924 *out_len = len;
3925
3926 return;
3927 }
3928
3929 if (feof (fd))
3930 {
3931 fprintf (stderr, "BUG feof()!!\n");
3932
3933 return;
3934 }
3935
3936 load_segment (wl_data, fd);
3937
3938 get_next_word (wl_data, fd, out_buf, out_len);
3939 }
3940
3941 #ifdef _POSIX
3942 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3943 #endif
3944
3945 #ifdef _WIN
3946 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3947 #endif
3948 {
3949 hc_signal (NULL);
3950
3951 dictstat_t d;
3952
3953 d.cnt = 0;
3954
3955 #ifdef _POSIX
3956 fstat (fileno (fd), &d.stat);
3957 #endif
3958
3959 #ifdef _WIN
3960 _fstat64 (fileno (fd), &d.stat);
3961 #endif
3962
3963 d.stat.st_mode = 0;
3964 d.stat.st_nlink = 0;
3965 d.stat.st_uid = 0;
3966 d.stat.st_gid = 0;
3967 d.stat.st_rdev = 0;
3968 d.stat.st_atime = 0;
3969
3970 #ifdef _POSIX
3971 d.stat.st_blksize = 0;
3972 d.stat.st_blocks = 0;
3973 #endif
3974
3975 if (d.stat.st_size == 0) return 0;
3976
3977 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3978
3979 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3980 {
3981 if (d_cache)
3982 {
3983 u64 cnt = d_cache->cnt;
3984
3985 u64 keyspace = cnt;
3986
3987 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3988 {
3989 keyspace *= data.kernel_rules_cnt;
3990 }
3991 else if (data.attack_kern == ATTACK_KERN_COMBI)
3992 {
3993 keyspace *= data.combs_cnt;
3994 }
3995
3996 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);
3997 if (data.quiet == 0) log_info ("");
3998
3999 hc_signal (sigHandler_default);
4000
4001 return (keyspace);
4002 }
4003 }
4004
4005 time_t now = 0;
4006 time_t prev = 0;
4007
4008 u64 comp = 0;
4009 u64 cnt = 0;
4010 u64 cnt2 = 0;
4011
4012 while (!feof (fd))
4013 {
4014 load_segment (wl_data, fd);
4015
4016 comp += wl_data->cnt;
4017
4018 u32 i = 0;
4019
4020 while (i < wl_data->cnt)
4021 {
4022 u32 len;
4023 u32 off;
4024
4025 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
4026
4027 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4028 {
4029 char rule_buf_out[BLOCK_SIZE] = { 0 };
4030
4031 int rule_len_out = -1;
4032
4033 if (len < BLOCK_SIZE)
4034 {
4035 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
4036 }
4037
4038 if (rule_len_out < 0)
4039 {
4040 len = PW_MAX1;
4041 }
4042 else
4043 {
4044 len = rule_len_out;
4045 }
4046 }
4047
4048 if (len < PW_MAX1)
4049 {
4050 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4051 {
4052 cnt += data.kernel_rules_cnt;
4053 }
4054 else if (data.attack_kern == ATTACK_KERN_COMBI)
4055 {
4056 cnt += data.combs_cnt;
4057 }
4058
4059 d.cnt++;
4060 }
4061
4062 i += off;
4063
4064 cnt2++;
4065 }
4066
4067 time (&now);
4068
4069 if ((now - prev) == 0) continue;
4070
4071 float percent = (float) comp / (float) d.stat.st_size;
4072
4073 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);
4074
4075 time (&prev);
4076 }
4077
4078 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);
4079 if (data.quiet == 0) log_info ("");
4080
4081 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4082
4083 hc_signal (sigHandler_default);
4084
4085 return (cnt);
4086 }
4087
4088 static void *thread_monitor (void *p)
4089 {
4090 uint runtime_check = 0;
4091 uint remove_check = 0;
4092 uint status_check = 0;
4093 uint restore_check = 0;
4094
4095 uint restore_left = data.restore_timer;
4096 uint remove_left = data.remove_timer;
4097 uint status_left = data.status_timer;
4098
4099 #ifdef HAVE_HWMON
4100 uint hwmon_check = 0;
4101
4102 int slowdown_warnings = 0;
4103
4104 // these variables are mainly used for fan control
4105
4106 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4107
4108 // temperature controller "loopback" values
4109
4110 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4111 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4112
4113 int temp_threshold = 1; // degrees celcius
4114
4115 int fan_speed_min = 15; // in percentage
4116 int fan_speed_max = 100;
4117
4118 time_t last_temp_check_time;
4119 #endif // HAVE_HWMON
4120
4121 uint sleep_time = 1;
4122
4123 if (data.runtime)
4124 {
4125 runtime_check = 1;
4126 }
4127
4128 if (data.restore_timer)
4129 {
4130 restore_check = 1;
4131 }
4132
4133 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4134 {
4135 remove_check = 1;
4136 }
4137
4138 if (data.status == 1)
4139 {
4140 status_check = 1;
4141 }
4142
4143 #ifdef HAVE_HWMON
4144 if (data.gpu_temp_disable == 0)
4145 {
4146 time (&last_temp_check_time);
4147
4148 hwmon_check = 1;
4149 }
4150 #endif
4151
4152 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4153 {
4154 #ifdef HAVE_HWMON
4155 if (hwmon_check == 0)
4156 #endif
4157 return (p);
4158 }
4159
4160 while (data.shutdown_inner == 0)
4161 {
4162 hc_sleep (sleep_time);
4163
4164 if (data.devices_status != STATUS_RUNNING) continue;
4165
4166 #ifdef HAVE_HWMON
4167
4168 if (hwmon_check == 1)
4169 {
4170 hc_thread_mutex_lock (mux_adl);
4171
4172 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4173 {
4174 hc_device_param_t *device_param = &data.devices_param[device_id];
4175
4176 if (device_param->skipped) continue;
4177
4178 if (device_param->device_vendor_id == VENDOR_ID_NV)
4179 {
4180 if (data.hm_nvapi)
4181 {
4182 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
4183 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
4184
4185 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4186 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4187
4188 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4189
4190 perfPolicies_status.info_value = perfPolicies_info.info_value;
4191
4192 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4193
4194 if (perfPolicies_status.throttle & 2)
4195 {
4196 if (slowdown_warnings < 3)
4197 {
4198 if (data.quiet == 0) clear_prompt ();
4199
4200 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4201
4202 if (slowdown_warnings == 2)
4203 {
4204 log_info ("");
4205 }
4206
4207 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4208 if (data.quiet == 0) fflush (stdout);
4209
4210 slowdown_warnings++;
4211 }
4212 }
4213 else
4214 {
4215 slowdown_warnings = 0;
4216 }
4217 }
4218 }
4219 }
4220
4221 hc_thread_mutex_unlock (mux_adl);
4222 }
4223
4224 if (hwmon_check == 1)
4225 {
4226 hc_thread_mutex_lock (mux_adl);
4227
4228 time_t temp_check_time;
4229
4230 time (&temp_check_time);
4231
4232 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4233
4234 if (Ta == 0) Ta = 1;
4235
4236 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4237 {
4238 hc_device_param_t *device_param = &data.devices_param[device_id];
4239
4240 if (device_param->skipped) continue;
4241
4242 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4243
4244 const int temperature = hm_get_temperature_with_device_id (device_id);
4245
4246 if (temperature > (int) data.gpu_temp_abort)
4247 {
4248 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4249
4250 if (data.devices_status != STATUS_QUIT) myabort ();
4251
4252 break;
4253 }
4254
4255 const int gpu_temp_retain = data.gpu_temp_retain;
4256
4257 if (gpu_temp_retain)
4258 {
4259 if (data.hm_device[device_id].fan_set_supported == 1)
4260 {
4261 int temp_cur = temperature;
4262
4263 int temp_diff_new = gpu_temp_retain - temp_cur;
4264
4265 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4266
4267 // calculate Ta value (time difference in seconds between the last check and this check)
4268
4269 last_temp_check_time = temp_check_time;
4270
4271 float Kp = 1.8;
4272 float Ki = 0.005;
4273 float Kd = 6;
4274
4275 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4276
4277 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);
4278
4279 if (abs (fan_diff_required) >= temp_threshold)
4280 {
4281 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4282
4283 int fan_speed_level = fan_speed_cur;
4284
4285 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4286
4287 int fan_speed_new = fan_speed_level - fan_diff_required;
4288
4289 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4290 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4291
4292 if (fan_speed_new != fan_speed_cur)
4293 {
4294 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4295 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4296
4297 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4298 {
4299 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4300 {
4301 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4302 }
4303 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4304 {
4305 #ifdef WIN
4306 hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1);
4307 #endif
4308
4309 #ifdef LINUX
4310 hm_set_fanspeed_with_device_id_xnvctrl (device_id, fan_speed_new);
4311 #endif
4312 }
4313
4314 fan_speed_chgd[device_id] = 1;
4315 }
4316
4317 temp_diff_old[device_id] = temp_diff_new;
4318 }
4319 }
4320 }
4321 }
4322 }
4323
4324 hc_thread_mutex_unlock (mux_adl);
4325 }
4326 #endif // HAVE_HWMON
4327
4328 if (restore_check == 1)
4329 {
4330 restore_left--;
4331
4332 if (restore_left == 0)
4333 {
4334 if (data.restore_disable == 0) cycle_restore ();
4335
4336 restore_left = data.restore_timer;
4337 }
4338 }
4339
4340 if ((runtime_check == 1) && (data.runtime_start > 0))
4341 {
4342 time_t runtime_cur;
4343
4344 time (&runtime_cur);
4345
4346 int runtime_left = data.proc_start + data.runtime - runtime_cur;
4347
4348 if (runtime_left <= 0)
4349 {
4350 if (data.benchmark == 0)
4351 {
4352 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4353 }
4354
4355 if (data.devices_status != STATUS_QUIT) myabort ();
4356 }
4357 }
4358
4359 if (remove_check == 1)
4360 {
4361 remove_left--;
4362
4363 if (remove_left == 0)
4364 {
4365 if (data.digests_saved != data.digests_done)
4366 {
4367 data.digests_saved = data.digests_done;
4368
4369 save_hash ();
4370 }
4371
4372 remove_left = data.remove_timer;
4373 }
4374 }
4375
4376 if (status_check == 1)
4377 {
4378 status_left--;
4379
4380 if (status_left == 0)
4381 {
4382 hc_thread_mutex_lock (mux_display);
4383
4384 if (data.quiet == 0) clear_prompt ();
4385
4386 if (data.quiet == 0) log_info ("");
4387
4388 status_display ();
4389
4390 if (data.quiet == 0) log_info ("");
4391
4392 hc_thread_mutex_unlock (mux_display);
4393
4394 status_left = data.status_timer;
4395 }
4396 }
4397 }
4398
4399 #ifdef HAVE_HWMON
4400 myfree (fan_speed_chgd);
4401
4402 myfree (temp_diff_old);
4403 myfree (temp_diff_sum);
4404 #endif
4405
4406 p = NULL;
4407
4408 return (p);
4409 }
4410
4411 static void *thread_outfile_remove (void *p)
4412 {
4413 // some hash-dependent constants
4414 char *outfile_dir = data.outfile_check_directory;
4415 uint dgst_size = data.dgst_size;
4416 uint isSalted = data.isSalted;
4417 uint esalt_size = data.esalt_size;
4418 uint hash_mode = data.hash_mode;
4419
4420 uint outfile_check_timer = data.outfile_check_timer;
4421
4422 char separator = data.separator;
4423
4424 // some hash-dependent functions
4425 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4426 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4427
4428 // buffers
4429 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4430
4431 hash_buf.digest = mymalloc (dgst_size);
4432
4433 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4434
4435 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4436
4437 uint digest_buf[64] = { 0 };
4438
4439 outfile_data_t *out_info = NULL;
4440
4441 char **out_files = NULL;
4442
4443 time_t folder_mtime = 0;
4444
4445 int out_cnt = 0;
4446
4447 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4448
4449 while (data.shutdown_inner == 0)
4450 {
4451 hc_sleep (1);
4452
4453 if (data.devices_status != STATUS_RUNNING) continue;
4454
4455 check_left--;
4456
4457 if (check_left == 0)
4458 {
4459 struct stat outfile_check_stat;
4460
4461 if (stat (outfile_dir, &outfile_check_stat) == 0)
4462 {
4463 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4464
4465 if (is_dir == 1)
4466 {
4467 if (outfile_check_stat.st_mtime > folder_mtime)
4468 {
4469 char **out_files_new = scan_directory (outfile_dir);
4470
4471 int out_cnt_new = count_dictionaries (out_files_new);
4472
4473 outfile_data_t *out_info_new = NULL;
4474
4475 if (out_cnt_new > 0)
4476 {
4477 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4478
4479 for (int i = 0; i < out_cnt_new; i++)
4480 {
4481 out_info_new[i].file_name = out_files_new[i];
4482
4483 // check if there are files that we have seen/checked before (and not changed)
4484
4485 for (int j = 0; j < out_cnt; j++)
4486 {
4487 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4488 {
4489 struct stat outfile_stat;
4490
4491 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4492 {
4493 if (outfile_stat.st_ctime == out_info[j].ctime)
4494 {
4495 out_info_new[i].ctime = out_info[j].ctime;
4496 out_info_new[i].seek = out_info[j].seek;
4497 }
4498 }
4499 }
4500 }
4501 }
4502 }
4503
4504 local_free (out_info);
4505 local_free (out_files);
4506
4507 out_files = out_files_new;
4508 out_cnt = out_cnt_new;
4509 out_info = out_info_new;
4510
4511 folder_mtime = outfile_check_stat.st_mtime;
4512 }
4513
4514 for (int j = 0; j < out_cnt; j++)
4515 {
4516 FILE *fp = fopen (out_info[j].file_name, "rb");
4517
4518 if (fp != NULL)
4519 {
4520 //hc_thread_mutex_lock (mux_display);
4521
4522 #ifdef _POSIX
4523 struct stat outfile_stat;
4524
4525 fstat (fileno (fp), &outfile_stat);
4526 #endif
4527
4528 #ifdef _WIN
4529 struct stat64 outfile_stat;
4530
4531 _fstat64 (fileno (fp), &outfile_stat);
4532 #endif
4533
4534 if (outfile_stat.st_ctime > out_info[j].ctime)
4535 {
4536 out_info[j].ctime = outfile_stat.st_ctime;
4537 out_info[j].seek = 0;
4538 }
4539
4540 fseek (fp, out_info[j].seek, SEEK_SET);
4541
4542 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4543
4544 while (!feof (fp))
4545 {
4546 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4547
4548 if (ptr == NULL) break;
4549
4550 int line_len = strlen (line_buf);
4551
4552 if (line_len <= 0) continue;
4553
4554 int iter = MAX_CUT_TRIES;
4555
4556 for (uint i = line_len - 1; i && iter; i--, line_len--)
4557 {
4558 if (line_buf[i] != separator) continue;
4559
4560 int parser_status = PARSER_OK;
4561
4562 if ((hash_mode != 2500) && (hash_mode != 6800))
4563 {
4564 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4565 }
4566
4567 uint found = 0;
4568
4569 if (parser_status == PARSER_OK)
4570 {
4571 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4572 {
4573 if (data.salts_shown[salt_pos] == 1) continue;
4574
4575 salt_t *salt_buf = &data.salts_buf[salt_pos];
4576
4577 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4578 {
4579 uint idx = salt_buf->digests_offset + digest_pos;
4580
4581 if (data.digests_shown[idx] == 1) continue;
4582
4583 uint cracked = 0;
4584
4585 if (hash_mode == 6800)
4586 {
4587 if (i == salt_buf->salt_len)
4588 {
4589 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4590 }
4591 }
4592 else if (hash_mode == 2500)
4593 {
4594 // BSSID : MAC1 : MAC2 (:plain)
4595 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4596 {
4597 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4598
4599 if (!cracked) continue;
4600
4601 // now compare MAC1 and MAC2 too, since we have this additional info
4602 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4603 char *mac2_pos = mac1_pos + 12 + 1;
4604
4605 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4606 wpa_t *wpa = &wpas[salt_pos];
4607
4608 // compare hex string(s) vs binary MAC address(es)
4609
4610 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4611 {
4612 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4613 {
4614 cracked = 0;
4615
4616 break;
4617 }
4618 }
4619
4620 // early skip ;)
4621 if (!cracked) continue;
4622
4623 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4624 {
4625 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4626 {
4627 cracked = 0;
4628
4629 break;
4630 }
4631 }
4632 }
4633 }
4634 else
4635 {
4636 char *digests_buf_ptr = (char *) data.digests_buf;
4637
4638 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4639
4640 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4641 }
4642
4643 if (cracked == 1)
4644 {
4645 found = 1;
4646
4647 data.digests_shown[idx] = 1;
4648
4649 data.digests_done++;
4650
4651 salt_buf->digests_done++;
4652
4653 if (salt_buf->digests_done == salt_buf->digests_cnt)
4654 {
4655 data.salts_shown[salt_pos] = 1;
4656
4657 data.salts_done++;
4658
4659 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4660 }
4661 }
4662 }
4663
4664 if (data.devices_status == STATUS_CRACKED) break;
4665 }
4666 }
4667
4668 if (found) break;
4669
4670 if (data.devices_status == STATUS_CRACKED) break;
4671
4672 iter--;
4673 }
4674
4675 if (data.devices_status == STATUS_CRACKED) break;
4676 }
4677
4678 myfree (line_buf);
4679
4680 out_info[j].seek = ftell (fp);
4681
4682 //hc_thread_mutex_unlock (mux_display);
4683
4684 fclose (fp);
4685 }
4686 }
4687 }
4688 }
4689
4690 check_left = outfile_check_timer;
4691 }
4692 }
4693
4694 if (esalt_size) local_free (hash_buf.esalt);
4695
4696 if (isSalted) local_free (hash_buf.salt);
4697
4698 local_free (hash_buf.digest);
4699
4700 local_free (out_info);
4701
4702 local_free (out_files);
4703
4704 p = NULL;
4705
4706 return (p);
4707 }
4708
4709 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4710 {
4711 //if (device_param->pws_cnt < device_param->kernel_power)
4712 //{
4713 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4714
4715 u8 *ptr = (u8 *) pw->i;
4716
4717 memcpy (ptr, pw_buf, pw_len);
4718
4719 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4720
4721 pw->pw_len = pw_len;
4722
4723 device_param->pws_cnt++;
4724 //}
4725 //else
4726 //{
4727 // fprintf (stderr, "BUG pw_add()!!\n");
4728 //
4729 // return;
4730 //}
4731 }
4732
4733 static void set_kernel_power_final (const u64 kernel_power_final)
4734 {
4735 if (data.quiet == 0)
4736 {
4737 clear_prompt ();
4738
4739 //log_info ("");
4740
4741 log_info ("INFO: approaching final keyspace, workload adjusted");
4742 log_info ("");
4743
4744 fprintf (stdout, "%s", PROMPT);
4745
4746 fflush (stdout);
4747 }
4748
4749 data.kernel_power_final = kernel_power_final;
4750 }
4751
4752 static u32 get_power (hc_device_param_t *device_param)
4753 {
4754 const u64 kernel_power_final = data.kernel_power_final;
4755
4756 if (kernel_power_final)
4757 {
4758 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4759
4760 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4761
4762 // work should be at least the hardware power available without any accelerator
4763
4764 const u64 work = MAX (words_left_device, device_param->hardware_power);
4765
4766 return work;
4767 }
4768
4769 return device_param->kernel_power;
4770 }
4771
4772 static uint get_work (hc_device_param_t *device_param, const u64 max)
4773 {
4774 hc_thread_mutex_lock (mux_dispatcher);
4775
4776 const u64 words_cur = data.words_cur;
4777 const u64 words_base = (data.limit == 0) ? data.words_base : MIN (data.limit, data.words_base);
4778
4779 device_param->words_off = words_cur;
4780
4781 const u64 kernel_power_all = data.kernel_power_all;
4782
4783 const u64 words_left = words_base - words_cur;
4784
4785 if (words_left < kernel_power_all)
4786 {
4787 if (data.kernel_power_final == 0)
4788 {
4789 set_kernel_power_final (words_left);
4790 }
4791 }
4792
4793 const u32 kernel_power = get_power (device_param);
4794
4795 uint work = MIN (words_left, kernel_power);
4796
4797 work = MIN (work, max);
4798
4799 data.words_cur += work;
4800
4801 hc_thread_mutex_unlock (mux_dispatcher);
4802
4803 return work;
4804 }
4805
4806 static void *thread_autotune (void *p)
4807 {
4808 hc_device_param_t *device_param = (hc_device_param_t *) p;
4809
4810 if (device_param->skipped) return NULL;
4811
4812 autotune (device_param);
4813
4814 return NULL;
4815 }
4816
4817 static void *thread_calc_stdin (void *p)
4818 {
4819 hc_device_param_t *device_param = (hc_device_param_t *) p;
4820
4821 if (device_param->skipped) return NULL;
4822
4823 char *buf = (char *) mymalloc (HCBUFSIZ);
4824
4825 const uint attack_kern = data.attack_kern;
4826
4827 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4828 {
4829 hc_thread_mutex_lock (mux_dispatcher);
4830
4831 if (feof (stdin) != 0)
4832 {
4833 hc_thread_mutex_unlock (mux_dispatcher);
4834
4835 break;
4836 }
4837
4838 uint words_cur = 0;
4839
4840 while (words_cur < device_param->kernel_power)
4841 {
4842 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4843
4844 if (line_buf == NULL) break;
4845
4846 uint line_len = in_superchop (line_buf);
4847
4848 line_len = convert_from_hex (line_buf, line_len);
4849
4850 // post-process rule engine
4851
4852 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4853 {
4854 char rule_buf_out[BLOCK_SIZE] = { 0 };
4855
4856 int rule_len_out = -1;
4857
4858 if (line_len < BLOCK_SIZE)
4859 {
4860 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4861 }
4862
4863 if (rule_len_out < 0) continue;
4864
4865 line_buf = rule_buf_out;
4866 line_len = rule_len_out;
4867 }
4868
4869 if (line_len > PW_MAX)
4870 {
4871 continue;
4872 }
4873
4874 // hmm that's always the case, or?
4875
4876 if (attack_kern == ATTACK_KERN_STRAIGHT)
4877 {
4878 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4879 {
4880 hc_thread_mutex_lock (mux_counter);
4881
4882 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4883 {
4884 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4885 }
4886
4887 hc_thread_mutex_unlock (mux_counter);
4888
4889 continue;
4890 }
4891 }
4892
4893 pw_add (device_param, (u8 *) line_buf, line_len);
4894
4895 words_cur++;
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
4903 hc_thread_mutex_unlock (mux_dispatcher);
4904
4905 if (data.devices_status == STATUS_CRACKED) break;
4906 if (data.devices_status == STATUS_ABORTED) break;
4907 if (data.devices_status == STATUS_QUIT) break;
4908 if (data.devices_status == STATUS_BYPASS) break;
4909
4910 // flush
4911
4912 const uint pws_cnt = device_param->pws_cnt;
4913
4914 if (pws_cnt)
4915 {
4916 run_copy (device_param, pws_cnt);
4917
4918 run_cracker (device_param, pws_cnt);
4919
4920 device_param->pws_cnt = 0;
4921
4922 /*
4923 still required?
4924 if (attack_kern == ATTACK_KERN_STRAIGHT)
4925 {
4926 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4927 }
4928 else if (attack_kern == ATTACK_KERN_COMBI)
4929 {
4930 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4931 }
4932 */
4933 }
4934 }
4935
4936 device_param->kernel_accel = 0;
4937 device_param->kernel_loops = 0;
4938
4939 myfree (buf);
4940
4941 return NULL;
4942 }
4943
4944 static void *thread_calc (void *p)
4945 {
4946 hc_device_param_t *device_param = (hc_device_param_t *) p;
4947
4948 if (device_param->skipped) return NULL;
4949
4950 const uint attack_mode = data.attack_mode;
4951 const uint attack_kern = data.attack_kern;
4952
4953 if (attack_mode == ATTACK_MODE_BF)
4954 {
4955 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4956 {
4957 const uint work = get_work (device_param, -1);
4958
4959 if (work == 0) break;
4960
4961 const u64 words_off = device_param->words_off;
4962 const u64 words_fin = words_off + work;
4963
4964 const uint pws_cnt = work;
4965
4966 device_param->pws_cnt = pws_cnt;
4967
4968 if (pws_cnt)
4969 {
4970 run_copy (device_param, pws_cnt);
4971
4972 run_cracker (device_param, pws_cnt);
4973
4974 device_param->pws_cnt = 0;
4975
4976 /*
4977 still required?
4978 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4979 */
4980 }
4981
4982 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4983
4984 if (data.devices_status == STATUS_CRACKED) break;
4985 if (data.devices_status == STATUS_ABORTED) break;
4986 if (data.devices_status == STATUS_QUIT) break;
4987 if (data.devices_status == STATUS_BYPASS) break;
4988
4989 if (data.benchmark == 1) break;
4990
4991 device_param->words_done = words_fin;
4992 }
4993 }
4994 else
4995 {
4996 const uint segment_size = data.segment_size;
4997
4998 char *dictfile = data.dictfile;
4999
5000 if (attack_mode == ATTACK_MODE_COMBI)
5001 {
5002 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5003 {
5004 dictfile = data.dictfile2;
5005 }
5006 }
5007
5008 FILE *fd = fopen (dictfile, "rb");
5009
5010 if (fd == NULL)
5011 {
5012 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
5013
5014 return NULL;
5015 }
5016
5017 if (attack_mode == ATTACK_MODE_COMBI)
5018 {
5019 const uint combs_mode = data.combs_mode;
5020
5021 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
5022 {
5023 const char *dictfilec = data.dictfile2;
5024
5025 FILE *combs_fp = fopen (dictfilec, "rb");
5026
5027 if (combs_fp == NULL)
5028 {
5029 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5030
5031 fclose (fd);
5032
5033 return NULL;
5034 }
5035
5036 device_param->combs_fp = combs_fp;
5037 }
5038 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5039 {
5040 const char *dictfilec = data.dictfile;
5041
5042 FILE *combs_fp = fopen (dictfilec, "rb");
5043
5044 if (combs_fp == NULL)
5045 {
5046 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5047
5048 fclose (fd);
5049
5050 return NULL;
5051 }
5052
5053 device_param->combs_fp = combs_fp;
5054 }
5055 }
5056
5057 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
5058
5059 wl_data->buf = (char *) mymalloc (segment_size);
5060 wl_data->avail = segment_size;
5061 wl_data->incr = segment_size;
5062 wl_data->cnt = 0;
5063 wl_data->pos = 0;
5064
5065 u64 words_cur = 0;
5066
5067 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5068 {
5069 u64 words_off = 0;
5070 u64 words_fin = 0;
5071
5072 u64 max = -1;
5073
5074 while (max)
5075 {
5076 const uint work = get_work (device_param, max);
5077
5078 if (work == 0) break;
5079
5080 max = 0;
5081
5082 words_off = device_param->words_off;
5083 words_fin = words_off + work;
5084
5085 char *line_buf;
5086 uint line_len;
5087
5088 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5089
5090 for ( ; words_cur < words_fin; words_cur++)
5091 {
5092 get_next_word (wl_data, fd, &line_buf, &line_len);
5093
5094 line_len = convert_from_hex (line_buf, line_len);
5095
5096 // post-process rule engine
5097
5098 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5099 {
5100 char rule_buf_out[BLOCK_SIZE] = { 0 };
5101
5102 int rule_len_out = -1;
5103
5104 if (line_len < BLOCK_SIZE)
5105 {
5106 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5107 }
5108
5109 if (rule_len_out < 0) continue;
5110
5111 line_buf = rule_buf_out;
5112 line_len = rule_len_out;
5113 }
5114
5115 if (attack_kern == ATTACK_KERN_STRAIGHT)
5116 {
5117 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5118 {
5119 max++;
5120
5121 hc_thread_mutex_lock (mux_counter);
5122
5123 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5124 {
5125 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5126 }
5127
5128 hc_thread_mutex_unlock (mux_counter);
5129
5130 continue;
5131 }
5132 }
5133 else if (attack_kern == ATTACK_KERN_COMBI)
5134 {
5135 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5136 // since we still need to combine the plains
5137
5138 if (line_len > data.pw_max)
5139 {
5140 max++;
5141
5142 hc_thread_mutex_lock (mux_counter);
5143
5144 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5145 {
5146 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5147 }
5148
5149 hc_thread_mutex_unlock (mux_counter);
5150
5151 continue;
5152 }
5153 }
5154
5155 pw_add (device_param, (u8 *) line_buf, line_len);
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 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5174
5175 if (data.devices_status == STATUS_CRACKED) break;
5176 if (data.devices_status == STATUS_ABORTED) break;
5177 if (data.devices_status == STATUS_QUIT) break;
5178 if (data.devices_status == STATUS_BYPASS) break;
5179
5180 //
5181 // flush
5182 //
5183
5184 const uint pws_cnt = device_param->pws_cnt;
5185
5186 if (pws_cnt)
5187 {
5188 run_copy (device_param, pws_cnt);
5189
5190 run_cracker (device_param, pws_cnt);
5191
5192 device_param->pws_cnt = 0;
5193
5194 /*
5195 still required?
5196 if (attack_kern == ATTACK_KERN_STRAIGHT)
5197 {
5198 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5199 }
5200 else if (attack_kern == ATTACK_KERN_COMBI)
5201 {
5202 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5203 }
5204 */
5205 }
5206
5207 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5208
5209 if (data.devices_status == STATUS_CRACKED) break;
5210 if (data.devices_status == STATUS_ABORTED) break;
5211 if (data.devices_status == STATUS_QUIT) break;
5212 if (data.devices_status == STATUS_BYPASS) break;
5213
5214 if (words_fin == 0) break;
5215
5216 device_param->words_done = words_fin;
5217 }
5218
5219 if (attack_mode == ATTACK_MODE_COMBI)
5220 {
5221 fclose (device_param->combs_fp);
5222 }
5223
5224 free (wl_data->buf);
5225 free (wl_data);
5226
5227 fclose (fd);
5228 }
5229
5230 device_param->kernel_accel = 0;
5231 device_param->kernel_loops = 0;
5232
5233 return NULL;
5234 }
5235
5236 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5237 {
5238 if (!device_param)
5239 {
5240 log_error ("ERROR: %s : Invalid argument", __func__);
5241
5242 exit (-1);
5243 }
5244
5245 salt_t *salt_buf = &data.salts_buf[salt_pos];
5246
5247 device_param->kernel_params_buf32[27] = salt_pos;
5248 device_param->kernel_params_buf32[30] = 1;
5249 device_param->kernel_params_buf32[31] = salt_buf->digests_cnt;
5250 device_param->kernel_params_buf32[32] = salt_buf->digests_offset;
5251 device_param->kernel_params_buf32[33] = 0;
5252 device_param->kernel_params_buf32[34] = 1;
5253
5254 char *dictfile_old = data.dictfile;
5255
5256 const char *weak_hash_check = "weak-hash-check";
5257
5258 data.dictfile = (char *) weak_hash_check;
5259
5260 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5261
5262 data.kernel_rules_buf[0].cmds[0] = 0;
5263
5264 /**
5265 * run the kernel
5266 */
5267
5268 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5269 {
5270 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5271 }
5272 else
5273 {
5274 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5275
5276 uint loop_step = 16;
5277
5278 const uint iter = salt_buf->salt_iter;
5279
5280 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5281 {
5282 uint loop_left = iter - loop_pos;
5283
5284 loop_left = MIN (loop_left, loop_step);
5285
5286 device_param->kernel_params_buf32[28] = loop_pos;
5287 device_param->kernel_params_buf32[29] = loop_left;
5288
5289 run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5290 }
5291
5292 run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5293 }
5294
5295 /**
5296 * result
5297 */
5298
5299 check_cracked (device_param, salt_pos);
5300
5301 /**
5302 * cleanup
5303 */
5304
5305 device_param->kernel_params_buf32[27] = 0;
5306 device_param->kernel_params_buf32[28] = 0;
5307 device_param->kernel_params_buf32[29] = 0;
5308 device_param->kernel_params_buf32[30] = 0;
5309 device_param->kernel_params_buf32[31] = 0;
5310 device_param->kernel_params_buf32[32] = 0;
5311 device_param->kernel_params_buf32[33] = 0;
5312 device_param->kernel_params_buf32[34] = 0;
5313
5314 data.dictfile = dictfile_old;
5315
5316 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5317 }
5318
5319 // hlfmt hashcat
5320
5321 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5322 {
5323 if (data.username == 0)
5324 {
5325 *hashbuf_pos = line_buf;
5326 *hashbuf_len = line_len;
5327 }
5328 else
5329 {
5330 char *pos = line_buf;
5331 int len = line_len;
5332
5333 for (int i = 0; i < line_len; i++, pos++, len--)
5334 {
5335 if (line_buf[i] == data.separator)
5336 {
5337 pos++;
5338
5339 len--;
5340
5341 break;
5342 }
5343 }
5344
5345 *hashbuf_pos = pos;
5346 *hashbuf_len = len;
5347 }
5348 }
5349
5350 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5351 {
5352 char *pos = NULL;
5353 int len = 0;
5354
5355 int sep_cnt = 0;
5356
5357 for (int i = 0; i < line_len; i++)
5358 {
5359 if (line_buf[i] == data.separator)
5360 {
5361 sep_cnt++;
5362
5363 continue;
5364 }
5365
5366 if (sep_cnt == 0)
5367 {
5368 if (pos == NULL) pos = line_buf + i;
5369
5370 len++;
5371 }
5372 }
5373
5374 *userbuf_pos = pos;
5375 *userbuf_len = len;
5376 }
5377
5378 // hlfmt pwdump
5379
5380 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5381 {
5382 int sep_cnt = 0;
5383
5384 int sep2_len = 0;
5385 int sep3_len = 0;
5386
5387 for (int i = 0; i < line_len; i++)
5388 {
5389 if (line_buf[i] == ':')
5390 {
5391 sep_cnt++;
5392
5393 continue;
5394 }
5395
5396 if (sep_cnt == 2) sep2_len++;
5397 if (sep_cnt == 3) sep3_len++;
5398 }
5399
5400 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5401
5402 return 0;
5403 }
5404
5405 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5406 {
5407 char *pos = NULL;
5408 int len = 0;
5409
5410 int sep_cnt = 0;
5411
5412 for (int i = 0; i < line_len; i++)
5413 {
5414 if (line_buf[i] == ':')
5415 {
5416 sep_cnt++;
5417
5418 continue;
5419 }
5420
5421 if (data.hash_mode == 1000)
5422 {
5423 if (sep_cnt == 3)
5424 {
5425 if (pos == NULL) pos = line_buf + i;
5426
5427 len++;
5428 }
5429 }
5430 else if (data.hash_mode == 3000)
5431 {
5432 if (sep_cnt == 2)
5433 {
5434 if (pos == NULL) pos = line_buf + i;
5435
5436 len++;
5437 }
5438 }
5439 }
5440
5441 *hashbuf_pos = pos;
5442 *hashbuf_len = len;
5443 }
5444
5445 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5446 {
5447 char *pos = NULL;
5448 int len = 0;
5449
5450 int sep_cnt = 0;
5451
5452 for (int i = 0; i < line_len; i++)
5453 {
5454 if (line_buf[i] == ':')
5455 {
5456 sep_cnt++;
5457
5458 continue;
5459 }
5460
5461 if (sep_cnt == 0)
5462 {
5463 if (pos == NULL) pos = line_buf + i;
5464
5465 len++;
5466 }
5467 }
5468
5469 *userbuf_pos = pos;
5470 *userbuf_len = len;
5471 }
5472
5473 // hlfmt passwd
5474
5475 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5476 {
5477 int sep_cnt = 0;
5478
5479 char sep5_first = 0;
5480 char sep6_first = 0;
5481
5482 for (int i = 0; i < line_len; i++)
5483 {
5484 if (line_buf[i] == ':')
5485 {
5486 sep_cnt++;
5487
5488 continue;
5489 }
5490
5491 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5492 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5493 }
5494
5495 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5496
5497 return 0;
5498 }
5499
5500 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5501 {
5502 char *pos = NULL;
5503 int len = 0;
5504
5505 int sep_cnt = 0;
5506
5507 for (int i = 0; i < line_len; i++)
5508 {
5509 if (line_buf[i] == ':')
5510 {
5511 sep_cnt++;
5512
5513 continue;
5514 }
5515
5516 if (sep_cnt == 1)
5517 {
5518 if (pos == NULL) pos = line_buf + i;
5519
5520 len++;
5521 }
5522 }
5523
5524 *hashbuf_pos = pos;
5525 *hashbuf_len = len;
5526 }
5527
5528 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5529 {
5530 char *pos = NULL;
5531 int len = 0;
5532
5533 int sep_cnt = 0;
5534
5535 for (int i = 0; i < line_len; i++)
5536 {
5537 if (line_buf[i] == ':')
5538 {
5539 sep_cnt++;
5540
5541 continue;
5542 }
5543
5544 if (sep_cnt == 0)
5545 {
5546 if (pos == NULL) pos = line_buf + i;
5547
5548 len++;
5549 }
5550 }
5551
5552 *userbuf_pos = pos;
5553 *userbuf_len = len;
5554 }
5555
5556 // hlfmt shadow
5557
5558 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5559 {
5560 int sep_cnt = 0;
5561
5562 for (int i = 0; i < line_len; i++)
5563 {
5564 if (line_buf[i] == ':') sep_cnt++;
5565 }
5566
5567 if (sep_cnt == 8) return 1;
5568
5569 return 0;
5570 }
5571
5572 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5573 {
5574 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5575 }
5576
5577 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5578 {
5579 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5580 }
5581
5582 // hlfmt main
5583
5584 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5585 {
5586 switch (hashfile_format)
5587 {
5588 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5589 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5590 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5591 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5592 }
5593 }
5594
5595 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5596 {
5597 switch (hashfile_format)
5598 {
5599 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5600 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5601 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5602 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5603 }
5604 }
5605
5606 char *strhlfmt (const uint hashfile_format)
5607 {
5608 switch (hashfile_format)
5609 {
5610 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5611 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5612 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5613 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5614 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5615 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5616 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5617 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5618 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5619 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5620 }
5621
5622 return ((char *) "Unknown");
5623 }
5624
5625 static uint hlfmt_detect (FILE *fp, uint max_check)
5626 {
5627 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5628
5629 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5630 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5631
5632 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5633
5634 uint num_check = 0;
5635
5636 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5637
5638 while (!feof (fp))
5639 {
5640 int line_len = fgetl (fp, line_buf);
5641
5642 if (line_len == 0) continue;
5643
5644 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5645 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5646 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5647
5648 if (num_check == max_check) break;
5649
5650 num_check++;
5651 }
5652
5653 myfree (line_buf);
5654
5655 uint hashlist_format = HLFMT_HASHCAT;
5656
5657 for (int i = 1; i < HLFMTS_CNT; i++)
5658 {
5659 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5660
5661 hashlist_format = i;
5662 }
5663
5664 free (formats_cnt);
5665
5666 return hashlist_format;
5667 }
5668
5669 /**
5670 * some further helper function
5671 */
5672
5673 // wrapper around mymalloc for ADL
5674
5675 #if defined(HAVE_HWMON)
5676 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5677 {
5678 return mymalloc (iSize);
5679 }
5680 #endif
5681
5682 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)
5683 {
5684 u64 collisions = 0;
5685
5686 const uint dgst_pos0 = data.dgst_pos0;
5687 const uint dgst_pos1 = data.dgst_pos1;
5688 const uint dgst_pos2 = data.dgst_pos2;
5689 const uint dgst_pos3 = data.dgst_pos3;
5690
5691 memset (bitmap_a, 0, bitmap_size);
5692 memset (bitmap_b, 0, bitmap_size);
5693 memset (bitmap_c, 0, bitmap_size);
5694 memset (bitmap_d, 0, bitmap_size);
5695
5696 for (uint i = 0; i < digests_cnt; i++)
5697 {
5698 uint *digest_ptr = (uint *) digests_buf_ptr;
5699
5700 digests_buf_ptr += dgst_size;
5701
5702 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5703 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5704 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5705 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5706
5707 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5708 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5709 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5710 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5711
5712 if (bitmap_a[idx0] & val0) collisions++;
5713 if (bitmap_b[idx1] & val1) collisions++;
5714 if (bitmap_c[idx2] & val2) collisions++;
5715 if (bitmap_d[idx3] & val3) collisions++;
5716
5717 bitmap_a[idx0] |= val0;
5718 bitmap_b[idx1] |= val1;
5719 bitmap_c[idx2] |= val2;
5720 bitmap_d[idx3] |= val3;
5721
5722 if (collisions >= collisions_max) return 0x7fffffff;
5723 }
5724
5725 return collisions;
5726 }
5727
5728 /**
5729 * main
5730 */
5731
5732 #ifdef WIN
5733 void SetConsoleWindowSize (const int x)
5734 {
5735 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5736
5737 if (h == INVALID_HANDLE_VALUE) return;
5738
5739 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5740
5741 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5742
5743 SMALL_RECT *sr = &bufferInfo.srWindow;
5744
5745 sr->Right = MAX (sr->Right, x - 1);
5746
5747 COORD co;
5748
5749 co.X = sr->Right + 1;
5750 co.Y = 9999;
5751
5752 if (!SetConsoleScreenBufferSize (h, co)) return;
5753
5754 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5755 }
5756 #endif
5757
5758 int main (int argc, char **argv)
5759 {
5760 #ifdef WIN
5761 SetConsoleWindowSize (132);
5762 #endif
5763
5764 /**
5765 * To help users a bit
5766 */
5767
5768 char *compute = getenv ("COMPUTE");
5769
5770 if (compute)
5771 {
5772 static char display[100];
5773
5774 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5775
5776 putenv (display);
5777 }
5778 else
5779 {
5780 if (getenv ("DISPLAY") == NULL)
5781 putenv ((char *) "DISPLAY=:0");
5782 }
5783
5784 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5785 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5786
5787 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5788 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5789
5790 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5791 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5792
5793 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5794 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5795
5796 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5797 putenv ((char *) "POCL_KERNEL_CACHE=0");
5798
5799 umask (077);
5800
5801 /**
5802 * Real init
5803 */
5804
5805 memset (&data, 0, sizeof (hc_global_data_t));
5806
5807 time_t proc_start;
5808
5809 time (&proc_start);
5810
5811 data.proc_start = proc_start;
5812
5813 int myargc = argc;
5814 char **myargv = argv;
5815
5816 hc_thread_mutex_init (mux_dispatcher);
5817 hc_thread_mutex_init (mux_counter);
5818 hc_thread_mutex_init (mux_display);
5819 hc_thread_mutex_init (mux_adl);
5820
5821 /**
5822 * commandline parameters
5823 */
5824
5825 uint usage = USAGE;
5826 uint version = VERSION;
5827 uint quiet = QUIET;
5828 uint benchmark = BENCHMARK;
5829 uint stdout_flag = STDOUT_FLAG;
5830 uint show = SHOW;
5831 uint left = LEFT;
5832 uint username = USERNAME;
5833 uint remove = REMOVE;
5834 uint remove_timer = REMOVE_TIMER;
5835 u64 skip = SKIP;
5836 u64 limit = LIMIT;
5837 uint keyspace = KEYSPACE;
5838 uint potfile_disable = POTFILE_DISABLE;
5839 char *potfile_path = NULL;
5840 uint debug_mode = DEBUG_MODE;
5841 char *debug_file = NULL;
5842 char *induction_dir = NULL;
5843 char *outfile_check_dir = NULL;
5844 uint force = FORCE;
5845 uint runtime = RUNTIME;
5846 uint hash_mode = HASH_MODE;
5847 uint attack_mode = ATTACK_MODE;
5848 uint markov_disable = MARKOV_DISABLE;
5849 uint markov_classic = MARKOV_CLASSIC;
5850 uint markov_threshold = MARKOV_THRESHOLD;
5851 char *markov_hcstat = NULL;
5852 char *outfile = NULL;
5853 uint outfile_format = OUTFILE_FORMAT;
5854 uint outfile_autohex = OUTFILE_AUTOHEX;
5855 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5856 uint restore = RESTORE;
5857 uint restore_timer = RESTORE_TIMER;
5858 uint restore_disable = RESTORE_DISABLE;
5859 uint status = STATUS;
5860 uint status_timer = STATUS_TIMER;
5861 uint machine_readable = MACHINE_READABLE;
5862 uint loopback = LOOPBACK;
5863 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5864 char *session = NULL;
5865 uint hex_charset = HEX_CHARSET;
5866 uint hex_salt = HEX_SALT;
5867 uint hex_wordlist = HEX_WORDLIST;
5868 uint rp_gen = RP_GEN;
5869 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5870 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5871 uint rp_gen_seed = RP_GEN_SEED;
5872 char *rule_buf_l = (char *) RULE_BUF_L;
5873 char *rule_buf_r = (char *) RULE_BUF_R;
5874 uint increment = INCREMENT;
5875 uint increment_min = INCREMENT_MIN;
5876 uint increment_max = INCREMENT_MAX;
5877 char *cpu_affinity = NULL;
5878 OCL_PTR *ocl = NULL;
5879 char *opencl_devices = NULL;
5880 char *opencl_platforms = NULL;
5881 char *opencl_device_types = NULL;
5882 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5883 char *truecrypt_keyfiles = NULL;
5884 char *veracrypt_keyfiles = NULL;
5885 uint veracrypt_pim = 0;
5886 uint workload_profile = WORKLOAD_PROFILE;
5887 uint kernel_accel = KERNEL_ACCEL;
5888 uint kernel_loops = KERNEL_LOOPS;
5889 uint nvidia_spin_damp = NVIDIA_SPIN_DAMP;
5890 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5891 #ifdef HAVE_HWMON
5892 uint gpu_temp_abort = GPU_TEMP_ABORT;
5893 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5894 uint powertune_enable = POWERTUNE_ENABLE;
5895 #endif
5896 uint logfile_disable = LOGFILE_DISABLE;
5897 uint segment_size = SEGMENT_SIZE;
5898 uint scrypt_tmto = SCRYPT_TMTO;
5899 char separator = SEPARATOR;
5900 uint bitmap_min = BITMAP_MIN;
5901 uint bitmap_max = BITMAP_MAX;
5902 char *custom_charset_1 = NULL;
5903 char *custom_charset_2 = NULL;
5904 char *custom_charset_3 = NULL;
5905 char *custom_charset_4 = NULL;
5906
5907 #define IDX_HELP 'h'
5908 #define IDX_VERSION 'V'
5909 #define IDX_VERSION_LOWER 'v'
5910 #define IDX_QUIET 0xff02
5911 #define IDX_SHOW 0xff03
5912 #define IDX_LEFT 0xff04
5913 #define IDX_REMOVE 0xff05
5914 #define IDX_REMOVE_TIMER 0xff37
5915 #define IDX_SKIP 's'
5916 #define IDX_LIMIT 'l'
5917 #define IDX_KEYSPACE 0xff35
5918 #define IDX_POTFILE_DISABLE 0xff06
5919 #define IDX_POTFILE_PATH 0xffe0
5920 #define IDX_DEBUG_MODE 0xff43
5921 #define IDX_DEBUG_FILE 0xff44
5922 #define IDX_INDUCTION_DIR 0xff46
5923 #define IDX_OUTFILE_CHECK_DIR 0xff47
5924 #define IDX_USERNAME 0xff07
5925 #define IDX_FORCE 0xff08
5926 #define IDX_RUNTIME 0xff09
5927 #define IDX_BENCHMARK 'b'
5928 #define IDX_STDOUT_FLAG 0xff77
5929 #define IDX_HASH_MODE 'm'
5930 #define IDX_ATTACK_MODE 'a'
5931 #define IDX_RP_FILE 'r'
5932 #define IDX_RP_GEN 'g'
5933 #define IDX_RP_GEN_FUNC_MIN 0xff10
5934 #define IDX_RP_GEN_FUNC_MAX 0xff11
5935 #define IDX_RP_GEN_SEED 0xff34
5936 #define IDX_RULE_BUF_L 'j'
5937 #define IDX_RULE_BUF_R 'k'
5938 #define IDX_INCREMENT 'i'
5939 #define IDX_INCREMENT_MIN 0xff12
5940 #define IDX_INCREMENT_MAX 0xff13
5941 #define IDX_OUTFILE 'o'
5942 #define IDX_OUTFILE_FORMAT 0xff14
5943 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5944 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5945 #define IDX_RESTORE 0xff15
5946 #define IDX_RESTORE_DISABLE 0xff27
5947 #define IDX_STATUS 0xff17
5948 #define IDX_STATUS_TIMER 0xff18
5949 #define IDX_MACHINE_READABLE 0xff50
5950 #define IDX_LOOPBACK 0xff38
5951 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5952 #define IDX_SESSION 0xff19
5953 #define IDX_HEX_CHARSET 0xff20
5954 #define IDX_HEX_SALT 0xff21
5955 #define IDX_HEX_WORDLIST 0xff40
5956 #define IDX_MARKOV_DISABLE 0xff22
5957 #define IDX_MARKOV_CLASSIC 0xff23
5958 #define IDX_MARKOV_THRESHOLD 't'
5959 #define IDX_MARKOV_HCSTAT 0xff24
5960 #define IDX_CPU_AFFINITY 0xff25
5961 #define IDX_OPENCL_DEVICES 'd'
5962 #define IDX_OPENCL_PLATFORMS 0xff72
5963 #define IDX_OPENCL_DEVICE_TYPES 'D'
5964 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5965 #define IDX_WORKLOAD_PROFILE 'w'
5966 #define IDX_KERNEL_ACCEL 'n'
5967 #define IDX_KERNEL_LOOPS 'u'
5968 #define IDX_NVIDIA_SPIN_DAMP 0xff79
5969 #define IDX_GPU_TEMP_DISABLE 0xff29
5970 #define IDX_GPU_TEMP_ABORT 0xff30
5971 #define IDX_GPU_TEMP_RETAIN 0xff31
5972 #define IDX_POWERTUNE_ENABLE 0xff41
5973 #define IDX_LOGFILE_DISABLE 0xff51
5974 #define IDX_TRUECRYPT_KEYFILES 0xff52
5975 #define IDX_VERACRYPT_KEYFILES 0xff53
5976 #define IDX_VERACRYPT_PIM 0xff54
5977 #define IDX_SCRYPT_TMTO 0xff61
5978 #define IDX_SEGMENT_SIZE 'c'
5979 #define IDX_SEPARATOR 'p'
5980 #define IDX_BITMAP_MIN 0xff70
5981 #define IDX_BITMAP_MAX 0xff71
5982 #define IDX_CUSTOM_CHARSET_1 '1'
5983 #define IDX_CUSTOM_CHARSET_2 '2'
5984 #define IDX_CUSTOM_CHARSET_3 '3'
5985 #define IDX_CUSTOM_CHARSET_4 '4'
5986
5987 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:D:n:u:c:p:s:l:1:2:3:4:ibw:";
5988
5989 struct option long_options[] =
5990 {
5991 {"help", no_argument, 0, IDX_HELP},
5992 {"version", no_argument, 0, IDX_VERSION},
5993 {"quiet", no_argument, 0, IDX_QUIET},
5994 {"show", no_argument, 0, IDX_SHOW},
5995 {"left", no_argument, 0, IDX_LEFT},
5996 {"username", no_argument, 0, IDX_USERNAME},
5997 {"remove", no_argument, 0, IDX_REMOVE},
5998 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5999 {"skip", required_argument, 0, IDX_SKIP},
6000 {"limit", required_argument, 0, IDX_LIMIT},
6001 {"keyspace", no_argument, 0, IDX_KEYSPACE},
6002 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
6003 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
6004 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
6005 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
6006 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
6007 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
6008 {"force", no_argument, 0, IDX_FORCE},
6009 {"benchmark", no_argument, 0, IDX_BENCHMARK},
6010 {"stdout", no_argument, 0, IDX_STDOUT_FLAG},
6011 {"restore", no_argument, 0, IDX_RESTORE},
6012 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
6013 {"status", no_argument, 0, IDX_STATUS},
6014 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
6015 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
6016 {"loopback", no_argument, 0, IDX_LOOPBACK},
6017 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
6018 {"session", required_argument, 0, IDX_SESSION},
6019 {"runtime", required_argument, 0, IDX_RUNTIME},
6020 {"generate-rules", required_argument, 0, IDX_RP_GEN},
6021 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
6022 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
6023 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
6024 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
6025 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
6026 {"hash-type", required_argument, 0, IDX_HASH_MODE},
6027 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
6028 {"rules-file", required_argument, 0, IDX_RP_FILE},
6029 {"outfile", required_argument, 0, IDX_OUTFILE},
6030 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
6031 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
6032 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
6033 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
6034 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
6035 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
6036 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
6037 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
6038 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
6039 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
6040 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
6041 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
6042 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
6043 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
6044 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
6045 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
6046 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
6047 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
6048 {"nvidia-spin-damp", required_argument, 0, IDX_NVIDIA_SPIN_DAMP},
6049 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
6050 #ifdef HAVE_HWMON
6051 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
6052 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
6053 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
6054 #endif // HAVE_HWMON
6055 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
6056 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
6057 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
6058 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
6059 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
6060 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
6061 {"seperator", required_argument, 0, IDX_SEPARATOR},
6062 {"separator", required_argument, 0, IDX_SEPARATOR},
6063 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
6064 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
6065 {"increment", no_argument, 0, IDX_INCREMENT},
6066 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
6067 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
6068 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
6069 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
6070 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
6071 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
6072 {0, 0, 0, 0}
6073 };
6074
6075 uint rp_files_cnt = 0;
6076
6077 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6078
6079 int option_index = 0;
6080 int c = -1;
6081
6082 optind = 1;
6083 optopt = 0;
6084
6085 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6086 {
6087 switch (c)
6088 {
6089 case IDX_HELP: usage = 1; break;
6090 case IDX_VERSION:
6091 case IDX_VERSION_LOWER: version = 1; break;
6092 case IDX_RESTORE: restore = 1; break;
6093 case IDX_SESSION: session = optarg; break;
6094 case IDX_SHOW: show = 1; break;
6095 case IDX_LEFT: left = 1; break;
6096 case '?': return (-1);
6097 }
6098 }
6099
6100 if (optopt != 0)
6101 {
6102 log_error ("ERROR: Invalid argument specified");
6103
6104 return (-1);
6105 }
6106
6107 /**
6108 * exit functions
6109 */
6110
6111 if (version)
6112 {
6113 log_info ("%s", VERSION_TAG);
6114
6115 return (0);
6116 }
6117
6118 if (usage)
6119 {
6120 usage_big_print (PROGNAME);
6121
6122 return (0);
6123 }
6124
6125 /**
6126 * session needs to be set, always!
6127 */
6128
6129 if (session == NULL) session = (char *) PROGNAME;
6130
6131 /**
6132 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6133 */
6134
6135 char *exec_path = get_exec_path ();
6136
6137 #ifdef LINUX
6138
6139 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6140 char *resolved_exec_path = realpath (exec_path, NULL);
6141
6142 char *install_dir = get_install_dir (resolved_exec_path);
6143 char *profile_dir = NULL;
6144 char *session_dir = NULL;
6145 char *shared_dir = NULL;
6146
6147 if (strcmp (install_dir, resolved_install_folder) == 0)
6148 {
6149 struct passwd *pw = getpwuid (getuid ());
6150
6151 const char *homedir = pw->pw_dir;
6152
6153 profile_dir = get_profile_dir (homedir);
6154 session_dir = get_session_dir (profile_dir);
6155 shared_dir = strdup (SHARED_FOLDER);
6156
6157 mkdir (profile_dir, 0700);
6158 mkdir (session_dir, 0700);
6159 }
6160 else
6161 {
6162 profile_dir = install_dir;
6163 session_dir = install_dir;
6164 shared_dir = install_dir;
6165 }
6166
6167 myfree (resolved_install_folder);
6168 myfree (resolved_exec_path);
6169
6170 #else
6171
6172 char *install_dir = get_install_dir (exec_path);
6173 char *profile_dir = install_dir;
6174 char *session_dir = install_dir;
6175 char *shared_dir = install_dir;
6176
6177 #endif
6178
6179 data.install_dir = install_dir;
6180 data.profile_dir = profile_dir;
6181 data.session_dir = session_dir;
6182 data.shared_dir = shared_dir;
6183
6184 myfree (exec_path);
6185
6186 /**
6187 * kernel cache, we need to make sure folder exist
6188 */
6189
6190 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6191
6192 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6193
6194 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6195
6196 mkdir (kernels_folder, 0700);
6197
6198 myfree (kernels_folder);
6199
6200 /**
6201 * session
6202 */
6203
6204 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6205
6206 data.session = session;
6207
6208 char *eff_restore_file = (char *) mymalloc (session_size);
6209 char *new_restore_file = (char *) mymalloc (session_size);
6210
6211 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
6212 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6213
6214 data.eff_restore_file = eff_restore_file;
6215 data.new_restore_file = new_restore_file;
6216
6217 if (((show == 1) || (left == 1)) && (restore == 1))
6218 {
6219 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6220 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6221
6222 return (-1);
6223 }
6224
6225 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6226 if ((show == 1) || (left == 1))
6227 {
6228 restore_disable = 1;
6229
6230 restore = 0;
6231 }
6232
6233 data.restore_disable = restore_disable;
6234
6235 restore_data_t *rd = init_restore (argc, argv);
6236
6237 data.rd = rd;
6238
6239 /**
6240 * restore file
6241 */
6242
6243 if (restore == 1)
6244 {
6245 read_restore (eff_restore_file, rd);
6246
6247 if (rd->version_bin < RESTORE_MIN)
6248 {
6249 log_error ("ERROR: Incompatible restore-file version");
6250
6251 return (-1);
6252 }
6253
6254 myargc = rd->argc;
6255 myargv = rd->argv;
6256
6257 #ifdef _POSIX
6258 rd->pid = getpid ();
6259 #elif _WIN
6260 rd->pid = GetCurrentProcessId ();
6261 #endif
6262 }
6263
6264 uint hash_mode_chgd = 0;
6265 uint runtime_chgd = 0;
6266 uint kernel_loops_chgd = 0;
6267 uint kernel_accel_chgd = 0;
6268 uint nvidia_spin_damp_chgd = 0;
6269 uint attack_mode_chgd = 0;
6270 uint outfile_format_chgd = 0;
6271 uint rp_gen_seed_chgd = 0;
6272 uint remove_timer_chgd = 0;
6273 uint increment_min_chgd = 0;
6274 uint increment_max_chgd = 0;
6275 uint workload_profile_chgd = 0;
6276 uint opencl_vector_width_chgd = 0;
6277
6278 optind = 1;
6279 optopt = 0;
6280 option_index = 0;
6281
6282 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6283 {
6284 switch (c)
6285 {
6286 //case IDX_HELP: usage = 1; break;
6287 //case IDX_VERSION: version = 1; break;
6288 //case IDX_RESTORE: restore = 1; break;
6289 case IDX_QUIET: quiet = 1; break;
6290 //case IDX_SHOW: show = 1; break;
6291 case IDX_SHOW: break;
6292 //case IDX_LEFT: left = 1; break;
6293 case IDX_LEFT: break;
6294 case IDX_USERNAME: username = 1; break;
6295 case IDX_REMOVE: remove = 1; break;
6296 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6297 remove_timer_chgd = 1; break;
6298 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6299 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6300 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6301 case IDX_DEBUG_FILE: debug_file = optarg; break;
6302 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6303 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6304 case IDX_FORCE: force = 1; break;
6305 case IDX_SKIP: skip = atoll (optarg); break;
6306 case IDX_LIMIT: limit = atoll (optarg); break;
6307 case IDX_KEYSPACE: keyspace = 1; break;
6308 case IDX_BENCHMARK: benchmark = 1; break;
6309 case IDX_STDOUT_FLAG: stdout_flag = 1; break;
6310 case IDX_RESTORE: break;
6311 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6312 case IDX_STATUS: status = 1; break;
6313 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6314 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6315 case IDX_LOOPBACK: loopback = 1; break;
6316 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6317 //case IDX_SESSION: session = optarg; break;
6318 case IDX_SESSION: break;
6319 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6320 hash_mode_chgd = 1; break;
6321 case IDX_RUNTIME: runtime = atoi (optarg);
6322 runtime_chgd = 1; break;
6323 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6324 attack_mode_chgd = 1; break;
6325 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6326 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6327 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6328 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6329 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6330 rp_gen_seed_chgd = 1; break;
6331 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6332 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6333 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6334 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6335 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6336 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6337 case IDX_OUTFILE: outfile = optarg; break;
6338 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6339 outfile_format_chgd = 1; break;
6340 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6341 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6342 case IDX_HEX_CHARSET: hex_charset = 1; break;
6343 case IDX_HEX_SALT: hex_salt = 1; break;
6344 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6345 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6346 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6347 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6348 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6349 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6350 opencl_vector_width_chgd = 1; break;
6351 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6352 workload_profile_chgd = 1; break;
6353 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6354 kernel_accel_chgd = 1; break;
6355 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6356 kernel_loops_chgd = 1; break;
6357 case IDX_NVIDIA_SPIN_DAMP: nvidia_spin_damp = atoi (optarg);
6358 nvidia_spin_damp_chgd = 1; break;
6359 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6360 #ifdef HAVE_HWMON
6361 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6362 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6363 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6364 #endif // HAVE_HWMON
6365 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6366 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6367 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6368 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6369 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6370 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6371 case IDX_SEPARATOR: separator = optarg[0]; break;
6372 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6373 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6374 case IDX_INCREMENT: increment = 1; break;
6375 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6376 increment_min_chgd = 1; break;
6377 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6378 increment_max_chgd = 1; break;
6379 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6380 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6381 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6382 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6383
6384 default:
6385 log_error ("ERROR: Invalid argument specified");
6386 return (-1);
6387 }
6388 }
6389
6390 if (optopt != 0)
6391 {
6392 log_error ("ERROR: Invalid argument specified");
6393
6394 return (-1);
6395 }
6396
6397 /**
6398 * Inform user things getting started,
6399 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6400 * - we do not need to check algorithm_pos
6401 */
6402
6403 if (quiet == 0)
6404 {
6405 if (benchmark == 1)
6406 {
6407 if (machine_readable == 0)
6408 {
6409 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6410 log_info ("");
6411 }
6412 else
6413 {
6414 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6415 }
6416 }
6417 else if (restore == 1)
6418 {
6419 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6420 log_info ("");
6421 }
6422 else if (stdout_flag == 1)
6423 {
6424 // do nothing
6425 }
6426 else if (keyspace == 1)
6427 {
6428 // do nothing
6429 }
6430 else
6431 {
6432 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6433 log_info ("");
6434 }
6435 }
6436
6437 /**
6438 * sanity check
6439 */
6440
6441 if (attack_mode > 7)
6442 {
6443 log_error ("ERROR: Invalid attack-mode specified");
6444
6445 return (-1);
6446 }
6447
6448 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6449 {
6450 log_error ("ERROR: Invalid runtime specified");
6451
6452 return (-1);
6453 }
6454
6455 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6456 {
6457 log_error ("ERROR: Invalid hash-type specified");
6458
6459 return (-1);
6460 }
6461
6462 // renamed hash modes
6463
6464 if (hash_mode_chgd)
6465 {
6466 int n = -1;
6467
6468 switch (hash_mode)
6469 {
6470 case 123: n = 124;
6471 break;
6472 }
6473
6474 if (n >= 0)
6475 {
6476 log_error ("Old -m specified, use -m %d instead", n);
6477
6478 return (-1);
6479 }
6480 }
6481
6482 if (username == 1)
6483 {
6484 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6485 {
6486 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6487
6488 return (-1);
6489 }
6490 }
6491
6492 if (outfile_format > 16)
6493 {
6494 log_error ("ERROR: Invalid outfile-format specified");
6495
6496 return (-1);
6497 }
6498
6499 if (left == 1)
6500 {
6501 if (outfile_format_chgd == 1)
6502 {
6503 if (outfile_format > 1)
6504 {
6505 log_error ("ERROR: Mixing outfile-format > 1 with left parameter is not allowed");
6506
6507 return (-1);
6508 }
6509 }
6510 else
6511 {
6512 outfile_format = OUTFILE_FMT_HASH;
6513 }
6514 }
6515
6516 if (show == 1)
6517 {
6518 if (outfile_format_chgd == 1)
6519 {
6520 if ((outfile_format > 7) && (outfile_format < 16))
6521 {
6522 log_error ("ERROR: Mixing outfile-format > 7 with show parameter is not allowed");
6523
6524 return (-1);
6525 }
6526 }
6527 }
6528
6529 if (increment_min < INCREMENT_MIN)
6530 {
6531 log_error ("ERROR: Invalid increment-min specified");
6532
6533 return (-1);
6534 }
6535
6536 if (increment_max > INCREMENT_MAX)
6537 {
6538 log_error ("ERROR: Invalid increment-max specified");
6539
6540 return (-1);
6541 }
6542
6543 if (increment_min > increment_max)
6544 {
6545 log_error ("ERROR: Invalid increment-min specified");
6546
6547 return (-1);
6548 }
6549
6550 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6551 {
6552 log_error ("ERROR: Increment is not allowed in attack-mode 0");
6553
6554 return (-1);
6555 }
6556
6557 if ((increment == 0) && (increment_min_chgd == 1))
6558 {
6559 log_error ("ERROR: Increment-min is only supported combined with increment switch");
6560
6561 return (-1);
6562 }
6563
6564 if ((increment == 0) && (increment_max_chgd == 1))
6565 {
6566 log_error ("ERROR: Increment-max is only supported combined with increment switch");
6567
6568 return (-1);
6569 }
6570
6571 if (rp_files_cnt && rp_gen)
6572 {
6573 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6574
6575 return (-1);
6576 }
6577
6578 if (rp_files_cnt || rp_gen)
6579 {
6580 if (attack_mode != ATTACK_MODE_STRAIGHT)
6581 {
6582 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6583
6584 return (-1);
6585 }
6586 }
6587
6588 if (rp_gen_func_min > rp_gen_func_max)
6589 {
6590 log_error ("ERROR: Invalid rp-gen-func-min specified");
6591
6592 return (-1);
6593 }
6594
6595 if (kernel_accel_chgd == 1)
6596 {
6597 if (force == 0)
6598 {
6599 log_info ("The manual use of the -n option (or --kernel-accel) is outdated");
6600 log_info ("Please consider using the -w option instead");
6601 log_info ("You can use --force to override this but do not post error reports if you do so");
6602 log_info ("");
6603
6604 return (-1);
6605 }
6606
6607 if (kernel_accel < 1)
6608 {
6609 log_error ("ERROR: Invalid kernel-accel specified");
6610
6611 return (-1);
6612 }
6613
6614 if (kernel_accel > 1024)
6615 {
6616 log_error ("ERROR: Invalid kernel-accel specified");
6617
6618 return (-1);
6619 }
6620 }
6621
6622 if (kernel_loops_chgd == 1)
6623 {
6624 if (force == 0)
6625 {
6626 log_info ("The manual use of the -u option (or --kernel-loops) is outdated");
6627 log_info ("Please consider using the -w option instead");
6628 log_info ("You can use --force to override this but do not post error reports if you do so");
6629 log_info ("");
6630
6631 return (-1);
6632 }
6633
6634 if (kernel_loops < 1)
6635 {
6636 log_error ("ERROR: Invalid kernel-loops specified");
6637
6638 return (-1);
6639 }
6640
6641 if (kernel_loops > 1024)
6642 {
6643 log_error ("ERROR: Invalid kernel-loops specified");
6644
6645 return (-1);
6646 }
6647 }
6648
6649 if ((workload_profile < 1) || (workload_profile > 4))
6650 {
6651 log_error ("ERROR: workload-profile %i not available", workload_profile);
6652
6653 return (-1);
6654 }
6655
6656 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6657 {
6658 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6659
6660 return (-1);
6661 }
6662
6663 if (show == 1 || left == 1)
6664 {
6665 attack_mode = ATTACK_MODE_NONE;
6666
6667 if (remove == 1)
6668 {
6669 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6670
6671 return (-1);
6672 }
6673
6674 if (potfile_disable == 1)
6675 {
6676 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6677
6678 return (-1);
6679 }
6680 }
6681
6682 uint attack_kern = ATTACK_KERN_NONE;
6683
6684 switch (attack_mode)
6685 {
6686 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6687 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6688 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6689 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6690 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6691 }
6692
6693 if (benchmark == 1)
6694 {
6695 if (myargv[optind] != 0)
6696 {
6697 log_error ("ERROR: Invalid argument for benchmark mode specified");
6698
6699 return (-1);
6700 }
6701
6702 if (attack_mode_chgd == 1)
6703 {
6704 if (attack_mode != ATTACK_MODE_BF)
6705 {
6706 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6707
6708 return (-1);
6709 }
6710 }
6711 }
6712 else
6713 {
6714 if (stdout_flag == 1) // no hash here
6715 {
6716 optind--;
6717 }
6718
6719 if (keyspace == 1)
6720 {
6721 int num_additional_params = 1;
6722
6723 if (attack_kern == ATTACK_KERN_COMBI)
6724 {
6725 num_additional_params = 2;
6726 }
6727
6728 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6729
6730 if (keyspace_wordlist_specified == 0) optind--;
6731 }
6732
6733 if (attack_kern == ATTACK_KERN_NONE)
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_STRAIGHT)
6743 {
6744 if ((optind + 1) > myargc)
6745 {
6746 usage_mini_print (myargv[0]);
6747
6748 return (-1);
6749 }
6750 }
6751 else if (attack_kern == ATTACK_KERN_COMBI)
6752 {
6753 if ((optind + 3) != myargc)
6754 {
6755 usage_mini_print (myargv[0]);
6756
6757 return (-1);
6758 }
6759 }
6760 else if (attack_kern == ATTACK_KERN_BF)
6761 {
6762 if ((optind + 1) > myargc)
6763 {
6764 usage_mini_print (myargv[0]);
6765
6766 return (-1);
6767 }
6768 }
6769 else
6770 {
6771 usage_mini_print (myargv[0]);
6772
6773 return (-1);
6774 }
6775 }
6776
6777 if (skip != 0 && limit != 0)
6778 {
6779 limit += skip;
6780 }
6781
6782 if (keyspace == 1)
6783 {
6784 if (show == 1)
6785 {
6786 log_error ("ERROR: Combining show parameter with keyspace parameter is not allowed");
6787
6788 return (-1);
6789 }
6790 else if (left == 1)
6791 {
6792 log_error ("ERROR: Combining left parameter with keyspace parameter is not allowed");
6793
6794 return (-1);
6795 }
6796
6797 potfile_disable = 1;
6798
6799 restore_disable = 1;
6800
6801 restore = 0;
6802
6803 weak_hash_threshold = 0;
6804
6805 quiet = 1;
6806 }
6807
6808 if (stdout_flag == 1)
6809 {
6810 status_timer = 0;
6811 restore_timer = 0;
6812 restore_disable = 1;
6813 restore = 0;
6814 potfile_disable = 1;
6815 weak_hash_threshold = 0;
6816 gpu_temp_disable = 1;
6817 hash_mode = 2000;
6818 quiet = 1;
6819 outfile_format = OUTFILE_FMT_PLAIN;
6820 kernel_accel = 1024;
6821 kernel_loops = 1024;
6822 force = 1;
6823 outfile_check_timer = 0;
6824 session = "stdout";
6825 opencl_vector_width = 1;
6826 }
6827
6828 if (remove_timer_chgd == 1)
6829 {
6830 if (remove == 0)
6831 {
6832 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6833
6834 return (-1);
6835 }
6836
6837 if (remove_timer < 1)
6838 {
6839 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6840
6841 return (-1);
6842 }
6843 }
6844
6845 if (loopback == 1)
6846 {
6847 if (attack_mode == ATTACK_MODE_STRAIGHT)
6848 {
6849 if ((rp_files_cnt == 0) && (rp_gen == 0))
6850 {
6851 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6852
6853 return (-1);
6854 }
6855 }
6856 else
6857 {
6858 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6859
6860 return (-1);
6861 }
6862 }
6863
6864 if (debug_mode > 0)
6865 {
6866 if (attack_mode != ATTACK_MODE_STRAIGHT)
6867 {
6868 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6869
6870 return (-1);
6871 }
6872
6873 if ((rp_files_cnt == 0) && (rp_gen == 0))
6874 {
6875 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6876
6877 return (-1);
6878 }
6879 }
6880
6881 if (debug_mode > 4)
6882 {
6883 log_error ("ERROR: Invalid debug-mode specified");
6884
6885 return (-1);
6886 }
6887
6888 if (debug_file != NULL)
6889 {
6890 if (debug_mode < 1)
6891 {
6892 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6893
6894 return (-1);
6895 }
6896 }
6897
6898 if (induction_dir != NULL)
6899 {
6900 if (attack_mode == ATTACK_MODE_BF)
6901 {
6902 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6903
6904 return (-1);
6905 }
6906 }
6907
6908 if (attack_mode != ATTACK_MODE_STRAIGHT)
6909 {
6910 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6911 {
6912 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6913
6914 return (-1);
6915 }
6916
6917 weak_hash_threshold = 0;
6918 }
6919
6920 if (nvidia_spin_damp > 100)
6921 {
6922 log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)");
6923
6924 return (-1);
6925 }
6926
6927
6928 /**
6929 * induction directory
6930 */
6931
6932 char *induction_directory = NULL;
6933
6934 if (attack_mode != ATTACK_MODE_BF)
6935 {
6936 if (induction_dir == NULL)
6937 {
6938 induction_directory = (char *) mymalloc (session_size);
6939
6940 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6941
6942 // create induction folder if it does not already exist
6943
6944 if (keyspace == 0)
6945 {
6946 if (rmdir (induction_directory) == -1)
6947 {
6948 if (errno == ENOENT)
6949 {
6950 // good, we can ignore
6951 }
6952 else if (errno == ENOTEMPTY)
6953 {
6954 char *induction_directory_mv = (char *) mymalloc (session_size);
6955
6956 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6957
6958 if (rename (induction_directory, induction_directory_mv) != 0)
6959 {
6960 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6961
6962 return (-1);
6963 }
6964 }
6965 else
6966 {
6967 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6968
6969 return (-1);
6970 }
6971 }
6972
6973 if (mkdir (induction_directory, 0700) == -1)
6974 {
6975 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6976
6977 return (-1);
6978 }
6979 }
6980 }
6981 else
6982 {
6983 induction_directory = induction_dir;
6984 }
6985 }
6986
6987 data.induction_directory = induction_directory;
6988
6989 /**
6990 * loopback
6991 */
6992
6993 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6994
6995 char *loopback_file = (char *) mymalloc (loopback_size);
6996
6997 /**
6998 * tuning db
6999 */
7000
7001 char tuning_db_file[256] = { 0 };
7002
7003 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
7004
7005 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
7006
7007 /**
7008 * outfile-check directory
7009 */
7010
7011 char *outfile_check_directory = NULL;
7012
7013 if (outfile_check_dir == NULL)
7014 {
7015 outfile_check_directory = (char *) mymalloc (session_size);
7016
7017 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
7018 }
7019 else
7020 {
7021 outfile_check_directory = outfile_check_dir;
7022 }
7023
7024 data.outfile_check_directory = outfile_check_directory;
7025
7026 if (keyspace == 0)
7027 {
7028 struct stat outfile_check_stat;
7029
7030 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
7031 {
7032 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
7033
7034 if (is_dir == 0)
7035 {
7036 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
7037
7038 return (-1);
7039 }
7040 }
7041 else if (outfile_check_dir == NULL)
7042 {
7043 if (mkdir (outfile_check_directory, 0700) == -1)
7044 {
7045 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
7046
7047 return (-1);
7048 }
7049 }
7050 }
7051
7052 /**
7053 * special other stuff
7054 */
7055
7056 if (hash_mode == 9710)
7057 {
7058 outfile_format = 5;
7059 outfile_format_chgd = 1;
7060 }
7061
7062 if (hash_mode == 9810)
7063 {
7064 outfile_format = 5;
7065 outfile_format_chgd = 1;
7066 }
7067
7068 if (hash_mode == 10410)
7069 {
7070 outfile_format = 5;
7071 outfile_format_chgd = 1;
7072 }
7073
7074 /**
7075 * store stuff
7076 */
7077
7078 data.hash_mode = hash_mode;
7079 data.restore = restore;
7080 data.restore_timer = restore_timer;
7081 data.restore_disable = restore_disable;
7082 data.status = status;
7083 data.status_timer = status_timer;
7084 data.machine_readable = machine_readable;
7085 data.loopback = loopback;
7086 data.runtime = runtime;
7087 data.remove = remove;
7088 data.remove_timer = remove_timer;
7089 data.debug_mode = debug_mode;
7090 data.debug_file = debug_file;
7091 data.username = username;
7092 data.quiet = quiet;
7093 data.outfile = outfile;
7094 data.outfile_format = outfile_format;
7095 data.outfile_autohex = outfile_autohex;
7096 data.hex_charset = hex_charset;
7097 data.hex_salt = hex_salt;
7098 data.hex_wordlist = hex_wordlist;
7099 data.separator = separator;
7100 data.rp_files = rp_files;
7101 data.rp_files_cnt = rp_files_cnt;
7102 data.rp_gen = rp_gen;
7103 data.rp_gen_seed = rp_gen_seed;
7104 data.force = force;
7105 data.benchmark = benchmark;
7106 data.skip = skip;
7107 data.limit = limit;
7108 #ifdef HAVE_HWMON
7109 data.powertune_enable = powertune_enable;
7110 #endif
7111 data.logfile_disable = logfile_disable;
7112 data.truecrypt_keyfiles = truecrypt_keyfiles;
7113 data.veracrypt_keyfiles = veracrypt_keyfiles;
7114 data.veracrypt_pim = veracrypt_pim;
7115 data.scrypt_tmto = scrypt_tmto;
7116 data.workload_profile = workload_profile;
7117
7118 /**
7119 * cpu affinity
7120 */
7121
7122 if (cpu_affinity)
7123 {
7124 set_cpu_affinity (cpu_affinity);
7125 }
7126
7127 if (rp_gen_seed_chgd == 0)
7128 {
7129 srand (proc_start);
7130 }
7131 else
7132 {
7133 srand (rp_gen_seed);
7134 }
7135
7136 /**
7137 * logfile init
7138 */
7139
7140 if (logfile_disable == 0)
7141 {
7142 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7143
7144 char *logfile = (char *) mymalloc (logfile_size);
7145
7146 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7147
7148 data.logfile = logfile;
7149
7150 char *topid = logfile_generate_topid ();
7151
7152 data.topid = topid;
7153 }
7154
7155 // logfile_append() checks for logfile_disable internally to make it easier from here
7156
7157 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7158 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7159 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7160 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7161 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7162 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7163 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7164 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7165 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7166 #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));
7167
7168 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7169 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7170 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7171 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7172 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7173 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7174 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7175 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7176
7177 logfile_top_msg ("START");
7178
7179 logfile_top_uint (attack_mode);
7180 logfile_top_uint (attack_kern);
7181 logfile_top_uint (benchmark);
7182 logfile_top_uint (stdout_flag);
7183 logfile_top_uint (bitmap_min);
7184 logfile_top_uint (bitmap_max);
7185 logfile_top_uint (debug_mode);
7186 logfile_top_uint (force);
7187 logfile_top_uint (kernel_accel);
7188 logfile_top_uint (kernel_loops);
7189 logfile_top_uint (nvidia_spin_damp);
7190 logfile_top_uint (gpu_temp_disable);
7191 #ifdef HAVE_HWMON
7192 logfile_top_uint (gpu_temp_abort);
7193 logfile_top_uint (gpu_temp_retain);
7194 #endif
7195 logfile_top_uint (hash_mode);
7196 logfile_top_uint (hex_charset);
7197 logfile_top_uint (hex_salt);
7198 logfile_top_uint (hex_wordlist);
7199 logfile_top_uint (increment);
7200 logfile_top_uint (increment_max);
7201 logfile_top_uint (increment_min);
7202 logfile_top_uint (keyspace);
7203 logfile_top_uint (left);
7204 logfile_top_uint (logfile_disable);
7205 logfile_top_uint (loopback);
7206 logfile_top_uint (markov_classic);
7207 logfile_top_uint (markov_disable);
7208 logfile_top_uint (markov_threshold);
7209 logfile_top_uint (outfile_autohex);
7210 logfile_top_uint (outfile_check_timer);
7211 logfile_top_uint (outfile_format);
7212 logfile_top_uint (potfile_disable);
7213 logfile_top_string (potfile_path);
7214 #if defined(HAVE_HWMON)
7215 logfile_top_uint (powertune_enable);
7216 #endif
7217 logfile_top_uint (scrypt_tmto);
7218 logfile_top_uint (quiet);
7219 logfile_top_uint (remove);
7220 logfile_top_uint (remove_timer);
7221 logfile_top_uint (restore);
7222 logfile_top_uint (restore_disable);
7223 logfile_top_uint (restore_timer);
7224 logfile_top_uint (rp_gen);
7225 logfile_top_uint (rp_gen_func_max);
7226 logfile_top_uint (rp_gen_func_min);
7227 logfile_top_uint (rp_gen_seed);
7228 logfile_top_uint (runtime);
7229 logfile_top_uint (segment_size);
7230 logfile_top_uint (show);
7231 logfile_top_uint (status);
7232 logfile_top_uint (machine_readable);
7233 logfile_top_uint (status_timer);
7234 logfile_top_uint (usage);
7235 logfile_top_uint (username);
7236 logfile_top_uint (version);
7237 logfile_top_uint (weak_hash_threshold);
7238 logfile_top_uint (workload_profile);
7239 logfile_top_uint64 (limit);
7240 logfile_top_uint64 (skip);
7241 logfile_top_char (separator);
7242 logfile_top_string (cpu_affinity);
7243 logfile_top_string (custom_charset_1);
7244 logfile_top_string (custom_charset_2);
7245 logfile_top_string (custom_charset_3);
7246 logfile_top_string (custom_charset_4);
7247 logfile_top_string (debug_file);
7248 logfile_top_string (opencl_devices);
7249 logfile_top_string (opencl_platforms);
7250 logfile_top_string (opencl_device_types);
7251 logfile_top_uint (opencl_vector_width);
7252 logfile_top_string (induction_dir);
7253 logfile_top_string (markov_hcstat);
7254 logfile_top_string (outfile);
7255 logfile_top_string (outfile_check_dir);
7256 logfile_top_string (rule_buf_l);
7257 logfile_top_string (rule_buf_r);
7258 logfile_top_string (session);
7259 logfile_top_string (truecrypt_keyfiles);
7260 logfile_top_string (veracrypt_keyfiles);
7261 logfile_top_uint (veracrypt_pim);
7262
7263 /**
7264 * Init OpenCL library loader
7265 */
7266
7267 if (keyspace == 0)
7268 {
7269 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7270
7271 ocl_init (ocl);
7272
7273 data.ocl = ocl;
7274 }
7275
7276 /**
7277 * OpenCL platform selection
7278 */
7279
7280 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7281
7282 /**
7283 * OpenCL device selection
7284 */
7285
7286 u32 devices_filter = setup_devices_filter (opencl_devices);
7287
7288 /**
7289 * OpenCL device type selection
7290 */
7291
7292 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7293
7294 /**
7295 * benchmark
7296 */
7297
7298 if (benchmark == 1)
7299 {
7300 /**
7301 * disable useless stuff for benchmark
7302 */
7303
7304 status_timer = 0;
7305 restore_timer = 0;
7306 restore_disable = 1;
7307 potfile_disable = 1;
7308 weak_hash_threshold = 0;
7309 nvidia_spin_damp = 0;
7310 gpu_temp_disable = 1;
7311 outfile_check_timer = 0;
7312
7313 #ifdef HAVE_HWMON
7314 if (powertune_enable == 1)
7315 {
7316 gpu_temp_disable = 0;
7317 }
7318 #endif
7319
7320 data.status_timer = status_timer;
7321 data.restore_timer = restore_timer;
7322 data.restore_disable = restore_disable;
7323 data.outfile_check_timer = outfile_check_timer;
7324
7325 /**
7326 * force attack mode to be bruteforce
7327 */
7328
7329 attack_mode = ATTACK_MODE_BF;
7330 attack_kern = ATTACK_KERN_BF;
7331
7332 if (workload_profile_chgd == 0)
7333 {
7334 workload_profile = 3;
7335
7336 data.workload_profile = workload_profile;
7337 }
7338 }
7339
7340 /**
7341 * status, monitor and outfile remove threads
7342 */
7343
7344 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
7345
7346 data.wordlist_mode = wordlist_mode;
7347
7348 if (wordlist_mode == WL_MODE_STDIN)
7349 {
7350 status = 1;
7351
7352 data.status = status;
7353 }
7354
7355 uint outer_threads_cnt = 0;
7356
7357 hc_thread_t *outer_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
7358
7359 data.shutdown_outer = 0;
7360
7361 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
7362 {
7363 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
7364 {
7365 hc_thread_create (outer_threads[outer_threads_cnt], thread_keypress, NULL);
7366
7367 outer_threads_cnt++;
7368 }
7369 }
7370
7371 /**
7372 * config
7373 */
7374
7375 uint hash_type = 0;
7376 uint salt_type = 0;
7377 uint attack_exec = 0;
7378 uint opts_type = 0;
7379 uint kern_type = 0;
7380 uint dgst_size = 0;
7381 uint esalt_size = 0;
7382 uint opti_type = 0;
7383 uint dgst_pos0 = -1;
7384 uint dgst_pos1 = -1;
7385 uint dgst_pos2 = -1;
7386 uint dgst_pos3 = -1;
7387
7388 int (*parse_func) (char *, uint, hash_t *);
7389 int (*sort_by_digest) (const void *, const void *);
7390
7391 uint algorithm_pos = 0;
7392 uint algorithm_max = 1;
7393
7394 uint *algorithms = default_benchmark_algorithms;
7395
7396 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7397
7398 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7399 {
7400 /*
7401 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7402 * the following algos are skipped entirely
7403 */
7404
7405 if (algorithm_pos > 0)
7406 {
7407 local_free (rd);
7408
7409 rd = init_restore (argc, argv);
7410
7411 data.rd = rd;
7412 }
7413
7414 /**
7415 * update hash_mode in case of multihash benchmark
7416 */
7417
7418 if (benchmark == 1)
7419 {
7420 if (hash_mode_chgd == 0)
7421 {
7422 hash_mode = algorithms[algorithm_pos];
7423
7424 data.hash_mode = hash_mode;
7425 }
7426
7427 quiet = 1;
7428
7429 data.quiet = quiet;
7430 }
7431
7432 switch (hash_mode)
7433 {
7434 case 0: hash_type = HASH_TYPE_MD5;
7435 salt_type = SALT_TYPE_NONE;
7436 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7437 opts_type = OPTS_TYPE_PT_GENERATE_LE
7438 | OPTS_TYPE_PT_ADD80
7439 | OPTS_TYPE_PT_ADDBITS14;
7440 kern_type = KERN_TYPE_MD5;
7441 dgst_size = DGST_SIZE_4_4;
7442 parse_func = md5_parse_hash;
7443 sort_by_digest = sort_by_digest_4_4;
7444 opti_type = OPTI_TYPE_ZERO_BYTE
7445 | OPTI_TYPE_PRECOMPUTE_INIT
7446 | OPTI_TYPE_PRECOMPUTE_MERKLE
7447 | OPTI_TYPE_MEET_IN_MIDDLE
7448 | OPTI_TYPE_EARLY_SKIP
7449 | OPTI_TYPE_NOT_ITERATED
7450 | OPTI_TYPE_NOT_SALTED
7451 | OPTI_TYPE_RAW_HASH;
7452 dgst_pos0 = 0;
7453 dgst_pos1 = 3;
7454 dgst_pos2 = 2;
7455 dgst_pos3 = 1;
7456 break;
7457
7458 case 10: hash_type = HASH_TYPE_MD5;
7459 salt_type = SALT_TYPE_INTERN;
7460 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7461 opts_type = OPTS_TYPE_PT_GENERATE_LE
7462 | OPTS_TYPE_ST_ADD80
7463 | OPTS_TYPE_ST_ADDBITS14;
7464 kern_type = KERN_TYPE_MD5_PWSLT;
7465 dgst_size = DGST_SIZE_4_4;
7466 parse_func = md5s_parse_hash;
7467 sort_by_digest = sort_by_digest_4_4;
7468 opti_type = OPTI_TYPE_ZERO_BYTE
7469 | OPTI_TYPE_PRECOMPUTE_INIT
7470 | OPTI_TYPE_PRECOMPUTE_MERKLE
7471 | OPTI_TYPE_MEET_IN_MIDDLE
7472 | OPTI_TYPE_EARLY_SKIP
7473 | OPTI_TYPE_NOT_ITERATED
7474 | OPTI_TYPE_APPENDED_SALT
7475 | OPTI_TYPE_RAW_HASH;
7476 dgst_pos0 = 0;
7477 dgst_pos1 = 3;
7478 dgst_pos2 = 2;
7479 dgst_pos3 = 1;
7480 break;
7481
7482 case 11: hash_type = HASH_TYPE_MD5;
7483 salt_type = SALT_TYPE_INTERN;
7484 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7485 opts_type = OPTS_TYPE_PT_GENERATE_LE
7486 | OPTS_TYPE_ST_ADD80
7487 | OPTS_TYPE_ST_ADDBITS14;
7488 kern_type = KERN_TYPE_MD5_PWSLT;
7489 dgst_size = DGST_SIZE_4_4;
7490 parse_func = joomla_parse_hash;
7491 sort_by_digest = sort_by_digest_4_4;
7492 opti_type = OPTI_TYPE_ZERO_BYTE
7493 | OPTI_TYPE_PRECOMPUTE_INIT
7494 | OPTI_TYPE_PRECOMPUTE_MERKLE
7495 | OPTI_TYPE_MEET_IN_MIDDLE
7496 | OPTI_TYPE_EARLY_SKIP
7497 | OPTI_TYPE_NOT_ITERATED
7498 | OPTI_TYPE_APPENDED_SALT
7499 | OPTI_TYPE_RAW_HASH;
7500 dgst_pos0 = 0;
7501 dgst_pos1 = 3;
7502 dgst_pos2 = 2;
7503 dgst_pos3 = 1;
7504 break;
7505
7506 case 12: hash_type = HASH_TYPE_MD5;
7507 salt_type = SALT_TYPE_INTERN;
7508 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7509 opts_type = OPTS_TYPE_PT_GENERATE_LE
7510 | OPTS_TYPE_ST_ADD80
7511 | OPTS_TYPE_ST_ADDBITS14;
7512 kern_type = KERN_TYPE_MD5_PWSLT;
7513 dgst_size = DGST_SIZE_4_4;
7514 parse_func = postgresql_parse_hash;
7515 sort_by_digest = sort_by_digest_4_4;
7516 opti_type = OPTI_TYPE_ZERO_BYTE
7517 | OPTI_TYPE_PRECOMPUTE_INIT
7518 | OPTI_TYPE_PRECOMPUTE_MERKLE
7519 | OPTI_TYPE_MEET_IN_MIDDLE
7520 | OPTI_TYPE_EARLY_SKIP
7521 | OPTI_TYPE_NOT_ITERATED
7522 | OPTI_TYPE_APPENDED_SALT
7523 | OPTI_TYPE_RAW_HASH;
7524 dgst_pos0 = 0;
7525 dgst_pos1 = 3;
7526 dgst_pos2 = 2;
7527 dgst_pos3 = 1;
7528 break;
7529
7530 case 20: hash_type = HASH_TYPE_MD5;
7531 salt_type = SALT_TYPE_INTERN;
7532 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7533 opts_type = OPTS_TYPE_PT_GENERATE_LE
7534 | OPTS_TYPE_PT_ADD80
7535 | OPTS_TYPE_PT_ADDBITS14;
7536 kern_type = KERN_TYPE_MD5_SLTPW;
7537 dgst_size = DGST_SIZE_4_4;
7538 parse_func = md5s_parse_hash;
7539 sort_by_digest = sort_by_digest_4_4;
7540 opti_type = OPTI_TYPE_ZERO_BYTE
7541 | OPTI_TYPE_PRECOMPUTE_INIT
7542 | OPTI_TYPE_PRECOMPUTE_MERKLE
7543 | OPTI_TYPE_EARLY_SKIP
7544 | OPTI_TYPE_NOT_ITERATED
7545 | OPTI_TYPE_PREPENDED_SALT
7546 | OPTI_TYPE_RAW_HASH;
7547 dgst_pos0 = 0;
7548 dgst_pos1 = 3;
7549 dgst_pos2 = 2;
7550 dgst_pos3 = 1;
7551 break;
7552
7553 case 21: hash_type = HASH_TYPE_MD5;
7554 salt_type = SALT_TYPE_INTERN;
7555 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7556 opts_type = OPTS_TYPE_PT_GENERATE_LE
7557 | OPTS_TYPE_PT_ADD80
7558 | OPTS_TYPE_PT_ADDBITS14;
7559 kern_type = KERN_TYPE_MD5_SLTPW;
7560 dgst_size = DGST_SIZE_4_4;
7561 parse_func = osc_parse_hash;
7562 sort_by_digest = sort_by_digest_4_4;
7563 opti_type = OPTI_TYPE_ZERO_BYTE
7564 | OPTI_TYPE_PRECOMPUTE_INIT
7565 | OPTI_TYPE_PRECOMPUTE_MERKLE
7566 | OPTI_TYPE_EARLY_SKIP
7567 | OPTI_TYPE_NOT_ITERATED
7568 | OPTI_TYPE_PREPENDED_SALT
7569 | OPTI_TYPE_RAW_HASH;
7570 dgst_pos0 = 0;
7571 dgst_pos1 = 3;
7572 dgst_pos2 = 2;
7573 dgst_pos3 = 1;
7574 break;
7575
7576 case 22: hash_type = HASH_TYPE_MD5;
7577 salt_type = SALT_TYPE_EMBEDDED;
7578 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7579 opts_type = OPTS_TYPE_PT_GENERATE_LE
7580 | OPTS_TYPE_PT_ADD80
7581 | OPTS_TYPE_PT_ADDBITS14;
7582 kern_type = KERN_TYPE_MD5_SLTPW;
7583 dgst_size = DGST_SIZE_4_4;
7584 parse_func = netscreen_parse_hash;
7585 sort_by_digest = sort_by_digest_4_4;
7586 opti_type = OPTI_TYPE_ZERO_BYTE
7587 | OPTI_TYPE_PRECOMPUTE_INIT
7588 | OPTI_TYPE_PRECOMPUTE_MERKLE
7589 | OPTI_TYPE_EARLY_SKIP
7590 | OPTI_TYPE_NOT_ITERATED
7591 | OPTI_TYPE_PREPENDED_SALT
7592 | OPTI_TYPE_RAW_HASH;
7593 dgst_pos0 = 0;
7594 dgst_pos1 = 3;
7595 dgst_pos2 = 2;
7596 dgst_pos3 = 1;
7597 break;
7598
7599 case 23: hash_type = HASH_TYPE_MD5;
7600 salt_type = SALT_TYPE_EMBEDDED;
7601 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7602 opts_type = OPTS_TYPE_PT_GENERATE_LE
7603 | OPTS_TYPE_PT_ADD80
7604 | OPTS_TYPE_PT_ADDBITS14;
7605 kern_type = KERN_TYPE_MD5_SLTPW;
7606 dgst_size = DGST_SIZE_4_4;
7607 parse_func = skype_parse_hash;
7608 sort_by_digest = sort_by_digest_4_4;
7609 opti_type = OPTI_TYPE_ZERO_BYTE
7610 | OPTI_TYPE_PRECOMPUTE_INIT
7611 | OPTI_TYPE_PRECOMPUTE_MERKLE
7612 | OPTI_TYPE_EARLY_SKIP
7613 | OPTI_TYPE_NOT_ITERATED
7614 | OPTI_TYPE_PREPENDED_SALT
7615 | OPTI_TYPE_RAW_HASH;
7616 dgst_pos0 = 0;
7617 dgst_pos1 = 3;
7618 dgst_pos2 = 2;
7619 dgst_pos3 = 1;
7620 break;
7621
7622 case 30: hash_type = HASH_TYPE_MD5;
7623 salt_type = SALT_TYPE_INTERN;
7624 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7625 opts_type = OPTS_TYPE_PT_GENERATE_LE
7626 | OPTS_TYPE_PT_UNICODE
7627 | OPTS_TYPE_ST_ADD80
7628 | OPTS_TYPE_ST_ADDBITS14;
7629 kern_type = KERN_TYPE_MD5_PWUSLT;
7630 dgst_size = DGST_SIZE_4_4;
7631 parse_func = md5s_parse_hash;
7632 sort_by_digest = sort_by_digest_4_4;
7633 opti_type = OPTI_TYPE_ZERO_BYTE
7634 | OPTI_TYPE_PRECOMPUTE_INIT
7635 | OPTI_TYPE_PRECOMPUTE_MERKLE
7636 | OPTI_TYPE_MEET_IN_MIDDLE
7637 | OPTI_TYPE_EARLY_SKIP
7638 | OPTI_TYPE_NOT_ITERATED
7639 | OPTI_TYPE_APPENDED_SALT
7640 | OPTI_TYPE_RAW_HASH;
7641 dgst_pos0 = 0;
7642 dgst_pos1 = 3;
7643 dgst_pos2 = 2;
7644 dgst_pos3 = 1;
7645 break;
7646
7647 case 40: hash_type = HASH_TYPE_MD5;
7648 salt_type = SALT_TYPE_INTERN;
7649 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7650 opts_type = OPTS_TYPE_PT_GENERATE_LE
7651 | OPTS_TYPE_PT_ADD80
7652 | OPTS_TYPE_PT_ADDBITS14
7653 | OPTS_TYPE_PT_UNICODE;
7654 kern_type = KERN_TYPE_MD5_SLTPWU;
7655 dgst_size = DGST_SIZE_4_4;
7656 parse_func = md5s_parse_hash;
7657 sort_by_digest = sort_by_digest_4_4;
7658 opti_type = OPTI_TYPE_ZERO_BYTE
7659 | OPTI_TYPE_PRECOMPUTE_INIT
7660 | OPTI_TYPE_PRECOMPUTE_MERKLE
7661 | OPTI_TYPE_EARLY_SKIP
7662 | OPTI_TYPE_NOT_ITERATED
7663 | OPTI_TYPE_PREPENDED_SALT
7664 | OPTI_TYPE_RAW_HASH;
7665 dgst_pos0 = 0;
7666 dgst_pos1 = 3;
7667 dgst_pos2 = 2;
7668 dgst_pos3 = 1;
7669 break;
7670
7671 case 50: hash_type = HASH_TYPE_MD5;
7672 salt_type = SALT_TYPE_INTERN;
7673 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7674 opts_type = OPTS_TYPE_PT_GENERATE_LE
7675 | OPTS_TYPE_ST_ADD80
7676 | OPTS_TYPE_ST_ADDBITS14;
7677 kern_type = KERN_TYPE_HMACMD5_PW;
7678 dgst_size = DGST_SIZE_4_4;
7679 parse_func = hmacmd5_parse_hash;
7680 sort_by_digest = sort_by_digest_4_4;
7681 opti_type = OPTI_TYPE_ZERO_BYTE
7682 | OPTI_TYPE_NOT_ITERATED;
7683 dgst_pos0 = 0;
7684 dgst_pos1 = 3;
7685 dgst_pos2 = 2;
7686 dgst_pos3 = 1;
7687 break;
7688
7689 case 60: hash_type = HASH_TYPE_MD5;
7690 salt_type = SALT_TYPE_INTERN;
7691 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7692 opts_type = OPTS_TYPE_PT_GENERATE_LE
7693 | OPTS_TYPE_PT_ADD80
7694 | OPTS_TYPE_PT_ADDBITS14;
7695 kern_type = KERN_TYPE_HMACMD5_SLT;
7696 dgst_size = DGST_SIZE_4_4;
7697 parse_func = hmacmd5_parse_hash;
7698 sort_by_digest = sort_by_digest_4_4;
7699 opti_type = OPTI_TYPE_ZERO_BYTE
7700 | OPTI_TYPE_NOT_ITERATED;
7701 dgst_pos0 = 0;
7702 dgst_pos1 = 3;
7703 dgst_pos2 = 2;
7704 dgst_pos3 = 1;
7705 break;
7706
7707 case 100: hash_type = HASH_TYPE_SHA1;
7708 salt_type = SALT_TYPE_NONE;
7709 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7710 opts_type = OPTS_TYPE_PT_GENERATE_BE
7711 | OPTS_TYPE_PT_ADD80
7712 | OPTS_TYPE_PT_ADDBITS15;
7713 kern_type = KERN_TYPE_SHA1;
7714 dgst_size = DGST_SIZE_4_5;
7715 parse_func = sha1_parse_hash;
7716 sort_by_digest = sort_by_digest_4_5;
7717 opti_type = OPTI_TYPE_ZERO_BYTE
7718 | OPTI_TYPE_PRECOMPUTE_INIT
7719 | OPTI_TYPE_PRECOMPUTE_MERKLE
7720 | OPTI_TYPE_EARLY_SKIP
7721 | OPTI_TYPE_NOT_ITERATED
7722 | OPTI_TYPE_NOT_SALTED
7723 | OPTI_TYPE_RAW_HASH;
7724 dgst_pos0 = 3;
7725 dgst_pos1 = 4;
7726 dgst_pos2 = 2;
7727 dgst_pos3 = 1;
7728 break;
7729
7730 case 101: hash_type = HASH_TYPE_SHA1;
7731 salt_type = SALT_TYPE_NONE;
7732 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7733 opts_type = OPTS_TYPE_PT_GENERATE_BE
7734 | OPTS_TYPE_PT_ADD80
7735 | OPTS_TYPE_PT_ADDBITS15;
7736 kern_type = KERN_TYPE_SHA1;
7737 dgst_size = DGST_SIZE_4_5;
7738 parse_func = sha1b64_parse_hash;
7739 sort_by_digest = sort_by_digest_4_5;
7740 opti_type = OPTI_TYPE_ZERO_BYTE
7741 | OPTI_TYPE_PRECOMPUTE_INIT
7742 | OPTI_TYPE_PRECOMPUTE_MERKLE
7743 | OPTI_TYPE_EARLY_SKIP
7744 | OPTI_TYPE_NOT_ITERATED
7745 | OPTI_TYPE_NOT_SALTED
7746 | OPTI_TYPE_RAW_HASH;
7747 dgst_pos0 = 3;
7748 dgst_pos1 = 4;
7749 dgst_pos2 = 2;
7750 dgst_pos3 = 1;
7751 break;
7752
7753 case 110: hash_type = HASH_TYPE_SHA1;
7754 salt_type = SALT_TYPE_INTERN;
7755 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7756 opts_type = OPTS_TYPE_PT_GENERATE_BE
7757 | OPTS_TYPE_ST_ADD80
7758 | OPTS_TYPE_ST_ADDBITS15;
7759 kern_type = KERN_TYPE_SHA1_PWSLT;
7760 dgst_size = DGST_SIZE_4_5;
7761 parse_func = sha1s_parse_hash;
7762 sort_by_digest = sort_by_digest_4_5;
7763 opti_type = OPTI_TYPE_ZERO_BYTE
7764 | OPTI_TYPE_PRECOMPUTE_INIT
7765 | OPTI_TYPE_PRECOMPUTE_MERKLE
7766 | OPTI_TYPE_EARLY_SKIP
7767 | OPTI_TYPE_NOT_ITERATED
7768 | OPTI_TYPE_APPENDED_SALT
7769 | OPTI_TYPE_RAW_HASH;
7770 dgst_pos0 = 3;
7771 dgst_pos1 = 4;
7772 dgst_pos2 = 2;
7773 dgst_pos3 = 1;
7774 break;
7775
7776 case 111: hash_type = HASH_TYPE_SHA1;
7777 salt_type = SALT_TYPE_EMBEDDED;
7778 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7779 opts_type = OPTS_TYPE_PT_GENERATE_BE
7780 | OPTS_TYPE_ST_ADD80
7781 | OPTS_TYPE_ST_ADDBITS15;
7782 kern_type = KERN_TYPE_SHA1_PWSLT;
7783 dgst_size = DGST_SIZE_4_5;
7784 parse_func = sha1b64s_parse_hash;
7785 sort_by_digest = sort_by_digest_4_5;
7786 opti_type = OPTI_TYPE_ZERO_BYTE
7787 | OPTI_TYPE_PRECOMPUTE_INIT
7788 | OPTI_TYPE_PRECOMPUTE_MERKLE
7789 | OPTI_TYPE_EARLY_SKIP
7790 | OPTI_TYPE_NOT_ITERATED
7791 | OPTI_TYPE_APPENDED_SALT
7792 | OPTI_TYPE_RAW_HASH;
7793 dgst_pos0 = 3;
7794 dgst_pos1 = 4;
7795 dgst_pos2 = 2;
7796 dgst_pos3 = 1;
7797 break;
7798
7799 case 112: hash_type = HASH_TYPE_SHA1;
7800 salt_type = SALT_TYPE_INTERN;
7801 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7802 opts_type = OPTS_TYPE_PT_GENERATE_BE
7803 | OPTS_TYPE_ST_ADD80
7804 | OPTS_TYPE_ST_ADDBITS15
7805 | OPTS_TYPE_ST_HEX;
7806 kern_type = KERN_TYPE_SHA1_PWSLT;
7807 dgst_size = DGST_SIZE_4_5;
7808 parse_func = oracles_parse_hash;
7809 sort_by_digest = sort_by_digest_4_5;
7810 opti_type = OPTI_TYPE_ZERO_BYTE
7811 | OPTI_TYPE_PRECOMPUTE_INIT
7812 | OPTI_TYPE_PRECOMPUTE_MERKLE
7813 | OPTI_TYPE_EARLY_SKIP
7814 | OPTI_TYPE_NOT_ITERATED
7815 | OPTI_TYPE_APPENDED_SALT
7816 | OPTI_TYPE_RAW_HASH;
7817 dgst_pos0 = 3;
7818 dgst_pos1 = 4;
7819 dgst_pos2 = 2;
7820 dgst_pos3 = 1;
7821 break;
7822
7823 case 120: hash_type = HASH_TYPE_SHA1;
7824 salt_type = SALT_TYPE_INTERN;
7825 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7826 opts_type = OPTS_TYPE_PT_GENERATE_BE
7827 | OPTS_TYPE_PT_ADD80
7828 | OPTS_TYPE_PT_ADDBITS15;
7829 kern_type = KERN_TYPE_SHA1_SLTPW;
7830 dgst_size = DGST_SIZE_4_5;
7831 parse_func = sha1s_parse_hash;
7832 sort_by_digest = sort_by_digest_4_5;
7833 opti_type = OPTI_TYPE_ZERO_BYTE
7834 | OPTI_TYPE_PRECOMPUTE_INIT
7835 | OPTI_TYPE_PRECOMPUTE_MERKLE
7836 | OPTI_TYPE_EARLY_SKIP
7837 | OPTI_TYPE_NOT_ITERATED
7838 | OPTI_TYPE_PREPENDED_SALT
7839 | OPTI_TYPE_RAW_HASH;
7840 dgst_pos0 = 3;
7841 dgst_pos1 = 4;
7842 dgst_pos2 = 2;
7843 dgst_pos3 = 1;
7844 break;
7845
7846 case 121: hash_type = HASH_TYPE_SHA1;
7847 salt_type = SALT_TYPE_INTERN;
7848 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7849 opts_type = OPTS_TYPE_PT_GENERATE_BE
7850 | OPTS_TYPE_PT_ADD80
7851 | OPTS_TYPE_PT_ADDBITS15
7852 | OPTS_TYPE_ST_LOWER;
7853 kern_type = KERN_TYPE_SHA1_SLTPW;
7854 dgst_size = DGST_SIZE_4_5;
7855 parse_func = smf_parse_hash;
7856 sort_by_digest = sort_by_digest_4_5;
7857 opti_type = OPTI_TYPE_ZERO_BYTE
7858 | OPTI_TYPE_PRECOMPUTE_INIT
7859 | OPTI_TYPE_PRECOMPUTE_MERKLE
7860 | OPTI_TYPE_EARLY_SKIP
7861 | OPTI_TYPE_NOT_ITERATED
7862 | OPTI_TYPE_PREPENDED_SALT
7863 | OPTI_TYPE_RAW_HASH;
7864 dgst_pos0 = 3;
7865 dgst_pos1 = 4;
7866 dgst_pos2 = 2;
7867 dgst_pos3 = 1;
7868 break;
7869
7870 case 122: hash_type = HASH_TYPE_SHA1;
7871 salt_type = SALT_TYPE_EMBEDDED;
7872 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7873 opts_type = OPTS_TYPE_PT_GENERATE_BE
7874 | OPTS_TYPE_PT_ADD80
7875 | OPTS_TYPE_PT_ADDBITS15
7876 | OPTS_TYPE_ST_HEX;
7877 kern_type = KERN_TYPE_SHA1_SLTPW;
7878 dgst_size = DGST_SIZE_4_5;
7879 parse_func = osx1_parse_hash;
7880 sort_by_digest = sort_by_digest_4_5;
7881 opti_type = OPTI_TYPE_ZERO_BYTE
7882 | OPTI_TYPE_PRECOMPUTE_INIT
7883 | OPTI_TYPE_PRECOMPUTE_MERKLE
7884 | OPTI_TYPE_EARLY_SKIP
7885 | OPTI_TYPE_NOT_ITERATED
7886 | OPTI_TYPE_PREPENDED_SALT
7887 | OPTI_TYPE_RAW_HASH;
7888 dgst_pos0 = 3;
7889 dgst_pos1 = 4;
7890 dgst_pos2 = 2;
7891 dgst_pos3 = 1;
7892 break;
7893
7894 case 124: hash_type = HASH_TYPE_SHA1;
7895 salt_type = SALT_TYPE_EMBEDDED;
7896 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7897 opts_type = OPTS_TYPE_PT_GENERATE_BE
7898 | OPTS_TYPE_PT_ADD80
7899 | OPTS_TYPE_PT_ADDBITS15;
7900 kern_type = KERN_TYPE_SHA1_SLTPW;
7901 dgst_size = DGST_SIZE_4_5;
7902 parse_func = djangosha1_parse_hash;
7903 sort_by_digest = sort_by_digest_4_5;
7904 opti_type = OPTI_TYPE_ZERO_BYTE
7905 | OPTI_TYPE_PRECOMPUTE_INIT
7906 | OPTI_TYPE_PRECOMPUTE_MERKLE
7907 | OPTI_TYPE_EARLY_SKIP
7908 | OPTI_TYPE_NOT_ITERATED
7909 | OPTI_TYPE_PREPENDED_SALT
7910 | OPTI_TYPE_RAW_HASH;
7911 dgst_pos0 = 3;
7912 dgst_pos1 = 4;
7913 dgst_pos2 = 2;
7914 dgst_pos3 = 1;
7915 break;
7916
7917 case 125: hash_type = HASH_TYPE_SHA1;
7918 salt_type = SALT_TYPE_EMBEDDED;
7919 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7920 opts_type = OPTS_TYPE_PT_GENERATE_BE
7921 | OPTS_TYPE_PT_ADD80
7922 | OPTS_TYPE_PT_ADDBITS15
7923 | OPTS_TYPE_ST_HEX;
7924 kern_type = KERN_TYPE_SHA1_SLTPW;
7925 dgst_size = DGST_SIZE_4_5;
7926 parse_func = arubaos_parse_hash;
7927 sort_by_digest = sort_by_digest_4_5;
7928 opti_type = OPTI_TYPE_ZERO_BYTE
7929 | OPTI_TYPE_PRECOMPUTE_INIT
7930 | OPTI_TYPE_PRECOMPUTE_MERKLE
7931 | OPTI_TYPE_EARLY_SKIP
7932 | OPTI_TYPE_NOT_ITERATED
7933 | OPTI_TYPE_PREPENDED_SALT
7934 | OPTI_TYPE_RAW_HASH;
7935 dgst_pos0 = 3;
7936 dgst_pos1 = 4;
7937 dgst_pos2 = 2;
7938 dgst_pos3 = 1;
7939 break;
7940
7941 case 130: hash_type = HASH_TYPE_SHA1;
7942 salt_type = SALT_TYPE_INTERN;
7943 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7944 opts_type = OPTS_TYPE_PT_GENERATE_BE
7945 | OPTS_TYPE_PT_UNICODE
7946 | OPTS_TYPE_ST_ADD80
7947 | OPTS_TYPE_ST_ADDBITS15;
7948 kern_type = KERN_TYPE_SHA1_PWUSLT;
7949 dgst_size = DGST_SIZE_4_5;
7950 parse_func = sha1s_parse_hash;
7951 sort_by_digest = sort_by_digest_4_5;
7952 opti_type = OPTI_TYPE_ZERO_BYTE
7953 | OPTI_TYPE_PRECOMPUTE_INIT
7954 | OPTI_TYPE_PRECOMPUTE_MERKLE
7955 | OPTI_TYPE_EARLY_SKIP
7956 | OPTI_TYPE_NOT_ITERATED
7957 | OPTI_TYPE_APPENDED_SALT
7958 | OPTI_TYPE_RAW_HASH;
7959 dgst_pos0 = 3;
7960 dgst_pos1 = 4;
7961 dgst_pos2 = 2;
7962 dgst_pos3 = 1;
7963 break;
7964
7965 case 131: hash_type = HASH_TYPE_SHA1;
7966 salt_type = SALT_TYPE_EMBEDDED;
7967 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7968 opts_type = OPTS_TYPE_PT_GENERATE_BE
7969 | OPTS_TYPE_PT_UNICODE
7970 | OPTS_TYPE_PT_UPPER
7971 | OPTS_TYPE_ST_ADD80
7972 | OPTS_TYPE_ST_ADDBITS15
7973 | OPTS_TYPE_ST_HEX;
7974 kern_type = KERN_TYPE_SHA1_PWUSLT;
7975 dgst_size = DGST_SIZE_4_5;
7976 parse_func = mssql2000_parse_hash;
7977 sort_by_digest = sort_by_digest_4_5;
7978 opti_type = OPTI_TYPE_ZERO_BYTE
7979 | OPTI_TYPE_PRECOMPUTE_INIT
7980 | OPTI_TYPE_PRECOMPUTE_MERKLE
7981 | OPTI_TYPE_EARLY_SKIP
7982 | OPTI_TYPE_NOT_ITERATED
7983 | OPTI_TYPE_APPENDED_SALT
7984 | OPTI_TYPE_RAW_HASH;
7985 dgst_pos0 = 3;
7986 dgst_pos1 = 4;
7987 dgst_pos2 = 2;
7988 dgst_pos3 = 1;
7989 break;
7990
7991 case 132: hash_type = HASH_TYPE_SHA1;
7992 salt_type = SALT_TYPE_EMBEDDED;
7993 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7994 opts_type = OPTS_TYPE_PT_GENERATE_BE
7995 | OPTS_TYPE_PT_UNICODE
7996 | OPTS_TYPE_ST_ADD80
7997 | OPTS_TYPE_ST_ADDBITS15
7998 | OPTS_TYPE_ST_HEX;
7999 kern_type = KERN_TYPE_SHA1_PWUSLT;
8000 dgst_size = DGST_SIZE_4_5;
8001 parse_func = mssql2005_parse_hash;
8002 sort_by_digest = sort_by_digest_4_5;
8003 opti_type = OPTI_TYPE_ZERO_BYTE
8004 | OPTI_TYPE_PRECOMPUTE_INIT
8005 | OPTI_TYPE_PRECOMPUTE_MERKLE
8006 | OPTI_TYPE_EARLY_SKIP
8007 | OPTI_TYPE_NOT_ITERATED
8008 | OPTI_TYPE_APPENDED_SALT
8009 | OPTI_TYPE_RAW_HASH;
8010 dgst_pos0 = 3;
8011 dgst_pos1 = 4;
8012 dgst_pos2 = 2;
8013 dgst_pos3 = 1;
8014 break;
8015
8016 case 133: hash_type = HASH_TYPE_SHA1;
8017 salt_type = SALT_TYPE_EMBEDDED;
8018 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8019 opts_type = OPTS_TYPE_PT_GENERATE_BE
8020 | OPTS_TYPE_PT_UNICODE
8021 | OPTS_TYPE_ST_ADD80
8022 | OPTS_TYPE_ST_ADDBITS15;
8023 kern_type = KERN_TYPE_SHA1_PWUSLT;
8024 dgst_size = DGST_SIZE_4_5;
8025 parse_func = peoplesoft_parse_hash;
8026 sort_by_digest = sort_by_digest_4_5;
8027 opti_type = OPTI_TYPE_ZERO_BYTE
8028 | OPTI_TYPE_PRECOMPUTE_INIT
8029 | OPTI_TYPE_PRECOMPUTE_MERKLE
8030 | OPTI_TYPE_EARLY_SKIP
8031 | OPTI_TYPE_NOT_ITERATED
8032 | OPTI_TYPE_APPENDED_SALT
8033 | OPTI_TYPE_RAW_HASH;
8034 dgst_pos0 = 3;
8035 dgst_pos1 = 4;
8036 dgst_pos2 = 2;
8037 dgst_pos3 = 1;
8038 break;
8039
8040 case 140: hash_type = HASH_TYPE_SHA1;
8041 salt_type = SALT_TYPE_INTERN;
8042 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8043 opts_type = OPTS_TYPE_PT_GENERATE_BE
8044 | OPTS_TYPE_PT_ADD80
8045 | OPTS_TYPE_PT_ADDBITS15
8046 | OPTS_TYPE_PT_UNICODE;
8047 kern_type = KERN_TYPE_SHA1_SLTPWU;
8048 dgst_size = DGST_SIZE_4_5;
8049 parse_func = sha1s_parse_hash;
8050 sort_by_digest = sort_by_digest_4_5;
8051 opti_type = OPTI_TYPE_ZERO_BYTE
8052 | OPTI_TYPE_PRECOMPUTE_INIT
8053 | OPTI_TYPE_PRECOMPUTE_MERKLE
8054 | OPTI_TYPE_EARLY_SKIP
8055 | OPTI_TYPE_NOT_ITERATED
8056 | OPTI_TYPE_PREPENDED_SALT
8057 | OPTI_TYPE_RAW_HASH;
8058 dgst_pos0 = 3;
8059 dgst_pos1 = 4;
8060 dgst_pos2 = 2;
8061 dgst_pos3 = 1;
8062 break;
8063
8064 case 141: hash_type = HASH_TYPE_SHA1;
8065 salt_type = SALT_TYPE_EMBEDDED;
8066 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8067 opts_type = OPTS_TYPE_PT_GENERATE_BE
8068 | OPTS_TYPE_PT_ADD80
8069 | OPTS_TYPE_PT_ADDBITS15
8070 | OPTS_TYPE_PT_UNICODE
8071 | OPTS_TYPE_ST_BASE64;
8072 kern_type = KERN_TYPE_SHA1_SLTPWU;
8073 dgst_size = DGST_SIZE_4_5;
8074 parse_func = episerver_parse_hash;
8075 sort_by_digest = sort_by_digest_4_5;
8076 opti_type = OPTI_TYPE_ZERO_BYTE
8077 | OPTI_TYPE_PRECOMPUTE_INIT
8078 | OPTI_TYPE_PRECOMPUTE_MERKLE
8079 | OPTI_TYPE_EARLY_SKIP
8080 | OPTI_TYPE_NOT_ITERATED
8081 | OPTI_TYPE_PREPENDED_SALT
8082 | OPTI_TYPE_RAW_HASH;
8083 dgst_pos0 = 3;
8084 dgst_pos1 = 4;
8085 dgst_pos2 = 2;
8086 dgst_pos3 = 1;
8087 break;
8088
8089 case 150: hash_type = HASH_TYPE_SHA1;
8090 salt_type = SALT_TYPE_INTERN;
8091 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8092 opts_type = OPTS_TYPE_PT_GENERATE_BE
8093 | OPTS_TYPE_ST_ADD80
8094 | OPTS_TYPE_ST_ADDBITS15;
8095 kern_type = KERN_TYPE_HMACSHA1_PW;
8096 dgst_size = DGST_SIZE_4_5;
8097 parse_func = hmacsha1_parse_hash;
8098 sort_by_digest = sort_by_digest_4_5;
8099 opti_type = OPTI_TYPE_ZERO_BYTE
8100 | OPTI_TYPE_NOT_ITERATED;
8101 dgst_pos0 = 3;
8102 dgst_pos1 = 4;
8103 dgst_pos2 = 2;
8104 dgst_pos3 = 1;
8105 break;
8106
8107 case 160: hash_type = HASH_TYPE_SHA1;
8108 salt_type = SALT_TYPE_INTERN;
8109 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8110 opts_type = OPTS_TYPE_PT_GENERATE_BE
8111 | OPTS_TYPE_PT_ADD80
8112 | OPTS_TYPE_PT_ADDBITS15;
8113 kern_type = KERN_TYPE_HMACSHA1_SLT;
8114 dgst_size = DGST_SIZE_4_5;
8115 parse_func = hmacsha1_parse_hash;
8116 sort_by_digest = sort_by_digest_4_5;
8117 opti_type = OPTI_TYPE_ZERO_BYTE
8118 | OPTI_TYPE_NOT_ITERATED;
8119 dgst_pos0 = 3;
8120 dgst_pos1 = 4;
8121 dgst_pos2 = 2;
8122 dgst_pos3 = 1;
8123 break;
8124
8125 case 200: hash_type = HASH_TYPE_MYSQL;
8126 salt_type = SALT_TYPE_NONE;
8127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8128 opts_type = 0;
8129 kern_type = KERN_TYPE_MYSQL;
8130 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8131 parse_func = mysql323_parse_hash;
8132 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8133 opti_type = OPTI_TYPE_ZERO_BYTE;
8134 dgst_pos0 = 0;
8135 dgst_pos1 = 1;
8136 dgst_pos2 = 2;
8137 dgst_pos3 = 3;
8138 break;
8139
8140 case 300: hash_type = HASH_TYPE_SHA1;
8141 salt_type = SALT_TYPE_NONE;
8142 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8143 opts_type = OPTS_TYPE_PT_GENERATE_BE
8144 | OPTS_TYPE_PT_ADD80
8145 | OPTS_TYPE_PT_ADDBITS15;
8146 kern_type = KERN_TYPE_MYSQL41;
8147 dgst_size = DGST_SIZE_4_5;
8148 parse_func = sha1_parse_hash;
8149 sort_by_digest = sort_by_digest_4_5;
8150 opti_type = OPTI_TYPE_ZERO_BYTE
8151 | OPTI_TYPE_PRECOMPUTE_INIT
8152 | OPTI_TYPE_PRECOMPUTE_MERKLE
8153 | OPTI_TYPE_EARLY_SKIP
8154 | OPTI_TYPE_NOT_ITERATED
8155 | OPTI_TYPE_NOT_SALTED;
8156 dgst_pos0 = 3;
8157 dgst_pos1 = 4;
8158 dgst_pos2 = 2;
8159 dgst_pos3 = 1;
8160 break;
8161
8162 case 400: hash_type = HASH_TYPE_MD5;
8163 salt_type = SALT_TYPE_EMBEDDED;
8164 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8165 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8166 kern_type = KERN_TYPE_PHPASS;
8167 dgst_size = DGST_SIZE_4_4;
8168 parse_func = phpass_parse_hash;
8169 sort_by_digest = sort_by_digest_4_4;
8170 opti_type = OPTI_TYPE_ZERO_BYTE
8171 | OPTI_TYPE_SLOW_HASH_SIMD;
8172 dgst_pos0 = 0;
8173 dgst_pos1 = 1;
8174 dgst_pos2 = 2;
8175 dgst_pos3 = 3;
8176 break;
8177
8178 case 500: hash_type = HASH_TYPE_MD5;
8179 salt_type = SALT_TYPE_EMBEDDED;
8180 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8181 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8182 kern_type = KERN_TYPE_MD5CRYPT;
8183 dgst_size = DGST_SIZE_4_4;
8184 parse_func = md5crypt_parse_hash;
8185 sort_by_digest = sort_by_digest_4_4;
8186 opti_type = OPTI_TYPE_ZERO_BYTE;
8187 dgst_pos0 = 0;
8188 dgst_pos1 = 1;
8189 dgst_pos2 = 2;
8190 dgst_pos3 = 3;
8191 break;
8192
8193 case 501: hash_type = HASH_TYPE_MD5;
8194 salt_type = SALT_TYPE_EMBEDDED;
8195 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8196 opts_type = OPTS_TYPE_PT_GENERATE_LE
8197 | OPTS_TYPE_HASH_COPY;
8198 kern_type = KERN_TYPE_MD5CRYPT;
8199 dgst_size = DGST_SIZE_4_4;
8200 parse_func = juniper_parse_hash;
8201 sort_by_digest = sort_by_digest_4_4;
8202 opti_type = OPTI_TYPE_ZERO_BYTE;
8203 dgst_pos0 = 0;
8204 dgst_pos1 = 1;
8205 dgst_pos2 = 2;
8206 dgst_pos3 = 3;
8207 break;
8208
8209 case 900: hash_type = HASH_TYPE_MD4;
8210 salt_type = SALT_TYPE_NONE;
8211 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8212 opts_type = OPTS_TYPE_PT_GENERATE_LE
8213 | OPTS_TYPE_PT_ADD80
8214 | OPTS_TYPE_PT_ADDBITS14;
8215 kern_type = KERN_TYPE_MD4;
8216 dgst_size = DGST_SIZE_4_4;
8217 parse_func = md4_parse_hash;
8218 sort_by_digest = sort_by_digest_4_4;
8219 opti_type = OPTI_TYPE_ZERO_BYTE
8220 | OPTI_TYPE_PRECOMPUTE_INIT
8221 | OPTI_TYPE_PRECOMPUTE_MERKLE
8222 | OPTI_TYPE_MEET_IN_MIDDLE
8223 | OPTI_TYPE_EARLY_SKIP
8224 | OPTI_TYPE_NOT_ITERATED
8225 | OPTI_TYPE_NOT_SALTED
8226 | OPTI_TYPE_RAW_HASH;
8227 dgst_pos0 = 0;
8228 dgst_pos1 = 3;
8229 dgst_pos2 = 2;
8230 dgst_pos3 = 1;
8231 break;
8232
8233 case 1000: hash_type = HASH_TYPE_MD4;
8234 salt_type = SALT_TYPE_NONE;
8235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8236 opts_type = OPTS_TYPE_PT_GENERATE_LE
8237 | OPTS_TYPE_PT_ADD80
8238 | OPTS_TYPE_PT_ADDBITS14
8239 | OPTS_TYPE_PT_UNICODE;
8240 kern_type = KERN_TYPE_MD4_PWU;
8241 dgst_size = DGST_SIZE_4_4;
8242 parse_func = md4_parse_hash;
8243 sort_by_digest = sort_by_digest_4_4;
8244 opti_type = OPTI_TYPE_ZERO_BYTE
8245 | OPTI_TYPE_PRECOMPUTE_INIT
8246 | OPTI_TYPE_PRECOMPUTE_MERKLE
8247 | OPTI_TYPE_MEET_IN_MIDDLE
8248 | OPTI_TYPE_EARLY_SKIP
8249 | OPTI_TYPE_NOT_ITERATED
8250 | OPTI_TYPE_NOT_SALTED
8251 | OPTI_TYPE_RAW_HASH;
8252 dgst_pos0 = 0;
8253 dgst_pos1 = 3;
8254 dgst_pos2 = 2;
8255 dgst_pos3 = 1;
8256 break;
8257
8258 case 1100: hash_type = HASH_TYPE_MD4;
8259 salt_type = SALT_TYPE_INTERN;
8260 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8261 opts_type = OPTS_TYPE_PT_GENERATE_LE
8262 | OPTS_TYPE_PT_ADD80
8263 | OPTS_TYPE_PT_ADDBITS14
8264 | OPTS_TYPE_PT_UNICODE
8265 | OPTS_TYPE_ST_ADD80
8266 | OPTS_TYPE_ST_UNICODE
8267 | OPTS_TYPE_ST_LOWER;
8268 kern_type = KERN_TYPE_MD44_PWUSLT;
8269 dgst_size = DGST_SIZE_4_4;
8270 parse_func = dcc_parse_hash;
8271 sort_by_digest = sort_by_digest_4_4;
8272 opti_type = OPTI_TYPE_ZERO_BYTE
8273 | OPTI_TYPE_PRECOMPUTE_INIT
8274 | OPTI_TYPE_PRECOMPUTE_MERKLE
8275 | OPTI_TYPE_EARLY_SKIP
8276 | OPTI_TYPE_NOT_ITERATED;
8277 dgst_pos0 = 0;
8278 dgst_pos1 = 3;
8279 dgst_pos2 = 2;
8280 dgst_pos3 = 1;
8281 break;
8282
8283 case 1400: hash_type = HASH_TYPE_SHA256;
8284 salt_type = SALT_TYPE_NONE;
8285 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8286 opts_type = OPTS_TYPE_PT_GENERATE_BE
8287 | OPTS_TYPE_PT_ADD80
8288 | OPTS_TYPE_PT_ADDBITS15;
8289 kern_type = KERN_TYPE_SHA256;
8290 dgst_size = DGST_SIZE_4_8;
8291 parse_func = sha256_parse_hash;
8292 sort_by_digest = sort_by_digest_4_8;
8293 opti_type = OPTI_TYPE_ZERO_BYTE
8294 | OPTI_TYPE_PRECOMPUTE_INIT
8295 | OPTI_TYPE_PRECOMPUTE_MERKLE
8296 | OPTI_TYPE_EARLY_SKIP
8297 | OPTI_TYPE_NOT_ITERATED
8298 | OPTI_TYPE_NOT_SALTED
8299 | OPTI_TYPE_RAW_HASH;
8300 dgst_pos0 = 3;
8301 dgst_pos1 = 7;
8302 dgst_pos2 = 2;
8303 dgst_pos3 = 6;
8304 break;
8305
8306 case 1410: hash_type = HASH_TYPE_SHA256;
8307 salt_type = SALT_TYPE_INTERN;
8308 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8309 opts_type = OPTS_TYPE_PT_GENERATE_BE
8310 | OPTS_TYPE_ST_ADD80
8311 | OPTS_TYPE_ST_ADDBITS15;
8312 kern_type = KERN_TYPE_SHA256_PWSLT;
8313 dgst_size = DGST_SIZE_4_8;
8314 parse_func = sha256s_parse_hash;
8315 sort_by_digest = sort_by_digest_4_8;
8316 opti_type = OPTI_TYPE_ZERO_BYTE
8317 | OPTI_TYPE_PRECOMPUTE_INIT
8318 | OPTI_TYPE_PRECOMPUTE_MERKLE
8319 | OPTI_TYPE_EARLY_SKIP
8320 | OPTI_TYPE_NOT_ITERATED
8321 | OPTI_TYPE_APPENDED_SALT
8322 | OPTI_TYPE_RAW_HASH;
8323 dgst_pos0 = 3;
8324 dgst_pos1 = 7;
8325 dgst_pos2 = 2;
8326 dgst_pos3 = 6;
8327 break;
8328
8329 case 1420: hash_type = HASH_TYPE_SHA256;
8330 salt_type = SALT_TYPE_INTERN;
8331 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8332 opts_type = OPTS_TYPE_PT_GENERATE_BE
8333 | OPTS_TYPE_PT_ADD80
8334 | OPTS_TYPE_PT_ADDBITS15;
8335 kern_type = KERN_TYPE_SHA256_SLTPW;
8336 dgst_size = DGST_SIZE_4_8;
8337 parse_func = sha256s_parse_hash;
8338 sort_by_digest = sort_by_digest_4_8;
8339 opti_type = OPTI_TYPE_ZERO_BYTE
8340 | OPTI_TYPE_PRECOMPUTE_INIT
8341 | OPTI_TYPE_PRECOMPUTE_MERKLE
8342 | OPTI_TYPE_EARLY_SKIP
8343 | OPTI_TYPE_NOT_ITERATED
8344 | OPTI_TYPE_PREPENDED_SALT
8345 | OPTI_TYPE_RAW_HASH;
8346 dgst_pos0 = 3;
8347 dgst_pos1 = 7;
8348 dgst_pos2 = 2;
8349 dgst_pos3 = 6;
8350 break;
8351
8352 case 1421: hash_type = HASH_TYPE_SHA256;
8353 salt_type = SALT_TYPE_EMBEDDED;
8354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8355 opts_type = OPTS_TYPE_PT_GENERATE_BE
8356 | OPTS_TYPE_PT_ADD80
8357 | OPTS_TYPE_PT_ADDBITS15;
8358 kern_type = KERN_TYPE_SHA256_SLTPW;
8359 dgst_size = DGST_SIZE_4_8;
8360 parse_func = hmailserver_parse_hash;
8361 sort_by_digest = sort_by_digest_4_8;
8362 opti_type = OPTI_TYPE_ZERO_BYTE
8363 | OPTI_TYPE_PRECOMPUTE_INIT
8364 | OPTI_TYPE_PRECOMPUTE_MERKLE
8365 | OPTI_TYPE_EARLY_SKIP
8366 | OPTI_TYPE_NOT_ITERATED
8367 | OPTI_TYPE_PREPENDED_SALT
8368 | OPTI_TYPE_RAW_HASH;
8369 dgst_pos0 = 3;
8370 dgst_pos1 = 7;
8371 dgst_pos2 = 2;
8372 dgst_pos3 = 6;
8373 break;
8374
8375 case 1430: hash_type = HASH_TYPE_SHA256;
8376 salt_type = SALT_TYPE_INTERN;
8377 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8378 opts_type = OPTS_TYPE_PT_GENERATE_BE
8379 | OPTS_TYPE_PT_UNICODE
8380 | OPTS_TYPE_ST_ADD80
8381 | OPTS_TYPE_ST_ADDBITS15;
8382 kern_type = KERN_TYPE_SHA256_PWUSLT;
8383 dgst_size = DGST_SIZE_4_8;
8384 parse_func = sha256s_parse_hash;
8385 sort_by_digest = sort_by_digest_4_8;
8386 opti_type = OPTI_TYPE_ZERO_BYTE
8387 | OPTI_TYPE_PRECOMPUTE_INIT
8388 | OPTI_TYPE_PRECOMPUTE_MERKLE
8389 | OPTI_TYPE_EARLY_SKIP
8390 | OPTI_TYPE_NOT_ITERATED
8391 | OPTI_TYPE_APPENDED_SALT
8392 | OPTI_TYPE_RAW_HASH;
8393 dgst_pos0 = 3;
8394 dgst_pos1 = 7;
8395 dgst_pos2 = 2;
8396 dgst_pos3 = 6;
8397 break;
8398
8399 case 1440: hash_type = HASH_TYPE_SHA256;
8400 salt_type = SALT_TYPE_INTERN;
8401 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8402 opts_type = OPTS_TYPE_PT_GENERATE_BE
8403 | OPTS_TYPE_PT_ADD80
8404 | OPTS_TYPE_PT_ADDBITS15
8405 | OPTS_TYPE_PT_UNICODE;
8406 kern_type = KERN_TYPE_SHA256_SLTPWU;
8407 dgst_size = DGST_SIZE_4_8;
8408 parse_func = sha256s_parse_hash;
8409 sort_by_digest = sort_by_digest_4_8;
8410 opti_type = OPTI_TYPE_ZERO_BYTE
8411 | OPTI_TYPE_PRECOMPUTE_INIT
8412 | OPTI_TYPE_PRECOMPUTE_MERKLE
8413 | OPTI_TYPE_EARLY_SKIP
8414 | OPTI_TYPE_NOT_ITERATED
8415 | OPTI_TYPE_PREPENDED_SALT
8416 | OPTI_TYPE_RAW_HASH;
8417 dgst_pos0 = 3;
8418 dgst_pos1 = 7;
8419 dgst_pos2 = 2;
8420 dgst_pos3 = 6;
8421 break;
8422
8423 case 1441: hash_type = HASH_TYPE_SHA256;
8424 salt_type = SALT_TYPE_EMBEDDED;
8425 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8426 opts_type = OPTS_TYPE_PT_GENERATE_BE
8427 | OPTS_TYPE_PT_ADD80
8428 | OPTS_TYPE_PT_ADDBITS15
8429 | OPTS_TYPE_PT_UNICODE
8430 | OPTS_TYPE_ST_BASE64;
8431 kern_type = KERN_TYPE_SHA256_SLTPWU;
8432 dgst_size = DGST_SIZE_4_8;
8433 parse_func = episerver4_parse_hash;
8434 sort_by_digest = sort_by_digest_4_8;
8435 opti_type = OPTI_TYPE_ZERO_BYTE
8436 | OPTI_TYPE_PRECOMPUTE_INIT
8437 | OPTI_TYPE_PRECOMPUTE_MERKLE
8438 | OPTI_TYPE_EARLY_SKIP
8439 | OPTI_TYPE_NOT_ITERATED
8440 | OPTI_TYPE_PREPENDED_SALT
8441 | OPTI_TYPE_RAW_HASH;
8442 dgst_pos0 = 3;
8443 dgst_pos1 = 7;
8444 dgst_pos2 = 2;
8445 dgst_pos3 = 6;
8446 break;
8447
8448 case 1450: hash_type = HASH_TYPE_SHA256;
8449 salt_type = SALT_TYPE_INTERN;
8450 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8451 opts_type = OPTS_TYPE_PT_GENERATE_BE
8452 | OPTS_TYPE_ST_ADD80;
8453 kern_type = KERN_TYPE_HMACSHA256_PW;
8454 dgst_size = DGST_SIZE_4_8;
8455 parse_func = hmacsha256_parse_hash;
8456 sort_by_digest = sort_by_digest_4_8;
8457 opti_type = OPTI_TYPE_ZERO_BYTE
8458 | OPTI_TYPE_NOT_ITERATED;
8459 dgst_pos0 = 3;
8460 dgst_pos1 = 7;
8461 dgst_pos2 = 2;
8462 dgst_pos3 = 6;
8463 break;
8464
8465 case 1460: hash_type = HASH_TYPE_SHA256;
8466 salt_type = SALT_TYPE_INTERN;
8467 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8468 opts_type = OPTS_TYPE_PT_GENERATE_BE
8469 | OPTS_TYPE_PT_ADD80
8470 | OPTS_TYPE_PT_ADDBITS15;
8471 kern_type = KERN_TYPE_HMACSHA256_SLT;
8472 dgst_size = DGST_SIZE_4_8;
8473 parse_func = hmacsha256_parse_hash;
8474 sort_by_digest = sort_by_digest_4_8;
8475 opti_type = OPTI_TYPE_ZERO_BYTE
8476 | OPTI_TYPE_NOT_ITERATED;
8477 dgst_pos0 = 3;
8478 dgst_pos1 = 7;
8479 dgst_pos2 = 2;
8480 dgst_pos3 = 6;
8481 break;
8482
8483 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8484 salt_type = SALT_TYPE_EMBEDDED;
8485 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8486 opts_type = OPTS_TYPE_PT_GENERATE_LE
8487 | OPTS_TYPE_PT_BITSLICE;
8488 kern_type = KERN_TYPE_DESCRYPT;
8489 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8490 parse_func = descrypt_parse_hash;
8491 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8492 opti_type = OPTI_TYPE_ZERO_BYTE
8493 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8494 dgst_pos0 = 0;
8495 dgst_pos1 = 1;
8496 dgst_pos2 = 2;
8497 dgst_pos3 = 3;
8498 break;
8499
8500 case 1600: hash_type = HASH_TYPE_MD5;
8501 salt_type = SALT_TYPE_EMBEDDED;
8502 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8503 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8504 kern_type = KERN_TYPE_APR1CRYPT;
8505 dgst_size = DGST_SIZE_4_4;
8506 parse_func = md5apr1_parse_hash;
8507 sort_by_digest = sort_by_digest_4_4;
8508 opti_type = OPTI_TYPE_ZERO_BYTE;
8509 dgst_pos0 = 0;
8510 dgst_pos1 = 1;
8511 dgst_pos2 = 2;
8512 dgst_pos3 = 3;
8513 break;
8514
8515 case 1700: hash_type = HASH_TYPE_SHA512;
8516 salt_type = SALT_TYPE_NONE;
8517 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8518 opts_type = OPTS_TYPE_PT_GENERATE_BE
8519 | OPTS_TYPE_PT_ADD80
8520 | OPTS_TYPE_PT_ADDBITS15;
8521 kern_type = KERN_TYPE_SHA512;
8522 dgst_size = DGST_SIZE_8_8;
8523 parse_func = sha512_parse_hash;
8524 sort_by_digest = sort_by_digest_8_8;
8525 opti_type = OPTI_TYPE_ZERO_BYTE
8526 | OPTI_TYPE_PRECOMPUTE_INIT
8527 | OPTI_TYPE_PRECOMPUTE_MERKLE
8528 | OPTI_TYPE_EARLY_SKIP
8529 | OPTI_TYPE_NOT_ITERATED
8530 | OPTI_TYPE_NOT_SALTED
8531 | OPTI_TYPE_USES_BITS_64
8532 | OPTI_TYPE_RAW_HASH;
8533 dgst_pos0 = 14;
8534 dgst_pos1 = 15;
8535 dgst_pos2 = 6;
8536 dgst_pos3 = 7;
8537 break;
8538
8539 case 1710: hash_type = HASH_TYPE_SHA512;
8540 salt_type = SALT_TYPE_INTERN;
8541 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8542 opts_type = OPTS_TYPE_PT_GENERATE_BE
8543 | OPTS_TYPE_ST_ADD80
8544 | OPTS_TYPE_ST_ADDBITS15;
8545 kern_type = KERN_TYPE_SHA512_PWSLT;
8546 dgst_size = DGST_SIZE_8_8;
8547 parse_func = sha512s_parse_hash;
8548 sort_by_digest = sort_by_digest_8_8;
8549 opti_type = OPTI_TYPE_ZERO_BYTE
8550 | OPTI_TYPE_PRECOMPUTE_INIT
8551 | OPTI_TYPE_PRECOMPUTE_MERKLE
8552 | OPTI_TYPE_EARLY_SKIP
8553 | OPTI_TYPE_NOT_ITERATED
8554 | OPTI_TYPE_APPENDED_SALT
8555 | OPTI_TYPE_USES_BITS_64
8556 | OPTI_TYPE_RAW_HASH;
8557 dgst_pos0 = 14;
8558 dgst_pos1 = 15;
8559 dgst_pos2 = 6;
8560 dgst_pos3 = 7;
8561 break;
8562
8563 case 1711: hash_type = HASH_TYPE_SHA512;
8564 salt_type = SALT_TYPE_EMBEDDED;
8565 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8566 opts_type = OPTS_TYPE_PT_GENERATE_BE
8567 | OPTS_TYPE_ST_ADD80
8568 | OPTS_TYPE_ST_ADDBITS15;
8569 kern_type = KERN_TYPE_SHA512_PWSLT;
8570 dgst_size = DGST_SIZE_8_8;
8571 parse_func = sha512b64s_parse_hash;
8572 sort_by_digest = sort_by_digest_8_8;
8573 opti_type = OPTI_TYPE_ZERO_BYTE
8574 | OPTI_TYPE_PRECOMPUTE_INIT
8575 | OPTI_TYPE_PRECOMPUTE_MERKLE
8576 | OPTI_TYPE_EARLY_SKIP
8577 | OPTI_TYPE_NOT_ITERATED
8578 | OPTI_TYPE_APPENDED_SALT
8579 | OPTI_TYPE_USES_BITS_64
8580 | OPTI_TYPE_RAW_HASH;
8581 dgst_pos0 = 14;
8582 dgst_pos1 = 15;
8583 dgst_pos2 = 6;
8584 dgst_pos3 = 7;
8585 break;
8586
8587 case 1720: hash_type = HASH_TYPE_SHA512;
8588 salt_type = SALT_TYPE_INTERN;
8589 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8590 opts_type = OPTS_TYPE_PT_GENERATE_BE
8591 | OPTS_TYPE_PT_ADD80
8592 | OPTS_TYPE_PT_ADDBITS15;
8593 kern_type = KERN_TYPE_SHA512_SLTPW;
8594 dgst_size = DGST_SIZE_8_8;
8595 parse_func = sha512s_parse_hash;
8596 sort_by_digest = sort_by_digest_8_8;
8597 opti_type = OPTI_TYPE_ZERO_BYTE
8598 | OPTI_TYPE_PRECOMPUTE_INIT
8599 | OPTI_TYPE_PRECOMPUTE_MERKLE
8600 | OPTI_TYPE_EARLY_SKIP
8601 | OPTI_TYPE_NOT_ITERATED
8602 | OPTI_TYPE_PREPENDED_SALT
8603 | OPTI_TYPE_USES_BITS_64
8604 | OPTI_TYPE_RAW_HASH;
8605 dgst_pos0 = 14;
8606 dgst_pos1 = 15;
8607 dgst_pos2 = 6;
8608 dgst_pos3 = 7;
8609 break;
8610
8611 case 1722: hash_type = HASH_TYPE_SHA512;
8612 salt_type = SALT_TYPE_EMBEDDED;
8613 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8614 opts_type = OPTS_TYPE_PT_GENERATE_BE
8615 | OPTS_TYPE_PT_ADD80
8616 | OPTS_TYPE_PT_ADDBITS15
8617 | OPTS_TYPE_ST_HEX;
8618 kern_type = KERN_TYPE_SHA512_SLTPW;
8619 dgst_size = DGST_SIZE_8_8;
8620 parse_func = osx512_parse_hash;
8621 sort_by_digest = sort_by_digest_8_8;
8622 opti_type = OPTI_TYPE_ZERO_BYTE
8623 | OPTI_TYPE_PRECOMPUTE_INIT
8624 | OPTI_TYPE_PRECOMPUTE_MERKLE
8625 | OPTI_TYPE_EARLY_SKIP
8626 | OPTI_TYPE_NOT_ITERATED
8627 | OPTI_TYPE_PREPENDED_SALT
8628 | OPTI_TYPE_USES_BITS_64
8629 | OPTI_TYPE_RAW_HASH;
8630 dgst_pos0 = 14;
8631 dgst_pos1 = 15;
8632 dgst_pos2 = 6;
8633 dgst_pos3 = 7;
8634 break;
8635
8636 case 1730: hash_type = HASH_TYPE_SHA512;
8637 salt_type = SALT_TYPE_INTERN;
8638 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8639 opts_type = OPTS_TYPE_PT_GENERATE_BE
8640 | OPTS_TYPE_PT_UNICODE
8641 | OPTS_TYPE_ST_ADD80
8642 | OPTS_TYPE_ST_ADDBITS15;
8643 kern_type = KERN_TYPE_SHA512_PWSLTU;
8644 dgst_size = DGST_SIZE_8_8;
8645 parse_func = sha512s_parse_hash;
8646 sort_by_digest = sort_by_digest_8_8;
8647 opti_type = OPTI_TYPE_ZERO_BYTE
8648 | OPTI_TYPE_PRECOMPUTE_INIT
8649 | OPTI_TYPE_PRECOMPUTE_MERKLE
8650 | OPTI_TYPE_EARLY_SKIP
8651 | OPTI_TYPE_NOT_ITERATED
8652 | OPTI_TYPE_APPENDED_SALT
8653 | OPTI_TYPE_USES_BITS_64
8654 | OPTI_TYPE_RAW_HASH;
8655 dgst_pos0 = 14;
8656 dgst_pos1 = 15;
8657 dgst_pos2 = 6;
8658 dgst_pos3 = 7;
8659 break;
8660
8661 case 1731: hash_type = HASH_TYPE_SHA512;
8662 salt_type = SALT_TYPE_EMBEDDED;
8663 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8664 opts_type = OPTS_TYPE_PT_GENERATE_BE
8665 | OPTS_TYPE_PT_UNICODE
8666 | OPTS_TYPE_ST_ADD80
8667 | OPTS_TYPE_ST_ADDBITS15
8668 | OPTS_TYPE_ST_HEX;
8669 kern_type = KERN_TYPE_SHA512_PWSLTU;
8670 dgst_size = DGST_SIZE_8_8;
8671 parse_func = mssql2012_parse_hash;
8672 sort_by_digest = sort_by_digest_8_8;
8673 opti_type = OPTI_TYPE_ZERO_BYTE
8674 | OPTI_TYPE_PRECOMPUTE_INIT
8675 | OPTI_TYPE_PRECOMPUTE_MERKLE
8676 | OPTI_TYPE_EARLY_SKIP
8677 | OPTI_TYPE_NOT_ITERATED
8678 | OPTI_TYPE_APPENDED_SALT
8679 | OPTI_TYPE_USES_BITS_64
8680 | OPTI_TYPE_RAW_HASH;
8681 dgst_pos0 = 14;
8682 dgst_pos1 = 15;
8683 dgst_pos2 = 6;
8684 dgst_pos3 = 7;
8685 break;
8686
8687 case 1740: hash_type = HASH_TYPE_SHA512;
8688 salt_type = SALT_TYPE_INTERN;
8689 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8690 opts_type = OPTS_TYPE_PT_GENERATE_BE
8691 | OPTS_TYPE_PT_ADD80
8692 | OPTS_TYPE_PT_ADDBITS15
8693 | OPTS_TYPE_PT_UNICODE;
8694 kern_type = KERN_TYPE_SHA512_SLTPWU;
8695 dgst_size = DGST_SIZE_8_8;
8696 parse_func = sha512s_parse_hash;
8697 sort_by_digest = sort_by_digest_8_8;
8698 opti_type = OPTI_TYPE_ZERO_BYTE
8699 | OPTI_TYPE_PRECOMPUTE_INIT
8700 | OPTI_TYPE_PRECOMPUTE_MERKLE
8701 | OPTI_TYPE_EARLY_SKIP
8702 | OPTI_TYPE_NOT_ITERATED
8703 | OPTI_TYPE_PREPENDED_SALT
8704 | OPTI_TYPE_USES_BITS_64
8705 | OPTI_TYPE_RAW_HASH;
8706 dgst_pos0 = 14;
8707 dgst_pos1 = 15;
8708 dgst_pos2 = 6;
8709 dgst_pos3 = 7;
8710 break;
8711
8712 case 1750: hash_type = HASH_TYPE_SHA512;
8713 salt_type = SALT_TYPE_INTERN;
8714 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8715 opts_type = OPTS_TYPE_PT_GENERATE_BE
8716 | OPTS_TYPE_ST_ADD80;
8717 kern_type = KERN_TYPE_HMACSHA512_PW;
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 1760: hash_type = HASH_TYPE_SHA512;
8731 salt_type = SALT_TYPE_INTERN;
8732 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8733 opts_type = OPTS_TYPE_PT_GENERATE_BE
8734 | OPTS_TYPE_PT_ADD80
8735 | OPTS_TYPE_PT_ADDBITS15;
8736 kern_type = KERN_TYPE_HMACSHA512_SLT;
8737 dgst_size = DGST_SIZE_8_8;
8738 parse_func = hmacsha512_parse_hash;
8739 sort_by_digest = sort_by_digest_8_8;
8740 opti_type = OPTI_TYPE_ZERO_BYTE
8741 | OPTI_TYPE_USES_BITS_64
8742 | OPTI_TYPE_NOT_ITERATED;
8743 dgst_pos0 = 14;
8744 dgst_pos1 = 15;
8745 dgst_pos2 = 6;
8746 dgst_pos3 = 7;
8747 break;
8748
8749 case 1800: hash_type = HASH_TYPE_SHA512;
8750 salt_type = SALT_TYPE_EMBEDDED;
8751 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8752 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8753 kern_type = KERN_TYPE_SHA512CRYPT;
8754 dgst_size = DGST_SIZE_8_8;
8755 parse_func = sha512crypt_parse_hash;
8756 sort_by_digest = sort_by_digest_8_8;
8757 opti_type = OPTI_TYPE_ZERO_BYTE
8758 | OPTI_TYPE_USES_BITS_64;
8759 dgst_pos0 = 0;
8760 dgst_pos1 = 1;
8761 dgst_pos2 = 2;
8762 dgst_pos3 = 3;
8763 break;
8764
8765 case 2000: hash_type = HASH_TYPE_STDOUT;
8766 salt_type = SALT_TYPE_NONE;
8767 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8768 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8769 kern_type = KERN_TYPE_STDOUT;
8770 dgst_size = DGST_SIZE_4_4;
8771 parse_func = NULL;
8772 sort_by_digest = NULL;
8773 opti_type = 0;
8774 dgst_pos0 = 0;
8775 dgst_pos1 = 0;
8776 dgst_pos2 = 0;
8777 dgst_pos3 = 0;
8778 break;
8779
8780 case 2100: hash_type = HASH_TYPE_DCC2;
8781 salt_type = SALT_TYPE_EMBEDDED;
8782 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8783 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8784 | OPTS_TYPE_ST_LOWER
8785 | OPTS_TYPE_ST_UNICODE;
8786 kern_type = KERN_TYPE_DCC2;
8787 dgst_size = DGST_SIZE_4_4;
8788 parse_func = dcc2_parse_hash;
8789 sort_by_digest = sort_by_digest_4_4;
8790 opti_type = OPTI_TYPE_ZERO_BYTE
8791 | OPTI_TYPE_SLOW_HASH_SIMD;
8792 dgst_pos0 = 0;
8793 dgst_pos1 = 1;
8794 dgst_pos2 = 2;
8795 dgst_pos3 = 3;
8796 break;
8797
8798 case 2400: hash_type = HASH_TYPE_MD5;
8799 salt_type = SALT_TYPE_NONE;
8800 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8801 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8802 kern_type = KERN_TYPE_MD5PIX;
8803 dgst_size = DGST_SIZE_4_4;
8804 parse_func = md5pix_parse_hash;
8805 sort_by_digest = sort_by_digest_4_4;
8806 opti_type = OPTI_TYPE_ZERO_BYTE
8807 | OPTI_TYPE_PRECOMPUTE_INIT
8808 | OPTI_TYPE_PRECOMPUTE_MERKLE
8809 | OPTI_TYPE_EARLY_SKIP
8810 | OPTI_TYPE_NOT_ITERATED
8811 | OPTI_TYPE_NOT_SALTED;
8812 dgst_pos0 = 0;
8813 dgst_pos1 = 3;
8814 dgst_pos2 = 2;
8815 dgst_pos3 = 1;
8816 break;
8817
8818 case 2410: hash_type = HASH_TYPE_MD5;
8819 salt_type = SALT_TYPE_INTERN;
8820 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8821 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8822 kern_type = KERN_TYPE_MD5ASA;
8823 dgst_size = DGST_SIZE_4_4;
8824 parse_func = md5asa_parse_hash;
8825 sort_by_digest = sort_by_digest_4_4;
8826 opti_type = OPTI_TYPE_ZERO_BYTE
8827 | OPTI_TYPE_PRECOMPUTE_INIT
8828 | OPTI_TYPE_PRECOMPUTE_MERKLE
8829 | OPTI_TYPE_EARLY_SKIP
8830 | OPTI_TYPE_NOT_ITERATED;
8831 dgst_pos0 = 0;
8832 dgst_pos1 = 3;
8833 dgst_pos2 = 2;
8834 dgst_pos3 = 1;
8835 break;
8836
8837 case 2500: hash_type = HASH_TYPE_WPA;
8838 salt_type = SALT_TYPE_EMBEDDED;
8839 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8840 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8841 kern_type = KERN_TYPE_WPA;
8842 dgst_size = DGST_SIZE_4_4;
8843 parse_func = wpa_parse_hash;
8844 sort_by_digest = sort_by_digest_4_4;
8845 opti_type = OPTI_TYPE_ZERO_BYTE
8846 | OPTI_TYPE_SLOW_HASH_SIMD;
8847 dgst_pos0 = 0;
8848 dgst_pos1 = 1;
8849 dgst_pos2 = 2;
8850 dgst_pos3 = 3;
8851 break;
8852
8853 case 2600: hash_type = HASH_TYPE_MD5;
8854 salt_type = SALT_TYPE_VIRTUAL;
8855 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8856 opts_type = OPTS_TYPE_PT_GENERATE_LE
8857 | OPTS_TYPE_PT_ADD80
8858 | OPTS_TYPE_PT_ADDBITS14
8859 | OPTS_TYPE_ST_ADD80;
8860 kern_type = KERN_TYPE_MD55_PWSLT1;
8861 dgst_size = DGST_SIZE_4_4;
8862 parse_func = md5md5_parse_hash;
8863 sort_by_digest = sort_by_digest_4_4;
8864 opti_type = OPTI_TYPE_ZERO_BYTE
8865 | OPTI_TYPE_PRECOMPUTE_INIT
8866 | OPTI_TYPE_PRECOMPUTE_MERKLE
8867 | OPTI_TYPE_EARLY_SKIP;
8868 dgst_pos0 = 0;
8869 dgst_pos1 = 3;
8870 dgst_pos2 = 2;
8871 dgst_pos3 = 1;
8872 break;
8873
8874 case 2611: hash_type = HASH_TYPE_MD5;
8875 salt_type = SALT_TYPE_INTERN;
8876 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8877 opts_type = OPTS_TYPE_PT_GENERATE_LE
8878 | OPTS_TYPE_PT_ADD80
8879 | OPTS_TYPE_PT_ADDBITS14
8880 | OPTS_TYPE_ST_ADD80;
8881 kern_type = KERN_TYPE_MD55_PWSLT1;
8882 dgst_size = DGST_SIZE_4_4;
8883 parse_func = vb3_parse_hash;
8884 sort_by_digest = sort_by_digest_4_4;
8885 opti_type = OPTI_TYPE_ZERO_BYTE
8886 | OPTI_TYPE_PRECOMPUTE_INIT
8887 | OPTI_TYPE_PRECOMPUTE_MERKLE
8888 | OPTI_TYPE_EARLY_SKIP;
8889 dgst_pos0 = 0;
8890 dgst_pos1 = 3;
8891 dgst_pos2 = 2;
8892 dgst_pos3 = 1;
8893 break;
8894
8895 case 2612: hash_type = HASH_TYPE_MD5;
8896 salt_type = SALT_TYPE_EMBEDDED;
8897 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8898 opts_type = OPTS_TYPE_PT_GENERATE_LE
8899 | OPTS_TYPE_PT_ADD80
8900 | OPTS_TYPE_PT_ADDBITS14
8901 | OPTS_TYPE_ST_ADD80
8902 | OPTS_TYPE_ST_HEX;
8903 kern_type = KERN_TYPE_MD55_PWSLT1;
8904 dgst_size = DGST_SIZE_4_4;
8905 parse_func = phps_parse_hash;
8906 sort_by_digest = sort_by_digest_4_4;
8907 opti_type = OPTI_TYPE_ZERO_BYTE
8908 | OPTI_TYPE_PRECOMPUTE_INIT
8909 | OPTI_TYPE_PRECOMPUTE_MERKLE
8910 | OPTI_TYPE_EARLY_SKIP;
8911 dgst_pos0 = 0;
8912 dgst_pos1 = 3;
8913 dgst_pos2 = 2;
8914 dgst_pos3 = 1;
8915 break;
8916
8917 case 2711: hash_type = HASH_TYPE_MD5;
8918 salt_type = SALT_TYPE_INTERN;
8919 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8920 opts_type = OPTS_TYPE_PT_GENERATE_LE
8921 | OPTS_TYPE_PT_ADD80
8922 | OPTS_TYPE_PT_ADDBITS14
8923 | OPTS_TYPE_ST_ADD80;
8924 kern_type = KERN_TYPE_MD55_PWSLT2;
8925 dgst_size = DGST_SIZE_4_4;
8926 parse_func = vb30_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 2811: hash_type = HASH_TYPE_MD5;
8938 salt_type = SALT_TYPE_INTERN;
8939 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8940 opts_type = OPTS_TYPE_PT_GENERATE_LE
8941 | OPTS_TYPE_PT_ADD80
8942 | OPTS_TYPE_PT_ADDBITS14;
8943 kern_type = KERN_TYPE_MD55_SLTPW;
8944 dgst_size = DGST_SIZE_4_4;
8945 parse_func = ipb2_parse_hash;
8946 sort_by_digest = sort_by_digest_4_4;
8947 opti_type = OPTI_TYPE_ZERO_BYTE
8948 | OPTI_TYPE_PRECOMPUTE_INIT
8949 | OPTI_TYPE_EARLY_SKIP;
8950 dgst_pos0 = 0;
8951 dgst_pos1 = 3;
8952 dgst_pos2 = 2;
8953 dgst_pos3 = 1;
8954 break;
8955
8956 case 3000: hash_type = HASH_TYPE_LM;
8957 salt_type = SALT_TYPE_NONE;
8958 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8959 opts_type = OPTS_TYPE_PT_GENERATE_LE
8960 | OPTS_TYPE_PT_UPPER
8961 | OPTS_TYPE_PT_BITSLICE;
8962 kern_type = KERN_TYPE_LM;
8963 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8964 parse_func = lm_parse_hash;
8965 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8966 opti_type = OPTI_TYPE_ZERO_BYTE
8967 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8968 dgst_pos0 = 0;
8969 dgst_pos1 = 1;
8970 dgst_pos2 = 2;
8971 dgst_pos3 = 3;
8972 break;
8973
8974 case 3100: hash_type = HASH_TYPE_ORACLEH;
8975 salt_type = SALT_TYPE_INTERN;
8976 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8977 opts_type = OPTS_TYPE_PT_GENERATE_LE
8978 | OPTS_TYPE_PT_UPPER
8979 | OPTS_TYPE_ST_UPPER;
8980 kern_type = KERN_TYPE_ORACLEH;
8981 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8982 parse_func = oracleh_parse_hash;
8983 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8984 opti_type = OPTI_TYPE_ZERO_BYTE;
8985 dgst_pos0 = 0;
8986 dgst_pos1 = 1;
8987 dgst_pos2 = 2;
8988 dgst_pos3 = 3;
8989 break;
8990
8991 case 3200: hash_type = HASH_TYPE_BCRYPT;
8992 salt_type = SALT_TYPE_EMBEDDED;
8993 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8994 opts_type = OPTS_TYPE_PT_GENERATE_LE
8995 | OPTS_TYPE_ST_GENERATE_LE;
8996 kern_type = KERN_TYPE_BCRYPT;
8997 dgst_size = DGST_SIZE_4_6;
8998 parse_func = bcrypt_parse_hash;
8999 sort_by_digest = sort_by_digest_4_6;
9000 opti_type = OPTI_TYPE_ZERO_BYTE;
9001 dgst_pos0 = 0;
9002 dgst_pos1 = 1;
9003 dgst_pos2 = 2;
9004 dgst_pos3 = 3;
9005 break;
9006
9007 case 3710: hash_type = HASH_TYPE_MD5;
9008 salt_type = SALT_TYPE_INTERN;
9009 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9010 opts_type = OPTS_TYPE_PT_GENERATE_LE
9011 | OPTS_TYPE_PT_ADD80
9012 | OPTS_TYPE_PT_ADDBITS14;
9013 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9014 dgst_size = DGST_SIZE_4_4;
9015 parse_func = md5s_parse_hash;
9016 sort_by_digest = sort_by_digest_4_4;
9017 opti_type = OPTI_TYPE_ZERO_BYTE
9018 | OPTI_TYPE_PRECOMPUTE_INIT
9019 | OPTI_TYPE_PRECOMPUTE_MERKLE
9020 | OPTI_TYPE_EARLY_SKIP;
9021 dgst_pos0 = 0;
9022 dgst_pos1 = 3;
9023 dgst_pos2 = 2;
9024 dgst_pos3 = 1;
9025 break;
9026
9027 case 3711: hash_type = HASH_TYPE_MD5;
9028 salt_type = SALT_TYPE_EMBEDDED;
9029 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9030 opts_type = OPTS_TYPE_PT_GENERATE_LE
9031 | OPTS_TYPE_PT_ADD80
9032 | OPTS_TYPE_PT_ADDBITS14;
9033 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9034 dgst_size = DGST_SIZE_4_4;
9035 parse_func = mediawiki_b_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 dgst_pos0 = 0;
9042 dgst_pos1 = 3;
9043 dgst_pos2 = 2;
9044 dgst_pos3 = 1;
9045 break;
9046
9047 case 3800: hash_type = HASH_TYPE_MD5;
9048 salt_type = SALT_TYPE_INTERN;
9049 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9050 opts_type = OPTS_TYPE_PT_GENERATE_LE
9051 | OPTS_TYPE_ST_ADDBITS14;
9052 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
9053 dgst_size = DGST_SIZE_4_4;
9054 parse_func = md5s_parse_hash;
9055 sort_by_digest = sort_by_digest_4_4;
9056 opti_type = OPTI_TYPE_ZERO_BYTE
9057 | OPTI_TYPE_PRECOMPUTE_INIT
9058 | OPTI_TYPE_PRECOMPUTE_MERKLE
9059 | OPTI_TYPE_EARLY_SKIP
9060 | OPTI_TYPE_NOT_ITERATED
9061 | OPTI_TYPE_RAW_HASH;
9062 dgst_pos0 = 0;
9063 dgst_pos1 = 3;
9064 dgst_pos2 = 2;
9065 dgst_pos3 = 1;
9066 break;
9067
9068 case 4300: hash_type = HASH_TYPE_MD5;
9069 salt_type = SALT_TYPE_VIRTUAL;
9070 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9071 opts_type = OPTS_TYPE_PT_GENERATE_LE
9072 | OPTS_TYPE_PT_ADD80
9073 | OPTS_TYPE_PT_ADDBITS14
9074 | OPTS_TYPE_ST_ADD80;
9075 kern_type = KERN_TYPE_MD5U5_PWSLT1;
9076 dgst_size = DGST_SIZE_4_4;
9077 parse_func = md5md5_parse_hash;
9078 sort_by_digest = sort_by_digest_4_4;
9079 opti_type = OPTI_TYPE_ZERO_BYTE
9080 | OPTI_TYPE_PRECOMPUTE_INIT
9081 | OPTI_TYPE_PRECOMPUTE_MERKLE
9082 | OPTI_TYPE_EARLY_SKIP;
9083 dgst_pos0 = 0;
9084 dgst_pos1 = 3;
9085 dgst_pos2 = 2;
9086 dgst_pos3 = 1;
9087 break;
9088
9089
9090 case 4400: hash_type = HASH_TYPE_MD5;
9091 salt_type = SALT_TYPE_NONE;
9092 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9093 opts_type = OPTS_TYPE_PT_GENERATE_BE
9094 | OPTS_TYPE_PT_ADD80
9095 | OPTS_TYPE_PT_ADDBITS15;
9096 kern_type = KERN_TYPE_MD5_SHA1;
9097 dgst_size = DGST_SIZE_4_4;
9098 parse_func = md5_parse_hash;
9099 sort_by_digest = sort_by_digest_4_4;
9100 opti_type = OPTI_TYPE_ZERO_BYTE
9101 | OPTI_TYPE_PRECOMPUTE_INIT
9102 | OPTI_TYPE_PRECOMPUTE_MERKLE
9103 | OPTI_TYPE_EARLY_SKIP
9104 | OPTI_TYPE_NOT_ITERATED
9105 | OPTI_TYPE_NOT_SALTED
9106 | OPTI_TYPE_RAW_HASH;
9107 dgst_pos0 = 0;
9108 dgst_pos1 = 3;
9109 dgst_pos2 = 2;
9110 dgst_pos3 = 1;
9111 break;
9112
9113 case 4500: hash_type = HASH_TYPE_SHA1;
9114 salt_type = SALT_TYPE_NONE;
9115 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9116 opts_type = OPTS_TYPE_PT_GENERATE_BE
9117 | OPTS_TYPE_PT_ADD80
9118 | OPTS_TYPE_PT_ADDBITS15;
9119 kern_type = KERN_TYPE_SHA11;
9120 dgst_size = DGST_SIZE_4_5;
9121 parse_func = sha1_parse_hash;
9122 sort_by_digest = sort_by_digest_4_5;
9123 opti_type = OPTI_TYPE_ZERO_BYTE
9124 | OPTI_TYPE_PRECOMPUTE_INIT
9125 | OPTI_TYPE_PRECOMPUTE_MERKLE
9126 | OPTI_TYPE_EARLY_SKIP
9127 | OPTI_TYPE_NOT_SALTED;
9128 dgst_pos0 = 3;
9129 dgst_pos1 = 4;
9130 dgst_pos2 = 2;
9131 dgst_pos3 = 1;
9132 break;
9133
9134 case 4700: hash_type = HASH_TYPE_SHA1;
9135 salt_type = SALT_TYPE_NONE;
9136 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9137 opts_type = OPTS_TYPE_PT_GENERATE_LE
9138 | OPTS_TYPE_PT_ADD80
9139 | OPTS_TYPE_PT_ADDBITS14;
9140 kern_type = KERN_TYPE_SHA1_MD5;
9141 dgst_size = DGST_SIZE_4_5;
9142 parse_func = sha1_parse_hash;
9143 sort_by_digest = sort_by_digest_4_5;
9144 opti_type = OPTI_TYPE_ZERO_BYTE
9145 | OPTI_TYPE_PRECOMPUTE_INIT
9146 | OPTI_TYPE_PRECOMPUTE_MERKLE
9147 | OPTI_TYPE_EARLY_SKIP
9148 | OPTI_TYPE_NOT_ITERATED
9149 | OPTI_TYPE_NOT_SALTED
9150 | OPTI_TYPE_RAW_HASH;
9151 dgst_pos0 = 3;
9152 dgst_pos1 = 4;
9153 dgst_pos2 = 2;
9154 dgst_pos3 = 1;
9155 break;
9156
9157 case 4800: hash_type = HASH_TYPE_MD5;
9158 salt_type = SALT_TYPE_EMBEDDED;
9159 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9160 opts_type = OPTS_TYPE_PT_GENERATE_LE
9161 | OPTS_TYPE_PT_ADDBITS14;
9162 kern_type = KERN_TYPE_MD5_CHAP;
9163 dgst_size = DGST_SIZE_4_4;
9164 parse_func = chap_parse_hash;
9165 sort_by_digest = sort_by_digest_4_4;
9166 opti_type = OPTI_TYPE_ZERO_BYTE
9167 | OPTI_TYPE_PRECOMPUTE_INIT
9168 | OPTI_TYPE_PRECOMPUTE_MERKLE
9169 | OPTI_TYPE_MEET_IN_MIDDLE
9170 | OPTI_TYPE_EARLY_SKIP
9171 | OPTI_TYPE_NOT_ITERATED
9172 | OPTI_TYPE_RAW_HASH;
9173 dgst_pos0 = 0;
9174 dgst_pos1 = 3;
9175 dgst_pos2 = 2;
9176 dgst_pos3 = 1;
9177 break;
9178
9179 case 4900: hash_type = HASH_TYPE_SHA1;
9180 salt_type = SALT_TYPE_INTERN;
9181 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9182 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9183 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9184 dgst_size = DGST_SIZE_4_5;
9185 parse_func = sha1s_parse_hash;
9186 sort_by_digest = sort_by_digest_4_5;
9187 opti_type = OPTI_TYPE_ZERO_BYTE
9188 | OPTI_TYPE_PRECOMPUTE_INIT
9189 | OPTI_TYPE_PRECOMPUTE_MERKLE
9190 | OPTI_TYPE_EARLY_SKIP;
9191 dgst_pos0 = 3;
9192 dgst_pos1 = 4;
9193 dgst_pos2 = 2;
9194 dgst_pos3 = 1;
9195 break;
9196
9197 case 5000: hash_type = HASH_TYPE_KECCAK;
9198 salt_type = SALT_TYPE_EMBEDDED;
9199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9200 opts_type = OPTS_TYPE_PT_GENERATE_LE
9201 | OPTS_TYPE_PT_ADD01;
9202 kern_type = KERN_TYPE_KECCAK;
9203 dgst_size = DGST_SIZE_8_25;
9204 parse_func = keccak_parse_hash;
9205 sort_by_digest = sort_by_digest_8_25;
9206 opti_type = OPTI_TYPE_ZERO_BYTE
9207 | OPTI_TYPE_USES_BITS_64
9208 | OPTI_TYPE_RAW_HASH;
9209 dgst_pos0 = 2;
9210 dgst_pos1 = 3;
9211 dgst_pos2 = 4;
9212 dgst_pos3 = 5;
9213 break;
9214
9215 case 5100: hash_type = HASH_TYPE_MD5H;
9216 salt_type = SALT_TYPE_NONE;
9217 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9218 opts_type = OPTS_TYPE_PT_GENERATE_LE
9219 | OPTS_TYPE_PT_ADD80
9220 | OPTS_TYPE_PT_ADDBITS14;
9221 kern_type = KERN_TYPE_MD5H;
9222 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9223 parse_func = md5half_parse_hash;
9224 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9225 opti_type = OPTI_TYPE_ZERO_BYTE
9226 | OPTI_TYPE_RAW_HASH;
9227 dgst_pos0 = 0;
9228 dgst_pos1 = 1;
9229 dgst_pos2 = 2;
9230 dgst_pos3 = 3;
9231 break;
9232
9233 case 5200: hash_type = HASH_TYPE_SHA256;
9234 salt_type = SALT_TYPE_EMBEDDED;
9235 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9236 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9237 kern_type = KERN_TYPE_PSAFE3;
9238 dgst_size = DGST_SIZE_4_8;
9239 parse_func = psafe3_parse_hash;
9240 sort_by_digest = sort_by_digest_4_8;
9241 opti_type = OPTI_TYPE_ZERO_BYTE;
9242 dgst_pos0 = 0;
9243 dgst_pos1 = 1;
9244 dgst_pos2 = 2;
9245 dgst_pos3 = 3;
9246 break;
9247
9248 case 5300: hash_type = HASH_TYPE_MD5;
9249 salt_type = SALT_TYPE_EMBEDDED;
9250 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9251 opts_type = OPTS_TYPE_PT_GENERATE_LE
9252 | OPTS_TYPE_ST_ADD80;
9253 kern_type = KERN_TYPE_IKEPSK_MD5;
9254 dgst_size = DGST_SIZE_4_4;
9255 parse_func = ikepsk_md5_parse_hash;
9256 sort_by_digest = sort_by_digest_4_4;
9257 opti_type = OPTI_TYPE_ZERO_BYTE;
9258 dgst_pos0 = 0;
9259 dgst_pos1 = 3;
9260 dgst_pos2 = 2;
9261 dgst_pos3 = 1;
9262 break;
9263
9264 case 5400: hash_type = HASH_TYPE_SHA1;
9265 salt_type = SALT_TYPE_EMBEDDED;
9266 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9267 opts_type = OPTS_TYPE_PT_GENERATE_BE
9268 | OPTS_TYPE_ST_ADD80;
9269 kern_type = KERN_TYPE_IKEPSK_SHA1;
9270 dgst_size = DGST_SIZE_4_5;
9271 parse_func = ikepsk_sha1_parse_hash;
9272 sort_by_digest = sort_by_digest_4_5;
9273 opti_type = OPTI_TYPE_ZERO_BYTE;
9274 dgst_pos0 = 3;
9275 dgst_pos1 = 4;
9276 dgst_pos2 = 2;
9277 dgst_pos3 = 1;
9278 break;
9279
9280 case 5500: hash_type = HASH_TYPE_NETNTLM;
9281 salt_type = SALT_TYPE_EMBEDDED;
9282 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9283 opts_type = OPTS_TYPE_PT_GENERATE_LE
9284 | OPTS_TYPE_PT_ADD80
9285 | OPTS_TYPE_PT_ADDBITS14
9286 | OPTS_TYPE_PT_UNICODE
9287 | OPTS_TYPE_ST_HEX;
9288 kern_type = KERN_TYPE_NETNTLMv1;
9289 dgst_size = DGST_SIZE_4_4;
9290 parse_func = netntlmv1_parse_hash;
9291 sort_by_digest = sort_by_digest_4_4;
9292 opti_type = OPTI_TYPE_ZERO_BYTE
9293 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9294 dgst_pos0 = 0;
9295 dgst_pos1 = 1;
9296 dgst_pos2 = 2;
9297 dgst_pos3 = 3;
9298 break;
9299
9300 case 5600: hash_type = HASH_TYPE_MD5;
9301 salt_type = SALT_TYPE_EMBEDDED;
9302 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9303 opts_type = OPTS_TYPE_PT_GENERATE_LE
9304 | OPTS_TYPE_PT_ADD80
9305 | OPTS_TYPE_PT_ADDBITS14
9306 | OPTS_TYPE_PT_UNICODE;
9307 kern_type = KERN_TYPE_NETNTLMv2;
9308 dgst_size = DGST_SIZE_4_4;
9309 parse_func = netntlmv2_parse_hash;
9310 sort_by_digest = sort_by_digest_4_4;
9311 opti_type = OPTI_TYPE_ZERO_BYTE;
9312 dgst_pos0 = 0;
9313 dgst_pos1 = 3;
9314 dgst_pos2 = 2;
9315 dgst_pos3 = 1;
9316 break;
9317
9318 case 5700: hash_type = HASH_TYPE_SHA256;
9319 salt_type = SALT_TYPE_NONE;
9320 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9321 opts_type = OPTS_TYPE_PT_GENERATE_BE
9322 | OPTS_TYPE_PT_ADD80
9323 | OPTS_TYPE_PT_ADDBITS15;
9324 kern_type = KERN_TYPE_SHA256;
9325 dgst_size = DGST_SIZE_4_8;
9326 parse_func = cisco4_parse_hash;
9327 sort_by_digest = sort_by_digest_4_8;
9328 opti_type = OPTI_TYPE_ZERO_BYTE
9329 | OPTI_TYPE_PRECOMPUTE_INIT
9330 | OPTI_TYPE_PRECOMPUTE_MERKLE
9331 | OPTI_TYPE_EARLY_SKIP
9332 | OPTI_TYPE_NOT_ITERATED
9333 | OPTI_TYPE_NOT_SALTED
9334 | OPTI_TYPE_RAW_HASH;
9335 dgst_pos0 = 3;
9336 dgst_pos1 = 7;
9337 dgst_pos2 = 2;
9338 dgst_pos3 = 6;
9339 break;
9340
9341 case 5800: hash_type = HASH_TYPE_SHA1;
9342 salt_type = SALT_TYPE_INTERN;
9343 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9344 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9345 | OPTS_TYPE_ST_ADD80;
9346 kern_type = KERN_TYPE_ANDROIDPIN;
9347 dgst_size = DGST_SIZE_4_5;
9348 parse_func = androidpin_parse_hash;
9349 sort_by_digest = sort_by_digest_4_5;
9350 opti_type = OPTI_TYPE_ZERO_BYTE;
9351 dgst_pos0 = 0;
9352 dgst_pos1 = 1;
9353 dgst_pos2 = 2;
9354 dgst_pos3 = 3;
9355 break;
9356
9357 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9358 salt_type = SALT_TYPE_NONE;
9359 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9360 opts_type = OPTS_TYPE_PT_GENERATE_LE
9361 | OPTS_TYPE_PT_ADD80;
9362 kern_type = KERN_TYPE_RIPEMD160;
9363 dgst_size = DGST_SIZE_4_5;
9364 parse_func = ripemd160_parse_hash;
9365 sort_by_digest = sort_by_digest_4_5;
9366 opti_type = OPTI_TYPE_ZERO_BYTE;
9367 dgst_pos0 = 0;
9368 dgst_pos1 = 1;
9369 dgst_pos2 = 2;
9370 dgst_pos3 = 3;
9371 break;
9372
9373 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9374 salt_type = SALT_TYPE_NONE;
9375 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9376 opts_type = OPTS_TYPE_PT_GENERATE_BE
9377 | OPTS_TYPE_PT_ADD80;
9378 kern_type = KERN_TYPE_WHIRLPOOL;
9379 dgst_size = DGST_SIZE_4_16;
9380 parse_func = whirlpool_parse_hash;
9381 sort_by_digest = sort_by_digest_4_16;
9382 opti_type = OPTI_TYPE_ZERO_BYTE;
9383 dgst_pos0 = 0;
9384 dgst_pos1 = 1;
9385 dgst_pos2 = 2;
9386 dgst_pos3 = 3;
9387 break;
9388
9389 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9390 salt_type = SALT_TYPE_EMBEDDED;
9391 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9392 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9393 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9394 dgst_size = DGST_SIZE_4_5;
9395 parse_func = truecrypt_parse_hash_2k;
9396 sort_by_digest = sort_by_digest_4_5;
9397 opti_type = OPTI_TYPE_ZERO_BYTE;
9398 dgst_pos0 = 0;
9399 dgst_pos1 = 1;
9400 dgst_pos2 = 2;
9401 dgst_pos3 = 3;
9402 break;
9403
9404 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9405 salt_type = SALT_TYPE_EMBEDDED;
9406 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9407 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9408 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9409 dgst_size = DGST_SIZE_4_5;
9410 parse_func = truecrypt_parse_hash_2k;
9411 sort_by_digest = sort_by_digest_4_5;
9412 opti_type = OPTI_TYPE_ZERO_BYTE;
9413 dgst_pos0 = 0;
9414 dgst_pos1 = 1;
9415 dgst_pos2 = 2;
9416 dgst_pos3 = 3;
9417 break;
9418
9419 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9420 salt_type = SALT_TYPE_EMBEDDED;
9421 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9422 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9423 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9424 dgst_size = DGST_SIZE_4_5;
9425 parse_func = truecrypt_parse_hash_2k;
9426 sort_by_digest = sort_by_digest_4_5;
9427 opti_type = OPTI_TYPE_ZERO_BYTE;
9428 dgst_pos0 = 0;
9429 dgst_pos1 = 1;
9430 dgst_pos2 = 2;
9431 dgst_pos3 = 3;
9432 break;
9433
9434 case 6221: hash_type = HASH_TYPE_SHA512;
9435 salt_type = SALT_TYPE_EMBEDDED;
9436 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9437 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9438 kern_type = KERN_TYPE_TCSHA512_XTS512;
9439 dgst_size = DGST_SIZE_8_8;
9440 parse_func = truecrypt_parse_hash_1k;
9441 sort_by_digest = sort_by_digest_8_8;
9442 opti_type = OPTI_TYPE_ZERO_BYTE
9443 | OPTI_TYPE_USES_BITS_64;
9444 dgst_pos0 = 0;
9445 dgst_pos1 = 1;
9446 dgst_pos2 = 2;
9447 dgst_pos3 = 3;
9448 break;
9449
9450 case 6222: hash_type = HASH_TYPE_SHA512;
9451 salt_type = SALT_TYPE_EMBEDDED;
9452 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9453 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9454 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9455 dgst_size = DGST_SIZE_8_8;
9456 parse_func = truecrypt_parse_hash_1k;
9457 sort_by_digest = sort_by_digest_8_8;
9458 opti_type = OPTI_TYPE_ZERO_BYTE
9459 | OPTI_TYPE_USES_BITS_64;
9460 dgst_pos0 = 0;
9461 dgst_pos1 = 1;
9462 dgst_pos2 = 2;
9463 dgst_pos3 = 3;
9464 break;
9465
9466 case 6223: hash_type = HASH_TYPE_SHA512;
9467 salt_type = SALT_TYPE_EMBEDDED;
9468 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9469 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9470 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9471 dgst_size = DGST_SIZE_8_8;
9472 parse_func = truecrypt_parse_hash_1k;
9473 sort_by_digest = sort_by_digest_8_8;
9474 opti_type = OPTI_TYPE_ZERO_BYTE
9475 | OPTI_TYPE_USES_BITS_64;
9476 dgst_pos0 = 0;
9477 dgst_pos1 = 1;
9478 dgst_pos2 = 2;
9479 dgst_pos3 = 3;
9480 break;
9481
9482 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9483 salt_type = SALT_TYPE_EMBEDDED;
9484 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9485 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9486 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9487 dgst_size = DGST_SIZE_4_8;
9488 parse_func = truecrypt_parse_hash_1k;
9489 sort_by_digest = sort_by_digest_4_8;
9490 opti_type = OPTI_TYPE_ZERO_BYTE;
9491 dgst_pos0 = 0;
9492 dgst_pos1 = 1;
9493 dgst_pos2 = 2;
9494 dgst_pos3 = 3;
9495 break;
9496
9497 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9498 salt_type = SALT_TYPE_EMBEDDED;
9499 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9500 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9501 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9502 dgst_size = DGST_SIZE_4_8;
9503 parse_func = truecrypt_parse_hash_1k;
9504 sort_by_digest = sort_by_digest_4_8;
9505 opti_type = OPTI_TYPE_ZERO_BYTE;
9506 dgst_pos0 = 0;
9507 dgst_pos1 = 1;
9508 dgst_pos2 = 2;
9509 dgst_pos3 = 3;
9510 break;
9511
9512 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9513 salt_type = SALT_TYPE_EMBEDDED;
9514 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9515 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9516 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9517 dgst_size = DGST_SIZE_4_8;
9518 parse_func = truecrypt_parse_hash_1k;
9519 sort_by_digest = sort_by_digest_4_8;
9520 opti_type = OPTI_TYPE_ZERO_BYTE;
9521 dgst_pos0 = 0;
9522 dgst_pos1 = 1;
9523 dgst_pos2 = 2;
9524 dgst_pos3 = 3;
9525 break;
9526
9527 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9528 salt_type = SALT_TYPE_EMBEDDED;
9529 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9530 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9531 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9532 dgst_size = DGST_SIZE_4_5;
9533 parse_func = truecrypt_parse_hash_1k;
9534 sort_by_digest = sort_by_digest_4_5;
9535 opti_type = OPTI_TYPE_ZERO_BYTE;
9536 dgst_pos0 = 0;
9537 dgst_pos1 = 1;
9538 dgst_pos2 = 2;
9539 dgst_pos3 = 3;
9540 break;
9541
9542 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9543 salt_type = SALT_TYPE_EMBEDDED;
9544 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9545 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9546 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9547 dgst_size = DGST_SIZE_4_5;
9548 parse_func = truecrypt_parse_hash_1k;
9549 sort_by_digest = sort_by_digest_4_5;
9550 opti_type = OPTI_TYPE_ZERO_BYTE;
9551 dgst_pos0 = 0;
9552 dgst_pos1 = 1;
9553 dgst_pos2 = 2;
9554 dgst_pos3 = 3;
9555 break;
9556
9557 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9558 salt_type = SALT_TYPE_EMBEDDED;
9559 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9560 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9561 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9562 dgst_size = DGST_SIZE_4_5;
9563 parse_func = truecrypt_parse_hash_1k;
9564 sort_by_digest = sort_by_digest_4_5;
9565 opti_type = OPTI_TYPE_ZERO_BYTE;
9566 dgst_pos0 = 0;
9567 dgst_pos1 = 1;
9568 dgst_pos2 = 2;
9569 dgst_pos3 = 3;
9570 break;
9571
9572 case 6300: hash_type = HASH_TYPE_MD5;
9573 salt_type = SALT_TYPE_EMBEDDED;
9574 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9575 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9576 kern_type = KERN_TYPE_MD5AIX;
9577 dgst_size = DGST_SIZE_4_4;
9578 parse_func = md5aix_parse_hash;
9579 sort_by_digest = sort_by_digest_4_4;
9580 opti_type = OPTI_TYPE_ZERO_BYTE;
9581 dgst_pos0 = 0;
9582 dgst_pos1 = 1;
9583 dgst_pos2 = 2;
9584 dgst_pos3 = 3;
9585 break;
9586
9587 case 6400: hash_type = HASH_TYPE_SHA256;
9588 salt_type = SALT_TYPE_EMBEDDED;
9589 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9590 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9591 kern_type = KERN_TYPE_SHA256AIX;
9592 dgst_size = DGST_SIZE_4_8;
9593 parse_func = sha256aix_parse_hash;
9594 sort_by_digest = sort_by_digest_4_8;
9595 opti_type = OPTI_TYPE_ZERO_BYTE;
9596 dgst_pos0 = 0;
9597 dgst_pos1 = 1;
9598 dgst_pos2 = 2;
9599 dgst_pos3 = 3;
9600 break;
9601
9602 case 6500: hash_type = HASH_TYPE_SHA512;
9603 salt_type = SALT_TYPE_EMBEDDED;
9604 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9605 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9606 kern_type = KERN_TYPE_SHA512AIX;
9607 dgst_size = DGST_SIZE_8_8;
9608 parse_func = sha512aix_parse_hash;
9609 sort_by_digest = sort_by_digest_8_8;
9610 opti_type = OPTI_TYPE_ZERO_BYTE
9611 | OPTI_TYPE_USES_BITS_64;
9612 dgst_pos0 = 0;
9613 dgst_pos1 = 1;
9614 dgst_pos2 = 2;
9615 dgst_pos3 = 3;
9616 break;
9617
9618 case 6600: hash_type = HASH_TYPE_AES;
9619 salt_type = SALT_TYPE_EMBEDDED;
9620 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9621 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9622 kern_type = KERN_TYPE_AGILEKEY;
9623 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9624 parse_func = agilekey_parse_hash;
9625 sort_by_digest = sort_by_digest_4_5;
9626 opti_type = OPTI_TYPE_ZERO_BYTE;
9627 dgst_pos0 = 0;
9628 dgst_pos1 = 1;
9629 dgst_pos2 = 2;
9630 dgst_pos3 = 3;
9631 break;
9632
9633 case 6700: hash_type = HASH_TYPE_SHA1;
9634 salt_type = SALT_TYPE_EMBEDDED;
9635 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9636 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9637 kern_type = KERN_TYPE_SHA1AIX;
9638 dgst_size = DGST_SIZE_4_5;
9639 parse_func = sha1aix_parse_hash;
9640 sort_by_digest = sort_by_digest_4_5;
9641 opti_type = OPTI_TYPE_ZERO_BYTE;
9642 dgst_pos0 = 0;
9643 dgst_pos1 = 1;
9644 dgst_pos2 = 2;
9645 dgst_pos3 = 3;
9646 break;
9647
9648 case 6800: hash_type = HASH_TYPE_AES;
9649 salt_type = SALT_TYPE_EMBEDDED;
9650 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9651 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9652 kern_type = KERN_TYPE_LASTPASS;
9653 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9654 parse_func = lastpass_parse_hash;
9655 sort_by_digest = sort_by_digest_4_8;
9656 opti_type = OPTI_TYPE_ZERO_BYTE;
9657 dgst_pos0 = 0;
9658 dgst_pos1 = 1;
9659 dgst_pos2 = 2;
9660 dgst_pos3 = 3;
9661 break;
9662
9663 case 6900: hash_type = HASH_TYPE_GOST;
9664 salt_type = SALT_TYPE_NONE;
9665 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9666 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9667 kern_type = KERN_TYPE_GOST;
9668 dgst_size = DGST_SIZE_4_8;
9669 parse_func = gost_parse_hash;
9670 sort_by_digest = sort_by_digest_4_8;
9671 opti_type = OPTI_TYPE_ZERO_BYTE;
9672 dgst_pos0 = 0;
9673 dgst_pos1 = 1;
9674 dgst_pos2 = 2;
9675 dgst_pos3 = 3;
9676 break;
9677
9678 case 7100: hash_type = HASH_TYPE_SHA512;
9679 salt_type = SALT_TYPE_EMBEDDED;
9680 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9681 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9682 kern_type = KERN_TYPE_PBKDF2_SHA512;
9683 dgst_size = DGST_SIZE_8_16;
9684 parse_func = sha512osx_parse_hash;
9685 sort_by_digest = sort_by_digest_8_16;
9686 opti_type = OPTI_TYPE_ZERO_BYTE
9687 | OPTI_TYPE_USES_BITS_64
9688 | OPTI_TYPE_SLOW_HASH_SIMD;
9689 dgst_pos0 = 0;
9690 dgst_pos1 = 1;
9691 dgst_pos2 = 2;
9692 dgst_pos3 = 3;
9693 break;
9694
9695 case 7200: hash_type = HASH_TYPE_SHA512;
9696 salt_type = SALT_TYPE_EMBEDDED;
9697 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9698 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9699 kern_type = KERN_TYPE_PBKDF2_SHA512;
9700 dgst_size = DGST_SIZE_8_16;
9701 parse_func = sha512grub_parse_hash;
9702 sort_by_digest = sort_by_digest_8_16;
9703 opti_type = OPTI_TYPE_ZERO_BYTE
9704 | OPTI_TYPE_USES_BITS_64
9705 | OPTI_TYPE_SLOW_HASH_SIMD;
9706 dgst_pos0 = 0;
9707 dgst_pos1 = 1;
9708 dgst_pos2 = 2;
9709 dgst_pos3 = 3;
9710 break;
9711
9712 case 7300: hash_type = HASH_TYPE_SHA1;
9713 salt_type = SALT_TYPE_EMBEDDED;
9714 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9715 opts_type = OPTS_TYPE_PT_GENERATE_BE
9716 | OPTS_TYPE_ST_ADD80
9717 | OPTS_TYPE_ST_ADDBITS15;
9718 kern_type = KERN_TYPE_RAKP;
9719 dgst_size = DGST_SIZE_4_5;
9720 parse_func = rakp_parse_hash;
9721 sort_by_digest = sort_by_digest_4_5;
9722 opti_type = OPTI_TYPE_ZERO_BYTE
9723 | OPTI_TYPE_NOT_ITERATED;
9724 dgst_pos0 = 3;
9725 dgst_pos1 = 4;
9726 dgst_pos2 = 2;
9727 dgst_pos3 = 1;
9728 break;
9729
9730 case 7400: hash_type = HASH_TYPE_SHA256;
9731 salt_type = SALT_TYPE_EMBEDDED;
9732 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9733 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9734 kern_type = KERN_TYPE_SHA256CRYPT;
9735 dgst_size = DGST_SIZE_4_8;
9736 parse_func = sha256crypt_parse_hash;
9737 sort_by_digest = sort_by_digest_4_8;
9738 opti_type = OPTI_TYPE_ZERO_BYTE;
9739 dgst_pos0 = 0;
9740 dgst_pos1 = 1;
9741 dgst_pos2 = 2;
9742 dgst_pos3 = 3;
9743 break;
9744
9745 case 7500: hash_type = HASH_TYPE_KRB5PA;
9746 salt_type = SALT_TYPE_EMBEDDED;
9747 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9748 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9749 kern_type = KERN_TYPE_KRB5PA;
9750 dgst_size = DGST_SIZE_4_4;
9751 parse_func = krb5pa_parse_hash;
9752 sort_by_digest = sort_by_digest_4_4;
9753 opti_type = OPTI_TYPE_ZERO_BYTE
9754 | OPTI_TYPE_NOT_ITERATED;
9755 dgst_pos0 = 0;
9756 dgst_pos1 = 1;
9757 dgst_pos2 = 2;
9758 dgst_pos3 = 3;
9759 break;
9760
9761 case 7600: hash_type = HASH_TYPE_SHA1;
9762 salt_type = SALT_TYPE_INTERN;
9763 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9764 opts_type = OPTS_TYPE_PT_GENERATE_BE
9765 | OPTS_TYPE_PT_ADD80
9766 | OPTS_TYPE_PT_ADDBITS15;
9767 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9768 dgst_size = DGST_SIZE_4_5;
9769 parse_func = redmine_parse_hash;
9770 sort_by_digest = sort_by_digest_4_5;
9771 opti_type = OPTI_TYPE_ZERO_BYTE
9772 | OPTI_TYPE_PRECOMPUTE_INIT
9773 | OPTI_TYPE_EARLY_SKIP
9774 | OPTI_TYPE_NOT_ITERATED
9775 | OPTI_TYPE_PREPENDED_SALT;
9776 dgst_pos0 = 3;
9777 dgst_pos1 = 4;
9778 dgst_pos2 = 2;
9779 dgst_pos3 = 1;
9780 break;
9781
9782 case 7700: hash_type = HASH_TYPE_SAPB;
9783 salt_type = SALT_TYPE_EMBEDDED;
9784 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9785 opts_type = OPTS_TYPE_PT_GENERATE_LE
9786 | OPTS_TYPE_PT_UPPER
9787 | OPTS_TYPE_ST_UPPER;
9788 kern_type = KERN_TYPE_SAPB;
9789 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9790 parse_func = sapb_parse_hash;
9791 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9792 opti_type = OPTI_TYPE_ZERO_BYTE
9793 | OPTI_TYPE_PRECOMPUTE_INIT
9794 | OPTI_TYPE_NOT_ITERATED;
9795 dgst_pos0 = 0;
9796 dgst_pos1 = 1;
9797 dgst_pos2 = 2;
9798 dgst_pos3 = 3;
9799 break;
9800
9801 case 7800: hash_type = HASH_TYPE_SAPG;
9802 salt_type = SALT_TYPE_EMBEDDED;
9803 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9804 opts_type = OPTS_TYPE_PT_GENERATE_BE
9805 | OPTS_TYPE_ST_ADD80
9806 | OPTS_TYPE_ST_UPPER;
9807 kern_type = KERN_TYPE_SAPG;
9808 dgst_size = DGST_SIZE_4_5;
9809 parse_func = sapg_parse_hash;
9810 sort_by_digest = sort_by_digest_4_5;
9811 opti_type = OPTI_TYPE_ZERO_BYTE
9812 | OPTI_TYPE_PRECOMPUTE_INIT
9813 | OPTI_TYPE_NOT_ITERATED;
9814 dgst_pos0 = 3;
9815 dgst_pos1 = 4;
9816 dgst_pos2 = 2;
9817 dgst_pos3 = 1;
9818 break;
9819
9820 case 7900: hash_type = HASH_TYPE_SHA512;
9821 salt_type = SALT_TYPE_EMBEDDED;
9822 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9823 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9824 kern_type = KERN_TYPE_DRUPAL7;
9825 dgst_size = DGST_SIZE_8_8;
9826 parse_func = drupal7_parse_hash;
9827 sort_by_digest = sort_by_digest_8_8;
9828 opti_type = OPTI_TYPE_ZERO_BYTE
9829 | OPTI_TYPE_USES_BITS_64;
9830 dgst_pos0 = 0;
9831 dgst_pos1 = 1;
9832 dgst_pos2 = 2;
9833 dgst_pos3 = 3;
9834 break;
9835
9836 case 8000: hash_type = HASH_TYPE_SHA256;
9837 salt_type = SALT_TYPE_EMBEDDED;
9838 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9839 opts_type = OPTS_TYPE_PT_GENERATE_BE
9840 | OPTS_TYPE_PT_UNICODE
9841 | OPTS_TYPE_ST_ADD80
9842 | OPTS_TYPE_ST_HEX;
9843 kern_type = KERN_TYPE_SYBASEASE;
9844 dgst_size = DGST_SIZE_4_8;
9845 parse_func = sybasease_parse_hash;
9846 sort_by_digest = sort_by_digest_4_8;
9847 opti_type = OPTI_TYPE_ZERO_BYTE
9848 | OPTI_TYPE_PRECOMPUTE_INIT
9849 | OPTI_TYPE_EARLY_SKIP
9850 | OPTI_TYPE_NOT_ITERATED
9851 | OPTI_TYPE_RAW_HASH;
9852 dgst_pos0 = 3;
9853 dgst_pos1 = 7;
9854 dgst_pos2 = 2;
9855 dgst_pos3 = 6;
9856 break;
9857
9858 case 8100: hash_type = HASH_TYPE_SHA1;
9859 salt_type = SALT_TYPE_EMBEDDED;
9860 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9861 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9862 kern_type = KERN_TYPE_NETSCALER;
9863 dgst_size = DGST_SIZE_4_5;
9864 parse_func = netscaler_parse_hash;
9865 sort_by_digest = sort_by_digest_4_5;
9866 opti_type = OPTI_TYPE_ZERO_BYTE
9867 | OPTI_TYPE_PRECOMPUTE_INIT
9868 | OPTI_TYPE_PRECOMPUTE_MERKLE
9869 | OPTI_TYPE_EARLY_SKIP
9870 | OPTI_TYPE_NOT_ITERATED
9871 | OPTI_TYPE_PREPENDED_SALT
9872 | OPTI_TYPE_RAW_HASH;
9873 dgst_pos0 = 3;
9874 dgst_pos1 = 4;
9875 dgst_pos2 = 2;
9876 dgst_pos3 = 1;
9877 break;
9878
9879 case 8200: hash_type = HASH_TYPE_SHA256;
9880 salt_type = SALT_TYPE_EMBEDDED;
9881 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9882 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9883 kern_type = KERN_TYPE_CLOUDKEY;
9884 dgst_size = DGST_SIZE_4_8;
9885 parse_func = cloudkey_parse_hash;
9886 sort_by_digest = sort_by_digest_4_8;
9887 opti_type = OPTI_TYPE_ZERO_BYTE;
9888 dgst_pos0 = 0;
9889 dgst_pos1 = 1;
9890 dgst_pos2 = 2;
9891 dgst_pos3 = 3;
9892 break;
9893
9894 case 8300: hash_type = HASH_TYPE_SHA1;
9895 salt_type = SALT_TYPE_EMBEDDED;
9896 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9897 opts_type = OPTS_TYPE_PT_GENERATE_BE
9898 | OPTS_TYPE_ST_HEX
9899 | OPTS_TYPE_ST_ADD80;
9900 kern_type = KERN_TYPE_NSEC3;
9901 dgst_size = DGST_SIZE_4_5;
9902 parse_func = nsec3_parse_hash;
9903 sort_by_digest = sort_by_digest_4_5;
9904 opti_type = OPTI_TYPE_ZERO_BYTE;
9905 dgst_pos0 = 3;
9906 dgst_pos1 = 4;
9907 dgst_pos2 = 2;
9908 dgst_pos3 = 1;
9909 break;
9910
9911 case 8400: hash_type = HASH_TYPE_SHA1;
9912 salt_type = SALT_TYPE_INTERN;
9913 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9914 opts_type = OPTS_TYPE_PT_GENERATE_BE
9915 | OPTS_TYPE_PT_ADD80
9916 | OPTS_TYPE_PT_ADDBITS15;
9917 kern_type = KERN_TYPE_WBB3;
9918 dgst_size = DGST_SIZE_4_5;
9919 parse_func = wbb3_parse_hash;
9920 sort_by_digest = sort_by_digest_4_5;
9921 opti_type = OPTI_TYPE_ZERO_BYTE
9922 | OPTI_TYPE_PRECOMPUTE_INIT
9923 | OPTI_TYPE_NOT_ITERATED;
9924 dgst_pos0 = 3;
9925 dgst_pos1 = 4;
9926 dgst_pos2 = 2;
9927 dgst_pos3 = 1;
9928 break;
9929
9930 case 8500: hash_type = HASH_TYPE_DESRACF;
9931 salt_type = SALT_TYPE_EMBEDDED;
9932 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9933 opts_type = OPTS_TYPE_PT_GENERATE_LE
9934 | OPTS_TYPE_ST_UPPER;
9935 kern_type = KERN_TYPE_RACF;
9936 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9937 parse_func = racf_parse_hash;
9938 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9939 opti_type = OPTI_TYPE_ZERO_BYTE
9940 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9941 dgst_pos0 = 0;
9942 dgst_pos1 = 1;
9943 dgst_pos2 = 2;
9944 dgst_pos3 = 3;
9945 break;
9946
9947 case 8600: hash_type = HASH_TYPE_LOTUS5;
9948 salt_type = SALT_TYPE_NONE;
9949 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9950 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9951 kern_type = KERN_TYPE_LOTUS5;
9952 dgst_size = DGST_SIZE_4_4;
9953 parse_func = lotus5_parse_hash;
9954 sort_by_digest = sort_by_digest_4_4;
9955 opti_type = OPTI_TYPE_EARLY_SKIP
9956 | OPTI_TYPE_NOT_ITERATED
9957 | OPTI_TYPE_NOT_SALTED
9958 | OPTI_TYPE_RAW_HASH;
9959 dgst_pos0 = 0;
9960 dgst_pos1 = 1;
9961 dgst_pos2 = 2;
9962 dgst_pos3 = 3;
9963 break;
9964
9965 case 8700: hash_type = HASH_TYPE_LOTUS6;
9966 salt_type = SALT_TYPE_EMBEDDED;
9967 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9968 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9969 kern_type = KERN_TYPE_LOTUS6;
9970 dgst_size = DGST_SIZE_4_4;
9971 parse_func = lotus6_parse_hash;
9972 sort_by_digest = sort_by_digest_4_4;
9973 opti_type = OPTI_TYPE_EARLY_SKIP
9974 | OPTI_TYPE_NOT_ITERATED
9975 | OPTI_TYPE_RAW_HASH;
9976 dgst_pos0 = 0;
9977 dgst_pos1 = 1;
9978 dgst_pos2 = 2;
9979 dgst_pos3 = 3;
9980 break;
9981
9982 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9983 salt_type = SALT_TYPE_EMBEDDED;
9984 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9985 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9986 kern_type = KERN_TYPE_ANDROIDFDE;
9987 dgst_size = DGST_SIZE_4_4;
9988 parse_func = androidfde_parse_hash;
9989 sort_by_digest = sort_by_digest_4_4;
9990 opti_type = OPTI_TYPE_ZERO_BYTE;
9991 dgst_pos0 = 0;
9992 dgst_pos1 = 1;
9993 dgst_pos2 = 2;
9994 dgst_pos3 = 3;
9995 break;
9996
9997 case 8900: hash_type = HASH_TYPE_SCRYPT;
9998 salt_type = SALT_TYPE_EMBEDDED;
9999 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10000 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10001 kern_type = KERN_TYPE_SCRYPT;
10002 dgst_size = DGST_SIZE_4_8;
10003 parse_func = scrypt_parse_hash;
10004 sort_by_digest = sort_by_digest_4_8;
10005 opti_type = OPTI_TYPE_ZERO_BYTE;
10006 dgst_pos0 = 0;
10007 dgst_pos1 = 1;
10008 dgst_pos2 = 2;
10009 dgst_pos3 = 3;
10010 break;
10011
10012 case 9000: hash_type = HASH_TYPE_SHA1;
10013 salt_type = SALT_TYPE_EMBEDDED;
10014 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10015 opts_type = OPTS_TYPE_PT_GENERATE_LE
10016 | OPTS_TYPE_ST_GENERATE_LE;
10017 kern_type = KERN_TYPE_PSAFE2;
10018 dgst_size = DGST_SIZE_4_5;
10019 parse_func = psafe2_parse_hash;
10020 sort_by_digest = sort_by_digest_4_5;
10021 opti_type = OPTI_TYPE_ZERO_BYTE;
10022 dgst_pos0 = 0;
10023 dgst_pos1 = 1;
10024 dgst_pos2 = 2;
10025 dgst_pos3 = 3;
10026 break;
10027
10028 case 9100: hash_type = HASH_TYPE_LOTUS8;
10029 salt_type = SALT_TYPE_EMBEDDED;
10030 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10031 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10032 kern_type = KERN_TYPE_LOTUS8;
10033 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10034 parse_func = lotus8_parse_hash;
10035 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10036 opti_type = OPTI_TYPE_ZERO_BYTE;
10037 dgst_pos0 = 0;
10038 dgst_pos1 = 1;
10039 dgst_pos2 = 2;
10040 dgst_pos3 = 3;
10041 break;
10042
10043 case 9200: hash_type = HASH_TYPE_SHA256;
10044 salt_type = SALT_TYPE_EMBEDDED;
10045 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10046 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10047 kern_type = KERN_TYPE_PBKDF2_SHA256;
10048 dgst_size = DGST_SIZE_4_32;
10049 parse_func = cisco8_parse_hash;
10050 sort_by_digest = sort_by_digest_4_32;
10051 opti_type = OPTI_TYPE_ZERO_BYTE
10052 | OPTI_TYPE_SLOW_HASH_SIMD;
10053 dgst_pos0 = 0;
10054 dgst_pos1 = 1;
10055 dgst_pos2 = 2;
10056 dgst_pos3 = 3;
10057 break;
10058
10059 case 9300: hash_type = HASH_TYPE_SCRYPT;
10060 salt_type = SALT_TYPE_EMBEDDED;
10061 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10062 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10063 kern_type = KERN_TYPE_SCRYPT;
10064 dgst_size = DGST_SIZE_4_8;
10065 parse_func = cisco9_parse_hash;
10066 sort_by_digest = sort_by_digest_4_8;
10067 opti_type = OPTI_TYPE_ZERO_BYTE;
10068 dgst_pos0 = 0;
10069 dgst_pos1 = 1;
10070 dgst_pos2 = 2;
10071 dgst_pos3 = 3;
10072 break;
10073
10074 case 9400: hash_type = HASH_TYPE_OFFICE2007;
10075 salt_type = SALT_TYPE_EMBEDDED;
10076 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10077 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10078 kern_type = KERN_TYPE_OFFICE2007;
10079 dgst_size = DGST_SIZE_4_4;
10080 parse_func = office2007_parse_hash;
10081 sort_by_digest = sort_by_digest_4_4;
10082 opti_type = OPTI_TYPE_ZERO_BYTE;
10083 dgst_pos0 = 0;
10084 dgst_pos1 = 1;
10085 dgst_pos2 = 2;
10086 dgst_pos3 = 3;
10087 break;
10088
10089 case 9500: hash_type = HASH_TYPE_OFFICE2010;
10090 salt_type = SALT_TYPE_EMBEDDED;
10091 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10092 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10093 kern_type = KERN_TYPE_OFFICE2010;
10094 dgst_size = DGST_SIZE_4_4;
10095 parse_func = office2010_parse_hash;
10096 sort_by_digest = sort_by_digest_4_4;
10097 opti_type = OPTI_TYPE_ZERO_BYTE;
10098 dgst_pos0 = 0;
10099 dgst_pos1 = 1;
10100 dgst_pos2 = 2;
10101 dgst_pos3 = 3;
10102 break;
10103
10104 case 9600: hash_type = HASH_TYPE_OFFICE2013;
10105 salt_type = SALT_TYPE_EMBEDDED;
10106 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10107 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10108 kern_type = KERN_TYPE_OFFICE2013;
10109 dgst_size = DGST_SIZE_4_4;
10110 parse_func = office2013_parse_hash;
10111 sort_by_digest = sort_by_digest_4_4;
10112 opti_type = OPTI_TYPE_ZERO_BYTE;
10113 dgst_pos0 = 0;
10114 dgst_pos1 = 1;
10115 dgst_pos2 = 2;
10116 dgst_pos3 = 3;
10117 break;
10118
10119 case 9700: 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 | OPTS_TYPE_PT_UNICODE;
10125 kern_type = KERN_TYPE_OLDOFFICE01;
10126 dgst_size = DGST_SIZE_4_4;
10127 parse_func = oldoffice01_parse_hash;
10128 sort_by_digest = sort_by_digest_4_4;
10129 opti_type = OPTI_TYPE_ZERO_BYTE
10130 | OPTI_TYPE_PRECOMPUTE_INIT
10131 | OPTI_TYPE_NOT_ITERATED;
10132 dgst_pos0 = 0;
10133 dgst_pos1 = 1;
10134 dgst_pos2 = 2;
10135 dgst_pos3 = 3;
10136 break;
10137
10138 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
10139 salt_type = SALT_TYPE_EMBEDDED;
10140 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10141 opts_type = OPTS_TYPE_PT_GENERATE_LE
10142 | OPTS_TYPE_PT_ADD80;
10143 kern_type = KERN_TYPE_OLDOFFICE01CM1;
10144 dgst_size = DGST_SIZE_4_4;
10145 parse_func = oldoffice01cm1_parse_hash;
10146 sort_by_digest = sort_by_digest_4_4;
10147 opti_type = OPTI_TYPE_ZERO_BYTE
10148 | OPTI_TYPE_PRECOMPUTE_INIT
10149 | OPTI_TYPE_NOT_ITERATED;
10150 dgst_pos0 = 0;
10151 dgst_pos1 = 1;
10152 dgst_pos2 = 2;
10153 dgst_pos3 = 3;
10154 break;
10155
10156 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
10157 salt_type = SALT_TYPE_EMBEDDED;
10158 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10159 opts_type = OPTS_TYPE_PT_GENERATE_LE
10160 | OPTS_TYPE_PT_ADD80
10161 | OPTS_TYPE_PT_UNICODE
10162 | OPTS_TYPE_PT_NEVERCRACK;
10163 kern_type = KERN_TYPE_OLDOFFICE01CM2;
10164 dgst_size = DGST_SIZE_4_4;
10165 parse_func = oldoffice01cm2_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 9800: 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_BE
10180 | OPTS_TYPE_PT_ADD80
10181 | OPTS_TYPE_PT_UNICODE;
10182 kern_type = KERN_TYPE_OLDOFFICE34;
10183 dgst_size = DGST_SIZE_4_4;
10184 parse_func = oldoffice34_parse_hash;
10185 sort_by_digest = sort_by_digest_4_4;
10186 opti_type = OPTI_TYPE_ZERO_BYTE
10187 | OPTI_TYPE_PRECOMPUTE_INIT
10188 | OPTI_TYPE_NOT_ITERATED;
10189 dgst_pos0 = 0;
10190 dgst_pos1 = 1;
10191 dgst_pos2 = 2;
10192 dgst_pos3 = 3;
10193 break;
10194
10195 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10196 salt_type = SALT_TYPE_EMBEDDED;
10197 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10198 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10199 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10200 dgst_size = DGST_SIZE_4_4;
10201 parse_func = oldoffice34cm1_parse_hash;
10202 sort_by_digest = sort_by_digest_4_4;
10203 opti_type = OPTI_TYPE_ZERO_BYTE
10204 | OPTI_TYPE_PRECOMPUTE_INIT
10205 | OPTI_TYPE_NOT_ITERATED;
10206 dgst_pos0 = 0;
10207 dgst_pos1 = 1;
10208 dgst_pos2 = 2;
10209 dgst_pos3 = 3;
10210 break;
10211
10212 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10213 salt_type = SALT_TYPE_EMBEDDED;
10214 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10215 opts_type = OPTS_TYPE_PT_GENERATE_BE
10216 | OPTS_TYPE_PT_ADD80
10217 | OPTS_TYPE_PT_UNICODE
10218 | OPTS_TYPE_PT_NEVERCRACK;
10219 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10220 dgst_size = DGST_SIZE_4_4;
10221 parse_func = oldoffice34cm2_parse_hash;
10222 sort_by_digest = sort_by_digest_4_4;
10223 opti_type = OPTI_TYPE_ZERO_BYTE
10224 | OPTI_TYPE_PRECOMPUTE_INIT
10225 | OPTI_TYPE_NOT_ITERATED;
10226 dgst_pos0 = 0;
10227 dgst_pos1 = 1;
10228 dgst_pos2 = 2;
10229 dgst_pos3 = 3;
10230 break;
10231
10232 case 9900: hash_type = HASH_TYPE_MD5;
10233 salt_type = SALT_TYPE_NONE;
10234 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10235 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10236 kern_type = KERN_TYPE_RADMIN2;
10237 dgst_size = DGST_SIZE_4_4;
10238 parse_func = radmin2_parse_hash;
10239 sort_by_digest = sort_by_digest_4_4;
10240 opti_type = OPTI_TYPE_ZERO_BYTE
10241 | OPTI_TYPE_PRECOMPUTE_INIT
10242 | OPTI_TYPE_EARLY_SKIP
10243 | OPTI_TYPE_NOT_ITERATED
10244 | OPTI_TYPE_NOT_SALTED;
10245 dgst_pos0 = 0;
10246 dgst_pos1 = 3;
10247 dgst_pos2 = 2;
10248 dgst_pos3 = 1;
10249 break;
10250
10251 case 10000: hash_type = HASH_TYPE_SHA256;
10252 salt_type = SALT_TYPE_EMBEDDED;
10253 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10254 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10255 kern_type = KERN_TYPE_PBKDF2_SHA256;
10256 dgst_size = DGST_SIZE_4_32;
10257 parse_func = djangopbkdf2_parse_hash;
10258 sort_by_digest = sort_by_digest_4_32;
10259 opti_type = OPTI_TYPE_ZERO_BYTE
10260 | OPTI_TYPE_SLOW_HASH_SIMD;
10261 dgst_pos0 = 0;
10262 dgst_pos1 = 1;
10263 dgst_pos2 = 2;
10264 dgst_pos3 = 3;
10265 break;
10266
10267 case 10100: hash_type = HASH_TYPE_SIPHASH;
10268 salt_type = SALT_TYPE_EMBEDDED;
10269 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10270 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10271 kern_type = KERN_TYPE_SIPHASH;
10272 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10273 parse_func = siphash_parse_hash;
10274 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10275 opti_type = OPTI_TYPE_ZERO_BYTE
10276 | OPTI_TYPE_NOT_ITERATED
10277 | OPTI_TYPE_RAW_HASH;
10278 dgst_pos0 = 0;
10279 dgst_pos1 = 1;
10280 dgst_pos2 = 2;
10281 dgst_pos3 = 3;
10282 break;
10283
10284 case 10200: hash_type = HASH_TYPE_MD5;
10285 salt_type = SALT_TYPE_EMBEDDED;
10286 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10287 opts_type = OPTS_TYPE_PT_GENERATE_LE
10288 | OPTS_TYPE_ST_ADD80
10289 | OPTS_TYPE_ST_ADDBITS14;
10290 kern_type = KERN_TYPE_HMACMD5_PW;
10291 dgst_size = DGST_SIZE_4_4;
10292 parse_func = crammd5_parse_hash;
10293 sort_by_digest = sort_by_digest_4_4;
10294 opti_type = OPTI_TYPE_ZERO_BYTE
10295 | OPTI_TYPE_NOT_ITERATED;
10296 dgst_pos0 = 0;
10297 dgst_pos1 = 3;
10298 dgst_pos2 = 2;
10299 dgst_pos3 = 1;
10300 break;
10301
10302 case 10300: hash_type = HASH_TYPE_SHA1;
10303 salt_type = SALT_TYPE_EMBEDDED;
10304 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10305 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10306 kern_type = KERN_TYPE_SAPH_SHA1;
10307 dgst_size = DGST_SIZE_4_5;
10308 parse_func = saph_sha1_parse_hash;
10309 sort_by_digest = sort_by_digest_4_5;
10310 opti_type = OPTI_TYPE_ZERO_BYTE;
10311 dgst_pos0 = 0;
10312 dgst_pos1 = 1;
10313 dgst_pos2 = 2;
10314 dgst_pos3 = 3;
10315 break;
10316
10317 case 10400: hash_type = HASH_TYPE_PDFU16;
10318 salt_type = SALT_TYPE_EMBEDDED;
10319 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10320 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10321 kern_type = KERN_TYPE_PDF11;
10322 dgst_size = DGST_SIZE_4_4;
10323 parse_func = pdf11_parse_hash;
10324 sort_by_digest = sort_by_digest_4_4;
10325 opti_type = OPTI_TYPE_ZERO_BYTE
10326 | OPTI_TYPE_NOT_ITERATED;
10327 dgst_pos0 = 0;
10328 dgst_pos1 = 1;
10329 dgst_pos2 = 2;
10330 dgst_pos3 = 3;
10331 break;
10332
10333 case 10410: hash_type = HASH_TYPE_PDFU16;
10334 salt_type = SALT_TYPE_EMBEDDED;
10335 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10336 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10337 kern_type = KERN_TYPE_PDF11CM1;
10338 dgst_size = DGST_SIZE_4_4;
10339 parse_func = pdf11cm1_parse_hash;
10340 sort_by_digest = sort_by_digest_4_4;
10341 opti_type = OPTI_TYPE_ZERO_BYTE
10342 | OPTI_TYPE_NOT_ITERATED;
10343 dgst_pos0 = 0;
10344 dgst_pos1 = 1;
10345 dgst_pos2 = 2;
10346 dgst_pos3 = 3;
10347 break;
10348
10349 case 10420: hash_type = HASH_TYPE_PDFU16;
10350 salt_type = SALT_TYPE_EMBEDDED;
10351 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10352 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10353 kern_type = KERN_TYPE_PDF11CM2;
10354 dgst_size = DGST_SIZE_4_4;
10355 parse_func = pdf11cm2_parse_hash;
10356 sort_by_digest = sort_by_digest_4_4;
10357 opti_type = OPTI_TYPE_ZERO_BYTE
10358 | OPTI_TYPE_NOT_ITERATED;
10359 dgst_pos0 = 0;
10360 dgst_pos1 = 1;
10361 dgst_pos2 = 2;
10362 dgst_pos3 = 3;
10363 break;
10364
10365 case 10500: hash_type = HASH_TYPE_PDFU16;
10366 salt_type = SALT_TYPE_EMBEDDED;
10367 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10368 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10369 kern_type = KERN_TYPE_PDF14;
10370 dgst_size = DGST_SIZE_4_4;
10371 parse_func = pdf14_parse_hash;
10372 sort_by_digest = sort_by_digest_4_4;
10373 opti_type = OPTI_TYPE_ZERO_BYTE
10374 | OPTI_TYPE_NOT_ITERATED;
10375 dgst_pos0 = 0;
10376 dgst_pos1 = 1;
10377 dgst_pos2 = 2;
10378 dgst_pos3 = 3;
10379 break;
10380
10381 case 10600: hash_type = HASH_TYPE_SHA256;
10382 salt_type = SALT_TYPE_EMBEDDED;
10383 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10384 opts_type = OPTS_TYPE_PT_GENERATE_BE
10385 | OPTS_TYPE_ST_ADD80
10386 | OPTS_TYPE_ST_ADDBITS15
10387 | OPTS_TYPE_HASH_COPY;
10388 kern_type = KERN_TYPE_SHA256_PWSLT;
10389 dgst_size = DGST_SIZE_4_8;
10390 parse_func = pdf17l3_parse_hash;
10391 sort_by_digest = sort_by_digest_4_8;
10392 opti_type = OPTI_TYPE_ZERO_BYTE
10393 | OPTI_TYPE_PRECOMPUTE_INIT
10394 | OPTI_TYPE_PRECOMPUTE_MERKLE
10395 | OPTI_TYPE_EARLY_SKIP
10396 | OPTI_TYPE_NOT_ITERATED
10397 | OPTI_TYPE_APPENDED_SALT
10398 | OPTI_TYPE_RAW_HASH;
10399 dgst_pos0 = 3;
10400 dgst_pos1 = 7;
10401 dgst_pos2 = 2;
10402 dgst_pos3 = 6;
10403 break;
10404
10405 case 10700: hash_type = HASH_TYPE_PDFU32;
10406 salt_type = SALT_TYPE_EMBEDDED;
10407 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10408 opts_type = OPTS_TYPE_PT_GENERATE_LE
10409 | OPTS_TYPE_HASH_COPY;
10410 kern_type = KERN_TYPE_PDF17L8;
10411 dgst_size = DGST_SIZE_4_8;
10412 parse_func = pdf17l8_parse_hash;
10413 sort_by_digest = sort_by_digest_4_8;
10414 opti_type = OPTI_TYPE_ZERO_BYTE
10415 | OPTI_TYPE_NOT_ITERATED;
10416 dgst_pos0 = 0;
10417 dgst_pos1 = 1;
10418 dgst_pos2 = 2;
10419 dgst_pos3 = 3;
10420 break;
10421
10422 case 10800: hash_type = HASH_TYPE_SHA384;
10423 salt_type = SALT_TYPE_NONE;
10424 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10425 opts_type = OPTS_TYPE_PT_GENERATE_BE
10426 | OPTS_TYPE_PT_ADD80
10427 | OPTS_TYPE_PT_ADDBITS15;
10428 kern_type = KERN_TYPE_SHA384;
10429 dgst_size = DGST_SIZE_8_8;
10430 parse_func = sha384_parse_hash;
10431 sort_by_digest = sort_by_digest_8_8;
10432 opti_type = OPTI_TYPE_ZERO_BYTE
10433 | OPTI_TYPE_PRECOMPUTE_INIT
10434 | OPTI_TYPE_PRECOMPUTE_MERKLE
10435 | OPTI_TYPE_EARLY_SKIP
10436 | OPTI_TYPE_NOT_ITERATED
10437 | OPTI_TYPE_NOT_SALTED
10438 | OPTI_TYPE_USES_BITS_64
10439 | OPTI_TYPE_RAW_HASH;
10440 dgst_pos0 = 6;
10441 dgst_pos1 = 7;
10442 dgst_pos2 = 4;
10443 dgst_pos3 = 5;
10444 break;
10445
10446 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10447 salt_type = SALT_TYPE_EMBEDDED;
10448 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10449 opts_type = OPTS_TYPE_PT_GENERATE_LE
10450 | OPTS_TYPE_ST_BASE64
10451 | OPTS_TYPE_HASH_COPY;
10452 kern_type = KERN_TYPE_PBKDF2_SHA256;
10453 dgst_size = DGST_SIZE_4_32;
10454 parse_func = pbkdf2_sha256_parse_hash;
10455 sort_by_digest = sort_by_digest_4_32;
10456 opti_type = OPTI_TYPE_ZERO_BYTE
10457 | OPTI_TYPE_SLOW_HASH_SIMD;
10458 dgst_pos0 = 0;
10459 dgst_pos1 = 1;
10460 dgst_pos2 = 2;
10461 dgst_pos3 = 3;
10462 break;
10463
10464 case 11000: hash_type = HASH_TYPE_MD5;
10465 salt_type = SALT_TYPE_INTERN;
10466 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10467 opts_type = OPTS_TYPE_PT_GENERATE_LE
10468 | OPTS_TYPE_PT_ADD80;
10469 kern_type = KERN_TYPE_PRESTASHOP;
10470 dgst_size = DGST_SIZE_4_4;
10471 parse_func = prestashop_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_NOT_ITERATED
10476 | OPTI_TYPE_PREPENDED_SALT;
10477 dgst_pos0 = 0;
10478 dgst_pos1 = 3;
10479 dgst_pos2 = 2;
10480 dgst_pos3 = 1;
10481 break;
10482
10483 case 11100: hash_type = HASH_TYPE_MD5;
10484 salt_type = SALT_TYPE_EMBEDDED;
10485 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10486 opts_type = OPTS_TYPE_PT_GENERATE_LE
10487 | OPTS_TYPE_ST_ADD80;
10488 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10489 dgst_size = DGST_SIZE_4_4;
10490 parse_func = postgresql_auth_parse_hash;
10491 sort_by_digest = sort_by_digest_4_4;
10492 opti_type = OPTI_TYPE_ZERO_BYTE
10493 | OPTI_TYPE_PRECOMPUTE_INIT
10494 | OPTI_TYPE_PRECOMPUTE_MERKLE
10495 | OPTI_TYPE_EARLY_SKIP;
10496 dgst_pos0 = 0;
10497 dgst_pos1 = 3;
10498 dgst_pos2 = 2;
10499 dgst_pos3 = 1;
10500 break;
10501
10502 case 11200: hash_type = HASH_TYPE_SHA1;
10503 salt_type = SALT_TYPE_EMBEDDED;
10504 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10505 opts_type = OPTS_TYPE_PT_GENERATE_BE
10506 | OPTS_TYPE_PT_ADD80
10507 | OPTS_TYPE_ST_HEX;
10508 kern_type = KERN_TYPE_MYSQL_AUTH;
10509 dgst_size = DGST_SIZE_4_5;
10510 parse_func = mysql_auth_parse_hash;
10511 sort_by_digest = sort_by_digest_4_5;
10512 opti_type = OPTI_TYPE_ZERO_BYTE
10513 | OPTI_TYPE_EARLY_SKIP;
10514 dgst_pos0 = 3;
10515 dgst_pos1 = 4;
10516 dgst_pos2 = 2;
10517 dgst_pos3 = 1;
10518 break;
10519
10520 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10521 salt_type = SALT_TYPE_EMBEDDED;
10522 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10523 opts_type = OPTS_TYPE_PT_GENERATE_LE
10524 | OPTS_TYPE_ST_HEX
10525 | OPTS_TYPE_ST_ADD80;
10526 kern_type = KERN_TYPE_BITCOIN_WALLET;
10527 dgst_size = DGST_SIZE_4_4;
10528 parse_func = bitcoin_wallet_parse_hash;
10529 sort_by_digest = sort_by_digest_4_4;
10530 opti_type = OPTI_TYPE_ZERO_BYTE;
10531 dgst_pos0 = 0;
10532 dgst_pos1 = 1;
10533 dgst_pos2 = 2;
10534 dgst_pos3 = 3;
10535 break;
10536
10537 case 11400: hash_type = HASH_TYPE_MD5;
10538 salt_type = SALT_TYPE_EMBEDDED;
10539 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10540 opts_type = OPTS_TYPE_PT_GENERATE_LE
10541 | OPTS_TYPE_PT_ADD80
10542 | OPTS_TYPE_HASH_COPY;
10543 kern_type = KERN_TYPE_SIP_AUTH;
10544 dgst_size = DGST_SIZE_4_4;
10545 parse_func = sip_auth_parse_hash;
10546 sort_by_digest = sort_by_digest_4_4;
10547 opti_type = OPTI_TYPE_ZERO_BYTE;
10548 dgst_pos0 = 0;
10549 dgst_pos1 = 3;
10550 dgst_pos2 = 2;
10551 dgst_pos3 = 1;
10552 break;
10553
10554 case 11500: hash_type = HASH_TYPE_CRC32;
10555 salt_type = SALT_TYPE_INTERN;
10556 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10557 opts_type = OPTS_TYPE_PT_GENERATE_LE
10558 | OPTS_TYPE_ST_GENERATE_LE
10559 | OPTS_TYPE_ST_HEX;
10560 kern_type = KERN_TYPE_CRC32;
10561 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10562 parse_func = crc32_parse_hash;
10563 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10564 opti_type = OPTI_TYPE_ZERO_BYTE;
10565 dgst_pos0 = 0;
10566 dgst_pos1 = 1;
10567 dgst_pos2 = 2;
10568 dgst_pos3 = 3;
10569 break;
10570
10571 case 11600: hash_type = HASH_TYPE_AES;
10572 salt_type = SALT_TYPE_EMBEDDED;
10573 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10574 opts_type = OPTS_TYPE_PT_GENERATE_LE
10575 | OPTS_TYPE_PT_NEVERCRACK;
10576 kern_type = KERN_TYPE_SEVEN_ZIP;
10577 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10578 parse_func = seven_zip_parse_hash;
10579 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10580 opti_type = OPTI_TYPE_ZERO_BYTE;
10581 dgst_pos0 = 0;
10582 dgst_pos1 = 1;
10583 dgst_pos2 = 2;
10584 dgst_pos3 = 3;
10585 break;
10586
10587 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10588 salt_type = SALT_TYPE_NONE;
10589 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10590 opts_type = OPTS_TYPE_PT_GENERATE_LE
10591 | OPTS_TYPE_PT_ADD01;
10592 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10593 dgst_size = DGST_SIZE_4_8;
10594 parse_func = gost2012sbog_256_parse_hash;
10595 sort_by_digest = sort_by_digest_4_8;
10596 opti_type = OPTI_TYPE_ZERO_BYTE;
10597 dgst_pos0 = 0;
10598 dgst_pos1 = 1;
10599 dgst_pos2 = 2;
10600 dgst_pos3 = 3;
10601 break;
10602
10603 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10604 salt_type = SALT_TYPE_NONE;
10605 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10606 opts_type = OPTS_TYPE_PT_GENERATE_LE
10607 | OPTS_TYPE_PT_ADD01;
10608 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10609 dgst_size = DGST_SIZE_4_16;
10610 parse_func = gost2012sbog_512_parse_hash;
10611 sort_by_digest = sort_by_digest_4_16;
10612 opti_type = OPTI_TYPE_ZERO_BYTE;
10613 dgst_pos0 = 0;
10614 dgst_pos1 = 1;
10615 dgst_pos2 = 2;
10616 dgst_pos3 = 3;
10617 break;
10618
10619 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10620 salt_type = SALT_TYPE_EMBEDDED;
10621 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10622 opts_type = OPTS_TYPE_PT_GENERATE_LE
10623 | OPTS_TYPE_ST_BASE64
10624 | OPTS_TYPE_HASH_COPY;
10625 kern_type = KERN_TYPE_PBKDF2_MD5;
10626 dgst_size = DGST_SIZE_4_32;
10627 parse_func = pbkdf2_md5_parse_hash;
10628 sort_by_digest = sort_by_digest_4_32;
10629 opti_type = OPTI_TYPE_ZERO_BYTE
10630 | OPTI_TYPE_SLOW_HASH_SIMD;
10631 dgst_pos0 = 0;
10632 dgst_pos1 = 1;
10633 dgst_pos2 = 2;
10634 dgst_pos3 = 3;
10635 break;
10636
10637 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10638 salt_type = SALT_TYPE_EMBEDDED;
10639 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10640 opts_type = OPTS_TYPE_PT_GENERATE_LE
10641 | OPTS_TYPE_ST_BASE64
10642 | OPTS_TYPE_HASH_COPY;
10643 kern_type = KERN_TYPE_PBKDF2_SHA1;
10644 dgst_size = DGST_SIZE_4_32;
10645 parse_func = pbkdf2_sha1_parse_hash;
10646 sort_by_digest = sort_by_digest_4_32;
10647 opti_type = OPTI_TYPE_ZERO_BYTE
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 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10656 salt_type = SALT_TYPE_EMBEDDED;
10657 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10658 opts_type = OPTS_TYPE_PT_GENERATE_LE
10659 | OPTS_TYPE_ST_BASE64
10660 | OPTS_TYPE_HASH_COPY;
10661 kern_type = KERN_TYPE_PBKDF2_SHA512;
10662 dgst_size = DGST_SIZE_8_16;
10663 parse_func = pbkdf2_sha512_parse_hash;
10664 sort_by_digest = sort_by_digest_8_16;
10665 opti_type = OPTI_TYPE_ZERO_BYTE
10666 | OPTI_TYPE_USES_BITS_64
10667 | OPTI_TYPE_SLOW_HASH_SIMD;
10668 dgst_pos0 = 0;
10669 dgst_pos1 = 1;
10670 dgst_pos2 = 2;
10671 dgst_pos3 = 3;
10672 break;
10673
10674 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10675 salt_type = SALT_TYPE_EMBEDDED;
10676 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10677 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10678 kern_type = KERN_TYPE_ECRYPTFS;
10679 dgst_size = DGST_SIZE_8_8;
10680 parse_func = ecryptfs_parse_hash;
10681 sort_by_digest = sort_by_digest_8_8;
10682 opti_type = OPTI_TYPE_ZERO_BYTE
10683 | OPTI_TYPE_USES_BITS_64;
10684 dgst_pos0 = 0;
10685 dgst_pos1 = 1;
10686 dgst_pos2 = 2;
10687 dgst_pos3 = 3;
10688 break;
10689
10690 case 12300: hash_type = HASH_TYPE_ORACLET;
10691 salt_type = SALT_TYPE_EMBEDDED;
10692 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10693 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10694 kern_type = KERN_TYPE_ORACLET;
10695 dgst_size = DGST_SIZE_8_16;
10696 parse_func = oraclet_parse_hash;
10697 sort_by_digest = sort_by_digest_8_16;
10698 opti_type = OPTI_TYPE_ZERO_BYTE
10699 | OPTI_TYPE_USES_BITS_64;
10700 dgst_pos0 = 0;
10701 dgst_pos1 = 1;
10702 dgst_pos2 = 2;
10703 dgst_pos3 = 3;
10704 break;
10705
10706 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10707 salt_type = SALT_TYPE_EMBEDDED;
10708 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10709 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10710 kern_type = KERN_TYPE_BSDICRYPT;
10711 dgst_size = DGST_SIZE_4_4;
10712 parse_func = bsdicrypt_parse_hash;
10713 sort_by_digest = sort_by_digest_4_4;
10714 opti_type = OPTI_TYPE_ZERO_BYTE
10715 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10716 dgst_pos0 = 0;
10717 dgst_pos1 = 1;
10718 dgst_pos2 = 2;
10719 dgst_pos3 = 3;
10720 break;
10721
10722 case 12500: hash_type = HASH_TYPE_RAR3HP;
10723 salt_type = SALT_TYPE_EMBEDDED;
10724 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10725 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10726 kern_type = KERN_TYPE_RAR3;
10727 dgst_size = DGST_SIZE_4_4;
10728 parse_func = rar3hp_parse_hash;
10729 sort_by_digest = sort_by_digest_4_4;
10730 opti_type = OPTI_TYPE_ZERO_BYTE;
10731 dgst_pos0 = 0;
10732 dgst_pos1 = 1;
10733 dgst_pos2 = 2;
10734 dgst_pos3 = 3;
10735 break;
10736
10737 case 12600: hash_type = HASH_TYPE_SHA256;
10738 salt_type = SALT_TYPE_INTERN;
10739 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10740 opts_type = OPTS_TYPE_PT_GENERATE_BE
10741 | OPTS_TYPE_PT_ADD80;
10742 kern_type = KERN_TYPE_CF10;
10743 dgst_size = DGST_SIZE_4_8;
10744 parse_func = cf10_parse_hash;
10745 sort_by_digest = sort_by_digest_4_8;
10746 opti_type = OPTI_TYPE_ZERO_BYTE
10747 | OPTI_TYPE_PRECOMPUTE_INIT
10748 | OPTI_TYPE_EARLY_SKIP
10749 | OPTI_TYPE_NOT_ITERATED;
10750 dgst_pos0 = 3;
10751 dgst_pos1 = 7;
10752 dgst_pos2 = 2;
10753 dgst_pos3 = 6;
10754 break;
10755
10756 case 12700: hash_type = HASH_TYPE_AES;
10757 salt_type = SALT_TYPE_EMBEDDED;
10758 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10759 opts_type = OPTS_TYPE_PT_GENERATE_LE
10760 | OPTS_TYPE_HASH_COPY;
10761 kern_type = KERN_TYPE_MYWALLET;
10762 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10763 parse_func = mywallet_parse_hash;
10764 sort_by_digest = sort_by_digest_4_5;
10765 opti_type = OPTI_TYPE_ZERO_BYTE;
10766 dgst_pos0 = 0;
10767 dgst_pos1 = 1;
10768 dgst_pos2 = 2;
10769 dgst_pos3 = 3;
10770 break;
10771
10772 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10773 salt_type = SALT_TYPE_EMBEDDED;
10774 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10775 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10776 kern_type = KERN_TYPE_MS_DRSR;
10777 dgst_size = DGST_SIZE_4_8;
10778 parse_func = ms_drsr_parse_hash;
10779 sort_by_digest = sort_by_digest_4_8;
10780 opti_type = OPTI_TYPE_ZERO_BYTE;
10781 dgst_pos0 = 0;
10782 dgst_pos1 = 1;
10783 dgst_pos2 = 2;
10784 dgst_pos3 = 3;
10785 break;
10786
10787 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10788 salt_type = SALT_TYPE_EMBEDDED;
10789 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10790 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10791 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10792 dgst_size = DGST_SIZE_4_8;
10793 parse_func = androidfde_samsung_parse_hash;
10794 sort_by_digest = sort_by_digest_4_8;
10795 opti_type = OPTI_TYPE_ZERO_BYTE;
10796 dgst_pos0 = 0;
10797 dgst_pos1 = 1;
10798 dgst_pos2 = 2;
10799 dgst_pos3 = 3;
10800 break;
10801
10802 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10803 salt_type = SALT_TYPE_EMBEDDED;
10804 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10805 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10806 kern_type = KERN_TYPE_RAR5;
10807 dgst_size = DGST_SIZE_4_4;
10808 parse_func = rar5_parse_hash;
10809 sort_by_digest = sort_by_digest_4_4;
10810 opti_type = OPTI_TYPE_ZERO_BYTE;
10811 dgst_pos0 = 0;
10812 dgst_pos1 = 1;
10813 dgst_pos2 = 2;
10814 dgst_pos3 = 3;
10815 break;
10816
10817 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10818 salt_type = SALT_TYPE_EMBEDDED;
10819 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10820 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10821 kern_type = KERN_TYPE_KRB5TGS;
10822 dgst_size = DGST_SIZE_4_4;
10823 parse_func = krb5tgs_parse_hash;
10824 sort_by_digest = sort_by_digest_4_4;
10825 opti_type = OPTI_TYPE_ZERO_BYTE
10826 | OPTI_TYPE_NOT_ITERATED;
10827 dgst_pos0 = 0;
10828 dgst_pos1 = 1;
10829 dgst_pos2 = 2;
10830 dgst_pos3 = 3;
10831 break;
10832
10833 case 13200: hash_type = HASH_TYPE_AES;
10834 salt_type = SALT_TYPE_EMBEDDED;
10835 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10836 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10837 kern_type = KERN_TYPE_AXCRYPT;
10838 dgst_size = DGST_SIZE_4_4;
10839 parse_func = axcrypt_parse_hash;
10840 sort_by_digest = sort_by_digest_4_4;
10841 opti_type = OPTI_TYPE_ZERO_BYTE;
10842 dgst_pos0 = 0;
10843 dgst_pos1 = 1;
10844 dgst_pos2 = 2;
10845 dgst_pos3 = 3;
10846 break;
10847
10848 case 13300: hash_type = HASH_TYPE_SHA1;
10849 salt_type = SALT_TYPE_NONE;
10850 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10851 opts_type = OPTS_TYPE_PT_GENERATE_BE
10852 | OPTS_TYPE_PT_ADD80
10853 | OPTS_TYPE_PT_ADDBITS15;
10854 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10855 dgst_size = DGST_SIZE_4_5;
10856 parse_func = sha1axcrypt_parse_hash;
10857 sort_by_digest = sort_by_digest_4_5;
10858 opti_type = OPTI_TYPE_ZERO_BYTE
10859 | OPTI_TYPE_PRECOMPUTE_INIT
10860 | OPTI_TYPE_EARLY_SKIP
10861 | OPTI_TYPE_NOT_ITERATED
10862 | OPTI_TYPE_NOT_SALTED;
10863 dgst_pos0 = 0;
10864 dgst_pos1 = 4;
10865 dgst_pos2 = 3;
10866 dgst_pos3 = 2;
10867 break;
10868
10869 case 13400: hash_type = HASH_TYPE_AES;
10870 salt_type = SALT_TYPE_EMBEDDED;
10871 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10872 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10873 kern_type = KERN_TYPE_KEEPASS;
10874 dgst_size = DGST_SIZE_4_4;
10875 parse_func = keepass_parse_hash;
10876 sort_by_digest = sort_by_digest_4_4;
10877 opti_type = OPTI_TYPE_ZERO_BYTE;
10878 dgst_pos0 = 0;
10879 dgst_pos1 = 1;
10880 dgst_pos2 = 2;
10881 dgst_pos3 = 3;
10882 break;
10883
10884 case 13500: hash_type = HASH_TYPE_SHA1;
10885 salt_type = SALT_TYPE_EMBEDDED;
10886 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10887 opts_type = OPTS_TYPE_PT_GENERATE_BE
10888 | OPTS_TYPE_PT_UNICODE
10889 | OPTS_TYPE_PT_ADD80;
10890 kern_type = KERN_TYPE_PSTOKEN;
10891 dgst_size = DGST_SIZE_4_5;
10892 parse_func = pstoken_parse_hash;
10893 sort_by_digest = sort_by_digest_4_5;
10894 opti_type = OPTI_TYPE_ZERO_BYTE
10895 | OPTI_TYPE_PRECOMPUTE_INIT
10896 | OPTI_TYPE_EARLY_SKIP
10897 | OPTI_TYPE_NOT_ITERATED
10898 | OPTI_TYPE_PREPENDED_SALT
10899 | OPTI_TYPE_RAW_HASH;
10900 dgst_pos0 = 3;
10901 dgst_pos1 = 4;
10902 dgst_pos2 = 2;
10903 dgst_pos3 = 1;
10904 break;
10905
10906 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10907 salt_type = SALT_TYPE_EMBEDDED;
10908 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10909 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10910 kern_type = KERN_TYPE_ZIP2;
10911 dgst_size = DGST_SIZE_4_4;
10912 parse_func = zip2_parse_hash;
10913 sort_by_digest = sort_by_digest_4_4;
10914 opti_type = OPTI_TYPE_ZERO_BYTE;
10915 dgst_pos0 = 0;
10916 dgst_pos1 = 1;
10917 dgst_pos2 = 2;
10918 dgst_pos3 = 3;
10919 break;
10920
10921 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10922 salt_type = SALT_TYPE_EMBEDDED;
10923 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10924 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10925 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10926 dgst_size = DGST_SIZE_4_5;
10927 parse_func = veracrypt_parse_hash_655331;
10928 sort_by_digest = sort_by_digest_4_5;
10929 opti_type = OPTI_TYPE_ZERO_BYTE;
10930 dgst_pos0 = 0;
10931 dgst_pos1 = 1;
10932 dgst_pos2 = 2;
10933 dgst_pos3 = 3;
10934 break;
10935
10936 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10937 salt_type = SALT_TYPE_EMBEDDED;
10938 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10939 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10940 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10941 dgst_size = DGST_SIZE_4_5;
10942 parse_func = veracrypt_parse_hash_655331;
10943 sort_by_digest = sort_by_digest_4_5;
10944 opti_type = OPTI_TYPE_ZERO_BYTE;
10945 dgst_pos0 = 0;
10946 dgst_pos1 = 1;
10947 dgst_pos2 = 2;
10948 dgst_pos3 = 3;
10949 break;
10950
10951 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10952 salt_type = SALT_TYPE_EMBEDDED;
10953 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10954 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10955 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10956 dgst_size = DGST_SIZE_4_5;
10957 parse_func = veracrypt_parse_hash_655331;
10958 sort_by_digest = sort_by_digest_4_5;
10959 opti_type = OPTI_TYPE_ZERO_BYTE;
10960 dgst_pos0 = 0;
10961 dgst_pos1 = 1;
10962 dgst_pos2 = 2;
10963 dgst_pos3 = 3;
10964 break;
10965
10966 case 13721: hash_type = HASH_TYPE_SHA512;
10967 salt_type = SALT_TYPE_EMBEDDED;
10968 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10969 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10970 kern_type = KERN_TYPE_TCSHA512_XTS512;
10971 dgst_size = DGST_SIZE_8_8;
10972 parse_func = veracrypt_parse_hash_500000;
10973 sort_by_digest = sort_by_digest_8_8;
10974 opti_type = OPTI_TYPE_ZERO_BYTE
10975 | OPTI_TYPE_USES_BITS_64;
10976 dgst_pos0 = 0;
10977 dgst_pos1 = 1;
10978 dgst_pos2 = 2;
10979 dgst_pos3 = 3;
10980 break;
10981
10982 case 13722: hash_type = HASH_TYPE_SHA512;
10983 salt_type = SALT_TYPE_EMBEDDED;
10984 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10985 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10986 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10987 dgst_size = DGST_SIZE_8_8;
10988 parse_func = veracrypt_parse_hash_500000;
10989 sort_by_digest = sort_by_digest_8_8;
10990 opti_type = OPTI_TYPE_ZERO_BYTE
10991 | OPTI_TYPE_USES_BITS_64;
10992 dgst_pos0 = 0;
10993 dgst_pos1 = 1;
10994 dgst_pos2 = 2;
10995 dgst_pos3 = 3;
10996 break;
10997
10998 case 13723: hash_type = HASH_TYPE_SHA512;
10999 salt_type = SALT_TYPE_EMBEDDED;
11000 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11001 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11002 kern_type = KERN_TYPE_TCSHA512_XTS1536;
11003 dgst_size = DGST_SIZE_8_8;
11004 parse_func = veracrypt_parse_hash_500000;
11005 sort_by_digest = sort_by_digest_8_8;
11006 opti_type = OPTI_TYPE_ZERO_BYTE
11007 | OPTI_TYPE_USES_BITS_64;
11008 dgst_pos0 = 0;
11009 dgst_pos1 = 1;
11010 dgst_pos2 = 2;
11011 dgst_pos3 = 3;
11012 break;
11013
11014 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
11015 salt_type = SALT_TYPE_EMBEDDED;
11016 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11017 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11018 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
11019 dgst_size = DGST_SIZE_4_8;
11020 parse_func = veracrypt_parse_hash_500000;
11021 sort_by_digest = sort_by_digest_4_8;
11022 opti_type = OPTI_TYPE_ZERO_BYTE;
11023 dgst_pos0 = 0;
11024 dgst_pos1 = 1;
11025 dgst_pos2 = 2;
11026 dgst_pos3 = 3;
11027 break;
11028
11029 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
11030 salt_type = SALT_TYPE_EMBEDDED;
11031 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11032 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11033 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
11034 dgst_size = DGST_SIZE_4_8;
11035 parse_func = veracrypt_parse_hash_500000;
11036 sort_by_digest = sort_by_digest_4_8;
11037 opti_type = OPTI_TYPE_ZERO_BYTE;
11038 dgst_pos0 = 0;
11039 dgst_pos1 = 1;
11040 dgst_pos2 = 2;
11041 dgst_pos3 = 3;
11042 break;
11043
11044 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
11045 salt_type = SALT_TYPE_EMBEDDED;
11046 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11047 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11048 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
11049 dgst_size = DGST_SIZE_4_8;
11050 parse_func = veracrypt_parse_hash_500000;
11051 sort_by_digest = sort_by_digest_4_8;
11052 opti_type = OPTI_TYPE_ZERO_BYTE;
11053 dgst_pos0 = 0;
11054 dgst_pos1 = 1;
11055 dgst_pos2 = 2;
11056 dgst_pos3 = 3;
11057 break;
11058
11059 case 13741: hash_type = HASH_TYPE_RIPEMD160;
11060 salt_type = SALT_TYPE_EMBEDDED;
11061 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11062 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11063 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
11064 dgst_size = DGST_SIZE_4_5;
11065 parse_func = veracrypt_parse_hash_327661;
11066 sort_by_digest = sort_by_digest_4_5;
11067 opti_type = OPTI_TYPE_ZERO_BYTE;
11068 dgst_pos0 = 0;
11069 dgst_pos1 = 1;
11070 dgst_pos2 = 2;
11071 dgst_pos3 = 3;
11072 break;
11073
11074 case 13742: hash_type = HASH_TYPE_RIPEMD160;
11075 salt_type = SALT_TYPE_EMBEDDED;
11076 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11077 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11078 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
11079 dgst_size = DGST_SIZE_4_5;
11080 parse_func = veracrypt_parse_hash_327661;
11081 sort_by_digest = sort_by_digest_4_5;
11082 opti_type = OPTI_TYPE_ZERO_BYTE;
11083 dgst_pos0 = 0;
11084 dgst_pos1 = 1;
11085 dgst_pos2 = 2;
11086 dgst_pos3 = 3;
11087 break;
11088
11089 case 13743: hash_type = HASH_TYPE_RIPEMD160;
11090 salt_type = SALT_TYPE_EMBEDDED;
11091 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11092 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11093 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11094 dgst_size = DGST_SIZE_4_5;
11095 parse_func = veracrypt_parse_hash_327661;
11096 sort_by_digest = sort_by_digest_4_5;
11097 opti_type = OPTI_TYPE_ZERO_BYTE;
11098 dgst_pos0 = 0;
11099 dgst_pos1 = 1;
11100 dgst_pos2 = 2;
11101 dgst_pos3 = 3;
11102 break;
11103
11104 case 13751: hash_type = HASH_TYPE_SHA256;
11105 salt_type = SALT_TYPE_EMBEDDED;
11106 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11107 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11108 kern_type = KERN_TYPE_VCSHA256_XTS512;
11109 dgst_size = DGST_SIZE_4_8;
11110 parse_func = veracrypt_parse_hash_500000;
11111 sort_by_digest = sort_by_digest_4_8;
11112 opti_type = OPTI_TYPE_ZERO_BYTE;
11113 dgst_pos0 = 0;
11114 dgst_pos1 = 1;
11115 dgst_pos2 = 2;
11116 dgst_pos3 = 3;
11117 break;
11118
11119 case 13752: hash_type = HASH_TYPE_SHA256;
11120 salt_type = SALT_TYPE_EMBEDDED;
11121 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11122 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11123 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11124 dgst_size = DGST_SIZE_4_8;
11125 parse_func = veracrypt_parse_hash_500000;
11126 sort_by_digest = sort_by_digest_4_8;
11127 opti_type = OPTI_TYPE_ZERO_BYTE;
11128 dgst_pos0 = 0;
11129 dgst_pos1 = 1;
11130 dgst_pos2 = 2;
11131 dgst_pos3 = 3;
11132 break;
11133
11134 case 13753: hash_type = HASH_TYPE_SHA256;
11135 salt_type = SALT_TYPE_EMBEDDED;
11136 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11137 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11138 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11139 dgst_size = DGST_SIZE_4_8;
11140 parse_func = veracrypt_parse_hash_500000;
11141 sort_by_digest = sort_by_digest_4_8;
11142 opti_type = OPTI_TYPE_ZERO_BYTE;
11143 dgst_pos0 = 0;
11144 dgst_pos1 = 1;
11145 dgst_pos2 = 2;
11146 dgst_pos3 = 3;
11147 break;
11148
11149 case 13761: hash_type = HASH_TYPE_SHA256;
11150 salt_type = SALT_TYPE_EMBEDDED;
11151 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11152 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11153 kern_type = KERN_TYPE_VCSHA256_XTS512;
11154 dgst_size = DGST_SIZE_4_8;
11155 parse_func = veracrypt_parse_hash_200000;
11156 sort_by_digest = sort_by_digest_4_8;
11157 opti_type = OPTI_TYPE_ZERO_BYTE;
11158 dgst_pos0 = 0;
11159 dgst_pos1 = 1;
11160 dgst_pos2 = 2;
11161 dgst_pos3 = 3;
11162 break;
11163
11164 case 13762: hash_type = HASH_TYPE_SHA256;
11165 salt_type = SALT_TYPE_EMBEDDED;
11166 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11167 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11168 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11169 dgst_size = DGST_SIZE_4_8;
11170 parse_func = veracrypt_parse_hash_200000;
11171 sort_by_digest = sort_by_digest_4_8;
11172 opti_type = OPTI_TYPE_ZERO_BYTE;
11173 dgst_pos0 = 0;
11174 dgst_pos1 = 1;
11175 dgst_pos2 = 2;
11176 dgst_pos3 = 3;
11177 break;
11178
11179 case 13763: hash_type = HASH_TYPE_SHA256;
11180 salt_type = SALT_TYPE_EMBEDDED;
11181 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11182 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11183 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11184 dgst_size = DGST_SIZE_4_8;
11185 parse_func = veracrypt_parse_hash_200000;
11186 sort_by_digest = sort_by_digest_4_8;
11187 opti_type = OPTI_TYPE_ZERO_BYTE;
11188 dgst_pos0 = 0;
11189 dgst_pos1 = 1;
11190 dgst_pos2 = 2;
11191 dgst_pos3 = 3;
11192 break;
11193
11194 case 13800: hash_type = HASH_TYPE_SHA256;
11195 salt_type = SALT_TYPE_EMBEDDED;
11196 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11197 opts_type = OPTS_TYPE_PT_GENERATE_BE
11198 | OPTS_TYPE_PT_UNICODE;
11199 kern_type = KERN_TYPE_WIN8PHONE;
11200 dgst_size = DGST_SIZE_4_8;
11201 parse_func = win8phone_parse_hash;
11202 sort_by_digest = sort_by_digest_4_8;
11203 opti_type = OPTI_TYPE_ZERO_BYTE
11204 | OPTI_TYPE_PRECOMPUTE_INIT
11205 | OPTI_TYPE_EARLY_SKIP
11206 | OPTI_TYPE_NOT_ITERATED
11207 | OPTI_TYPE_RAW_HASH;
11208 dgst_pos0 = 3;
11209 dgst_pos1 = 7;
11210 dgst_pos2 = 2;
11211 dgst_pos3 = 6;
11212 break;
11213
11214 default: usage_mini_print (PROGNAME); return (-1);
11215 }
11216
11217 /**
11218 * parser
11219 */
11220
11221 data.parse_func = parse_func;
11222
11223 /**
11224 * misc stuff
11225 */
11226
11227 if (hex_salt)
11228 {
11229 if (salt_type == SALT_TYPE_INTERN)
11230 {
11231 opts_type |= OPTS_TYPE_ST_HEX;
11232 }
11233 else
11234 {
11235 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11236
11237 return (-1);
11238 }
11239 }
11240
11241 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11242 | (salt_type == SALT_TYPE_EXTERN)
11243 | (salt_type == SALT_TYPE_EMBEDDED)
11244 | (salt_type == SALT_TYPE_VIRTUAL));
11245
11246 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
11247
11248 data.hash_type = hash_type;
11249 data.attack_mode = attack_mode;
11250 data.attack_kern = attack_kern;
11251 data.attack_exec = attack_exec;
11252 data.kern_type = kern_type;
11253 data.opts_type = opts_type;
11254 data.dgst_size = dgst_size;
11255 data.salt_type = salt_type;
11256 data.isSalted = isSalted;
11257 data.sort_by_digest = sort_by_digest;
11258 data.dgst_pos0 = dgst_pos0;
11259 data.dgst_pos1 = dgst_pos1;
11260 data.dgst_pos2 = dgst_pos2;
11261 data.dgst_pos3 = dgst_pos3;
11262
11263 esalt_size = 0;
11264
11265 switch (hash_mode)
11266 {
11267 case 2500: esalt_size = sizeof (wpa_t); break;
11268 case 5300: esalt_size = sizeof (ikepsk_t); break;
11269 case 5400: esalt_size = sizeof (ikepsk_t); break;
11270 case 5500: esalt_size = sizeof (netntlm_t); break;
11271 case 5600: esalt_size = sizeof (netntlm_t); break;
11272 case 6211: esalt_size = sizeof (tc_t); break;
11273 case 6212: esalt_size = sizeof (tc_t); break;
11274 case 6213: esalt_size = sizeof (tc_t); break;
11275 case 6221: esalt_size = sizeof (tc_t); break;
11276 case 6222: esalt_size = sizeof (tc_t); break;
11277 case 6223: esalt_size = sizeof (tc_t); break;
11278 case 6231: esalt_size = sizeof (tc_t); break;
11279 case 6232: esalt_size = sizeof (tc_t); break;
11280 case 6233: esalt_size = sizeof (tc_t); break;
11281 case 6241: esalt_size = sizeof (tc_t); break;
11282 case 6242: esalt_size = sizeof (tc_t); break;
11283 case 6243: esalt_size = sizeof (tc_t); break;
11284 case 6600: esalt_size = sizeof (agilekey_t); break;
11285 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11286 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
11287 case 7300: esalt_size = sizeof (rakp_t); break;
11288 case 7500: esalt_size = sizeof (krb5pa_t); break;
11289 case 8200: esalt_size = sizeof (cloudkey_t); break;
11290 case 8800: esalt_size = sizeof (androidfde_t); break;
11291 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
11292 case 9400: esalt_size = sizeof (office2007_t); break;
11293 case 9500: esalt_size = sizeof (office2010_t); break;
11294 case 9600: esalt_size = sizeof (office2013_t); break;
11295 case 9700: esalt_size = sizeof (oldoffice01_t); break;
11296 case 9710: esalt_size = sizeof (oldoffice01_t); break;
11297 case 9720: esalt_size = sizeof (oldoffice01_t); break;
11298 case 9800: esalt_size = sizeof (oldoffice34_t); break;
11299 case 9810: esalt_size = sizeof (oldoffice34_t); break;
11300 case 9820: esalt_size = sizeof (oldoffice34_t); break;
11301 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
11302 case 10200: esalt_size = sizeof (cram_md5_t); break;
11303 case 10400: esalt_size = sizeof (pdf_t); break;
11304 case 10410: esalt_size = sizeof (pdf_t); break;
11305 case 10420: esalt_size = sizeof (pdf_t); break;
11306 case 10500: esalt_size = sizeof (pdf_t); break;
11307 case 10600: esalt_size = sizeof (pdf_t); break;
11308 case 10700: esalt_size = sizeof (pdf_t); break;
11309 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
11310 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
11311 case 11400: esalt_size = sizeof (sip_t); break;
11312 case 11600: esalt_size = sizeof (seven_zip_t); break;
11313 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
11314 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
11315 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11316 case 13000: esalt_size = sizeof (rar5_t); break;
11317 case 13100: esalt_size = sizeof (krb5tgs_t); break;
11318 case 13400: esalt_size = sizeof (keepass_t); break;
11319 case 13500: esalt_size = sizeof (pstoken_t); break;
11320 case 13600: esalt_size = sizeof (zip2_t); break;
11321 case 13711: esalt_size = sizeof (tc_t); break;
11322 case 13712: esalt_size = sizeof (tc_t); break;
11323 case 13713: esalt_size = sizeof (tc_t); break;
11324 case 13721: esalt_size = sizeof (tc_t); break;
11325 case 13722: esalt_size = sizeof (tc_t); break;
11326 case 13723: esalt_size = sizeof (tc_t); break;
11327 case 13731: esalt_size = sizeof (tc_t); break;
11328 case 13732: esalt_size = sizeof (tc_t); break;
11329 case 13733: esalt_size = sizeof (tc_t); break;
11330 case 13741: esalt_size = sizeof (tc_t); break;
11331 case 13742: esalt_size = sizeof (tc_t); break;
11332 case 13743: esalt_size = sizeof (tc_t); break;
11333 case 13751: esalt_size = sizeof (tc_t); break;
11334 case 13752: esalt_size = sizeof (tc_t); break;
11335 case 13753: esalt_size = sizeof (tc_t); break;
11336 case 13761: esalt_size = sizeof (tc_t); break;
11337 case 13762: esalt_size = sizeof (tc_t); break;
11338 case 13763: esalt_size = sizeof (tc_t); break;
11339 case 13800: esalt_size = sizeof (win8phone_t); break;
11340 }
11341
11342 data.esalt_size = esalt_size;
11343
11344 /**
11345 * choose dictionary parser
11346 */
11347
11348 if (hash_type == HASH_TYPE_LM)
11349 {
11350 get_next_word_func = get_next_word_lm;
11351 }
11352 else if (opts_type & OPTS_TYPE_PT_UPPER)
11353 {
11354 get_next_word_func = get_next_word_uc;
11355 }
11356 else
11357 {
11358 get_next_word_func = get_next_word_std;
11359 }
11360
11361 /**
11362 * dictstat
11363 */
11364
11365 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11366
11367 #ifdef _POSIX
11368 size_t dictstat_nmemb = 0;
11369 #endif
11370
11371 #ifdef _WIN
11372 uint dictstat_nmemb = 0;
11373 #endif
11374
11375 char dictstat[256] = { 0 };
11376
11377 FILE *dictstat_fp = NULL;
11378
11379 if (keyspace == 0)
11380 {
11381 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11382
11383 dictstat_fp = fopen (dictstat, "rb");
11384
11385 if (dictstat_fp)
11386 {
11387 #ifdef _POSIX
11388 struct stat tmpstat;
11389
11390 fstat (fileno (dictstat_fp), &tmpstat);
11391 #endif
11392
11393 #ifdef _WIN
11394 struct stat64 tmpstat;
11395
11396 _fstat64 (fileno (dictstat_fp), &tmpstat);
11397 #endif
11398
11399 if (tmpstat.st_mtime < COMPTIME)
11400 {
11401 /* with v0.15 the format changed so we have to ensure user is using a good version
11402 since there is no version-header in the dictstat file */
11403
11404 fclose (dictstat_fp);
11405
11406 unlink (dictstat);
11407 }
11408 else
11409 {
11410 while (!feof (dictstat_fp))
11411 {
11412 dictstat_t d;
11413
11414 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11415
11416 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11417
11418 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11419 {
11420 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11421
11422 return -1;
11423 }
11424 }
11425
11426 fclose (dictstat_fp);
11427 }
11428 }
11429 }
11430
11431 /**
11432 * potfile
11433 */
11434
11435 char potfile[256] = { 0 };
11436
11437 if (potfile_path == NULL)
11438 {
11439 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11440 }
11441 else
11442 {
11443 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11444 }
11445
11446 data.pot_fp = NULL;
11447
11448 FILE *out_fp = NULL;
11449 FILE *pot_fp = NULL;
11450
11451 if (show == 1 || left == 1)
11452 {
11453 pot_fp = fopen (potfile, "rb");
11454
11455 if (pot_fp == NULL)
11456 {
11457 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11458
11459 return (-1);
11460 }
11461
11462 if (outfile != NULL)
11463 {
11464 if ((out_fp = fopen (outfile, "ab")) == NULL)
11465 {
11466 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11467
11468 fclose (pot_fp);
11469
11470 return (-1);
11471 }
11472 }
11473 else
11474 {
11475 out_fp = stdout;
11476 }
11477 }
11478 else
11479 {
11480 if (potfile_disable == 0)
11481 {
11482 pot_fp = fopen (potfile, "ab");
11483
11484 if (pot_fp == NULL)
11485 {
11486 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11487
11488 return (-1);
11489 }
11490
11491 data.pot_fp = pot_fp;
11492 }
11493 }
11494
11495 pot_t *pot = NULL;
11496
11497 uint pot_cnt = 0;
11498 uint pot_avail = 0;
11499
11500 if (show == 1 || left == 1)
11501 {
11502 SUPPRESS_OUTPUT = 1;
11503
11504 pot_avail = count_lines (pot_fp);
11505
11506 rewind (pot_fp);
11507
11508 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11509
11510 uint pot_hashes_avail = 0;
11511
11512 uint line_num = 0;
11513
11514 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11515
11516 while (!feof (pot_fp))
11517 {
11518 line_num++;
11519
11520 int line_len = fgetl (pot_fp, line_buf);
11521
11522 if (line_len == 0) continue;
11523
11524 char *plain_buf = line_buf + line_len;
11525
11526 pot_t *pot_ptr = &pot[pot_cnt];
11527
11528 hash_t *hashes_buf = &pot_ptr->hash;
11529
11530 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11531 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11532
11533 if (pot_cnt == pot_hashes_avail)
11534 {
11535 uint pos = 0;
11536
11537 for (pos = 0; pos < INCR_POT; pos++)
11538 {
11539 if ((pot_cnt + pos) >= pot_avail) break;
11540
11541 pot_t *tmp_pot = &pot[pot_cnt + pos];
11542
11543 hash_t *tmp_hash = &tmp_pot->hash;
11544
11545 tmp_hash->digest = mymalloc (dgst_size);
11546
11547 if (isSalted)
11548 {
11549 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11550 }
11551
11552 if (esalt_size)
11553 {
11554 tmp_hash->esalt = mymalloc (esalt_size);
11555 }
11556
11557 pot_hashes_avail++;
11558 }
11559 }
11560
11561 int plain_len = 0;
11562
11563 int parser_status;
11564
11565 int iter = MAX_CUT_TRIES;
11566
11567 do
11568 {
11569 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11570 {
11571 if (line_buf[i] == ':')
11572 {
11573 line_len--;
11574
11575 break;
11576 }
11577 }
11578
11579 if (data.hash_mode != 2500)
11580 {
11581 parser_status = parse_func (line_buf, line_len, hashes_buf);
11582 }
11583 else
11584 {
11585 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11586
11587 if (line_len > max_salt_size)
11588 {
11589 parser_status = PARSER_GLOBAL_LENGTH;
11590 }
11591 else
11592 {
11593 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11594
11595 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11596
11597 hashes_buf->salt->salt_len = line_len;
11598
11599 parser_status = PARSER_OK;
11600 }
11601 }
11602
11603 // if NOT parsed without error, we add the ":" to the plain
11604
11605 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11606 {
11607 plain_len++;
11608 plain_buf--;
11609 }
11610
11611 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11612
11613 if (parser_status < PARSER_GLOBAL_ZERO)
11614 {
11615 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11616
11617 continue;
11618 }
11619
11620 if (plain_len >= 255) continue;
11621
11622 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11623
11624 pot_ptr->plain_len = plain_len;
11625
11626 pot_cnt++;
11627 }
11628
11629 myfree (line_buf);
11630
11631 fclose (pot_fp);
11632
11633 SUPPRESS_OUTPUT = 0;
11634
11635 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11636 }
11637
11638 /**
11639 * word len
11640 */
11641
11642 uint pw_min = PW_MIN;
11643 uint pw_max = PW_MAX;
11644
11645 switch (hash_mode)
11646 {
11647 case 125: if (pw_max > 32) pw_max = 32;
11648 break;
11649 case 400: if (pw_max > 40) pw_max = 40;
11650 break;
11651 case 500: if (pw_max > 16) pw_max = 16;
11652 break;
11653 case 1500: if (pw_max > 8) pw_max = 8;
11654 break;
11655 case 1600: if (pw_max > 16) pw_max = 16;
11656 break;
11657 case 1800: if (pw_max > 16) pw_max = 16;
11658 break;
11659 case 2100: if (pw_max > 16) pw_max = 16;
11660 break;
11661 case 2500: if (pw_min < 8) pw_min = 8;
11662 break;
11663 case 3000: if (pw_max > 7) pw_max = 7;
11664 break;
11665 case 5200: if (pw_max > 24) pw_max = 24;
11666 break;
11667 case 5800: if (pw_max > 16) pw_max = 16;
11668 break;
11669 case 6300: if (pw_max > 16) pw_max = 16;
11670 break;
11671 case 7400: if (pw_max > 16) pw_max = 16;
11672 break;
11673 case 7700: if (pw_max > 8) pw_max = 8;
11674 break;
11675 case 7900: if (pw_max > 48) pw_max = 48;
11676 break;
11677 case 8500: if (pw_max > 8) pw_max = 8;
11678 break;
11679 case 8600: if (pw_max > 16) pw_max = 16;
11680 break;
11681 case 9710: pw_min = 5;
11682 pw_max = 5;
11683 break;
11684 case 9810: pw_min = 5;
11685 pw_max = 5;
11686 break;
11687 case 10410: pw_min = 5;
11688 pw_max = 5;
11689 break;
11690 case 10300: if (pw_max < 3) pw_min = 3;
11691 if (pw_max > 40) pw_max = 40;
11692 break;
11693 case 10500: if (pw_max < 3) pw_min = 3;
11694 if (pw_max > 40) pw_max = 40;
11695 break;
11696 case 10700: if (pw_max > 16) pw_max = 16;
11697 break;
11698 case 11300: if (pw_max > 40) pw_max = 40;
11699 break;
11700 case 11600: if (pw_max > 32) pw_max = 32;
11701 break;
11702 case 12500: if (pw_max > 20) pw_max = 20;
11703 break;
11704 case 12800: if (pw_max > 24) pw_max = 24;
11705 break;
11706 }
11707
11708 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11709 {
11710 switch (attack_kern)
11711 {
11712 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11713 break;
11714 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11715 break;
11716 }
11717 }
11718
11719 /**
11720 * charsets : keep them together for more easy maintainnce
11721 */
11722
11723 cs_t mp_sys[6] = { { { 0 }, 0 } };
11724 cs_t mp_usr[4] = { { { 0 }, 0 } };
11725
11726 mp_setup_sys (mp_sys);
11727
11728 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11729 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11730 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11731 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11732
11733 /**
11734 * load hashes, part I: find input mode, count hashes
11735 */
11736
11737 uint hashlist_mode = 0;
11738 uint hashlist_format = HLFMT_HASHCAT;
11739
11740 uint hashes_avail = 0;
11741
11742 if ((benchmark == 0) && (stdout_flag == 0))
11743 {
11744 struct stat f;
11745
11746 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11747
11748 if ((hash_mode == 2500) ||
11749 (hash_mode == 5200) ||
11750 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11751 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11752 (hash_mode == 9000))
11753 {
11754 hashlist_mode = HL_MODE_ARG;
11755
11756 char *hashfile = myargv[optind];
11757
11758 data.hashfile = hashfile;
11759
11760 logfile_top_var_string ("target", hashfile);
11761 }
11762
11763 if (hashlist_mode == HL_MODE_ARG)
11764 {
11765 if (hash_mode == 2500)
11766 {
11767 struct stat st;
11768
11769 if (stat (data.hashfile, &st) == -1)
11770 {
11771 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11772
11773 return (-1);
11774 }
11775
11776 hashes_avail = st.st_size / sizeof (hccap_t);
11777 }
11778 else
11779 {
11780 hashes_avail = 1;
11781 }
11782 }
11783 else if (hashlist_mode == HL_MODE_FILE)
11784 {
11785 char *hashfile = myargv[optind];
11786
11787 data.hashfile = hashfile;
11788
11789 logfile_top_var_string ("target", hashfile);
11790
11791 FILE *fp = NULL;
11792
11793 if ((fp = fopen (hashfile, "rb")) == NULL)
11794 {
11795 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11796
11797 return (-1);
11798 }
11799
11800 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11801
11802 hashes_avail = count_lines (fp);
11803
11804 rewind (fp);
11805
11806 if (hashes_avail == 0)
11807 {
11808 log_error ("ERROR: hashfile is empty or corrupt");
11809
11810 fclose (fp);
11811
11812 return (-1);
11813 }
11814
11815 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11816
11817 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11818 {
11819 log_error ("ERROR: remove not supported in native hashfile-format mode");
11820
11821 fclose (fp);
11822
11823 return (-1);
11824 }
11825
11826 fclose (fp);
11827 }
11828 }
11829 else
11830 {
11831 hashlist_mode = HL_MODE_ARG;
11832
11833 hashes_avail = 1;
11834 }
11835
11836 if (hash_mode == 3000) hashes_avail *= 2;
11837
11838 data.hashlist_mode = hashlist_mode;
11839 data.hashlist_format = hashlist_format;
11840
11841 logfile_top_uint (hashlist_mode);
11842 logfile_top_uint (hashlist_format);
11843
11844 /**
11845 * load hashes, part II: allocate required memory, set pointers
11846 */
11847
11848 hash_t *hashes_buf = NULL;
11849 void *digests_buf = NULL;
11850 salt_t *salts_buf = NULL;
11851 void *esalts_buf = NULL;
11852
11853 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11854
11855 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11856
11857 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11858 {
11859 u32 hash_pos;
11860
11861 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11862 {
11863 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11864
11865 hashes_buf[hash_pos].hash_info = hash_info;
11866
11867 if (username && (remove || show || left))
11868 {
11869 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11870 }
11871
11872 if (benchmark)
11873 {
11874 hash_info->orighash = (char *) mymalloc (256);
11875 }
11876 }
11877 }
11878
11879 if (isSalted)
11880 {
11881 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11882
11883 if (esalt_size)
11884 {
11885 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11886 }
11887 }
11888 else
11889 {
11890 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11891 }
11892
11893 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11894 {
11895 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11896
11897 if (isSalted)
11898 {
11899 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11900
11901 if (esalt_size)
11902 {
11903 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11904 }
11905 }
11906 else
11907 {
11908 hashes_buf[hash_pos].salt = &salts_buf[0];
11909 }
11910 }
11911
11912 /**
11913 * load hashes, part III: parse hashes or generate them if benchmark
11914 */
11915
11916 uint hashes_cnt = 0;
11917
11918 if (benchmark == 0)
11919 {
11920 if (keyspace == 1)
11921 {
11922 // useless to read hash file for keyspace, cheat a little bit w/ optind
11923 }
11924 else if (stdout_flag == 1)
11925 {
11926 // useless to read hash file for stdout, cheat a little bit w/ optind
11927 }
11928 else if (hashes_avail == 0)
11929 {
11930 }
11931 else if (hashlist_mode == HL_MODE_ARG)
11932 {
11933 char *input_buf = myargv[optind];
11934
11935 uint input_len = strlen (input_buf);
11936
11937 logfile_top_var_string ("target", input_buf);
11938
11939 char *hash_buf = NULL;
11940 int hash_len = 0;
11941
11942 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11943
11944 bool hash_fmt_error = 0;
11945
11946 if (hash_len < 1) hash_fmt_error = 1;
11947 if (hash_buf == NULL) hash_fmt_error = 1;
11948
11949 if (hash_fmt_error)
11950 {
11951 log_info ("WARNING: Failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11952 }
11953 else
11954 {
11955 if (opts_type & OPTS_TYPE_HASH_COPY)
11956 {
11957 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11958
11959 hash_info_tmp->orighash = mystrdup (hash_buf);
11960 }
11961
11962 if (isSalted)
11963 {
11964 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11965 }
11966
11967 int parser_status = PARSER_OK;
11968
11969 if (hash_mode == 2500)
11970 {
11971 if (hash_len == 0)
11972 {
11973 log_error ("ERROR: hccap file not specified");
11974
11975 return (-1);
11976 }
11977
11978 hashlist_mode = HL_MODE_FILE;
11979
11980 data.hashlist_mode = hashlist_mode;
11981
11982 FILE *fp = fopen (hash_buf, "rb");
11983
11984 if (fp == NULL)
11985 {
11986 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11987
11988 return (-1);
11989 }
11990
11991 if (hashes_avail < 1)
11992 {
11993 log_error ("ERROR: hccap file is empty or corrupt");
11994
11995 fclose (fp);
11996
11997 return (-1);
11998 }
11999
12000 uint hccap_size = sizeof (hccap_t);
12001
12002 char *in = (char *) mymalloc (hccap_size);
12003
12004 while (!feof (fp))
12005 {
12006 int n = fread (in, hccap_size, 1, fp);
12007
12008 if (n != 1)
12009 {
12010 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
12011
12012 break;
12013 }
12014
12015 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
12016
12017 if (parser_status != PARSER_OK)
12018 {
12019 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
12020
12021 continue;
12022 }
12023
12024 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
12025
12026 if ((show == 1) || (left == 1))
12027 {
12028 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
12029
12030 char *salt_ptr = (char *) tmp_salt->salt_buf;
12031
12032 int cur_pos = tmp_salt->salt_len;
12033 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12034
12035 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
12036
12037 // do the appending task
12038
12039 snprintf (salt_ptr + cur_pos,
12040 rem_len,
12041 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
12042 wpa->orig_mac1[0],
12043 wpa->orig_mac1[1],
12044 wpa->orig_mac1[2],
12045 wpa->orig_mac1[3],
12046 wpa->orig_mac1[4],
12047 wpa->orig_mac1[5],
12048 wpa->orig_mac2[0],
12049 wpa->orig_mac2[1],
12050 wpa->orig_mac2[2],
12051 wpa->orig_mac2[3],
12052 wpa->orig_mac2[4],
12053 wpa->orig_mac2[5]);
12054
12055 // memset () the remaining part of the salt
12056
12057 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
12058 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12059
12060 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
12061
12062 tmp_salt->salt_len += 1 + 12 + 1 + 12;
12063 }
12064
12065 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);
12066 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);
12067
12068 hashes_cnt++;
12069 }
12070
12071 fclose (fp);
12072
12073 myfree (in);
12074 }
12075 else if (hash_mode == 3000)
12076 {
12077 if (hash_len == 32)
12078 {
12079 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12080
12081 hash_t *lm_hash_left = NULL;
12082
12083 if (parser_status == PARSER_OK)
12084 {
12085 lm_hash_left = &hashes_buf[hashes_cnt];
12086
12087 hashes_cnt++;
12088 }
12089 else
12090 {
12091 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12092 }
12093
12094 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12095
12096 hash_t *lm_hash_right = NULL;
12097
12098 if (parser_status == PARSER_OK)
12099 {
12100 lm_hash_right = &hashes_buf[hashes_cnt];
12101
12102 hashes_cnt++;
12103 }
12104 else
12105 {
12106 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12107 }
12108
12109 // show / left
12110
12111 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12112 {
12113 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);
12114 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);
12115 }
12116 }
12117 else
12118 {
12119 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12120
12121 if (parser_status == PARSER_OK)
12122 {
12123 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12124 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12125 }
12126
12127 if (parser_status == PARSER_OK)
12128 {
12129 hashes_cnt++;
12130 }
12131 else
12132 {
12133 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12134 }
12135 }
12136 }
12137 else
12138 {
12139 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12140
12141 if (parser_status == PARSER_OK)
12142 {
12143 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12144 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12145 }
12146
12147 if (parser_status == PARSER_OK)
12148 {
12149 hashes_cnt++;
12150 }
12151 else
12152 {
12153 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12154 }
12155 }
12156 }
12157 }
12158 else if (hashlist_mode == HL_MODE_FILE)
12159 {
12160 char *hashfile = data.hashfile;
12161
12162 FILE *fp;
12163
12164 if ((fp = fopen (hashfile, "rb")) == NULL)
12165 {
12166 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12167
12168 return (-1);
12169 }
12170
12171 uint line_num = 0;
12172
12173 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12174
12175 while (!feof (fp))
12176 {
12177 line_num++;
12178
12179 int line_len = fgetl (fp, line_buf);
12180
12181 if (line_len == 0) continue;
12182
12183 char *hash_buf = NULL;
12184 int hash_len = 0;
12185
12186 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12187
12188 bool hash_fmt_error = 0;
12189
12190 if (hash_len < 1) hash_fmt_error = 1;
12191 if (hash_buf == NULL) hash_fmt_error = 1;
12192
12193 if (hash_fmt_error)
12194 {
12195 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12196
12197 continue;
12198 }
12199
12200 if (username)
12201 {
12202 char *user_buf = NULL;
12203 int user_len = 0;
12204
12205 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12206
12207 if (remove || show)
12208 {
12209 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12210
12211 *user = (user_t *) mymalloc (sizeof (user_t));
12212
12213 user_t *user_ptr = *user;
12214
12215 if (user_buf != NULL)
12216 {
12217 user_ptr->user_name = mystrdup (user_buf);
12218 }
12219 else
12220 {
12221 user_ptr->user_name = mystrdup ("");
12222 }
12223
12224 user_ptr->user_len = user_len;
12225 }
12226 }
12227
12228 if (opts_type & OPTS_TYPE_HASH_COPY)
12229 {
12230 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12231
12232 hash_info_tmp->orighash = mystrdup (hash_buf);
12233 }
12234
12235 if (isSalted)
12236 {
12237 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12238 }
12239
12240 if (hash_mode == 3000)
12241 {
12242 if (hash_len == 32)
12243 {
12244 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12245
12246 if (parser_status < PARSER_GLOBAL_ZERO)
12247 {
12248 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12249
12250 continue;
12251 }
12252
12253 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12254
12255 hashes_cnt++;
12256
12257 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12258
12259 if (parser_status < PARSER_GLOBAL_ZERO)
12260 {
12261 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12262
12263 continue;
12264 }
12265
12266 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12267
12268 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);
12269
12270 hashes_cnt++;
12271
12272 // show / left
12273
12274 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);
12275 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);
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' on 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 else
12297 {
12298 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12299
12300 if (parser_status < PARSER_GLOBAL_ZERO)
12301 {
12302 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12303
12304 continue;
12305 }
12306
12307 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);
12308
12309 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12310 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12311
12312 hashes_cnt++;
12313 }
12314 }
12315
12316 myfree (line_buf);
12317
12318 fclose (fp);
12319
12320 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12321
12322 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12323 }
12324 }
12325 else
12326 {
12327 if (isSalted)
12328 {
12329 hashes_buf[0].salt->salt_len = 8;
12330
12331 // special salt handling
12332
12333 switch (hash_mode)
12334 {
12335 case 1500: hashes_buf[0].salt->salt_len = 2;
12336 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12337 break;
12338 case 1731: hashes_buf[0].salt->salt_len = 4;
12339 break;
12340 case 2410: hashes_buf[0].salt->salt_len = 4;
12341 break;
12342 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12343 break;
12344 case 3100: hashes_buf[0].salt->salt_len = 1;
12345 break;
12346 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
12347 break;
12348 case 5800: hashes_buf[0].salt->salt_len = 16;
12349 break;
12350 case 6800: hashes_buf[0].salt->salt_len = 32;
12351 break;
12352 case 8400: hashes_buf[0].salt->salt_len = 40;
12353 break;
12354 case 8800: hashes_buf[0].salt->salt_len = 16;
12355 break;
12356 case 8900: hashes_buf[0].salt->salt_len = 16;
12357 hashes_buf[0].salt->scrypt_N = 1024;
12358 hashes_buf[0].salt->scrypt_r = 1;
12359 hashes_buf[0].salt->scrypt_p = 1;
12360 break;
12361 case 9100: hashes_buf[0].salt->salt_len = 16;
12362 break;
12363 case 9300: hashes_buf[0].salt->salt_len = 14;
12364 hashes_buf[0].salt->scrypt_N = 16384;
12365 hashes_buf[0].salt->scrypt_r = 1;
12366 hashes_buf[0].salt->scrypt_p = 1;
12367 break;
12368 case 9400: hashes_buf[0].salt->salt_len = 16;
12369 break;
12370 case 9500: hashes_buf[0].salt->salt_len = 16;
12371 break;
12372 case 9600: hashes_buf[0].salt->salt_len = 16;
12373 break;
12374 case 9700: hashes_buf[0].salt->salt_len = 16;
12375 break;
12376 case 9710: hashes_buf[0].salt->salt_len = 16;
12377 break;
12378 case 9720: hashes_buf[0].salt->salt_len = 16;
12379 break;
12380 case 9800: hashes_buf[0].salt->salt_len = 16;
12381 break;
12382 case 9810: hashes_buf[0].salt->salt_len = 16;
12383 break;
12384 case 9820: hashes_buf[0].salt->salt_len = 16;
12385 break;
12386 case 10300: hashes_buf[0].salt->salt_len = 12;
12387 break;
12388 case 11500: hashes_buf[0].salt->salt_len = 4;
12389 break;
12390 case 11600: hashes_buf[0].salt->salt_len = 4;
12391 break;
12392 case 12400: hashes_buf[0].salt->salt_len = 4;
12393 break;
12394 case 12500: hashes_buf[0].salt->salt_len = 8;
12395 break;
12396 case 12600: hashes_buf[0].salt->salt_len = 64;
12397 break;
12398 }
12399
12400 // special esalt handling
12401
12402 switch (hash_mode)
12403 {
12404 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12405 break;
12406 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12407 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12408 break;
12409 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12410 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12411 break;
12412 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12413 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12414 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12415 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12416 break;
12417 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12418 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12419 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12420 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12421 break;
12422 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12423 break;
12424 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12425 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12426 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12427 break;
12428 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12429 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12430 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12431 break;
12432 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12433 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12434 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12435 break;
12436 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12437 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12438 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12439 break;
12440 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12441 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12442 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12443 break;
12444 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12445 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12446 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12447 break;
12448 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12449 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12450 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12451 break;
12452 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12453 break;
12454 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12455 break;
12456 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12457 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12458 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12459 break;
12460 }
12461 }
12462
12463 // set hashfile
12464
12465 switch (hash_mode)
12466 {
12467 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12468 break;
12469 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12470 break;
12471 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12472 break;
12473 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12474 break;
12475 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12476 break;
12477 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12478 break;
12479 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12480 break;
12481 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12482 break;
12483 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12484 break;
12485 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12486 break;
12487 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12488 break;
12489 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12490 break;
12491 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12492 break;
12493 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12494 break;
12495 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12496 break;
12497 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12498 break;
12499 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12500 break;
12501 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12502 break;
12503 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12504 break;
12505 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12506 break;
12507 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12508 break;
12509 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12510 break;
12511 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12512 break;
12513 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12514 break;
12515 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12516 break;
12517 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12518 break;
12519 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12520 break;
12521 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12522 break;
12523 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12524 break;
12525 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12526 break;
12527 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12528 break;
12529 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12530 break;
12531 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12532 break;
12533 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12534 break;
12535 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12536 break;
12537 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12538 break;
12539 }
12540
12541 // set default iterations
12542
12543 switch (hash_mode)
12544 {
12545 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12546 break;
12547 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12548 break;
12549 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12550 break;
12551 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12552 break;
12553 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12554 break;
12555 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12556 break;
12557 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12558 break;
12559 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12560 break;
12561 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12562 break;
12563 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12564 break;
12565 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12566 break;
12567 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12568 break;
12569 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12570 break;
12571 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12572 break;
12573 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12574 break;
12575 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12576 break;
12577 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12578 break;
12579 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12580 break;
12581 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12582 break;
12583 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12584 break;
12585 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12586 break;
12587 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12588 break;
12589 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12590 break;
12591 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12592 break;
12593 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12594 break;
12595 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12596 break;
12597 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12598 break;
12599 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12600 break;
12601 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12602 break;
12603 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12604 break;
12605 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12606 break;
12607 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12608 break;
12609 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12610 break;
12611 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12612 break;
12613 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12614 break;
12615 case 8900: hashes_buf[0].salt->salt_iter = 1;
12616 break;
12617 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12618 break;
12619 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12620 break;
12621 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12622 break;
12623 case 9300: hashes_buf[0].salt->salt_iter = 1;
12624 break;
12625 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12626 break;
12627 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12628 break;
12629 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12630 break;
12631 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12632 break;
12633 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12634 break;
12635 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12636 break;
12637 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12638 break;
12639 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12640 break;
12641 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12642 break;
12643 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12644 break;
12645 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12646 break;
12647 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12648 break;
12649 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12650 break;
12651 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12652 break;
12653 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12654 break;
12655 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12656 break;
12657 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12658 break;
12659 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12660 break;
12661 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12662 break;
12663 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12664 break;
12665 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12666 break;
12667 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12668 break;
12669 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12670 break;
12671 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12672 break;
12673 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12674 break;
12675 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12676 break;
12677 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12678 break;
12679 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12680 break;
12681 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12682 break;
12683 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12684 break;
12685 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12686 break;
12687 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12688 break;
12689 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12690 break;
12691 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12692 break;
12693 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12694 break;
12695 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12696 break;
12697 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12698 break;
12699 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12700 break;
12701 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12702 break;
12703 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12704 break;
12705 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12706 break;
12707 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12708 break;
12709 }
12710
12711 hashes_cnt = 1;
12712 }
12713
12714 if (show == 1 || left == 1)
12715 {
12716 for (uint i = 0; i < pot_cnt; i++)
12717 {
12718 pot_t *pot_ptr = &pot[i];
12719
12720 hash_t *hashes_buf = &pot_ptr->hash;
12721
12722 local_free (hashes_buf->digest);
12723
12724 if (isSalted)
12725 {
12726 local_free (hashes_buf->salt);
12727 }
12728 }
12729
12730 local_free (pot);
12731
12732 if (data.quiet == 0) log_info_nn ("");
12733
12734 return (0);
12735 }
12736
12737 if ((keyspace == 0) && (stdout_flag == 0))
12738 {
12739 if (hashes_cnt == 0)
12740 {
12741 log_error ("ERROR: No hashes loaded");
12742
12743 return (-1);
12744 }
12745 }
12746
12747 /**
12748 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12749 */
12750
12751 if (data.outfile != NULL)
12752 {
12753 if (data.hashfile != NULL)
12754 {
12755 #ifdef _POSIX
12756 struct stat tmpstat_outfile;
12757 struct stat tmpstat_hashfile;
12758 #endif
12759
12760 #ifdef _WIN
12761 struct stat64 tmpstat_outfile;
12762 struct stat64 tmpstat_hashfile;
12763 #endif
12764
12765 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12766
12767 if (tmp_outfile_fp)
12768 {
12769 #ifdef _POSIX
12770 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12771 #endif
12772
12773 #ifdef _WIN
12774 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12775 #endif
12776
12777 fclose (tmp_outfile_fp);
12778 }
12779
12780 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12781
12782 if (tmp_hashfile_fp)
12783 {
12784 #ifdef _POSIX
12785 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12786 #endif
12787
12788 #ifdef _WIN
12789 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12790 #endif
12791
12792 fclose (tmp_hashfile_fp);
12793 }
12794
12795 if (tmp_outfile_fp && tmp_outfile_fp)
12796 {
12797 tmpstat_outfile.st_mode = 0;
12798 tmpstat_outfile.st_nlink = 0;
12799 tmpstat_outfile.st_uid = 0;
12800 tmpstat_outfile.st_gid = 0;
12801 tmpstat_outfile.st_rdev = 0;
12802 tmpstat_outfile.st_atime = 0;
12803
12804 tmpstat_hashfile.st_mode = 0;
12805 tmpstat_hashfile.st_nlink = 0;
12806 tmpstat_hashfile.st_uid = 0;
12807 tmpstat_hashfile.st_gid = 0;
12808 tmpstat_hashfile.st_rdev = 0;
12809 tmpstat_hashfile.st_atime = 0;
12810
12811 #ifdef _POSIX
12812 tmpstat_outfile.st_blksize = 0;
12813 tmpstat_outfile.st_blocks = 0;
12814
12815 tmpstat_hashfile.st_blksize = 0;
12816 tmpstat_hashfile.st_blocks = 0;
12817 #endif
12818
12819 #ifdef _POSIX
12820 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12821 {
12822 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12823
12824 return (-1);
12825 }
12826 #endif
12827
12828 #ifdef _WIN
12829 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12830 {
12831 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12832
12833 return (-1);
12834 }
12835 #endif
12836 }
12837 }
12838 }
12839
12840 /**
12841 * Remove duplicates
12842 */
12843
12844 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12845
12846 if (isSalted)
12847 {
12848 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12849 }
12850 else
12851 {
12852 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12853 }
12854
12855 uint hashes_cnt_orig = hashes_cnt;
12856
12857 hashes_cnt = 1;
12858
12859 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12860 {
12861 if (isSalted)
12862 {
12863 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12864 {
12865 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12866 }
12867 }
12868 else
12869 {
12870 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12871 }
12872
12873 if (hashes_pos > hashes_cnt)
12874 {
12875 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12876 }
12877
12878 hashes_cnt++;
12879 }
12880
12881 /**
12882 * Potfile removes
12883 */
12884
12885 uint potfile_remove_cracks = 0;
12886
12887 if (potfile_disable == 0)
12888 {
12889 hash_t hash_buf;
12890
12891 hash_buf.digest = mymalloc (dgst_size);
12892 hash_buf.salt = NULL;
12893 hash_buf.esalt = NULL;
12894 hash_buf.hash_info = NULL;
12895 hash_buf.cracked = 0;
12896
12897 if (isSalted)
12898 {
12899 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12900 }
12901
12902 if (esalt_size)
12903 {
12904 hash_buf.esalt = mymalloc (esalt_size);
12905 }
12906
12907 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12908
12909 // no solution for these special hash types (for instane because they use hashfile in output etc)
12910 if ((hash_mode != 5200) &&
12911 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12912 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12913 (hash_mode != 9000))
12914 {
12915 FILE *fp = fopen (potfile, "rb");
12916
12917 if (fp != NULL)
12918 {
12919 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12920
12921 // to be safe work with a copy (because of line_len loop, i etc)
12922 // moved up here because it's easier to handle continue case
12923 // it's just 64kb
12924
12925 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12926
12927 while (!feof (fp))
12928 {
12929 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12930
12931 if (ptr == NULL) break;
12932
12933 int line_len = strlen (line_buf);
12934
12935 if (line_len == 0) continue;
12936
12937 int iter = MAX_CUT_TRIES;
12938
12939 for (int i = line_len - 1; i && iter; i--, line_len--)
12940 {
12941 if (line_buf[i] != ':') continue;
12942
12943 if (isSalted)
12944 {
12945 memset (hash_buf.salt, 0, sizeof (salt_t));
12946 }
12947
12948 hash_t *found = NULL;
12949
12950 if (hash_mode == 6800)
12951 {
12952 if (i < 64) // 64 = 16 * uint in salt_buf[]
12953 {
12954 // manipulate salt_buf
12955 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12956
12957 hash_buf.salt->salt_len = i;
12958
12959 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12960 }
12961 }
12962 else if (hash_mode == 2500)
12963 {
12964 if (i < 64) // 64 = 16 * uint in salt_buf[]
12965 {
12966 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12967 // manipulate salt_buf
12968
12969 memcpy (line_buf_cpy, line_buf, i);
12970
12971 char *mac2_pos = strrchr (line_buf_cpy, ':');
12972
12973 if (mac2_pos == NULL) continue;
12974
12975 mac2_pos[0] = 0;
12976 mac2_pos++;
12977
12978 if (strlen (mac2_pos) != 12) continue;
12979
12980 char *mac1_pos = strrchr (line_buf_cpy, ':');
12981
12982 if (mac1_pos == NULL) continue;
12983
12984 mac1_pos[0] = 0;
12985 mac1_pos++;
12986
12987 if (strlen (mac1_pos) != 12) continue;
12988
12989 uint essid_length = mac1_pos - line_buf_cpy - 1;
12990
12991 // here we need the ESSID
12992 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12993
12994 hash_buf.salt->salt_len = essid_length;
12995
12996 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12997
12998 if (found)
12999 {
13000 wpa_t *wpa = (wpa_t *) found->esalt;
13001
13002 // compare hex string(s) vs binary MAC address(es)
13003
13004 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13005 {
13006 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
13007 {
13008 found = NULL;
13009
13010 break;
13011 }
13012 }
13013
13014 // early skip ;)
13015 if (!found) continue;
13016
13017 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13018 {
13019 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
13020 {
13021 found = NULL;
13022
13023 break;
13024 }
13025 }
13026 }
13027 }
13028 }
13029 else
13030 {
13031 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
13032
13033 if (parser_status == PARSER_OK)
13034 {
13035 if (isSalted)
13036 {
13037 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
13038 }
13039 else
13040 {
13041 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
13042 }
13043 }
13044 }
13045
13046 if (found == NULL) continue;
13047
13048 if (!found->cracked) potfile_remove_cracks++;
13049
13050 found->cracked = 1;
13051
13052 if (found) break;
13053
13054 iter--;
13055 }
13056 }
13057
13058 myfree (line_buf_cpy);
13059
13060 myfree (line_buf);
13061
13062 fclose (fp);
13063 }
13064 }
13065
13066 if (esalt_size)
13067 {
13068 local_free (hash_buf.esalt);
13069 }
13070
13071 if (isSalted)
13072 {
13073 local_free (hash_buf.salt);
13074 }
13075
13076 local_free (hash_buf.digest);
13077 }
13078
13079 /**
13080 * Now generate all the buffers required for later
13081 */
13082
13083 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
13084
13085 salt_t *salts_buf_new = NULL;
13086 void *esalts_buf_new = NULL;
13087
13088 if (isSalted)
13089 {
13090 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
13091
13092 if (esalt_size)
13093 {
13094 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
13095 }
13096 }
13097 else
13098 {
13099 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13100 }
13101
13102 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13103
13104 uint digests_cnt = hashes_cnt;
13105 uint digests_done = 0;
13106
13107 size_t size_digests = digests_cnt * dgst_size;
13108 size_t size_shown = digests_cnt * sizeof (uint);
13109
13110 uint *digests_shown = (uint *) mymalloc (size_shown);
13111 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13112
13113 uint salts_cnt = 0;
13114 uint salts_done = 0;
13115
13116 hashinfo_t **hash_info = NULL;
13117
13118 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13119 {
13120 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13121
13122 if (username && (remove || show))
13123 {
13124 uint user_pos;
13125
13126 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13127 {
13128 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13129
13130 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13131 }
13132 }
13133 }
13134
13135 uint *salts_shown = (uint *) mymalloc (size_shown);
13136
13137 salt_t *salt_buf;
13138
13139 {
13140 // copied from inner loop
13141
13142 salt_buf = &salts_buf_new[salts_cnt];
13143
13144 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13145
13146 if (esalt_size)
13147 {
13148 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13149 }
13150
13151 salt_buf->digests_cnt = 0;
13152 salt_buf->digests_done = 0;
13153 salt_buf->digests_offset = 0;
13154
13155 salts_cnt++;
13156 }
13157
13158 if (hashes_buf[0].cracked == 1)
13159 {
13160 digests_shown[0] = 1;
13161
13162 digests_done++;
13163
13164 salt_buf->digests_done++;
13165 }
13166
13167 salt_buf->digests_cnt++;
13168
13169 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13170
13171 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13172 {
13173 hash_info[0] = hashes_buf[0].hash_info;
13174 }
13175
13176 // copy from inner loop
13177
13178 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13179 {
13180 if (isSalted)
13181 {
13182 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13183 {
13184 salt_buf = &salts_buf_new[salts_cnt];
13185
13186 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13187
13188 if (esalt_size)
13189 {
13190 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13191 }
13192
13193 salt_buf->digests_cnt = 0;
13194 salt_buf->digests_done = 0;
13195 salt_buf->digests_offset = hashes_pos;
13196
13197 salts_cnt++;
13198 }
13199 }
13200
13201 if (hashes_buf[hashes_pos].cracked == 1)
13202 {
13203 digests_shown[hashes_pos] = 1;
13204
13205 digests_done++;
13206
13207 salt_buf->digests_done++;
13208 }
13209
13210 salt_buf->digests_cnt++;
13211
13212 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13213
13214 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13215 {
13216 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13217 }
13218 }
13219
13220 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13221 {
13222 salt_t *salt_buf = &salts_buf_new[salt_pos];
13223
13224 if (salt_buf->digests_done == salt_buf->digests_cnt)
13225 {
13226 salts_shown[salt_pos] = 1;
13227
13228 salts_done++;
13229 }
13230
13231 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13232 }
13233
13234 local_free (digests_buf);
13235 local_free (salts_buf);
13236 local_free (esalts_buf);
13237
13238 digests_buf = digests_buf_new;
13239 salts_buf = salts_buf_new;
13240 esalts_buf = esalts_buf_new;
13241
13242 local_free (hashes_buf);
13243
13244 /**
13245 * special modification not set from parser
13246 */
13247
13248 switch (hash_mode)
13249 {
13250 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13251 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13252 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13253 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13254 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13255 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13256 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13257 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13258 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13259 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13260 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13261 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13262 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13263 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13264 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13265 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13266 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13267 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13268 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13269 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13270 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13271 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13272 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13273 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13274 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13275 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13276 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13277 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13278 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13279 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13280 }
13281
13282 if (truecrypt_keyfiles)
13283 {
13284 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13285
13286 char *keyfiles = strdup (truecrypt_keyfiles);
13287
13288 char *keyfile = strtok (keyfiles, ",");
13289
13290 do
13291 {
13292 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13293
13294 } while ((keyfile = strtok (NULL, ",")) != NULL);
13295
13296 free (keyfiles);
13297 }
13298
13299 if (veracrypt_keyfiles)
13300 {
13301 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13302
13303 char *keyfiles = strdup (veracrypt_keyfiles);
13304
13305 char *keyfile = strtok (keyfiles, ",");
13306
13307 do
13308 {
13309 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13310
13311 } while ((keyfile = strtok (NULL, ",")) != NULL);
13312
13313 free (keyfiles);
13314 }
13315
13316 data.digests_cnt = digests_cnt;
13317 data.digests_done = digests_done;
13318 data.digests_buf = digests_buf;
13319 data.digests_shown = digests_shown;
13320 data.digests_shown_tmp = digests_shown_tmp;
13321
13322 data.salts_cnt = salts_cnt;
13323 data.salts_done = salts_done;
13324 data.salts_buf = salts_buf;
13325 data.salts_shown = salts_shown;
13326
13327 data.esalts_buf = esalts_buf;
13328 data.hash_info = hash_info;
13329
13330 /**
13331 * Automatic Optimizers
13332 */
13333
13334 if (salts_cnt == 1)
13335 opti_type |= OPTI_TYPE_SINGLE_SALT;
13336
13337 if (digests_cnt == 1)
13338 opti_type |= OPTI_TYPE_SINGLE_HASH;
13339
13340 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13341 opti_type |= OPTI_TYPE_NOT_ITERATED;
13342
13343 if (attack_mode == ATTACK_MODE_BF)
13344 opti_type |= OPTI_TYPE_BRUTE_FORCE;
13345
13346 data.opti_type = opti_type;
13347
13348 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13349 {
13350 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13351 {
13352 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13353 {
13354 if (opts_type & OPTS_TYPE_ST_ADD80)
13355 {
13356 opts_type &= ~OPTS_TYPE_ST_ADD80;
13357 opts_type |= OPTS_TYPE_PT_ADD80;
13358 }
13359
13360 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13361 {
13362 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13363 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13364 }
13365
13366 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13367 {
13368 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13369 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13370 }
13371 }
13372 }
13373 }
13374
13375 /**
13376 * Some algorithm, like descrypt, can benefit from JIT compilation
13377 */
13378
13379 int force_jit_compilation = -1;
13380
13381 if (hash_mode == 8900)
13382 {
13383 force_jit_compilation = 8900;
13384 }
13385 else if (hash_mode == 9300)
13386 {
13387 force_jit_compilation = 8900;
13388 }
13389 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13390 {
13391 force_jit_compilation = 1500;
13392 }
13393
13394 /**
13395 * generate bitmap tables
13396 */
13397
13398 const uint bitmap_shift1 = 5;
13399 const uint bitmap_shift2 = 13;
13400
13401 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13402
13403 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13404 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13405 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13406 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13407 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13408 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13409 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13410 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13411
13412 uint bitmap_bits;
13413 uint bitmap_nums;
13414 uint bitmap_mask;
13415 uint bitmap_size;
13416
13417 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13418 {
13419 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13420
13421 bitmap_nums = 1 << bitmap_bits;
13422
13423 bitmap_mask = bitmap_nums - 1;
13424
13425 bitmap_size = bitmap_nums * sizeof (uint);
13426
13427 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13428
13429 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;
13430 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;
13431
13432 break;
13433 }
13434
13435 bitmap_nums = 1 << bitmap_bits;
13436
13437 bitmap_mask = bitmap_nums - 1;
13438
13439 bitmap_size = bitmap_nums * sizeof (uint);
13440
13441 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);
13442 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);
13443
13444 /**
13445 * prepare quick rule
13446 */
13447
13448 data.rule_buf_l = rule_buf_l;
13449 data.rule_buf_r = rule_buf_r;
13450
13451 int rule_len_l = (int) strlen (rule_buf_l);
13452 int rule_len_r = (int) strlen (rule_buf_r);
13453
13454 data.rule_len_l = rule_len_l;
13455 data.rule_len_r = rule_len_r;
13456
13457 /**
13458 * load rules
13459 */
13460
13461 uint *all_kernel_rules_cnt = NULL;
13462
13463 kernel_rule_t **all_kernel_rules_buf = NULL;
13464
13465 if (rp_files_cnt)
13466 {
13467 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13468
13469 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13470 }
13471
13472 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13473
13474 int rule_len = 0;
13475
13476 for (uint i = 0; i < rp_files_cnt; i++)
13477 {
13478 uint kernel_rules_avail = 0;
13479
13480 uint kernel_rules_cnt = 0;
13481
13482 kernel_rule_t *kernel_rules_buf = NULL;
13483
13484 char *rp_file = rp_files[i];
13485
13486 char in[BLOCK_SIZE] = { 0 };
13487 char out[BLOCK_SIZE] = { 0 };
13488
13489 FILE *fp = NULL;
13490
13491 uint rule_line = 0;
13492
13493 if ((fp = fopen (rp_file, "rb")) == NULL)
13494 {
13495 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13496
13497 return (-1);
13498 }
13499
13500 while (!feof (fp))
13501 {
13502 memset (rule_buf, 0, HCBUFSIZ);
13503
13504 rule_len = fgetl (fp, rule_buf);
13505
13506 rule_line++;
13507
13508 if (rule_len == 0) continue;
13509
13510 if (rule_buf[0] == '#') continue;
13511
13512 if (kernel_rules_avail == kernel_rules_cnt)
13513 {
13514 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13515
13516 kernel_rules_avail += INCR_RULES;
13517 }
13518
13519 memset (in, 0, BLOCK_SIZE);
13520 memset (out, 0, BLOCK_SIZE);
13521
13522 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13523
13524 if (result == -1)
13525 {
13526 log_info ("WARNING: Skipping invalid or unsupported rule in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13527
13528 continue;
13529 }
13530
13531 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13532 {
13533 log_info ("WARNING: Cannot convert rule for use on OpenCL device in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13534
13535 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13536
13537 continue;
13538 }
13539
13540 /* its so slow
13541 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13542 {
13543 log_info ("Duplicate rule for use on OpenCL device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13544
13545 continue;
13546 }
13547 */
13548
13549 kernel_rules_cnt++;
13550 }
13551
13552 fclose (fp);
13553
13554 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13555
13556 all_kernel_rules_buf[i] = kernel_rules_buf;
13557 }
13558
13559 /**
13560 * merge rules or automatic rule generator
13561 */
13562
13563 uint kernel_rules_cnt = 0;
13564
13565 kernel_rule_t *kernel_rules_buf = NULL;
13566
13567 if (attack_mode == ATTACK_MODE_STRAIGHT)
13568 {
13569 if (rp_files_cnt)
13570 {
13571 kernel_rules_cnt = 1;
13572
13573 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13574
13575 repeats[0] = kernel_rules_cnt;
13576
13577 for (uint i = 0; i < rp_files_cnt; i++)
13578 {
13579 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13580
13581 repeats[i + 1] = kernel_rules_cnt;
13582 }
13583
13584 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13585
13586 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13587
13588 for (uint i = 0; i < kernel_rules_cnt; i++)
13589 {
13590 uint out_pos = 0;
13591
13592 kernel_rule_t *out = &kernel_rules_buf[i];
13593
13594 for (uint j = 0; j < rp_files_cnt; j++)
13595 {
13596 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13597 uint in_pos;
13598
13599 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13600
13601 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13602 {
13603 if (out_pos == RULES_MAX - 1)
13604 {
13605 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13606
13607 break;
13608 }
13609
13610 out->cmds[out_pos] = in->cmds[in_pos];
13611 }
13612 }
13613 }
13614
13615 local_free (repeats);
13616 }
13617 else if (rp_gen)
13618 {
13619 uint kernel_rules_avail = 0;
13620
13621 while (kernel_rules_cnt < rp_gen)
13622 {
13623 if (kernel_rules_avail == kernel_rules_cnt)
13624 {
13625 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13626
13627 kernel_rules_avail += INCR_RULES;
13628 }
13629
13630 memset (rule_buf, 0, HCBUFSIZ);
13631
13632 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13633
13634 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13635
13636 kernel_rules_cnt++;
13637 }
13638 }
13639 }
13640
13641 myfree (rule_buf);
13642
13643 /**
13644 * generate NOP rules
13645 */
13646
13647 if ((rp_files_cnt == 0) && (rp_gen == 0))
13648 {
13649 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13650
13651 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13652
13653 kernel_rules_cnt++;
13654 }
13655
13656 data.kernel_rules_cnt = kernel_rules_cnt;
13657 data.kernel_rules_buf = kernel_rules_buf;
13658
13659 if (kernel_rules_cnt == 0)
13660 {
13661 log_error ("ERROR: No valid rules left");
13662
13663 return (-1);
13664 }
13665
13666 /**
13667 * OpenCL platforms: detect
13668 */
13669
13670 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13671 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13672
13673 cl_uint platforms_cnt = 0;
13674 cl_uint platform_devices_cnt = 0;
13675
13676 if (keyspace == 0)
13677 {
13678 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13679
13680 if (platforms_cnt == 0)
13681 {
13682 log_info ("");
13683 log_info ("ATTENTION! No OpenCL compatible platform found");
13684 log_info ("");
13685 log_info ("You're probably missing the OpenCL runtime installation");
13686 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13687 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13688 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13689 log_info ("");
13690
13691 return (-1);
13692 }
13693
13694 if (opencl_platforms_filter != (uint) -1)
13695 {
13696 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13697
13698 if (opencl_platforms_filter > platform_cnt_mask)
13699 {
13700 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13701
13702 return (-1);
13703 }
13704 }
13705 }
13706
13707 if (opencl_device_types == NULL)
13708 {
13709 /**
13710 * OpenCL device types:
13711 * 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.
13712 */
13713
13714 cl_device_type device_types_all = 0;
13715
13716 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13717 {
13718 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13719
13720 cl_platform_id platform = platforms[platform_id];
13721
13722 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13723
13724 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13725 {
13726 cl_device_id device = platform_devices[platform_devices_id];
13727
13728 cl_device_type device_type;
13729
13730 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13731
13732 device_types_all |= device_type;
13733 }
13734 }
13735
13736 // In such a case, automatically enable CPU device type support, since it's disabled by default.
13737
13738 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13739 {
13740 device_types_filter |= CL_DEVICE_TYPE_CPU;
13741 }
13742
13743 // In another case, when the user uses --stdout, using CPU devices is much faster to setup
13744 // If we have a CPU device, force it to be used
13745
13746 if (stdout_flag == 1)
13747 {
13748 if (device_types_all & CL_DEVICE_TYPE_CPU)
13749 {
13750 device_types_filter = CL_DEVICE_TYPE_CPU;
13751 }
13752 }
13753 }
13754
13755 /**
13756 * OpenCL devices: simply push all devices from all platforms into the same device array
13757 */
13758
13759 int need_adl = 0;
13760 int need_nvapi = 0;
13761 int need_nvml = 0;
13762 int need_xnvctrl = 0;
13763
13764 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13765
13766 data.devices_param = devices_param;
13767
13768 uint devices_cnt = 0;
13769
13770 uint devices_active = 0;
13771
13772 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13773 {
13774 cl_platform_id platform = platforms[platform_id];
13775
13776 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13777
13778 char platform_vendor[INFOSZ] = { 0 };
13779
13780 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13781
13782 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13783 // this causes trouble with vendor id based macros
13784 // we'll assign generic to those without special optimization available
13785
13786 cl_uint platform_vendor_id = 0;
13787
13788 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13789 {
13790 platform_vendor_id = VENDOR_ID_AMD;
13791 }
13792 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13793 {
13794 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13795 }
13796 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13797 {
13798 platform_vendor_id = VENDOR_ID_APPLE;
13799 }
13800 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13801 {
13802 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13803 }
13804 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13805 {
13806 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13807 }
13808 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13809 {
13810 platform_vendor_id = VENDOR_ID_MESA;
13811 }
13812 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13813 {
13814 platform_vendor_id = VENDOR_ID_NV;
13815 }
13816 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13817 {
13818 platform_vendor_id = VENDOR_ID_POCL;
13819 }
13820 else
13821 {
13822 platform_vendor_id = VENDOR_ID_GENERIC;
13823 }
13824
13825 const uint platform_skipped = ((opencl_platforms_filter & (1 << platform_id)) == 0);
13826
13827 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13828 {
13829 if (machine_readable == 0)
13830 {
13831 if (platform_skipped == 0)
13832 {
13833 const int len = log_info ("OpenCL Platform #%u: %s", platform_id + 1, platform_vendor);
13834
13835 char line[256] = { 0 };
13836
13837 for (int i = 0; i < len; i++) line[i] = '=';
13838
13839 log_info (line);
13840 }
13841 else
13842 {
13843 log_info ("OpenCL Platform #%u: %s, skipped", platform_id + 1, platform_vendor);
13844 log_info ("");
13845 }
13846 }
13847 }
13848
13849 if (platform_skipped == 1) continue;
13850
13851 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13852 {
13853 size_t param_value_size = 0;
13854
13855 const uint device_id = devices_cnt;
13856
13857 hc_device_param_t *device_param = &data.devices_param[device_id];
13858
13859 device_param->platform_vendor_id = platform_vendor_id;
13860
13861 device_param->device = platform_devices[platform_devices_id];
13862
13863 device_param->device_id = device_id;
13864
13865 device_param->platform_devices_id = platform_devices_id;
13866
13867 // device_type
13868
13869 cl_device_type device_type;
13870
13871 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13872
13873 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13874
13875 device_param->device_type = device_type;
13876
13877 // device_name
13878
13879 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13880
13881 char *device_name = (char *) mymalloc (param_value_size);
13882
13883 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13884
13885 device_param->device_name = device_name;
13886
13887 // device_vendor
13888
13889 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13890
13891 char *device_vendor = (char *) mymalloc (param_value_size);
13892
13893 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13894
13895 device_param->device_vendor = device_vendor;
13896
13897 cl_uint device_vendor_id = 0;
13898
13899 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13900 {
13901 device_vendor_id = VENDOR_ID_AMD;
13902 }
13903 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13904 {
13905 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13906 }
13907 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13908 {
13909 device_vendor_id = VENDOR_ID_APPLE;
13910 }
13911 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13912 {
13913 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13914 }
13915 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13916 {
13917 device_vendor_id = VENDOR_ID_INTEL_SDK;
13918 }
13919 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13920 {
13921 device_vendor_id = VENDOR_ID_MESA;
13922 }
13923 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13924 {
13925 device_vendor_id = VENDOR_ID_NV;
13926 }
13927 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13928 {
13929 device_vendor_id = VENDOR_ID_POCL;
13930 }
13931 else
13932 {
13933 device_vendor_id = VENDOR_ID_GENERIC;
13934 }
13935
13936 device_param->device_vendor_id = device_vendor_id;
13937
13938 // tuning db
13939
13940 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13941
13942 // device_version
13943
13944 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13945
13946 char *device_version = (char *) mymalloc (param_value_size);
13947
13948 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13949
13950 device_param->device_version = device_version;
13951
13952 // device_opencl_version
13953
13954 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13955
13956 char *device_opencl_version = (char *) mymalloc (param_value_size);
13957
13958 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13959
13960 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13961
13962 myfree (device_opencl_version);
13963
13964 // vector_width
13965
13966 cl_uint vector_width;
13967
13968 if (opencl_vector_width_chgd == 0)
13969 {
13970 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13971 {
13972 if (opti_type & OPTI_TYPE_USES_BITS_64)
13973 {
13974 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13975 }
13976 else
13977 {
13978 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13979 }
13980 }
13981 else
13982 {
13983 vector_width = (cl_uint) tuningdb_entry->vector_width;
13984 }
13985 }
13986 else
13987 {
13988 vector_width = opencl_vector_width;
13989 }
13990
13991 if (vector_width > 16) vector_width = 16;
13992
13993 device_param->vector_width = vector_width;
13994
13995 // max_compute_units
13996
13997 cl_uint device_processors;
13998
13999 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
14000
14001 device_param->device_processors = device_processors;
14002
14003 // device_maxmem_alloc
14004 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
14005
14006 cl_ulong device_maxmem_alloc;
14007
14008 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
14009
14010 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
14011
14012 // device_global_mem
14013
14014 cl_ulong device_global_mem;
14015
14016 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
14017
14018 device_param->device_global_mem = device_global_mem;
14019
14020 // max_work_group_size
14021
14022 size_t device_maxworkgroup_size;
14023
14024 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
14025
14026 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
14027
14028 // max_clock_frequency
14029
14030 cl_uint device_maxclock_frequency;
14031
14032 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
14033
14034 device_param->device_maxclock_frequency = device_maxclock_frequency;
14035
14036 // device_endian_little
14037
14038 cl_bool device_endian_little;
14039
14040 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
14041
14042 if (device_endian_little == CL_FALSE)
14043 {
14044 log_info ("- Device #%u: WARNING: Not a little endian device", device_id + 1);
14045
14046 device_param->skipped = 1;
14047 }
14048
14049 // device_available
14050
14051 cl_bool device_available;
14052
14053 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
14054
14055 if (device_available == CL_FALSE)
14056 {
14057 log_info ("- Device #%u: WARNING: Device not available", device_id + 1);
14058
14059 device_param->skipped = 1;
14060 }
14061
14062 // device_compiler_available
14063
14064 cl_bool device_compiler_available;
14065
14066 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
14067
14068 if (device_compiler_available == CL_FALSE)
14069 {
14070 log_info ("- Device #%u: WARNING: No compiler available for device", device_id + 1);
14071
14072 device_param->skipped = 1;
14073 }
14074
14075 // device_execution_capabilities
14076
14077 cl_device_exec_capabilities device_execution_capabilities;
14078
14079 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
14080
14081 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
14082 {
14083 log_info ("- Device #%u: WARNING: Device does not support executing kernels", device_id + 1);
14084
14085 device_param->skipped = 1;
14086 }
14087
14088 // device_extensions
14089
14090 size_t device_extensions_size;
14091
14092 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
14093
14094 char *device_extensions = mymalloc (device_extensions_size + 1);
14095
14096 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
14097
14098 if (strstr (device_extensions, "base_atomics") == 0)
14099 {
14100 log_info ("- Device #%u: WARNING: Device does not support base atomics", device_id + 1);
14101
14102 device_param->skipped = 1;
14103 }
14104
14105 if (strstr (device_extensions, "byte_addressable_store") == 0)
14106 {
14107 log_info ("- Device #%u: WARNING: Device does not support byte addressable store", device_id + 1);
14108
14109 device_param->skipped = 1;
14110 }
14111
14112 myfree (device_extensions);
14113
14114 // device_local_mem_size
14115
14116 cl_ulong device_local_mem_size;
14117
14118 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
14119
14120 if (device_local_mem_size < 32768)
14121 {
14122 log_info ("- Device #%u: WARNING: Device local mem size is too small", device_id + 1);
14123
14124 device_param->skipped = 1;
14125 }
14126
14127 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
14128 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
14129 // This results in both utilizing it for 50%
14130 // However, Intel has much better SIMD control over their own hardware
14131 // It makes sense to give them full control over their own hardware
14132
14133 if (device_type & CL_DEVICE_TYPE_CPU)
14134 {
14135 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14136 {
14137 if (data.force == 0)
14138 {
14139 if (algorithm_pos == 0)
14140 {
14141 log_info ("- Device #%u: WARNING: Not a native Intel OpenCL runtime, expect massive speed loss", device_id + 1);
14142 log_info (" You can use --force to override this but do not post error reports if you do so");
14143 }
14144
14145 device_param->skipped = 1;
14146 }
14147 }
14148 }
14149
14150 // skipped
14151
14152 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14153 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14154
14155 // driver_version
14156
14157 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14158
14159 char *driver_version = (char *) mymalloc (param_value_size);
14160
14161 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14162
14163 device_param->driver_version = driver_version;
14164
14165 // device_name_chksum
14166
14167 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14168
14169 #if __x86_64__
14170 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);
14171 #else
14172 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);
14173 #endif
14174
14175 uint device_name_digest[4] = { 0 };
14176
14177 md5_64 ((uint *) device_name_chksum, device_name_digest);
14178
14179 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14180
14181 device_param->device_name_chksum = device_name_chksum;
14182
14183 // vendor specific
14184
14185 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14186 {
14187 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14188 {
14189 need_adl = 1;
14190 }
14191
14192 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14193 {
14194 need_nvml = 1;
14195
14196 #ifdef LINUX
14197 need_xnvctrl = 1;
14198 #endif
14199
14200 #ifdef WIN
14201 need_nvapi = 1;
14202 #endif
14203 }
14204 }
14205
14206 if (device_type & CL_DEVICE_TYPE_GPU)
14207 {
14208 if (device_vendor_id == VENDOR_ID_NV)
14209 {
14210 cl_uint kernel_exec_timeout = 0;
14211
14212 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14213
14214 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14215
14216 device_param->kernel_exec_timeout = kernel_exec_timeout;
14217
14218 cl_uint sm_minor = 0;
14219 cl_uint sm_major = 0;
14220
14221 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14222 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14223
14224 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14225 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14226
14227 device_param->sm_minor = sm_minor;
14228 device_param->sm_major = sm_major;
14229
14230 // CPU burning loop damper
14231 // Value is given as number between 0-100
14232 // By default 100%
14233
14234 device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14235
14236 if (nvidia_spin_damp_chgd == 0)
14237 {
14238 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14239 {
14240 /**
14241 * the workaround is not a friend of rule based attacks
14242 * the words from the wordlist combined with fast and slow rules cause
14243 * fluctuations which cause inaccurate wait time estimations
14244 * using a reduced damping percentage almost compensates this
14245 */
14246
14247 device_param->nvidia_spin_damp = 64;
14248 }
14249 }
14250
14251 device_param->nvidia_spin_damp /= 100;
14252 }
14253 }
14254
14255 // display results
14256
14257 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14258 {
14259 if (machine_readable == 0)
14260 {
14261 if (device_param->skipped == 0)
14262 {
14263 log_info ("- Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14264 device_id + 1,
14265 device_name,
14266 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14267 (unsigned int) (device_global_mem / 1024 / 1024),
14268 (unsigned int) device_processors);
14269 }
14270 else
14271 {
14272 log_info ("- Device #%u: %s, skipped",
14273 device_id + 1,
14274 device_name);
14275 }
14276 }
14277 }
14278
14279 // common driver check
14280
14281 if (device_param->skipped == 0)
14282 {
14283 if (device_type & CL_DEVICE_TYPE_GPU)
14284 {
14285 if (platform_vendor_id == VENDOR_ID_AMD)
14286 {
14287 int catalyst_check = (force == 1) ? 0 : 1;
14288
14289 int catalyst_warn = 0;
14290
14291 int catalyst_broken = 0;
14292
14293 if (catalyst_check == 1)
14294 {
14295 catalyst_warn = 1;
14296
14297 // v14.9 and higher
14298 if (atoi (device_param->driver_version) >= 1573)
14299 {
14300 catalyst_warn = 0;
14301 }
14302
14303 catalyst_check = 0;
14304 }
14305
14306 if (catalyst_broken == 1)
14307 {
14308 log_info ("");
14309 log_info ("ATTENTION! The Catalyst driver installed on your system is known to be broken!");
14310 log_info ("It passes over cracked hashes and will not report them as cracked");
14311 log_info ("You are STRONGLY encouraged not to use it");
14312 log_info ("You can use --force to override this but do not post error reports if you do so");
14313 log_info ("");
14314
14315 return (-1);
14316 }
14317
14318 if (catalyst_warn == 1)
14319 {
14320 log_info ("");
14321 log_info ("ATTENTION! Unsupported or incorrectly installed Catalyst driver detected!");
14322 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver");
14323 log_info ("See hashcat's homepage for official supported catalyst drivers");
14324 #ifdef _WIN
14325 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14326 #endif
14327 log_info ("You can use --force to override this but do not post error reports if you do so");
14328 log_info ("");
14329
14330 return (-1);
14331 }
14332 }
14333 else if (platform_vendor_id == VENDOR_ID_NV)
14334 {
14335 if (device_param->kernel_exec_timeout != 0)
14336 {
14337 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);
14338 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14339 }
14340 }
14341 }
14342
14343 /* turns out pocl still creates segfaults (because of llvm)
14344 if (device_type & CL_DEVICE_TYPE_CPU)
14345 {
14346 if (platform_vendor_id == VENDOR_ID_AMD)
14347 {
14348 if (force == 0)
14349 {
14350 log_info ("");
14351 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14352 log_info ("You are STRONGLY encouraged not to use it");
14353 log_info ("You can use --force to override this but do not post error reports if you do so");
14354 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14355 log_info ("");
14356
14357 return (-1);
14358 }
14359 }
14360 }
14361 */
14362
14363 /**
14364 * kernel accel and loops tuning db adjustment
14365 */
14366
14367 device_param->kernel_accel_min = 1;
14368 device_param->kernel_accel_max = 1024;
14369
14370 device_param->kernel_loops_min = 1;
14371 device_param->kernel_loops_max = 1024;
14372
14373 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14374
14375 if (tuningdb_entry)
14376 {
14377 u32 _kernel_accel = tuningdb_entry->kernel_accel;
14378 u32 _kernel_loops = tuningdb_entry->kernel_loops;
14379
14380 if (_kernel_accel)
14381 {
14382 device_param->kernel_accel_min = _kernel_accel;
14383 device_param->kernel_accel_max = _kernel_accel;
14384 }
14385
14386 if (_kernel_loops)
14387 {
14388 if (workload_profile == 1)
14389 {
14390 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14391 }
14392 else if (workload_profile == 2)
14393 {
14394 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14395 }
14396
14397 device_param->kernel_loops_min = _kernel_loops;
14398 device_param->kernel_loops_max = _kernel_loops;
14399 }
14400 }
14401
14402 // commandline parameters overwrite tuningdb entries
14403
14404 if (kernel_accel)
14405 {
14406 device_param->kernel_accel_min = kernel_accel;
14407 device_param->kernel_accel_max = kernel_accel;
14408 }
14409
14410 if (kernel_loops)
14411 {
14412 device_param->kernel_loops_min = kernel_loops;
14413 device_param->kernel_loops_max = kernel_loops;
14414 }
14415
14416 /**
14417 * activate device
14418 */
14419
14420 devices_active++;
14421 }
14422
14423 // next please
14424
14425 devices_cnt++;
14426 }
14427
14428 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14429 {
14430 if (machine_readable == 0)
14431 {
14432 log_info ("");
14433 }
14434 }
14435 }
14436
14437 if (keyspace == 0 && devices_active == 0)
14438 {
14439 log_error ("ERROR: No devices found/left");
14440
14441 return (-1);
14442 }
14443
14444 // 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)
14445
14446 if (devices_filter != (uint) -1)
14447 {
14448 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14449
14450 if (devices_filter > devices_cnt_mask)
14451 {
14452 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14453
14454 return (-1);
14455 }
14456 }
14457
14458 data.devices_cnt = devices_cnt;
14459
14460 data.devices_active = devices_active;
14461
14462 /**
14463 * HM devices: init
14464 */
14465
14466 #ifdef HAVE_HWMON
14467 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14468 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14469 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14470 hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX] = { { 0 } };
14471
14472 if (gpu_temp_disable == 0)
14473 {
14474 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14475 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14476 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14477 XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));
14478
14479 data.hm_adl = NULL;
14480 data.hm_nvapi = NULL;
14481 data.hm_nvml = NULL;
14482 data.hm_xnvctrl = NULL;
14483
14484 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14485 {
14486 data.hm_nvml = nvml;
14487 }
14488
14489 if (data.hm_nvml)
14490 {
14491 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14492 {
14493 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14494
14495 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14496
14497 int tmp_out = 0;
14498
14499 for (int i = 0; i < tmp_in; i++)
14500 {
14501 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14502 }
14503
14504 for (int i = 0; i < tmp_out; i++)
14505 {
14506 unsigned int speed;
14507
14508 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14509
14510 // doesn't seem to create any advantages
14511 //hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14512 //hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14513 }
14514 }
14515 }
14516
14517 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14518 {
14519 data.hm_nvapi = nvapi;
14520 }
14521
14522 if (data.hm_nvapi)
14523 {
14524 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14525 {
14526 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14527
14528 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14529
14530 int tmp_out = 0;
14531
14532 for (int i = 0; i < tmp_in; i++)
14533 {
14534 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14535 }
14536 }
14537 }
14538
14539 if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0))
14540 {
14541 data.hm_xnvctrl = xnvctrl;
14542 }
14543
14544 if (data.hm_xnvctrl)
14545 {
14546 if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
14547 {
14548 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14549 {
14550 hc_device_param_t *device_param = &data.devices_param[device_id];
14551
14552 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14553
14554 hm_adapters_xnvctrl[device_id].xnvctrl = device_id;
14555
14556 int speed = 0;
14557
14558 if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
14559 }
14560 }
14561 }
14562
14563 if ((need_adl == 1) && (adl_init (adl) == 0))
14564 {
14565 data.hm_adl = adl;
14566 }
14567
14568 if (data.hm_adl)
14569 {
14570 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14571 {
14572 // total number of adapters
14573
14574 int hm_adapters_num;
14575
14576 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14577
14578 // adapter info
14579
14580 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14581
14582 if (lpAdapterInfo == NULL) return (-1);
14583
14584 // get a list (of ids of) valid/usable adapters
14585
14586 int num_adl_adapters = 0;
14587
14588 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14589
14590 if (num_adl_adapters > 0)
14591 {
14592 hc_thread_mutex_lock (mux_adl);
14593
14594 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14595
14596 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14597
14598 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14599 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14600
14601 hc_thread_mutex_unlock (mux_adl);
14602 }
14603
14604 myfree (valid_adl_device_list);
14605 myfree (lpAdapterInfo);
14606 }
14607 }
14608
14609 if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14610 {
14611 gpu_temp_disable = 1;
14612 }
14613 }
14614
14615 /**
14616 * OpenCL devices: allocate buffer for device specific information
14617 */
14618
14619 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14620
14621 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14622
14623 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14624
14625 /**
14626 * User-defined GPU temp handling
14627 */
14628
14629 if (gpu_temp_disable == 1)
14630 {
14631 gpu_temp_abort = 0;
14632 gpu_temp_retain = 0;
14633 }
14634
14635 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14636 {
14637 if (gpu_temp_abort < gpu_temp_retain)
14638 {
14639 log_error ("ERROR: Invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14640
14641 return (-1);
14642 }
14643 }
14644
14645 data.gpu_temp_disable = gpu_temp_disable;
14646 data.gpu_temp_abort = gpu_temp_abort;
14647 data.gpu_temp_retain = gpu_temp_retain;
14648 #endif
14649
14650 /**
14651 * enable custom signal handler(s)
14652 */
14653
14654 if (benchmark == 0)
14655 {
14656 hc_signal (sigHandler_default);
14657 }
14658 else
14659 {
14660 hc_signal (sigHandler_benchmark);
14661 }
14662
14663 /**
14664 * inform the user
14665 */
14666
14667 if (data.quiet == 0)
14668 {
14669 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14670
14671 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);
14672
14673 if (attack_mode == ATTACK_MODE_STRAIGHT)
14674 {
14675 log_info ("Rules: %u", kernel_rules_cnt);
14676 }
14677
14678 if (opti_type)
14679 {
14680 log_info ("Applicable Optimizers:");
14681
14682 for (uint i = 0; i < 32; i++)
14683 {
14684 const uint opti_bit = 1u << i;
14685
14686 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14687 }
14688 }
14689
14690 /**
14691 * Watchdog and Temperature balance
14692 */
14693
14694 #ifdef HAVE_HWMON
14695 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14696 {
14697 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14698 }
14699
14700 if (gpu_temp_abort == 0)
14701 {
14702 log_info ("Watchdog: Temperature abort trigger disabled");
14703 }
14704 else
14705 {
14706 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14707 }
14708
14709 if (gpu_temp_retain == 0)
14710 {
14711 log_info ("Watchdog: Temperature retain trigger disabled");
14712 }
14713 else
14714 {
14715 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14716 }
14717
14718 if (data.quiet == 0) log_info ("");
14719 #endif
14720 }
14721
14722 #ifdef HAVE_HWMON
14723
14724 /**
14725 * HM devices: copy
14726 */
14727
14728 if (gpu_temp_disable == 0)
14729 {
14730 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14731 {
14732 hc_device_param_t *device_param = &data.devices_param[device_id];
14733
14734 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14735
14736 if (device_param->skipped) continue;
14737
14738 const uint platform_devices_id = device_param->platform_devices_id;
14739
14740 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14741 {
14742 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14743 data.hm_device[device_id].nvapi = 0;
14744 data.hm_device[device_id].nvml = 0;
14745 data.hm_device[device_id].xnvctrl = 0;
14746 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14747 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14748 data.hm_device[device_id].fan_set_supported = 0;
14749 }
14750
14751 if (device_param->device_vendor_id == VENDOR_ID_NV)
14752 {
14753 data.hm_device[device_id].adl = 0;
14754 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14755 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14756 data.hm_device[device_id].xnvctrl = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
14757 data.hm_device[device_id].od_version = 0;
14758 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14759 data.hm_device[device_id].fan_set_supported = 0;
14760 }
14761 }
14762 }
14763
14764 /**
14765 * powertune on user request
14766 */
14767
14768 if (powertune_enable == 1)
14769 {
14770 hc_thread_mutex_lock (mux_adl);
14771
14772 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14773 {
14774 hc_device_param_t *device_param = &data.devices_param[device_id];
14775
14776 if (device_param->skipped) continue;
14777
14778 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14779 {
14780 /**
14781 * Temporary fix:
14782 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14783 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14784 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14785 * Driver / ADL bug?
14786 */
14787
14788 if (data.hm_device[device_id].od_version == 6)
14789 {
14790 int ADL_rc;
14791
14792 // check powertune capabilities first, if not available then skip device
14793
14794 int powertune_supported = 0;
14795
14796 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14797 {
14798 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14799
14800 return (-1);
14801 }
14802
14803 // first backup current value, we will restore it later
14804
14805 if (powertune_supported != 0)
14806 {
14807 // powercontrol settings
14808
14809 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14810
14811 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14812 {
14813 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14814 }
14815
14816 if (ADL_rc != ADL_OK)
14817 {
14818 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14819
14820 return (-1);
14821 }
14822
14823 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14824 {
14825 log_error ("ERROR: Failed to set new ADL PowerControl values");
14826
14827 return (-1);
14828 }
14829
14830 // clocks
14831
14832 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14833
14834 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14835
14836 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)
14837 {
14838 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14839
14840 return (-1);
14841 }
14842
14843 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14844
14845 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14846
14847 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14848 {
14849 log_error ("ERROR: Failed to get ADL device capabilities");
14850
14851 return (-1);
14852 }
14853
14854 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14855 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14856
14857 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14858 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14859
14860 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14861 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14862
14863 // warning if profile has too low max values
14864
14865 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14866 {
14867 log_info ("WARN: The custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14868 }
14869
14870 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14871 {
14872 log_info ("WARN: The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14873 }
14874
14875 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14876
14877 performance_state->iNumberOfPerformanceLevels = 2;
14878
14879 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14880 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14881 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14882 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14883
14884 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)
14885 {
14886 log_info ("ERROR: Failed to set ADL performance state");
14887
14888 return (-1);
14889 }
14890
14891 local_free (performance_state);
14892 }
14893
14894 // set powertune value only
14895
14896 if (powertune_supported != 0)
14897 {
14898 // powertune set
14899 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14900
14901 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14902 {
14903 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14904
14905 return (-1);
14906 }
14907
14908 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14909 {
14910 log_error ("ERROR: Failed to set new ADL PowerControl values");
14911
14912 return (-1);
14913 }
14914 }
14915 }
14916 }
14917
14918 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14919 {
14920 // first backup current value, we will restore it later
14921
14922 unsigned int limit;
14923
14924 int powertune_supported = 0;
14925
14926 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14927 {
14928 powertune_supported = 1;
14929 }
14930
14931 // if backup worked, activate the maximum allowed
14932
14933 if (powertune_supported != 0)
14934 {
14935 unsigned int minLimit;
14936 unsigned int maxLimit;
14937
14938 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14939 {
14940 if (maxLimit > 0)
14941 {
14942 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14943 {
14944 // now we can be sure we need to reset later
14945
14946 nvml_power_limit[device_id] = limit;
14947 }
14948 }
14949 }
14950 }
14951 }
14952 }
14953
14954 hc_thread_mutex_unlock (mux_adl);
14955 }
14956
14957 #endif // HAVE_HWMON
14958
14959 #ifdef DEBUG
14960 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14961 #endif
14962
14963 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14964
14965 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14966 {
14967 /**
14968 * host buffer
14969 */
14970
14971 hc_device_param_t *device_param = &data.devices_param[device_id];
14972
14973 if (device_param->skipped) continue;
14974
14975 /**
14976 * device properties
14977 */
14978
14979 const char *device_name_chksum = device_param->device_name_chksum;
14980 const u32 device_processors = device_param->device_processors;
14981
14982 /**
14983 * create context for each device
14984 */
14985
14986 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14987
14988 /**
14989 * create command-queue
14990 */
14991
14992 // not supported with NV
14993 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14994
14995 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14996
14997 /**
14998 * kernel threads: some algorithms need a fixed kernel-threads count
14999 * because of shared memory usage or bitslice
15000 * there needs to be some upper limit, otherwise there's too much overhead
15001 */
15002
15003 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
15004
15005 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
15006 {
15007 kernel_threads = KERNEL_THREADS_MAX_CPU;
15008 }
15009
15010 if (hash_mode == 1500) kernel_threads = 64; // DES
15011 if (hash_mode == 3000) kernel_threads = 64; // DES
15012 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
15013 if (hash_mode == 7500) kernel_threads = 64; // RC4
15014 if (hash_mode == 8900) kernel_threads = 64; // Scrypt
15015 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
15016 if (hash_mode == 9300) kernel_threads = 64; // Scrypt
15017 if (hash_mode == 9700) kernel_threads = 64; // RC4
15018 if (hash_mode == 9710) kernel_threads = 64; // RC4
15019 if (hash_mode == 9800) kernel_threads = 64; // RC4
15020 if (hash_mode == 9810) kernel_threads = 64; // RC4
15021 if (hash_mode == 10400) kernel_threads = 64; // RC4
15022 if (hash_mode == 10410) kernel_threads = 64; // RC4
15023 if (hash_mode == 10500) kernel_threads = 64; // RC4
15024 if (hash_mode == 13100) kernel_threads = 64; // RC4
15025
15026 device_param->kernel_threads = kernel_threads;
15027
15028 device_param->hardware_power = device_processors * kernel_threads;
15029
15030 /**
15031 * create input buffers on device : calculate size of fixed memory buffers
15032 */
15033
15034 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
15035 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
15036
15037 device_param->size_root_css = size_root_css;
15038 device_param->size_markov_css = size_markov_css;
15039
15040 size_t size_results = sizeof (uint);
15041
15042 device_param->size_results = size_results;
15043
15044 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
15045 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
15046
15047 size_t size_plains = digests_cnt * sizeof (plain_t);
15048 size_t size_salts = salts_cnt * sizeof (salt_t);
15049 size_t size_esalts = salts_cnt * esalt_size;
15050
15051 device_param->size_plains = size_plains;
15052 device_param->size_digests = size_digests;
15053 device_param->size_shown = size_shown;
15054 device_param->size_salts = size_salts;
15055
15056 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
15057 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
15058 size_t size_tm = 32 * sizeof (bs_word_t);
15059
15060 // scryptV stuff
15061
15062 size_t size_scrypt = 4;
15063
15064 if ((hash_mode == 8900) || (hash_mode == 9300))
15065 {
15066 // we need to check that all hashes have the same scrypt settings
15067
15068 const u32 scrypt_N = data.salts_buf[0].scrypt_N;
15069 const u32 scrypt_r = data.salts_buf[0].scrypt_r;
15070 const u32 scrypt_p = data.salts_buf[0].scrypt_p;
15071
15072 for (uint i = 1; i < salts_cnt; i++)
15073 {
15074 if ((data.salts_buf[i].scrypt_N != scrypt_N)
15075 || (data.salts_buf[i].scrypt_r != scrypt_r)
15076 || (data.salts_buf[i].scrypt_p != scrypt_p))
15077 {
15078 log_error ("ERROR: Mixed scrypt settings not supported");
15079
15080 return -1;
15081 }
15082 }
15083
15084 uint tmto_start = 0;
15085 uint tmto_stop = 10;
15086
15087 if (scrypt_tmto)
15088 {
15089 tmto_start = scrypt_tmto;
15090 }
15091 else
15092 {
15093 // in case the user did not specify the tmto manually
15094 // use some values known to run best (tested on 290x for AMD and GTX1080 for NV)
15095
15096 if (hash_mode == 8900)
15097 {
15098 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15099 {
15100 tmto_start = 3;
15101 }
15102 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15103 {
15104 tmto_start = 2;
15105 }
15106 }
15107 else if (hash_mode == 9300)
15108 {
15109 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15110 {
15111 tmto_start = 2;
15112 }
15113 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15114 {
15115 tmto_start = 4;
15116 }
15117 }
15118 }
15119
15120 data.scrypt_tmp_size = (128 * scrypt_r);
15121
15122 device_param->kernel_accel_min = 1;
15123 device_param->kernel_accel_max = 8;
15124
15125 uint tmto;
15126
15127 for (tmto = tmto_start; tmto < tmto_stop; tmto++)
15128 {
15129 size_scrypt = (128 * scrypt_r) * scrypt_N;
15130
15131 size_scrypt /= 1 << tmto;
15132
15133 size_scrypt *= device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel_max;
15134
15135 if ((size_scrypt / 4) > device_param->device_maxmem_alloc)
15136 {
15137 if (quiet == 0) log_info ("WARNING: Not enough single-block device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15138
15139 continue;
15140 }
15141
15142 if (size_scrypt > device_param->device_global_mem)
15143 {
15144 if (quiet == 0) log_info ("WARNING: Not enough total device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15145
15146 continue;
15147 }
15148
15149 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
15150 {
15151 data.scrypt_tmto_final = tmto;
15152 }
15153
15154 break;
15155 }
15156
15157 if (tmto == tmto_stop)
15158 {
15159 log_error ("ERROR: Can't allocate enough device memory");
15160
15161 return -1;
15162 }
15163
15164 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.scrypt_tmto_final, size_scrypt);
15165 }
15166
15167 size_t size_scrypt4 = size_scrypt / 4;
15168
15169 /**
15170 * some algorithms need a fixed kernel-loops count
15171 */
15172
15173 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15174 {
15175 const u32 kernel_loops_fixed = 1024;
15176
15177 device_param->kernel_loops_min = kernel_loops_fixed;
15178 device_param->kernel_loops_max = kernel_loops_fixed;
15179 }
15180
15181 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15182 {
15183 const u32 kernel_loops_fixed = 1024;
15184
15185 device_param->kernel_loops_min = kernel_loops_fixed;
15186 device_param->kernel_loops_max = kernel_loops_fixed;
15187 }
15188
15189 if (hash_mode == 8900)
15190 {
15191 const u32 kernel_loops_fixed = 1;
15192
15193 device_param->kernel_loops_min = kernel_loops_fixed;
15194 device_param->kernel_loops_max = kernel_loops_fixed;
15195 }
15196
15197 if (hash_mode == 9300)
15198 {
15199 const u32 kernel_loops_fixed = 1;
15200
15201 device_param->kernel_loops_min = kernel_loops_fixed;
15202 device_param->kernel_loops_max = kernel_loops_fixed;
15203 }
15204
15205 if (hash_mode == 12500)
15206 {
15207 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15208
15209 device_param->kernel_loops_min = kernel_loops_fixed;
15210 device_param->kernel_loops_max = kernel_loops_fixed;
15211 }
15212
15213 /**
15214 * some algorithms have a maximum kernel-loops count
15215 */
15216
15217 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15218 {
15219 u32 innerloop_cnt = 0;
15220
15221 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15222 {
15223 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15224 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15225 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15226 }
15227 else
15228 {
15229 innerloop_cnt = data.salts_buf[0].salt_iter;
15230 }
15231
15232 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15233 (innerloop_cnt <= device_param->kernel_loops_max))
15234 {
15235 device_param->kernel_loops_max = innerloop_cnt;
15236 }
15237 }
15238
15239 u32 kernel_accel_min = device_param->kernel_accel_min;
15240 u32 kernel_accel_max = device_param->kernel_accel_max;
15241
15242 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15243
15244 size_t size_pws = 4;
15245 size_t size_tmps = 4;
15246 size_t size_hooks = 4;
15247
15248 while (kernel_accel_max >= kernel_accel_min)
15249 {
15250 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15251
15252 // size_pws
15253
15254 size_pws = kernel_power_max * sizeof (pw_t);
15255
15256 // size_tmps
15257
15258 switch (hash_mode)
15259 {
15260 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15261 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15262 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15263 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15264 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15265 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15266 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15267 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15268 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15269 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15270 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15271 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15272 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15273 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15274 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15275 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15276 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15277 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15278 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15279 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15280 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15281 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15282 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15283 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
15284 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
15285 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
15286 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
15287 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
15288 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15289 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15290 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
15291 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
15292 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15293 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
15294 case 8900: size_tmps = kernel_power_max * data.scrypt_tmp_size; break;
15295 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
15296 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
15297 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15298 case 9300: size_tmps = kernel_power_max * data.scrypt_tmp_size; break;
15299 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
15300 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
15301 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
15302 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15303 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
15304 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
15305 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
15306 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
15307 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15308 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
15309 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
15310 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
15311 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15312 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15313 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
15314 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
15315 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
15316 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
15317 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
15318 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15319 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15320 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15321 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
15322 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
15323 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15324 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15325 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15326 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15327 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15328 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15329 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15330 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15331 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15332 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15333 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15334 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15335 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15336 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15337 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15338 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15339 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15340 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15341 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15342 };
15343
15344 // size_hooks
15345
15346 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15347 {
15348 switch (hash_mode)
15349 {
15350 }
15351 }
15352
15353 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15354 // if not, decrease amplifier and try again
15355
15356 int memory_limit_hit = 0;
15357
15358 if (size_pws > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15359 if (size_tmps > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15360 if (size_hooks > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15361
15362 const u64 size_total
15363 = bitmap_size
15364 + bitmap_size
15365 + bitmap_size
15366 + bitmap_size
15367 + bitmap_size
15368 + bitmap_size
15369 + bitmap_size
15370 + bitmap_size
15371 + size_bfs
15372 + size_combs
15373 + size_digests
15374 + size_esalts
15375 + size_hooks
15376 + size_markov_css
15377 + size_plains
15378 + size_pws
15379 + size_pws // not a bug
15380 + size_results
15381 + size_root_css
15382 + size_rules
15383 + size_rules_c
15384 + size_salts
15385 + size_scrypt4
15386 + size_scrypt4
15387 + size_scrypt4
15388 + size_scrypt4
15389 + size_shown
15390 + size_tm
15391 + size_tmps;
15392
15393 if (size_total > device_param->device_global_mem) memory_limit_hit = 1;
15394
15395 if (memory_limit_hit == 1)
15396 {
15397 kernel_accel_max--;
15398
15399 continue;
15400 }
15401
15402 break;
15403 }
15404
15405 if (kernel_accel_max < kernel_accel_min)
15406 {
15407 log_error ("- Device #%u: Device does not provide enough allocatable device-memory to handle this attack", device_id + 1);
15408
15409 return -1;
15410 }
15411
15412 device_param->kernel_accel_min = kernel_accel_min;
15413 device_param->kernel_accel_max = kernel_accel_max;
15414
15415 /*
15416 if (kernel_accel_max < kernel_accel)
15417 {
15418 if (quiet == 0) log_info ("- Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
15419
15420 device_param->kernel_accel = kernel_accel_max;
15421 }
15422 */
15423
15424 device_param->size_bfs = size_bfs;
15425 device_param->size_combs = size_combs;
15426 device_param->size_rules = size_rules;
15427 device_param->size_rules_c = size_rules_c;
15428 device_param->size_pws = size_pws;
15429 device_param->size_tmps = size_tmps;
15430 device_param->size_hooks = size_hooks;
15431
15432 /**
15433 * default building options
15434 */
15435
15436 char cpath[1024] = { 0 };
15437
15438 char build_opts[1024] = { 0 };
15439
15440 #if _WIN
15441
15442 snprintf (cpath, sizeof (cpath) - 1, "%s\\OpenCL\\", shared_dir);
15443
15444 char *cpath_real = mymalloc (MAX_PATH);
15445
15446 if (GetFullPathName (cpath, MAX_PATH, cpath_real, NULL) == 0)
15447 {
15448 log_error ("ERROR: %s: %s", cpath, "GetFullPathName()");
15449
15450 return -1;
15451 }
15452
15453 naive_replace (cpath_real, '\\', '/');
15454
15455 // not escaping here, windows has quotes
15456
15457 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\"", cpath_real);
15458
15459 #else
15460
15461 snprintf (cpath, sizeof (cpath) - 1, "%s/OpenCL/", shared_dir);
15462
15463 char *cpath_real = mymalloc (PATH_MAX);
15464
15465 if (realpath (cpath, cpath_real) == NULL)
15466 {
15467 log_error ("ERROR: %s: %s", cpath, strerror (errno));
15468
15469 return -1;
15470 }
15471
15472 naive_escape (cpath_real, PATH_MAX, ' ', '\\');
15473
15474 snprintf (build_opts, sizeof (build_opts) - 1, "-I %s", cpath_real);
15475
15476 #endif
15477
15478 // include check
15479 // this test needs to be done manually because of osx opencl runtime
15480 // if there's a problem with permission, its not reporting back and erroring out silently
15481
15482 #define files_cnt 15
15483
15484 const char *files_names[files_cnt] =
15485 {
15486 "inc_cipher_aes256.cl",
15487 "inc_cipher_serpent256.cl",
15488 "inc_cipher_twofish256.cl",
15489 "inc_common.cl",
15490 "inc_comp_multi_bs.cl",
15491 "inc_comp_multi.cl",
15492 "inc_comp_single_bs.cl",
15493 "inc_comp_single.cl",
15494 "inc_hash_constants.h",
15495 "inc_hash_functions.cl",
15496 "inc_rp.cl",
15497 "inc_rp.h",
15498 "inc_simd.cl",
15499 "inc_types.cl",
15500 "inc_vendor.cl",
15501 };
15502
15503 for (int i = 0; i < files_cnt; i++)
15504 {
15505 char path[1024] = { 0 };
15506
15507 snprintf (path, sizeof (path) - 1, "%s/%s", cpath_real, files_names[i]);
15508
15509 FILE *fd = fopen (path, "r");
15510
15511 if (fd == NULL)
15512 {
15513 log_error ("ERROR: %s: fopen(): %s", path, strerror (errno));
15514
15515 return -1;
15516 }
15517
15518 char buf[1];
15519
15520 size_t n = fread (buf, 1, 1, fd);
15521
15522 if (n != 1)
15523 {
15524 log_error ("ERROR: %s: fread(): %s", path, strerror (errno));
15525
15526 return -1;
15527 }
15528
15529 fclose (fd);
15530 }
15531
15532 myfree (cpath_real);
15533
15534 // we don't have sm_* on vendors not NV but it doesn't matter
15535
15536 char build_opts_new[1024] = { 0 };
15537
15538 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -D VENDOR_ID=%u -D CUDA_ARCH=%d -D VECT_SIZE=%u -D DEVICE_TYPE=%u -D DGST_R0=%u -D DGST_R1=%u -D DGST_R2=%u -D DGST_R3=%u -D DGST_ELEM=%u -D KERN_TYPE=%u -D _unroll -cl-std=CL1.1", build_opts, device_param->device_vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, data.dgst_pos0, data.dgst_pos1, data.dgst_pos2, data.dgst_pos3, data.dgst_size / 4, kern_type);
15539
15540 strncpy (build_opts, build_opts_new, sizeof (build_opts));
15541
15542 #ifdef DEBUG
15543 log_info ("- Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15544 #endif
15545
15546 /**
15547 * main kernel
15548 */
15549
15550 {
15551 /**
15552 * kernel source filename
15553 */
15554
15555 char source_file[256] = { 0 };
15556
15557 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15558
15559 struct stat sst;
15560
15561 if (stat (source_file, &sst) == -1)
15562 {
15563 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15564
15565 return -1;
15566 }
15567
15568 /**
15569 * kernel cached filename
15570 */
15571
15572 char cached_file[256] = { 0 };
15573
15574 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15575
15576 int cached = 1;
15577
15578 struct stat cst;
15579
15580 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15581 {
15582 cached = 0;
15583 }
15584
15585 /**
15586 * kernel compile or load
15587 */
15588
15589 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15590
15591 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15592
15593 if (force_jit_compilation == -1)
15594 {
15595 if (cached == 0)
15596 {
15597 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));
15598
15599 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15600
15601 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15602
15603 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15604
15605 #ifdef DEBUG
15606 size_t build_log_size = 0;
15607
15608 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15609
15610 if (build_log_size > 1)
15611 {
15612 char *build_log = (char *) malloc (build_log_size + 1);
15613
15614 memset (build_log, 0, build_log_size + 1);
15615
15616 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15617
15618 puts (build_log);
15619
15620 free (build_log);
15621 }
15622 #endif
15623
15624 if (rc != 0)
15625 {
15626 device_param->skipped = true;
15627
15628 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15629
15630 continue;
15631 }
15632
15633 size_t binary_size;
15634
15635 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15636
15637 u8 *binary = (u8 *) mymalloc (binary_size);
15638
15639 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15640
15641 writeProgramBin (cached_file, binary, binary_size);
15642
15643 local_free (binary);
15644 }
15645 else
15646 {
15647 #ifdef DEBUG
15648 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15649 #endif
15650
15651 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15652
15653 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15654
15655 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15656 }
15657 }
15658 else
15659 {
15660 #ifdef DEBUG
15661 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15662 #endif
15663
15664 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15665
15666 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15667
15668 char build_opts_update[1024] = { 0 };
15669
15670 if (force_jit_compilation == 1500)
15671 {
15672 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%u", build_opts, data.salts_buf[0].salt_buf[0]);
15673 }
15674 else if (force_jit_compilation == 8900)
15675 {
15676 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DSCRYPT_N=%u -DSCRYPT_R=%u -DSCRYPT_P=%u -DSCRYPT_TMTO=%u -DSCRYPT_TMP_ELEM=%u", build_opts, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, 1 << data.scrypt_tmto_final, data.scrypt_tmp_size / 16);
15677 }
15678 else
15679 {
15680 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15681 }
15682
15683 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15684
15685 #ifdef DEBUG
15686 size_t build_log_size = 0;
15687
15688 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15689
15690 if (build_log_size > 1)
15691 {
15692 char *build_log = (char *) malloc (build_log_size + 1);
15693
15694 memset (build_log, 0, build_log_size + 1);
15695
15696 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15697
15698 puts (build_log);
15699
15700 free (build_log);
15701 }
15702 #endif
15703
15704 if (rc != 0)
15705 {
15706 device_param->skipped = true;
15707
15708 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15709 }
15710 }
15711
15712 local_free (kernel_lengths);
15713 local_free (kernel_sources[0]);
15714 local_free (kernel_sources);
15715 }
15716
15717 /**
15718 * word generator kernel
15719 */
15720
15721 if (attack_mode != ATTACK_MODE_STRAIGHT)
15722 {
15723 /**
15724 * kernel mp source filename
15725 */
15726
15727 char source_file[256] = { 0 };
15728
15729 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15730
15731 struct stat sst;
15732
15733 if (stat (source_file, &sst) == -1)
15734 {
15735 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15736
15737 return -1;
15738 }
15739
15740 /**
15741 * kernel mp cached filename
15742 */
15743
15744 char cached_file[256] = { 0 };
15745
15746 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15747
15748 int cached = 1;
15749
15750 struct stat cst;
15751
15752 if (stat (cached_file, &cst) == -1)
15753 {
15754 cached = 0;
15755 }
15756
15757 /**
15758 * kernel compile or load
15759 */
15760
15761 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15762
15763 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15764
15765 if (cached == 0)
15766 {
15767 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));
15768 if (quiet == 0) log_info ("");
15769
15770 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15771
15772 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15773
15774 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15775
15776 if (rc != 0)
15777 {
15778 device_param->skipped = true;
15779
15780 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15781
15782 continue;
15783 }
15784
15785 size_t binary_size;
15786
15787 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15788
15789 u8 *binary = (u8 *) mymalloc (binary_size);
15790
15791 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15792
15793 writeProgramBin (cached_file, binary, binary_size);
15794
15795 local_free (binary);
15796 }
15797 else
15798 {
15799 #ifdef DEBUG
15800 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15801 #endif
15802
15803 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15804
15805 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15806
15807 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15808 }
15809
15810 local_free (kernel_lengths);
15811 local_free (kernel_sources[0]);
15812 local_free (kernel_sources);
15813 }
15814
15815 /**
15816 * amplifier kernel
15817 */
15818
15819 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15820 {
15821
15822 }
15823 else
15824 {
15825 /**
15826 * kernel amp source filename
15827 */
15828
15829 char source_file[256] = { 0 };
15830
15831 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15832
15833 struct stat sst;
15834
15835 if (stat (source_file, &sst) == -1)
15836 {
15837 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15838
15839 return -1;
15840 }
15841
15842 /**
15843 * kernel amp cached filename
15844 */
15845
15846 char cached_file[256] = { 0 };
15847
15848 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15849
15850 int cached = 1;
15851
15852 struct stat cst;
15853
15854 if (stat (cached_file, &cst) == -1)
15855 {
15856 cached = 0;
15857 }
15858
15859 /**
15860 * kernel compile or load
15861 */
15862
15863 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15864
15865 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15866
15867 if (cached == 0)
15868 {
15869 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));
15870 if (quiet == 0) log_info ("");
15871
15872 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15873
15874 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15875
15876 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15877
15878 if (rc != 0)
15879 {
15880 device_param->skipped = true;
15881
15882 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15883
15884 continue;
15885 }
15886
15887 size_t binary_size;
15888
15889 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15890
15891 u8 *binary = (u8 *) mymalloc (binary_size);
15892
15893 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15894
15895 writeProgramBin (cached_file, binary, binary_size);
15896
15897 local_free (binary);
15898 }
15899 else
15900 {
15901 #ifdef DEBUG
15902 if (quiet == 0) log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15903 #endif
15904
15905 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15906
15907 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15908
15909 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15910 }
15911
15912 local_free (kernel_lengths);
15913 local_free (kernel_sources[0]);
15914 local_free (kernel_sources);
15915 }
15916
15917 // some algorithm collide too fast, make that impossible
15918
15919 if (benchmark == 1)
15920 {
15921 ((uint *) digests_buf)[0] = -1;
15922 ((uint *) digests_buf)[1] = -1;
15923 ((uint *) digests_buf)[2] = -1;
15924 ((uint *) digests_buf)[3] = -1;
15925 }
15926
15927 /**
15928 * global buffers
15929 */
15930
15931 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15932 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15933 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15934 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15935 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15936 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15937 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15938 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15939 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15940 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15941 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15942 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15943 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15944 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15945 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15946 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15947 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15948 device_param->d_scryptV0_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
15949 device_param->d_scryptV1_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
15950 device_param->d_scryptV2_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
15951 device_param->d_scryptV3_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
15952
15953 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);
15954 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);
15955 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);
15956 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);
15957 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);
15958 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);
15959 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);
15960 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);
15961 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15962 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15963 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15964
15965 /**
15966 * special buffers
15967 */
15968
15969 if (attack_kern == ATTACK_KERN_STRAIGHT)
15970 {
15971 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15972 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15973
15974 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15975 }
15976 else if (attack_kern == ATTACK_KERN_COMBI)
15977 {
15978 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15979 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15980 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15981 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15982 }
15983 else if (attack_kern == ATTACK_KERN_BF)
15984 {
15985 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15986 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15987 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15988 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15989 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15990 }
15991
15992 if (size_esalts)
15993 {
15994 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15995
15996 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15997 }
15998
15999 /**
16000 * main host data
16001 */
16002
16003 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
16004
16005 device_param->pws_buf = pws_buf;
16006
16007 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
16008
16009 device_param->combs_buf = combs_buf;
16010
16011 void *hooks_buf = mymalloc (size_hooks);
16012
16013 device_param->hooks_buf = hooks_buf;
16014
16015 /**
16016 * kernel args
16017 */
16018
16019 device_param->kernel_params_buf32[24] = bitmap_mask;
16020 device_param->kernel_params_buf32[25] = bitmap_shift1;
16021 device_param->kernel_params_buf32[26] = bitmap_shift2;
16022 device_param->kernel_params_buf32[27] = 0; // salt_pos
16023 device_param->kernel_params_buf32[28] = 0; // loop_pos
16024 device_param->kernel_params_buf32[29] = 0; // loop_cnt
16025 device_param->kernel_params_buf32[30] = 0; // kernel_rules_cnt
16026 device_param->kernel_params_buf32[31] = 0; // digests_cnt
16027 device_param->kernel_params_buf32[32] = 0; // digests_offset
16028 device_param->kernel_params_buf32[33] = 0; // combs_mode
16029 device_param->kernel_params_buf32[34] = 0; // gid_max
16030
16031 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16032 ? &device_param->d_pws_buf
16033 : &device_param->d_pws_amp_buf;
16034 device_param->kernel_params[ 1] = &device_param->d_rules_c;
16035 device_param->kernel_params[ 2] = &device_param->d_combs_c;
16036 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
16037 device_param->kernel_params[ 4] = &device_param->d_tmps;
16038 device_param->kernel_params[ 5] = &device_param->d_hooks;
16039 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
16040 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
16041 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
16042 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
16043 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
16044 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
16045 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
16046 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
16047 device_param->kernel_params[14] = &device_param->d_plain_bufs;
16048 device_param->kernel_params[15] = &device_param->d_digests_buf;
16049 device_param->kernel_params[16] = &device_param->d_digests_shown;
16050 device_param->kernel_params[17] = &device_param->d_salt_bufs;
16051 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
16052 device_param->kernel_params[19] = &device_param->d_result;
16053 device_param->kernel_params[20] = &device_param->d_scryptV0_buf;
16054 device_param->kernel_params[21] = &device_param->d_scryptV1_buf;
16055 device_param->kernel_params[22] = &device_param->d_scryptV2_buf;
16056 device_param->kernel_params[23] = &device_param->d_scryptV3_buf;
16057 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
16058 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
16059 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
16060 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
16061 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
16062 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
16063 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
16064 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
16065 device_param->kernel_params[32] = &device_param->kernel_params_buf32[32];
16066 device_param->kernel_params[33] = &device_param->kernel_params_buf32[33];
16067 device_param->kernel_params[34] = &device_param->kernel_params_buf32[34];
16068
16069 device_param->kernel_params_mp_buf64[3] = 0;
16070 device_param->kernel_params_mp_buf32[4] = 0;
16071 device_param->kernel_params_mp_buf32[5] = 0;
16072 device_param->kernel_params_mp_buf32[6] = 0;
16073 device_param->kernel_params_mp_buf32[7] = 0;
16074 device_param->kernel_params_mp_buf32[8] = 0;
16075
16076 device_param->kernel_params_mp[0] = NULL;
16077 device_param->kernel_params_mp[1] = NULL;
16078 device_param->kernel_params_mp[2] = NULL;
16079 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
16080 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
16081 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
16082 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
16083 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
16084 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
16085
16086 device_param->kernel_params_mp_l_buf64[3] = 0;
16087 device_param->kernel_params_mp_l_buf32[4] = 0;
16088 device_param->kernel_params_mp_l_buf32[5] = 0;
16089 device_param->kernel_params_mp_l_buf32[6] = 0;
16090 device_param->kernel_params_mp_l_buf32[7] = 0;
16091 device_param->kernel_params_mp_l_buf32[8] = 0;
16092 device_param->kernel_params_mp_l_buf32[9] = 0;
16093
16094 device_param->kernel_params_mp_l[0] = NULL;
16095 device_param->kernel_params_mp_l[1] = NULL;
16096 device_param->kernel_params_mp_l[2] = NULL;
16097 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
16098 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
16099 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
16100 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
16101 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
16102 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
16103 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
16104
16105 device_param->kernel_params_mp_r_buf64[3] = 0;
16106 device_param->kernel_params_mp_r_buf32[4] = 0;
16107 device_param->kernel_params_mp_r_buf32[5] = 0;
16108 device_param->kernel_params_mp_r_buf32[6] = 0;
16109 device_param->kernel_params_mp_r_buf32[7] = 0;
16110 device_param->kernel_params_mp_r_buf32[8] = 0;
16111
16112 device_param->kernel_params_mp_r[0] = NULL;
16113 device_param->kernel_params_mp_r[1] = NULL;
16114 device_param->kernel_params_mp_r[2] = NULL;
16115 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
16116 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
16117 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
16118 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
16119 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
16120 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
16121
16122 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
16123 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
16124
16125 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
16126 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
16127 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
16128 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
16129 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
16130 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
16131 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
16132
16133 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
16134 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
16135
16136 device_param->kernel_params_memset_buf32[1] = 0; // value
16137 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
16138
16139 device_param->kernel_params_memset[0] = NULL;
16140 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
16141 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
16142
16143 /**
16144 * kernel name
16145 */
16146
16147 size_t kernel_wgs_tmp;
16148
16149 char kernel_name[64] = { 0 };
16150
16151 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16152 {
16153 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16154 {
16155 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
16156
16157 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16158
16159 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
16160
16161 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16162
16163 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
16164
16165 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16166 }
16167 else
16168 {
16169 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
16170
16171 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16172
16173 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
16174
16175 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16176
16177 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
16178
16179 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16180 }
16181
16182 if (data.attack_mode == ATTACK_MODE_BF)
16183 {
16184 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16185 {
16186 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
16187
16188 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16189
16190 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);
16191 }
16192 }
16193 }
16194 else
16195 {
16196 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
16197
16198 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16199
16200 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
16201
16202 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16203
16204 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
16205
16206 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16207
16208 if (opts_type & OPTS_TYPE_HOOK12)
16209 {
16210 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
16211
16212 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16213
16214 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);
16215 }
16216
16217 if (opts_type & OPTS_TYPE_HOOK23)
16218 {
16219 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
16220
16221 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16222
16223 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);
16224 }
16225 }
16226
16227 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);
16228 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);
16229 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);
16230
16231 for (uint i = 0; i <= 23; i++)
16232 {
16233 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
16234 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
16235 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
16236
16237 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
16238 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
16239 }
16240
16241 for (uint i = 24; i <= 34; i++)
16242 {
16243 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
16244 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
16245 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
16246
16247 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
16248 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
16249 }
16250
16251 // GPU memset
16252
16253 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
16254
16255 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);
16256
16257 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
16258 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
16259 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
16260
16261 // MP start
16262
16263 if (attack_mode == ATTACK_MODE_BF)
16264 {
16265 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
16266 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
16267
16268 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);
16269 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);
16270
16271 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16272 {
16273 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
16274 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
16275 }
16276 }
16277 else if (attack_mode == ATTACK_MODE_HYBRID1)
16278 {
16279 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16280
16281 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);
16282 }
16283 else if (attack_mode == ATTACK_MODE_HYBRID2)
16284 {
16285 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16286
16287 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);
16288 }
16289
16290 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16291 {
16292 // nothing to do
16293 }
16294 else
16295 {
16296 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
16297
16298 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);
16299 }
16300
16301 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16302 {
16303 // nothing to do
16304 }
16305 else
16306 {
16307 for (uint i = 0; i < 5; i++)
16308 {
16309 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
16310 }
16311
16312 for (uint i = 5; i < 7; i++)
16313 {
16314 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
16315 }
16316 }
16317
16318 // maybe this has been updated by clGetKernelWorkGroupInfo()
16319 // value can only be decreased, so we don't need to reallocate buffers
16320
16321 device_param->kernel_threads = kernel_threads;
16322
16323 // zero some data buffers
16324
16325 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
16326 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
16327 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
16328 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
16329 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
16330 run_kernel_bzero (device_param, device_param->d_result, size_results);
16331
16332 /**
16333 * special buffers
16334 */
16335
16336 if (attack_kern == ATTACK_KERN_STRAIGHT)
16337 {
16338 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
16339 }
16340 else if (attack_kern == ATTACK_KERN_COMBI)
16341 {
16342 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
16343 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
16344 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16345 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16346 }
16347 else if (attack_kern == ATTACK_KERN_BF)
16348 {
16349 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
16350 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
16351 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
16352 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16353 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16354 }
16355
16356 #if defined(HAVE_HWMON)
16357
16358 /**
16359 * Store initial fanspeed if gpu_temp_retain is enabled
16360 */
16361
16362 if (gpu_temp_disable == 0)
16363 {
16364 if (gpu_temp_retain != 0)
16365 {
16366 hc_thread_mutex_lock (mux_adl);
16367
16368 if (data.hm_device[device_id].fan_get_supported == 1)
16369 {
16370 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
16371 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
16372
16373 // we also set it to tell the OS we take control over the fan and it's automatic controller
16374 // if it was set to automatic. we do not control user-defined fanspeeds.
16375
16376 if (fanpolicy == 1)
16377 {
16378 data.hm_device[device_id].fan_set_supported = 1;
16379
16380 int rc = -1;
16381
16382 if (device_param->device_vendor_id == VENDOR_ID_AMD)
16383 {
16384 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
16385 }
16386 else if (device_param->device_vendor_id == VENDOR_ID_NV)
16387 {
16388 #ifdef LINUX
16389 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE);
16390 #endif
16391
16392 #ifdef WIN
16393 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
16394 #endif
16395 }
16396
16397 if (rc == 0)
16398 {
16399 data.hm_device[device_id].fan_set_supported = 1;
16400 }
16401 else
16402 {
16403 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
16404
16405 data.hm_device[device_id].fan_set_supported = 0;
16406 }
16407 }
16408 else
16409 {
16410 data.hm_device[device_id].fan_set_supported = 0;
16411 }
16412 }
16413
16414 hc_thread_mutex_unlock (mux_adl);
16415 }
16416 }
16417
16418 #endif // HAVE_HWMON
16419 }
16420
16421 if (data.quiet == 0) log_info_nn ("");
16422
16423 /**
16424 * In benchmark-mode, inform user which algorithm is checked
16425 */
16426
16427 if (benchmark == 1)
16428 {
16429 if (machine_readable == 0)
16430 {
16431 quiet = 0;
16432
16433 data.quiet = quiet;
16434
16435 char *hash_type = strhashtype (data.hash_mode); // not a bug
16436
16437 log_info ("Hashtype: %s", hash_type);
16438 log_info ("");
16439 }
16440 }
16441
16442 /**
16443 * keep track of the progress
16444 */
16445
16446 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16447 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16448 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16449
16450 /**
16451 * open filehandles
16452 */
16453
16454 #if _WIN
16455 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
16456 {
16457 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
16458
16459 return (-1);
16460 }
16461
16462 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
16463 {
16464 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
16465
16466 return (-1);
16467 }
16468
16469 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
16470 {
16471 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
16472
16473 return (-1);
16474 }
16475 #endif
16476
16477 /**
16478 * dictionary pad
16479 */
16480
16481 segment_size *= (1024 * 1024);
16482
16483 data.segment_size = segment_size;
16484
16485 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
16486
16487 wl_data->buf = (char *) mymalloc (segment_size);
16488 wl_data->avail = segment_size;
16489 wl_data->incr = segment_size;
16490 wl_data->cnt = 0;
16491 wl_data->pos = 0;
16492
16493 cs_t *css_buf = NULL;
16494 uint css_cnt = 0;
16495 uint dictcnt = 0;
16496 uint maskcnt = 1;
16497 char **masks = NULL;
16498 char **dictfiles = NULL;
16499
16500 uint mask_from_file = 0;
16501
16502 if (attack_mode == ATTACK_MODE_STRAIGHT)
16503 {
16504 if (wordlist_mode == WL_MODE_FILE)
16505 {
16506 int wls_left = myargc - (optind + 1);
16507
16508 for (int i = 0; i < wls_left; i++)
16509 {
16510 char *l0_filename = myargv[optind + 1 + i];
16511
16512 struct stat l0_stat;
16513
16514 if (stat (l0_filename, &l0_stat) == -1)
16515 {
16516 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
16517
16518 return (-1);
16519 }
16520
16521 uint is_dir = S_ISDIR (l0_stat.st_mode);
16522
16523 if (is_dir == 0)
16524 {
16525 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16526
16527 dictcnt++;
16528
16529 dictfiles[dictcnt - 1] = l0_filename;
16530 }
16531 else
16532 {
16533 // do not allow --keyspace w/ a directory
16534
16535 if (keyspace == 1)
16536 {
16537 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16538
16539 return (-1);
16540 }
16541
16542 char **dictionary_files = NULL;
16543
16544 dictionary_files = scan_directory (l0_filename);
16545
16546 if (dictionary_files != NULL)
16547 {
16548 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16549
16550 for (int d = 0; dictionary_files[d] != NULL; d++)
16551 {
16552 char *l1_filename = dictionary_files[d];
16553
16554 struct stat l1_stat;
16555
16556 if (stat (l1_filename, &l1_stat) == -1)
16557 {
16558 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16559
16560 return (-1);
16561 }
16562
16563 if (S_ISREG (l1_stat.st_mode))
16564 {
16565 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16566
16567 dictcnt++;
16568
16569 dictfiles[dictcnt - 1] = strdup (l1_filename);
16570 }
16571 }
16572 }
16573
16574 local_free (dictionary_files);
16575 }
16576 }
16577
16578 if (dictcnt < 1)
16579 {
16580 log_error ("ERROR: No usable dictionary file found.");
16581
16582 return (-1);
16583 }
16584 }
16585 else if (wordlist_mode == WL_MODE_STDIN)
16586 {
16587 dictcnt = 1;
16588 }
16589 }
16590 else if (attack_mode == ATTACK_MODE_COMBI)
16591 {
16592 // display
16593
16594 char *dictfile1 = myargv[optind + 1 + 0];
16595 char *dictfile2 = myargv[optind + 1 + 1];
16596
16597 // find the bigger dictionary and use as base
16598
16599 FILE *fp1 = NULL;
16600 FILE *fp2 = NULL;
16601
16602 struct stat tmp_stat;
16603
16604 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16605 {
16606 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16607
16608 return (-1);
16609 }
16610
16611 if (stat (dictfile1, &tmp_stat) == -1)
16612 {
16613 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16614
16615 fclose (fp1);
16616
16617 return (-1);
16618 }
16619
16620 if (S_ISDIR (tmp_stat.st_mode))
16621 {
16622 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16623
16624 fclose (fp1);
16625
16626 return (-1);
16627 }
16628
16629 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16630 {
16631 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16632
16633 fclose (fp1);
16634
16635 return (-1);
16636 }
16637
16638 if (stat (dictfile2, &tmp_stat) == -1)
16639 {
16640 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16641
16642 fclose (fp1);
16643 fclose (fp2);
16644
16645 return (-1);
16646 }
16647
16648 if (S_ISDIR (tmp_stat.st_mode))
16649 {
16650 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16651
16652 fclose (fp1);
16653 fclose (fp2);
16654
16655 return (-1);
16656 }
16657
16658 data.combs_cnt = 1;
16659
16660 data.quiet = 1;
16661
16662 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16663
16664 data.quiet = quiet;
16665
16666 if (words1_cnt == 0)
16667 {
16668 log_error ("ERROR: %s: empty file", dictfile1);
16669
16670 fclose (fp1);
16671 fclose (fp2);
16672
16673 return (-1);
16674 }
16675
16676 data.combs_cnt = 1;
16677
16678 data.quiet = 1;
16679
16680 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16681
16682 data.quiet = quiet;
16683
16684 if (words2_cnt == 0)
16685 {
16686 log_error ("ERROR: %s: empty file", dictfile2);
16687
16688 fclose (fp1);
16689 fclose (fp2);
16690
16691 return (-1);
16692 }
16693
16694 fclose (fp1);
16695 fclose (fp2);
16696
16697 data.dictfile = dictfile1;
16698 data.dictfile2 = dictfile2;
16699
16700 if (words1_cnt >= words2_cnt)
16701 {
16702 data.combs_cnt = words2_cnt;
16703 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16704
16705 dictfiles = &data.dictfile;
16706
16707 dictcnt = 1;
16708 }
16709 else
16710 {
16711 data.combs_cnt = words1_cnt;
16712 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16713
16714 dictfiles = &data.dictfile2;
16715
16716 dictcnt = 1;
16717
16718 // we also have to switch wordlist related rules!
16719
16720 char *tmpc = data.rule_buf_l;
16721
16722 data.rule_buf_l = data.rule_buf_r;
16723 data.rule_buf_r = tmpc;
16724
16725 int tmpi = data.rule_len_l;
16726
16727 data.rule_len_l = data.rule_len_r;
16728 data.rule_len_r = tmpi;
16729 }
16730 }
16731 else if (attack_mode == ATTACK_MODE_BF)
16732 {
16733 char *mask = NULL;
16734
16735 maskcnt = 0;
16736
16737 if (benchmark == 0)
16738 {
16739 mask = myargv[optind + 1];
16740
16741 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16742
16743 if ((optind + 2) <= myargc)
16744 {
16745 struct stat file_stat;
16746
16747 if (stat (mask, &file_stat) == -1)
16748 {
16749 maskcnt = 1;
16750
16751 masks[maskcnt - 1] = mystrdup (mask);
16752 }
16753 else
16754 {
16755 int wls_left = myargc - (optind + 1);
16756
16757 uint masks_avail = INCR_MASKS;
16758
16759 for (int i = 0; i < wls_left; i++)
16760 {
16761 if (i != 0)
16762 {
16763 mask = myargv[optind + 1 + i];
16764
16765 if (stat (mask, &file_stat) == -1)
16766 {
16767 log_error ("ERROR: %s: %s", mask, strerror (errno));
16768
16769 return (-1);
16770 }
16771 }
16772
16773 uint is_file = S_ISREG (file_stat.st_mode);
16774
16775 if (is_file == 1)
16776 {
16777 FILE *mask_fp;
16778
16779 if ((mask_fp = fopen (mask, "r")) == NULL)
16780 {
16781 log_error ("ERROR: %s: %s", mask, strerror (errno));
16782
16783 return (-1);
16784 }
16785
16786 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16787
16788 while (!feof (mask_fp))
16789 {
16790 memset (line_buf, 0, HCBUFSIZ);
16791
16792 int line_len = fgetl (mask_fp, line_buf);
16793
16794 if (line_len == 0) continue;
16795
16796 if (line_buf[0] == '#') continue;
16797
16798 if (masks_avail == maskcnt)
16799 {
16800 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16801
16802 masks_avail += INCR_MASKS;
16803 }
16804
16805 masks[maskcnt] = mystrdup (line_buf);
16806
16807 maskcnt++;
16808 }
16809
16810 myfree (line_buf);
16811
16812 fclose (mask_fp);
16813 }
16814 else
16815 {
16816 log_error ("ERROR: %s: unsupported file-type", mask);
16817
16818 return (-1);
16819 }
16820 }
16821
16822 mask_from_file = 1;
16823 }
16824 }
16825 else
16826 {
16827 custom_charset_1 = (char *) "?l?d?u";
16828 custom_charset_2 = (char *) "?l?d";
16829 custom_charset_3 = (char *) "?l?d*!$@_";
16830
16831 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16832 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16833 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16834
16835 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16836
16837 wordlist_mode = WL_MODE_MASK;
16838
16839 data.wordlist_mode = wordlist_mode;
16840
16841 increment = 1;
16842
16843 maskcnt = 1;
16844 }
16845 }
16846 else
16847 {
16848 /**
16849 * generate full masks and charsets
16850 */
16851
16852 masks = (char **) mymalloc (sizeof (char *));
16853
16854 switch (hash_mode)
16855 {
16856 case 1731: pw_min = 5;
16857 pw_max = 5;
16858 mask = mystrdup ("?b?b?b?b?b");
16859 break;
16860 case 12500: pw_min = 5;
16861 pw_max = 5;
16862 mask = mystrdup ("?b?b?b?b?b");
16863 break;
16864 default: pw_min = 7;
16865 pw_max = 7;
16866 mask = mystrdup ("?b?b?b?b?b?b?b");
16867 break;
16868 }
16869
16870 maskcnt = 1;
16871
16872 masks[maskcnt - 1] = mystrdup (mask);
16873
16874 wordlist_mode = WL_MODE_MASK;
16875
16876 data.wordlist_mode = wordlist_mode;
16877
16878 increment = 1;
16879 }
16880
16881 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16882
16883 if (increment)
16884 {
16885 if (increment_min > pw_min) pw_min = increment_min;
16886
16887 if (increment_max < pw_max) pw_max = increment_max;
16888 }
16889 }
16890 else if (attack_mode == ATTACK_MODE_HYBRID1)
16891 {
16892 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16893
16894 // display
16895
16896 char *mask = myargv[myargc - 1];
16897
16898 maskcnt = 0;
16899
16900 masks = (char **) mymalloc (1 * sizeof (char *));
16901
16902 // mod
16903
16904 struct stat file_stat;
16905
16906 if (stat (mask, &file_stat) == -1)
16907 {
16908 maskcnt = 1;
16909
16910 masks[maskcnt - 1] = mystrdup (mask);
16911 }
16912 else
16913 {
16914 uint is_file = S_ISREG (file_stat.st_mode);
16915
16916 if (is_file == 1)
16917 {
16918 FILE *mask_fp;
16919
16920 if ((mask_fp = fopen (mask, "r")) == NULL)
16921 {
16922 log_error ("ERROR: %s: %s", mask, strerror (errno));
16923
16924 return (-1);
16925 }
16926
16927 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16928
16929 uint masks_avail = 1;
16930
16931 while (!feof (mask_fp))
16932 {
16933 memset (line_buf, 0, HCBUFSIZ);
16934
16935 int line_len = fgetl (mask_fp, line_buf);
16936
16937 if (line_len == 0) continue;
16938
16939 if (line_buf[0] == '#') continue;
16940
16941 if (masks_avail == maskcnt)
16942 {
16943 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16944
16945 masks_avail += INCR_MASKS;
16946 }
16947
16948 masks[maskcnt] = mystrdup (line_buf);
16949
16950 maskcnt++;
16951 }
16952
16953 myfree (line_buf);
16954
16955 fclose (mask_fp);
16956
16957 mask_from_file = 1;
16958 }
16959 else
16960 {
16961 maskcnt = 1;
16962
16963 masks[maskcnt - 1] = mystrdup (mask);
16964 }
16965 }
16966
16967 // base
16968
16969 int wls_left = myargc - (optind + 2);
16970
16971 for (int i = 0; i < wls_left; i++)
16972 {
16973 char *filename = myargv[optind + 1 + i];
16974
16975 struct stat file_stat;
16976
16977 if (stat (filename, &file_stat) == -1)
16978 {
16979 log_error ("ERROR: %s: %s", filename, strerror (errno));
16980
16981 return (-1);
16982 }
16983
16984 uint is_dir = S_ISDIR (file_stat.st_mode);
16985
16986 if (is_dir == 0)
16987 {
16988 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16989
16990 dictcnt++;
16991
16992 dictfiles[dictcnt - 1] = filename;
16993 }
16994 else
16995 {
16996 // do not allow --keyspace w/ a directory
16997
16998 if (keyspace == 1)
16999 {
17000 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17001
17002 return (-1);
17003 }
17004
17005 char **dictionary_files = NULL;
17006
17007 dictionary_files = scan_directory (filename);
17008
17009 if (dictionary_files != NULL)
17010 {
17011 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17012
17013 for (int d = 0; dictionary_files[d] != NULL; d++)
17014 {
17015 char *l1_filename = dictionary_files[d];
17016
17017 struct stat l1_stat;
17018
17019 if (stat (l1_filename, &l1_stat) == -1)
17020 {
17021 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17022
17023 return (-1);
17024 }
17025
17026 if (S_ISREG (l1_stat.st_mode))
17027 {
17028 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17029
17030 dictcnt++;
17031
17032 dictfiles[dictcnt - 1] = strdup (l1_filename);
17033 }
17034 }
17035 }
17036
17037 local_free (dictionary_files);
17038 }
17039 }
17040
17041 if (dictcnt < 1)
17042 {
17043 log_error ("ERROR: No usable dictionary file found.");
17044
17045 return (-1);
17046 }
17047
17048 if (increment)
17049 {
17050 maskcnt = 0;
17051
17052 uint mask_min = increment_min; // we can't reject smaller masks here
17053 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17054
17055 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17056 {
17057 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17058
17059 if (cur_mask == NULL) break;
17060
17061 masks[maskcnt] = cur_mask;
17062
17063 maskcnt++;
17064
17065 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17066 }
17067 }
17068 }
17069 else if (attack_mode == ATTACK_MODE_HYBRID2)
17070 {
17071 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
17072
17073 // display
17074
17075 char *mask = myargv[optind + 1 + 0];
17076
17077 maskcnt = 0;
17078
17079 masks = (char **) mymalloc (1 * sizeof (char *));
17080
17081 // mod
17082
17083 struct stat file_stat;
17084
17085 if (stat (mask, &file_stat) == -1)
17086 {
17087 maskcnt = 1;
17088
17089 masks[maskcnt - 1] = mystrdup (mask);
17090 }
17091 else
17092 {
17093 uint is_file = S_ISREG (file_stat.st_mode);
17094
17095 if (is_file == 1)
17096 {
17097 FILE *mask_fp;
17098
17099 if ((mask_fp = fopen (mask, "r")) == NULL)
17100 {
17101 log_error ("ERROR: %s: %s", mask, strerror (errno));
17102
17103 return (-1);
17104 }
17105
17106 char *line_buf = (char *) mymalloc (HCBUFSIZ);
17107
17108 uint masks_avail = 1;
17109
17110 while (!feof (mask_fp))
17111 {
17112 memset (line_buf, 0, HCBUFSIZ);
17113
17114 int line_len = fgetl (mask_fp, line_buf);
17115
17116 if (line_len == 0) continue;
17117
17118 if (line_buf[0] == '#') continue;
17119
17120 if (masks_avail == maskcnt)
17121 {
17122 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
17123
17124 masks_avail += INCR_MASKS;
17125 }
17126
17127 masks[maskcnt] = mystrdup (line_buf);
17128
17129 maskcnt++;
17130 }
17131
17132 myfree (line_buf);
17133
17134 fclose (mask_fp);
17135
17136 mask_from_file = 1;
17137 }
17138 else
17139 {
17140 maskcnt = 1;
17141
17142 masks[maskcnt - 1] = mystrdup (mask);
17143 }
17144 }
17145
17146 // base
17147
17148 int wls_left = myargc - (optind + 2);
17149
17150 for (int i = 0; i < wls_left; i++)
17151 {
17152 char *filename = myargv[optind + 2 + i];
17153
17154 struct stat file_stat;
17155
17156 if (stat (filename, &file_stat) == -1)
17157 {
17158 log_error ("ERROR: %s: %s", filename, strerror (errno));
17159
17160 return (-1);
17161 }
17162
17163 uint is_dir = S_ISDIR (file_stat.st_mode);
17164
17165 if (is_dir == 0)
17166 {
17167 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17168
17169 dictcnt++;
17170
17171 dictfiles[dictcnt - 1] = filename;
17172 }
17173 else
17174 {
17175 // do not allow --keyspace w/ a directory
17176
17177 if (keyspace == 1)
17178 {
17179 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17180
17181 return (-1);
17182 }
17183
17184 char **dictionary_files = NULL;
17185
17186 dictionary_files = scan_directory (filename);
17187
17188 if (dictionary_files != NULL)
17189 {
17190 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17191
17192 for (int d = 0; dictionary_files[d] != NULL; d++)
17193 {
17194 char *l1_filename = dictionary_files[d];
17195
17196 struct stat l1_stat;
17197
17198 if (stat (l1_filename, &l1_stat) == -1)
17199 {
17200 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17201
17202 return (-1);
17203 }
17204
17205 if (S_ISREG (l1_stat.st_mode))
17206 {
17207 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17208
17209 dictcnt++;
17210
17211 dictfiles[dictcnt - 1] = strdup (l1_filename);
17212 }
17213 }
17214 }
17215
17216 local_free (dictionary_files);
17217 }
17218 }
17219
17220 if (dictcnt < 1)
17221 {
17222 log_error ("ERROR: No usable dictionary file found.");
17223
17224 return (-1);
17225 }
17226
17227 if (increment)
17228 {
17229 maskcnt = 0;
17230
17231 uint mask_min = increment_min; // we can't reject smaller masks here
17232 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17233
17234 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17235 {
17236 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17237
17238 if (cur_mask == NULL) break;
17239
17240 masks[maskcnt] = cur_mask;
17241
17242 maskcnt++;
17243
17244 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17245 }
17246 }
17247 }
17248
17249 data.pw_min = pw_min;
17250 data.pw_max = pw_max;
17251
17252 /**
17253 * weak hash check
17254 */
17255
17256 if (weak_hash_threshold >= salts_cnt)
17257 {
17258 hc_device_param_t *device_param = NULL;
17259
17260 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17261 {
17262 device_param = &data.devices_param[device_id];
17263
17264 if (device_param->skipped) continue;
17265
17266 break;
17267 }
17268
17269 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
17270
17271 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
17272 {
17273 weak_hash_check (device_param, salt_pos);
17274 }
17275
17276 // Display hack, guarantee that there is at least one \r before real start
17277
17278 //if (data.quiet == 0) log_info ("");
17279 }
17280
17281 /**
17282 * status and monitor threads
17283 */
17284
17285 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17286 {
17287 data.devices_status = STATUS_STARTING;
17288 }
17289
17290 uint inner_threads_cnt = 0;
17291
17292 hc_thread_t *inner_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17293
17294 data.shutdown_inner = 0;
17295
17296 /**
17297 * Outfile remove
17298 */
17299
17300 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
17301 {
17302 hc_thread_create (inner_threads[inner_threads_cnt], thread_monitor, NULL);
17303
17304 inner_threads_cnt++;
17305
17306 if (outfile_check_timer != 0)
17307 {
17308 if (data.outfile_check_directory != NULL)
17309 {
17310 if ((hash_mode != 5200) &&
17311 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
17312 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
17313 (hash_mode != 9000))
17314 {
17315 hc_thread_create (inner_threads[inner_threads_cnt], thread_outfile_remove, NULL);
17316
17317 inner_threads_cnt++;
17318 }
17319 else
17320 {
17321 outfile_check_timer = 0;
17322 }
17323 }
17324 else
17325 {
17326 outfile_check_timer = 0;
17327 }
17328 }
17329 }
17330
17331 /**
17332 * Inform the user if we got some hashes remove because of the pot file remove feature
17333 */
17334
17335 if (data.quiet == 0)
17336 {
17337 if (potfile_remove_cracks > 0)
17338 {
17339 if (potfile_remove_cracks == 1) log_info ("INFO: Removed 1 hash found in pot file\n");
17340 else log_info ("INFO: Removed %u hashes found in pot file\n", potfile_remove_cracks);
17341 }
17342 }
17343
17344 data.outfile_check_timer = outfile_check_timer;
17345
17346 /**
17347 * main loop
17348 */
17349
17350 char **induction_dictionaries = NULL;
17351
17352 int induction_dictionaries_cnt = 0;
17353
17354 hcstat_table_t *root_table_buf = NULL;
17355 hcstat_table_t *markov_table_buf = NULL;
17356
17357 uint initial_restore_done = 0;
17358
17359 data.maskcnt = maskcnt;
17360
17361 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
17362 {
17363 if (data.devices_status == STATUS_CRACKED) continue;
17364 if (data.devices_status == STATUS_ABORTED) continue;
17365 if (data.devices_status == STATUS_QUIT) continue;
17366
17367 if (maskpos > rd->maskpos)
17368 {
17369 rd->dictpos = 0;
17370 }
17371
17372 rd->maskpos = maskpos;
17373 data.maskpos = maskpos;
17374
17375 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
17376 {
17377 char *mask = masks[maskpos];
17378
17379 if (mask_from_file == 1)
17380 {
17381 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
17382
17383 char *str_ptr;
17384 uint str_pos;
17385
17386 uint mask_offset = 0;
17387
17388 uint separator_cnt;
17389
17390 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
17391 {
17392 str_ptr = strstr (mask + mask_offset, ",");
17393
17394 if (str_ptr == NULL) break;
17395
17396 str_pos = str_ptr - mask;
17397
17398 // escaped separator, i.e. "\,"
17399
17400 if (str_pos > 0)
17401 {
17402 if (mask[str_pos - 1] == '\\')
17403 {
17404 separator_cnt --;
17405
17406 mask_offset = str_pos + 1;
17407
17408 continue;
17409 }
17410 }
17411
17412 // reset the offset
17413
17414 mask_offset = 0;
17415
17416 mask[str_pos] = '\0';
17417
17418 switch (separator_cnt)
17419 {
17420 case 0:
17421 mp_reset_usr (mp_usr, 0);
17422
17423 custom_charset_1 = mask;
17424 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17425 break;
17426
17427 case 1:
17428 mp_reset_usr (mp_usr, 1);
17429
17430 custom_charset_2 = mask;
17431 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17432 break;
17433
17434 case 2:
17435 mp_reset_usr (mp_usr, 2);
17436
17437 custom_charset_3 = mask;
17438 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17439 break;
17440
17441 case 3:
17442 mp_reset_usr (mp_usr, 3);
17443
17444 custom_charset_4 = mask;
17445 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
17446 break;
17447 }
17448
17449 mask = mask + str_pos + 1;
17450 }
17451 }
17452
17453 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17454 {
17455 if (maskpos > 0)
17456 {
17457 local_free (css_buf);
17458 local_free (data.root_css_buf);
17459 local_free (data.markov_css_buf);
17460
17461 local_free (masks[maskpos - 1]);
17462 }
17463
17464 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17465
17466 data.mask = mask;
17467 data.css_cnt = css_cnt;
17468 data.css_buf = css_buf;
17469
17470 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17471
17472 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17473
17474 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17475 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17476
17477 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17478
17479 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17480
17481 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17482 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17483
17484 data.root_css_buf = root_css_buf;
17485 data.markov_css_buf = markov_css_buf;
17486
17487 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17488
17489 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17490
17491 local_free (root_table_buf);
17492 local_free (markov_table_buf);
17493
17494 // args
17495
17496 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17497 {
17498 hc_device_param_t *device_param = &data.devices_param[device_id];
17499
17500 if (device_param->skipped) continue;
17501
17502 device_param->kernel_params_mp[0] = &device_param->d_combs;
17503 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
17504 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
17505
17506 device_param->kernel_params_mp_buf64[3] = 0;
17507 device_param->kernel_params_mp_buf32[4] = css_cnt;
17508 device_param->kernel_params_mp_buf32[5] = 0;
17509 device_param->kernel_params_mp_buf32[6] = 0;
17510 device_param->kernel_params_mp_buf32[7] = 0;
17511
17512 if (attack_mode == ATTACK_MODE_HYBRID1)
17513 {
17514 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
17515 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
17516 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
17517 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
17518 }
17519 else if (attack_mode == ATTACK_MODE_HYBRID2)
17520 {
17521 device_param->kernel_params_mp_buf32[5] = 0;
17522 device_param->kernel_params_mp_buf32[6] = 0;
17523 device_param->kernel_params_mp_buf32[7] = 0;
17524 }
17525
17526 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]);
17527 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]);
17528 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]);
17529
17530 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);
17531 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);
17532 }
17533 }
17534 else if (attack_mode == ATTACK_MODE_BF)
17535 {
17536 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
17537
17538 if (increment)
17539 {
17540 for (uint i = 0; i < dictcnt; i++)
17541 {
17542 local_free (dictfiles[i]);
17543 }
17544
17545 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17546 {
17547 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17548
17549 if (l1_filename == NULL) break;
17550
17551 dictcnt++;
17552
17553 dictfiles[dictcnt - 1] = l1_filename;
17554 }
17555 }
17556 else
17557 {
17558 dictcnt++;
17559
17560 dictfiles[dictcnt - 1] = mask;
17561 }
17562
17563 if (dictcnt == 0)
17564 {
17565 log_error ("ERROR: Mask is too small");
17566
17567 return (-1);
17568 }
17569 }
17570 }
17571
17572 free (induction_dictionaries);
17573
17574 // induction_dictionaries_cnt = 0; // implied
17575
17576 if (attack_mode != ATTACK_MODE_BF)
17577 {
17578 if (keyspace == 0)
17579 {
17580 induction_dictionaries = scan_directory (induction_directory);
17581
17582 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17583 }
17584 }
17585
17586 if (induction_dictionaries_cnt)
17587 {
17588 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17589 }
17590
17591 /**
17592 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17593 */
17594 if (keyspace == 1)
17595 {
17596 if ((maskcnt > 1) || (dictcnt > 1))
17597 {
17598 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17599
17600 return (-1);
17601 }
17602 }
17603
17604 for (uint dictpos = rd->dictpos; dictpos < dictcnt; dictpos++)
17605 {
17606 if (data.devices_status == STATUS_CRACKED) continue;
17607 if (data.devices_status == STATUS_ABORTED) continue;
17608 if (data.devices_status == STATUS_QUIT) continue;
17609
17610 rd->dictpos = dictpos;
17611
17612 char *subid = logfile_generate_subid ();
17613
17614 data.subid = subid;
17615
17616 logfile_sub_msg ("START");
17617
17618 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17619 {
17620 data.devices_status = STATUS_INIT;
17621 }
17622
17623 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17624 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17625 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17626
17627 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17628
17629 data.cpt_pos = 0;
17630
17631 data.cpt_start = time (NULL);
17632
17633 data.cpt_total = 0;
17634
17635 if (data.restore == 0)
17636 {
17637 rd->words_cur = skip;
17638
17639 skip = 0;
17640
17641 data.skip = 0;
17642 }
17643
17644 data.ms_paused = 0;
17645
17646 data.kernel_power_final = 0;
17647
17648 data.words_cur = rd->words_cur;
17649
17650 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17651 {
17652 hc_device_param_t *device_param = &data.devices_param[device_id];
17653
17654 if (device_param->skipped) continue;
17655
17656 device_param->speed_pos = 0;
17657
17658 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17659 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17660
17661 device_param->exec_pos = 0;
17662
17663 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17664
17665 device_param->outerloop_pos = 0;
17666 device_param->outerloop_left = 0;
17667 device_param->innerloop_pos = 0;
17668 device_param->innerloop_left = 0;
17669
17670 // some more resets:
17671
17672 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17673
17674 device_param->pws_cnt = 0;
17675
17676 device_param->words_off = 0;
17677 device_param->words_done = 0;
17678 }
17679
17680 // figure out some workload
17681
17682 if (attack_mode == ATTACK_MODE_STRAIGHT)
17683 {
17684 if (data.wordlist_mode == WL_MODE_FILE)
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 logfile_sub_string (dictfile);
17700
17701 for (uint i = 0; i < rp_files_cnt; i++)
17702 {
17703 logfile_sub_var_string ("rulefile", rp_files[i]);
17704 }
17705
17706 FILE *fd2 = fopen (dictfile, "rb");
17707
17708 if (fd2 == NULL)
17709 {
17710 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17711
17712 return (-1);
17713 }
17714
17715 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17716
17717 fclose (fd2);
17718
17719 if (data.words_cnt == 0)
17720 {
17721 logfile_sub_msg ("STOP");
17722
17723 continue;
17724 }
17725 }
17726 }
17727 else if (attack_mode == ATTACK_MODE_COMBI)
17728 {
17729 char *dictfile = data.dictfile;
17730 char *dictfile2 = data.dictfile2;
17731
17732 logfile_sub_string (dictfile);
17733 logfile_sub_string (dictfile2);
17734
17735 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17736 {
17737 FILE *fd2 = fopen (dictfile, "rb");
17738
17739 if (fd2 == NULL)
17740 {
17741 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17742
17743 return (-1);
17744 }
17745
17746 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17747
17748 fclose (fd2);
17749 }
17750 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17751 {
17752 FILE *fd2 = fopen (dictfile2, "rb");
17753
17754 if (fd2 == NULL)
17755 {
17756 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17757
17758 return (-1);
17759 }
17760
17761 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17762
17763 fclose (fd2);
17764 }
17765
17766 if (data.words_cnt == 0)
17767 {
17768 logfile_sub_msg ("STOP");
17769
17770 continue;
17771 }
17772 }
17773 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17774 {
17775 char *dictfile = NULL;
17776
17777 if (induction_dictionaries_cnt)
17778 {
17779 dictfile = induction_dictionaries[0];
17780 }
17781 else
17782 {
17783 dictfile = dictfiles[dictpos];
17784 }
17785
17786 data.dictfile = dictfile;
17787
17788 char *mask = data.mask;
17789
17790 logfile_sub_string (dictfile);
17791 logfile_sub_string (mask);
17792
17793 FILE *fd2 = fopen (dictfile, "rb");
17794
17795 if (fd2 == NULL)
17796 {
17797 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17798
17799 return (-1);
17800 }
17801
17802 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17803
17804 fclose (fd2);
17805
17806 if (data.words_cnt == 0)
17807 {
17808 logfile_sub_msg ("STOP");
17809
17810 continue;
17811 }
17812 }
17813 else if (attack_mode == ATTACK_MODE_BF)
17814 {
17815 local_free (css_buf);
17816 local_free (data.root_css_buf);
17817 local_free (data.markov_css_buf);
17818
17819 char *mask = dictfiles[dictpos];
17820
17821 logfile_sub_string (mask);
17822
17823 // base
17824
17825 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17826
17827 if (opts_type & OPTS_TYPE_PT_UNICODE)
17828 {
17829 uint css_cnt_unicode = css_cnt * 2;
17830
17831 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17832
17833 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17834 {
17835 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17836
17837 css_buf_unicode[j + 1].cs_buf[0] = 0;
17838 css_buf_unicode[j + 1].cs_len = 1;
17839 }
17840
17841 free (css_buf);
17842
17843 css_buf = css_buf_unicode;
17844 css_cnt = css_cnt_unicode;
17845 }
17846
17847 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17848
17849 uint mask_min = pw_min;
17850 uint mask_max = pw_max;
17851
17852 if (opts_type & OPTS_TYPE_PT_UNICODE)
17853 {
17854 mask_min *= 2;
17855 mask_max *= 2;
17856 }
17857
17858 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17859 {
17860 if (css_cnt < mask_min)
17861 {
17862 log_info ("WARNING: Skipping mask '%s' because it is smaller than the minimum password length", mask);
17863 }
17864
17865 if (css_cnt > mask_max)
17866 {
17867 log_info ("WARNING: Skipping mask '%s' because it is larger than the maximum password length", mask);
17868 }
17869
17870 // skip to next mask
17871
17872 logfile_sub_msg ("STOP");
17873
17874 continue;
17875 }
17876
17877 uint save_css_cnt = css_cnt;
17878
17879 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17880 {
17881 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17882 {
17883 uint salt_len = (uint) data.salts_buf[0].salt_len;
17884 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17885
17886 uint css_cnt_salt = css_cnt + salt_len;
17887
17888 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17889
17890 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17891
17892 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17893 {
17894 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17895 css_buf_salt[j].cs_len = 1;
17896 }
17897
17898 free (css_buf);
17899
17900 css_buf = css_buf_salt;
17901 css_cnt = css_cnt_salt;
17902 }
17903 }
17904
17905 data.mask = mask;
17906 data.css_cnt = css_cnt;
17907 data.css_buf = css_buf;
17908
17909 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17910
17911 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17912
17913 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17914
17915 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17916 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17917
17918 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17919
17920 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17921
17922 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17923 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17924
17925 data.root_css_buf = root_css_buf;
17926 data.markov_css_buf = markov_css_buf;
17927
17928 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17929
17930 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17931
17932 local_free (root_table_buf);
17933 local_free (markov_table_buf);
17934
17935 // copy + args
17936
17937 uint css_cnt_l = css_cnt;
17938 uint css_cnt_r;
17939
17940 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17941 {
17942 if (save_css_cnt < 6)
17943 {
17944 css_cnt_r = 1;
17945 }
17946 else if (save_css_cnt == 6)
17947 {
17948 css_cnt_r = 2;
17949 }
17950 else
17951 {
17952 if (opts_type & OPTS_TYPE_PT_UNICODE)
17953 {
17954 if (save_css_cnt == 8 || save_css_cnt == 10)
17955 {
17956 css_cnt_r = 2;
17957 }
17958 else
17959 {
17960 css_cnt_r = 4;
17961 }
17962 }
17963 else
17964 {
17965 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17966 {
17967 css_cnt_r = 3;
17968 }
17969 else
17970 {
17971 css_cnt_r = 4;
17972 }
17973 }
17974 }
17975 }
17976 else
17977 {
17978 css_cnt_r = 1;
17979
17980 /* unfinished code?
17981 int sum = css_buf[css_cnt_r - 1].cs_len;
17982
17983 for (uint i = 1; i < 4 && i < css_cnt; i++)
17984 {
17985 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17986
17987 css_cnt_r++;
17988
17989 sum *= css_buf[css_cnt_r - 1].cs_len;
17990 }
17991 */
17992 }
17993
17994 css_cnt_l -= css_cnt_r;
17995
17996 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17997
17998 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17999 {
18000 hc_device_param_t *device_param = &data.devices_param[device_id];
18001
18002 if (device_param->skipped) continue;
18003
18004 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
18005 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
18006 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
18007
18008 device_param->kernel_params_mp_l_buf64[3] = 0;
18009 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
18010 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
18011 device_param->kernel_params_mp_l_buf32[6] = 0;
18012 device_param->kernel_params_mp_l_buf32[7] = 0;
18013 device_param->kernel_params_mp_l_buf32[8] = 0;
18014
18015 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
18016 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
18017 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
18018 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
18019
18020 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
18021 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
18022 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
18023
18024 device_param->kernel_params_mp_r_buf64[3] = 0;
18025 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
18026 device_param->kernel_params_mp_r_buf32[5] = 0;
18027 device_param->kernel_params_mp_r_buf32[6] = 0;
18028 device_param->kernel_params_mp_r_buf32[7] = 0;
18029
18030 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]);
18031 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]);
18032 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]);
18033
18034 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]);
18035 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]);
18036 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]);
18037
18038 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);
18039 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);
18040 }
18041 }
18042
18043 u64 words_base = data.words_cnt;
18044
18045 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18046 {
18047 if (data.kernel_rules_cnt)
18048 {
18049 words_base /= data.kernel_rules_cnt;
18050 }
18051 }
18052 else if (data.attack_kern == ATTACK_KERN_COMBI)
18053 {
18054 if (data.combs_cnt)
18055 {
18056 words_base /= data.combs_cnt;
18057 }
18058 }
18059 else if (data.attack_kern == ATTACK_KERN_BF)
18060 {
18061 if (data.bfs_cnt)
18062 {
18063 words_base /= data.bfs_cnt;
18064 }
18065 }
18066
18067 data.words_base = words_base;
18068
18069 if (keyspace == 1)
18070 {
18071 log_info ("%llu", (unsigned long long int) words_base);
18072
18073 return (0);
18074 }
18075
18076 if (data.words_cur > data.words_base)
18077 {
18078 log_error ("ERROR: Restore value greater keyspace");
18079
18080 return (-1);
18081 }
18082
18083 if (data.words_cur)
18084 {
18085 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18086 {
18087 for (uint i = 0; i < data.salts_cnt; i++)
18088 {
18089 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
18090 }
18091 }
18092 else if (data.attack_kern == ATTACK_KERN_COMBI)
18093 {
18094 for (uint i = 0; i < data.salts_cnt; i++)
18095 {
18096 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
18097 }
18098 }
18099 else if (data.attack_kern == ATTACK_KERN_BF)
18100 {
18101 for (uint i = 0; i < data.salts_cnt; i++)
18102 {
18103 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
18104 }
18105 }
18106 }
18107
18108 /*
18109 * Update loopback file
18110 */
18111
18112 if (loopback == 1)
18113 {
18114 time_t now;
18115
18116 time (&now);
18117
18118 uint random_num = get_random_num (0, 9999);
18119
18120 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
18121
18122 data.loopback_file = loopback_file;
18123 }
18124
18125 /*
18126 * Update dictionary statistic
18127 */
18128
18129 if (keyspace == 0)
18130 {
18131 dictstat_fp = fopen (dictstat, "wb");
18132
18133 if (dictstat_fp)
18134 {
18135 lock_file (dictstat_fp);
18136
18137 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
18138
18139 fclose (dictstat_fp);
18140 }
18141 }
18142
18143 /**
18144 * create autotune threads
18145 */
18146
18147 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
18148
18149 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18150 {
18151 data.devices_status = STATUS_AUTOTUNE;
18152 }
18153
18154 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18155 {
18156 hc_device_param_t *device_param = &devices_param[device_id];
18157
18158 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
18159 }
18160
18161 hc_thread_wait (data.devices_cnt, c_threads);
18162
18163 /*
18164 * Inform user about possible slow speeds
18165 */
18166
18167 uint hardware_power_all = 0;
18168
18169 uint kernel_power_all = 0;
18170
18171 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18172 {
18173 hc_device_param_t *device_param = &devices_param[device_id];
18174
18175 hardware_power_all += device_param->hardware_power;
18176
18177 kernel_power_all += device_param->kernel_power;
18178 }
18179
18180 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
18181
18182 data.kernel_power_all = kernel_power_all;
18183
18184 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18185 {
18186 if (data.words_base < kernel_power_all)
18187 {
18188 if (quiet == 0)
18189 {
18190 clear_prompt ();
18191
18192 log_info ("ATTENTION!");
18193 log_info (" The wordlist or mask you are using is too small.");
18194 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
18195 log_info (" The cracking speed will drop.");
18196 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
18197 log_info ("");
18198 }
18199 }
18200 }
18201
18202 /**
18203 * create cracker threads
18204 */
18205
18206 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18207 {
18208 data.devices_status = STATUS_RUNNING;
18209 }
18210
18211 if (initial_restore_done == 0)
18212 {
18213 if (data.restore_disable == 0) cycle_restore ();
18214
18215 initial_restore_done = 1;
18216 }
18217
18218 hc_timer_set (&data.timer_running);
18219
18220 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18221 {
18222 if ((quiet == 0) && (status == 0) && (benchmark == 0))
18223 {
18224 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
18225 if (quiet == 0) fflush (stdout);
18226 }
18227 }
18228 else if (wordlist_mode == WL_MODE_STDIN)
18229 {
18230 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
18231 if (data.quiet == 0) log_info ("");
18232 }
18233
18234 time_t runtime_start;
18235
18236 time (&runtime_start);
18237
18238 data.runtime_start = runtime_start;
18239
18240 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18241 {
18242 hc_device_param_t *device_param = &devices_param[device_id];
18243
18244 if (wordlist_mode == WL_MODE_STDIN)
18245 {
18246 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
18247 }
18248 else
18249 {
18250 hc_thread_create (c_threads[device_id], thread_calc, device_param);
18251 }
18252 }
18253
18254 hc_thread_wait (data.devices_cnt, c_threads);
18255
18256 local_free (c_threads);
18257
18258 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18259 {
18260 data.devices_status = STATUS_EXHAUSTED;
18261 }
18262
18263 logfile_sub_var_uint ("status-after-work", data.devices_status);
18264
18265 data.restore = 0;
18266
18267 if (induction_dictionaries_cnt)
18268 {
18269 unlink (induction_dictionaries[0]);
18270 }
18271
18272 free (induction_dictionaries);
18273
18274 if (attack_mode != ATTACK_MODE_BF)
18275 {
18276 induction_dictionaries = scan_directory (induction_directory);
18277
18278 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18279 }
18280
18281 if (benchmark == 1)
18282 {
18283 status_benchmark ();
18284
18285 if (machine_readable == 0)
18286 {
18287 log_info ("");
18288 }
18289 }
18290 else
18291 {
18292 if (quiet == 0)
18293 {
18294 clear_prompt ();
18295
18296 log_info ("");
18297
18298 if (stdout_flag == 0) status_display ();
18299
18300 log_info ("");
18301 }
18302 }
18303
18304 if (induction_dictionaries_cnt)
18305 {
18306 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18307 }
18308
18309 time_t runtime_stop;
18310
18311 time (&runtime_stop);
18312
18313 data.runtime_stop = runtime_stop;
18314
18315 logfile_sub_uint (runtime_start);
18316 logfile_sub_uint (runtime_stop);
18317
18318 logfile_sub_msg ("STOP");
18319
18320 global_free (subid);
18321
18322 // from this point we handle bypass as running
18323
18324 if (data.devices_status == STATUS_BYPASS)
18325 {
18326 data.devices_status = STATUS_RUNNING;
18327 }
18328
18329 // and overwrite benchmark aborts as well
18330
18331 if (data.benchmark == 1)
18332 {
18333 if (data.devices_status == STATUS_ABORTED)
18334 {
18335 data.devices_status = STATUS_RUNNING;
18336 }
18337 }
18338
18339 // finalize task
18340
18341 if (data.devices_status == STATUS_CRACKED) break;
18342 if (data.devices_status == STATUS_ABORTED) break;
18343 if (data.devices_status == STATUS_QUIT) break;
18344 }
18345
18346 if (data.devices_status == STATUS_CRACKED) break;
18347 if (data.devices_status == STATUS_ABORTED) break;
18348 if (data.devices_status == STATUS_QUIT) break;
18349 }
18350
18351 // 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
18352 if (attack_mode == ATTACK_MODE_STRAIGHT)
18353 {
18354 if (data.wordlist_mode == WL_MODE_FILE)
18355 {
18356 if (data.dictfile == NULL)
18357 {
18358 if (dictfiles != NULL)
18359 {
18360 data.dictfile = dictfiles[0];
18361
18362 hc_timer_set (&data.timer_running);
18363 }
18364 }
18365 }
18366 }
18367 // NOTE: combi is okay because it is already set beforehand
18368 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
18369 {
18370 if (data.dictfile == NULL)
18371 {
18372 if (dictfiles != NULL)
18373 {
18374 hc_timer_set (&data.timer_running);
18375
18376 data.dictfile = dictfiles[0];
18377 }
18378 }
18379 }
18380 else if (attack_mode == ATTACK_MODE_BF)
18381 {
18382 if (data.mask == NULL)
18383 {
18384 hc_timer_set (&data.timer_running);
18385
18386 data.mask = masks[0];
18387 }
18388 }
18389
18390 // if cracked / aborted remove last induction dictionary
18391
18392 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
18393 {
18394 struct stat induct_stat;
18395
18396 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
18397 {
18398 unlink (induction_dictionaries[file_pos]);
18399 }
18400 }
18401
18402 // wait for inner threads
18403
18404 data.shutdown_inner = 1;
18405
18406 for (uint thread_idx = 0; thread_idx < inner_threads_cnt; thread_idx++)
18407 {
18408 hc_thread_wait (1, &inner_threads[thread_idx]);
18409 }
18410
18411 local_free (inner_threads);
18412
18413 // we dont need restore file anymore
18414 if (data.restore_disable == 0)
18415 {
18416 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
18417 {
18418 unlink (eff_restore_file);
18419 unlink (new_restore_file);
18420 }
18421 else
18422 {
18423 cycle_restore ();
18424 }
18425 }
18426
18427 // finally save left hashes
18428
18429 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
18430 {
18431 save_hash ();
18432 }
18433
18434 /**
18435 * Clean up
18436 */
18437
18438 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18439 {
18440 hc_device_param_t *device_param = &data.devices_param[device_id];
18441
18442 if (device_param->skipped) continue;
18443
18444 local_free (device_param->combs_buf);
18445 local_free (device_param->hooks_buf);
18446 local_free (device_param->device_name);
18447 local_free (device_param->device_name_chksum);
18448 local_free (device_param->device_version);
18449 local_free (device_param->driver_version);
18450
18451 if (device_param->pws_buf) myfree (device_param->pws_buf);
18452 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
18453 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
18454 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
18455 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
18456 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
18457 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
18458 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
18459 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
18460 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
18461 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
18462 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
18463 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
18464 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
18465 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
18466 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
18467 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
18468 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
18469 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
18470 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
18471 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
18472 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
18473 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
18474 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
18475 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
18476 if (device_param->d_scryptV0_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV0_buf);
18477 if (device_param->d_scryptV1_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV1_buf);
18478 if (device_param->d_scryptV2_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV2_buf);
18479 if (device_param->d_scryptV3_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV3_buf);
18480 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
18481 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
18482 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
18483
18484 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
18485 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
18486 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
18487 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
18488 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
18489 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
18490 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
18491 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
18492 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
18493 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
18494 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
18495
18496 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
18497 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
18498 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
18499
18500 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
18501 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
18502 }
18503
18504 // reset default fan speed
18505
18506 #ifdef HAVE_HWMON
18507 if (gpu_temp_disable == 0)
18508 {
18509 if (gpu_temp_retain != 0)
18510 {
18511 hc_thread_mutex_lock (mux_adl);
18512
18513 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18514 {
18515 hc_device_param_t *device_param = &data.devices_param[device_id];
18516
18517 if (device_param->skipped) continue;
18518
18519 if (data.hm_device[device_id].fan_set_supported == 1)
18520 {
18521 int rc = -1;
18522
18523 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18524 {
18525 rc = hm_set_fanspeed_with_device_id_adl (device_id, 100, 0);
18526 }
18527 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18528 {
18529 #ifdef LINUX
18530 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE);
18531 #endif
18532
18533 #ifdef WIN
18534 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, 100, 0);
18535 #endif
18536 }
18537
18538 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18539 }
18540 }
18541
18542 hc_thread_mutex_unlock (mux_adl);
18543 }
18544 }
18545
18546 // reset power tuning
18547
18548 if (powertune_enable == 1)
18549 {
18550 hc_thread_mutex_lock (mux_adl);
18551
18552 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18553 {
18554 hc_device_param_t *device_param = &data.devices_param[device_id];
18555
18556 if (device_param->skipped) continue;
18557
18558 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18559 {
18560 if (data.hm_device[device_id].od_version == 6)
18561 {
18562 // check powertune capabilities first, if not available then skip device
18563
18564 int powertune_supported = 0;
18565
18566 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18567 {
18568 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18569
18570 return (-1);
18571 }
18572
18573 if (powertune_supported != 0)
18574 {
18575 // powercontrol settings
18576
18577 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18578 {
18579 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18580
18581 return (-1);
18582 }
18583
18584 // clocks
18585
18586 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18587
18588 performance_state->iNumberOfPerformanceLevels = 2;
18589
18590 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18591 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18592 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18593 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18594
18595 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18596 {
18597 log_info ("ERROR: Failed to restore ADL performance state");
18598
18599 return (-1);
18600 }
18601
18602 local_free (performance_state);
18603 }
18604 }
18605 }
18606
18607 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18608 {
18609 unsigned int limit = nvml_power_limit[device_id];
18610
18611 if (limit > 0)
18612 {
18613 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18614 }
18615 }
18616 }
18617
18618 hc_thread_mutex_unlock (mux_adl);
18619 }
18620
18621 if (gpu_temp_disable == 0)
18622 {
18623 if (data.hm_nvml)
18624 {
18625 hm_NVML_nvmlShutdown (data.hm_nvml);
18626
18627 nvml_close (data.hm_nvml);
18628
18629 data.hm_nvml = NULL;
18630 }
18631
18632 if (data.hm_nvapi)
18633 {
18634 hm_NvAPI_Unload (data.hm_nvapi);
18635
18636 nvapi_close (data.hm_nvapi);
18637
18638 data.hm_nvapi = NULL;
18639 }
18640
18641 if (data.hm_xnvctrl)
18642 {
18643 hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);
18644
18645 xnvctrl_close (data.hm_xnvctrl);
18646
18647 data.hm_xnvctrl = NULL;
18648 }
18649
18650 if (data.hm_adl)
18651 {
18652 hm_ADL_Main_Control_Destroy (data.hm_adl);
18653
18654 adl_close (data.hm_adl);
18655
18656 data.hm_adl = NULL;
18657 }
18658 }
18659 #endif // HAVE_HWMON
18660
18661 // free memory
18662
18663 local_free (masks);
18664
18665 local_free (dictstat_base);
18666
18667 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18668 {
18669 pot_t *pot_ptr = &pot[pot_pos];
18670
18671 hash_t *hash = &pot_ptr->hash;
18672
18673 local_free (hash->digest);
18674
18675 if (isSalted)
18676 {
18677 local_free (hash->salt);
18678 }
18679 }
18680
18681 local_free (pot);
18682
18683 local_free (all_kernel_rules_cnt);
18684 local_free (all_kernel_rules_buf);
18685
18686 local_free (wl_data->buf);
18687 local_free (wl_data);
18688
18689 local_free (bitmap_s1_a);
18690 local_free (bitmap_s1_b);
18691 local_free (bitmap_s1_c);
18692 local_free (bitmap_s1_d);
18693 local_free (bitmap_s2_a);
18694 local_free (bitmap_s2_b);
18695 local_free (bitmap_s2_c);
18696 local_free (bitmap_s2_d);
18697
18698 #ifdef HAVE_HWMON
18699 local_free (od_clock_mem_status);
18700 local_free (od_power_control_status);
18701 local_free (nvml_power_limit);
18702 #endif
18703
18704 global_free (devices_param);
18705
18706 global_free (kernel_rules_buf);
18707
18708 global_free (root_css_buf);
18709 global_free (markov_css_buf);
18710
18711 global_free (digests_buf);
18712 global_free (digests_shown);
18713 global_free (digests_shown_tmp);
18714
18715 global_free (salts_buf);
18716 global_free (salts_shown);
18717
18718 global_free (esalts_buf);
18719
18720 global_free (words_progress_done);
18721 global_free (words_progress_rejected);
18722 global_free (words_progress_restored);
18723
18724 if (pot_fp) fclose (pot_fp);
18725
18726 if (data.devices_status == STATUS_QUIT) break;
18727 }
18728
18729 // wait for outer threads
18730
18731 data.shutdown_outer = 1;
18732
18733 for (uint thread_idx = 0; thread_idx < outer_threads_cnt; thread_idx++)
18734 {
18735 hc_thread_wait (1, &outer_threads[thread_idx]);
18736 }
18737
18738 local_free (outer_threads);
18739
18740 // destroy others mutex
18741
18742 hc_thread_mutex_delete (mux_dispatcher);
18743 hc_thread_mutex_delete (mux_counter);
18744 hc_thread_mutex_delete (mux_display);
18745 hc_thread_mutex_delete (mux_adl);
18746
18747 // free memory
18748
18749 local_free (eff_restore_file);
18750 local_free (new_restore_file);
18751
18752 local_free (rd);
18753
18754 // tuning db
18755
18756 tuning_db_destroy (tuning_db);
18757
18758 // loopback
18759
18760 local_free (loopback_file);
18761
18762 if (loopback == 1) unlink (loopback_file);
18763
18764 // induction directory
18765
18766 if (induction_dir == NULL)
18767 {
18768 if (attack_mode != ATTACK_MODE_BF)
18769 {
18770 if (rmdir (induction_directory) == -1)
18771 {
18772 if (errno == ENOENT)
18773 {
18774 // good, we can ignore
18775 }
18776 else if (errno == ENOTEMPTY)
18777 {
18778 // good, we can ignore
18779 }
18780 else
18781 {
18782 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18783
18784 return (-1);
18785 }
18786 }
18787
18788 local_free (induction_directory);
18789 }
18790 }
18791
18792 // outfile-check directory
18793
18794 if (outfile_check_dir == NULL)
18795 {
18796 if (rmdir (outfile_check_directory) == -1)
18797 {
18798 if (errno == ENOENT)
18799 {
18800 // good, we can ignore
18801 }
18802 else if (errno == ENOTEMPTY)
18803 {
18804 // good, we can ignore
18805 }
18806 else
18807 {
18808 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18809
18810 return (-1);
18811 }
18812 }
18813
18814 local_free (outfile_check_directory);
18815 }
18816
18817 time_t proc_stop;
18818
18819 time (&proc_stop);
18820
18821 logfile_top_uint (proc_start);
18822 logfile_top_uint (proc_stop);
18823
18824 logfile_top_msg ("STOP");
18825
18826 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18827 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18828
18829 if (data.ocl) ocl_close (data.ocl);
18830
18831 if (data.devices_status == STATUS_ABORTED) return 2;
18832 if (data.devices_status == STATUS_QUIT) return 2;
18833 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18834 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18835 if (data.devices_status == STATUS_CRACKED) return 0;
18836
18837 return -1;
18838 }
Hashcat additions to support pwdhash