projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Rewrite some code to workaround strict aliasing rule violation for older compilers
[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 #if defined(DARWIN) || defined(__FreeBSD__)
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 1
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 // in this case some required buffers are free'd, ascii_digest() would run into segfault
929 if (data.shutdown_inner == 1) return;
930
931 if (data.machine_readable == 1)
932 {
933 status_display_machine_readable ();
934
935 return;
936 }
937
938 char tmp_buf[1000] = { 0 };
939
940 uint tmp_len = 0;
941
942 log_info ("Session.Name...: %s", data.session);
943
944 char *status_type = strstatus (data.devices_status);
945
946 uint hash_mode = data.hash_mode;
947
948 char *hash_type = strhashtype (hash_mode); // not a bug
949
950 log_info ("Status.........: %s", status_type);
951
952 /**
953 * show rules
954 */
955
956 if (data.rp_files_cnt)
957 {
958 uint i;
959
960 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
961 {
962 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
963 }
964
965 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
966
967 log_info ("Rules.Type.....: %s", tmp_buf);
968
969 tmp_len = 0;
970 }
971
972 if (data.rp_gen)
973 {
974 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
975
976 if (data.rp_gen_seed)
977 {
978 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
979 }
980 }
981
982 /**
983 * show input
984 */
985
986 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
987 {
988 if (data.wordlist_mode == WL_MODE_FILE)
989 {
990 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
991 }
992 else if (data.wordlist_mode == WL_MODE_STDIN)
993 {
994 log_info ("Input.Mode.....: Pipe");
995 }
996 }
997 else if (data.attack_mode == ATTACK_MODE_COMBI)
998 {
999 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1000 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1001 }
1002 else if (data.attack_mode == ATTACK_MODE_BF)
1003 {
1004 char *mask = data.mask;
1005
1006 if (mask != NULL)
1007 {
1008 uint mask_len = data.css_cnt;
1009
1010 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1011
1012 if (mask_len > 0)
1013 {
1014 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1015 {
1016 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1017 {
1018 mask_len -= data.salts_buf[0].salt_len;
1019 }
1020 }
1021
1022 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1023
1024 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1025 }
1026
1027 if (data.maskcnt > 1)
1028 {
1029 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1030
1031 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1032 }
1033
1034 log_info ("Input.Mode.....: %s", tmp_buf);
1035 }
1036
1037 tmp_len = 0;
1038 }
1039 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1040 {
1041 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1042 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1043 }
1044 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1045 {
1046 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1047 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1048 }
1049
1050 if (data.digests_cnt == 1)
1051 {
1052 if (data.hash_mode == 2500)
1053 {
1054 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1055
1056 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1057 (char *) data.salts_buf[0].salt_buf,
1058 wpa->orig_mac1[0],
1059 wpa->orig_mac1[1],
1060 wpa->orig_mac1[2],
1061 wpa->orig_mac1[3],
1062 wpa->orig_mac1[4],
1063 wpa->orig_mac1[5],
1064 wpa->orig_mac2[0],
1065 wpa->orig_mac2[1],
1066 wpa->orig_mac2[2],
1067 wpa->orig_mac2[3],
1068 wpa->orig_mac2[4],
1069 wpa->orig_mac2[5]);
1070 }
1071 else if (data.hash_mode == 5200)
1072 {
1073 log_info ("Hash.Target....: File (%s)", data.hashfile);
1074 }
1075 else if (data.hash_mode == 9000)
1076 {
1077 log_info ("Hash.Target....: File (%s)", data.hashfile);
1078 }
1079 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1080 {
1081 log_info ("Hash.Target....: File (%s)", data.hashfile);
1082 }
1083 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1084 {
1085 log_info ("Hash.Target....: File (%s)", data.hashfile);
1086 }
1087 else
1088 {
1089 char out_buf[HCBUFSIZ] = { 0 };
1090
1091 ascii_digest (out_buf, 0, 0);
1092
1093 // limit length
1094 if (strlen (out_buf) > 40)
1095 {
1096 out_buf[41] = '.';
1097 out_buf[42] = '.';
1098 out_buf[43] = '.';
1099 out_buf[44] = 0;
1100 }
1101
1102 log_info ("Hash.Target....: %s", out_buf);
1103 }
1104 }
1105 else
1106 {
1107 if (data.hash_mode == 3000)
1108 {
1109 char out_buf1[32] = { 0 };
1110 char out_buf2[32] = { 0 };
1111
1112 ascii_digest (out_buf1, 0, 0);
1113 ascii_digest (out_buf2, 0, 1);
1114
1115 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1116 }
1117 else
1118 {
1119 log_info ("Hash.Target....: File (%s)", data.hashfile);
1120 }
1121 }
1122
1123 log_info ("Hash.Type......: %s", hash_type);
1124
1125 /**
1126 * speed new
1127 */
1128
1129 u64 speed_cnt[DEVICES_MAX] = { 0 };
1130 double speed_ms[DEVICES_MAX] = { 0 };
1131
1132 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1133 {
1134 hc_device_param_t *device_param = &data.devices_param[device_id];
1135
1136 if (device_param->skipped) continue;
1137
1138 speed_cnt[device_id] = 0;
1139 speed_ms[device_id] = 0;
1140
1141 for (int i = 0; i < SPEED_CACHE; i++)
1142 {
1143 speed_cnt[device_id] += device_param->speed_cnt[i];
1144 speed_ms[device_id] += device_param->speed_ms[i];
1145 }
1146
1147 speed_cnt[device_id] /= SPEED_CACHE;
1148 speed_ms[device_id] /= SPEED_CACHE;
1149 }
1150
1151 double hashes_all_ms = 0;
1152
1153 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1154
1155 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1156 {
1157 hc_device_param_t *device_param = &data.devices_param[device_id];
1158
1159 if (device_param->skipped) continue;
1160
1161 hashes_dev_ms[device_id] = 0;
1162
1163 if (speed_ms[device_id])
1164 {
1165 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1166
1167 hashes_all_ms += hashes_dev_ms[device_id];
1168 }
1169 }
1170
1171 /**
1172 * exec time
1173 */
1174
1175 double exec_all_ms[DEVICES_MAX] = { 0 };
1176
1177 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1178 {
1179 hc_device_param_t *device_param = &data.devices_param[device_id];
1180
1181 if (device_param->skipped) continue;
1182
1183 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1184
1185 exec_all_ms[device_id] = exec_ms_avg;
1186 }
1187
1188 /**
1189 * timers
1190 */
1191
1192 double ms_running = 0;
1193
1194 hc_timer_get (data.timer_running, ms_running);
1195
1196 double ms_paused = data.ms_paused;
1197
1198 if (data.devices_status == STATUS_PAUSED)
1199 {
1200 double ms_paused_tmp = 0;
1201
1202 hc_timer_get (data.timer_paused, ms_paused_tmp);
1203
1204 ms_paused += ms_paused_tmp;
1205 }
1206
1207 #ifdef WIN
1208
1209 __time64_t sec_run = ms_running / 1000;
1210
1211 #else
1212
1213 time_t sec_run = ms_running / 1000;
1214
1215 #endif
1216
1217 if (sec_run)
1218 {
1219 char display_run[32] = { 0 };
1220
1221 struct tm tm_run;
1222
1223 struct tm *tmp = NULL;
1224
1225 #ifdef WIN
1226
1227 tmp = _gmtime64 (&sec_run);
1228
1229 #else
1230
1231 tmp = gmtime (&sec_run);
1232
1233 #endif
1234
1235 if (tmp != NULL)
1236 {
1237 memset (&tm_run, 0, sizeof (tm_run));
1238
1239 memcpy (&tm_run, tmp, sizeof (tm_run));
1240
1241 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1242
1243 char *start = ctime (&data.proc_start);
1244
1245 size_t start_len = strlen (start);
1246
1247 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1248 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1249
1250 log_info ("Time.Started...: %s (%s)", start, display_run);
1251 }
1252 }
1253 else
1254 {
1255 log_info ("Time.Started...: 0 secs");
1256 }
1257
1258 /**
1259 * counters
1260 */
1261
1262 u64 progress_total = data.words_cnt * data.salts_cnt;
1263
1264 u64 all_done = 0;
1265 u64 all_rejected = 0;
1266 u64 all_restored = 0;
1267
1268 u64 progress_noneed = 0;
1269
1270 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1271 {
1272 all_done += data.words_progress_done[salt_pos];
1273 all_rejected += data.words_progress_rejected[salt_pos];
1274 all_restored += data.words_progress_restored[salt_pos];
1275
1276 // Important for ETA only
1277
1278 if (data.salts_shown[salt_pos] == 1)
1279 {
1280 const u64 all = data.words_progress_done[salt_pos]
1281 + data.words_progress_rejected[salt_pos]
1282 + data.words_progress_restored[salt_pos];
1283
1284 const u64 left = data.words_cnt - all;
1285
1286 progress_noneed += left;
1287 }
1288 }
1289
1290 u64 progress_cur = all_restored + all_done + all_rejected;
1291 u64 progress_end = progress_total;
1292
1293 u64 progress_skip = 0;
1294
1295 if (data.skip)
1296 {
1297 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1298
1299 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1300 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1301 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1302 }
1303
1304 if (data.limit)
1305 {
1306 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1307
1308 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1309 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1310 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1311 }
1312
1313 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1314 u64 progress_end_relative_skip = progress_end - progress_skip;
1315
1316 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1317 {
1318 if (data.devices_status != STATUS_CRACKED)
1319 {
1320 #ifdef WIN
1321 __time64_t sec_etc = 0;
1322 #else
1323 time_t sec_etc = 0;
1324 #endif
1325
1326 if (hashes_all_ms)
1327 {
1328 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1329
1330 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1331
1332 sec_etc = ms_left / 1000;
1333 }
1334
1335 if (sec_etc == 0)
1336 {
1337 //log_info ("Time.Estimated.: 0 secs");
1338 }
1339 else if ((u64) sec_etc > ETC_MAX)
1340 {
1341 log_info ("Time.Estimated.: > 10 Years");
1342 }
1343 else
1344 {
1345 char display_etc[32] = { 0 };
1346 char display_runtime[32] = { 0 };
1347
1348 struct tm tm_etc;
1349 struct tm tm_runtime;
1350
1351 struct tm *tmp = NULL;
1352
1353 #ifdef WIN
1354 tmp = _gmtime64 (&sec_etc);
1355 #else
1356 tmp = gmtime (&sec_etc);
1357 #endif
1358
1359 if (tmp != NULL)
1360 {
1361 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1362
1363 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1364
1365 time_t now;
1366
1367 time (&now);
1368
1369 now += sec_etc;
1370
1371 char *etc = ctime (&now);
1372
1373 size_t etc_len = strlen (etc);
1374
1375 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1376 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1377
1378 if (data.runtime)
1379 {
1380 time_t runtime_cur;
1381
1382 time (&runtime_cur);
1383
1384 #ifdef WIN
1385
1386 __time64_t runtime_left = data.proc_start + data.runtime - runtime_cur;
1387
1388 tmp = _gmtime64 (&runtime_left);
1389
1390 #else
1391
1392 time_t runtime_left = data.proc_start + data.runtime - runtime_cur;
1393
1394 tmp = gmtime (&runtime_left);
1395
1396 #endif
1397
1398 if ((tmp != NULL) && (runtime_left > 0) && (runtime_left < sec_etc))
1399 {
1400 memcpy (&tm_runtime, tmp, sizeof (tm_runtime));
1401
1402 format_timer_display (&tm_runtime, display_runtime, sizeof (display_runtime));
1403
1404 log_info ("Time.Estimated.: %s (%s), but limited (%s)", etc, display_etc, display_runtime);
1405 }
1406 else
1407 {
1408 log_info ("Time.Estimated.: %s (%s), but limit exceeded", etc, display_etc);
1409 }
1410 }
1411 else
1412 {
1413 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1414 }
1415 }
1416 }
1417 }
1418 }
1419
1420 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1421 {
1422 hc_device_param_t *device_param = &data.devices_param[device_id];
1423
1424 if (device_param->skipped) continue;
1425
1426 char display_dev_cur[16] = { 0 };
1427
1428 strncpy (display_dev_cur, "0.00", 4);
1429
1430 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1431
1432 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1433 }
1434
1435 char display_all_cur[16] = { 0 };
1436
1437 strncpy (display_all_cur, "0.00", 4);
1438
1439 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1440
1441 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1442
1443 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1444 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1445
1446 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);
1447
1448 // crack-per-time
1449
1450 if (data.digests_cnt > 100)
1451 {
1452 time_t now = time (NULL);
1453
1454 int cpt_cur_min = 0;
1455 int cpt_cur_hour = 0;
1456 int cpt_cur_day = 0;
1457
1458 for (int i = 0; i < CPT_BUF; i++)
1459 {
1460 const uint cracked = data.cpt_buf[i].cracked;
1461 const time_t timestamp = data.cpt_buf[i].timestamp;
1462
1463 if ((timestamp + 60) > now)
1464 {
1465 cpt_cur_min += cracked;
1466 }
1467
1468 if ((timestamp + 3600) > now)
1469 {
1470 cpt_cur_hour += cracked;
1471 }
1472
1473 if ((timestamp + 86400) > now)
1474 {
1475 cpt_cur_day += cracked;
1476 }
1477 }
1478
1479 double ms_real = ms_running - ms_paused;
1480
1481 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1482 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1483 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1484
1485 if ((data.cpt_start + 86400) < now)
1486 {
1487 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1488 cpt_cur_min,
1489 cpt_cur_hour,
1490 cpt_cur_day,
1491 cpt_avg_min,
1492 cpt_avg_hour,
1493 cpt_avg_day);
1494 }
1495 else if ((data.cpt_start + 3600) < now)
1496 {
1497 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1498 cpt_cur_min,
1499 cpt_cur_hour,
1500 cpt_avg_min,
1501 cpt_avg_hour,
1502 cpt_avg_day);
1503 }
1504 else if ((data.cpt_start + 60) < now)
1505 {
1506 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1507 cpt_cur_min,
1508 cpt_avg_min,
1509 cpt_avg_hour,
1510 cpt_avg_day);
1511 }
1512 else
1513 {
1514 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1515 cpt_avg_min,
1516 cpt_avg_hour,
1517 cpt_avg_day);
1518 }
1519 }
1520
1521 // Restore point
1522
1523 u64 restore_point = get_lowest_words_done ();
1524
1525 u64 restore_total = data.words_base;
1526
1527 float percent_restore = 0;
1528
1529 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1530
1531 if (progress_end_relative_skip)
1532 {
1533 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1534 {
1535 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1536 float percent_rejected = 0.0;
1537
1538 if (progress_cur)
1539 {
1540 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1541 }
1542
1543 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);
1544 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1545
1546 if (data.restore_disable == 0)
1547 {
1548 if (percent_finished != 1)
1549 {
1550 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1551 }
1552 }
1553 }
1554 }
1555 else
1556 {
1557 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1558 {
1559 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1560 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1561
1562 if (data.restore_disable == 0)
1563 {
1564 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1565 }
1566 }
1567 else
1568 {
1569 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1570 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1571
1572 // --restore not allowed if stdin is used -- really? why?
1573
1574 //if (data.restore_disable == 0)
1575 //{
1576 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1577 //}
1578 }
1579 }
1580
1581 #ifdef HAVE_HWMON
1582
1583 if (data.devices_status == STATUS_EXHAUSTED) return;
1584 if (data.devices_status == STATUS_CRACKED) return;
1585 if (data.devices_status == STATUS_ABORTED) return;
1586 if (data.devices_status == STATUS_QUIT) return;
1587
1588 if (data.gpu_temp_disable == 0)
1589 {
1590 hc_thread_mutex_lock (mux_adl);
1591
1592 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1593 {
1594 hc_device_param_t *device_param = &data.devices_param[device_id];
1595
1596 if (device_param->skipped) continue;
1597
1598 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1599 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1600 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1601 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1602 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1603 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1604 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1605
1606 char output_buf[256] = { 0 };
1607
1608 int output_len = 0;
1609
1610 if (num_temperature >= 0)
1611 {
1612 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1613
1614 output_len = strlen (output_buf);
1615 }
1616
1617 if (num_fanspeed >= 0)
1618 {
1619 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1620
1621 output_len = strlen (output_buf);
1622 }
1623
1624 if (num_utilization >= 0)
1625 {
1626 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1627
1628 output_len = strlen (output_buf);
1629 }
1630
1631 if (num_corespeed >= 0)
1632 {
1633 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1634
1635 output_len = strlen (output_buf);
1636 }
1637
1638 if (num_memoryspeed >= 0)
1639 {
1640 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1641
1642 output_len = strlen (output_buf);
1643 }
1644
1645 if (num_buslanes >= 0)
1646 {
1647 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1648
1649 output_len = strlen (output_buf);
1650 }
1651
1652 if (num_throttle == 1)
1653 {
1654 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1655
1656 output_len = strlen (output_buf);
1657 }
1658
1659 if (output_len == 0)
1660 {
1661 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1662
1663 output_len = strlen (output_buf);
1664 }
1665
1666 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1667 }
1668
1669 hc_thread_mutex_unlock (mux_adl);
1670 }
1671
1672 #endif // HAVE_HWMON
1673 }
1674
1675 static void status_benchmark_automate ()
1676 {
1677 u64 speed_cnt[DEVICES_MAX] = { 0 };
1678 double speed_ms[DEVICES_MAX] = { 0 };
1679
1680 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1681 {
1682 hc_device_param_t *device_param = &data.devices_param[device_id];
1683
1684 if (device_param->skipped) continue;
1685
1686 speed_cnt[device_id] = device_param->speed_cnt[0];
1687 speed_ms[device_id] = device_param->speed_ms[0];
1688 }
1689
1690 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1691
1692 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1693 {
1694 hc_device_param_t *device_param = &data.devices_param[device_id];
1695
1696 if (device_param->skipped) continue;
1697
1698 hashes_dev_ms[device_id] = 0;
1699
1700 if (speed_ms[device_id])
1701 {
1702 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1703 }
1704 }
1705
1706 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1707 {
1708 hc_device_param_t *device_param = &data.devices_param[device_id];
1709
1710 if (device_param->skipped) continue;
1711
1712 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1713 }
1714 }
1715
1716 static void status_benchmark ()
1717 {
1718 if (data.devices_status == STATUS_INIT) return;
1719 if (data.devices_status == STATUS_STARTING) return;
1720
1721 if (data.shutdown_inner == 1) return;
1722
1723 if (data.machine_readable == 1)
1724 {
1725 status_benchmark_automate ();
1726
1727 return;
1728 }
1729
1730 u64 speed_cnt[DEVICES_MAX] = { 0 };
1731 double speed_ms[DEVICES_MAX] = { 0 };
1732
1733 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1734 {
1735 hc_device_param_t *device_param = &data.devices_param[device_id];
1736
1737 if (device_param->skipped) continue;
1738
1739 speed_cnt[device_id] = device_param->speed_cnt[0];
1740 speed_ms[device_id] = device_param->speed_ms[0];
1741 }
1742
1743 double hashes_all_ms = 0;
1744
1745 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1746
1747 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1748 {
1749 hc_device_param_t *device_param = &data.devices_param[device_id];
1750
1751 if (device_param->skipped) continue;
1752
1753 hashes_dev_ms[device_id] = 0;
1754
1755 if (speed_ms[device_id])
1756 {
1757 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1758
1759 hashes_all_ms += hashes_dev_ms[device_id];
1760 }
1761 }
1762
1763 /**
1764 * exec time
1765 */
1766
1767 double exec_all_ms[DEVICES_MAX] = { 0 };
1768
1769 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1770 {
1771 hc_device_param_t *device_param = &data.devices_param[device_id];
1772
1773 if (device_param->skipped) continue;
1774
1775 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1776
1777 exec_all_ms[device_id] = exec_ms_avg;
1778 }
1779
1780 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1781 {
1782 hc_device_param_t *device_param = &data.devices_param[device_id];
1783
1784 if (device_param->skipped) continue;
1785
1786 char display_dev_cur[16] = { 0 };
1787
1788 strncpy (display_dev_cur, "0.00", 4);
1789
1790 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1791
1792 if (data.devices_active >= 10)
1793 {
1794 log_info ("Speed.Dev.#%d: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1795 }
1796 else
1797 {
1798 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1799 }
1800 }
1801
1802 char display_all_cur[16] = { 0 };
1803
1804 strncpy (display_all_cur, "0.00", 4);
1805
1806 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1807
1808 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1809 }
1810
1811 /**
1812 * hashcat -only- functions
1813 */
1814
1815 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1816 {
1817 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1818 {
1819 if (attack_kern == ATTACK_KERN_STRAIGHT)
1820 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1821 else if (attack_kern == ATTACK_KERN_COMBI)
1822 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1823 else if (attack_kern == ATTACK_KERN_BF)
1824 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1825 }
1826 else
1827 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1828 }
1829
1830 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)
1831 {
1832 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1833 {
1834 if (attack_kern == ATTACK_KERN_STRAIGHT)
1835 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1836 else if (attack_kern == ATTACK_KERN_COMBI)
1837 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1838 else if (attack_kern == ATTACK_KERN_BF)
1839 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1840 }
1841 else
1842 {
1843 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1844 }
1845 }
1846
1847 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1848 {
1849 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1850 {
1851 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1852 }
1853 else
1854 {
1855 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1856 }
1857 }
1858
1859 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)
1860 {
1861 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1862 {
1863 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1864 }
1865 else
1866 {
1867 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1868 }
1869 }
1870
1871 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1872 {
1873 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1874 }
1875
1876 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1877 {
1878 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1879 }
1880
1881 static char *filename_from_filepath (char *filepath)
1882 {
1883 char *ptr = NULL;
1884
1885 if ((ptr = strrchr (filepath, '/')) != NULL)
1886 {
1887 ptr++;
1888 }
1889 else if ((ptr = strrchr (filepath, '\\')) != NULL)
1890 {
1891 ptr++;
1892 }
1893 else
1894 {
1895 ptr = filepath;
1896 }
1897
1898 return ptr;
1899 }
1900
1901 static uint convert_from_hex (char *line_buf, const uint line_len)
1902 {
1903 if (line_len & 1) return (line_len); // not in hex
1904
1905 if (data.hex_wordlist == 1)
1906 {
1907 uint i;
1908 uint j;
1909
1910 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1911 {
1912 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1913 }
1914
1915 memset (line_buf + i, 0, line_len - i);
1916
1917 return (i);
1918 }
1919 else if (line_len >= 6) // $HEX[] = 6
1920 {
1921 if (line_buf[0] != '$') return (line_len);
1922 if (line_buf[1] != 'H') return (line_len);
1923 if (line_buf[2] != 'E') return (line_len);
1924 if (line_buf[3] != 'X') return (line_len);
1925 if (line_buf[4] != '[') return (line_len);
1926 if (line_buf[line_len - 1] != ']') return (line_len);
1927
1928 uint i;
1929 uint j;
1930
1931 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1932 {
1933 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1934 }
1935
1936 memset (line_buf + i, 0, line_len - i);
1937
1938 return (i);
1939 }
1940
1941 return (line_len);
1942 }
1943
1944 static void clear_prompt ()
1945 {
1946 fputc ('\r', stdout);
1947
1948 for (size_t i = 0; i < strlen (PROMPT); i++)
1949 {
1950 fputc (' ', stdout);
1951 }
1952
1953 fputc ('\r', stdout);
1954
1955 fflush (stdout);
1956 }
1957
1958 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1959 {
1960 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);
1961 }
1962
1963 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1964 {
1965 char *outfile = data.outfile;
1966 uint quiet = data.quiet;
1967 FILE *pot_fp = data.pot_fp;
1968 uint loopback = data.loopback;
1969 uint debug_mode = data.debug_mode;
1970 char *debug_file = data.debug_file;
1971
1972 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1973 int debug_rule_len = 0; // -1 error
1974 uint debug_plain_len = 0;
1975
1976 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1977
1978 // hash
1979
1980 char out_buf[HCBUFSIZ] = { 0 };
1981
1982 const u32 salt_pos = plain->salt_pos;
1983 const u32 digest_pos = plain->digest_pos; // relative
1984 const u32 gidvid = plain->gidvid;
1985 const u32 il_pos = plain->il_pos;
1986
1987 ascii_digest (out_buf, salt_pos, digest_pos);
1988
1989 // plain
1990
1991 u64 crackpos = device_param->words_off;
1992
1993 uint plain_buf[16] = { 0 };
1994
1995 u8 *plain_ptr = (u8 *) plain_buf;
1996
1997 unsigned int plain_len = 0;
1998
1999 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2000 {
2001 pw_t pw;
2002
2003 gidd_to_pw_t (device_param, gidvid, &pw);
2004
2005 for (int i = 0; i < 16; i++)
2006 {
2007 plain_buf[i] = pw.i[i];
2008 }
2009
2010 plain_len = pw.pw_len;
2011
2012 const uint off = device_param->innerloop_pos + il_pos;
2013
2014 if (debug_mode > 0)
2015 {
2016 debug_rule_len = 0;
2017
2018 // save rule
2019 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
2020 {
2021 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
2022
2023 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
2024 }
2025
2026 // save plain
2027 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
2028 {
2029 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
2030
2031 memcpy (debug_plain_ptr, plain_ptr, plain_len);
2032
2033 debug_plain_len = plain_len;
2034 }
2035 }
2036
2037 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2038
2039 crackpos += gidvid;
2040 crackpos *= data.kernel_rules_cnt;
2041 crackpos += device_param->innerloop_pos + il_pos;
2042
2043 if (plain_len > data.pw_max) plain_len = data.pw_max;
2044 }
2045 else if (data.attack_mode == ATTACK_MODE_COMBI)
2046 {
2047 pw_t pw;
2048
2049 gidd_to_pw_t (device_param, gidvid, &pw);
2050
2051 for (int i = 0; i < 16; i++)
2052 {
2053 plain_buf[i] = pw.i[i];
2054 }
2055
2056 plain_len = pw.pw_len;
2057
2058 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2059 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2060
2061 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2062 {
2063 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2064 }
2065 else
2066 {
2067 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2068
2069 memcpy (plain_ptr, comb_buf, comb_len);
2070 }
2071
2072 plain_len += comb_len;
2073
2074 crackpos += gidvid;
2075 crackpos *= data.combs_cnt;
2076 crackpos += device_param->innerloop_pos + il_pos;
2077
2078 if (data.pw_max != PW_DICTMAX1)
2079 {
2080 if (plain_len > data.pw_max) plain_len = data.pw_max;
2081 }
2082 }
2083 else if (data.attack_mode == ATTACK_MODE_BF)
2084 {
2085 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2086 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2087
2088 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2089 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2090
2091 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2092 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2093
2094 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2095 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2096
2097 plain_len = data.css_cnt;
2098
2099 crackpos += gidvid;
2100 crackpos *= data.bfs_cnt;
2101 crackpos += device_param->innerloop_pos + il_pos;
2102 }
2103 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2104 {
2105 pw_t pw;
2106
2107 gidd_to_pw_t (device_param, gidvid, &pw);
2108
2109 for (int i = 0; i < 16; i++)
2110 {
2111 plain_buf[i] = pw.i[i];
2112 }
2113
2114 plain_len = pw.pw_len;
2115
2116 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2117
2118 uint start = 0;
2119 uint stop = device_param->kernel_params_mp_buf32[4];
2120
2121 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2122
2123 plain_len += start + stop;
2124
2125 crackpos += gidvid;
2126 crackpos *= data.combs_cnt;
2127 crackpos += device_param->innerloop_pos + il_pos;
2128
2129 if (data.pw_max != PW_DICTMAX1)
2130 {
2131 if (plain_len > data.pw_max) plain_len = data.pw_max;
2132 }
2133 }
2134 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2135 {
2136 pw_t pw;
2137
2138 gidd_to_pw_t (device_param, gidvid, &pw);
2139
2140 for (int i = 0; i < 16; i++)
2141 {
2142 plain_buf[i] = pw.i[i];
2143 }
2144
2145 plain_len = pw.pw_len;
2146
2147 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2148
2149 uint start = 0;
2150 uint stop = device_param->kernel_params_mp_buf32[4];
2151
2152 memmove (plain_ptr + stop, plain_ptr, plain_len);
2153
2154 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2155
2156 plain_len += start + stop;
2157
2158 crackpos += gidvid;
2159 crackpos *= data.combs_cnt;
2160 crackpos += device_param->innerloop_pos + il_pos;
2161
2162 if (data.pw_max != PW_DICTMAX1)
2163 {
2164 if (plain_len > data.pw_max) plain_len = data.pw_max;
2165 }
2166 }
2167
2168 if (data.attack_mode == ATTACK_MODE_BF)
2169 {
2170 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2171 {
2172 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2173 {
2174 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2175 {
2176 plain_len = plain_len - data.salts_buf[0].salt_len;
2177 }
2178 }
2179
2180 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2181 {
2182 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2183 {
2184 plain_ptr[j] = plain_ptr[i];
2185 }
2186
2187 plain_len = plain_len / 2;
2188 }
2189 }
2190 }
2191
2192 // if enabled, update also the potfile
2193
2194 if (pot_fp)
2195 {
2196 lock_file (pot_fp);
2197
2198 fprintf (pot_fp, "%s:", out_buf);
2199
2200 format_plain (pot_fp, plain_ptr, plain_len, 1);
2201
2202 fputc ('\n', pot_fp);
2203
2204 fflush (pot_fp);
2205
2206 unlock_file (pot_fp);
2207 }
2208
2209 // outfile
2210
2211 FILE *out_fp = NULL;
2212
2213 if (outfile != NULL)
2214 {
2215 if ((out_fp = fopen (outfile, "ab")) == NULL)
2216 {
2217 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2218
2219 out_fp = stdout;
2220 }
2221
2222 lock_file (out_fp);
2223 }
2224 else
2225 {
2226 out_fp = stdout;
2227
2228 if (quiet == 0) clear_prompt ();
2229 }
2230
2231 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2232
2233 if (outfile != NULL)
2234 {
2235 if (out_fp != stdout)
2236 {
2237 fclose (out_fp);
2238 }
2239 }
2240 else
2241 {
2242 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2243 {
2244 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2245 {
2246 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2247 if (quiet == 0) fflush (stdout);
2248 }
2249 }
2250 }
2251
2252 // loopback
2253
2254 if (loopback)
2255 {
2256 char *loopback_file = data.loopback_file;
2257
2258 FILE *fb_fp = NULL;
2259
2260 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2261 {
2262 lock_file (fb_fp);
2263
2264 format_plain (fb_fp, plain_ptr, plain_len, 1);
2265
2266 fputc ('\n', fb_fp);
2267
2268 fclose (fb_fp);
2269 }
2270 }
2271
2272 // (rule) debug mode
2273
2274 // the next check implies that:
2275 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2276 // - debug_mode > 0
2277
2278 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2279 {
2280 if (debug_rule_len < 0) debug_rule_len = 0;
2281
2282 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2283
2284 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2285
2286 if ((quiet == 0) && (debug_file == NULL))
2287 {
2288 fprintf (stdout, "%s", PROMPT);
2289
2290 fflush (stdout);
2291 }
2292 }
2293 }
2294
2295 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2296 {
2297 salt_t *salt_buf = &data.salts_buf[salt_pos];
2298
2299 u32 num_cracked;
2300
2301 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2302
2303 if (num_cracked)
2304 {
2305 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2306
2307 log_info_nn ("");
2308
2309 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2310
2311 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);
2312
2313 uint cpt_cracked = 0;
2314
2315 hc_thread_mutex_lock (mux_display);
2316
2317 for (uint i = 0; i < num_cracked; i++)
2318 {
2319 const uint hash_pos = cracked[i].hash_pos;
2320
2321 if (data.digests_shown[hash_pos] == 1) continue;
2322
2323 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2324 {
2325 data.digests_shown[hash_pos] = 1;
2326
2327 data.digests_done++;
2328
2329 cpt_cracked++;
2330
2331 salt_buf->digests_done++;
2332
2333 if (salt_buf->digests_done == salt_buf->digests_cnt)
2334 {
2335 data.salts_shown[salt_pos] = 1;
2336
2337 data.salts_done++;
2338 }
2339 }
2340
2341 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2342
2343 check_hash (device_param, &cracked[i]);
2344 }
2345
2346 hc_thread_mutex_unlock (mux_display);
2347
2348 myfree (cracked);
2349
2350 if (cpt_cracked > 0)
2351 {
2352 hc_thread_mutex_lock (mux_display);
2353
2354 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2355 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2356
2357 data.cpt_pos++;
2358
2359 data.cpt_total += cpt_cracked;
2360
2361 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2362
2363 hc_thread_mutex_unlock (mux_display);
2364 }
2365
2366 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2367 {
2368 // we need to reset cracked state on the device
2369 // otherwise host thinks again and again the hash was cracked
2370 // and returns invalid password each time
2371
2372 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2373
2374 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);
2375 }
2376
2377 num_cracked = 0;
2378
2379 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2380 }
2381 }
2382
2383 // stolen from princeprocessor ;)
2384
2385 typedef struct
2386 {
2387 FILE *fp;
2388
2389 char buf[BUFSIZ];
2390 int len;
2391
2392 } out_t;
2393
2394 static void out_flush (out_t *out)
2395 {
2396 fwrite (out->buf, 1, out->len, out->fp);
2397
2398 out->len = 0;
2399 }
2400
2401 static void out_push (out_t *out, const u8 *pw_buf, const int pw_len)
2402 {
2403 char *ptr = out->buf + out->len;
2404
2405 memcpy (ptr, pw_buf, pw_len);
2406
2407 ptr[pw_len] = '\n';
2408
2409 out->len += pw_len + 1;
2410
2411 if (out->len >= BUFSIZ - 100)
2412 {
2413 out_flush (out);
2414 }
2415 }
2416
2417 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2418 {
2419 out_t out;
2420
2421 out.fp = stdout;
2422 out.len = 0;
2423
2424 uint plain_buf[16] = { 0 };
2425
2426 u8 *plain_ptr = (u8 *) plain_buf;
2427
2428 uint plain_len = 0;
2429
2430 const uint il_cnt = device_param->kernel_params_buf32[30]; // ugly, i know
2431
2432 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2433 {
2434 pw_t pw;
2435
2436 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2437 {
2438 gidd_to_pw_t (device_param, gidvid, &pw);
2439
2440 const uint pos = device_param->innerloop_pos;
2441
2442 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2443 {
2444 for (int i = 0; i < 8; i++)
2445 {
2446 plain_buf[i] = pw.i[i];
2447 }
2448
2449 plain_len = pw.pw_len;
2450
2451 plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2452
2453 if (plain_len > data.pw_max) plain_len = data.pw_max;
2454
2455 out_push (&out, plain_ptr, plain_len);
2456 }
2457 }
2458 }
2459 else if (data.attack_mode == ATTACK_MODE_COMBI)
2460 {
2461 pw_t pw;
2462
2463 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2464 {
2465 gidd_to_pw_t (device_param, gidvid, &pw);
2466
2467 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2468 {
2469 for (int i = 0; i < 8; i++)
2470 {
2471 plain_buf[i] = pw.i[i];
2472 }
2473
2474 plain_len = pw.pw_len;
2475
2476 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2477 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2478
2479 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2480 {
2481 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2482 }
2483 else
2484 {
2485 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2486
2487 memcpy (plain_ptr, comb_buf, comb_len);
2488 }
2489
2490 plain_len += comb_len;
2491
2492 if (data.pw_max != PW_DICTMAX1)
2493 {
2494 if (plain_len > data.pw_max) plain_len = data.pw_max;
2495 }
2496
2497 out_push (&out, plain_ptr, plain_len);
2498 }
2499 }
2500 }
2501 else if (data.attack_mode == ATTACK_MODE_BF)
2502 {
2503 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2504 {
2505 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2506 {
2507 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2508 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2509
2510 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2511 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2512
2513 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2514 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2515
2516 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2517 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2518
2519 plain_len = data.css_cnt;
2520
2521 out_push (&out, plain_ptr, plain_len);
2522 }
2523 }
2524 }
2525 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2526 {
2527 pw_t pw;
2528
2529 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2530 {
2531 gidd_to_pw_t (device_param, gidvid, &pw);
2532
2533 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2534 {
2535 for (int i = 0; i < 8; i++)
2536 {
2537 plain_buf[i] = pw.i[i];
2538 }
2539
2540 plain_len = pw.pw_len;
2541
2542 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2543
2544 uint start = 0;
2545 uint stop = device_param->kernel_params_mp_buf32[4];
2546
2547 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2548
2549 plain_len += start + stop;
2550
2551 out_push (&out, plain_ptr, plain_len);
2552 }
2553 }
2554 }
2555 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2556 {
2557 pw_t pw;
2558
2559 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2560 {
2561 gidd_to_pw_t (device_param, gidvid, &pw);
2562
2563 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2564 {
2565 for (int i = 0; i < 8; i++)
2566 {
2567 plain_buf[i] = pw.i[i];
2568 }
2569
2570 plain_len = pw.pw_len;
2571
2572 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2573
2574 uint start = 0;
2575 uint stop = device_param->kernel_params_mp_buf32[4];
2576
2577 memmove (plain_ptr + stop, plain_ptr, plain_len);
2578
2579 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2580
2581 plain_len += start + stop;
2582
2583 out_push (&out, plain_ptr, plain_len);
2584 }
2585 }
2586 }
2587
2588 out_flush (&out);
2589 }
2590
2591 static void save_hash ()
2592 {
2593 char *hashfile = data.hashfile;
2594
2595 char new_hashfile[256] = { 0 };
2596 char old_hashfile[256] = { 0 };
2597
2598 snprintf (new_hashfile, 255, "%s.new", hashfile);
2599 snprintf (old_hashfile, 255, "%s.old", hashfile);
2600
2601 unlink (new_hashfile);
2602
2603 char separator = data.separator;
2604
2605 FILE *fp = fopen (new_hashfile, "wb");
2606
2607 if (fp == NULL)
2608 {
2609 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2610
2611 exit (-1);
2612 }
2613
2614 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2615 {
2616 if (data.salts_shown[salt_pos] == 1) continue;
2617
2618 salt_t *salt_buf = &data.salts_buf[salt_pos];
2619
2620 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2621 {
2622 uint idx = salt_buf->digests_offset + digest_pos;
2623
2624 if (data.digests_shown[idx] == 1) continue;
2625
2626 if (data.hash_mode != 2500)
2627 {
2628 if (data.username == 1)
2629 {
2630 user_t *user = data.hash_info[idx]->user;
2631
2632 uint i;
2633
2634 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2635
2636 fputc (separator, fp);
2637 }
2638
2639 char out_buf[HCBUFSIZ]; // scratch buffer
2640
2641 out_buf[0] = 0;
2642
2643 ascii_digest (out_buf, salt_pos, digest_pos);
2644
2645 fputs (out_buf, fp);
2646
2647 fputc ('\n', fp);
2648 }
2649 else
2650 {
2651 hccap_t hccap;
2652
2653 to_hccap_t (&hccap, salt_pos, digest_pos);
2654
2655 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2656 }
2657 }
2658 }
2659
2660 fflush (fp);
2661
2662 fclose (fp);
2663
2664 unlink (old_hashfile);
2665
2666 if (rename (hashfile, old_hashfile) != 0)
2667 {
2668 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2669
2670 exit (-1);
2671 }
2672
2673 unlink (hashfile);
2674
2675 if (rename (new_hashfile, hashfile) != 0)
2676 {
2677 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2678
2679 exit (-1);
2680 }
2681
2682 unlink (old_hashfile);
2683 }
2684
2685 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2686 {
2687 uint num_elements = num;
2688
2689 device_param->kernel_params_buf32[33] = data.combs_mode;
2690 device_param->kernel_params_buf32[34] = num;
2691
2692 uint kernel_threads = device_param->kernel_threads;
2693
2694 while (num_elements % kernel_threads) num_elements++;
2695
2696 cl_kernel kernel = NULL;
2697
2698 switch (kern_run)
2699 {
2700 case KERN_RUN_1: kernel = device_param->kernel1; break;
2701 case KERN_RUN_12: kernel = device_param->kernel12; break;
2702 case KERN_RUN_2: kernel = device_param->kernel2; break;
2703 case KERN_RUN_23: kernel = device_param->kernel23; break;
2704 case KERN_RUN_3: kernel = device_param->kernel3; break;
2705 }
2706
2707 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2708 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2709 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2710 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2711 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2712 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2713 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2714 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2715 hc_clSetKernelArg (data.ocl, kernel, 32, sizeof (cl_uint), device_param->kernel_params[32]);
2716 hc_clSetKernelArg (data.ocl, kernel, 33, sizeof (cl_uint), device_param->kernel_params[33]);
2717 hc_clSetKernelArg (data.ocl, kernel, 34, sizeof (cl_uint), device_param->kernel_params[34]);
2718
2719 cl_event event;
2720
2721 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2722 {
2723 const size_t global_work_size[3] = { num_elements, 32, 1 };
2724 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2725
2726 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2727 }
2728 else
2729 {
2730 if (kern_run == KERN_RUN_2)
2731 {
2732 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2733 {
2734 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2735 }
2736 }
2737
2738 while (num_elements % kernel_threads) num_elements++;
2739
2740 const size_t global_work_size[3] = { num_elements, 1, 1 };
2741 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2742
2743 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2744 }
2745
2746 hc_clFlush (data.ocl, device_param->command_queue);
2747
2748 if (device_param->nvidia_spin_damp)
2749 {
2750 if (data.devices_status == STATUS_RUNNING)
2751 {
2752 if (iteration < EXPECTED_ITERATIONS)
2753 {
2754 switch (kern_run)
2755 {
2756 case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration] * device_param->nvidia_spin_damp); break;
2757 case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration] * device_param->nvidia_spin_damp); break;
2758 case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration] * device_param->nvidia_spin_damp); break;
2759 }
2760 }
2761 }
2762 }
2763
2764 hc_clWaitForEvents (data.ocl, 1, &event);
2765
2766 cl_ulong time_start;
2767 cl_ulong time_end;
2768
2769 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2770 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2771
2772 const double exec_us = (double) (time_end - time_start) / 1000;
2773
2774 if (data.devices_status == STATUS_RUNNING)
2775 {
2776 if (iteration < EXPECTED_ITERATIONS)
2777 {
2778 switch (kern_run)
2779 {
2780 case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2781 case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2782 case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2783 }
2784 }
2785 }
2786
2787 if (event_update)
2788 {
2789 uint exec_pos = device_param->exec_pos;
2790
2791 device_param->exec_ms[exec_pos] = exec_us / 1000;
2792
2793 exec_pos++;
2794
2795 if (exec_pos == EXEC_CACHE)
2796 {
2797 exec_pos = 0;
2798 }
2799
2800 device_param->exec_pos = exec_pos;
2801 }
2802
2803 hc_clReleaseEvent (data.ocl, event);
2804
2805 hc_clFinish (data.ocl, device_param->command_queue);
2806 }
2807
2808 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2809 {
2810 uint num_elements = num;
2811
2812 switch (kern_run)
2813 {
2814 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2815 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2816 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2817 }
2818
2819 // causes problems with special threads like in bcrypt
2820 // const uint kernel_threads = device_param->kernel_threads;
2821
2822 uint kernel_threads = device_param->kernel_threads;
2823
2824 while (num_elements % kernel_threads) num_elements++;
2825
2826 cl_kernel kernel = NULL;
2827
2828 switch (kern_run)
2829 {
2830 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2831 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2832 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2833 }
2834
2835 switch (kern_run)
2836 {
2837 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2838 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2839 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2840 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2841 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2842 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2843 break;
2844 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2845 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2846 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2847 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2848 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2849 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2850 break;
2851 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2852 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2853 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2854 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2855 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2856 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2857 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2858 break;
2859 }
2860
2861 const size_t global_work_size[3] = { num_elements, 1, 1 };
2862 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2863
2864 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2865
2866 hc_clFlush (data.ocl, device_param->command_queue);
2867
2868 hc_clFinish (data.ocl, device_param->command_queue);
2869 }
2870
2871 static void run_kernel_tm (hc_device_param_t *device_param)
2872 {
2873 const uint num_elements = 1024; // fixed
2874
2875 uint kernel_threads = 32;
2876
2877 cl_kernel kernel = device_param->kernel_tm;
2878
2879 const size_t global_work_size[3] = { num_elements, 1, 1 };
2880 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2881
2882 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2883
2884 hc_clFlush (data.ocl, device_param->command_queue);
2885
2886 hc_clFinish (data.ocl, device_param->command_queue);
2887 }
2888
2889 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2890 {
2891 uint num_elements = num;
2892
2893 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2894 device_param->kernel_params_amp_buf32[6] = num_elements;
2895
2896 // causes problems with special threads like in bcrypt
2897 // const uint kernel_threads = device_param->kernel_threads;
2898
2899 uint kernel_threads = device_param->kernel_threads;
2900
2901 while (num_elements % kernel_threads) num_elements++;
2902
2903 cl_kernel kernel = device_param->kernel_amp;
2904
2905 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2906 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2907
2908 const size_t global_work_size[3] = { num_elements, 1, 1 };
2909 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2910
2911 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2912
2913 hc_clFlush (data.ocl, device_param->command_queue);
2914
2915 hc_clFinish (data.ocl, device_param->command_queue);
2916 }
2917
2918 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2919 {
2920 const u32 num16d = num / 16;
2921 const u32 num16m = num % 16;
2922
2923 if (num16d)
2924 {
2925 device_param->kernel_params_memset_buf32[1] = value;
2926 device_param->kernel_params_memset_buf32[2] = num16d;
2927
2928 uint kernel_threads = device_param->kernel_threads;
2929
2930 uint num_elements = num16d;
2931
2932 while (num_elements % kernel_threads) num_elements++;
2933
2934 cl_kernel kernel = device_param->kernel_memset;
2935
2936 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2937 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2938 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2939
2940 const size_t global_work_size[3] = { num_elements, 1, 1 };
2941 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2942
2943 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2944
2945 hc_clFlush (data.ocl, device_param->command_queue);
2946
2947 hc_clFinish (data.ocl, device_param->command_queue);
2948 }
2949
2950 if (num16m)
2951 {
2952 u32 tmp[4];
2953
2954 tmp[0] = value;
2955 tmp[1] = value;
2956 tmp[2] = value;
2957 tmp[3] = value;
2958
2959 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2960 }
2961 }
2962
2963 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2964 {
2965 run_kernel_memset (device_param, buf, 0, size);
2966
2967 /*
2968 int rc = -1;
2969
2970 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2971 {
2972 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2973
2974 const cl_uchar zero = 0;
2975
2976 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2977 }
2978
2979 if (rc != 0)
2980 {
2981 // NOTE: clEnqueueFillBuffer () always fails with -59
2982 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2983 // How's that possible, OpenCL 1.2 support is advertised??
2984 // We need to workaround...
2985
2986 #define FILLSZ 0x100000
2987
2988 char *tmp = (char *) mymalloc (FILLSZ);
2989
2990 for (size_t i = 0; i < size; i += FILLSZ)
2991 {
2992 const size_t left = size - i;
2993
2994 const size_t fillsz = MIN (FILLSZ, left);
2995
2996 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2997 }
2998
2999 myfree (tmp);
3000 }
3001 */
3002 }
3003
3004 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)
3005 {
3006 if (data.hash_mode == 2000)
3007 {
3008 process_stdout (device_param, pws_cnt);
3009
3010 return;
3011 }
3012
3013 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3014 {
3015 if (attack_mode == ATTACK_MODE_BF)
3016 {
3017 if (opts_type & OPTS_TYPE_PT_BITSLICE)
3018 {
3019 const uint size_tm = 32 * sizeof (bs_word_t);
3020
3021 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
3022
3023 run_kernel_tm (device_param);
3024
3025 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);
3026 }
3027 }
3028
3029 if (highest_pw_len < 16)
3030 {
3031 run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
3032 }
3033 else if (highest_pw_len < 32)
3034 {
3035 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
3036 }
3037 else
3038 {
3039 run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
3040 }
3041 }
3042 else
3043 {
3044 run_kernel_amp (device_param, pws_cnt);
3045
3046 run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
3047
3048 if (opts_type & OPTS_TYPE_HOOK12)
3049 {
3050 run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
3051
3052 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);
3053
3054 // do something with data
3055
3056 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);
3057 }
3058
3059 uint iter = salt_buf->salt_iter;
3060
3061 uint loop_step = device_param->kernel_loops;
3062
3063 for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
3064 {
3065 uint loop_left = iter - loop_pos;
3066
3067 loop_left = MIN (loop_left, loop_step);
3068
3069 device_param->kernel_params_buf32[28] = loop_pos;
3070 device_param->kernel_params_buf32[29] = loop_left;
3071
3072 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
3073
3074 if (data.devices_status == STATUS_CRACKED) break;
3075 if (data.devices_status == STATUS_ABORTED) break;
3076 if (data.devices_status == STATUS_QUIT) break;
3077 if (data.devices_status == STATUS_BYPASS) break;
3078
3079 /**
3080 * speed
3081 */
3082
3083 const float iter_part = (float) (loop_pos + loop_left) / iter;
3084
3085 const u64 perf_sum_all = pws_cnt * iter_part;
3086
3087 double speed_ms;
3088
3089 hc_timer_get (device_param->timer_speed, speed_ms);
3090
3091 const u32 speed_pos = device_param->speed_pos;
3092
3093 device_param->speed_cnt[speed_pos] = perf_sum_all;
3094
3095 device_param->speed_ms[speed_pos] = speed_ms;
3096
3097 if (data.benchmark == 1)
3098 {
3099 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
3100 }
3101 }
3102
3103 if (opts_type & OPTS_TYPE_HOOK23)
3104 {
3105 run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
3106
3107 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);
3108
3109 // do something with data
3110
3111 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);
3112 }
3113
3114 run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3115 }
3116 }
3117
3118 static int run_rule_engine (const int rule_len, const char *rule_buf)
3119 {
3120 if (rule_len == 0)
3121 {
3122 return 0;
3123 }
3124 else if (rule_len == 1)
3125 {
3126 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3127 }
3128
3129 return 1;
3130 }
3131
3132 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3133 {
3134 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3135 {
3136 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);
3137 }
3138 else if (data.attack_kern == ATTACK_KERN_COMBI)
3139 {
3140 if (data.attack_mode == ATTACK_MODE_COMBI)
3141 {
3142 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3143 {
3144 if (data.opts_type & OPTS_TYPE_PT_ADD01)
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] = 0x01;
3153 }
3154 }
3155 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3156 {
3157 for (u32 i = 0; i < pws_cnt; i++)
3158 {
3159 const u32 pw_len = device_param->pws_buf[i].pw_len;
3160
3161 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3162
3163 ptr[pw_len] = 0x80;
3164 }
3165 }
3166 }
3167 }
3168 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3169 {
3170 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3171 {
3172 for (u32 i = 0; i < pws_cnt; i++)
3173 {
3174 const u32 pw_len = device_param->pws_buf[i].pw_len;
3175
3176 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3177
3178 ptr[pw_len] = 0x01;
3179 }
3180 }
3181 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3182 {
3183 for (u32 i = 0; i < pws_cnt; i++)
3184 {
3185 const u32 pw_len = device_param->pws_buf[i].pw_len;
3186
3187 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3188
3189 ptr[pw_len] = 0x80;
3190 }
3191 }
3192 }
3193
3194 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);
3195 }
3196 else if (data.attack_kern == ATTACK_KERN_BF)
3197 {
3198 const u64 off = device_param->words_off;
3199
3200 device_param->kernel_params_mp_l_buf64[3] = off;
3201
3202 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3203 }
3204 }
3205
3206 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3207 {
3208 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3209
3210 device_param->kernel_params_buf32[28] = 0;
3211 device_param->kernel_params_buf32[29] = kernel_loops; // not a bug, both need to be set
3212 device_param->kernel_params_buf32[30] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3213
3214 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3215 {
3216 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3217 }
3218 else
3219 {
3220 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3221 }
3222
3223 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3224
3225 return exec_ms_prev;
3226 }
3227
3228 static void autotune (hc_device_param_t *device_param)
3229 {
3230 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3231
3232 const u32 kernel_accel_min = device_param->kernel_accel_min;
3233 const u32 kernel_accel_max = device_param->kernel_accel_max;
3234
3235 const u32 kernel_loops_min = device_param->kernel_loops_min;
3236 const u32 kernel_loops_max = device_param->kernel_loops_max;
3237
3238 u32 kernel_accel = kernel_accel_min;
3239 u32 kernel_loops = kernel_loops_min;
3240
3241 // in this case the user specified a fixed -u and -n on the commandline
3242 // no way to tune anything
3243 // but we need to run a few caching rounds
3244
3245 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3246 {
3247 if (data.hash_mode != 2000)
3248 {
3249 try_run (device_param, kernel_accel, kernel_loops);
3250 try_run (device_param, kernel_accel, kernel_loops);
3251 try_run (device_param, kernel_accel, kernel_loops);
3252 try_run (device_param, kernel_accel, kernel_loops);
3253 }
3254
3255 device_param->kernel_accel = kernel_accel;
3256 device_param->kernel_loops = kernel_loops;
3257
3258 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3259
3260 device_param->kernel_power = kernel_power;
3261
3262 return;
3263 }
3264
3265 // from here it's clear we are allowed to autotune
3266 // so let's init some fake words
3267
3268 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3269
3270 if (data.attack_kern == ATTACK_KERN_BF)
3271 {
3272 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3273 }
3274 else
3275 {
3276 for (u32 i = 0; i < kernel_power_max; i++)
3277 {
3278 device_param->pws_buf[i].i[0] = i;
3279 device_param->pws_buf[i].i[1] = 0x01234567;
3280 device_param->pws_buf[i].pw_len = 7 + (i & 7);
3281 }
3282
3283 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);
3284 }
3285
3286 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3287 {
3288 if (data.kernel_rules_cnt > 1)
3289 {
3290 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);
3291 }
3292 }
3293 else
3294 {
3295 run_kernel_amp (device_param, kernel_power_max);
3296 }
3297
3298 #define VERIFIER_CNT 1
3299
3300 // first find out highest kernel-loops that stays below target_ms
3301
3302 if (kernel_loops_min < kernel_loops_max)
3303 {
3304 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3305 {
3306 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3307
3308 for (int i = 0; i < VERIFIER_CNT; i++)
3309 {
3310 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3311
3312 exec_ms = MIN (exec_ms, exec_ms_v);
3313 }
3314
3315 if (exec_ms < target_ms) break;
3316 }
3317 }
3318
3319 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3320
3321 #define STEPS_CNT 10
3322
3323 if (kernel_accel_min < kernel_accel_max)
3324 {
3325 for (int i = 0; i < STEPS_CNT; i++)
3326 {
3327 const u32 kernel_accel_try = 1 << i;
3328
3329 if (kernel_accel_try < kernel_accel_min) continue;
3330 if (kernel_accel_try > kernel_accel_max) break;
3331
3332 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3333
3334 for (int i = 0; i < VERIFIER_CNT; i++)
3335 {
3336 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3337
3338 exec_ms = MIN (exec_ms, exec_ms_v);
3339 }
3340
3341 if (exec_ms > target_ms) break;
3342
3343 kernel_accel = kernel_accel_try;
3344 }
3345 }
3346
3347 // at this point we want to know the actual runtime for the following reason:
3348 // we need a reference for the balancing loop following up, and this
3349 // the balancing loop can have an effect that the creates a new opportunity, for example:
3350 // if the target is 95 ms and the current runtime is 48ms the above loop
3351 // stopped the execution because the previous exec_ms was > 95ms
3352 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3353 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3354
3355 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3356
3357 for (int i = 0; i < VERIFIER_CNT; i++)
3358 {
3359 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3360
3361 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3362 }
3363
3364 u32 diff = kernel_loops - kernel_accel;
3365
3366 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3367 {
3368 u32 kernel_accel_orig = kernel_accel;
3369 u32 kernel_loops_orig = kernel_loops;
3370
3371 for (u32 f = 1; f < 1024; f++)
3372 {
3373 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3374 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3375
3376 if (kernel_accel_try > kernel_accel_max) break;
3377 if (kernel_loops_try < kernel_loops_min) break;
3378
3379 u32 diff_new = kernel_loops_try - kernel_accel_try;
3380
3381 if (diff_new > diff) break;
3382
3383 diff_new = diff;
3384
3385 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3386
3387 for (int i = 0; i < VERIFIER_CNT; i++)
3388 {
3389 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3390
3391 exec_ms = MIN (exec_ms, exec_ms_v);
3392 }
3393
3394 if (exec_ms < exec_ms_pre_final)
3395 {
3396 exec_ms_pre_final = exec_ms;
3397
3398 kernel_accel = kernel_accel_try;
3399 kernel_loops = kernel_loops_try;
3400 }
3401 }
3402 }
3403
3404 const double exec_left = target_ms / exec_ms_pre_final;
3405
3406 const double accel_left = kernel_accel_max / kernel_accel;
3407
3408 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3409
3410 if (exec_accel_min >= 1.0)
3411 {
3412 // this is safe to not overflow kernel_accel_max because of accel_left
3413
3414 kernel_accel = (double) kernel_accel * exec_accel_min;
3415 }
3416
3417 // reset them fake words
3418
3419 /*
3420 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3421
3422 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);
3423 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);
3424 */
3425
3426 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3427
3428 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3429 {
3430 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3431 }
3432
3433 // reset timer
3434
3435 device_param->exec_pos = 0;
3436
3437 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3438
3439 memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3440 memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3441 memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3442
3443 // store
3444
3445 device_param->kernel_accel = kernel_accel;
3446 device_param->kernel_loops = kernel_loops;
3447
3448 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3449
3450 device_param->kernel_power = kernel_power;
3451
3452 #ifdef DEBUG
3453
3454 if (data.quiet == 0)
3455 {
3456 clear_prompt ();
3457
3458 log_info ("- Device #%u: autotuned kernel-accel to %u\n"
3459 "- Device #%u: autotuned kernel-loops to %u\n",
3460 device_param->device_id + 1, kernel_accel,
3461 device_param->device_id + 1, kernel_loops);
3462
3463 fprintf (stdout, "%s", PROMPT);
3464
3465 fflush (stdout);
3466 }
3467
3468 #endif
3469 }
3470
3471 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3472 {
3473 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3474
3475 // init speed timer
3476
3477 uint speed_pos = device_param->speed_pos;
3478
3479 #ifdef _POSIX
3480 if (device_param->timer_speed.tv_sec == 0)
3481 {
3482 hc_timer_set (&device_param->timer_speed);
3483 }
3484 #endif
3485
3486 #ifdef _WIN
3487 if (device_param->timer_speed.QuadPart == 0)
3488 {
3489 hc_timer_set (&device_param->timer_speed);
3490 }
3491 #endif
3492
3493 // find higest password length, this is for optimization stuff
3494
3495 uint highest_pw_len = 0;
3496
3497 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3498 {
3499 }
3500 else if (data.attack_kern == ATTACK_KERN_COMBI)
3501 {
3502 }
3503 else if (data.attack_kern == ATTACK_KERN_BF)
3504 {
3505 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3506 + device_param->kernel_params_mp_l_buf32[5];
3507 }
3508
3509 // iteration type
3510
3511 uint innerloop_step = 0;
3512 uint innerloop_cnt = 0;
3513
3514 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3515 else innerloop_step = 1;
3516
3517 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3518 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3519 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3520
3521 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3522
3523 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3524 {
3525 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3526
3527 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3528
3529 if (data.devices_status == STATUS_CRACKED) break;
3530 if (data.devices_status == STATUS_ABORTED) break;
3531 if (data.devices_status == STATUS_QUIT) break;
3532 if (data.devices_status == STATUS_BYPASS) break;
3533
3534 salt_t *salt_buf = &data.salts_buf[salt_pos];
3535
3536 device_param->kernel_params_buf32[27] = salt_pos;
3537 device_param->kernel_params_buf32[31] = salt_buf->digests_cnt;
3538 device_param->kernel_params_buf32[32] = salt_buf->digests_offset;
3539
3540 FILE *combs_fp = device_param->combs_fp;
3541
3542 if (data.attack_mode == ATTACK_MODE_COMBI)
3543 {
3544 rewind (combs_fp);
3545 }
3546
3547 // innerloops
3548
3549 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3550 {
3551 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3552
3553 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3554
3555 if (data.devices_status == STATUS_CRACKED) break;
3556 if (data.devices_status == STATUS_ABORTED) break;
3557 if (data.devices_status == STATUS_QUIT) break;
3558 if (data.devices_status == STATUS_BYPASS) break;
3559
3560 uint fast_iteration = 0;
3561
3562 uint innerloop_left = innerloop_cnt - innerloop_pos;
3563
3564 if (innerloop_left > innerloop_step)
3565 {
3566 innerloop_left = innerloop_step;
3567
3568 fast_iteration = 1;
3569 }
3570
3571 device_param->innerloop_pos = innerloop_pos;
3572 device_param->innerloop_left = innerloop_left;
3573
3574 device_param->kernel_params_buf32[30] = innerloop_left;
3575
3576 // i think we can get rid of this
3577 if (innerloop_left == 0)
3578 {
3579 puts ("bug, how should this happen????\n");
3580
3581 continue;
3582 }
3583
3584 if (data.salts_shown[salt_pos] == 1)
3585 {
3586 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3587
3588 continue;
3589 }
3590
3591 // initialize amplifiers
3592
3593 if (data.attack_mode == ATTACK_MODE_COMBI)
3594 {
3595 uint i = 0;
3596
3597 while (i < innerloop_left)
3598 {
3599 if (feof (combs_fp)) break;
3600
3601 int line_len = fgetl (combs_fp, line_buf);
3602
3603 if (line_len >= PW_MAX1) continue;
3604
3605 line_len = convert_from_hex (line_buf, line_len);
3606
3607 char *line_buf_new = line_buf;
3608
3609 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3610 {
3611 char rule_buf_out[BLOCK_SIZE] = { 0 };
3612
3613 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3614
3615 if (rule_len_out < 0)
3616 {
3617 data.words_progress_rejected[salt_pos] += pws_cnt;
3618
3619 continue;
3620 }
3621
3622 line_len = rule_len_out;
3623
3624 line_buf_new = rule_buf_out;
3625 }
3626
3627 line_len = MIN (line_len, PW_DICTMAX);
3628
3629 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3630
3631 memcpy (ptr, line_buf_new, line_len);
3632
3633 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3634
3635 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3636 {
3637 uppercase (ptr, line_len);
3638 }
3639
3640 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3641 {
3642 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3643 {
3644 ptr[line_len] = 0x80;
3645 }
3646
3647 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3648 {
3649 ptr[line_len] = 0x01;
3650 }
3651 }
3652
3653 device_param->combs_buf[i].pw_len = line_len;
3654
3655 i++;
3656 }
3657
3658 for (uint j = i; j < innerloop_left; j++)
3659 {
3660 device_param->combs_buf[j].i[0] = 0;
3661 device_param->combs_buf[j].i[1] = 0;
3662 device_param->combs_buf[j].i[2] = 0;
3663 device_param->combs_buf[j].i[3] = 0;
3664 device_param->combs_buf[j].i[4] = 0;
3665 device_param->combs_buf[j].i[5] = 0;
3666 device_param->combs_buf[j].i[6] = 0;
3667 device_param->combs_buf[j].i[7] = 0;
3668
3669 device_param->combs_buf[j].pw_len = 0;
3670 }
3671
3672 innerloop_left = i;
3673 }
3674 else if (data.attack_mode == ATTACK_MODE_BF)
3675 {
3676 u64 off = innerloop_pos;
3677
3678 device_param->kernel_params_mp_r_buf64[3] = off;
3679
3680 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3681 }
3682 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3683 {
3684 u64 off = innerloop_pos;
3685
3686 device_param->kernel_params_mp_buf64[3] = off;
3687
3688 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3689 }
3690 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3691 {
3692 u64 off = innerloop_pos;
3693
3694 device_param->kernel_params_mp_buf64[3] = off;
3695
3696 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3697 }
3698
3699 // copy amplifiers
3700
3701 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3702 {
3703 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);
3704 }
3705 else if (data.attack_mode == ATTACK_MODE_COMBI)
3706 {
3707 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);
3708 }
3709 else if (data.attack_mode == ATTACK_MODE_BF)
3710 {
3711 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);
3712 }
3713 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3714 {
3715 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);
3716 }
3717 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3718 {
3719 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);
3720 }
3721
3722 if (data.benchmark == 1)
3723 {
3724 hc_timer_set (&device_param->timer_speed);
3725 }
3726
3727 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
3728
3729 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3730
3731 if (data.devices_status == STATUS_CRACKED) break;
3732 if (data.devices_status == STATUS_ABORTED) break;
3733 if (data.devices_status == STATUS_QUIT) break;
3734 if (data.devices_status == STATUS_BYPASS) break;
3735
3736 /**
3737 * result
3738 */
3739
3740 if (data.benchmark == 0)
3741 {
3742 check_cracked (device_param, salt_pos);
3743 }
3744
3745 /**
3746 * progress
3747 */
3748
3749 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3750
3751 hc_thread_mutex_lock (mux_counter);
3752
3753 data.words_progress_done[salt_pos] += perf_sum_all;
3754
3755 hc_thread_mutex_unlock (mux_counter);
3756
3757 /**
3758 * speed
3759 */
3760
3761 double speed_ms;
3762
3763 hc_timer_get (device_param->timer_speed, speed_ms);
3764
3765 hc_timer_set (&device_param->timer_speed);
3766
3767 // current speed
3768
3769 //hc_thread_mutex_lock (mux_display);
3770
3771 device_param->speed_cnt[speed_pos] = perf_sum_all;
3772
3773 device_param->speed_ms[speed_pos] = speed_ms;
3774
3775 //hc_thread_mutex_unlock (mux_display);
3776
3777 speed_pos++;
3778
3779 if (speed_pos == SPEED_CACHE)
3780 {
3781 speed_pos = 0;
3782 }
3783
3784 /**
3785 * benchmark
3786 */
3787
3788 if (data.benchmark == 1) break;
3789 }
3790 }
3791
3792 device_param->speed_pos = speed_pos;
3793
3794 myfree (line_buf);
3795 }
3796
3797 static void load_segment (wl_data_t *wl_data, FILE *fd)
3798 {
3799 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3800
3801 wl_data->pos = 0;
3802
3803 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3804
3805 wl_data->buf[wl_data->cnt] = 0;
3806
3807 if (wl_data->cnt == 0) return;
3808
3809 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3810
3811 while (!feof (fd))
3812 {
3813 if (wl_data->cnt == wl_data->avail)
3814 {
3815 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3816
3817 wl_data->avail += wl_data->incr;
3818 }
3819
3820 const int c = fgetc (fd);
3821
3822 if (c == EOF) break;
3823
3824 wl_data->buf[wl_data->cnt] = (char) c;
3825
3826 wl_data->cnt++;
3827
3828 if (c == '\n') break;
3829 }
3830
3831 // ensure stream ends with a newline
3832
3833 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3834 {
3835 wl_data->cnt++;
3836
3837 wl_data->buf[wl_data->cnt - 1] = '\n';
3838 }
3839
3840 return;
3841 }
3842
3843 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3844 {
3845 char *ptr = buf;
3846
3847 for (u32 i = 0; i < sz; i++, ptr++)
3848 {
3849 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3850
3851 if (i == 7)
3852 {
3853 *off = i;
3854 *len = i;
3855
3856 return;
3857 }
3858
3859 if (*ptr != '\n') continue;
3860
3861 *off = i + 1;
3862
3863 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3864
3865 *len = i;
3866
3867 return;
3868 }
3869
3870 *off = sz;
3871 *len = sz;
3872 }
3873
3874 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3875 {
3876 char *ptr = buf;
3877
3878 for (u32 i = 0; i < sz; i++, ptr++)
3879 {
3880 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3881
3882 if (*ptr != '\n') continue;
3883
3884 *off = i + 1;
3885
3886 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3887
3888 *len = i;
3889
3890 return;
3891 }
3892
3893 *off = sz;
3894 *len = sz;
3895 }
3896
3897 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3898 {
3899 char *ptr = buf;
3900
3901 for (u32 i = 0; i < sz; i++, ptr++)
3902 {
3903 if (*ptr != '\n') continue;
3904
3905 *off = i + 1;
3906
3907 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3908
3909 *len = i;
3910
3911 return;
3912 }
3913
3914 *off = sz;
3915 *len = sz;
3916 }
3917
3918 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3919 {
3920 while (wl_data->pos < wl_data->cnt)
3921 {
3922 uint off;
3923 uint len;
3924
3925 char *ptr = wl_data->buf + wl_data->pos;
3926
3927 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3928
3929 wl_data->pos += off;
3930
3931 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3932 {
3933 char rule_buf_out[BLOCK_SIZE] = { 0 };
3934
3935 int rule_len_out = -1;
3936
3937 if (len < BLOCK_SIZE)
3938 {
3939 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3940 }
3941
3942 if (rule_len_out < 0)
3943 {
3944 continue;
3945 }
3946
3947 if (rule_len_out > PW_MAX)
3948 {
3949 continue;
3950 }
3951 }
3952 else
3953 {
3954 if (len > PW_MAX)
3955 {
3956 continue;
3957 }
3958 }
3959
3960 *out_buf = ptr;
3961 *out_len = len;
3962
3963 return;
3964 }
3965
3966 if (feof (fd))
3967 {
3968 fprintf (stderr, "BUG feof()!!\n");
3969
3970 return;
3971 }
3972
3973 load_segment (wl_data, fd);
3974
3975 get_next_word (wl_data, fd, out_buf, out_len);
3976 }
3977
3978 #ifdef _POSIX
3979 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3980 #endif
3981
3982 #ifdef _WIN
3983 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3984 #endif
3985 {
3986 hc_signal (NULL);
3987
3988 dictstat_t d;
3989
3990 d.cnt = 0;
3991
3992 #ifdef _POSIX
3993 fstat (fileno (fd), &d.stat);
3994 #endif
3995
3996 #ifdef _WIN
3997 _fstat64 (fileno (fd), &d.stat);
3998 #endif
3999
4000 d.stat.st_mode = 0;
4001 d.stat.st_nlink = 0;
4002 d.stat.st_uid = 0;
4003 d.stat.st_gid = 0;
4004 d.stat.st_rdev = 0;
4005 d.stat.st_atime = 0;
4006
4007 #ifdef _POSIX
4008 d.stat.st_blksize = 0;
4009 d.stat.st_blocks = 0;
4010 #endif
4011
4012 if (d.stat.st_size == 0) return 0;
4013
4014 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4015
4016 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
4017 {
4018 if (d_cache)
4019 {
4020 u64 cnt = d_cache->cnt;
4021
4022 u64 keyspace = cnt;
4023
4024 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4025 {
4026 keyspace *= data.kernel_rules_cnt;
4027 }
4028 else if (data.attack_kern == ATTACK_KERN_COMBI)
4029 {
4030 keyspace *= data.combs_cnt;
4031 }
4032
4033 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);
4034 if (data.quiet == 0) log_info ("");
4035
4036 hc_signal (sigHandler_default);
4037
4038 return (keyspace);
4039 }
4040 }
4041
4042 time_t now = 0;
4043 time_t prev = 0;
4044
4045 u64 comp = 0;
4046 u64 cnt = 0;
4047 u64 cnt2 = 0;
4048
4049 while (!feof (fd))
4050 {
4051 load_segment (wl_data, fd);
4052
4053 comp += wl_data->cnt;
4054
4055 u32 i = 0;
4056
4057 while (i < wl_data->cnt)
4058 {
4059 u32 len;
4060 u32 off;
4061
4062 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
4063
4064 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4065 {
4066 char rule_buf_out[BLOCK_SIZE] = { 0 };
4067
4068 int rule_len_out = -1;
4069
4070 if (len < BLOCK_SIZE)
4071 {
4072 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
4073 }
4074
4075 if (rule_len_out < 0)
4076 {
4077 len = PW_MAX1;
4078 }
4079 else
4080 {
4081 len = rule_len_out;
4082 }
4083 }
4084
4085 if (len < PW_MAX1)
4086 {
4087 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4088 {
4089 cnt += data.kernel_rules_cnt;
4090 }
4091 else if (data.attack_kern == ATTACK_KERN_COMBI)
4092 {
4093 cnt += data.combs_cnt;
4094 }
4095
4096 d.cnt++;
4097 }
4098
4099 i += off;
4100
4101 cnt2++;
4102 }
4103
4104 time (&now);
4105
4106 if ((now - prev) == 0) continue;
4107
4108 float percent = (float) comp / (float) d.stat.st_size;
4109
4110 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);
4111
4112 time (&prev);
4113 }
4114
4115 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);
4116 if (data.quiet == 0) log_info ("");
4117
4118 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4119
4120 hc_signal (sigHandler_default);
4121
4122 return (cnt);
4123 }
4124
4125 static void *thread_monitor (void *p)
4126 {
4127 uint runtime_check = 0;
4128 uint remove_check = 0;
4129 uint status_check = 0;
4130 uint restore_check = 0;
4131
4132 uint restore_left = data.restore_timer;
4133 uint remove_left = data.remove_timer;
4134 uint status_left = data.status_timer;
4135
4136 #ifdef HAVE_HWMON
4137 uint hwmon_check = 0;
4138
4139 int slowdown_warnings = 0;
4140
4141 // these variables are mainly used for fan control
4142
4143 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4144
4145 // temperature controller "loopback" values
4146
4147 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4148 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4149
4150 int temp_threshold = 1; // degrees celcius
4151
4152 int fan_speed_min = 15; // in percentage
4153 int fan_speed_max = 100;
4154
4155 time_t last_temp_check_time;
4156 #endif // HAVE_HWMON
4157
4158 uint sleep_time = 1;
4159
4160 if (data.runtime)
4161 {
4162 runtime_check = 1;
4163 }
4164
4165 if (data.restore_timer)
4166 {
4167 restore_check = 1;
4168 }
4169
4170 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4171 {
4172 remove_check = 1;
4173 }
4174
4175 if (data.status == 1)
4176 {
4177 status_check = 1;
4178 }
4179
4180 #ifdef HAVE_HWMON
4181 if (data.gpu_temp_disable == 0)
4182 {
4183 time (&last_temp_check_time);
4184
4185 hwmon_check = 1;
4186 }
4187 #endif
4188
4189 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4190 {
4191 #ifdef HAVE_HWMON
4192 if (hwmon_check == 0)
4193 #endif
4194 return (p);
4195 }
4196
4197 while (data.shutdown_inner == 0)
4198 {
4199 hc_sleep (sleep_time);
4200
4201 if (data.devices_status != STATUS_RUNNING) continue;
4202
4203 #ifdef HAVE_HWMON
4204
4205 if (hwmon_check == 1)
4206 {
4207 hc_thread_mutex_lock (mux_adl);
4208
4209 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4210 {
4211 hc_device_param_t *device_param = &data.devices_param[device_id];
4212
4213 if (device_param->skipped) continue;
4214
4215 if (device_param->device_vendor_id == VENDOR_ID_NV)
4216 {
4217 if (data.hm_nvapi)
4218 {
4219 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info;
4220 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status;
4221
4222 memset (&perfPolicies_info, 0, sizeof (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1));
4223 memset (&perfPolicies_status, 0, sizeof (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1));
4224
4225 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4226 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4227
4228 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4229
4230 perfPolicies_status.info_value = perfPolicies_info.info_value;
4231
4232 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4233
4234 if (perfPolicies_status.throttle & 2)
4235 {
4236 if (slowdown_warnings < 3)
4237 {
4238 if (data.quiet == 0) clear_prompt ();
4239
4240 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4241
4242 if (slowdown_warnings == 2)
4243 {
4244 log_info ("");
4245 }
4246
4247 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4248 if (data.quiet == 0) fflush (stdout);
4249
4250 slowdown_warnings++;
4251 }
4252 }
4253 else
4254 {
4255 slowdown_warnings = 0;
4256 }
4257 }
4258 }
4259 }
4260
4261 hc_thread_mutex_unlock (mux_adl);
4262 }
4263
4264 if (hwmon_check == 1)
4265 {
4266 hc_thread_mutex_lock (mux_adl);
4267
4268 time_t temp_check_time;
4269
4270 time (&temp_check_time);
4271
4272 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4273
4274 if (Ta == 0) Ta = 1;
4275
4276 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4277 {
4278 hc_device_param_t *device_param = &data.devices_param[device_id];
4279
4280 if (device_param->skipped) continue;
4281
4282 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4283
4284 const int temperature = hm_get_temperature_with_device_id (device_id);
4285
4286 if (temperature > (int) data.gpu_temp_abort)
4287 {
4288 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4289
4290 if (data.devices_status != STATUS_QUIT) myabort ();
4291
4292 break;
4293 }
4294
4295 const int gpu_temp_retain = data.gpu_temp_retain;
4296
4297 if (gpu_temp_retain)
4298 {
4299 if (data.hm_device[device_id].fan_set_supported == 1)
4300 {
4301 int temp_cur = temperature;
4302
4303 int temp_diff_new = gpu_temp_retain - temp_cur;
4304
4305 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4306
4307 // calculate Ta value (time difference in seconds between the last check and this check)
4308
4309 last_temp_check_time = temp_check_time;
4310
4311 float Kp = 1.8;
4312 float Ki = 0.005;
4313 float Kd = 6;
4314
4315 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4316
4317 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);
4318
4319 if (abs (fan_diff_required) >= temp_threshold)
4320 {
4321 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4322
4323 int fan_speed_level = fan_speed_cur;
4324
4325 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4326
4327 int fan_speed_new = fan_speed_level - fan_diff_required;
4328
4329 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4330 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4331
4332 if (fan_speed_new != fan_speed_cur)
4333 {
4334 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4335 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4336
4337 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4338 {
4339 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4340 {
4341 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4342 }
4343 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4344 {
4345 #ifdef WIN
4346 hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1);
4347 #endif
4348
4349 #ifdef LINUX
4350 hm_set_fanspeed_with_device_id_xnvctrl (device_id, fan_speed_new);
4351 #endif
4352 }
4353
4354 fan_speed_chgd[device_id] = 1;
4355 }
4356
4357 temp_diff_old[device_id] = temp_diff_new;
4358 }
4359 }
4360 }
4361 }
4362 }
4363
4364 hc_thread_mutex_unlock (mux_adl);
4365 }
4366 #endif // HAVE_HWMON
4367
4368 if (restore_check == 1)
4369 {
4370 restore_left--;
4371
4372 if (restore_left == 0)
4373 {
4374 if (data.restore_disable == 0) cycle_restore ();
4375
4376 restore_left = data.restore_timer;
4377 }
4378 }
4379
4380 if ((runtime_check == 1) && (data.runtime_start > 0))
4381 {
4382 time_t runtime_cur;
4383
4384 time (&runtime_cur);
4385
4386 int runtime_left = data.proc_start + data.runtime - runtime_cur;
4387
4388 if (runtime_left <= 0)
4389 {
4390 if (data.benchmark == 0)
4391 {
4392 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4393 }
4394
4395 if (data.devices_status != STATUS_QUIT) myabort ();
4396 }
4397 }
4398
4399 if (remove_check == 1)
4400 {
4401 remove_left--;
4402
4403 if (remove_left == 0)
4404 {
4405 if (data.digests_saved != data.digests_done)
4406 {
4407 data.digests_saved = data.digests_done;
4408
4409 save_hash ();
4410 }
4411
4412 remove_left = data.remove_timer;
4413 }
4414 }
4415
4416 if (status_check == 1)
4417 {
4418 status_left--;
4419
4420 if (status_left == 0)
4421 {
4422 hc_thread_mutex_lock (mux_display);
4423
4424 if (data.quiet == 0) clear_prompt ();
4425
4426 if (data.quiet == 0) log_info ("");
4427
4428 status_display ();
4429
4430 if (data.quiet == 0) log_info ("");
4431
4432 hc_thread_mutex_unlock (mux_display);
4433
4434 status_left = data.status_timer;
4435 }
4436 }
4437 }
4438
4439 #ifdef HAVE_HWMON
4440 myfree (fan_speed_chgd);
4441
4442 myfree (temp_diff_old);
4443 myfree (temp_diff_sum);
4444 #endif
4445
4446 p = NULL;
4447
4448 return (p);
4449 }
4450
4451 static void *thread_outfile_remove (void *p)
4452 {
4453 // some hash-dependent constants
4454 char *outfile_dir = data.outfile_check_directory;
4455 uint dgst_size = data.dgst_size;
4456 uint isSalted = data.isSalted;
4457 uint esalt_size = data.esalt_size;
4458 uint hash_mode = data.hash_mode;
4459
4460 uint outfile_check_timer = data.outfile_check_timer;
4461
4462 char separator = data.separator;
4463
4464 // some hash-dependent functions
4465 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4466 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4467
4468 // buffers
4469 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4470
4471 hash_buf.digest = mymalloc (dgst_size);
4472
4473 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4474
4475 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4476
4477 uint digest_buf[64] = { 0 };
4478
4479 outfile_data_t *out_info = NULL;
4480
4481 char **out_files = NULL;
4482
4483 time_t folder_mtime = 0;
4484
4485 int out_cnt = 0;
4486
4487 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4488
4489 while (data.shutdown_inner == 0)
4490 {
4491 hc_sleep (1);
4492
4493 if (data.devices_status != STATUS_RUNNING) continue;
4494
4495 check_left--;
4496
4497 if (check_left == 0)
4498 {
4499 struct stat outfile_check_stat;
4500
4501 if (stat (outfile_dir, &outfile_check_stat) == 0)
4502 {
4503 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4504
4505 if (is_dir == 1)
4506 {
4507 if (outfile_check_stat.st_mtime > folder_mtime)
4508 {
4509 char **out_files_new = scan_directory (outfile_dir);
4510
4511 int out_cnt_new = count_dictionaries (out_files_new);
4512
4513 outfile_data_t *out_info_new = NULL;
4514
4515 if (out_cnt_new > 0)
4516 {
4517 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4518
4519 for (int i = 0; i < out_cnt_new; i++)
4520 {
4521 out_info_new[i].file_name = out_files_new[i];
4522
4523 // check if there are files that we have seen/checked before (and not changed)
4524
4525 for (int j = 0; j < out_cnt; j++)
4526 {
4527 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4528 {
4529 struct stat outfile_stat;
4530
4531 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4532 {
4533 if (outfile_stat.st_ctime == out_info[j].ctime)
4534 {
4535 out_info_new[i].ctime = out_info[j].ctime;
4536 out_info_new[i].seek = out_info[j].seek;
4537 }
4538 }
4539 }
4540 }
4541 }
4542 }
4543
4544 local_free (out_info);
4545 local_free (out_files);
4546
4547 out_files = out_files_new;
4548 out_cnt = out_cnt_new;
4549 out_info = out_info_new;
4550
4551 folder_mtime = outfile_check_stat.st_mtime;
4552 }
4553
4554 for (int j = 0; j < out_cnt; j++)
4555 {
4556 FILE *fp = fopen (out_info[j].file_name, "rb");
4557
4558 if (fp != NULL)
4559 {
4560 //hc_thread_mutex_lock (mux_display);
4561
4562 #ifdef _POSIX
4563 struct stat outfile_stat;
4564
4565 fstat (fileno (fp), &outfile_stat);
4566 #endif
4567
4568 #ifdef _WIN
4569 struct stat64 outfile_stat;
4570
4571 _fstat64 (fileno (fp), &outfile_stat);
4572 #endif
4573
4574 if (outfile_stat.st_ctime > out_info[j].ctime)
4575 {
4576 out_info[j].ctime = outfile_stat.st_ctime;
4577 out_info[j].seek = 0;
4578 }
4579
4580 fseek (fp, out_info[j].seek, SEEK_SET);
4581
4582 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4583
4584 while (!feof (fp))
4585 {
4586 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4587
4588 if (ptr == NULL) break;
4589
4590 int line_len = strlen (line_buf);
4591
4592 if (line_len <= 0) continue;
4593
4594 int iter = MAX_CUT_TRIES;
4595
4596 for (uint i = line_len - 1; i && iter; i--, line_len--)
4597 {
4598 if (line_buf[i] != separator) continue;
4599
4600 int parser_status = PARSER_OK;
4601
4602 if ((hash_mode != 2500) && (hash_mode != 6800))
4603 {
4604 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4605 }
4606
4607 uint found = 0;
4608
4609 if (parser_status == PARSER_OK)
4610 {
4611 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4612 {
4613 if (data.salts_shown[salt_pos] == 1) continue;
4614
4615 salt_t *salt_buf = &data.salts_buf[salt_pos];
4616
4617 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4618 {
4619 uint idx = salt_buf->digests_offset + digest_pos;
4620
4621 if (data.digests_shown[idx] == 1) continue;
4622
4623 uint cracked = 0;
4624
4625 if (hash_mode == 6800)
4626 {
4627 if (i == salt_buf->salt_len)
4628 {
4629 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4630 }
4631 }
4632 else if (hash_mode == 2500)
4633 {
4634 // BSSID : MAC1 : MAC2 (:plain)
4635 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4636 {
4637 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4638
4639 if (!cracked) continue;
4640
4641 // now compare MAC1 and MAC2 too, since we have this additional info
4642 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4643 char *mac2_pos = mac1_pos + 12 + 1;
4644
4645 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4646 wpa_t *wpa = &wpas[salt_pos];
4647
4648 // compare hex string(s) vs binary MAC address(es)
4649
4650 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4651 {
4652 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4653 {
4654 cracked = 0;
4655
4656 break;
4657 }
4658 }
4659
4660 // early skip ;)
4661 if (!cracked) continue;
4662
4663 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4664 {
4665 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4666 {
4667 cracked = 0;
4668
4669 break;
4670 }
4671 }
4672 }
4673 }
4674 else
4675 {
4676 char *digests_buf_ptr = (char *) data.digests_buf;
4677
4678 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4679
4680 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4681 }
4682
4683 if (cracked == 1)
4684 {
4685 found = 1;
4686
4687 data.digests_shown[idx] = 1;
4688
4689 data.digests_done++;
4690
4691 salt_buf->digests_done++;
4692
4693 if (salt_buf->digests_done == salt_buf->digests_cnt)
4694 {
4695 data.salts_shown[salt_pos] = 1;
4696
4697 data.salts_done++;
4698
4699 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4700 }
4701 }
4702 }
4703
4704 if (data.devices_status == STATUS_CRACKED) break;
4705 }
4706 }
4707
4708 if (found) break;
4709
4710 if (data.devices_status == STATUS_CRACKED) break;
4711
4712 iter--;
4713 }
4714
4715 if (data.devices_status == STATUS_CRACKED) break;
4716 }
4717
4718 myfree (line_buf);
4719
4720 out_info[j].seek = ftell (fp);
4721
4722 //hc_thread_mutex_unlock (mux_display);
4723
4724 fclose (fp);
4725 }
4726 }
4727 }
4728 }
4729
4730 check_left = outfile_check_timer;
4731 }
4732 }
4733
4734 if (esalt_size) local_free (hash_buf.esalt);
4735
4736 if (isSalted) local_free (hash_buf.salt);
4737
4738 local_free (hash_buf.digest);
4739
4740 local_free (out_info);
4741
4742 local_free (out_files);
4743
4744 p = NULL;
4745
4746 return (p);
4747 }
4748
4749 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4750 {
4751 //if (device_param->pws_cnt < device_param->kernel_power)
4752 //{
4753 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4754
4755 u8 *ptr = (u8 *) pw->i;
4756
4757 memcpy (ptr, pw_buf, pw_len);
4758
4759 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4760
4761 pw->pw_len = pw_len;
4762
4763 device_param->pws_cnt++;
4764 //}
4765 //else
4766 //{
4767 // fprintf (stderr, "BUG pw_add()!!\n");
4768 //
4769 // return;
4770 //}
4771 }
4772
4773 static void set_kernel_power_final (const u64 kernel_power_final)
4774 {
4775 if (data.quiet == 0)
4776 {
4777 clear_prompt ();
4778
4779 //log_info ("");
4780
4781 log_info ("INFO: approaching final keyspace, workload adjusted");
4782 log_info ("");
4783
4784 fprintf (stdout, "%s", PROMPT);
4785
4786 fflush (stdout);
4787 }
4788
4789 data.kernel_power_final = kernel_power_final;
4790 }
4791
4792 static u32 get_power (hc_device_param_t *device_param)
4793 {
4794 const u64 kernel_power_final = data.kernel_power_final;
4795
4796 if (kernel_power_final)
4797 {
4798 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4799
4800 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4801
4802 // work should be at least the hardware power available without any accelerator
4803
4804 const u64 work = MAX (words_left_device, device_param->hardware_power);
4805
4806 return work;
4807 }
4808
4809 return device_param->kernel_power;
4810 }
4811
4812 static uint get_work (hc_device_param_t *device_param, const u64 max)
4813 {
4814 hc_thread_mutex_lock (mux_dispatcher);
4815
4816 const u64 words_cur = data.words_cur;
4817 const u64 words_base = (data.limit == 0) ? data.words_base : MIN (data.limit, data.words_base);
4818
4819 device_param->words_off = words_cur;
4820
4821 const u64 kernel_power_all = data.kernel_power_all;
4822
4823 const u64 words_left = words_base - words_cur;
4824
4825 if (words_left < kernel_power_all)
4826 {
4827 if (data.kernel_power_final == 0)
4828 {
4829 set_kernel_power_final (words_left);
4830 }
4831 }
4832
4833 const u32 kernel_power = get_power (device_param);
4834
4835 uint work = MIN (words_left, kernel_power);
4836
4837 work = MIN (work, max);
4838
4839 data.words_cur += work;
4840
4841 hc_thread_mutex_unlock (mux_dispatcher);
4842
4843 return work;
4844 }
4845
4846 static void *thread_autotune (void *p)
4847 {
4848 hc_device_param_t *device_param = (hc_device_param_t *) p;
4849
4850 if (device_param->skipped) return NULL;
4851
4852 autotune (device_param);
4853
4854 return NULL;
4855 }
4856
4857 static void *thread_calc_stdin (void *p)
4858 {
4859 hc_device_param_t *device_param = (hc_device_param_t *) p;
4860
4861 if (device_param->skipped) return NULL;
4862
4863 char *buf = (char *) mymalloc (HCBUFSIZ);
4864
4865 const uint attack_kern = data.attack_kern;
4866
4867 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4868 {
4869 hc_thread_mutex_lock (mux_dispatcher);
4870
4871 if (feof (stdin) != 0)
4872 {
4873 hc_thread_mutex_unlock (mux_dispatcher);
4874
4875 break;
4876 }
4877
4878 uint words_cur = 0;
4879
4880 while (words_cur < device_param->kernel_power)
4881 {
4882 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4883
4884 if (line_buf == NULL) break;
4885
4886 uint line_len = in_superchop (line_buf);
4887
4888 line_len = convert_from_hex (line_buf, line_len);
4889
4890 // post-process rule engine
4891
4892 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4893 {
4894 char rule_buf_out[BLOCK_SIZE] = { 0 };
4895
4896 int rule_len_out = -1;
4897
4898 if (line_len < BLOCK_SIZE)
4899 {
4900 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4901 }
4902
4903 if (rule_len_out < 0) continue;
4904
4905 line_buf = rule_buf_out;
4906 line_len = rule_len_out;
4907 }
4908
4909 if (line_len > PW_MAX)
4910 {
4911 continue;
4912 }
4913
4914 // hmm that's always the case, or?
4915
4916 if (attack_kern == ATTACK_KERN_STRAIGHT)
4917 {
4918 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4919 {
4920 hc_thread_mutex_lock (mux_counter);
4921
4922 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4923 {
4924 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4925 }
4926
4927 hc_thread_mutex_unlock (mux_counter);
4928
4929 continue;
4930 }
4931 }
4932
4933 pw_add (device_param, (u8 *) line_buf, line_len);
4934
4935 words_cur++;
4936
4937 if (data.devices_status == STATUS_CRACKED) break;
4938 if (data.devices_status == STATUS_ABORTED) break;
4939 if (data.devices_status == STATUS_QUIT) break;
4940 if (data.devices_status == STATUS_BYPASS) break;
4941 }
4942
4943 hc_thread_mutex_unlock (mux_dispatcher);
4944
4945 if (data.devices_status == STATUS_CRACKED) break;
4946 if (data.devices_status == STATUS_ABORTED) break;
4947 if (data.devices_status == STATUS_QUIT) break;
4948 if (data.devices_status == STATUS_BYPASS) break;
4949
4950 // flush
4951
4952 const uint pws_cnt = device_param->pws_cnt;
4953
4954 if (pws_cnt)
4955 {
4956 run_copy (device_param, pws_cnt);
4957
4958 run_cracker (device_param, pws_cnt);
4959
4960 device_param->pws_cnt = 0;
4961
4962 /*
4963 still required?
4964 if (attack_kern == ATTACK_KERN_STRAIGHT)
4965 {
4966 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4967 }
4968 else if (attack_kern == ATTACK_KERN_COMBI)
4969 {
4970 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4971 }
4972 */
4973 }
4974 }
4975
4976 device_param->kernel_accel = 0;
4977 device_param->kernel_loops = 0;
4978
4979 myfree (buf);
4980
4981 return NULL;
4982 }
4983
4984 static void *thread_calc (void *p)
4985 {
4986 hc_device_param_t *device_param = (hc_device_param_t *) p;
4987
4988 if (device_param->skipped) return NULL;
4989
4990 const uint attack_mode = data.attack_mode;
4991 const uint attack_kern = data.attack_kern;
4992
4993 if (attack_mode == ATTACK_MODE_BF)
4994 {
4995 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4996 {
4997 const uint work = get_work (device_param, -1);
4998
4999 if (work == 0) break;
5000
5001 const u64 words_off = device_param->words_off;
5002 const u64 words_fin = words_off + work;
5003
5004 const uint pws_cnt = work;
5005
5006 device_param->pws_cnt = pws_cnt;
5007
5008 if (pws_cnt)
5009 {
5010 run_copy (device_param, pws_cnt);
5011
5012 run_cracker (device_param, pws_cnt);
5013
5014 device_param->pws_cnt = 0;
5015
5016 /*
5017 still required?
5018 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
5019 */
5020 }
5021
5022 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5023
5024 if (data.devices_status == STATUS_CRACKED) break;
5025 if (data.devices_status == STATUS_ABORTED) break;
5026 if (data.devices_status == STATUS_QUIT) break;
5027 if (data.devices_status == STATUS_BYPASS) break;
5028
5029 if (data.benchmark == 1) break;
5030
5031 device_param->words_done = words_fin;
5032 }
5033 }
5034 else
5035 {
5036 const uint segment_size = data.segment_size;
5037
5038 char *dictfile = data.dictfile;
5039
5040 if (attack_mode == ATTACK_MODE_COMBI)
5041 {
5042 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5043 {
5044 dictfile = data.dictfile2;
5045 }
5046 }
5047
5048 FILE *fd = fopen (dictfile, "rb");
5049
5050 if (fd == NULL)
5051 {
5052 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
5053
5054 return NULL;
5055 }
5056
5057 if (attack_mode == ATTACK_MODE_COMBI)
5058 {
5059 const uint combs_mode = data.combs_mode;
5060
5061 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
5062 {
5063 const char *dictfilec = data.dictfile2;
5064
5065 FILE *combs_fp = fopen (dictfilec, "rb");
5066
5067 if (combs_fp == NULL)
5068 {
5069 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5070
5071 fclose (fd);
5072
5073 return NULL;
5074 }
5075
5076 device_param->combs_fp = combs_fp;
5077 }
5078 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5079 {
5080 const char *dictfilec = data.dictfile;
5081
5082 FILE *combs_fp = fopen (dictfilec, "rb");
5083
5084 if (combs_fp == NULL)
5085 {
5086 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5087
5088 fclose (fd);
5089
5090 return NULL;
5091 }
5092
5093 device_param->combs_fp = combs_fp;
5094 }
5095 }
5096
5097 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
5098
5099 wl_data->buf = (char *) mymalloc (segment_size);
5100 wl_data->avail = segment_size;
5101 wl_data->incr = segment_size;
5102 wl_data->cnt = 0;
5103 wl_data->pos = 0;
5104
5105 u64 words_cur = 0;
5106
5107 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5108 {
5109 u64 words_off = 0;
5110 u64 words_fin = 0;
5111
5112 u64 max = -1;
5113
5114 while (max)
5115 {
5116 const uint work = get_work (device_param, max);
5117
5118 if (work == 0) break;
5119
5120 max = 0;
5121
5122 words_off = device_param->words_off;
5123 words_fin = words_off + work;
5124
5125 char *line_buf;
5126 uint line_len;
5127
5128 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5129
5130 for ( ; words_cur < words_fin; words_cur++)
5131 {
5132 get_next_word (wl_data, fd, &line_buf, &line_len);
5133
5134 line_len = convert_from_hex (line_buf, line_len);
5135
5136 // post-process rule engine
5137
5138 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5139 {
5140 char rule_buf_out[BLOCK_SIZE] = { 0 };
5141
5142 int rule_len_out = -1;
5143
5144 if (line_len < BLOCK_SIZE)
5145 {
5146 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5147 }
5148
5149 if (rule_len_out < 0) continue;
5150
5151 line_buf = rule_buf_out;
5152 line_len = rule_len_out;
5153 }
5154
5155 if (attack_kern == ATTACK_KERN_STRAIGHT)
5156 {
5157 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5158 {
5159 max++;
5160
5161 hc_thread_mutex_lock (mux_counter);
5162
5163 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5164 {
5165 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5166 }
5167
5168 hc_thread_mutex_unlock (mux_counter);
5169
5170 continue;
5171 }
5172 }
5173 else if (attack_kern == ATTACK_KERN_COMBI)
5174 {
5175 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5176 // since we still need to combine the plains
5177
5178 if (line_len > data.pw_max)
5179 {
5180 max++;
5181
5182 hc_thread_mutex_lock (mux_counter);
5183
5184 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5185 {
5186 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5187 }
5188
5189 hc_thread_mutex_unlock (mux_counter);
5190
5191 continue;
5192 }
5193 }
5194
5195 pw_add (device_param, (u8 *) line_buf, line_len);
5196
5197 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5198
5199 if (data.devices_status == STATUS_CRACKED) break;
5200 if (data.devices_status == STATUS_ABORTED) break;
5201 if (data.devices_status == STATUS_QUIT) break;
5202 if (data.devices_status == STATUS_BYPASS) break;
5203 }
5204
5205 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5206
5207 if (data.devices_status == STATUS_CRACKED) break;
5208 if (data.devices_status == STATUS_ABORTED) break;
5209 if (data.devices_status == STATUS_QUIT) break;
5210 if (data.devices_status == STATUS_BYPASS) break;
5211 }
5212
5213 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5214
5215 if (data.devices_status == STATUS_CRACKED) break;
5216 if (data.devices_status == STATUS_ABORTED) break;
5217 if (data.devices_status == STATUS_QUIT) break;
5218 if (data.devices_status == STATUS_BYPASS) break;
5219
5220 //
5221 // flush
5222 //
5223
5224 const uint pws_cnt = device_param->pws_cnt;
5225
5226 if (pws_cnt)
5227 {
5228 run_copy (device_param, pws_cnt);
5229
5230 run_cracker (device_param, pws_cnt);
5231
5232 device_param->pws_cnt = 0;
5233
5234 /*
5235 still required?
5236 if (attack_kern == ATTACK_KERN_STRAIGHT)
5237 {
5238 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5239 }
5240 else if (attack_kern == ATTACK_KERN_COMBI)
5241 {
5242 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5243 }
5244 */
5245 }
5246
5247 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5248
5249 if (data.devices_status == STATUS_CRACKED) break;
5250 if (data.devices_status == STATUS_ABORTED) break;
5251 if (data.devices_status == STATUS_QUIT) break;
5252 if (data.devices_status == STATUS_BYPASS) break;
5253
5254 if (words_fin == 0) break;
5255
5256 device_param->words_done = words_fin;
5257 }
5258
5259 if (attack_mode == ATTACK_MODE_COMBI)
5260 {
5261 fclose (device_param->combs_fp);
5262 }
5263
5264 free (wl_data->buf);
5265 free (wl_data);
5266
5267 fclose (fd);
5268 }
5269
5270 device_param->kernel_accel = 0;
5271 device_param->kernel_loops = 0;
5272
5273 return NULL;
5274 }
5275
5276 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5277 {
5278 if (!device_param)
5279 {
5280 log_error ("ERROR: %s : Invalid argument", __func__);
5281
5282 exit (-1);
5283 }
5284
5285 salt_t *salt_buf = &data.salts_buf[salt_pos];
5286
5287 device_param->kernel_params_buf32[27] = salt_pos;
5288 device_param->kernel_params_buf32[30] = 1;
5289 device_param->kernel_params_buf32[31] = salt_buf->digests_cnt;
5290 device_param->kernel_params_buf32[32] = salt_buf->digests_offset;
5291 device_param->kernel_params_buf32[33] = 0;
5292 device_param->kernel_params_buf32[34] = 1;
5293
5294 char *dictfile_old = data.dictfile;
5295
5296 const char *weak_hash_check = "weak-hash-check";
5297
5298 data.dictfile = (char *) weak_hash_check;
5299
5300 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5301
5302 data.kernel_rules_buf[0].cmds[0] = 0;
5303
5304 /**
5305 * run the kernel
5306 */
5307
5308 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5309 {
5310 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5311 }
5312 else
5313 {
5314 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5315
5316 uint loop_step = 16;
5317
5318 const uint iter = salt_buf->salt_iter;
5319
5320 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5321 {
5322 uint loop_left = iter - loop_pos;
5323
5324 loop_left = MIN (loop_left, loop_step);
5325
5326 device_param->kernel_params_buf32[28] = loop_pos;
5327 device_param->kernel_params_buf32[29] = loop_left;
5328
5329 run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5330 }
5331
5332 run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5333 }
5334
5335 /**
5336 * result
5337 */
5338
5339 check_cracked (device_param, salt_pos);
5340
5341 /**
5342 * cleanup
5343 */
5344
5345 device_param->kernel_params_buf32[27] = 0;
5346 device_param->kernel_params_buf32[28] = 0;
5347 device_param->kernel_params_buf32[29] = 0;
5348 device_param->kernel_params_buf32[30] = 0;
5349 device_param->kernel_params_buf32[31] = 0;
5350 device_param->kernel_params_buf32[32] = 0;
5351 device_param->kernel_params_buf32[33] = 0;
5352 device_param->kernel_params_buf32[34] = 0;
5353
5354 data.dictfile = dictfile_old;
5355
5356 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5357 }
5358
5359 // hlfmt hashcat
5360
5361 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5362 {
5363 if (data.username == 0)
5364 {
5365 *hashbuf_pos = line_buf;
5366 *hashbuf_len = line_len;
5367 }
5368 else
5369 {
5370 char *pos = line_buf;
5371 int len = line_len;
5372
5373 for (int i = 0; i < line_len; i++, pos++, len--)
5374 {
5375 if (line_buf[i] == data.separator)
5376 {
5377 pos++;
5378
5379 len--;
5380
5381 break;
5382 }
5383 }
5384
5385 *hashbuf_pos = pos;
5386 *hashbuf_len = len;
5387 }
5388 }
5389
5390 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5391 {
5392 char *pos = NULL;
5393 int len = 0;
5394
5395 int sep_cnt = 0;
5396
5397 for (int i = 0; i < line_len; i++)
5398 {
5399 if (line_buf[i] == data.separator)
5400 {
5401 sep_cnt++;
5402
5403 continue;
5404 }
5405
5406 if (sep_cnt == 0)
5407 {
5408 if (pos == NULL) pos = line_buf + i;
5409
5410 len++;
5411 }
5412 }
5413
5414 *userbuf_pos = pos;
5415 *userbuf_len = len;
5416 }
5417
5418 // hlfmt pwdump
5419
5420 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5421 {
5422 int sep_cnt = 0;
5423
5424 int sep2_len = 0;
5425 int sep3_len = 0;
5426
5427 for (int i = 0; i < line_len; i++)
5428 {
5429 if (line_buf[i] == ':')
5430 {
5431 sep_cnt++;
5432
5433 continue;
5434 }
5435
5436 if (sep_cnt == 2) sep2_len++;
5437 if (sep_cnt == 3) sep3_len++;
5438 }
5439
5440 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5441
5442 return 0;
5443 }
5444
5445 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_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 (data.hash_mode == 1000)
5462 {
5463 if (sep_cnt == 3)
5464 {
5465 if (pos == NULL) pos = line_buf + i;
5466
5467 len++;
5468 }
5469 }
5470 else if (data.hash_mode == 3000)
5471 {
5472 if (sep_cnt == 2)
5473 {
5474 if (pos == NULL) pos = line_buf + i;
5475
5476 len++;
5477 }
5478 }
5479 }
5480
5481 *hashbuf_pos = pos;
5482 *hashbuf_len = len;
5483 }
5484
5485 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5486 {
5487 char *pos = NULL;
5488 int len = 0;
5489
5490 int sep_cnt = 0;
5491
5492 for (int i = 0; i < line_len; i++)
5493 {
5494 if (line_buf[i] == ':')
5495 {
5496 sep_cnt++;
5497
5498 continue;
5499 }
5500
5501 if (sep_cnt == 0)
5502 {
5503 if (pos == NULL) pos = line_buf + i;
5504
5505 len++;
5506 }
5507 }
5508
5509 *userbuf_pos = pos;
5510 *userbuf_len = len;
5511 }
5512
5513 // hlfmt passwd
5514
5515 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5516 {
5517 int sep_cnt = 0;
5518
5519 char sep5_first = 0;
5520 char sep6_first = 0;
5521
5522 for (int i = 0; i < line_len; i++)
5523 {
5524 if (line_buf[i] == ':')
5525 {
5526 sep_cnt++;
5527
5528 continue;
5529 }
5530
5531 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5532 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5533 }
5534
5535 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5536
5537 return 0;
5538 }
5539
5540 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5541 {
5542 char *pos = NULL;
5543 int len = 0;
5544
5545 int sep_cnt = 0;
5546
5547 for (int i = 0; i < line_len; i++)
5548 {
5549 if (line_buf[i] == ':')
5550 {
5551 sep_cnt++;
5552
5553 continue;
5554 }
5555
5556 if (sep_cnt == 1)
5557 {
5558 if (pos == NULL) pos = line_buf + i;
5559
5560 len++;
5561 }
5562 }
5563
5564 *hashbuf_pos = pos;
5565 *hashbuf_len = len;
5566 }
5567
5568 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5569 {
5570 char *pos = NULL;
5571 int len = 0;
5572
5573 int sep_cnt = 0;
5574
5575 for (int i = 0; i < line_len; i++)
5576 {
5577 if (line_buf[i] == ':')
5578 {
5579 sep_cnt++;
5580
5581 continue;
5582 }
5583
5584 if (sep_cnt == 0)
5585 {
5586 if (pos == NULL) pos = line_buf + i;
5587
5588 len++;
5589 }
5590 }
5591
5592 *userbuf_pos = pos;
5593 *userbuf_len = len;
5594 }
5595
5596 // hlfmt shadow
5597
5598 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5599 {
5600 int sep_cnt = 0;
5601
5602 for (int i = 0; i < line_len; i++)
5603 {
5604 if (line_buf[i] == ':') sep_cnt++;
5605 }
5606
5607 if (sep_cnt == 8) return 1;
5608
5609 return 0;
5610 }
5611
5612 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5613 {
5614 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5615 }
5616
5617 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5618 {
5619 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5620 }
5621
5622 // hlfmt main
5623
5624 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5625 {
5626 switch (hashfile_format)
5627 {
5628 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5629 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5630 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5631 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5632 }
5633 }
5634
5635 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5636 {
5637 switch (hashfile_format)
5638 {
5639 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5640 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5641 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5642 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5643 }
5644 }
5645
5646 char *strhlfmt (const uint hashfile_format)
5647 {
5648 switch (hashfile_format)
5649 {
5650 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5651 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5652 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5653 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5654 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5655 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5656 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5657 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5658 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5659 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5660 }
5661
5662 return ((char *) "Unknown");
5663 }
5664
5665 static uint hlfmt_detect (FILE *fp, uint max_check)
5666 {
5667 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5668
5669 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5670 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5671
5672 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5673
5674 uint num_check = 0;
5675
5676 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5677
5678 while (!feof (fp))
5679 {
5680 int line_len = fgetl (fp, line_buf);
5681
5682 if (line_len == 0) continue;
5683
5684 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5685 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5686 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5687
5688 if (num_check == max_check) break;
5689
5690 num_check++;
5691 }
5692
5693 myfree (line_buf);
5694
5695 uint hashlist_format = HLFMT_HASHCAT;
5696
5697 for (int i = 1; i < HLFMTS_CNT; i++)
5698 {
5699 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5700
5701 hashlist_format = i;
5702 }
5703
5704 free (formats_cnt);
5705
5706 return hashlist_format;
5707 }
5708
5709 /**
5710 * some further helper function
5711 */
5712
5713 // wrapper around mymalloc for ADL
5714
5715 #if defined(HAVE_HWMON)
5716 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5717 {
5718 return mymalloc (iSize);
5719 }
5720 #endif
5721
5722 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)
5723 {
5724 u64 collisions = 0;
5725
5726 const uint dgst_pos0 = data.dgst_pos0;
5727 const uint dgst_pos1 = data.dgst_pos1;
5728 const uint dgst_pos2 = data.dgst_pos2;
5729 const uint dgst_pos3 = data.dgst_pos3;
5730
5731 memset (bitmap_a, 0, bitmap_size);
5732 memset (bitmap_b, 0, bitmap_size);
5733 memset (bitmap_c, 0, bitmap_size);
5734 memset (bitmap_d, 0, bitmap_size);
5735
5736 for (uint i = 0; i < digests_cnt; i++)
5737 {
5738 uint *digest_ptr = (uint *) digests_buf_ptr;
5739
5740 digests_buf_ptr += dgst_size;
5741
5742 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5743 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5744 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5745 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5746
5747 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5748 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5749 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5750 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5751
5752 if (bitmap_a[idx0] & val0) collisions++;
5753 if (bitmap_b[idx1] & val1) collisions++;
5754 if (bitmap_c[idx2] & val2) collisions++;
5755 if (bitmap_d[idx3] & val3) collisions++;
5756
5757 bitmap_a[idx0] |= val0;
5758 bitmap_b[idx1] |= val1;
5759 bitmap_c[idx2] |= val2;
5760 bitmap_d[idx3] |= val3;
5761
5762 if (collisions >= collisions_max) return 0x7fffffff;
5763 }
5764
5765 return collisions;
5766 }
5767
5768 /**
5769 * main
5770 */
5771
5772 #ifdef WIN
5773 void SetConsoleWindowSize (const int x)
5774 {
5775 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5776
5777 if (h == INVALID_HANDLE_VALUE) return;
5778
5779 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5780
5781 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5782
5783 SMALL_RECT *sr = &bufferInfo.srWindow;
5784
5785 sr->Right = MAX (sr->Right, x - 1);
5786
5787 COORD co;
5788
5789 co.X = sr->Right + 1;
5790 co.Y = 9999;
5791
5792 if (!SetConsoleScreenBufferSize (h, co)) return;
5793
5794 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5795 }
5796 #endif
5797
5798 int main (int argc, char **argv)
5799 {
5800 #ifdef WIN
5801 SetConsoleWindowSize (132);
5802 #endif
5803
5804 /**
5805 * To help users a bit
5806 */
5807
5808 char *compute = getenv ("COMPUTE");
5809
5810 if (compute)
5811 {
5812 static char display[100];
5813
5814 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5815
5816 putenv (display);
5817 }
5818 else
5819 {
5820 if (getenv ("DISPLAY") == NULL)
5821 putenv ((char *) "DISPLAY=:0");
5822 }
5823
5824 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5825 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5826
5827 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5828 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5829
5830 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5831 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5832
5833 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5834 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5835
5836 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5837 putenv ((char *) "POCL_KERNEL_CACHE=0");
5838
5839 umask (077);
5840
5841 /**
5842 * Real init
5843 */
5844
5845 memset (&data, 0, sizeof (hc_global_data_t));
5846
5847 time_t proc_start;
5848
5849 time (&proc_start);
5850
5851 data.proc_start = proc_start;
5852
5853 int myargc = argc;
5854 char **myargv = argv;
5855
5856 hc_thread_mutex_init (mux_dispatcher);
5857 hc_thread_mutex_init (mux_counter);
5858 hc_thread_mutex_init (mux_display);
5859 hc_thread_mutex_init (mux_adl);
5860
5861 /**
5862 * commandline parameters
5863 */
5864
5865 uint usage = USAGE;
5866 uint version = VERSION;
5867 uint quiet = QUIET;
5868 uint benchmark = BENCHMARK;
5869 uint stdout_flag = STDOUT_FLAG;
5870 uint show = SHOW;
5871 uint left = LEFT;
5872 uint username = USERNAME;
5873 uint remove = REMOVE;
5874 uint remove_timer = REMOVE_TIMER;
5875 u64 skip = SKIP;
5876 u64 limit = LIMIT;
5877 uint keyspace = KEYSPACE;
5878 uint potfile_disable = POTFILE_DISABLE;
5879 char *potfile_path = NULL;
5880 uint debug_mode = DEBUG_MODE;
5881 char *debug_file = NULL;
5882 char *induction_dir = NULL;
5883 char *outfile_check_dir = NULL;
5884 uint force = FORCE;
5885 uint runtime = RUNTIME;
5886 uint hash_mode = HASH_MODE;
5887 uint attack_mode = ATTACK_MODE;
5888 uint markov_disable = MARKOV_DISABLE;
5889 uint markov_classic = MARKOV_CLASSIC;
5890 uint markov_threshold = MARKOV_THRESHOLD;
5891 char *markov_hcstat = NULL;
5892 char *outfile = NULL;
5893 uint outfile_format = OUTFILE_FORMAT;
5894 uint outfile_autohex = OUTFILE_AUTOHEX;
5895 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5896 uint restore = RESTORE;
5897 uint restore_timer = RESTORE_TIMER;
5898 uint restore_disable = RESTORE_DISABLE;
5899 uint status = STATUS;
5900 uint status_timer = STATUS_TIMER;
5901 uint machine_readable = MACHINE_READABLE;
5902 uint loopback = LOOPBACK;
5903 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5904 char *session = NULL;
5905 uint hex_charset = HEX_CHARSET;
5906 uint hex_salt = HEX_SALT;
5907 uint hex_wordlist = HEX_WORDLIST;
5908 uint rp_gen = RP_GEN;
5909 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5910 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5911 uint rp_gen_seed = RP_GEN_SEED;
5912 char *rule_buf_l = (char *) RULE_BUF_L;
5913 char *rule_buf_r = (char *) RULE_BUF_R;
5914 uint increment = INCREMENT;
5915 uint increment_min = INCREMENT_MIN;
5916 uint increment_max = INCREMENT_MAX;
5917 char *cpu_affinity = NULL;
5918 OCL_PTR *ocl = NULL;
5919 char *opencl_devices = NULL;
5920 char *opencl_platforms = NULL;
5921 char *opencl_device_types = NULL;
5922 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5923 char *truecrypt_keyfiles = NULL;
5924 char *veracrypt_keyfiles = NULL;
5925 uint veracrypt_pim = 0;
5926 uint workload_profile = WORKLOAD_PROFILE;
5927 uint kernel_accel = KERNEL_ACCEL;
5928 uint kernel_loops = KERNEL_LOOPS;
5929 uint nvidia_spin_damp = NVIDIA_SPIN_DAMP;
5930 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5931 #ifdef HAVE_HWMON
5932 uint gpu_temp_abort = GPU_TEMP_ABORT;
5933 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5934 uint powertune_enable = POWERTUNE_ENABLE;
5935 #endif
5936 uint logfile_disable = LOGFILE_DISABLE;
5937 uint segment_size = SEGMENT_SIZE;
5938 uint scrypt_tmto = SCRYPT_TMTO;
5939 char separator = SEPARATOR;
5940 uint bitmap_min = BITMAP_MIN;
5941 uint bitmap_max = BITMAP_MAX;
5942 char *custom_charset_1 = NULL;
5943 char *custom_charset_2 = NULL;
5944 char *custom_charset_3 = NULL;
5945 char *custom_charset_4 = NULL;
5946
5947 #define IDX_HELP 'h'
5948 #define IDX_VERSION 'V'
5949 #define IDX_VERSION_LOWER 'v'
5950 #define IDX_QUIET 0xff02
5951 #define IDX_SHOW 0xff03
5952 #define IDX_LEFT 0xff04
5953 #define IDX_REMOVE 0xff05
5954 #define IDX_REMOVE_TIMER 0xff37
5955 #define IDX_SKIP 's'
5956 #define IDX_LIMIT 'l'
5957 #define IDX_KEYSPACE 0xff35
5958 #define IDX_POTFILE_DISABLE 0xff06
5959 #define IDX_POTFILE_PATH 0xffe0
5960 #define IDX_DEBUG_MODE 0xff43
5961 #define IDX_DEBUG_FILE 0xff44
5962 #define IDX_INDUCTION_DIR 0xff46
5963 #define IDX_OUTFILE_CHECK_DIR 0xff47
5964 #define IDX_USERNAME 0xff07
5965 #define IDX_FORCE 0xff08
5966 #define IDX_RUNTIME 0xff09
5967 #define IDX_BENCHMARK 'b'
5968 #define IDX_STDOUT_FLAG 0xff77
5969 #define IDX_HASH_MODE 'm'
5970 #define IDX_ATTACK_MODE 'a'
5971 #define IDX_RP_FILE 'r'
5972 #define IDX_RP_GEN 'g'
5973 #define IDX_RP_GEN_FUNC_MIN 0xff10
5974 #define IDX_RP_GEN_FUNC_MAX 0xff11
5975 #define IDX_RP_GEN_SEED 0xff34
5976 #define IDX_RULE_BUF_L 'j'
5977 #define IDX_RULE_BUF_R 'k'
5978 #define IDX_INCREMENT 'i'
5979 #define IDX_INCREMENT_MIN 0xff12
5980 #define IDX_INCREMENT_MAX 0xff13
5981 #define IDX_OUTFILE 'o'
5982 #define IDX_OUTFILE_FORMAT 0xff14
5983 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5984 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5985 #define IDX_RESTORE 0xff15
5986 #define IDX_RESTORE_DISABLE 0xff27
5987 #define IDX_STATUS 0xff17
5988 #define IDX_STATUS_TIMER 0xff18
5989 #define IDX_MACHINE_READABLE 0xff50
5990 #define IDX_LOOPBACK 0xff38
5991 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5992 #define IDX_SESSION 0xff19
5993 #define IDX_HEX_CHARSET 0xff20
5994 #define IDX_HEX_SALT 0xff21
5995 #define IDX_HEX_WORDLIST 0xff40
5996 #define IDX_MARKOV_DISABLE 0xff22
5997 #define IDX_MARKOV_CLASSIC 0xff23
5998 #define IDX_MARKOV_THRESHOLD 't'
5999 #define IDX_MARKOV_HCSTAT 0xff24
6000 #define IDX_CPU_AFFINITY 0xff25
6001 #define IDX_OPENCL_DEVICES 'd'
6002 #define IDX_OPENCL_PLATFORMS 0xff72
6003 #define IDX_OPENCL_DEVICE_TYPES 'D'
6004 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
6005 #define IDX_WORKLOAD_PROFILE 'w'
6006 #define IDX_KERNEL_ACCEL 'n'
6007 #define IDX_KERNEL_LOOPS 'u'
6008 #define IDX_NVIDIA_SPIN_DAMP 0xff79
6009 #define IDX_GPU_TEMP_DISABLE 0xff29
6010 #define IDX_GPU_TEMP_ABORT 0xff30
6011 #define IDX_GPU_TEMP_RETAIN 0xff31
6012 #define IDX_POWERTUNE_ENABLE 0xff41
6013 #define IDX_LOGFILE_DISABLE 0xff51
6014 #define IDX_TRUECRYPT_KEYFILES 0xff52
6015 #define IDX_VERACRYPT_KEYFILES 0xff53
6016 #define IDX_VERACRYPT_PIM 0xff54
6017 #define IDX_SCRYPT_TMTO 0xff61
6018 #define IDX_SEGMENT_SIZE 'c'
6019 #define IDX_SEPARATOR 'p'
6020 #define IDX_BITMAP_MIN 0xff70
6021 #define IDX_BITMAP_MAX 0xff71
6022 #define IDX_CUSTOM_CHARSET_1 '1'
6023 #define IDX_CUSTOM_CHARSET_2 '2'
6024 #define IDX_CUSTOM_CHARSET_3 '3'
6025 #define IDX_CUSTOM_CHARSET_4 '4'
6026
6027 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:D:n:u:c:p:s:l:1:2:3:4:ibw:";
6028
6029 struct option long_options[] =
6030 {
6031 {"help", no_argument, 0, IDX_HELP},
6032 {"version", no_argument, 0, IDX_VERSION},
6033 {"quiet", no_argument, 0, IDX_QUIET},
6034 {"show", no_argument, 0, IDX_SHOW},
6035 {"left", no_argument, 0, IDX_LEFT},
6036 {"username", no_argument, 0, IDX_USERNAME},
6037 {"remove", no_argument, 0, IDX_REMOVE},
6038 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
6039 {"skip", required_argument, 0, IDX_SKIP},
6040 {"limit", required_argument, 0, IDX_LIMIT},
6041 {"keyspace", no_argument, 0, IDX_KEYSPACE},
6042 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
6043 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
6044 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
6045 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
6046 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
6047 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
6048 {"force", no_argument, 0, IDX_FORCE},
6049 {"benchmark", no_argument, 0, IDX_BENCHMARK},
6050 {"stdout", no_argument, 0, IDX_STDOUT_FLAG},
6051 {"restore", no_argument, 0, IDX_RESTORE},
6052 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
6053 {"status", no_argument, 0, IDX_STATUS},
6054 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
6055 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
6056 {"loopback", no_argument, 0, IDX_LOOPBACK},
6057 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
6058 {"session", required_argument, 0, IDX_SESSION},
6059 {"runtime", required_argument, 0, IDX_RUNTIME},
6060 {"generate-rules", required_argument, 0, IDX_RP_GEN},
6061 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
6062 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
6063 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
6064 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
6065 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
6066 {"hash-type", required_argument, 0, IDX_HASH_MODE},
6067 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
6068 {"rules-file", required_argument, 0, IDX_RP_FILE},
6069 {"outfile", required_argument, 0, IDX_OUTFILE},
6070 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
6071 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
6072 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
6073 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
6074 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
6075 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
6076 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
6077 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
6078 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
6079 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
6080 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
6081 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
6082 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
6083 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
6084 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
6085 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
6086 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
6087 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
6088 {"nvidia-spin-damp", required_argument, 0, IDX_NVIDIA_SPIN_DAMP},
6089 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
6090 #ifdef HAVE_HWMON
6091 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
6092 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
6093 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
6094 #endif // HAVE_HWMON
6095 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
6096 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
6097 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
6098 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
6099 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
6100 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
6101 {"seperator", required_argument, 0, IDX_SEPARATOR},
6102 {"separator", required_argument, 0, IDX_SEPARATOR},
6103 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
6104 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
6105 {"increment", no_argument, 0, IDX_INCREMENT},
6106 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
6107 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
6108 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
6109 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
6110 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
6111 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
6112 {0, 0, 0, 0}
6113 };
6114
6115 uint rp_files_cnt = 0;
6116
6117 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6118
6119 int option_index = 0;
6120 int c = -1;
6121
6122 optind = 1;
6123 optopt = 0;
6124
6125 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6126 {
6127 switch (c)
6128 {
6129 case IDX_HELP: usage = 1; break;
6130 case IDX_VERSION:
6131 case IDX_VERSION_LOWER: version = 1; break;
6132 case IDX_RESTORE: restore = 1; break;
6133 case IDX_SESSION: session = optarg; break;
6134 case IDX_SHOW: show = 1; break;
6135 case IDX_LEFT: left = 1; break;
6136 case '?': return (-1);
6137 }
6138 }
6139
6140 if (optopt != 0)
6141 {
6142 log_error ("ERROR: Invalid argument specified");
6143
6144 return (-1);
6145 }
6146
6147 /**
6148 * exit functions
6149 */
6150
6151 if (version)
6152 {
6153 log_info ("%s", VERSION_TAG);
6154
6155 return (0);
6156 }
6157
6158 if (usage)
6159 {
6160 usage_big_print (PROGNAME);
6161
6162 return (0);
6163 }
6164
6165 /**
6166 * session needs to be set, always!
6167 */
6168
6169 if (session == NULL) session = (char *) PROGNAME;
6170
6171 /**
6172 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6173 */
6174
6175 char *exec_path = get_exec_path ();
6176
6177
6178 #if defined(LINUX) || defined(__APPLE__) || defined(__FreeBSD__)
6179
6180 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6181 char *resolved_exec_path = realpath (exec_path, NULL);
6182
6183 if (resolved_install_folder == NULL)
6184 {
6185 log_error ("ERROR: %s: %s", resolved_install_folder, strerror (errno));
6186
6187 return (-1);
6188 }
6189
6190 if (resolved_exec_path == NULL)
6191 {
6192 log_error ("ERROR: %s: %s", resolved_exec_path, strerror (errno));
6193
6194 return (-1);
6195 }
6196
6197 char *install_dir = get_install_dir (resolved_exec_path);
6198 char *profile_dir = NULL;
6199 char *session_dir = NULL;
6200 char *shared_dir = NULL;
6201
6202 if (strcmp (install_dir, resolved_install_folder) == 0)
6203 {
6204 struct passwd *pw = getpwuid (getuid ());
6205
6206 const char *homedir = pw->pw_dir;
6207
6208 profile_dir = get_profile_dir (homedir);
6209 session_dir = get_session_dir (profile_dir);
6210 shared_dir = strdup (SHARED_FOLDER);
6211
6212 mkdir (profile_dir, 0700);
6213 mkdir (session_dir, 0700);
6214 }
6215 else
6216 {
6217 profile_dir = install_dir;
6218 session_dir = install_dir;
6219 shared_dir = install_dir;
6220 }
6221
6222 myfree (resolved_install_folder);
6223 myfree (resolved_exec_path);
6224
6225 #else
6226
6227 char *install_dir = get_install_dir (exec_path);
6228 char *profile_dir = install_dir;
6229 char *session_dir = install_dir;
6230 char *shared_dir = install_dir;
6231
6232 #endif
6233
6234 data.install_dir = install_dir;
6235 data.profile_dir = profile_dir;
6236 data.session_dir = session_dir;
6237 data.shared_dir = shared_dir;
6238
6239 myfree (exec_path);
6240
6241 /**
6242 * kernel cache, we need to make sure folder exist
6243 */
6244
6245 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6246
6247 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6248
6249 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6250
6251 mkdir (kernels_folder, 0700);
6252
6253 myfree (kernels_folder);
6254
6255 /**
6256 * session
6257 */
6258
6259 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6260
6261 data.session = session;
6262
6263 char *eff_restore_file = (char *) mymalloc (session_size);
6264 char *new_restore_file = (char *) mymalloc (session_size);
6265
6266 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
6267 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6268
6269 data.eff_restore_file = eff_restore_file;
6270 data.new_restore_file = new_restore_file;
6271
6272 if (((show == 1) || (left == 1)) && (restore == 1))
6273 {
6274 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6275 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6276
6277 return (-1);
6278 }
6279
6280 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6281 if ((show == 1) || (left == 1))
6282 {
6283 restore_disable = 1;
6284
6285 restore = 0;
6286 }
6287
6288 data.restore_disable = restore_disable;
6289
6290 restore_data_t *rd = init_restore (argc, argv);
6291
6292 data.rd = rd;
6293
6294 /**
6295 * restore file
6296 */
6297
6298 if (restore == 1)
6299 {
6300 read_restore (eff_restore_file, rd);
6301
6302 if (rd->version_bin < RESTORE_MIN)
6303 {
6304 log_error ("ERROR: Incompatible restore-file version");
6305
6306 return (-1);
6307 }
6308
6309 myargc = rd->argc;
6310 myargv = rd->argv;
6311
6312 #ifdef _POSIX
6313 rd->pid = getpid ();
6314 #elif _WIN
6315 rd->pid = GetCurrentProcessId ();
6316 #endif
6317 }
6318
6319 uint hash_mode_chgd = 0;
6320 uint runtime_chgd = 0;
6321 uint kernel_loops_chgd = 0;
6322 uint kernel_accel_chgd = 0;
6323 uint nvidia_spin_damp_chgd = 0;
6324 uint attack_mode_chgd = 0;
6325 uint outfile_format_chgd = 0;
6326 uint rp_gen_seed_chgd = 0;
6327 uint remove_timer_chgd = 0;
6328 uint increment_min_chgd = 0;
6329 uint increment_max_chgd = 0;
6330 uint workload_profile_chgd = 0;
6331 uint opencl_vector_width_chgd = 0;
6332
6333 optind = 1;
6334 optopt = 0;
6335 option_index = 0;
6336
6337 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6338 {
6339 switch (c)
6340 {
6341 //case IDX_HELP: usage = 1; break;
6342 //case IDX_VERSION: version = 1; break;
6343 //case IDX_RESTORE: restore = 1; break;
6344 case IDX_QUIET: quiet = 1; break;
6345 //case IDX_SHOW: show = 1; break;
6346 case IDX_SHOW: break;
6347 //case IDX_LEFT: left = 1; break;
6348 case IDX_LEFT: break;
6349 case IDX_USERNAME: username = 1; break;
6350 case IDX_REMOVE: remove = 1; break;
6351 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6352 remove_timer_chgd = 1; break;
6353 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6354 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6355 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6356 case IDX_DEBUG_FILE: debug_file = optarg; break;
6357 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6358 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6359 case IDX_FORCE: force = 1; break;
6360 case IDX_SKIP: skip = atoll (optarg); break;
6361 case IDX_LIMIT: limit = atoll (optarg); break;
6362 case IDX_KEYSPACE: keyspace = 1; break;
6363 case IDX_BENCHMARK: benchmark = 1; break;
6364 case IDX_STDOUT_FLAG: stdout_flag = 1; break;
6365 case IDX_RESTORE: break;
6366 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6367 case IDX_STATUS: status = 1; break;
6368 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6369 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6370 case IDX_LOOPBACK: loopback = 1; break;
6371 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6372 //case IDX_SESSION: session = optarg; break;
6373 case IDX_SESSION: break;
6374 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6375 hash_mode_chgd = 1; break;
6376 case IDX_RUNTIME: runtime = atoi (optarg);
6377 runtime_chgd = 1; break;
6378 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6379 attack_mode_chgd = 1; break;
6380 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6381 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6382 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6383 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6384 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6385 rp_gen_seed_chgd = 1; break;
6386 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6387 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6388 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6389 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6390 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6391 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6392 case IDX_OUTFILE: outfile = optarg; break;
6393 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6394 outfile_format_chgd = 1; break;
6395 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6396 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6397 case IDX_HEX_CHARSET: hex_charset = 1; break;
6398 case IDX_HEX_SALT: hex_salt = 1; break;
6399 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6400 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6401 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6402 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6403 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6404 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6405 opencl_vector_width_chgd = 1; break;
6406 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6407 workload_profile_chgd = 1; break;
6408 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6409 kernel_accel_chgd = 1; break;
6410 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6411 kernel_loops_chgd = 1; break;
6412 case IDX_NVIDIA_SPIN_DAMP: nvidia_spin_damp = atoi (optarg);
6413 nvidia_spin_damp_chgd = 1; break;
6414 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6415 #ifdef HAVE_HWMON
6416 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6417 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6418 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6419 #endif // HAVE_HWMON
6420 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6421 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6422 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6423 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6424 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6425 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6426 case IDX_SEPARATOR: separator = optarg[0]; break;
6427 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6428 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6429 case IDX_INCREMENT: increment = 1; break;
6430 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6431 increment_min_chgd = 1; break;
6432 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6433 increment_max_chgd = 1; break;
6434 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6435 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6436 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6437 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6438
6439 default:
6440 log_error ("ERROR: Invalid argument specified");
6441 return (-1);
6442 }
6443 }
6444
6445 if (optopt != 0)
6446 {
6447 log_error ("ERROR: Invalid argument specified");
6448
6449 return (-1);
6450 }
6451
6452 /**
6453 * Inform user things getting started,
6454 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6455 * - we do not need to check algorithm_pos
6456 */
6457
6458 if (quiet == 0)
6459 {
6460 if (benchmark == 1)
6461 {
6462 if (machine_readable == 0)
6463 {
6464 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6465 log_info ("");
6466 }
6467 else
6468 {
6469 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6470 }
6471 }
6472 else if (restore == 1)
6473 {
6474 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6475 log_info ("");
6476 }
6477 else if (stdout_flag == 1)
6478 {
6479 // do nothing
6480 }
6481 else if (keyspace == 1)
6482 {
6483 // do nothing
6484 }
6485 else
6486 {
6487 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6488 log_info ("");
6489 }
6490 }
6491
6492 /**
6493 * sanity check
6494 */
6495
6496 if (attack_mode > 7)
6497 {
6498 log_error ("ERROR: Invalid attack-mode specified");
6499
6500 return (-1);
6501 }
6502
6503 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6504 {
6505 log_error ("ERROR: Invalid runtime specified");
6506
6507 return (-1);
6508 }
6509
6510 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6511 {
6512 log_error ("ERROR: Invalid hash-type specified");
6513
6514 return (-1);
6515 }
6516
6517 // renamed hash modes
6518
6519 if (hash_mode_chgd)
6520 {
6521 int n = -1;
6522
6523 switch (hash_mode)
6524 {
6525 case 123: n = 124;
6526 break;
6527 }
6528
6529 if (n >= 0)
6530 {
6531 log_error ("Old -m specified, use -m %d instead", n);
6532
6533 return (-1);
6534 }
6535 }
6536
6537 if (username == 1)
6538 {
6539 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6540 {
6541 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6542
6543 return (-1);
6544 }
6545 }
6546
6547 if (outfile_format > 16)
6548 {
6549 log_error ("ERROR: Invalid outfile-format specified");
6550
6551 return (-1);
6552 }
6553
6554 if (left == 1)
6555 {
6556 if (outfile_format_chgd == 1)
6557 {
6558 if (outfile_format > 1)
6559 {
6560 log_error ("ERROR: Mixing outfile-format > 1 with left parameter is not allowed");
6561
6562 return (-1);
6563 }
6564 }
6565 else
6566 {
6567 outfile_format = OUTFILE_FMT_HASH;
6568 }
6569 }
6570
6571 if (show == 1)
6572 {
6573 if (outfile_format_chgd == 1)
6574 {
6575 if ((outfile_format > 7) && (outfile_format < 16))
6576 {
6577 log_error ("ERROR: Mixing outfile-format > 7 with show parameter is not allowed");
6578
6579 return (-1);
6580 }
6581 }
6582 }
6583
6584 if (increment_min < INCREMENT_MIN)
6585 {
6586 log_error ("ERROR: Invalid increment-min specified");
6587
6588 return (-1);
6589 }
6590
6591 if (increment_max > INCREMENT_MAX)
6592 {
6593 log_error ("ERROR: Invalid increment-max specified");
6594
6595 return (-1);
6596 }
6597
6598 if (increment_min > increment_max)
6599 {
6600 log_error ("ERROR: Invalid increment-min specified");
6601
6602 return (-1);
6603 }
6604
6605 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6606 {
6607 log_error ("ERROR: Increment is not allowed in attack-mode 0");
6608
6609 return (-1);
6610 }
6611
6612 if ((increment == 0) && (increment_min_chgd == 1))
6613 {
6614 log_error ("ERROR: Increment-min is only supported combined with increment switch");
6615
6616 return (-1);
6617 }
6618
6619 if ((increment == 0) && (increment_max_chgd == 1))
6620 {
6621 log_error ("ERROR: Increment-max is only supported combined with increment switch");
6622
6623 return (-1);
6624 }
6625
6626 if (rp_files_cnt && rp_gen)
6627 {
6628 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6629
6630 return (-1);
6631 }
6632
6633 if (rp_files_cnt || rp_gen)
6634 {
6635 if (attack_mode != ATTACK_MODE_STRAIGHT)
6636 {
6637 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6638
6639 return (-1);
6640 }
6641 }
6642
6643 if (rp_gen_func_min > rp_gen_func_max)
6644 {
6645 log_error ("ERROR: Invalid rp-gen-func-min specified");
6646
6647 return (-1);
6648 }
6649
6650 if (kernel_accel_chgd == 1)
6651 {
6652 if (force == 0)
6653 {
6654 log_info ("The manual use of the -n option (or --kernel-accel) is outdated");
6655 log_info ("Please consider using the -w option instead");
6656 log_info ("You can use --force to override this but do not post error reports if you do so");
6657 log_info ("");
6658
6659 return (-1);
6660 }
6661
6662 if (kernel_accel < 1)
6663 {
6664 log_error ("ERROR: Invalid kernel-accel specified");
6665
6666 return (-1);
6667 }
6668
6669 if (kernel_accel > 1024)
6670 {
6671 log_error ("ERROR: Invalid kernel-accel specified");
6672
6673 return (-1);
6674 }
6675 }
6676
6677 if (kernel_loops_chgd == 1)
6678 {
6679 if (force == 0)
6680 {
6681 log_info ("The manual use of the -u option (or --kernel-loops) is outdated");
6682 log_info ("Please consider using the -w option instead");
6683 log_info ("You can use --force to override this but do not post error reports if you do so");
6684 log_info ("");
6685
6686 return (-1);
6687 }
6688
6689 if (kernel_loops < 1)
6690 {
6691 log_error ("ERROR: Invalid kernel-loops specified");
6692
6693 return (-1);
6694 }
6695
6696 if (kernel_loops > 1024)
6697 {
6698 log_error ("ERROR: Invalid kernel-loops specified");
6699
6700 return (-1);
6701 }
6702 }
6703
6704 if ((workload_profile < 1) || (workload_profile > 4))
6705 {
6706 log_error ("ERROR: workload-profile %i not available", workload_profile);
6707
6708 return (-1);
6709 }
6710
6711 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6712 {
6713 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6714
6715 return (-1);
6716 }
6717
6718 if (show == 1 || left == 1)
6719 {
6720 attack_mode = ATTACK_MODE_NONE;
6721
6722 if (remove == 1)
6723 {
6724 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6725
6726 return (-1);
6727 }
6728
6729 if (potfile_disable == 1)
6730 {
6731 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6732
6733 return (-1);
6734 }
6735 }
6736
6737 uint attack_kern = ATTACK_KERN_NONE;
6738
6739 switch (attack_mode)
6740 {
6741 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6742 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6743 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6744 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6745 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6746 }
6747
6748 if (benchmark == 1)
6749 {
6750 if (myargv[optind] != 0)
6751 {
6752 log_error ("ERROR: Invalid argument for benchmark mode specified");
6753
6754 return (-1);
6755 }
6756
6757 if (attack_mode_chgd == 1)
6758 {
6759 if (attack_mode != ATTACK_MODE_BF)
6760 {
6761 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6762
6763 return (-1);
6764 }
6765 }
6766 }
6767 else
6768 {
6769 if (stdout_flag == 1) // no hash here
6770 {
6771 optind--;
6772 }
6773
6774 if (keyspace == 1)
6775 {
6776 int num_additional_params = 1;
6777
6778 if (attack_kern == ATTACK_KERN_COMBI)
6779 {
6780 num_additional_params = 2;
6781 }
6782
6783 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6784
6785 if (keyspace_wordlist_specified == 0) optind--;
6786 }
6787
6788 if (attack_kern == ATTACK_KERN_NONE)
6789 {
6790 if ((optind + 1) != myargc)
6791 {
6792 usage_mini_print (myargv[0]);
6793
6794 return (-1);
6795 }
6796 }
6797 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6798 {
6799 if ((optind + 1) > myargc)
6800 {
6801 usage_mini_print (myargv[0]);
6802
6803 return (-1);
6804 }
6805 }
6806 else if (attack_kern == ATTACK_KERN_COMBI)
6807 {
6808 if ((optind + 3) != myargc)
6809 {
6810 usage_mini_print (myargv[0]);
6811
6812 return (-1);
6813 }
6814 }
6815 else if (attack_kern == ATTACK_KERN_BF)
6816 {
6817 if ((optind + 1) > myargc)
6818 {
6819 usage_mini_print (myargv[0]);
6820
6821 return (-1);
6822 }
6823 }
6824 else
6825 {
6826 usage_mini_print (myargv[0]);
6827
6828 return (-1);
6829 }
6830 }
6831
6832 if (skip != 0 && limit != 0)
6833 {
6834 limit += skip;
6835 }
6836
6837 if (keyspace == 1)
6838 {
6839 if (show == 1)
6840 {
6841 log_error ("ERROR: Combining show parameter with keyspace parameter is not allowed");
6842
6843 return (-1);
6844 }
6845 else if (left == 1)
6846 {
6847 log_error ("ERROR: Combining left parameter with keyspace parameter is not allowed");
6848
6849 return (-1);
6850 }
6851
6852 potfile_disable = 1;
6853
6854 restore_disable = 1;
6855
6856 restore = 0;
6857
6858 weak_hash_threshold = 0;
6859
6860 quiet = 1;
6861 }
6862
6863 if (stdout_flag == 1)
6864 {
6865 status_timer = 0;
6866 restore_timer = 0;
6867 restore_disable = 1;
6868 restore = 0;
6869 potfile_disable = 1;
6870 weak_hash_threshold = 0;
6871 gpu_temp_disable = 1;
6872 hash_mode = 2000;
6873 quiet = 1;
6874 outfile_format = OUTFILE_FMT_PLAIN;
6875 kernel_accel = 1024;
6876 kernel_loops = 1024;
6877 force = 1;
6878 outfile_check_timer = 0;
6879 session = "stdout";
6880 opencl_vector_width = 1;
6881 }
6882
6883 if (remove_timer_chgd == 1)
6884 {
6885 if (remove == 0)
6886 {
6887 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6888
6889 return (-1);
6890 }
6891
6892 if (remove_timer < 1)
6893 {
6894 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6895
6896 return (-1);
6897 }
6898 }
6899
6900 if (loopback == 1)
6901 {
6902 if (attack_mode == ATTACK_MODE_STRAIGHT)
6903 {
6904 if ((rp_files_cnt == 0) && (rp_gen == 0))
6905 {
6906 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6907
6908 return (-1);
6909 }
6910 }
6911 else
6912 {
6913 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6914
6915 return (-1);
6916 }
6917 }
6918
6919 if (debug_mode > 0)
6920 {
6921 if (attack_mode != ATTACK_MODE_STRAIGHT)
6922 {
6923 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6924
6925 return (-1);
6926 }
6927
6928 if ((rp_files_cnt == 0) && (rp_gen == 0))
6929 {
6930 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6931
6932 return (-1);
6933 }
6934 }
6935
6936 if (debug_mode > 4)
6937 {
6938 log_error ("ERROR: Invalid debug-mode specified");
6939
6940 return (-1);
6941 }
6942
6943 if (debug_file != NULL)
6944 {
6945 if (debug_mode < 1)
6946 {
6947 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6948
6949 return (-1);
6950 }
6951 }
6952
6953 if (induction_dir != NULL)
6954 {
6955 if (attack_mode == ATTACK_MODE_BF)
6956 {
6957 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6958
6959 return (-1);
6960 }
6961 }
6962
6963 if (attack_mode != ATTACK_MODE_STRAIGHT)
6964 {
6965 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6966 {
6967 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6968
6969 return (-1);
6970 }
6971
6972 weak_hash_threshold = 0;
6973 }
6974
6975 if (nvidia_spin_damp > 100)
6976 {
6977 log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)");
6978
6979 return (-1);
6980 }
6981
6982
6983 /**
6984 * induction directory
6985 */
6986
6987 char *induction_directory = NULL;
6988
6989 if (attack_mode != ATTACK_MODE_BF)
6990 {
6991 if (induction_dir == NULL)
6992 {
6993 induction_directory = (char *) mymalloc (session_size);
6994
6995 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6996
6997 // create induction folder if it does not already exist
6998
6999 if (keyspace == 0)
7000 {
7001 if (rmdir (induction_directory) == -1)
7002 {
7003 if (errno == ENOENT)
7004 {
7005 // good, we can ignore
7006 }
7007 else if (errno == ENOTEMPTY)
7008 {
7009 char *induction_directory_mv = (char *) mymalloc (session_size);
7010
7011 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
7012
7013 if (rename (induction_directory, induction_directory_mv) != 0)
7014 {
7015 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
7016
7017 return (-1);
7018 }
7019 }
7020 else
7021 {
7022 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
7023
7024 return (-1);
7025 }
7026 }
7027
7028 if (mkdir (induction_directory, 0700) == -1)
7029 {
7030 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
7031
7032 return (-1);
7033 }
7034 }
7035 }
7036 else
7037 {
7038 induction_directory = induction_dir;
7039 }
7040 }
7041
7042 data.induction_directory = induction_directory;
7043
7044 /**
7045 * loopback
7046 */
7047
7048 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
7049
7050 char *loopback_file = (char *) mymalloc (loopback_size);
7051
7052 /**
7053 * tuning db
7054 */
7055
7056 char tuning_db_file[256] = { 0 };
7057
7058 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
7059
7060 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
7061
7062 /**
7063 * outfile-check directory
7064 */
7065
7066 char *outfile_check_directory = NULL;
7067
7068 if (outfile_check_dir == NULL)
7069 {
7070 outfile_check_directory = (char *) mymalloc (session_size);
7071
7072 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
7073 }
7074 else
7075 {
7076 outfile_check_directory = outfile_check_dir;
7077 }
7078
7079 data.outfile_check_directory = outfile_check_directory;
7080
7081 if (keyspace == 0)
7082 {
7083 struct stat outfile_check_stat;
7084
7085 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
7086 {
7087 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
7088
7089 if (is_dir == 0)
7090 {
7091 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
7092
7093 return (-1);
7094 }
7095 }
7096 else if (outfile_check_dir == NULL)
7097 {
7098 if (mkdir (outfile_check_directory, 0700) == -1)
7099 {
7100 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
7101
7102 return (-1);
7103 }
7104 }
7105 }
7106
7107 /**
7108 * special other stuff
7109 */
7110
7111 if (hash_mode == 9710)
7112 {
7113 outfile_format = 5;
7114 outfile_format_chgd = 1;
7115 }
7116
7117 if (hash_mode == 9810)
7118 {
7119 outfile_format = 5;
7120 outfile_format_chgd = 1;
7121 }
7122
7123 if (hash_mode == 10410)
7124 {
7125 outfile_format = 5;
7126 outfile_format_chgd = 1;
7127 }
7128
7129 /**
7130 * store stuff
7131 */
7132
7133 data.hash_mode = hash_mode;
7134 data.restore = restore;
7135 data.restore_timer = restore_timer;
7136 data.restore_disable = restore_disable;
7137 data.status = status;
7138 data.status_timer = status_timer;
7139 data.machine_readable = machine_readable;
7140 data.loopback = loopback;
7141 data.runtime = runtime;
7142 data.remove = remove;
7143 data.remove_timer = remove_timer;
7144 data.debug_mode = debug_mode;
7145 data.debug_file = debug_file;
7146 data.username = username;
7147 data.quiet = quiet;
7148 data.outfile = outfile;
7149 data.outfile_format = outfile_format;
7150 data.outfile_autohex = outfile_autohex;
7151 data.hex_charset = hex_charset;
7152 data.hex_salt = hex_salt;
7153 data.hex_wordlist = hex_wordlist;
7154 data.separator = separator;
7155 data.rp_files = rp_files;
7156 data.rp_files_cnt = rp_files_cnt;
7157 data.rp_gen = rp_gen;
7158 data.rp_gen_seed = rp_gen_seed;
7159 data.force = force;
7160 data.benchmark = benchmark;
7161 data.skip = skip;
7162 data.limit = limit;
7163 #ifdef HAVE_HWMON
7164 data.powertune_enable = powertune_enable;
7165 #endif
7166 data.logfile_disable = logfile_disable;
7167 data.truecrypt_keyfiles = truecrypt_keyfiles;
7168 data.veracrypt_keyfiles = veracrypt_keyfiles;
7169 data.veracrypt_pim = veracrypt_pim;
7170 data.scrypt_tmto = scrypt_tmto;
7171 data.workload_profile = workload_profile;
7172
7173 /**
7174 * cpu affinity
7175 */
7176
7177 if (cpu_affinity)
7178 {
7179 set_cpu_affinity (cpu_affinity);
7180 }
7181
7182 if (rp_gen_seed_chgd == 0)
7183 {
7184 srand (proc_start);
7185 }
7186 else
7187 {
7188 srand (rp_gen_seed);
7189 }
7190
7191 /**
7192 * logfile init
7193 */
7194
7195 if (logfile_disable == 0)
7196 {
7197 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7198
7199 char *logfile = (char *) mymalloc (logfile_size);
7200
7201 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7202
7203 data.logfile = logfile;
7204
7205 char *topid = logfile_generate_topid ();
7206
7207 data.topid = topid;
7208 }
7209
7210 // logfile_append() checks for logfile_disable internally to make it easier from here
7211
7212 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7213 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7214 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7215 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7216 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7217 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7218 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7219 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7220 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7221 #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));
7222
7223 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7224 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7225 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7226 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7227 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7228 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7229 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7230 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7231
7232 logfile_top_msg ("START");
7233
7234 logfile_top_uint (attack_mode);
7235 logfile_top_uint (attack_kern);
7236 logfile_top_uint (benchmark);
7237 logfile_top_uint (stdout_flag);
7238 logfile_top_uint (bitmap_min);
7239 logfile_top_uint (bitmap_max);
7240 logfile_top_uint (debug_mode);
7241 logfile_top_uint (force);
7242 logfile_top_uint (kernel_accel);
7243 logfile_top_uint (kernel_loops);
7244 logfile_top_uint (nvidia_spin_damp);
7245 logfile_top_uint (gpu_temp_disable);
7246 #ifdef HAVE_HWMON
7247 logfile_top_uint (gpu_temp_abort);
7248 logfile_top_uint (gpu_temp_retain);
7249 #endif
7250 logfile_top_uint (hash_mode);
7251 logfile_top_uint (hex_charset);
7252 logfile_top_uint (hex_salt);
7253 logfile_top_uint (hex_wordlist);
7254 logfile_top_uint (increment);
7255 logfile_top_uint (increment_max);
7256 logfile_top_uint (increment_min);
7257 logfile_top_uint (keyspace);
7258 logfile_top_uint (left);
7259 logfile_top_uint (logfile_disable);
7260 logfile_top_uint (loopback);
7261 logfile_top_uint (markov_classic);
7262 logfile_top_uint (markov_disable);
7263 logfile_top_uint (markov_threshold);
7264 logfile_top_uint (outfile_autohex);
7265 logfile_top_uint (outfile_check_timer);
7266 logfile_top_uint (outfile_format);
7267 logfile_top_uint (potfile_disable);
7268 logfile_top_string (potfile_path);
7269 #if defined(HAVE_HWMON)
7270 logfile_top_uint (powertune_enable);
7271 #endif
7272 logfile_top_uint (scrypt_tmto);
7273 logfile_top_uint (quiet);
7274 logfile_top_uint (remove);
7275 logfile_top_uint (remove_timer);
7276 logfile_top_uint (restore);
7277 logfile_top_uint (restore_disable);
7278 logfile_top_uint (restore_timer);
7279 logfile_top_uint (rp_gen);
7280 logfile_top_uint (rp_gen_func_max);
7281 logfile_top_uint (rp_gen_func_min);
7282 logfile_top_uint (rp_gen_seed);
7283 logfile_top_uint (runtime);
7284 logfile_top_uint (segment_size);
7285 logfile_top_uint (show);
7286 logfile_top_uint (status);
7287 logfile_top_uint (machine_readable);
7288 logfile_top_uint (status_timer);
7289 logfile_top_uint (usage);
7290 logfile_top_uint (username);
7291 logfile_top_uint (version);
7292 logfile_top_uint (weak_hash_threshold);
7293 logfile_top_uint (workload_profile);
7294 logfile_top_uint64 (limit);
7295 logfile_top_uint64 (skip);
7296 logfile_top_char (separator);
7297 logfile_top_string (cpu_affinity);
7298 logfile_top_string (custom_charset_1);
7299 logfile_top_string (custom_charset_2);
7300 logfile_top_string (custom_charset_3);
7301 logfile_top_string (custom_charset_4);
7302 logfile_top_string (debug_file);
7303 logfile_top_string (opencl_devices);
7304 logfile_top_string (opencl_platforms);
7305 logfile_top_string (opencl_device_types);
7306 logfile_top_uint (opencl_vector_width);
7307 logfile_top_string (induction_dir);
7308 logfile_top_string (markov_hcstat);
7309 logfile_top_string (outfile);
7310 logfile_top_string (outfile_check_dir);
7311 logfile_top_string (rule_buf_l);
7312 logfile_top_string (rule_buf_r);
7313 logfile_top_string (session);
7314 logfile_top_string (truecrypt_keyfiles);
7315 logfile_top_string (veracrypt_keyfiles);
7316 logfile_top_uint (veracrypt_pim);
7317
7318 /**
7319 * Init OpenCL library loader
7320 */
7321
7322 if (keyspace == 0)
7323 {
7324 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7325
7326 ocl_init (ocl);
7327
7328 data.ocl = ocl;
7329 }
7330
7331 /**
7332 * OpenCL platform selection
7333 */
7334
7335 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7336
7337 /**
7338 * OpenCL device selection
7339 */
7340
7341 u32 devices_filter = setup_devices_filter (opencl_devices);
7342
7343 /**
7344 * OpenCL device type selection
7345 */
7346
7347 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7348
7349 /**
7350 * benchmark
7351 */
7352
7353 if (benchmark == 1)
7354 {
7355 /**
7356 * disable useless stuff for benchmark
7357 */
7358
7359 status_timer = 0;
7360 restore_timer = 0;
7361 restore_disable = 1;
7362 potfile_disable = 1;
7363 weak_hash_threshold = 0;
7364 nvidia_spin_damp = 0;
7365 gpu_temp_disable = 1;
7366 outfile_check_timer = 0;
7367
7368 #ifdef HAVE_HWMON
7369 if (powertune_enable == 1)
7370 {
7371 gpu_temp_disable = 0;
7372 }
7373 #endif
7374
7375 data.status_timer = status_timer;
7376 data.restore_timer = restore_timer;
7377 data.restore_disable = restore_disable;
7378 data.outfile_check_timer = outfile_check_timer;
7379
7380 /**
7381 * force attack mode to be bruteforce
7382 */
7383
7384 attack_mode = ATTACK_MODE_BF;
7385 attack_kern = ATTACK_KERN_BF;
7386
7387 if (workload_profile_chgd == 0)
7388 {
7389 workload_profile = 3;
7390
7391 data.workload_profile = workload_profile;
7392 }
7393 }
7394
7395 /**
7396 * status, monitor and outfile remove threads
7397 */
7398
7399 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
7400
7401 data.wordlist_mode = wordlist_mode;
7402
7403 if (wordlist_mode == WL_MODE_STDIN)
7404 {
7405 status = 1;
7406
7407 data.status = status;
7408 }
7409
7410 uint outer_threads_cnt = 0;
7411
7412 hc_thread_t *outer_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
7413
7414 data.shutdown_outer = 0;
7415
7416 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
7417 {
7418 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
7419 {
7420 hc_thread_create (outer_threads[outer_threads_cnt], thread_keypress, NULL);
7421
7422 outer_threads_cnt++;
7423 }
7424 }
7425
7426 /**
7427 * config
7428 */
7429
7430 uint hash_type = 0;
7431 uint salt_type = 0;
7432 uint attack_exec = 0;
7433 uint opts_type = 0;
7434 uint kern_type = 0;
7435 uint dgst_size = 0;
7436 uint esalt_size = 0;
7437 uint opti_type = 0;
7438 uint dgst_pos0 = -1;
7439 uint dgst_pos1 = -1;
7440 uint dgst_pos2 = -1;
7441 uint dgst_pos3 = -1;
7442
7443 int (*parse_func) (char *, uint, hash_t *);
7444 int (*sort_by_digest) (const void *, const void *);
7445
7446 uint algorithm_pos = 0;
7447 uint algorithm_max = 1;
7448
7449 uint *algorithms = default_benchmark_algorithms;
7450
7451 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7452
7453 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7454 {
7455 /*
7456 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7457 * the following algos are skipped entirely
7458 */
7459
7460 if (algorithm_pos > 0)
7461 {
7462 local_free (rd);
7463
7464 rd = init_restore (argc, argv);
7465
7466 data.rd = rd;
7467 }
7468
7469 /**
7470 * update hash_mode in case of multihash benchmark
7471 */
7472
7473 if (benchmark == 1)
7474 {
7475 if (hash_mode_chgd == 0)
7476 {
7477 hash_mode = algorithms[algorithm_pos];
7478
7479 data.hash_mode = hash_mode;
7480 }
7481
7482 quiet = 1;
7483
7484 data.quiet = quiet;
7485 }
7486
7487 switch (hash_mode)
7488 {
7489 case 0: hash_type = HASH_TYPE_MD5;
7490 salt_type = SALT_TYPE_NONE;
7491 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7492 opts_type = OPTS_TYPE_PT_GENERATE_LE
7493 | OPTS_TYPE_PT_ADD80
7494 | OPTS_TYPE_PT_ADDBITS14;
7495 kern_type = KERN_TYPE_MD5;
7496 dgst_size = DGST_SIZE_4_4;
7497 parse_func = md5_parse_hash;
7498 sort_by_digest = sort_by_digest_4_4;
7499 opti_type = OPTI_TYPE_ZERO_BYTE
7500 | OPTI_TYPE_PRECOMPUTE_INIT
7501 | OPTI_TYPE_PRECOMPUTE_MERKLE
7502 | OPTI_TYPE_MEET_IN_MIDDLE
7503 | OPTI_TYPE_EARLY_SKIP
7504 | OPTI_TYPE_NOT_ITERATED
7505 | OPTI_TYPE_NOT_SALTED
7506 | OPTI_TYPE_RAW_HASH;
7507 dgst_pos0 = 0;
7508 dgst_pos1 = 3;
7509 dgst_pos2 = 2;
7510 dgst_pos3 = 1;
7511 break;
7512
7513 case 10: hash_type = HASH_TYPE_MD5;
7514 salt_type = SALT_TYPE_INTERN;
7515 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7516 opts_type = OPTS_TYPE_PT_GENERATE_LE
7517 | OPTS_TYPE_ST_ADD80
7518 | OPTS_TYPE_ST_ADDBITS14;
7519 kern_type = KERN_TYPE_MD5_PWSLT;
7520 dgst_size = DGST_SIZE_4_4;
7521 parse_func = md5s_parse_hash;
7522 sort_by_digest = sort_by_digest_4_4;
7523 opti_type = OPTI_TYPE_ZERO_BYTE
7524 | OPTI_TYPE_PRECOMPUTE_INIT
7525 | OPTI_TYPE_PRECOMPUTE_MERKLE
7526 | OPTI_TYPE_MEET_IN_MIDDLE
7527 | OPTI_TYPE_EARLY_SKIP
7528 | OPTI_TYPE_NOT_ITERATED
7529 | OPTI_TYPE_APPENDED_SALT
7530 | OPTI_TYPE_RAW_HASH;
7531 dgst_pos0 = 0;
7532 dgst_pos1 = 3;
7533 dgst_pos2 = 2;
7534 dgst_pos3 = 1;
7535 break;
7536
7537 case 11: hash_type = HASH_TYPE_MD5;
7538 salt_type = SALT_TYPE_INTERN;
7539 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7540 opts_type = OPTS_TYPE_PT_GENERATE_LE
7541 | OPTS_TYPE_ST_ADD80
7542 | OPTS_TYPE_ST_ADDBITS14;
7543 kern_type = KERN_TYPE_MD5_PWSLT;
7544 dgst_size = DGST_SIZE_4_4;
7545 parse_func = joomla_parse_hash;
7546 sort_by_digest = sort_by_digest_4_4;
7547 opti_type = OPTI_TYPE_ZERO_BYTE
7548 | OPTI_TYPE_PRECOMPUTE_INIT
7549 | OPTI_TYPE_PRECOMPUTE_MERKLE
7550 | OPTI_TYPE_MEET_IN_MIDDLE
7551 | OPTI_TYPE_EARLY_SKIP
7552 | OPTI_TYPE_NOT_ITERATED
7553 | OPTI_TYPE_APPENDED_SALT
7554 | OPTI_TYPE_RAW_HASH;
7555 dgst_pos0 = 0;
7556 dgst_pos1 = 3;
7557 dgst_pos2 = 2;
7558 dgst_pos3 = 1;
7559 break;
7560
7561 case 12: hash_type = HASH_TYPE_MD5;
7562 salt_type = SALT_TYPE_INTERN;
7563 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7564 opts_type = OPTS_TYPE_PT_GENERATE_LE
7565 | OPTS_TYPE_ST_ADD80
7566 | OPTS_TYPE_ST_ADDBITS14;
7567 kern_type = KERN_TYPE_MD5_PWSLT;
7568 dgst_size = DGST_SIZE_4_4;
7569 parse_func = postgresql_parse_hash;
7570 sort_by_digest = sort_by_digest_4_4;
7571 opti_type = OPTI_TYPE_ZERO_BYTE
7572 | OPTI_TYPE_PRECOMPUTE_INIT
7573 | OPTI_TYPE_PRECOMPUTE_MERKLE
7574 | OPTI_TYPE_MEET_IN_MIDDLE
7575 | OPTI_TYPE_EARLY_SKIP
7576 | OPTI_TYPE_NOT_ITERATED
7577 | OPTI_TYPE_APPENDED_SALT
7578 | OPTI_TYPE_RAW_HASH;
7579 dgst_pos0 = 0;
7580 dgst_pos1 = 3;
7581 dgst_pos2 = 2;
7582 dgst_pos3 = 1;
7583 break;
7584
7585 case 20: hash_type = HASH_TYPE_MD5;
7586 salt_type = SALT_TYPE_INTERN;
7587 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7588 opts_type = OPTS_TYPE_PT_GENERATE_LE
7589 | OPTS_TYPE_PT_ADD80
7590 | OPTS_TYPE_PT_ADDBITS14;
7591 kern_type = KERN_TYPE_MD5_SLTPW;
7592 dgst_size = DGST_SIZE_4_4;
7593 parse_func = md5s_parse_hash;
7594 sort_by_digest = sort_by_digest_4_4;
7595 opti_type = OPTI_TYPE_ZERO_BYTE
7596 | OPTI_TYPE_PRECOMPUTE_INIT
7597 | OPTI_TYPE_PRECOMPUTE_MERKLE
7598 | OPTI_TYPE_EARLY_SKIP
7599 | OPTI_TYPE_NOT_ITERATED
7600 | OPTI_TYPE_PREPENDED_SALT
7601 | OPTI_TYPE_RAW_HASH;
7602 dgst_pos0 = 0;
7603 dgst_pos1 = 3;
7604 dgst_pos2 = 2;
7605 dgst_pos3 = 1;
7606 break;
7607
7608 case 21: hash_type = HASH_TYPE_MD5;
7609 salt_type = SALT_TYPE_INTERN;
7610 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7611 opts_type = OPTS_TYPE_PT_GENERATE_LE
7612 | OPTS_TYPE_PT_ADD80
7613 | OPTS_TYPE_PT_ADDBITS14;
7614 kern_type = KERN_TYPE_MD5_SLTPW;
7615 dgst_size = DGST_SIZE_4_4;
7616 parse_func = osc_parse_hash;
7617 sort_by_digest = sort_by_digest_4_4;
7618 opti_type = OPTI_TYPE_ZERO_BYTE
7619 | OPTI_TYPE_PRECOMPUTE_INIT
7620 | OPTI_TYPE_PRECOMPUTE_MERKLE
7621 | OPTI_TYPE_EARLY_SKIP
7622 | OPTI_TYPE_NOT_ITERATED
7623 | OPTI_TYPE_PREPENDED_SALT
7624 | OPTI_TYPE_RAW_HASH;
7625 dgst_pos0 = 0;
7626 dgst_pos1 = 3;
7627 dgst_pos2 = 2;
7628 dgst_pos3 = 1;
7629 break;
7630
7631 case 22: hash_type = HASH_TYPE_MD5;
7632 salt_type = SALT_TYPE_EMBEDDED;
7633 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7634 opts_type = OPTS_TYPE_PT_GENERATE_LE
7635 | OPTS_TYPE_PT_ADD80
7636 | OPTS_TYPE_PT_ADDBITS14;
7637 kern_type = KERN_TYPE_MD5_SLTPW;
7638 dgst_size = DGST_SIZE_4_4;
7639 parse_func = netscreen_parse_hash;
7640 sort_by_digest = sort_by_digest_4_4;
7641 opti_type = OPTI_TYPE_ZERO_BYTE
7642 | OPTI_TYPE_PRECOMPUTE_INIT
7643 | OPTI_TYPE_PRECOMPUTE_MERKLE
7644 | OPTI_TYPE_EARLY_SKIP
7645 | OPTI_TYPE_NOT_ITERATED
7646 | OPTI_TYPE_PREPENDED_SALT
7647 | OPTI_TYPE_RAW_HASH;
7648 dgst_pos0 = 0;
7649 dgst_pos1 = 3;
7650 dgst_pos2 = 2;
7651 dgst_pos3 = 1;
7652 break;
7653
7654 case 23: hash_type = HASH_TYPE_MD5;
7655 salt_type = SALT_TYPE_EMBEDDED;
7656 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7657 opts_type = OPTS_TYPE_PT_GENERATE_LE
7658 | OPTS_TYPE_PT_ADD80
7659 | OPTS_TYPE_PT_ADDBITS14;
7660 kern_type = KERN_TYPE_MD5_SLTPW;
7661 dgst_size = DGST_SIZE_4_4;
7662 parse_func = skype_parse_hash;
7663 sort_by_digest = sort_by_digest_4_4;
7664 opti_type = OPTI_TYPE_ZERO_BYTE
7665 | OPTI_TYPE_PRECOMPUTE_INIT
7666 | OPTI_TYPE_PRECOMPUTE_MERKLE
7667 | OPTI_TYPE_EARLY_SKIP
7668 | OPTI_TYPE_NOT_ITERATED
7669 | OPTI_TYPE_PREPENDED_SALT
7670 | OPTI_TYPE_RAW_HASH;
7671 dgst_pos0 = 0;
7672 dgst_pos1 = 3;
7673 dgst_pos2 = 2;
7674 dgst_pos3 = 1;
7675 break;
7676
7677 case 30: hash_type = HASH_TYPE_MD5;
7678 salt_type = SALT_TYPE_INTERN;
7679 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7680 opts_type = OPTS_TYPE_PT_GENERATE_LE
7681 | OPTS_TYPE_PT_UNICODE
7682 | OPTS_TYPE_ST_ADD80
7683 | OPTS_TYPE_ST_ADDBITS14;
7684 kern_type = KERN_TYPE_MD5_PWUSLT;
7685 dgst_size = DGST_SIZE_4_4;
7686 parse_func = md5s_parse_hash;
7687 sort_by_digest = sort_by_digest_4_4;
7688 opti_type = OPTI_TYPE_ZERO_BYTE
7689 | OPTI_TYPE_PRECOMPUTE_INIT
7690 | OPTI_TYPE_PRECOMPUTE_MERKLE
7691 | OPTI_TYPE_MEET_IN_MIDDLE
7692 | OPTI_TYPE_EARLY_SKIP
7693 | OPTI_TYPE_NOT_ITERATED
7694 | OPTI_TYPE_APPENDED_SALT
7695 | OPTI_TYPE_RAW_HASH;
7696 dgst_pos0 = 0;
7697 dgst_pos1 = 3;
7698 dgst_pos2 = 2;
7699 dgst_pos3 = 1;
7700 break;
7701
7702 case 40: hash_type = HASH_TYPE_MD5;
7703 salt_type = SALT_TYPE_INTERN;
7704 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7705 opts_type = OPTS_TYPE_PT_GENERATE_LE
7706 | OPTS_TYPE_PT_ADD80
7707 | OPTS_TYPE_PT_ADDBITS14
7708 | OPTS_TYPE_PT_UNICODE;
7709 kern_type = KERN_TYPE_MD5_SLTPWU;
7710 dgst_size = DGST_SIZE_4_4;
7711 parse_func = md5s_parse_hash;
7712 sort_by_digest = sort_by_digest_4_4;
7713 opti_type = OPTI_TYPE_ZERO_BYTE
7714 | OPTI_TYPE_PRECOMPUTE_INIT
7715 | OPTI_TYPE_PRECOMPUTE_MERKLE
7716 | OPTI_TYPE_EARLY_SKIP
7717 | OPTI_TYPE_NOT_ITERATED
7718 | OPTI_TYPE_PREPENDED_SALT
7719 | OPTI_TYPE_RAW_HASH;
7720 dgst_pos0 = 0;
7721 dgst_pos1 = 3;
7722 dgst_pos2 = 2;
7723 dgst_pos3 = 1;
7724 break;
7725
7726 case 50: hash_type = HASH_TYPE_MD5;
7727 salt_type = SALT_TYPE_INTERN;
7728 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7729 opts_type = OPTS_TYPE_PT_GENERATE_LE
7730 | OPTS_TYPE_ST_ADD80
7731 | OPTS_TYPE_ST_ADDBITS14;
7732 kern_type = KERN_TYPE_HMACMD5_PW;
7733 dgst_size = DGST_SIZE_4_4;
7734 parse_func = hmacmd5_parse_hash;
7735 sort_by_digest = sort_by_digest_4_4;
7736 opti_type = OPTI_TYPE_ZERO_BYTE
7737 | OPTI_TYPE_NOT_ITERATED;
7738 dgst_pos0 = 0;
7739 dgst_pos1 = 3;
7740 dgst_pos2 = 2;
7741 dgst_pos3 = 1;
7742 break;
7743
7744 case 60: hash_type = HASH_TYPE_MD5;
7745 salt_type = SALT_TYPE_INTERN;
7746 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7747 opts_type = OPTS_TYPE_PT_GENERATE_LE
7748 | OPTS_TYPE_PT_ADD80
7749 | OPTS_TYPE_PT_ADDBITS14;
7750 kern_type = KERN_TYPE_HMACMD5_SLT;
7751 dgst_size = DGST_SIZE_4_4;
7752 parse_func = hmacmd5_parse_hash;
7753 sort_by_digest = sort_by_digest_4_4;
7754 opti_type = OPTI_TYPE_ZERO_BYTE
7755 | OPTI_TYPE_NOT_ITERATED;
7756 dgst_pos0 = 0;
7757 dgst_pos1 = 3;
7758 dgst_pos2 = 2;
7759 dgst_pos3 = 1;
7760 break;
7761
7762 case 100: hash_type = HASH_TYPE_SHA1;
7763 salt_type = SALT_TYPE_NONE;
7764 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7765 opts_type = OPTS_TYPE_PT_GENERATE_BE
7766 | OPTS_TYPE_PT_ADD80
7767 | OPTS_TYPE_PT_ADDBITS15;
7768 kern_type = KERN_TYPE_SHA1;
7769 dgst_size = DGST_SIZE_4_5;
7770 parse_func = sha1_parse_hash;
7771 sort_by_digest = sort_by_digest_4_5;
7772 opti_type = OPTI_TYPE_ZERO_BYTE
7773 | OPTI_TYPE_PRECOMPUTE_INIT
7774 | OPTI_TYPE_PRECOMPUTE_MERKLE
7775 | OPTI_TYPE_EARLY_SKIP
7776 | OPTI_TYPE_NOT_ITERATED
7777 | OPTI_TYPE_NOT_SALTED
7778 | OPTI_TYPE_RAW_HASH;
7779 dgst_pos0 = 3;
7780 dgst_pos1 = 4;
7781 dgst_pos2 = 2;
7782 dgst_pos3 = 1;
7783 break;
7784
7785 case 101: hash_type = HASH_TYPE_SHA1;
7786 salt_type = SALT_TYPE_NONE;
7787 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7788 opts_type = OPTS_TYPE_PT_GENERATE_BE
7789 | OPTS_TYPE_PT_ADD80
7790 | OPTS_TYPE_PT_ADDBITS15;
7791 kern_type = KERN_TYPE_SHA1;
7792 dgst_size = DGST_SIZE_4_5;
7793 parse_func = sha1b64_parse_hash;
7794 sort_by_digest = sort_by_digest_4_5;
7795 opti_type = OPTI_TYPE_ZERO_BYTE
7796 | OPTI_TYPE_PRECOMPUTE_INIT
7797 | OPTI_TYPE_PRECOMPUTE_MERKLE
7798 | OPTI_TYPE_EARLY_SKIP
7799 | OPTI_TYPE_NOT_ITERATED
7800 | OPTI_TYPE_NOT_SALTED
7801 | OPTI_TYPE_RAW_HASH;
7802 dgst_pos0 = 3;
7803 dgst_pos1 = 4;
7804 dgst_pos2 = 2;
7805 dgst_pos3 = 1;
7806 break;
7807
7808 case 110: hash_type = HASH_TYPE_SHA1;
7809 salt_type = SALT_TYPE_INTERN;
7810 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7811 opts_type = OPTS_TYPE_PT_GENERATE_BE
7812 | OPTS_TYPE_ST_ADD80
7813 | OPTS_TYPE_ST_ADDBITS15;
7814 kern_type = KERN_TYPE_SHA1_PWSLT;
7815 dgst_size = DGST_SIZE_4_5;
7816 parse_func = sha1s_parse_hash;
7817 sort_by_digest = sort_by_digest_4_5;
7818 opti_type = OPTI_TYPE_ZERO_BYTE
7819 | OPTI_TYPE_PRECOMPUTE_INIT
7820 | OPTI_TYPE_PRECOMPUTE_MERKLE
7821 | OPTI_TYPE_EARLY_SKIP
7822 | OPTI_TYPE_NOT_ITERATED
7823 | OPTI_TYPE_APPENDED_SALT
7824 | OPTI_TYPE_RAW_HASH;
7825 dgst_pos0 = 3;
7826 dgst_pos1 = 4;
7827 dgst_pos2 = 2;
7828 dgst_pos3 = 1;
7829 break;
7830
7831 case 111: hash_type = HASH_TYPE_SHA1;
7832 salt_type = SALT_TYPE_EMBEDDED;
7833 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7834 opts_type = OPTS_TYPE_PT_GENERATE_BE
7835 | OPTS_TYPE_ST_ADD80
7836 | OPTS_TYPE_ST_ADDBITS15;
7837 kern_type = KERN_TYPE_SHA1_PWSLT;
7838 dgst_size = DGST_SIZE_4_5;
7839 parse_func = sha1b64s_parse_hash;
7840 sort_by_digest = sort_by_digest_4_5;
7841 opti_type = OPTI_TYPE_ZERO_BYTE
7842 | OPTI_TYPE_PRECOMPUTE_INIT
7843 | OPTI_TYPE_PRECOMPUTE_MERKLE
7844 | OPTI_TYPE_EARLY_SKIP
7845 | OPTI_TYPE_NOT_ITERATED
7846 | OPTI_TYPE_APPENDED_SALT
7847 | OPTI_TYPE_RAW_HASH;
7848 dgst_pos0 = 3;
7849 dgst_pos1 = 4;
7850 dgst_pos2 = 2;
7851 dgst_pos3 = 1;
7852 break;
7853
7854 case 112: hash_type = HASH_TYPE_SHA1;
7855 salt_type = SALT_TYPE_INTERN;
7856 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7857 opts_type = OPTS_TYPE_PT_GENERATE_BE
7858 | OPTS_TYPE_ST_ADD80
7859 | OPTS_TYPE_ST_ADDBITS15
7860 | OPTS_TYPE_ST_HEX;
7861 kern_type = KERN_TYPE_SHA1_PWSLT;
7862 dgst_size = DGST_SIZE_4_5;
7863 parse_func = oracles_parse_hash;
7864 sort_by_digest = sort_by_digest_4_5;
7865 opti_type = OPTI_TYPE_ZERO_BYTE
7866 | OPTI_TYPE_PRECOMPUTE_INIT
7867 | OPTI_TYPE_PRECOMPUTE_MERKLE
7868 | OPTI_TYPE_EARLY_SKIP
7869 | OPTI_TYPE_NOT_ITERATED
7870 | OPTI_TYPE_APPENDED_SALT
7871 | OPTI_TYPE_RAW_HASH;
7872 dgst_pos0 = 3;
7873 dgst_pos1 = 4;
7874 dgst_pos2 = 2;
7875 dgst_pos3 = 1;
7876 break;
7877
7878 case 120: hash_type = HASH_TYPE_SHA1;
7879 salt_type = SALT_TYPE_INTERN;
7880 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7881 opts_type = OPTS_TYPE_PT_GENERATE_BE
7882 | OPTS_TYPE_PT_ADD80
7883 | OPTS_TYPE_PT_ADDBITS15;
7884 kern_type = KERN_TYPE_SHA1_SLTPW;
7885 dgst_size = DGST_SIZE_4_5;
7886 parse_func = sha1s_parse_hash;
7887 sort_by_digest = sort_by_digest_4_5;
7888 opti_type = OPTI_TYPE_ZERO_BYTE
7889 | OPTI_TYPE_PRECOMPUTE_INIT
7890 | OPTI_TYPE_PRECOMPUTE_MERKLE
7891 | OPTI_TYPE_EARLY_SKIP
7892 | OPTI_TYPE_NOT_ITERATED
7893 | OPTI_TYPE_PREPENDED_SALT
7894 | OPTI_TYPE_RAW_HASH;
7895 dgst_pos0 = 3;
7896 dgst_pos1 = 4;
7897 dgst_pos2 = 2;
7898 dgst_pos3 = 1;
7899 break;
7900
7901 case 121: hash_type = HASH_TYPE_SHA1;
7902 salt_type = SALT_TYPE_INTERN;
7903 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7904 opts_type = OPTS_TYPE_PT_GENERATE_BE
7905 | OPTS_TYPE_PT_ADD80
7906 | OPTS_TYPE_PT_ADDBITS15
7907 | OPTS_TYPE_ST_LOWER;
7908 kern_type = KERN_TYPE_SHA1_SLTPW;
7909 dgst_size = DGST_SIZE_4_5;
7910 parse_func = smf_parse_hash;
7911 sort_by_digest = sort_by_digest_4_5;
7912 opti_type = OPTI_TYPE_ZERO_BYTE
7913 | OPTI_TYPE_PRECOMPUTE_INIT
7914 | OPTI_TYPE_PRECOMPUTE_MERKLE
7915 | OPTI_TYPE_EARLY_SKIP
7916 | OPTI_TYPE_NOT_ITERATED
7917 | OPTI_TYPE_PREPENDED_SALT
7918 | OPTI_TYPE_RAW_HASH;
7919 dgst_pos0 = 3;
7920 dgst_pos1 = 4;
7921 dgst_pos2 = 2;
7922 dgst_pos3 = 1;
7923 break;
7924
7925 case 122: hash_type = HASH_TYPE_SHA1;
7926 salt_type = SALT_TYPE_EMBEDDED;
7927 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7928 opts_type = OPTS_TYPE_PT_GENERATE_BE
7929 | OPTS_TYPE_PT_ADD80
7930 | OPTS_TYPE_PT_ADDBITS15
7931 | OPTS_TYPE_ST_HEX;
7932 kern_type = KERN_TYPE_SHA1_SLTPW;
7933 dgst_size = DGST_SIZE_4_5;
7934 parse_func = osx1_parse_hash;
7935 sort_by_digest = sort_by_digest_4_5;
7936 opti_type = OPTI_TYPE_ZERO_BYTE
7937 | OPTI_TYPE_PRECOMPUTE_INIT
7938 | OPTI_TYPE_PRECOMPUTE_MERKLE
7939 | OPTI_TYPE_EARLY_SKIP
7940 | OPTI_TYPE_NOT_ITERATED
7941 | OPTI_TYPE_PREPENDED_SALT
7942 | OPTI_TYPE_RAW_HASH;
7943 dgst_pos0 = 3;
7944 dgst_pos1 = 4;
7945 dgst_pos2 = 2;
7946 dgst_pos3 = 1;
7947 break;
7948
7949 case 124: hash_type = HASH_TYPE_SHA1;
7950 salt_type = SALT_TYPE_EMBEDDED;
7951 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7952 opts_type = OPTS_TYPE_PT_GENERATE_BE
7953 | OPTS_TYPE_PT_ADD80
7954 | OPTS_TYPE_PT_ADDBITS15;
7955 kern_type = KERN_TYPE_SHA1_SLTPW;
7956 dgst_size = DGST_SIZE_4_5;
7957 parse_func = djangosha1_parse_hash;
7958 sort_by_digest = sort_by_digest_4_5;
7959 opti_type = OPTI_TYPE_ZERO_BYTE
7960 | OPTI_TYPE_PRECOMPUTE_INIT
7961 | OPTI_TYPE_PRECOMPUTE_MERKLE
7962 | OPTI_TYPE_EARLY_SKIP
7963 | OPTI_TYPE_NOT_ITERATED
7964 | OPTI_TYPE_PREPENDED_SALT
7965 | OPTI_TYPE_RAW_HASH;
7966 dgst_pos0 = 3;
7967 dgst_pos1 = 4;
7968 dgst_pos2 = 2;
7969 dgst_pos3 = 1;
7970 break;
7971
7972 case 125: hash_type = HASH_TYPE_SHA1;
7973 salt_type = SALT_TYPE_EMBEDDED;
7974 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7975 opts_type = OPTS_TYPE_PT_GENERATE_BE
7976 | OPTS_TYPE_PT_ADD80
7977 | OPTS_TYPE_PT_ADDBITS15
7978 | OPTS_TYPE_ST_HEX;
7979 kern_type = KERN_TYPE_SHA1_SLTPW;
7980 dgst_size = DGST_SIZE_4_5;
7981 parse_func = arubaos_parse_hash;
7982 sort_by_digest = sort_by_digest_4_5;
7983 opti_type = OPTI_TYPE_ZERO_BYTE
7984 | OPTI_TYPE_PRECOMPUTE_INIT
7985 | OPTI_TYPE_PRECOMPUTE_MERKLE
7986 | OPTI_TYPE_EARLY_SKIP
7987 | OPTI_TYPE_NOT_ITERATED
7988 | OPTI_TYPE_PREPENDED_SALT
7989 | OPTI_TYPE_RAW_HASH;
7990 dgst_pos0 = 3;
7991 dgst_pos1 = 4;
7992 dgst_pos2 = 2;
7993 dgst_pos3 = 1;
7994 break;
7995
7996 case 130: hash_type = HASH_TYPE_SHA1;
7997 salt_type = SALT_TYPE_INTERN;
7998 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7999 opts_type = OPTS_TYPE_PT_GENERATE_BE
8000 | OPTS_TYPE_PT_UNICODE
8001 | OPTS_TYPE_ST_ADD80
8002 | OPTS_TYPE_ST_ADDBITS15;
8003 kern_type = KERN_TYPE_SHA1_PWUSLT;
8004 dgst_size = DGST_SIZE_4_5;
8005 parse_func = sha1s_parse_hash;
8006 sort_by_digest = sort_by_digest_4_5;
8007 opti_type = OPTI_TYPE_ZERO_BYTE
8008 | OPTI_TYPE_PRECOMPUTE_INIT
8009 | OPTI_TYPE_PRECOMPUTE_MERKLE
8010 | OPTI_TYPE_EARLY_SKIP
8011 | OPTI_TYPE_NOT_ITERATED
8012 | OPTI_TYPE_APPENDED_SALT
8013 | OPTI_TYPE_RAW_HASH;
8014 dgst_pos0 = 3;
8015 dgst_pos1 = 4;
8016 dgst_pos2 = 2;
8017 dgst_pos3 = 1;
8018 break;
8019
8020 case 131: hash_type = HASH_TYPE_SHA1;
8021 salt_type = SALT_TYPE_EMBEDDED;
8022 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8023 opts_type = OPTS_TYPE_PT_GENERATE_BE
8024 | OPTS_TYPE_PT_UNICODE
8025 | OPTS_TYPE_PT_UPPER
8026 | OPTS_TYPE_ST_ADD80
8027 | OPTS_TYPE_ST_ADDBITS15
8028 | OPTS_TYPE_ST_HEX;
8029 kern_type = KERN_TYPE_SHA1_PWUSLT;
8030 dgst_size = DGST_SIZE_4_5;
8031 parse_func = mssql2000_parse_hash;
8032 sort_by_digest = sort_by_digest_4_5;
8033 opti_type = OPTI_TYPE_ZERO_BYTE
8034 | OPTI_TYPE_PRECOMPUTE_INIT
8035 | OPTI_TYPE_PRECOMPUTE_MERKLE
8036 | OPTI_TYPE_EARLY_SKIP
8037 | OPTI_TYPE_NOT_ITERATED
8038 | OPTI_TYPE_APPENDED_SALT
8039 | OPTI_TYPE_RAW_HASH;
8040 dgst_pos0 = 3;
8041 dgst_pos1 = 4;
8042 dgst_pos2 = 2;
8043 dgst_pos3 = 1;
8044 break;
8045
8046 case 132: hash_type = HASH_TYPE_SHA1;
8047 salt_type = SALT_TYPE_EMBEDDED;
8048 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8049 opts_type = OPTS_TYPE_PT_GENERATE_BE
8050 | OPTS_TYPE_PT_UNICODE
8051 | OPTS_TYPE_ST_ADD80
8052 | OPTS_TYPE_ST_ADDBITS15
8053 | OPTS_TYPE_ST_HEX;
8054 kern_type = KERN_TYPE_SHA1_PWUSLT;
8055 dgst_size = DGST_SIZE_4_5;
8056 parse_func = mssql2005_parse_hash;
8057 sort_by_digest = sort_by_digest_4_5;
8058 opti_type = OPTI_TYPE_ZERO_BYTE
8059 | OPTI_TYPE_PRECOMPUTE_INIT
8060 | OPTI_TYPE_PRECOMPUTE_MERKLE
8061 | OPTI_TYPE_EARLY_SKIP
8062 | OPTI_TYPE_NOT_ITERATED
8063 | OPTI_TYPE_APPENDED_SALT
8064 | OPTI_TYPE_RAW_HASH;
8065 dgst_pos0 = 3;
8066 dgst_pos1 = 4;
8067 dgst_pos2 = 2;
8068 dgst_pos3 = 1;
8069 break;
8070
8071 case 133: hash_type = HASH_TYPE_SHA1;
8072 salt_type = SALT_TYPE_EMBEDDED;
8073 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8074 opts_type = OPTS_TYPE_PT_GENERATE_BE
8075 | OPTS_TYPE_PT_UNICODE
8076 | OPTS_TYPE_ST_ADD80
8077 | OPTS_TYPE_ST_ADDBITS15;
8078 kern_type = KERN_TYPE_SHA1_PWUSLT;
8079 dgst_size = DGST_SIZE_4_5;
8080 parse_func = peoplesoft_parse_hash;
8081 sort_by_digest = sort_by_digest_4_5;
8082 opti_type = OPTI_TYPE_ZERO_BYTE
8083 | OPTI_TYPE_PRECOMPUTE_INIT
8084 | OPTI_TYPE_PRECOMPUTE_MERKLE
8085 | OPTI_TYPE_EARLY_SKIP
8086 | OPTI_TYPE_NOT_ITERATED
8087 | OPTI_TYPE_APPENDED_SALT
8088 | OPTI_TYPE_RAW_HASH;
8089 dgst_pos0 = 3;
8090 dgst_pos1 = 4;
8091 dgst_pos2 = 2;
8092 dgst_pos3 = 1;
8093 break;
8094
8095 case 140: hash_type = HASH_TYPE_SHA1;
8096 salt_type = SALT_TYPE_INTERN;
8097 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8098 opts_type = OPTS_TYPE_PT_GENERATE_BE
8099 | OPTS_TYPE_PT_ADD80
8100 | OPTS_TYPE_PT_ADDBITS15
8101 | OPTS_TYPE_PT_UNICODE;
8102 kern_type = KERN_TYPE_SHA1_SLTPWU;
8103 dgst_size = DGST_SIZE_4_5;
8104 parse_func = sha1s_parse_hash;
8105 sort_by_digest = sort_by_digest_4_5;
8106 opti_type = OPTI_TYPE_ZERO_BYTE
8107 | OPTI_TYPE_PRECOMPUTE_INIT
8108 | OPTI_TYPE_PRECOMPUTE_MERKLE
8109 | OPTI_TYPE_EARLY_SKIP
8110 | OPTI_TYPE_NOT_ITERATED
8111 | OPTI_TYPE_PREPENDED_SALT
8112 | OPTI_TYPE_RAW_HASH;
8113 dgst_pos0 = 3;
8114 dgst_pos1 = 4;
8115 dgst_pos2 = 2;
8116 dgst_pos3 = 1;
8117 break;
8118
8119 case 141: hash_type = HASH_TYPE_SHA1;
8120 salt_type = SALT_TYPE_EMBEDDED;
8121 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8122 opts_type = OPTS_TYPE_PT_GENERATE_BE
8123 | OPTS_TYPE_PT_ADD80
8124 | OPTS_TYPE_PT_ADDBITS15
8125 | OPTS_TYPE_PT_UNICODE
8126 | OPTS_TYPE_ST_BASE64;
8127 kern_type = KERN_TYPE_SHA1_SLTPWU;
8128 dgst_size = DGST_SIZE_4_5;
8129 parse_func = episerver_parse_hash;
8130 sort_by_digest = sort_by_digest_4_5;
8131 opti_type = OPTI_TYPE_ZERO_BYTE
8132 | OPTI_TYPE_PRECOMPUTE_INIT
8133 | OPTI_TYPE_PRECOMPUTE_MERKLE
8134 | OPTI_TYPE_EARLY_SKIP
8135 | OPTI_TYPE_NOT_ITERATED
8136 | OPTI_TYPE_PREPENDED_SALT
8137 | OPTI_TYPE_RAW_HASH;
8138 dgst_pos0 = 3;
8139 dgst_pos1 = 4;
8140 dgst_pos2 = 2;
8141 dgst_pos3 = 1;
8142 break;
8143
8144 case 150: hash_type = HASH_TYPE_SHA1;
8145 salt_type = SALT_TYPE_INTERN;
8146 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8147 opts_type = OPTS_TYPE_PT_GENERATE_BE
8148 | OPTS_TYPE_ST_ADD80
8149 | OPTS_TYPE_ST_ADDBITS15;
8150 kern_type = KERN_TYPE_HMACSHA1_PW;
8151 dgst_size = DGST_SIZE_4_5;
8152 parse_func = hmacsha1_parse_hash;
8153 sort_by_digest = sort_by_digest_4_5;
8154 opti_type = OPTI_TYPE_ZERO_BYTE
8155 | OPTI_TYPE_NOT_ITERATED;
8156 dgst_pos0 = 3;
8157 dgst_pos1 = 4;
8158 dgst_pos2 = 2;
8159 dgst_pos3 = 1;
8160 break;
8161
8162 case 160: hash_type = HASH_TYPE_SHA1;
8163 salt_type = SALT_TYPE_INTERN;
8164 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8165 opts_type = OPTS_TYPE_PT_GENERATE_BE
8166 | OPTS_TYPE_PT_ADD80
8167 | OPTS_TYPE_PT_ADDBITS15;
8168 kern_type = KERN_TYPE_HMACSHA1_SLT;
8169 dgst_size = DGST_SIZE_4_5;
8170 parse_func = hmacsha1_parse_hash;
8171 sort_by_digest = sort_by_digest_4_5;
8172 opti_type = OPTI_TYPE_ZERO_BYTE
8173 | OPTI_TYPE_NOT_ITERATED;
8174 dgst_pos0 = 3;
8175 dgst_pos1 = 4;
8176 dgst_pos2 = 2;
8177 dgst_pos3 = 1;
8178 break;
8179
8180 case 200: hash_type = HASH_TYPE_MYSQL;
8181 salt_type = SALT_TYPE_NONE;
8182 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8183 opts_type = 0;
8184 kern_type = KERN_TYPE_MYSQL;
8185 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8186 parse_func = mysql323_parse_hash;
8187 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8188 opti_type = OPTI_TYPE_ZERO_BYTE;
8189 dgst_pos0 = 0;
8190 dgst_pos1 = 1;
8191 dgst_pos2 = 2;
8192 dgst_pos3 = 3;
8193 break;
8194
8195 case 300: hash_type = HASH_TYPE_SHA1;
8196 salt_type = SALT_TYPE_NONE;
8197 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8198 opts_type = OPTS_TYPE_PT_GENERATE_BE
8199 | OPTS_TYPE_PT_ADD80
8200 | OPTS_TYPE_PT_ADDBITS15;
8201 kern_type = KERN_TYPE_MYSQL41;
8202 dgst_size = DGST_SIZE_4_5;
8203 parse_func = sha1_parse_hash;
8204 sort_by_digest = sort_by_digest_4_5;
8205 opti_type = OPTI_TYPE_ZERO_BYTE
8206 | OPTI_TYPE_PRECOMPUTE_INIT
8207 | OPTI_TYPE_PRECOMPUTE_MERKLE
8208 | OPTI_TYPE_EARLY_SKIP
8209 | OPTI_TYPE_NOT_ITERATED
8210 | OPTI_TYPE_NOT_SALTED;
8211 dgst_pos0 = 3;
8212 dgst_pos1 = 4;
8213 dgst_pos2 = 2;
8214 dgst_pos3 = 1;
8215 break;
8216
8217 case 400: hash_type = HASH_TYPE_MD5;
8218 salt_type = SALT_TYPE_EMBEDDED;
8219 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8220 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8221 kern_type = KERN_TYPE_PHPASS;
8222 dgst_size = DGST_SIZE_4_4;
8223 parse_func = phpass_parse_hash;
8224 sort_by_digest = sort_by_digest_4_4;
8225 opti_type = OPTI_TYPE_ZERO_BYTE
8226 | OPTI_TYPE_SLOW_HASH_SIMD;
8227 dgst_pos0 = 0;
8228 dgst_pos1 = 1;
8229 dgst_pos2 = 2;
8230 dgst_pos3 = 3;
8231 break;
8232
8233 case 500: hash_type = HASH_TYPE_MD5;
8234 salt_type = SALT_TYPE_EMBEDDED;
8235 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8236 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8237 kern_type = KERN_TYPE_MD5CRYPT;
8238 dgst_size = DGST_SIZE_4_4;
8239 parse_func = md5crypt_parse_hash;
8240 sort_by_digest = sort_by_digest_4_4;
8241 opti_type = OPTI_TYPE_ZERO_BYTE;
8242 dgst_pos0 = 0;
8243 dgst_pos1 = 1;
8244 dgst_pos2 = 2;
8245 dgst_pos3 = 3;
8246 break;
8247
8248 case 501: hash_type = HASH_TYPE_MD5;
8249 salt_type = SALT_TYPE_EMBEDDED;
8250 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8251 opts_type = OPTS_TYPE_PT_GENERATE_LE
8252 | OPTS_TYPE_HASH_COPY;
8253 kern_type = KERN_TYPE_MD5CRYPT;
8254 dgst_size = DGST_SIZE_4_4;
8255 parse_func = juniper_parse_hash;
8256 sort_by_digest = sort_by_digest_4_4;
8257 opti_type = OPTI_TYPE_ZERO_BYTE;
8258 dgst_pos0 = 0;
8259 dgst_pos1 = 1;
8260 dgst_pos2 = 2;
8261 dgst_pos3 = 3;
8262 break;
8263
8264 case 900: hash_type = HASH_TYPE_MD4;
8265 salt_type = SALT_TYPE_NONE;
8266 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8267 opts_type = OPTS_TYPE_PT_GENERATE_LE
8268 | OPTS_TYPE_PT_ADD80
8269 | OPTS_TYPE_PT_ADDBITS14;
8270 kern_type = KERN_TYPE_MD4;
8271 dgst_size = DGST_SIZE_4_4;
8272 parse_func = md4_parse_hash;
8273 sort_by_digest = sort_by_digest_4_4;
8274 opti_type = OPTI_TYPE_ZERO_BYTE
8275 | OPTI_TYPE_PRECOMPUTE_INIT
8276 | OPTI_TYPE_PRECOMPUTE_MERKLE
8277 | OPTI_TYPE_MEET_IN_MIDDLE
8278 | OPTI_TYPE_EARLY_SKIP
8279 | OPTI_TYPE_NOT_ITERATED
8280 | OPTI_TYPE_NOT_SALTED
8281 | OPTI_TYPE_RAW_HASH;
8282 dgst_pos0 = 0;
8283 dgst_pos1 = 3;
8284 dgst_pos2 = 2;
8285 dgst_pos3 = 1;
8286 break;
8287
8288 case 1000: hash_type = HASH_TYPE_MD4;
8289 salt_type = SALT_TYPE_NONE;
8290 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8291 opts_type = OPTS_TYPE_PT_GENERATE_LE
8292 | OPTS_TYPE_PT_ADD80
8293 | OPTS_TYPE_PT_ADDBITS14
8294 | OPTS_TYPE_PT_UNICODE;
8295 kern_type = KERN_TYPE_MD4_PWU;
8296 dgst_size = DGST_SIZE_4_4;
8297 parse_func = md4_parse_hash;
8298 sort_by_digest = sort_by_digest_4_4;
8299 opti_type = OPTI_TYPE_ZERO_BYTE
8300 | OPTI_TYPE_PRECOMPUTE_INIT
8301 | OPTI_TYPE_PRECOMPUTE_MERKLE
8302 | OPTI_TYPE_MEET_IN_MIDDLE
8303 | OPTI_TYPE_EARLY_SKIP
8304 | OPTI_TYPE_NOT_ITERATED
8305 | OPTI_TYPE_NOT_SALTED
8306 | OPTI_TYPE_RAW_HASH;
8307 dgst_pos0 = 0;
8308 dgst_pos1 = 3;
8309 dgst_pos2 = 2;
8310 dgst_pos3 = 1;
8311 break;
8312
8313 case 1100: hash_type = HASH_TYPE_MD4;
8314 salt_type = SALT_TYPE_INTERN;
8315 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8316 opts_type = OPTS_TYPE_PT_GENERATE_LE
8317 | OPTS_TYPE_PT_ADD80
8318 | OPTS_TYPE_PT_ADDBITS14
8319 | OPTS_TYPE_PT_UNICODE
8320 | OPTS_TYPE_ST_ADD80
8321 | OPTS_TYPE_ST_UNICODE
8322 | OPTS_TYPE_ST_LOWER;
8323 kern_type = KERN_TYPE_MD44_PWUSLT;
8324 dgst_size = DGST_SIZE_4_4;
8325 parse_func = dcc_parse_hash;
8326 sort_by_digest = sort_by_digest_4_4;
8327 opti_type = OPTI_TYPE_ZERO_BYTE
8328 | OPTI_TYPE_PRECOMPUTE_INIT
8329 | OPTI_TYPE_PRECOMPUTE_MERKLE
8330 | OPTI_TYPE_EARLY_SKIP
8331 | OPTI_TYPE_NOT_ITERATED;
8332 dgst_pos0 = 0;
8333 dgst_pos1 = 3;
8334 dgst_pos2 = 2;
8335 dgst_pos3 = 1;
8336 break;
8337
8338 case 1400: hash_type = HASH_TYPE_SHA256;
8339 salt_type = SALT_TYPE_NONE;
8340 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8341 opts_type = OPTS_TYPE_PT_GENERATE_BE
8342 | OPTS_TYPE_PT_ADD80
8343 | OPTS_TYPE_PT_ADDBITS15;
8344 kern_type = KERN_TYPE_SHA256;
8345 dgst_size = DGST_SIZE_4_8;
8346 parse_func = sha256_parse_hash;
8347 sort_by_digest = sort_by_digest_4_8;
8348 opti_type = OPTI_TYPE_ZERO_BYTE
8349 | OPTI_TYPE_PRECOMPUTE_INIT
8350 | OPTI_TYPE_PRECOMPUTE_MERKLE
8351 | OPTI_TYPE_EARLY_SKIP
8352 | OPTI_TYPE_NOT_ITERATED
8353 | OPTI_TYPE_NOT_SALTED
8354 | OPTI_TYPE_RAW_HASH;
8355 dgst_pos0 = 3;
8356 dgst_pos1 = 7;
8357 dgst_pos2 = 2;
8358 dgst_pos3 = 6;
8359 break;
8360
8361 case 1410: hash_type = HASH_TYPE_SHA256;
8362 salt_type = SALT_TYPE_INTERN;
8363 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8364 opts_type = OPTS_TYPE_PT_GENERATE_BE
8365 | OPTS_TYPE_ST_ADD80
8366 | OPTS_TYPE_ST_ADDBITS15;
8367 kern_type = KERN_TYPE_SHA256_PWSLT;
8368 dgst_size = DGST_SIZE_4_8;
8369 parse_func = sha256s_parse_hash;
8370 sort_by_digest = sort_by_digest_4_8;
8371 opti_type = OPTI_TYPE_ZERO_BYTE
8372 | OPTI_TYPE_PRECOMPUTE_INIT
8373 | OPTI_TYPE_PRECOMPUTE_MERKLE
8374 | OPTI_TYPE_EARLY_SKIP
8375 | OPTI_TYPE_NOT_ITERATED
8376 | OPTI_TYPE_APPENDED_SALT
8377 | OPTI_TYPE_RAW_HASH;
8378 dgst_pos0 = 3;
8379 dgst_pos1 = 7;
8380 dgst_pos2 = 2;
8381 dgst_pos3 = 6;
8382 break;
8383
8384 case 1420: hash_type = HASH_TYPE_SHA256;
8385 salt_type = SALT_TYPE_INTERN;
8386 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8387 opts_type = OPTS_TYPE_PT_GENERATE_BE
8388 | OPTS_TYPE_PT_ADD80
8389 | OPTS_TYPE_PT_ADDBITS15;
8390 kern_type = KERN_TYPE_SHA256_SLTPW;
8391 dgst_size = DGST_SIZE_4_8;
8392 parse_func = sha256s_parse_hash;
8393 sort_by_digest = sort_by_digest_4_8;
8394 opti_type = OPTI_TYPE_ZERO_BYTE
8395 | OPTI_TYPE_PRECOMPUTE_INIT
8396 | OPTI_TYPE_PRECOMPUTE_MERKLE
8397 | OPTI_TYPE_EARLY_SKIP
8398 | OPTI_TYPE_NOT_ITERATED
8399 | OPTI_TYPE_PREPENDED_SALT
8400 | OPTI_TYPE_RAW_HASH;
8401 dgst_pos0 = 3;
8402 dgst_pos1 = 7;
8403 dgst_pos2 = 2;
8404 dgst_pos3 = 6;
8405 break;
8406
8407 case 1421: hash_type = HASH_TYPE_SHA256;
8408 salt_type = SALT_TYPE_EMBEDDED;
8409 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8410 opts_type = OPTS_TYPE_PT_GENERATE_BE
8411 | OPTS_TYPE_PT_ADD80
8412 | OPTS_TYPE_PT_ADDBITS15;
8413 kern_type = KERN_TYPE_SHA256_SLTPW;
8414 dgst_size = DGST_SIZE_4_8;
8415 parse_func = hmailserver_parse_hash;
8416 sort_by_digest = sort_by_digest_4_8;
8417 opti_type = OPTI_TYPE_ZERO_BYTE
8418 | OPTI_TYPE_PRECOMPUTE_INIT
8419 | OPTI_TYPE_PRECOMPUTE_MERKLE
8420 | OPTI_TYPE_EARLY_SKIP
8421 | OPTI_TYPE_NOT_ITERATED
8422 | OPTI_TYPE_PREPENDED_SALT
8423 | OPTI_TYPE_RAW_HASH;
8424 dgst_pos0 = 3;
8425 dgst_pos1 = 7;
8426 dgst_pos2 = 2;
8427 dgst_pos3 = 6;
8428 break;
8429
8430 case 1430: hash_type = HASH_TYPE_SHA256;
8431 salt_type = SALT_TYPE_INTERN;
8432 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8433 opts_type = OPTS_TYPE_PT_GENERATE_BE
8434 | OPTS_TYPE_PT_UNICODE
8435 | OPTS_TYPE_ST_ADD80
8436 | OPTS_TYPE_ST_ADDBITS15;
8437 kern_type = KERN_TYPE_SHA256_PWUSLT;
8438 dgst_size = DGST_SIZE_4_8;
8439 parse_func = sha256s_parse_hash;
8440 sort_by_digest = sort_by_digest_4_8;
8441 opti_type = OPTI_TYPE_ZERO_BYTE
8442 | OPTI_TYPE_PRECOMPUTE_INIT
8443 | OPTI_TYPE_PRECOMPUTE_MERKLE
8444 | OPTI_TYPE_EARLY_SKIP
8445 | OPTI_TYPE_NOT_ITERATED
8446 | OPTI_TYPE_APPENDED_SALT
8447 | OPTI_TYPE_RAW_HASH;
8448 dgst_pos0 = 3;
8449 dgst_pos1 = 7;
8450 dgst_pos2 = 2;
8451 dgst_pos3 = 6;
8452 break;
8453
8454 case 1440: hash_type = HASH_TYPE_SHA256;
8455 salt_type = SALT_TYPE_INTERN;
8456 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8457 opts_type = OPTS_TYPE_PT_GENERATE_BE
8458 | OPTS_TYPE_PT_ADD80
8459 | OPTS_TYPE_PT_ADDBITS15
8460 | OPTS_TYPE_PT_UNICODE;
8461 kern_type = KERN_TYPE_SHA256_SLTPWU;
8462 dgst_size = DGST_SIZE_4_8;
8463 parse_func = sha256s_parse_hash;
8464 sort_by_digest = sort_by_digest_4_8;
8465 opti_type = OPTI_TYPE_ZERO_BYTE
8466 | OPTI_TYPE_PRECOMPUTE_INIT
8467 | OPTI_TYPE_PRECOMPUTE_MERKLE
8468 | OPTI_TYPE_EARLY_SKIP
8469 | OPTI_TYPE_NOT_ITERATED
8470 | OPTI_TYPE_PREPENDED_SALT
8471 | OPTI_TYPE_RAW_HASH;
8472 dgst_pos0 = 3;
8473 dgst_pos1 = 7;
8474 dgst_pos2 = 2;
8475 dgst_pos3 = 6;
8476 break;
8477
8478 case 1441: hash_type = HASH_TYPE_SHA256;
8479 salt_type = SALT_TYPE_EMBEDDED;
8480 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8481 opts_type = OPTS_TYPE_PT_GENERATE_BE
8482 | OPTS_TYPE_PT_ADD80
8483 | OPTS_TYPE_PT_ADDBITS15
8484 | OPTS_TYPE_PT_UNICODE
8485 | OPTS_TYPE_ST_BASE64;
8486 kern_type = KERN_TYPE_SHA256_SLTPWU;
8487 dgst_size = DGST_SIZE_4_8;
8488 parse_func = episerver4_parse_hash;
8489 sort_by_digest = sort_by_digest_4_8;
8490 opti_type = OPTI_TYPE_ZERO_BYTE
8491 | OPTI_TYPE_PRECOMPUTE_INIT
8492 | OPTI_TYPE_PRECOMPUTE_MERKLE
8493 | OPTI_TYPE_EARLY_SKIP
8494 | OPTI_TYPE_NOT_ITERATED
8495 | OPTI_TYPE_PREPENDED_SALT
8496 | OPTI_TYPE_RAW_HASH;
8497 dgst_pos0 = 3;
8498 dgst_pos1 = 7;
8499 dgst_pos2 = 2;
8500 dgst_pos3 = 6;
8501 break;
8502
8503 case 1450: hash_type = HASH_TYPE_SHA256;
8504 salt_type = SALT_TYPE_INTERN;
8505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8506 opts_type = OPTS_TYPE_PT_GENERATE_BE
8507 | OPTS_TYPE_ST_ADD80;
8508 kern_type = KERN_TYPE_HMACSHA256_PW;
8509 dgst_size = DGST_SIZE_4_8;
8510 parse_func = hmacsha256_parse_hash;
8511 sort_by_digest = sort_by_digest_4_8;
8512 opti_type = OPTI_TYPE_ZERO_BYTE
8513 | OPTI_TYPE_NOT_ITERATED;
8514 dgst_pos0 = 3;
8515 dgst_pos1 = 7;
8516 dgst_pos2 = 2;
8517 dgst_pos3 = 6;
8518 break;
8519
8520 case 1460: hash_type = HASH_TYPE_SHA256;
8521 salt_type = SALT_TYPE_INTERN;
8522 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8523 opts_type = OPTS_TYPE_PT_GENERATE_BE
8524 | OPTS_TYPE_PT_ADD80
8525 | OPTS_TYPE_PT_ADDBITS15;
8526 kern_type = KERN_TYPE_HMACSHA256_SLT;
8527 dgst_size = DGST_SIZE_4_8;
8528 parse_func = hmacsha256_parse_hash;
8529 sort_by_digest = sort_by_digest_4_8;
8530 opti_type = OPTI_TYPE_ZERO_BYTE
8531 | OPTI_TYPE_NOT_ITERATED;
8532 dgst_pos0 = 3;
8533 dgst_pos1 = 7;
8534 dgst_pos2 = 2;
8535 dgst_pos3 = 6;
8536 break;
8537
8538 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8539 salt_type = SALT_TYPE_EMBEDDED;
8540 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8541 opts_type = OPTS_TYPE_PT_GENERATE_LE
8542 | OPTS_TYPE_PT_BITSLICE;
8543 kern_type = KERN_TYPE_DESCRYPT;
8544 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8545 parse_func = descrypt_parse_hash;
8546 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8547 opti_type = OPTI_TYPE_ZERO_BYTE
8548 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8549 dgst_pos0 = 0;
8550 dgst_pos1 = 1;
8551 dgst_pos2 = 2;
8552 dgst_pos3 = 3;
8553 break;
8554
8555 case 1600: hash_type = HASH_TYPE_MD5;
8556 salt_type = SALT_TYPE_EMBEDDED;
8557 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8558 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8559 kern_type = KERN_TYPE_APR1CRYPT;
8560 dgst_size = DGST_SIZE_4_4;
8561 parse_func = md5apr1_parse_hash;
8562 sort_by_digest = sort_by_digest_4_4;
8563 opti_type = OPTI_TYPE_ZERO_BYTE;
8564 dgst_pos0 = 0;
8565 dgst_pos1 = 1;
8566 dgst_pos2 = 2;
8567 dgst_pos3 = 3;
8568 break;
8569
8570 case 1700: hash_type = HASH_TYPE_SHA512;
8571 salt_type = SALT_TYPE_NONE;
8572 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8573 opts_type = OPTS_TYPE_PT_GENERATE_BE
8574 | OPTS_TYPE_PT_ADD80
8575 | OPTS_TYPE_PT_ADDBITS15;
8576 kern_type = KERN_TYPE_SHA512;
8577 dgst_size = DGST_SIZE_8_8;
8578 parse_func = sha512_parse_hash;
8579 sort_by_digest = sort_by_digest_8_8;
8580 opti_type = OPTI_TYPE_ZERO_BYTE
8581 | OPTI_TYPE_PRECOMPUTE_INIT
8582 | OPTI_TYPE_PRECOMPUTE_MERKLE
8583 | OPTI_TYPE_EARLY_SKIP
8584 | OPTI_TYPE_NOT_ITERATED
8585 | OPTI_TYPE_NOT_SALTED
8586 | OPTI_TYPE_USES_BITS_64
8587 | OPTI_TYPE_RAW_HASH;
8588 dgst_pos0 = 14;
8589 dgst_pos1 = 15;
8590 dgst_pos2 = 6;
8591 dgst_pos3 = 7;
8592 break;
8593
8594 case 1710: hash_type = HASH_TYPE_SHA512;
8595 salt_type = SALT_TYPE_INTERN;
8596 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8597 opts_type = OPTS_TYPE_PT_GENERATE_BE
8598 | OPTS_TYPE_ST_ADD80
8599 | OPTS_TYPE_ST_ADDBITS15;
8600 kern_type = KERN_TYPE_SHA512_PWSLT;
8601 dgst_size = DGST_SIZE_8_8;
8602 parse_func = sha512s_parse_hash;
8603 sort_by_digest = sort_by_digest_8_8;
8604 opti_type = OPTI_TYPE_ZERO_BYTE
8605 | OPTI_TYPE_PRECOMPUTE_INIT
8606 | OPTI_TYPE_PRECOMPUTE_MERKLE
8607 | OPTI_TYPE_EARLY_SKIP
8608 | OPTI_TYPE_NOT_ITERATED
8609 | OPTI_TYPE_APPENDED_SALT
8610 | OPTI_TYPE_USES_BITS_64
8611 | OPTI_TYPE_RAW_HASH;
8612 dgst_pos0 = 14;
8613 dgst_pos1 = 15;
8614 dgst_pos2 = 6;
8615 dgst_pos3 = 7;
8616 break;
8617
8618 case 1711: hash_type = HASH_TYPE_SHA512;
8619 salt_type = SALT_TYPE_EMBEDDED;
8620 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8621 opts_type = OPTS_TYPE_PT_GENERATE_BE
8622 | OPTS_TYPE_ST_ADD80
8623 | OPTS_TYPE_ST_ADDBITS15;
8624 kern_type = KERN_TYPE_SHA512_PWSLT;
8625 dgst_size = DGST_SIZE_8_8;
8626 parse_func = sha512b64s_parse_hash;
8627 sort_by_digest = sort_by_digest_8_8;
8628 opti_type = OPTI_TYPE_ZERO_BYTE
8629 | OPTI_TYPE_PRECOMPUTE_INIT
8630 | OPTI_TYPE_PRECOMPUTE_MERKLE
8631 | OPTI_TYPE_EARLY_SKIP
8632 | OPTI_TYPE_NOT_ITERATED
8633 | OPTI_TYPE_APPENDED_SALT
8634 | OPTI_TYPE_USES_BITS_64
8635 | OPTI_TYPE_RAW_HASH;
8636 dgst_pos0 = 14;
8637 dgst_pos1 = 15;
8638 dgst_pos2 = 6;
8639 dgst_pos3 = 7;
8640 break;
8641
8642 case 1720: hash_type = HASH_TYPE_SHA512;
8643 salt_type = SALT_TYPE_INTERN;
8644 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8645 opts_type = OPTS_TYPE_PT_GENERATE_BE
8646 | OPTS_TYPE_PT_ADD80
8647 | OPTS_TYPE_PT_ADDBITS15;
8648 kern_type = KERN_TYPE_SHA512_SLTPW;
8649 dgst_size = DGST_SIZE_8_8;
8650 parse_func = sha512s_parse_hash;
8651 sort_by_digest = sort_by_digest_8_8;
8652 opti_type = OPTI_TYPE_ZERO_BYTE
8653 | OPTI_TYPE_PRECOMPUTE_INIT
8654 | OPTI_TYPE_PRECOMPUTE_MERKLE
8655 | OPTI_TYPE_EARLY_SKIP
8656 | OPTI_TYPE_NOT_ITERATED
8657 | OPTI_TYPE_PREPENDED_SALT
8658 | OPTI_TYPE_USES_BITS_64
8659 | OPTI_TYPE_RAW_HASH;
8660 dgst_pos0 = 14;
8661 dgst_pos1 = 15;
8662 dgst_pos2 = 6;
8663 dgst_pos3 = 7;
8664 break;
8665
8666 case 1722: hash_type = HASH_TYPE_SHA512;
8667 salt_type = SALT_TYPE_EMBEDDED;
8668 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8669 opts_type = OPTS_TYPE_PT_GENERATE_BE
8670 | OPTS_TYPE_PT_ADD80
8671 | OPTS_TYPE_PT_ADDBITS15
8672 | OPTS_TYPE_ST_HEX;
8673 kern_type = KERN_TYPE_SHA512_SLTPW;
8674 dgst_size = DGST_SIZE_8_8;
8675 parse_func = osx512_parse_hash;
8676 sort_by_digest = sort_by_digest_8_8;
8677 opti_type = OPTI_TYPE_ZERO_BYTE
8678 | OPTI_TYPE_PRECOMPUTE_INIT
8679 | OPTI_TYPE_PRECOMPUTE_MERKLE
8680 | OPTI_TYPE_EARLY_SKIP
8681 | OPTI_TYPE_NOT_ITERATED
8682 | OPTI_TYPE_PREPENDED_SALT
8683 | OPTI_TYPE_USES_BITS_64
8684 | OPTI_TYPE_RAW_HASH;
8685 dgst_pos0 = 14;
8686 dgst_pos1 = 15;
8687 dgst_pos2 = 6;
8688 dgst_pos3 = 7;
8689 break;
8690
8691 case 1730: hash_type = HASH_TYPE_SHA512;
8692 salt_type = SALT_TYPE_INTERN;
8693 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8694 opts_type = OPTS_TYPE_PT_GENERATE_BE
8695 | OPTS_TYPE_PT_UNICODE
8696 | OPTS_TYPE_ST_ADD80
8697 | OPTS_TYPE_ST_ADDBITS15;
8698 kern_type = KERN_TYPE_SHA512_PWSLTU;
8699 dgst_size = DGST_SIZE_8_8;
8700 parse_func = sha512s_parse_hash;
8701 sort_by_digest = sort_by_digest_8_8;
8702 opti_type = OPTI_TYPE_ZERO_BYTE
8703 | OPTI_TYPE_PRECOMPUTE_INIT
8704 | OPTI_TYPE_PRECOMPUTE_MERKLE
8705 | OPTI_TYPE_EARLY_SKIP
8706 | OPTI_TYPE_NOT_ITERATED
8707 | OPTI_TYPE_APPENDED_SALT
8708 | OPTI_TYPE_USES_BITS_64
8709 | OPTI_TYPE_RAW_HASH;
8710 dgst_pos0 = 14;
8711 dgst_pos1 = 15;
8712 dgst_pos2 = 6;
8713 dgst_pos3 = 7;
8714 break;
8715
8716 case 1731: hash_type = HASH_TYPE_SHA512;
8717 salt_type = SALT_TYPE_EMBEDDED;
8718 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8719 opts_type = OPTS_TYPE_PT_GENERATE_BE
8720 | OPTS_TYPE_PT_UNICODE
8721 | OPTS_TYPE_ST_ADD80
8722 | OPTS_TYPE_ST_ADDBITS15
8723 | OPTS_TYPE_ST_HEX;
8724 kern_type = KERN_TYPE_SHA512_PWSLTU;
8725 dgst_size = DGST_SIZE_8_8;
8726 parse_func = mssql2012_parse_hash;
8727 sort_by_digest = sort_by_digest_8_8;
8728 opti_type = OPTI_TYPE_ZERO_BYTE
8729 | OPTI_TYPE_PRECOMPUTE_INIT
8730 | OPTI_TYPE_PRECOMPUTE_MERKLE
8731 | OPTI_TYPE_EARLY_SKIP
8732 | OPTI_TYPE_NOT_ITERATED
8733 | OPTI_TYPE_APPENDED_SALT
8734 | OPTI_TYPE_USES_BITS_64
8735 | OPTI_TYPE_RAW_HASH;
8736 dgst_pos0 = 14;
8737 dgst_pos1 = 15;
8738 dgst_pos2 = 6;
8739 dgst_pos3 = 7;
8740 break;
8741
8742 case 1740: hash_type = HASH_TYPE_SHA512;
8743 salt_type = SALT_TYPE_INTERN;
8744 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8745 opts_type = OPTS_TYPE_PT_GENERATE_BE
8746 | OPTS_TYPE_PT_ADD80
8747 | OPTS_TYPE_PT_ADDBITS15
8748 | OPTS_TYPE_PT_UNICODE;
8749 kern_type = KERN_TYPE_SHA512_SLTPWU;
8750 dgst_size = DGST_SIZE_8_8;
8751 parse_func = sha512s_parse_hash;
8752 sort_by_digest = sort_by_digest_8_8;
8753 opti_type = OPTI_TYPE_ZERO_BYTE
8754 | OPTI_TYPE_PRECOMPUTE_INIT
8755 | OPTI_TYPE_PRECOMPUTE_MERKLE
8756 | OPTI_TYPE_EARLY_SKIP
8757 | OPTI_TYPE_NOT_ITERATED
8758 | OPTI_TYPE_PREPENDED_SALT
8759 | OPTI_TYPE_USES_BITS_64
8760 | OPTI_TYPE_RAW_HASH;
8761 dgst_pos0 = 14;
8762 dgst_pos1 = 15;
8763 dgst_pos2 = 6;
8764 dgst_pos3 = 7;
8765 break;
8766
8767 case 1750: hash_type = HASH_TYPE_SHA512;
8768 salt_type = SALT_TYPE_INTERN;
8769 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8770 opts_type = OPTS_TYPE_PT_GENERATE_BE
8771 | OPTS_TYPE_ST_ADD80;
8772 kern_type = KERN_TYPE_HMACSHA512_PW;
8773 dgst_size = DGST_SIZE_8_8;
8774 parse_func = hmacsha512_parse_hash;
8775 sort_by_digest = sort_by_digest_8_8;
8776 opti_type = OPTI_TYPE_ZERO_BYTE
8777 | OPTI_TYPE_USES_BITS_64
8778 | OPTI_TYPE_NOT_ITERATED;
8779 dgst_pos0 = 14;
8780 dgst_pos1 = 15;
8781 dgst_pos2 = 6;
8782 dgst_pos3 = 7;
8783 break;
8784
8785 case 1760: hash_type = HASH_TYPE_SHA512;
8786 salt_type = SALT_TYPE_INTERN;
8787 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8788 opts_type = OPTS_TYPE_PT_GENERATE_BE
8789 | OPTS_TYPE_PT_ADD80
8790 | OPTS_TYPE_PT_ADDBITS15;
8791 kern_type = KERN_TYPE_HMACSHA512_SLT;
8792 dgst_size = DGST_SIZE_8_8;
8793 parse_func = hmacsha512_parse_hash;
8794 sort_by_digest = sort_by_digest_8_8;
8795 opti_type = OPTI_TYPE_ZERO_BYTE
8796 | OPTI_TYPE_USES_BITS_64
8797 | OPTI_TYPE_NOT_ITERATED;
8798 dgst_pos0 = 14;
8799 dgst_pos1 = 15;
8800 dgst_pos2 = 6;
8801 dgst_pos3 = 7;
8802 break;
8803
8804 case 1800: hash_type = HASH_TYPE_SHA512;
8805 salt_type = SALT_TYPE_EMBEDDED;
8806 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8807 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8808 kern_type = KERN_TYPE_SHA512CRYPT;
8809 dgst_size = DGST_SIZE_8_8;
8810 parse_func = sha512crypt_parse_hash;
8811 sort_by_digest = sort_by_digest_8_8;
8812 opti_type = OPTI_TYPE_ZERO_BYTE
8813 | OPTI_TYPE_USES_BITS_64;
8814 dgst_pos0 = 0;
8815 dgst_pos1 = 1;
8816 dgst_pos2 = 2;
8817 dgst_pos3 = 3;
8818 break;
8819
8820 case 2000: hash_type = HASH_TYPE_STDOUT;
8821 salt_type = SALT_TYPE_NONE;
8822 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8823 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8824 kern_type = KERN_TYPE_STDOUT;
8825 dgst_size = DGST_SIZE_4_4;
8826 parse_func = NULL;
8827 sort_by_digest = NULL;
8828 opti_type = 0;
8829 dgst_pos0 = 0;
8830 dgst_pos1 = 0;
8831 dgst_pos2 = 0;
8832 dgst_pos3 = 0;
8833 break;
8834
8835 case 2100: hash_type = HASH_TYPE_DCC2;
8836 salt_type = SALT_TYPE_EMBEDDED;
8837 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8838 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8839 | OPTS_TYPE_ST_LOWER
8840 | OPTS_TYPE_ST_UNICODE;
8841 kern_type = KERN_TYPE_DCC2;
8842 dgst_size = DGST_SIZE_4_4;
8843 parse_func = dcc2_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 2400: hash_type = HASH_TYPE_MD5;
8854 salt_type = SALT_TYPE_NONE;
8855 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8856 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8857 kern_type = KERN_TYPE_MD5PIX;
8858 dgst_size = DGST_SIZE_4_4;
8859 parse_func = md5pix_parse_hash;
8860 sort_by_digest = sort_by_digest_4_4;
8861 opti_type = OPTI_TYPE_ZERO_BYTE
8862 | OPTI_TYPE_PRECOMPUTE_INIT
8863 | OPTI_TYPE_PRECOMPUTE_MERKLE
8864 | OPTI_TYPE_EARLY_SKIP
8865 | OPTI_TYPE_NOT_ITERATED
8866 | OPTI_TYPE_NOT_SALTED;
8867 dgst_pos0 = 0;
8868 dgst_pos1 = 3;
8869 dgst_pos2 = 2;
8870 dgst_pos3 = 1;
8871 break;
8872
8873 case 2410: hash_type = HASH_TYPE_MD5;
8874 salt_type = SALT_TYPE_INTERN;
8875 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8876 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8877 kern_type = KERN_TYPE_MD5ASA;
8878 dgst_size = DGST_SIZE_4_4;
8879 parse_func = md5asa_parse_hash;
8880 sort_by_digest = sort_by_digest_4_4;
8881 opti_type = OPTI_TYPE_ZERO_BYTE
8882 | OPTI_TYPE_PRECOMPUTE_INIT
8883 | OPTI_TYPE_PRECOMPUTE_MERKLE
8884 | OPTI_TYPE_EARLY_SKIP
8885 | OPTI_TYPE_NOT_ITERATED;
8886 dgst_pos0 = 0;
8887 dgst_pos1 = 3;
8888 dgst_pos2 = 2;
8889 dgst_pos3 = 1;
8890 break;
8891
8892 case 2500: hash_type = HASH_TYPE_WPA;
8893 salt_type = SALT_TYPE_EMBEDDED;
8894 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8895 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8896 kern_type = KERN_TYPE_WPA;
8897 dgst_size = DGST_SIZE_4_4;
8898 parse_func = wpa_parse_hash;
8899 sort_by_digest = sort_by_digest_4_4;
8900 opti_type = OPTI_TYPE_ZERO_BYTE
8901 | OPTI_TYPE_SLOW_HASH_SIMD;
8902 dgst_pos0 = 0;
8903 dgst_pos1 = 1;
8904 dgst_pos2 = 2;
8905 dgst_pos3 = 3;
8906 break;
8907
8908 case 2600: hash_type = HASH_TYPE_MD5;
8909 salt_type = SALT_TYPE_VIRTUAL;
8910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8911 opts_type = OPTS_TYPE_PT_GENERATE_LE
8912 | OPTS_TYPE_PT_ADD80
8913 | OPTS_TYPE_PT_ADDBITS14
8914 | OPTS_TYPE_ST_ADD80;
8915 kern_type = KERN_TYPE_MD55_PWSLT1;
8916 dgst_size = DGST_SIZE_4_4;
8917 parse_func = md5md5_parse_hash;
8918 sort_by_digest = sort_by_digest_4_4;
8919 opti_type = OPTI_TYPE_ZERO_BYTE
8920 | OPTI_TYPE_PRECOMPUTE_INIT
8921 | OPTI_TYPE_PRECOMPUTE_MERKLE
8922 | OPTI_TYPE_EARLY_SKIP;
8923 dgst_pos0 = 0;
8924 dgst_pos1 = 3;
8925 dgst_pos2 = 2;
8926 dgst_pos3 = 1;
8927 break;
8928
8929 case 2611: hash_type = HASH_TYPE_MD5;
8930 salt_type = SALT_TYPE_INTERN;
8931 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8932 opts_type = OPTS_TYPE_PT_GENERATE_LE
8933 | OPTS_TYPE_PT_ADD80
8934 | OPTS_TYPE_PT_ADDBITS14
8935 | OPTS_TYPE_ST_ADD80;
8936 kern_type = KERN_TYPE_MD55_PWSLT1;
8937 dgst_size = DGST_SIZE_4_4;
8938 parse_func = vb3_parse_hash;
8939 sort_by_digest = sort_by_digest_4_4;
8940 opti_type = OPTI_TYPE_ZERO_BYTE
8941 | OPTI_TYPE_PRECOMPUTE_INIT
8942 | OPTI_TYPE_PRECOMPUTE_MERKLE
8943 | OPTI_TYPE_EARLY_SKIP;
8944 dgst_pos0 = 0;
8945 dgst_pos1 = 3;
8946 dgst_pos2 = 2;
8947 dgst_pos3 = 1;
8948 break;
8949
8950 case 2612: hash_type = HASH_TYPE_MD5;
8951 salt_type = SALT_TYPE_EMBEDDED;
8952 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8953 opts_type = OPTS_TYPE_PT_GENERATE_LE
8954 | OPTS_TYPE_PT_ADD80
8955 | OPTS_TYPE_PT_ADDBITS14
8956 | OPTS_TYPE_ST_ADD80
8957 | OPTS_TYPE_ST_HEX;
8958 kern_type = KERN_TYPE_MD55_PWSLT1;
8959 dgst_size = DGST_SIZE_4_4;
8960 parse_func = phps_parse_hash;
8961 sort_by_digest = sort_by_digest_4_4;
8962 opti_type = OPTI_TYPE_ZERO_BYTE
8963 | OPTI_TYPE_PRECOMPUTE_INIT
8964 | OPTI_TYPE_PRECOMPUTE_MERKLE
8965 | OPTI_TYPE_EARLY_SKIP;
8966 dgst_pos0 = 0;
8967 dgst_pos1 = 3;
8968 dgst_pos2 = 2;
8969 dgst_pos3 = 1;
8970 break;
8971
8972 case 2711: hash_type = HASH_TYPE_MD5;
8973 salt_type = SALT_TYPE_INTERN;
8974 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8975 opts_type = OPTS_TYPE_PT_GENERATE_LE
8976 | OPTS_TYPE_PT_ADD80
8977 | OPTS_TYPE_PT_ADDBITS14
8978 | OPTS_TYPE_ST_ADD80;
8979 kern_type = KERN_TYPE_MD55_PWSLT2;
8980 dgst_size = DGST_SIZE_4_4;
8981 parse_func = vb30_parse_hash;
8982 sort_by_digest = sort_by_digest_4_4;
8983 opti_type = OPTI_TYPE_ZERO_BYTE
8984 | OPTI_TYPE_PRECOMPUTE_INIT
8985 | OPTI_TYPE_EARLY_SKIP;
8986 dgst_pos0 = 0;
8987 dgst_pos1 = 3;
8988 dgst_pos2 = 2;
8989 dgst_pos3 = 1;
8990 break;
8991
8992 case 2811: hash_type = HASH_TYPE_MD5;
8993 salt_type = SALT_TYPE_INTERN;
8994 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8995 opts_type = OPTS_TYPE_PT_GENERATE_LE
8996 | OPTS_TYPE_PT_ADD80
8997 | OPTS_TYPE_PT_ADDBITS14;
8998 kern_type = KERN_TYPE_MD55_SLTPW;
8999 dgst_size = DGST_SIZE_4_4;
9000 parse_func = ipb2_parse_hash;
9001 sort_by_digest = sort_by_digest_4_4;
9002 opti_type = OPTI_TYPE_ZERO_BYTE
9003 | OPTI_TYPE_PRECOMPUTE_INIT
9004 | OPTI_TYPE_EARLY_SKIP;
9005 dgst_pos0 = 0;
9006 dgst_pos1 = 3;
9007 dgst_pos2 = 2;
9008 dgst_pos3 = 1;
9009 break;
9010
9011 case 3000: hash_type = HASH_TYPE_LM;
9012 salt_type = SALT_TYPE_NONE;
9013 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9014 opts_type = OPTS_TYPE_PT_GENERATE_LE
9015 | OPTS_TYPE_PT_UPPER
9016 | OPTS_TYPE_PT_BITSLICE;
9017 kern_type = KERN_TYPE_LM;
9018 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9019 parse_func = lm_parse_hash;
9020 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9021 opti_type = OPTI_TYPE_ZERO_BYTE
9022 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9023 dgst_pos0 = 0;
9024 dgst_pos1 = 1;
9025 dgst_pos2 = 2;
9026 dgst_pos3 = 3;
9027 break;
9028
9029 case 3100: hash_type = HASH_TYPE_ORACLEH;
9030 salt_type = SALT_TYPE_INTERN;
9031 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9032 opts_type = OPTS_TYPE_PT_GENERATE_LE
9033 | OPTS_TYPE_PT_UPPER
9034 | OPTS_TYPE_ST_UPPER;
9035 kern_type = KERN_TYPE_ORACLEH;
9036 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9037 parse_func = oracleh_parse_hash;
9038 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9039 opti_type = OPTI_TYPE_ZERO_BYTE;
9040 dgst_pos0 = 0;
9041 dgst_pos1 = 1;
9042 dgst_pos2 = 2;
9043 dgst_pos3 = 3;
9044 break;
9045
9046 case 3200: hash_type = HASH_TYPE_BCRYPT;
9047 salt_type = SALT_TYPE_EMBEDDED;
9048 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9049 opts_type = OPTS_TYPE_PT_GENERATE_LE
9050 | OPTS_TYPE_ST_GENERATE_LE;
9051 kern_type = KERN_TYPE_BCRYPT;
9052 dgst_size = DGST_SIZE_4_6;
9053 parse_func = bcrypt_parse_hash;
9054 sort_by_digest = sort_by_digest_4_6;
9055 opti_type = OPTI_TYPE_ZERO_BYTE;
9056 dgst_pos0 = 0;
9057 dgst_pos1 = 1;
9058 dgst_pos2 = 2;
9059 dgst_pos3 = 3;
9060 break;
9061
9062 case 3710: hash_type = HASH_TYPE_MD5;
9063 salt_type = SALT_TYPE_INTERN;
9064 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9065 opts_type = OPTS_TYPE_PT_GENERATE_LE
9066 | OPTS_TYPE_PT_ADD80
9067 | OPTS_TYPE_PT_ADDBITS14;
9068 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9069 dgst_size = DGST_SIZE_4_4;
9070 parse_func = md5s_parse_hash;
9071 sort_by_digest = sort_by_digest_4_4;
9072 opti_type = OPTI_TYPE_ZERO_BYTE
9073 | OPTI_TYPE_PRECOMPUTE_INIT
9074 | OPTI_TYPE_PRECOMPUTE_MERKLE
9075 | OPTI_TYPE_EARLY_SKIP;
9076 dgst_pos0 = 0;
9077 dgst_pos1 = 3;
9078 dgst_pos2 = 2;
9079 dgst_pos3 = 1;
9080 break;
9081
9082 case 3711: hash_type = HASH_TYPE_MD5;
9083 salt_type = SALT_TYPE_EMBEDDED;
9084 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9085 opts_type = OPTS_TYPE_PT_GENERATE_LE
9086 | OPTS_TYPE_PT_ADD80
9087 | OPTS_TYPE_PT_ADDBITS14;
9088 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9089 dgst_size = DGST_SIZE_4_4;
9090 parse_func = mediawiki_b_parse_hash;
9091 sort_by_digest = sort_by_digest_4_4;
9092 opti_type = OPTI_TYPE_ZERO_BYTE
9093 | OPTI_TYPE_PRECOMPUTE_INIT
9094 | OPTI_TYPE_PRECOMPUTE_MERKLE
9095 | OPTI_TYPE_EARLY_SKIP;
9096 dgst_pos0 = 0;
9097 dgst_pos1 = 3;
9098 dgst_pos2 = 2;
9099 dgst_pos3 = 1;
9100 break;
9101
9102 case 3800: hash_type = HASH_TYPE_MD5;
9103 salt_type = SALT_TYPE_INTERN;
9104 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9105 opts_type = OPTS_TYPE_PT_GENERATE_LE
9106 | OPTS_TYPE_ST_ADDBITS14;
9107 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
9108 dgst_size = DGST_SIZE_4_4;
9109 parse_func = md5s_parse_hash;
9110 sort_by_digest = sort_by_digest_4_4;
9111 opti_type = OPTI_TYPE_ZERO_BYTE
9112 | OPTI_TYPE_PRECOMPUTE_INIT
9113 | OPTI_TYPE_PRECOMPUTE_MERKLE
9114 | OPTI_TYPE_EARLY_SKIP
9115 | OPTI_TYPE_NOT_ITERATED
9116 | OPTI_TYPE_RAW_HASH;
9117 dgst_pos0 = 0;
9118 dgst_pos1 = 3;
9119 dgst_pos2 = 2;
9120 dgst_pos3 = 1;
9121 break;
9122
9123 case 4300: hash_type = HASH_TYPE_MD5;
9124 salt_type = SALT_TYPE_VIRTUAL;
9125 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9126 opts_type = OPTS_TYPE_PT_GENERATE_LE
9127 | OPTS_TYPE_PT_ADD80
9128 | OPTS_TYPE_PT_ADDBITS14
9129 | OPTS_TYPE_ST_ADD80;
9130 kern_type = KERN_TYPE_MD5U5_PWSLT1;
9131 dgst_size = DGST_SIZE_4_4;
9132 parse_func = md5md5_parse_hash;
9133 sort_by_digest = sort_by_digest_4_4;
9134 opti_type = OPTI_TYPE_ZERO_BYTE
9135 | OPTI_TYPE_PRECOMPUTE_INIT
9136 | OPTI_TYPE_PRECOMPUTE_MERKLE
9137 | OPTI_TYPE_EARLY_SKIP;
9138 dgst_pos0 = 0;
9139 dgst_pos1 = 3;
9140 dgst_pos2 = 2;
9141 dgst_pos3 = 1;
9142 break;
9143
9144
9145 case 4400: hash_type = HASH_TYPE_MD5;
9146 salt_type = SALT_TYPE_NONE;
9147 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9148 opts_type = OPTS_TYPE_PT_GENERATE_BE
9149 | OPTS_TYPE_PT_ADD80
9150 | OPTS_TYPE_PT_ADDBITS15;
9151 kern_type = KERN_TYPE_MD5_SHA1;
9152 dgst_size = DGST_SIZE_4_4;
9153 parse_func = md5_parse_hash;
9154 sort_by_digest = sort_by_digest_4_4;
9155 opti_type = OPTI_TYPE_ZERO_BYTE
9156 | OPTI_TYPE_PRECOMPUTE_INIT
9157 | OPTI_TYPE_PRECOMPUTE_MERKLE
9158 | OPTI_TYPE_EARLY_SKIP
9159 | OPTI_TYPE_NOT_ITERATED
9160 | OPTI_TYPE_NOT_SALTED
9161 | OPTI_TYPE_RAW_HASH;
9162 dgst_pos0 = 0;
9163 dgst_pos1 = 3;
9164 dgst_pos2 = 2;
9165 dgst_pos3 = 1;
9166 break;
9167
9168 case 4500: hash_type = HASH_TYPE_SHA1;
9169 salt_type = SALT_TYPE_NONE;
9170 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9171 opts_type = OPTS_TYPE_PT_GENERATE_BE
9172 | OPTS_TYPE_PT_ADD80
9173 | OPTS_TYPE_PT_ADDBITS15;
9174 kern_type = KERN_TYPE_SHA11;
9175 dgst_size = DGST_SIZE_4_5;
9176 parse_func = sha1_parse_hash;
9177 sort_by_digest = sort_by_digest_4_5;
9178 opti_type = OPTI_TYPE_ZERO_BYTE
9179 | OPTI_TYPE_PRECOMPUTE_INIT
9180 | OPTI_TYPE_PRECOMPUTE_MERKLE
9181 | OPTI_TYPE_EARLY_SKIP
9182 | OPTI_TYPE_NOT_SALTED;
9183 dgst_pos0 = 3;
9184 dgst_pos1 = 4;
9185 dgst_pos2 = 2;
9186 dgst_pos3 = 1;
9187 break;
9188
9189 case 4700: hash_type = HASH_TYPE_SHA1;
9190 salt_type = SALT_TYPE_NONE;
9191 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9192 opts_type = OPTS_TYPE_PT_GENERATE_LE
9193 | OPTS_TYPE_PT_ADD80
9194 | OPTS_TYPE_PT_ADDBITS14;
9195 kern_type = KERN_TYPE_SHA1_MD5;
9196 dgst_size = DGST_SIZE_4_5;
9197 parse_func = sha1_parse_hash;
9198 sort_by_digest = sort_by_digest_4_5;
9199 opti_type = OPTI_TYPE_ZERO_BYTE
9200 | OPTI_TYPE_PRECOMPUTE_INIT
9201 | OPTI_TYPE_PRECOMPUTE_MERKLE
9202 | OPTI_TYPE_EARLY_SKIP
9203 | OPTI_TYPE_NOT_ITERATED
9204 | OPTI_TYPE_NOT_SALTED
9205 | OPTI_TYPE_RAW_HASH;
9206 dgst_pos0 = 3;
9207 dgst_pos1 = 4;
9208 dgst_pos2 = 2;
9209 dgst_pos3 = 1;
9210 break;
9211
9212 case 4800: hash_type = HASH_TYPE_MD5;
9213 salt_type = SALT_TYPE_EMBEDDED;
9214 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9215 opts_type = OPTS_TYPE_PT_GENERATE_LE
9216 | OPTS_TYPE_PT_ADDBITS14;
9217 kern_type = KERN_TYPE_MD5_CHAP;
9218 dgst_size = DGST_SIZE_4_4;
9219 parse_func = chap_parse_hash;
9220 sort_by_digest = sort_by_digest_4_4;
9221 opti_type = OPTI_TYPE_ZERO_BYTE
9222 | OPTI_TYPE_PRECOMPUTE_INIT
9223 | OPTI_TYPE_PRECOMPUTE_MERKLE
9224 | OPTI_TYPE_MEET_IN_MIDDLE
9225 | OPTI_TYPE_EARLY_SKIP
9226 | OPTI_TYPE_NOT_ITERATED
9227 | OPTI_TYPE_RAW_HASH;
9228 dgst_pos0 = 0;
9229 dgst_pos1 = 3;
9230 dgst_pos2 = 2;
9231 dgst_pos3 = 1;
9232 break;
9233
9234 case 4900: hash_type = HASH_TYPE_SHA1;
9235 salt_type = SALT_TYPE_INTERN;
9236 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9237 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9238 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9239 dgst_size = DGST_SIZE_4_5;
9240 parse_func = sha1s_parse_hash;
9241 sort_by_digest = sort_by_digest_4_5;
9242 opti_type = OPTI_TYPE_ZERO_BYTE
9243 | OPTI_TYPE_PRECOMPUTE_INIT
9244 | OPTI_TYPE_PRECOMPUTE_MERKLE
9245 | OPTI_TYPE_EARLY_SKIP;
9246 dgst_pos0 = 3;
9247 dgst_pos1 = 4;
9248 dgst_pos2 = 2;
9249 dgst_pos3 = 1;
9250 break;
9251
9252 case 5000: hash_type = HASH_TYPE_KECCAK;
9253 salt_type = SALT_TYPE_EMBEDDED;
9254 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9255 opts_type = OPTS_TYPE_PT_GENERATE_LE
9256 | OPTS_TYPE_PT_ADD01;
9257 kern_type = KERN_TYPE_KECCAK;
9258 dgst_size = DGST_SIZE_8_25;
9259 parse_func = keccak_parse_hash;
9260 sort_by_digest = sort_by_digest_8_25;
9261 opti_type = OPTI_TYPE_ZERO_BYTE
9262 | OPTI_TYPE_USES_BITS_64
9263 | OPTI_TYPE_RAW_HASH;
9264 dgst_pos0 = 2;
9265 dgst_pos1 = 3;
9266 dgst_pos2 = 4;
9267 dgst_pos3 = 5;
9268 break;
9269
9270 case 5100: hash_type = HASH_TYPE_MD5H;
9271 salt_type = SALT_TYPE_NONE;
9272 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9273 opts_type = OPTS_TYPE_PT_GENERATE_LE
9274 | OPTS_TYPE_PT_ADD80
9275 | OPTS_TYPE_PT_ADDBITS14;
9276 kern_type = KERN_TYPE_MD5H;
9277 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9278 parse_func = md5half_parse_hash;
9279 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9280 opti_type = OPTI_TYPE_ZERO_BYTE
9281 | OPTI_TYPE_RAW_HASH;
9282 dgst_pos0 = 0;
9283 dgst_pos1 = 1;
9284 dgst_pos2 = 2;
9285 dgst_pos3 = 3;
9286 break;
9287
9288 case 5200: hash_type = HASH_TYPE_SHA256;
9289 salt_type = SALT_TYPE_EMBEDDED;
9290 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9291 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9292 kern_type = KERN_TYPE_PSAFE3;
9293 dgst_size = DGST_SIZE_4_8;
9294 parse_func = psafe3_parse_hash;
9295 sort_by_digest = sort_by_digest_4_8;
9296 opti_type = OPTI_TYPE_ZERO_BYTE;
9297 dgst_pos0 = 0;
9298 dgst_pos1 = 1;
9299 dgst_pos2 = 2;
9300 dgst_pos3 = 3;
9301 break;
9302
9303 case 5300: hash_type = HASH_TYPE_MD5;
9304 salt_type = SALT_TYPE_EMBEDDED;
9305 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9306 opts_type = OPTS_TYPE_PT_GENERATE_LE
9307 | OPTS_TYPE_ST_ADD80;
9308 kern_type = KERN_TYPE_IKEPSK_MD5;
9309 dgst_size = DGST_SIZE_4_4;
9310 parse_func = ikepsk_md5_parse_hash;
9311 sort_by_digest = sort_by_digest_4_4;
9312 opti_type = OPTI_TYPE_ZERO_BYTE;
9313 dgst_pos0 = 0;
9314 dgst_pos1 = 3;
9315 dgst_pos2 = 2;
9316 dgst_pos3 = 1;
9317 break;
9318
9319 case 5400: hash_type = HASH_TYPE_SHA1;
9320 salt_type = SALT_TYPE_EMBEDDED;
9321 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9322 opts_type = OPTS_TYPE_PT_GENERATE_BE
9323 | OPTS_TYPE_ST_ADD80;
9324 kern_type = KERN_TYPE_IKEPSK_SHA1;
9325 dgst_size = DGST_SIZE_4_5;
9326 parse_func = ikepsk_sha1_parse_hash;
9327 sort_by_digest = sort_by_digest_4_5;
9328 opti_type = OPTI_TYPE_ZERO_BYTE;
9329 dgst_pos0 = 3;
9330 dgst_pos1 = 4;
9331 dgst_pos2 = 2;
9332 dgst_pos3 = 1;
9333 break;
9334
9335 case 5500: hash_type = HASH_TYPE_NETNTLM;
9336 salt_type = SALT_TYPE_EMBEDDED;
9337 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9338 opts_type = OPTS_TYPE_PT_GENERATE_LE
9339 | OPTS_TYPE_PT_ADD80
9340 | OPTS_TYPE_PT_ADDBITS14
9341 | OPTS_TYPE_PT_UNICODE
9342 | OPTS_TYPE_ST_HEX;
9343 kern_type = KERN_TYPE_NETNTLMv1;
9344 dgst_size = DGST_SIZE_4_4;
9345 parse_func = netntlmv1_parse_hash;
9346 sort_by_digest = sort_by_digest_4_4;
9347 opti_type = OPTI_TYPE_ZERO_BYTE
9348 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9349 dgst_pos0 = 0;
9350 dgst_pos1 = 1;
9351 dgst_pos2 = 2;
9352 dgst_pos3 = 3;
9353 break;
9354
9355 case 5600: hash_type = HASH_TYPE_MD5;
9356 salt_type = SALT_TYPE_EMBEDDED;
9357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9358 opts_type = OPTS_TYPE_PT_GENERATE_LE
9359 | OPTS_TYPE_PT_ADD80
9360 | OPTS_TYPE_PT_ADDBITS14
9361 | OPTS_TYPE_PT_UNICODE;
9362 kern_type = KERN_TYPE_NETNTLMv2;
9363 dgst_size = DGST_SIZE_4_4;
9364 parse_func = netntlmv2_parse_hash;
9365 sort_by_digest = sort_by_digest_4_4;
9366 opti_type = OPTI_TYPE_ZERO_BYTE;
9367 dgst_pos0 = 0;
9368 dgst_pos1 = 3;
9369 dgst_pos2 = 2;
9370 dgst_pos3 = 1;
9371 break;
9372
9373 case 5700: hash_type = HASH_TYPE_SHA256;
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 | OPTS_TYPE_PT_ADDBITS15;
9379 kern_type = KERN_TYPE_SHA256;
9380 dgst_size = DGST_SIZE_4_8;
9381 parse_func = cisco4_parse_hash;
9382 sort_by_digest = sort_by_digest_4_8;
9383 opti_type = OPTI_TYPE_ZERO_BYTE
9384 | OPTI_TYPE_PRECOMPUTE_INIT
9385 | OPTI_TYPE_PRECOMPUTE_MERKLE
9386 | OPTI_TYPE_EARLY_SKIP
9387 | OPTI_TYPE_NOT_ITERATED
9388 | OPTI_TYPE_NOT_SALTED
9389 | OPTI_TYPE_RAW_HASH;
9390 dgst_pos0 = 3;
9391 dgst_pos1 = 7;
9392 dgst_pos2 = 2;
9393 dgst_pos3 = 6;
9394 break;
9395
9396 case 5800: hash_type = HASH_TYPE_SHA1;
9397 salt_type = SALT_TYPE_INTERN;
9398 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9399 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9400 | OPTS_TYPE_ST_ADD80;
9401 kern_type = KERN_TYPE_ANDROIDPIN;
9402 dgst_size = DGST_SIZE_4_5;
9403 parse_func = androidpin_parse_hash;
9404 sort_by_digest = sort_by_digest_4_5;
9405 opti_type = OPTI_TYPE_ZERO_BYTE;
9406 dgst_pos0 = 0;
9407 dgst_pos1 = 1;
9408 dgst_pos2 = 2;
9409 dgst_pos3 = 3;
9410 break;
9411
9412 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9413 salt_type = SALT_TYPE_NONE;
9414 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9415 opts_type = OPTS_TYPE_PT_GENERATE_LE
9416 | OPTS_TYPE_PT_ADD80;
9417 kern_type = KERN_TYPE_RIPEMD160;
9418 dgst_size = DGST_SIZE_4_5;
9419 parse_func = ripemd160_parse_hash;
9420 sort_by_digest = sort_by_digest_4_5;
9421 opti_type = OPTI_TYPE_ZERO_BYTE;
9422 dgst_pos0 = 0;
9423 dgst_pos1 = 1;
9424 dgst_pos2 = 2;
9425 dgst_pos3 = 3;
9426 break;
9427
9428 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9429 salt_type = SALT_TYPE_NONE;
9430 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9431 opts_type = OPTS_TYPE_PT_GENERATE_BE
9432 | OPTS_TYPE_PT_ADD80;
9433 kern_type = KERN_TYPE_WHIRLPOOL;
9434 dgst_size = DGST_SIZE_4_16;
9435 parse_func = whirlpool_parse_hash;
9436 sort_by_digest = sort_by_digest_4_16;
9437 opti_type = OPTI_TYPE_ZERO_BYTE;
9438 dgst_pos0 = 0;
9439 dgst_pos1 = 1;
9440 dgst_pos2 = 2;
9441 dgst_pos3 = 3;
9442 break;
9443
9444 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9445 salt_type = SALT_TYPE_EMBEDDED;
9446 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9447 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9448 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9449 dgst_size = DGST_SIZE_4_5;
9450 parse_func = truecrypt_parse_hash_2k;
9451 sort_by_digest = sort_by_digest_4_5;
9452 opti_type = OPTI_TYPE_ZERO_BYTE;
9453 dgst_pos0 = 0;
9454 dgst_pos1 = 1;
9455 dgst_pos2 = 2;
9456 dgst_pos3 = 3;
9457 break;
9458
9459 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9460 salt_type = SALT_TYPE_EMBEDDED;
9461 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9462 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9463 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9464 dgst_size = DGST_SIZE_4_5;
9465 parse_func = truecrypt_parse_hash_2k;
9466 sort_by_digest = sort_by_digest_4_5;
9467 opti_type = OPTI_TYPE_ZERO_BYTE;
9468 dgst_pos0 = 0;
9469 dgst_pos1 = 1;
9470 dgst_pos2 = 2;
9471 dgst_pos3 = 3;
9472 break;
9473
9474 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9475 salt_type = SALT_TYPE_EMBEDDED;
9476 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9477 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9478 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9479 dgst_size = DGST_SIZE_4_5;
9480 parse_func = truecrypt_parse_hash_2k;
9481 sort_by_digest = sort_by_digest_4_5;
9482 opti_type = OPTI_TYPE_ZERO_BYTE;
9483 dgst_pos0 = 0;
9484 dgst_pos1 = 1;
9485 dgst_pos2 = 2;
9486 dgst_pos3 = 3;
9487 break;
9488
9489 case 6221: hash_type = HASH_TYPE_SHA512;
9490 salt_type = SALT_TYPE_EMBEDDED;
9491 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9492 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9493 kern_type = KERN_TYPE_TCSHA512_XTS512;
9494 dgst_size = DGST_SIZE_8_8;
9495 parse_func = truecrypt_parse_hash_1k;
9496 sort_by_digest = sort_by_digest_8_8;
9497 opti_type = OPTI_TYPE_ZERO_BYTE
9498 | OPTI_TYPE_USES_BITS_64;
9499 dgst_pos0 = 0;
9500 dgst_pos1 = 1;
9501 dgst_pos2 = 2;
9502 dgst_pos3 = 3;
9503 break;
9504
9505 case 6222: hash_type = HASH_TYPE_SHA512;
9506 salt_type = SALT_TYPE_EMBEDDED;
9507 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9508 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9509 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9510 dgst_size = DGST_SIZE_8_8;
9511 parse_func = truecrypt_parse_hash_1k;
9512 sort_by_digest = sort_by_digest_8_8;
9513 opti_type = OPTI_TYPE_ZERO_BYTE
9514 | OPTI_TYPE_USES_BITS_64;
9515 dgst_pos0 = 0;
9516 dgst_pos1 = 1;
9517 dgst_pos2 = 2;
9518 dgst_pos3 = 3;
9519 break;
9520
9521 case 6223: hash_type = HASH_TYPE_SHA512;
9522 salt_type = SALT_TYPE_EMBEDDED;
9523 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9524 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9525 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9526 dgst_size = DGST_SIZE_8_8;
9527 parse_func = truecrypt_parse_hash_1k;
9528 sort_by_digest = sort_by_digest_8_8;
9529 opti_type = OPTI_TYPE_ZERO_BYTE
9530 | OPTI_TYPE_USES_BITS_64;
9531 dgst_pos0 = 0;
9532 dgst_pos1 = 1;
9533 dgst_pos2 = 2;
9534 dgst_pos3 = 3;
9535 break;
9536
9537 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9538 salt_type = SALT_TYPE_EMBEDDED;
9539 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9540 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9541 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9542 dgst_size = DGST_SIZE_4_8;
9543 parse_func = truecrypt_parse_hash_1k;
9544 sort_by_digest = sort_by_digest_4_8;
9545 opti_type = OPTI_TYPE_ZERO_BYTE;
9546 dgst_pos0 = 0;
9547 dgst_pos1 = 1;
9548 dgst_pos2 = 2;
9549 dgst_pos3 = 3;
9550 break;
9551
9552 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9553 salt_type = SALT_TYPE_EMBEDDED;
9554 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9555 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9556 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9557 dgst_size = DGST_SIZE_4_8;
9558 parse_func = truecrypt_parse_hash_1k;
9559 sort_by_digest = sort_by_digest_4_8;
9560 opti_type = OPTI_TYPE_ZERO_BYTE;
9561 dgst_pos0 = 0;
9562 dgst_pos1 = 1;
9563 dgst_pos2 = 2;
9564 dgst_pos3 = 3;
9565 break;
9566
9567 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9568 salt_type = SALT_TYPE_EMBEDDED;
9569 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9570 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9571 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9572 dgst_size = DGST_SIZE_4_8;
9573 parse_func = truecrypt_parse_hash_1k;
9574 sort_by_digest = sort_by_digest_4_8;
9575 opti_type = OPTI_TYPE_ZERO_BYTE;
9576 dgst_pos0 = 0;
9577 dgst_pos1 = 1;
9578 dgst_pos2 = 2;
9579 dgst_pos3 = 3;
9580 break;
9581
9582 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9583 salt_type = SALT_TYPE_EMBEDDED;
9584 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9585 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9586 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9587 dgst_size = DGST_SIZE_4_5;
9588 parse_func = truecrypt_parse_hash_1k;
9589 sort_by_digest = sort_by_digest_4_5;
9590 opti_type = OPTI_TYPE_ZERO_BYTE;
9591 dgst_pos0 = 0;
9592 dgst_pos1 = 1;
9593 dgst_pos2 = 2;
9594 dgst_pos3 = 3;
9595 break;
9596
9597 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9598 salt_type = SALT_TYPE_EMBEDDED;
9599 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9600 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9601 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9602 dgst_size = DGST_SIZE_4_5;
9603 parse_func = truecrypt_parse_hash_1k;
9604 sort_by_digest = sort_by_digest_4_5;
9605 opti_type = OPTI_TYPE_ZERO_BYTE;
9606 dgst_pos0 = 0;
9607 dgst_pos1 = 1;
9608 dgst_pos2 = 2;
9609 dgst_pos3 = 3;
9610 break;
9611
9612 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9613 salt_type = SALT_TYPE_EMBEDDED;
9614 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9615 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9616 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9617 dgst_size = DGST_SIZE_4_5;
9618 parse_func = truecrypt_parse_hash_1k;
9619 sort_by_digest = sort_by_digest_4_5;
9620 opti_type = OPTI_TYPE_ZERO_BYTE;
9621 dgst_pos0 = 0;
9622 dgst_pos1 = 1;
9623 dgst_pos2 = 2;
9624 dgst_pos3 = 3;
9625 break;
9626
9627 case 6300: hash_type = HASH_TYPE_MD5;
9628 salt_type = SALT_TYPE_EMBEDDED;
9629 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9630 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9631 kern_type = KERN_TYPE_MD5AIX;
9632 dgst_size = DGST_SIZE_4_4;
9633 parse_func = md5aix_parse_hash;
9634 sort_by_digest = sort_by_digest_4_4;
9635 opti_type = OPTI_TYPE_ZERO_BYTE;
9636 dgst_pos0 = 0;
9637 dgst_pos1 = 1;
9638 dgst_pos2 = 2;
9639 dgst_pos3 = 3;
9640 break;
9641
9642 case 6400: hash_type = HASH_TYPE_SHA256;
9643 salt_type = SALT_TYPE_EMBEDDED;
9644 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9645 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9646 kern_type = KERN_TYPE_SHA256AIX;
9647 dgst_size = DGST_SIZE_4_8;
9648 parse_func = sha256aix_parse_hash;
9649 sort_by_digest = sort_by_digest_4_8;
9650 opti_type = OPTI_TYPE_ZERO_BYTE;
9651 dgst_pos0 = 0;
9652 dgst_pos1 = 1;
9653 dgst_pos2 = 2;
9654 dgst_pos3 = 3;
9655 break;
9656
9657 case 6500: hash_type = HASH_TYPE_SHA512;
9658 salt_type = SALT_TYPE_EMBEDDED;
9659 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9660 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9661 kern_type = KERN_TYPE_SHA512AIX;
9662 dgst_size = DGST_SIZE_8_8;
9663 parse_func = sha512aix_parse_hash;
9664 sort_by_digest = sort_by_digest_8_8;
9665 opti_type = OPTI_TYPE_ZERO_BYTE
9666 | OPTI_TYPE_USES_BITS_64;
9667 dgst_pos0 = 0;
9668 dgst_pos1 = 1;
9669 dgst_pos2 = 2;
9670 dgst_pos3 = 3;
9671 break;
9672
9673 case 6600: hash_type = HASH_TYPE_AES;
9674 salt_type = SALT_TYPE_EMBEDDED;
9675 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9676 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9677 kern_type = KERN_TYPE_AGILEKEY;
9678 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9679 parse_func = agilekey_parse_hash;
9680 sort_by_digest = sort_by_digest_4_5;
9681 opti_type = OPTI_TYPE_ZERO_BYTE;
9682 dgst_pos0 = 0;
9683 dgst_pos1 = 1;
9684 dgst_pos2 = 2;
9685 dgst_pos3 = 3;
9686 break;
9687
9688 case 6700: hash_type = HASH_TYPE_SHA1;
9689 salt_type = SALT_TYPE_EMBEDDED;
9690 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9691 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9692 kern_type = KERN_TYPE_SHA1AIX;
9693 dgst_size = DGST_SIZE_4_5;
9694 parse_func = sha1aix_parse_hash;
9695 sort_by_digest = sort_by_digest_4_5;
9696 opti_type = OPTI_TYPE_ZERO_BYTE;
9697 dgst_pos0 = 0;
9698 dgst_pos1 = 1;
9699 dgst_pos2 = 2;
9700 dgst_pos3 = 3;
9701 break;
9702
9703 case 6800: hash_type = HASH_TYPE_AES;
9704 salt_type = SALT_TYPE_EMBEDDED;
9705 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9706 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9707 kern_type = KERN_TYPE_LASTPASS;
9708 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9709 parse_func = lastpass_parse_hash;
9710 sort_by_digest = sort_by_digest_4_8;
9711 opti_type = OPTI_TYPE_ZERO_BYTE;
9712 dgst_pos0 = 0;
9713 dgst_pos1 = 1;
9714 dgst_pos2 = 2;
9715 dgst_pos3 = 3;
9716 break;
9717
9718 case 6900: hash_type = HASH_TYPE_GOST;
9719 salt_type = SALT_TYPE_NONE;
9720 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9721 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9722 kern_type = KERN_TYPE_GOST;
9723 dgst_size = DGST_SIZE_4_8;
9724 parse_func = gost_parse_hash;
9725 sort_by_digest = sort_by_digest_4_8;
9726 opti_type = OPTI_TYPE_ZERO_BYTE;
9727 dgst_pos0 = 0;
9728 dgst_pos1 = 1;
9729 dgst_pos2 = 2;
9730 dgst_pos3 = 3;
9731 break;
9732
9733 case 7100: hash_type = HASH_TYPE_SHA512;
9734 salt_type = SALT_TYPE_EMBEDDED;
9735 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9736 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9737 kern_type = KERN_TYPE_PBKDF2_SHA512;
9738 dgst_size = DGST_SIZE_8_16;
9739 parse_func = sha512osx_parse_hash;
9740 sort_by_digest = sort_by_digest_8_16;
9741 opti_type = OPTI_TYPE_ZERO_BYTE
9742 | OPTI_TYPE_USES_BITS_64
9743 | OPTI_TYPE_SLOW_HASH_SIMD;
9744 dgst_pos0 = 0;
9745 dgst_pos1 = 1;
9746 dgst_pos2 = 2;
9747 dgst_pos3 = 3;
9748 break;
9749
9750 case 7200: hash_type = HASH_TYPE_SHA512;
9751 salt_type = SALT_TYPE_EMBEDDED;
9752 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9753 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9754 kern_type = KERN_TYPE_PBKDF2_SHA512;
9755 dgst_size = DGST_SIZE_8_16;
9756 parse_func = sha512grub_parse_hash;
9757 sort_by_digest = sort_by_digest_8_16;
9758 opti_type = OPTI_TYPE_ZERO_BYTE
9759 | OPTI_TYPE_USES_BITS_64
9760 | OPTI_TYPE_SLOW_HASH_SIMD;
9761 dgst_pos0 = 0;
9762 dgst_pos1 = 1;
9763 dgst_pos2 = 2;
9764 dgst_pos3 = 3;
9765 break;
9766
9767 case 7300: hash_type = HASH_TYPE_SHA1;
9768 salt_type = SALT_TYPE_EMBEDDED;
9769 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9770 opts_type = OPTS_TYPE_PT_GENERATE_BE
9771 | OPTS_TYPE_ST_ADD80
9772 | OPTS_TYPE_ST_ADDBITS15;
9773 kern_type = KERN_TYPE_RAKP;
9774 dgst_size = DGST_SIZE_4_5;
9775 parse_func = rakp_parse_hash;
9776 sort_by_digest = sort_by_digest_4_5;
9777 opti_type = OPTI_TYPE_ZERO_BYTE
9778 | OPTI_TYPE_NOT_ITERATED;
9779 dgst_pos0 = 3;
9780 dgst_pos1 = 4;
9781 dgst_pos2 = 2;
9782 dgst_pos3 = 1;
9783 break;
9784
9785 case 7400: hash_type = HASH_TYPE_SHA256;
9786 salt_type = SALT_TYPE_EMBEDDED;
9787 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9788 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9789 kern_type = KERN_TYPE_SHA256CRYPT;
9790 dgst_size = DGST_SIZE_4_8;
9791 parse_func = sha256crypt_parse_hash;
9792 sort_by_digest = sort_by_digest_4_8;
9793 opti_type = OPTI_TYPE_ZERO_BYTE;
9794 dgst_pos0 = 0;
9795 dgst_pos1 = 1;
9796 dgst_pos2 = 2;
9797 dgst_pos3 = 3;
9798 break;
9799
9800 case 7500: hash_type = HASH_TYPE_KRB5PA;
9801 salt_type = SALT_TYPE_EMBEDDED;
9802 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9803 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9804 kern_type = KERN_TYPE_KRB5PA;
9805 dgst_size = DGST_SIZE_4_4;
9806 parse_func = krb5pa_parse_hash;
9807 sort_by_digest = sort_by_digest_4_4;
9808 opti_type = OPTI_TYPE_ZERO_BYTE
9809 | OPTI_TYPE_NOT_ITERATED;
9810 dgst_pos0 = 0;
9811 dgst_pos1 = 1;
9812 dgst_pos2 = 2;
9813 dgst_pos3 = 3;
9814 break;
9815
9816 case 7600: hash_type = HASH_TYPE_SHA1;
9817 salt_type = SALT_TYPE_INTERN;
9818 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9819 opts_type = OPTS_TYPE_PT_GENERATE_BE
9820 | OPTS_TYPE_PT_ADD80
9821 | OPTS_TYPE_PT_ADDBITS15;
9822 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9823 dgst_size = DGST_SIZE_4_5;
9824 parse_func = redmine_parse_hash;
9825 sort_by_digest = sort_by_digest_4_5;
9826 opti_type = OPTI_TYPE_ZERO_BYTE
9827 | OPTI_TYPE_PRECOMPUTE_INIT
9828 | OPTI_TYPE_EARLY_SKIP
9829 | OPTI_TYPE_NOT_ITERATED
9830 | OPTI_TYPE_PREPENDED_SALT;
9831 dgst_pos0 = 3;
9832 dgst_pos1 = 4;
9833 dgst_pos2 = 2;
9834 dgst_pos3 = 1;
9835 break;
9836
9837 case 7700: hash_type = HASH_TYPE_SAPB;
9838 salt_type = SALT_TYPE_EMBEDDED;
9839 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9840 opts_type = OPTS_TYPE_PT_GENERATE_LE
9841 | OPTS_TYPE_PT_UPPER
9842 | OPTS_TYPE_ST_UPPER;
9843 kern_type = KERN_TYPE_SAPB;
9844 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9845 parse_func = sapb_parse_hash;
9846 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9847 opti_type = OPTI_TYPE_ZERO_BYTE
9848 | OPTI_TYPE_PRECOMPUTE_INIT
9849 | OPTI_TYPE_NOT_ITERATED;
9850 dgst_pos0 = 0;
9851 dgst_pos1 = 1;
9852 dgst_pos2 = 2;
9853 dgst_pos3 = 3;
9854 break;
9855
9856 case 7800: hash_type = HASH_TYPE_SAPG;
9857 salt_type = SALT_TYPE_EMBEDDED;
9858 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9859 opts_type = OPTS_TYPE_PT_GENERATE_BE
9860 | OPTS_TYPE_ST_ADD80
9861 | OPTS_TYPE_ST_UPPER;
9862 kern_type = KERN_TYPE_SAPG;
9863 dgst_size = DGST_SIZE_4_5;
9864 parse_func = sapg_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_NOT_ITERATED;
9869 dgst_pos0 = 3;
9870 dgst_pos1 = 4;
9871 dgst_pos2 = 2;
9872 dgst_pos3 = 1;
9873 break;
9874
9875 case 7900: hash_type = HASH_TYPE_SHA512;
9876 salt_type = SALT_TYPE_EMBEDDED;
9877 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9878 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9879 kern_type = KERN_TYPE_DRUPAL7;
9880 dgst_size = DGST_SIZE_8_8;
9881 parse_func = drupal7_parse_hash;
9882 sort_by_digest = sort_by_digest_8_8;
9883 opti_type = OPTI_TYPE_ZERO_BYTE
9884 | OPTI_TYPE_USES_BITS_64;
9885 dgst_pos0 = 0;
9886 dgst_pos1 = 1;
9887 dgst_pos2 = 2;
9888 dgst_pos3 = 3;
9889 break;
9890
9891 case 8000: hash_type = HASH_TYPE_SHA256;
9892 salt_type = SALT_TYPE_EMBEDDED;
9893 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9894 opts_type = OPTS_TYPE_PT_GENERATE_BE
9895 | OPTS_TYPE_PT_UNICODE
9896 | OPTS_TYPE_ST_ADD80
9897 | OPTS_TYPE_ST_HEX;
9898 kern_type = KERN_TYPE_SYBASEASE;
9899 dgst_size = DGST_SIZE_4_8;
9900 parse_func = sybasease_parse_hash;
9901 sort_by_digest = sort_by_digest_4_8;
9902 opti_type = OPTI_TYPE_ZERO_BYTE
9903 | OPTI_TYPE_PRECOMPUTE_INIT
9904 | OPTI_TYPE_EARLY_SKIP
9905 | OPTI_TYPE_NOT_ITERATED
9906 | OPTI_TYPE_RAW_HASH;
9907 dgst_pos0 = 3;
9908 dgst_pos1 = 7;
9909 dgst_pos2 = 2;
9910 dgst_pos3 = 6;
9911 break;
9912
9913 case 8100: hash_type = HASH_TYPE_SHA1;
9914 salt_type = SALT_TYPE_EMBEDDED;
9915 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9916 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9917 kern_type = KERN_TYPE_NETSCALER;
9918 dgst_size = DGST_SIZE_4_5;
9919 parse_func = netscaler_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_PRECOMPUTE_MERKLE
9924 | OPTI_TYPE_EARLY_SKIP
9925 | OPTI_TYPE_NOT_ITERATED
9926 | OPTI_TYPE_PREPENDED_SALT
9927 | OPTI_TYPE_RAW_HASH;
9928 dgst_pos0 = 3;
9929 dgst_pos1 = 4;
9930 dgst_pos2 = 2;
9931 dgst_pos3 = 1;
9932 break;
9933
9934 case 8200: hash_type = HASH_TYPE_SHA256;
9935 salt_type = SALT_TYPE_EMBEDDED;
9936 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9937 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9938 kern_type = KERN_TYPE_CLOUDKEY;
9939 dgst_size = DGST_SIZE_4_8;
9940 parse_func = cloudkey_parse_hash;
9941 sort_by_digest = sort_by_digest_4_8;
9942 opti_type = OPTI_TYPE_ZERO_BYTE;
9943 dgst_pos0 = 0;
9944 dgst_pos1 = 1;
9945 dgst_pos2 = 2;
9946 dgst_pos3 = 3;
9947 break;
9948
9949 case 8300: hash_type = HASH_TYPE_SHA1;
9950 salt_type = SALT_TYPE_EMBEDDED;
9951 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9952 opts_type = OPTS_TYPE_PT_GENERATE_BE
9953 | OPTS_TYPE_ST_HEX
9954 | OPTS_TYPE_ST_ADD80;
9955 kern_type = KERN_TYPE_NSEC3;
9956 dgst_size = DGST_SIZE_4_5;
9957 parse_func = nsec3_parse_hash;
9958 sort_by_digest = sort_by_digest_4_5;
9959 opti_type = OPTI_TYPE_ZERO_BYTE;
9960 dgst_pos0 = 3;
9961 dgst_pos1 = 4;
9962 dgst_pos2 = 2;
9963 dgst_pos3 = 1;
9964 break;
9965
9966 case 8400: hash_type = HASH_TYPE_SHA1;
9967 salt_type = SALT_TYPE_INTERN;
9968 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9969 opts_type = OPTS_TYPE_PT_GENERATE_BE
9970 | OPTS_TYPE_PT_ADD80
9971 | OPTS_TYPE_PT_ADDBITS15;
9972 kern_type = KERN_TYPE_WBB3;
9973 dgst_size = DGST_SIZE_4_5;
9974 parse_func = wbb3_parse_hash;
9975 sort_by_digest = sort_by_digest_4_5;
9976 opti_type = OPTI_TYPE_ZERO_BYTE
9977 | OPTI_TYPE_PRECOMPUTE_INIT
9978 | OPTI_TYPE_NOT_ITERATED;
9979 dgst_pos0 = 3;
9980 dgst_pos1 = 4;
9981 dgst_pos2 = 2;
9982 dgst_pos3 = 1;
9983 break;
9984
9985 case 8500: hash_type = HASH_TYPE_DESRACF;
9986 salt_type = SALT_TYPE_EMBEDDED;
9987 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9988 opts_type = OPTS_TYPE_PT_GENERATE_LE
9989 | OPTS_TYPE_ST_UPPER;
9990 kern_type = KERN_TYPE_RACF;
9991 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9992 parse_func = racf_parse_hash;
9993 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9994 opti_type = OPTI_TYPE_ZERO_BYTE
9995 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9996 dgst_pos0 = 0;
9997 dgst_pos1 = 1;
9998 dgst_pos2 = 2;
9999 dgst_pos3 = 3;
10000 break;
10001
10002 case 8600: hash_type = HASH_TYPE_LOTUS5;
10003 salt_type = SALT_TYPE_NONE;
10004 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10005 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10006 kern_type = KERN_TYPE_LOTUS5;
10007 dgst_size = DGST_SIZE_4_4;
10008 parse_func = lotus5_parse_hash;
10009 sort_by_digest = sort_by_digest_4_4;
10010 opti_type = OPTI_TYPE_EARLY_SKIP
10011 | OPTI_TYPE_NOT_ITERATED
10012 | OPTI_TYPE_NOT_SALTED
10013 | OPTI_TYPE_RAW_HASH;
10014 dgst_pos0 = 0;
10015 dgst_pos1 = 1;
10016 dgst_pos2 = 2;
10017 dgst_pos3 = 3;
10018 break;
10019
10020 case 8700: hash_type = HASH_TYPE_LOTUS6;
10021 salt_type = SALT_TYPE_EMBEDDED;
10022 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10023 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10024 kern_type = KERN_TYPE_LOTUS6;
10025 dgst_size = DGST_SIZE_4_4;
10026 parse_func = lotus6_parse_hash;
10027 sort_by_digest = sort_by_digest_4_4;
10028 opti_type = OPTI_TYPE_EARLY_SKIP
10029 | OPTI_TYPE_NOT_ITERATED
10030 | OPTI_TYPE_RAW_HASH;
10031 dgst_pos0 = 0;
10032 dgst_pos1 = 1;
10033 dgst_pos2 = 2;
10034 dgst_pos3 = 3;
10035 break;
10036
10037 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
10038 salt_type = SALT_TYPE_EMBEDDED;
10039 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10040 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10041 kern_type = KERN_TYPE_ANDROIDFDE;
10042 dgst_size = DGST_SIZE_4_4;
10043 parse_func = androidfde_parse_hash;
10044 sort_by_digest = sort_by_digest_4_4;
10045 opti_type = OPTI_TYPE_ZERO_BYTE;
10046 dgst_pos0 = 0;
10047 dgst_pos1 = 1;
10048 dgst_pos2 = 2;
10049 dgst_pos3 = 3;
10050 break;
10051
10052 case 8900: hash_type = HASH_TYPE_SCRYPT;
10053 salt_type = SALT_TYPE_EMBEDDED;
10054 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10055 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10056 kern_type = KERN_TYPE_SCRYPT;
10057 dgst_size = DGST_SIZE_4_8;
10058 parse_func = scrypt_parse_hash;
10059 sort_by_digest = sort_by_digest_4_8;
10060 opti_type = OPTI_TYPE_ZERO_BYTE;
10061 dgst_pos0 = 0;
10062 dgst_pos1 = 1;
10063 dgst_pos2 = 2;
10064 dgst_pos3 = 3;
10065 break;
10066
10067 case 9000: hash_type = HASH_TYPE_SHA1;
10068 salt_type = SALT_TYPE_EMBEDDED;
10069 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10070 opts_type = OPTS_TYPE_PT_GENERATE_LE
10071 | OPTS_TYPE_ST_GENERATE_LE;
10072 kern_type = KERN_TYPE_PSAFE2;
10073 dgst_size = DGST_SIZE_4_5;
10074 parse_func = psafe2_parse_hash;
10075 sort_by_digest = sort_by_digest_4_5;
10076 opti_type = OPTI_TYPE_ZERO_BYTE;
10077 dgst_pos0 = 0;
10078 dgst_pos1 = 1;
10079 dgst_pos2 = 2;
10080 dgst_pos3 = 3;
10081 break;
10082
10083 case 9100: hash_type = HASH_TYPE_LOTUS8;
10084 salt_type = SALT_TYPE_EMBEDDED;
10085 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10086 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10087 kern_type = KERN_TYPE_LOTUS8;
10088 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10089 parse_func = lotus8_parse_hash;
10090 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10091 opti_type = OPTI_TYPE_ZERO_BYTE;
10092 dgst_pos0 = 0;
10093 dgst_pos1 = 1;
10094 dgst_pos2 = 2;
10095 dgst_pos3 = 3;
10096 break;
10097
10098 case 9200: hash_type = HASH_TYPE_SHA256;
10099 salt_type = SALT_TYPE_EMBEDDED;
10100 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10101 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10102 kern_type = KERN_TYPE_PBKDF2_SHA256;
10103 dgst_size = DGST_SIZE_4_32;
10104 parse_func = cisco8_parse_hash;
10105 sort_by_digest = sort_by_digest_4_32;
10106 opti_type = OPTI_TYPE_ZERO_BYTE
10107 | OPTI_TYPE_SLOW_HASH_SIMD;
10108 dgst_pos0 = 0;
10109 dgst_pos1 = 1;
10110 dgst_pos2 = 2;
10111 dgst_pos3 = 3;
10112 break;
10113
10114 case 9300: hash_type = HASH_TYPE_SCRYPT;
10115 salt_type = SALT_TYPE_EMBEDDED;
10116 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10117 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10118 kern_type = KERN_TYPE_SCRYPT;
10119 dgst_size = DGST_SIZE_4_8;
10120 parse_func = cisco9_parse_hash;
10121 sort_by_digest = sort_by_digest_4_8;
10122 opti_type = OPTI_TYPE_ZERO_BYTE;
10123 dgst_pos0 = 0;
10124 dgst_pos1 = 1;
10125 dgst_pos2 = 2;
10126 dgst_pos3 = 3;
10127 break;
10128
10129 case 9400: hash_type = HASH_TYPE_OFFICE2007;
10130 salt_type = SALT_TYPE_EMBEDDED;
10131 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10132 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10133 kern_type = KERN_TYPE_OFFICE2007;
10134 dgst_size = DGST_SIZE_4_4;
10135 parse_func = office2007_parse_hash;
10136 sort_by_digest = sort_by_digest_4_4;
10137 opti_type = OPTI_TYPE_ZERO_BYTE;
10138 dgst_pos0 = 0;
10139 dgst_pos1 = 1;
10140 dgst_pos2 = 2;
10141 dgst_pos3 = 3;
10142 break;
10143
10144 case 9500: hash_type = HASH_TYPE_OFFICE2010;
10145 salt_type = SALT_TYPE_EMBEDDED;
10146 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10147 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10148 kern_type = KERN_TYPE_OFFICE2010;
10149 dgst_size = DGST_SIZE_4_4;
10150 parse_func = office2010_parse_hash;
10151 sort_by_digest = sort_by_digest_4_4;
10152 opti_type = OPTI_TYPE_ZERO_BYTE;
10153 dgst_pos0 = 0;
10154 dgst_pos1 = 1;
10155 dgst_pos2 = 2;
10156 dgst_pos3 = 3;
10157 break;
10158
10159 case 9600: hash_type = HASH_TYPE_OFFICE2013;
10160 salt_type = SALT_TYPE_EMBEDDED;
10161 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10162 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10163 kern_type = KERN_TYPE_OFFICE2013;
10164 dgst_size = DGST_SIZE_4_4;
10165 parse_func = office2013_parse_hash;
10166 sort_by_digest = sort_by_digest_4_4;
10167 opti_type = OPTI_TYPE_ZERO_BYTE;
10168 dgst_pos0 = 0;
10169 dgst_pos1 = 1;
10170 dgst_pos2 = 2;
10171 dgst_pos3 = 3;
10172 break;
10173
10174 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
10175 salt_type = SALT_TYPE_EMBEDDED;
10176 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10177 opts_type = OPTS_TYPE_PT_GENERATE_LE
10178 | OPTS_TYPE_PT_ADD80
10179 | OPTS_TYPE_PT_UNICODE;
10180 kern_type = KERN_TYPE_OLDOFFICE01;
10181 dgst_size = DGST_SIZE_4_4;
10182 parse_func = oldoffice01_parse_hash;
10183 sort_by_digest = sort_by_digest_4_4;
10184 opti_type = OPTI_TYPE_ZERO_BYTE
10185 | OPTI_TYPE_PRECOMPUTE_INIT
10186 | OPTI_TYPE_NOT_ITERATED;
10187 dgst_pos0 = 0;
10188 dgst_pos1 = 1;
10189 dgst_pos2 = 2;
10190 dgst_pos3 = 3;
10191 break;
10192
10193 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
10194 salt_type = SALT_TYPE_EMBEDDED;
10195 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10196 opts_type = OPTS_TYPE_PT_GENERATE_LE
10197 | OPTS_TYPE_PT_ADD80;
10198 kern_type = KERN_TYPE_OLDOFFICE01CM1;
10199 dgst_size = DGST_SIZE_4_4;
10200 parse_func = oldoffice01cm1_parse_hash;
10201 sort_by_digest = sort_by_digest_4_4;
10202 opti_type = OPTI_TYPE_ZERO_BYTE
10203 | OPTI_TYPE_PRECOMPUTE_INIT
10204 | OPTI_TYPE_NOT_ITERATED;
10205 dgst_pos0 = 0;
10206 dgst_pos1 = 1;
10207 dgst_pos2 = 2;
10208 dgst_pos3 = 3;
10209 break;
10210
10211 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
10212 salt_type = SALT_TYPE_EMBEDDED;
10213 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10214 opts_type = OPTS_TYPE_PT_GENERATE_LE
10215 | OPTS_TYPE_PT_ADD80
10216 | OPTS_TYPE_PT_UNICODE
10217 | OPTS_TYPE_PT_NEVERCRACK;
10218 kern_type = KERN_TYPE_OLDOFFICE01CM2;
10219 dgst_size = DGST_SIZE_4_4;
10220 parse_func = oldoffice01cm2_parse_hash;
10221 sort_by_digest = sort_by_digest_4_4;
10222 opti_type = OPTI_TYPE_ZERO_BYTE
10223 | OPTI_TYPE_PRECOMPUTE_INIT
10224 | OPTI_TYPE_NOT_ITERATED;
10225 dgst_pos0 = 0;
10226 dgst_pos1 = 1;
10227 dgst_pos2 = 2;
10228 dgst_pos3 = 3;
10229 break;
10230
10231 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
10232 salt_type = SALT_TYPE_EMBEDDED;
10233 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10234 opts_type = OPTS_TYPE_PT_GENERATE_BE
10235 | OPTS_TYPE_PT_ADD80
10236 | OPTS_TYPE_PT_UNICODE;
10237 kern_type = KERN_TYPE_OLDOFFICE34;
10238 dgst_size = DGST_SIZE_4_4;
10239 parse_func = oldoffice34_parse_hash;
10240 sort_by_digest = sort_by_digest_4_4;
10241 opti_type = OPTI_TYPE_ZERO_BYTE
10242 | OPTI_TYPE_PRECOMPUTE_INIT
10243 | OPTI_TYPE_NOT_ITERATED;
10244 dgst_pos0 = 0;
10245 dgst_pos1 = 1;
10246 dgst_pos2 = 2;
10247 dgst_pos3 = 3;
10248 break;
10249
10250 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10251 salt_type = SALT_TYPE_EMBEDDED;
10252 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10253 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10254 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10255 dgst_size = DGST_SIZE_4_4;
10256 parse_func = oldoffice34cm1_parse_hash;
10257 sort_by_digest = sort_by_digest_4_4;
10258 opti_type = OPTI_TYPE_ZERO_BYTE
10259 | OPTI_TYPE_PRECOMPUTE_INIT
10260 | OPTI_TYPE_NOT_ITERATED;
10261 dgst_pos0 = 0;
10262 dgst_pos1 = 1;
10263 dgst_pos2 = 2;
10264 dgst_pos3 = 3;
10265 break;
10266
10267 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10268 salt_type = SALT_TYPE_EMBEDDED;
10269 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10270 opts_type = OPTS_TYPE_PT_GENERATE_BE
10271 | OPTS_TYPE_PT_ADD80
10272 | OPTS_TYPE_PT_UNICODE
10273 | OPTS_TYPE_PT_NEVERCRACK;
10274 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10275 dgst_size = DGST_SIZE_4_4;
10276 parse_func = oldoffice34cm2_parse_hash;
10277 sort_by_digest = sort_by_digest_4_4;
10278 opti_type = OPTI_TYPE_ZERO_BYTE
10279 | OPTI_TYPE_PRECOMPUTE_INIT
10280 | OPTI_TYPE_NOT_ITERATED;
10281 dgst_pos0 = 0;
10282 dgst_pos1 = 1;
10283 dgst_pos2 = 2;
10284 dgst_pos3 = 3;
10285 break;
10286
10287 case 9900: hash_type = HASH_TYPE_MD5;
10288 salt_type = SALT_TYPE_NONE;
10289 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10290 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10291 kern_type = KERN_TYPE_RADMIN2;
10292 dgst_size = DGST_SIZE_4_4;
10293 parse_func = radmin2_parse_hash;
10294 sort_by_digest = sort_by_digest_4_4;
10295 opti_type = OPTI_TYPE_ZERO_BYTE
10296 | OPTI_TYPE_PRECOMPUTE_INIT
10297 | OPTI_TYPE_EARLY_SKIP
10298 | OPTI_TYPE_NOT_ITERATED
10299 | OPTI_TYPE_NOT_SALTED;
10300 dgst_pos0 = 0;
10301 dgst_pos1 = 3;
10302 dgst_pos2 = 2;
10303 dgst_pos3 = 1;
10304 break;
10305
10306 case 10000: hash_type = HASH_TYPE_SHA256;
10307 salt_type = SALT_TYPE_EMBEDDED;
10308 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10309 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10310 kern_type = KERN_TYPE_PBKDF2_SHA256;
10311 dgst_size = DGST_SIZE_4_32;
10312 parse_func = djangopbkdf2_parse_hash;
10313 sort_by_digest = sort_by_digest_4_32;
10314 opti_type = OPTI_TYPE_ZERO_BYTE
10315 | OPTI_TYPE_SLOW_HASH_SIMD;
10316 dgst_pos0 = 0;
10317 dgst_pos1 = 1;
10318 dgst_pos2 = 2;
10319 dgst_pos3 = 3;
10320 break;
10321
10322 case 10100: hash_type = HASH_TYPE_SIPHASH;
10323 salt_type = SALT_TYPE_EMBEDDED;
10324 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10325 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10326 kern_type = KERN_TYPE_SIPHASH;
10327 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10328 parse_func = siphash_parse_hash;
10329 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10330 opti_type = OPTI_TYPE_ZERO_BYTE
10331 | OPTI_TYPE_NOT_ITERATED
10332 | OPTI_TYPE_RAW_HASH;
10333 dgst_pos0 = 0;
10334 dgst_pos1 = 1;
10335 dgst_pos2 = 2;
10336 dgst_pos3 = 3;
10337 break;
10338
10339 case 10200: hash_type = HASH_TYPE_MD5;
10340 salt_type = SALT_TYPE_EMBEDDED;
10341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10342 opts_type = OPTS_TYPE_PT_GENERATE_LE
10343 | OPTS_TYPE_ST_ADD80
10344 | OPTS_TYPE_ST_ADDBITS14;
10345 kern_type = KERN_TYPE_HMACMD5_PW;
10346 dgst_size = DGST_SIZE_4_4;
10347 parse_func = crammd5_parse_hash;
10348 sort_by_digest = sort_by_digest_4_4;
10349 opti_type = OPTI_TYPE_ZERO_BYTE
10350 | OPTI_TYPE_NOT_ITERATED;
10351 dgst_pos0 = 0;
10352 dgst_pos1 = 3;
10353 dgst_pos2 = 2;
10354 dgst_pos3 = 1;
10355 break;
10356
10357 case 10300: hash_type = HASH_TYPE_SHA1;
10358 salt_type = SALT_TYPE_EMBEDDED;
10359 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10360 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10361 kern_type = KERN_TYPE_SAPH_SHA1;
10362 dgst_size = DGST_SIZE_4_5;
10363 parse_func = saph_sha1_parse_hash;
10364 sort_by_digest = sort_by_digest_4_5;
10365 opti_type = OPTI_TYPE_ZERO_BYTE;
10366 dgst_pos0 = 0;
10367 dgst_pos1 = 1;
10368 dgst_pos2 = 2;
10369 dgst_pos3 = 3;
10370 break;
10371
10372 case 10400: hash_type = HASH_TYPE_PDFU16;
10373 salt_type = SALT_TYPE_EMBEDDED;
10374 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10375 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10376 kern_type = KERN_TYPE_PDF11;
10377 dgst_size = DGST_SIZE_4_4;
10378 parse_func = pdf11_parse_hash;
10379 sort_by_digest = sort_by_digest_4_4;
10380 opti_type = OPTI_TYPE_ZERO_BYTE
10381 | OPTI_TYPE_NOT_ITERATED;
10382 dgst_pos0 = 0;
10383 dgst_pos1 = 1;
10384 dgst_pos2 = 2;
10385 dgst_pos3 = 3;
10386 break;
10387
10388 case 10410: hash_type = HASH_TYPE_PDFU16;
10389 salt_type = SALT_TYPE_EMBEDDED;
10390 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10391 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10392 kern_type = KERN_TYPE_PDF11CM1;
10393 dgst_size = DGST_SIZE_4_4;
10394 parse_func = pdf11cm1_parse_hash;
10395 sort_by_digest = sort_by_digest_4_4;
10396 opti_type = OPTI_TYPE_ZERO_BYTE
10397 | OPTI_TYPE_NOT_ITERATED;
10398 dgst_pos0 = 0;
10399 dgst_pos1 = 1;
10400 dgst_pos2 = 2;
10401 dgst_pos3 = 3;
10402 break;
10403
10404 case 10420: hash_type = HASH_TYPE_PDFU16;
10405 salt_type = SALT_TYPE_EMBEDDED;
10406 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10407 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10408 kern_type = KERN_TYPE_PDF11CM2;
10409 dgst_size = DGST_SIZE_4_4;
10410 parse_func = pdf11cm2_parse_hash;
10411 sort_by_digest = sort_by_digest_4_4;
10412 opti_type = OPTI_TYPE_ZERO_BYTE
10413 | OPTI_TYPE_NOT_ITERATED;
10414 dgst_pos0 = 0;
10415 dgst_pos1 = 1;
10416 dgst_pos2 = 2;
10417 dgst_pos3 = 3;
10418 break;
10419
10420 case 10500: hash_type = HASH_TYPE_PDFU16;
10421 salt_type = SALT_TYPE_EMBEDDED;
10422 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10423 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10424 kern_type = KERN_TYPE_PDF14;
10425 dgst_size = DGST_SIZE_4_4;
10426 parse_func = pdf14_parse_hash;
10427 sort_by_digest = sort_by_digest_4_4;
10428 opti_type = OPTI_TYPE_ZERO_BYTE
10429 | OPTI_TYPE_NOT_ITERATED;
10430 dgst_pos0 = 0;
10431 dgst_pos1 = 1;
10432 dgst_pos2 = 2;
10433 dgst_pos3 = 3;
10434 break;
10435
10436 case 10600: hash_type = HASH_TYPE_SHA256;
10437 salt_type = SALT_TYPE_EMBEDDED;
10438 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10439 opts_type = OPTS_TYPE_PT_GENERATE_BE
10440 | OPTS_TYPE_ST_ADD80
10441 | OPTS_TYPE_ST_ADDBITS15
10442 | OPTS_TYPE_HASH_COPY;
10443 kern_type = KERN_TYPE_SHA256_PWSLT;
10444 dgst_size = DGST_SIZE_4_8;
10445 parse_func = pdf17l3_parse_hash;
10446 sort_by_digest = sort_by_digest_4_8;
10447 opti_type = OPTI_TYPE_ZERO_BYTE
10448 | OPTI_TYPE_PRECOMPUTE_INIT
10449 | OPTI_TYPE_PRECOMPUTE_MERKLE
10450 | OPTI_TYPE_EARLY_SKIP
10451 | OPTI_TYPE_NOT_ITERATED
10452 | OPTI_TYPE_APPENDED_SALT
10453 | OPTI_TYPE_RAW_HASH;
10454 dgst_pos0 = 3;
10455 dgst_pos1 = 7;
10456 dgst_pos2 = 2;
10457 dgst_pos3 = 6;
10458 break;
10459
10460 case 10700: hash_type = HASH_TYPE_PDFU32;
10461 salt_type = SALT_TYPE_EMBEDDED;
10462 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10463 opts_type = OPTS_TYPE_PT_GENERATE_LE
10464 | OPTS_TYPE_HASH_COPY;
10465 kern_type = KERN_TYPE_PDF17L8;
10466 dgst_size = DGST_SIZE_4_8;
10467 parse_func = pdf17l8_parse_hash;
10468 sort_by_digest = sort_by_digest_4_8;
10469 opti_type = OPTI_TYPE_ZERO_BYTE
10470 | OPTI_TYPE_NOT_ITERATED;
10471 dgst_pos0 = 0;
10472 dgst_pos1 = 1;
10473 dgst_pos2 = 2;
10474 dgst_pos3 = 3;
10475 break;
10476
10477 case 10800: hash_type = HASH_TYPE_SHA384;
10478 salt_type = SALT_TYPE_NONE;
10479 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10480 opts_type = OPTS_TYPE_PT_GENERATE_BE
10481 | OPTS_TYPE_PT_ADD80
10482 | OPTS_TYPE_PT_ADDBITS15;
10483 kern_type = KERN_TYPE_SHA384;
10484 dgst_size = DGST_SIZE_8_8;
10485 parse_func = sha384_parse_hash;
10486 sort_by_digest = sort_by_digest_8_8;
10487 opti_type = OPTI_TYPE_ZERO_BYTE
10488 | OPTI_TYPE_PRECOMPUTE_INIT
10489 | OPTI_TYPE_PRECOMPUTE_MERKLE
10490 | OPTI_TYPE_EARLY_SKIP
10491 | OPTI_TYPE_NOT_ITERATED
10492 | OPTI_TYPE_NOT_SALTED
10493 | OPTI_TYPE_USES_BITS_64
10494 | OPTI_TYPE_RAW_HASH;
10495 dgst_pos0 = 6;
10496 dgst_pos1 = 7;
10497 dgst_pos2 = 4;
10498 dgst_pos3 = 5;
10499 break;
10500
10501 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10502 salt_type = SALT_TYPE_EMBEDDED;
10503 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10504 opts_type = OPTS_TYPE_PT_GENERATE_LE
10505 | OPTS_TYPE_ST_BASE64
10506 | OPTS_TYPE_HASH_COPY;
10507 kern_type = KERN_TYPE_PBKDF2_SHA256;
10508 dgst_size = DGST_SIZE_4_32;
10509 parse_func = pbkdf2_sha256_parse_hash;
10510 sort_by_digest = sort_by_digest_4_32;
10511 opti_type = OPTI_TYPE_ZERO_BYTE
10512 | OPTI_TYPE_SLOW_HASH_SIMD;
10513 dgst_pos0 = 0;
10514 dgst_pos1 = 1;
10515 dgst_pos2 = 2;
10516 dgst_pos3 = 3;
10517 break;
10518
10519 case 11000: hash_type = HASH_TYPE_MD5;
10520 salt_type = SALT_TYPE_INTERN;
10521 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10522 opts_type = OPTS_TYPE_PT_GENERATE_LE
10523 | OPTS_TYPE_PT_ADD80;
10524 kern_type = KERN_TYPE_PRESTASHOP;
10525 dgst_size = DGST_SIZE_4_4;
10526 parse_func = prestashop_parse_hash;
10527 sort_by_digest = sort_by_digest_4_4;
10528 opti_type = OPTI_TYPE_ZERO_BYTE
10529 | OPTI_TYPE_PRECOMPUTE_INIT
10530 | OPTI_TYPE_NOT_ITERATED
10531 | OPTI_TYPE_PREPENDED_SALT;
10532 dgst_pos0 = 0;
10533 dgst_pos1 = 3;
10534 dgst_pos2 = 2;
10535 dgst_pos3 = 1;
10536 break;
10537
10538 case 11100: hash_type = HASH_TYPE_MD5;
10539 salt_type = SALT_TYPE_EMBEDDED;
10540 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10541 opts_type = OPTS_TYPE_PT_GENERATE_LE
10542 | OPTS_TYPE_ST_ADD80;
10543 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10544 dgst_size = DGST_SIZE_4_4;
10545 parse_func = postgresql_auth_parse_hash;
10546 sort_by_digest = sort_by_digest_4_4;
10547 opti_type = OPTI_TYPE_ZERO_BYTE
10548 | OPTI_TYPE_PRECOMPUTE_INIT
10549 | OPTI_TYPE_PRECOMPUTE_MERKLE
10550 | OPTI_TYPE_EARLY_SKIP;
10551 dgst_pos0 = 0;
10552 dgst_pos1 = 3;
10553 dgst_pos2 = 2;
10554 dgst_pos3 = 1;
10555 break;
10556
10557 case 11200: hash_type = HASH_TYPE_SHA1;
10558 salt_type = SALT_TYPE_EMBEDDED;
10559 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10560 opts_type = OPTS_TYPE_PT_GENERATE_BE
10561 | OPTS_TYPE_PT_ADD80
10562 | OPTS_TYPE_ST_HEX;
10563 kern_type = KERN_TYPE_MYSQL_AUTH;
10564 dgst_size = DGST_SIZE_4_5;
10565 parse_func = mysql_auth_parse_hash;
10566 sort_by_digest = sort_by_digest_4_5;
10567 opti_type = OPTI_TYPE_ZERO_BYTE
10568 | OPTI_TYPE_EARLY_SKIP;
10569 dgst_pos0 = 3;
10570 dgst_pos1 = 4;
10571 dgst_pos2 = 2;
10572 dgst_pos3 = 1;
10573 break;
10574
10575 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10576 salt_type = SALT_TYPE_EMBEDDED;
10577 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10578 opts_type = OPTS_TYPE_PT_GENERATE_LE
10579 | OPTS_TYPE_ST_HEX
10580 | OPTS_TYPE_ST_ADD80;
10581 kern_type = KERN_TYPE_BITCOIN_WALLET;
10582 dgst_size = DGST_SIZE_4_4;
10583 parse_func = bitcoin_wallet_parse_hash;
10584 sort_by_digest = sort_by_digest_4_4;
10585 opti_type = OPTI_TYPE_ZERO_BYTE;
10586 dgst_pos0 = 0;
10587 dgst_pos1 = 1;
10588 dgst_pos2 = 2;
10589 dgst_pos3 = 3;
10590 break;
10591
10592 case 11400: hash_type = HASH_TYPE_MD5;
10593 salt_type = SALT_TYPE_EMBEDDED;
10594 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10595 opts_type = OPTS_TYPE_PT_GENERATE_LE
10596 | OPTS_TYPE_PT_ADD80
10597 | OPTS_TYPE_HASH_COPY;
10598 kern_type = KERN_TYPE_SIP_AUTH;
10599 dgst_size = DGST_SIZE_4_4;
10600 parse_func = sip_auth_parse_hash;
10601 sort_by_digest = sort_by_digest_4_4;
10602 opti_type = OPTI_TYPE_ZERO_BYTE;
10603 dgst_pos0 = 0;
10604 dgst_pos1 = 3;
10605 dgst_pos2 = 2;
10606 dgst_pos3 = 1;
10607 break;
10608
10609 case 11500: hash_type = HASH_TYPE_CRC32;
10610 salt_type = SALT_TYPE_INTERN;
10611 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10612 opts_type = OPTS_TYPE_PT_GENERATE_LE
10613 | OPTS_TYPE_ST_GENERATE_LE
10614 | OPTS_TYPE_ST_HEX;
10615 kern_type = KERN_TYPE_CRC32;
10616 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10617 parse_func = crc32_parse_hash;
10618 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10619 opti_type = OPTI_TYPE_ZERO_BYTE;
10620 dgst_pos0 = 0;
10621 dgst_pos1 = 1;
10622 dgst_pos2 = 2;
10623 dgst_pos3 = 3;
10624 break;
10625
10626 case 11600: hash_type = HASH_TYPE_AES;
10627 salt_type = SALT_TYPE_EMBEDDED;
10628 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10629 opts_type = OPTS_TYPE_PT_GENERATE_LE
10630 | OPTS_TYPE_PT_NEVERCRACK;
10631 kern_type = KERN_TYPE_SEVEN_ZIP;
10632 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10633 parse_func = seven_zip_parse_hash;
10634 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10635 opti_type = OPTI_TYPE_ZERO_BYTE;
10636 dgst_pos0 = 0;
10637 dgst_pos1 = 1;
10638 dgst_pos2 = 2;
10639 dgst_pos3 = 3;
10640 break;
10641
10642 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10643 salt_type = SALT_TYPE_NONE;
10644 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10645 opts_type = OPTS_TYPE_PT_GENERATE_LE
10646 | OPTS_TYPE_PT_ADD01;
10647 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10648 dgst_size = DGST_SIZE_4_8;
10649 parse_func = gost2012sbog_256_parse_hash;
10650 sort_by_digest = sort_by_digest_4_8;
10651 opti_type = OPTI_TYPE_ZERO_BYTE;
10652 dgst_pos0 = 0;
10653 dgst_pos1 = 1;
10654 dgst_pos2 = 2;
10655 dgst_pos3 = 3;
10656 break;
10657
10658 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10659 salt_type = SALT_TYPE_NONE;
10660 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10661 opts_type = OPTS_TYPE_PT_GENERATE_LE
10662 | OPTS_TYPE_PT_ADD01;
10663 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10664 dgst_size = DGST_SIZE_4_16;
10665 parse_func = gost2012sbog_512_parse_hash;
10666 sort_by_digest = sort_by_digest_4_16;
10667 opti_type = OPTI_TYPE_ZERO_BYTE;
10668 dgst_pos0 = 0;
10669 dgst_pos1 = 1;
10670 dgst_pos2 = 2;
10671 dgst_pos3 = 3;
10672 break;
10673
10674 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10675 salt_type = SALT_TYPE_EMBEDDED;
10676 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10677 opts_type = OPTS_TYPE_PT_GENERATE_LE
10678 | OPTS_TYPE_ST_BASE64
10679 | OPTS_TYPE_HASH_COPY;
10680 kern_type = KERN_TYPE_PBKDF2_MD5;
10681 dgst_size = DGST_SIZE_4_32;
10682 parse_func = pbkdf2_md5_parse_hash;
10683 sort_by_digest = sort_by_digest_4_32;
10684 opti_type = OPTI_TYPE_ZERO_BYTE
10685 | OPTI_TYPE_SLOW_HASH_SIMD;
10686 dgst_pos0 = 0;
10687 dgst_pos1 = 1;
10688 dgst_pos2 = 2;
10689 dgst_pos3 = 3;
10690 break;
10691
10692 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10693 salt_type = SALT_TYPE_EMBEDDED;
10694 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10695 opts_type = OPTS_TYPE_PT_GENERATE_LE
10696 | OPTS_TYPE_ST_BASE64
10697 | OPTS_TYPE_HASH_COPY;
10698 kern_type = KERN_TYPE_PBKDF2_SHA1;
10699 dgst_size = DGST_SIZE_4_32;
10700 parse_func = pbkdf2_sha1_parse_hash;
10701 sort_by_digest = sort_by_digest_4_32;
10702 opti_type = OPTI_TYPE_ZERO_BYTE
10703 | OPTI_TYPE_SLOW_HASH_SIMD;
10704 dgst_pos0 = 0;
10705 dgst_pos1 = 1;
10706 dgst_pos2 = 2;
10707 dgst_pos3 = 3;
10708 break;
10709
10710 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10711 salt_type = SALT_TYPE_EMBEDDED;
10712 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10713 opts_type = OPTS_TYPE_PT_GENERATE_LE
10714 | OPTS_TYPE_ST_BASE64
10715 | OPTS_TYPE_HASH_COPY;
10716 kern_type = KERN_TYPE_PBKDF2_SHA512;
10717 dgst_size = DGST_SIZE_8_16;
10718 parse_func = pbkdf2_sha512_parse_hash;
10719 sort_by_digest = sort_by_digest_8_16;
10720 opti_type = OPTI_TYPE_ZERO_BYTE
10721 | OPTI_TYPE_USES_BITS_64
10722 | OPTI_TYPE_SLOW_HASH_SIMD;
10723 dgst_pos0 = 0;
10724 dgst_pos1 = 1;
10725 dgst_pos2 = 2;
10726 dgst_pos3 = 3;
10727 break;
10728
10729 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10730 salt_type = SALT_TYPE_EMBEDDED;
10731 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10732 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10733 kern_type = KERN_TYPE_ECRYPTFS;
10734 dgst_size = DGST_SIZE_8_8;
10735 parse_func = ecryptfs_parse_hash;
10736 sort_by_digest = sort_by_digest_8_8;
10737 opti_type = OPTI_TYPE_ZERO_BYTE
10738 | OPTI_TYPE_USES_BITS_64;
10739 dgst_pos0 = 0;
10740 dgst_pos1 = 1;
10741 dgst_pos2 = 2;
10742 dgst_pos3 = 3;
10743 break;
10744
10745 case 12300: hash_type = HASH_TYPE_ORACLET;
10746 salt_type = SALT_TYPE_EMBEDDED;
10747 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10748 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10749 kern_type = KERN_TYPE_ORACLET;
10750 dgst_size = DGST_SIZE_8_16;
10751 parse_func = oraclet_parse_hash;
10752 sort_by_digest = sort_by_digest_8_16;
10753 opti_type = OPTI_TYPE_ZERO_BYTE
10754 | OPTI_TYPE_USES_BITS_64;
10755 dgst_pos0 = 0;
10756 dgst_pos1 = 1;
10757 dgst_pos2 = 2;
10758 dgst_pos3 = 3;
10759 break;
10760
10761 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10762 salt_type = SALT_TYPE_EMBEDDED;
10763 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10764 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10765 kern_type = KERN_TYPE_BSDICRYPT;
10766 dgst_size = DGST_SIZE_4_4;
10767 parse_func = bsdicrypt_parse_hash;
10768 sort_by_digest = sort_by_digest_4_4;
10769 opti_type = OPTI_TYPE_ZERO_BYTE
10770 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10771 dgst_pos0 = 0;
10772 dgst_pos1 = 1;
10773 dgst_pos2 = 2;
10774 dgst_pos3 = 3;
10775 break;
10776
10777 case 12500: hash_type = HASH_TYPE_RAR3HP;
10778 salt_type = SALT_TYPE_EMBEDDED;
10779 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10780 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10781 kern_type = KERN_TYPE_RAR3;
10782 dgst_size = DGST_SIZE_4_4;
10783 parse_func = rar3hp_parse_hash;
10784 sort_by_digest = sort_by_digest_4_4;
10785 opti_type = OPTI_TYPE_ZERO_BYTE;
10786 dgst_pos0 = 0;
10787 dgst_pos1 = 1;
10788 dgst_pos2 = 2;
10789 dgst_pos3 = 3;
10790 break;
10791
10792 case 12600: hash_type = HASH_TYPE_SHA256;
10793 salt_type = SALT_TYPE_INTERN;
10794 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10795 opts_type = OPTS_TYPE_PT_GENERATE_BE
10796 | OPTS_TYPE_PT_ADD80;
10797 kern_type = KERN_TYPE_CF10;
10798 dgst_size = DGST_SIZE_4_8;
10799 parse_func = cf10_parse_hash;
10800 sort_by_digest = sort_by_digest_4_8;
10801 opti_type = OPTI_TYPE_ZERO_BYTE
10802 | OPTI_TYPE_PRECOMPUTE_INIT
10803 | OPTI_TYPE_EARLY_SKIP
10804 | OPTI_TYPE_NOT_ITERATED;
10805 dgst_pos0 = 3;
10806 dgst_pos1 = 7;
10807 dgst_pos2 = 2;
10808 dgst_pos3 = 6;
10809 break;
10810
10811 case 12700: hash_type = HASH_TYPE_AES;
10812 salt_type = SALT_TYPE_EMBEDDED;
10813 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10814 opts_type = OPTS_TYPE_PT_GENERATE_LE
10815 | OPTS_TYPE_HASH_COPY;
10816 kern_type = KERN_TYPE_MYWALLET;
10817 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10818 parse_func = mywallet_parse_hash;
10819 sort_by_digest = sort_by_digest_4_5;
10820 opti_type = OPTI_TYPE_ZERO_BYTE;
10821 dgst_pos0 = 0;
10822 dgst_pos1 = 1;
10823 dgst_pos2 = 2;
10824 dgst_pos3 = 3;
10825 break;
10826
10827 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10828 salt_type = SALT_TYPE_EMBEDDED;
10829 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10830 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10831 kern_type = KERN_TYPE_MS_DRSR;
10832 dgst_size = DGST_SIZE_4_8;
10833 parse_func = ms_drsr_parse_hash;
10834 sort_by_digest = sort_by_digest_4_8;
10835 opti_type = OPTI_TYPE_ZERO_BYTE;
10836 dgst_pos0 = 0;
10837 dgst_pos1 = 1;
10838 dgst_pos2 = 2;
10839 dgst_pos3 = 3;
10840 break;
10841
10842 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10843 salt_type = SALT_TYPE_EMBEDDED;
10844 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10845 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10846 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10847 dgst_size = DGST_SIZE_4_8;
10848 parse_func = androidfde_samsung_parse_hash;
10849 sort_by_digest = sort_by_digest_4_8;
10850 opti_type = OPTI_TYPE_ZERO_BYTE;
10851 dgst_pos0 = 0;
10852 dgst_pos1 = 1;
10853 dgst_pos2 = 2;
10854 dgst_pos3 = 3;
10855 break;
10856
10857 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10858 salt_type = SALT_TYPE_EMBEDDED;
10859 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10860 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10861 kern_type = KERN_TYPE_RAR5;
10862 dgst_size = DGST_SIZE_4_4;
10863 parse_func = rar5_parse_hash;
10864 sort_by_digest = sort_by_digest_4_4;
10865 opti_type = OPTI_TYPE_ZERO_BYTE;
10866 dgst_pos0 = 0;
10867 dgst_pos1 = 1;
10868 dgst_pos2 = 2;
10869 dgst_pos3 = 3;
10870 break;
10871
10872 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10873 salt_type = SALT_TYPE_EMBEDDED;
10874 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10875 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10876 kern_type = KERN_TYPE_KRB5TGS;
10877 dgst_size = DGST_SIZE_4_4;
10878 parse_func = krb5tgs_parse_hash;
10879 sort_by_digest = sort_by_digest_4_4;
10880 opti_type = OPTI_TYPE_ZERO_BYTE
10881 | OPTI_TYPE_NOT_ITERATED;
10882 dgst_pos0 = 0;
10883 dgst_pos1 = 1;
10884 dgst_pos2 = 2;
10885 dgst_pos3 = 3;
10886 break;
10887
10888 case 13200: hash_type = HASH_TYPE_AES;
10889 salt_type = SALT_TYPE_EMBEDDED;
10890 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10891 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10892 kern_type = KERN_TYPE_AXCRYPT;
10893 dgst_size = DGST_SIZE_4_4;
10894 parse_func = axcrypt_parse_hash;
10895 sort_by_digest = sort_by_digest_4_4;
10896 opti_type = OPTI_TYPE_ZERO_BYTE;
10897 dgst_pos0 = 0;
10898 dgst_pos1 = 1;
10899 dgst_pos2 = 2;
10900 dgst_pos3 = 3;
10901 break;
10902
10903 case 13300: hash_type = HASH_TYPE_SHA1;
10904 salt_type = SALT_TYPE_NONE;
10905 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10906 opts_type = OPTS_TYPE_PT_GENERATE_BE
10907 | OPTS_TYPE_PT_ADD80
10908 | OPTS_TYPE_PT_ADDBITS15;
10909 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10910 dgst_size = DGST_SIZE_4_5;
10911 parse_func = sha1axcrypt_parse_hash;
10912 sort_by_digest = sort_by_digest_4_5;
10913 opti_type = OPTI_TYPE_ZERO_BYTE
10914 | OPTI_TYPE_PRECOMPUTE_INIT
10915 | OPTI_TYPE_EARLY_SKIP
10916 | OPTI_TYPE_NOT_ITERATED
10917 | OPTI_TYPE_NOT_SALTED;
10918 dgst_pos0 = 0;
10919 dgst_pos1 = 4;
10920 dgst_pos2 = 3;
10921 dgst_pos3 = 2;
10922 break;
10923
10924 case 13400: hash_type = HASH_TYPE_AES;
10925 salt_type = SALT_TYPE_EMBEDDED;
10926 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10927 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10928 kern_type = KERN_TYPE_KEEPASS;
10929 dgst_size = DGST_SIZE_4_4;
10930 parse_func = keepass_parse_hash;
10931 sort_by_digest = sort_by_digest_4_4;
10932 opti_type = OPTI_TYPE_ZERO_BYTE;
10933 dgst_pos0 = 0;
10934 dgst_pos1 = 1;
10935 dgst_pos2 = 2;
10936 dgst_pos3 = 3;
10937 break;
10938
10939 case 13500: hash_type = HASH_TYPE_SHA1;
10940 salt_type = SALT_TYPE_EMBEDDED;
10941 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10942 opts_type = OPTS_TYPE_PT_GENERATE_BE
10943 | OPTS_TYPE_PT_UNICODE
10944 | OPTS_TYPE_PT_ADD80;
10945 kern_type = KERN_TYPE_PSTOKEN;
10946 dgst_size = DGST_SIZE_4_5;
10947 parse_func = pstoken_parse_hash;
10948 sort_by_digest = sort_by_digest_4_5;
10949 opti_type = OPTI_TYPE_ZERO_BYTE
10950 | OPTI_TYPE_PRECOMPUTE_INIT
10951 | OPTI_TYPE_EARLY_SKIP
10952 | OPTI_TYPE_NOT_ITERATED
10953 | OPTI_TYPE_PREPENDED_SALT
10954 | OPTI_TYPE_RAW_HASH;
10955 dgst_pos0 = 3;
10956 dgst_pos1 = 4;
10957 dgst_pos2 = 2;
10958 dgst_pos3 = 1;
10959 break;
10960
10961 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10962 salt_type = SALT_TYPE_EMBEDDED;
10963 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10964 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10965 kern_type = KERN_TYPE_ZIP2;
10966 dgst_size = DGST_SIZE_4_4;
10967 parse_func = zip2_parse_hash;
10968 sort_by_digest = sort_by_digest_4_4;
10969 opti_type = OPTI_TYPE_ZERO_BYTE;
10970 dgst_pos0 = 0;
10971 dgst_pos1 = 1;
10972 dgst_pos2 = 2;
10973 dgst_pos3 = 3;
10974 break;
10975
10976 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10977 salt_type = SALT_TYPE_EMBEDDED;
10978 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10979 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10980 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10981 dgst_size = DGST_SIZE_4_5;
10982 parse_func = veracrypt_parse_hash_655331;
10983 sort_by_digest = sort_by_digest_4_5;
10984 opti_type = OPTI_TYPE_ZERO_BYTE;
10985 dgst_pos0 = 0;
10986 dgst_pos1 = 1;
10987 dgst_pos2 = 2;
10988 dgst_pos3 = 3;
10989 break;
10990
10991 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10992 salt_type = SALT_TYPE_EMBEDDED;
10993 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10994 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10995 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10996 dgst_size = DGST_SIZE_4_5;
10997 parse_func = veracrypt_parse_hash_655331;
10998 sort_by_digest = sort_by_digest_4_5;
10999 opti_type = OPTI_TYPE_ZERO_BYTE;
11000 dgst_pos0 = 0;
11001 dgst_pos1 = 1;
11002 dgst_pos2 = 2;
11003 dgst_pos3 = 3;
11004 break;
11005
11006 case 13713: hash_type = HASH_TYPE_RIPEMD160;
11007 salt_type = SALT_TYPE_EMBEDDED;
11008 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11009 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11010 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11011 dgst_size = DGST_SIZE_4_5;
11012 parse_func = veracrypt_parse_hash_655331;
11013 sort_by_digest = sort_by_digest_4_5;
11014 opti_type = OPTI_TYPE_ZERO_BYTE;
11015 dgst_pos0 = 0;
11016 dgst_pos1 = 1;
11017 dgst_pos2 = 2;
11018 dgst_pos3 = 3;
11019 break;
11020
11021 case 13721: hash_type = HASH_TYPE_SHA512;
11022 salt_type = SALT_TYPE_EMBEDDED;
11023 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11024 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11025 kern_type = KERN_TYPE_TCSHA512_XTS512;
11026 dgst_size = DGST_SIZE_8_8;
11027 parse_func = veracrypt_parse_hash_500000;
11028 sort_by_digest = sort_by_digest_8_8;
11029 opti_type = OPTI_TYPE_ZERO_BYTE
11030 | OPTI_TYPE_USES_BITS_64;
11031 dgst_pos0 = 0;
11032 dgst_pos1 = 1;
11033 dgst_pos2 = 2;
11034 dgst_pos3 = 3;
11035 break;
11036
11037 case 13722: hash_type = HASH_TYPE_SHA512;
11038 salt_type = SALT_TYPE_EMBEDDED;
11039 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11040 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11041 kern_type = KERN_TYPE_TCSHA512_XTS1024;
11042 dgst_size = DGST_SIZE_8_8;
11043 parse_func = veracrypt_parse_hash_500000;
11044 sort_by_digest = sort_by_digest_8_8;
11045 opti_type = OPTI_TYPE_ZERO_BYTE
11046 | OPTI_TYPE_USES_BITS_64;
11047 dgst_pos0 = 0;
11048 dgst_pos1 = 1;
11049 dgst_pos2 = 2;
11050 dgst_pos3 = 3;
11051 break;
11052
11053 case 13723: hash_type = HASH_TYPE_SHA512;
11054 salt_type = SALT_TYPE_EMBEDDED;
11055 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11056 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11057 kern_type = KERN_TYPE_TCSHA512_XTS1536;
11058 dgst_size = DGST_SIZE_8_8;
11059 parse_func = veracrypt_parse_hash_500000;
11060 sort_by_digest = sort_by_digest_8_8;
11061 opti_type = OPTI_TYPE_ZERO_BYTE
11062 | OPTI_TYPE_USES_BITS_64;
11063 dgst_pos0 = 0;
11064 dgst_pos1 = 1;
11065 dgst_pos2 = 2;
11066 dgst_pos3 = 3;
11067 break;
11068
11069 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
11070 salt_type = SALT_TYPE_EMBEDDED;
11071 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11072 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11073 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
11074 dgst_size = DGST_SIZE_4_8;
11075 parse_func = veracrypt_parse_hash_500000;
11076 sort_by_digest = sort_by_digest_4_8;
11077 opti_type = OPTI_TYPE_ZERO_BYTE;
11078 dgst_pos0 = 0;
11079 dgst_pos1 = 1;
11080 dgst_pos2 = 2;
11081 dgst_pos3 = 3;
11082 break;
11083
11084 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
11085 salt_type = SALT_TYPE_EMBEDDED;
11086 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11087 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11088 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
11089 dgst_size = DGST_SIZE_4_8;
11090 parse_func = veracrypt_parse_hash_500000;
11091 sort_by_digest = sort_by_digest_4_8;
11092 opti_type = OPTI_TYPE_ZERO_BYTE;
11093 dgst_pos0 = 0;
11094 dgst_pos1 = 1;
11095 dgst_pos2 = 2;
11096 dgst_pos3 = 3;
11097 break;
11098
11099 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
11100 salt_type = SALT_TYPE_EMBEDDED;
11101 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11102 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11103 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
11104 dgst_size = DGST_SIZE_4_8;
11105 parse_func = veracrypt_parse_hash_500000;
11106 sort_by_digest = sort_by_digest_4_8;
11107 opti_type = OPTI_TYPE_ZERO_BYTE;
11108 dgst_pos0 = 0;
11109 dgst_pos1 = 1;
11110 dgst_pos2 = 2;
11111 dgst_pos3 = 3;
11112 break;
11113
11114 case 13741: hash_type = HASH_TYPE_RIPEMD160;
11115 salt_type = SALT_TYPE_EMBEDDED;
11116 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11117 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11118 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
11119 dgst_size = DGST_SIZE_4_5;
11120 parse_func = veracrypt_parse_hash_327661;
11121 sort_by_digest = sort_by_digest_4_5;
11122 opti_type = OPTI_TYPE_ZERO_BYTE;
11123 dgst_pos0 = 0;
11124 dgst_pos1 = 1;
11125 dgst_pos2 = 2;
11126 dgst_pos3 = 3;
11127 break;
11128
11129 case 13742: hash_type = HASH_TYPE_RIPEMD160;
11130 salt_type = SALT_TYPE_EMBEDDED;
11131 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11132 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11133 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
11134 dgst_size = DGST_SIZE_4_5;
11135 parse_func = veracrypt_parse_hash_327661;
11136 sort_by_digest = sort_by_digest_4_5;
11137 opti_type = OPTI_TYPE_ZERO_BYTE;
11138 dgst_pos0 = 0;
11139 dgst_pos1 = 1;
11140 dgst_pos2 = 2;
11141 dgst_pos3 = 3;
11142 break;
11143
11144 case 13743: hash_type = HASH_TYPE_RIPEMD160;
11145 salt_type = SALT_TYPE_EMBEDDED;
11146 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11147 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11148 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11149 dgst_size = DGST_SIZE_4_5;
11150 parse_func = veracrypt_parse_hash_327661;
11151 sort_by_digest = sort_by_digest_4_5;
11152 opti_type = OPTI_TYPE_ZERO_BYTE;
11153 dgst_pos0 = 0;
11154 dgst_pos1 = 1;
11155 dgst_pos2 = 2;
11156 dgst_pos3 = 3;
11157 break;
11158
11159 case 13751: hash_type = HASH_TYPE_SHA256;
11160 salt_type = SALT_TYPE_EMBEDDED;
11161 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11162 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11163 kern_type = KERN_TYPE_VCSHA256_XTS512;
11164 dgst_size = DGST_SIZE_4_8;
11165 parse_func = veracrypt_parse_hash_500000;
11166 sort_by_digest = sort_by_digest_4_8;
11167 opti_type = OPTI_TYPE_ZERO_BYTE;
11168 dgst_pos0 = 0;
11169 dgst_pos1 = 1;
11170 dgst_pos2 = 2;
11171 dgst_pos3 = 3;
11172 break;
11173
11174 case 13752: hash_type = HASH_TYPE_SHA256;
11175 salt_type = SALT_TYPE_EMBEDDED;
11176 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11177 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11178 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11179 dgst_size = DGST_SIZE_4_8;
11180 parse_func = veracrypt_parse_hash_500000;
11181 sort_by_digest = sort_by_digest_4_8;
11182 opti_type = OPTI_TYPE_ZERO_BYTE;
11183 dgst_pos0 = 0;
11184 dgst_pos1 = 1;
11185 dgst_pos2 = 2;
11186 dgst_pos3 = 3;
11187 break;
11188
11189 case 13753: hash_type = HASH_TYPE_SHA256;
11190 salt_type = SALT_TYPE_EMBEDDED;
11191 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11192 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11193 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11194 dgst_size = DGST_SIZE_4_8;
11195 parse_func = veracrypt_parse_hash_500000;
11196 sort_by_digest = sort_by_digest_4_8;
11197 opti_type = OPTI_TYPE_ZERO_BYTE;
11198 dgst_pos0 = 0;
11199 dgst_pos1 = 1;
11200 dgst_pos2 = 2;
11201 dgst_pos3 = 3;
11202 break;
11203
11204 case 13761: hash_type = HASH_TYPE_SHA256;
11205 salt_type = SALT_TYPE_EMBEDDED;
11206 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11207 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11208 kern_type = KERN_TYPE_VCSHA256_XTS512;
11209 dgst_size = DGST_SIZE_4_8;
11210 parse_func = veracrypt_parse_hash_200000;
11211 sort_by_digest = sort_by_digest_4_8;
11212 opti_type = OPTI_TYPE_ZERO_BYTE;
11213 dgst_pos0 = 0;
11214 dgst_pos1 = 1;
11215 dgst_pos2 = 2;
11216 dgst_pos3 = 3;
11217 break;
11218
11219 case 13762: hash_type = HASH_TYPE_SHA256;
11220 salt_type = SALT_TYPE_EMBEDDED;
11221 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11222 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11223 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11224 dgst_size = DGST_SIZE_4_8;
11225 parse_func = veracrypt_parse_hash_200000;
11226 sort_by_digest = sort_by_digest_4_8;
11227 opti_type = OPTI_TYPE_ZERO_BYTE;
11228 dgst_pos0 = 0;
11229 dgst_pos1 = 1;
11230 dgst_pos2 = 2;
11231 dgst_pos3 = 3;
11232 break;
11233
11234 case 13763: hash_type = HASH_TYPE_SHA256;
11235 salt_type = SALT_TYPE_EMBEDDED;
11236 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11237 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11238 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11239 dgst_size = DGST_SIZE_4_8;
11240 parse_func = veracrypt_parse_hash_200000;
11241 sort_by_digest = sort_by_digest_4_8;
11242 opti_type = OPTI_TYPE_ZERO_BYTE;
11243 dgst_pos0 = 0;
11244 dgst_pos1 = 1;
11245 dgst_pos2 = 2;
11246 dgst_pos3 = 3;
11247 break;
11248
11249 case 13800: hash_type = HASH_TYPE_SHA256;
11250 salt_type = SALT_TYPE_EMBEDDED;
11251 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11252 opts_type = OPTS_TYPE_PT_GENERATE_BE
11253 | OPTS_TYPE_PT_UNICODE;
11254 kern_type = KERN_TYPE_WIN8PHONE;
11255 dgst_size = DGST_SIZE_4_8;
11256 parse_func = win8phone_parse_hash;
11257 sort_by_digest = sort_by_digest_4_8;
11258 opti_type = OPTI_TYPE_ZERO_BYTE
11259 | OPTI_TYPE_PRECOMPUTE_INIT
11260 | OPTI_TYPE_EARLY_SKIP
11261 | OPTI_TYPE_NOT_ITERATED
11262 | OPTI_TYPE_RAW_HASH;
11263 dgst_pos0 = 3;
11264 dgst_pos1 = 7;
11265 dgst_pos2 = 2;
11266 dgst_pos3 = 6;
11267 break;
11268
11269 default: usage_mini_print (PROGNAME); return (-1);
11270 }
11271
11272 /**
11273 * parser
11274 */
11275
11276 data.parse_func = parse_func;
11277
11278 /**
11279 * misc stuff
11280 */
11281
11282 if (hex_salt)
11283 {
11284 if (salt_type == SALT_TYPE_INTERN)
11285 {
11286 opts_type |= OPTS_TYPE_ST_HEX;
11287 }
11288 else
11289 {
11290 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11291
11292 return (-1);
11293 }
11294 }
11295
11296 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11297 | (salt_type == SALT_TYPE_EXTERN)
11298 | (salt_type == SALT_TYPE_EMBEDDED)
11299 | (salt_type == SALT_TYPE_VIRTUAL));
11300
11301 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
11302
11303 data.hash_type = hash_type;
11304 data.attack_mode = attack_mode;
11305 data.attack_kern = attack_kern;
11306 data.attack_exec = attack_exec;
11307 data.kern_type = kern_type;
11308 data.opts_type = opts_type;
11309 data.dgst_size = dgst_size;
11310 data.salt_type = salt_type;
11311 data.isSalted = isSalted;
11312 data.sort_by_digest = sort_by_digest;
11313 data.dgst_pos0 = dgst_pos0;
11314 data.dgst_pos1 = dgst_pos1;
11315 data.dgst_pos2 = dgst_pos2;
11316 data.dgst_pos3 = dgst_pos3;
11317
11318 esalt_size = 0;
11319
11320 switch (hash_mode)
11321 {
11322 case 2500: esalt_size = sizeof (wpa_t); break;
11323 case 5300: esalt_size = sizeof (ikepsk_t); break;
11324 case 5400: esalt_size = sizeof (ikepsk_t); break;
11325 case 5500: esalt_size = sizeof (netntlm_t); break;
11326 case 5600: esalt_size = sizeof (netntlm_t); break;
11327 case 6211: esalt_size = sizeof (tc_t); break;
11328 case 6212: esalt_size = sizeof (tc_t); break;
11329 case 6213: esalt_size = sizeof (tc_t); break;
11330 case 6221: esalt_size = sizeof (tc_t); break;
11331 case 6222: esalt_size = sizeof (tc_t); break;
11332 case 6223: esalt_size = sizeof (tc_t); break;
11333 case 6231: esalt_size = sizeof (tc_t); break;
11334 case 6232: esalt_size = sizeof (tc_t); break;
11335 case 6233: esalt_size = sizeof (tc_t); break;
11336 case 6241: esalt_size = sizeof (tc_t); break;
11337 case 6242: esalt_size = sizeof (tc_t); break;
11338 case 6243: esalt_size = sizeof (tc_t); break;
11339 case 6600: esalt_size = sizeof (agilekey_t); break;
11340 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11341 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
11342 case 7300: esalt_size = sizeof (rakp_t); break;
11343 case 7500: esalt_size = sizeof (krb5pa_t); break;
11344 case 8200: esalt_size = sizeof (cloudkey_t); break;
11345 case 8800: esalt_size = sizeof (androidfde_t); break;
11346 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
11347 case 9400: esalt_size = sizeof (office2007_t); break;
11348 case 9500: esalt_size = sizeof (office2010_t); break;
11349 case 9600: esalt_size = sizeof (office2013_t); break;
11350 case 9700: esalt_size = sizeof (oldoffice01_t); break;
11351 case 9710: esalt_size = sizeof (oldoffice01_t); break;
11352 case 9720: esalt_size = sizeof (oldoffice01_t); break;
11353 case 9800: esalt_size = sizeof (oldoffice34_t); break;
11354 case 9810: esalt_size = sizeof (oldoffice34_t); break;
11355 case 9820: esalt_size = sizeof (oldoffice34_t); break;
11356 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
11357 case 10200: esalt_size = sizeof (cram_md5_t); break;
11358 case 10400: esalt_size = sizeof (pdf_t); break;
11359 case 10410: esalt_size = sizeof (pdf_t); break;
11360 case 10420: esalt_size = sizeof (pdf_t); break;
11361 case 10500: esalt_size = sizeof (pdf_t); break;
11362 case 10600: esalt_size = sizeof (pdf_t); break;
11363 case 10700: esalt_size = sizeof (pdf_t); break;
11364 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
11365 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
11366 case 11400: esalt_size = sizeof (sip_t); break;
11367 case 11600: esalt_size = sizeof (seven_zip_t); break;
11368 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
11369 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
11370 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11371 case 13000: esalt_size = sizeof (rar5_t); break;
11372 case 13100: esalt_size = sizeof (krb5tgs_t); break;
11373 case 13400: esalt_size = sizeof (keepass_t); break;
11374 case 13500: esalt_size = sizeof (pstoken_t); break;
11375 case 13600: esalt_size = sizeof (zip2_t); break;
11376 case 13711: esalt_size = sizeof (tc_t); break;
11377 case 13712: esalt_size = sizeof (tc_t); break;
11378 case 13713: esalt_size = sizeof (tc_t); break;
11379 case 13721: esalt_size = sizeof (tc_t); break;
11380 case 13722: esalt_size = sizeof (tc_t); break;
11381 case 13723: esalt_size = sizeof (tc_t); break;
11382 case 13731: esalt_size = sizeof (tc_t); break;
11383 case 13732: esalt_size = sizeof (tc_t); break;
11384 case 13733: esalt_size = sizeof (tc_t); break;
11385 case 13741: esalt_size = sizeof (tc_t); break;
11386 case 13742: esalt_size = sizeof (tc_t); break;
11387 case 13743: esalt_size = sizeof (tc_t); break;
11388 case 13751: esalt_size = sizeof (tc_t); break;
11389 case 13752: esalt_size = sizeof (tc_t); break;
11390 case 13753: esalt_size = sizeof (tc_t); break;
11391 case 13761: esalt_size = sizeof (tc_t); break;
11392 case 13762: esalt_size = sizeof (tc_t); break;
11393 case 13763: esalt_size = sizeof (tc_t); break;
11394 case 13800: esalt_size = sizeof (win8phone_t); break;
11395 }
11396
11397 data.esalt_size = esalt_size;
11398
11399 /**
11400 * choose dictionary parser
11401 */
11402
11403 if (hash_type == HASH_TYPE_LM)
11404 {
11405 get_next_word_func = get_next_word_lm;
11406 }
11407 else if (opts_type & OPTS_TYPE_PT_UPPER)
11408 {
11409 get_next_word_func = get_next_word_uc;
11410 }
11411 else
11412 {
11413 get_next_word_func = get_next_word_std;
11414 }
11415
11416 /**
11417 * dictstat
11418 */
11419
11420 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11421
11422 #ifdef _POSIX
11423 size_t dictstat_nmemb = 0;
11424 #endif
11425
11426 #ifdef _WIN
11427 uint dictstat_nmemb = 0;
11428 #endif
11429
11430 char dictstat[256] = { 0 };
11431
11432 FILE *dictstat_fp = NULL;
11433
11434 if (keyspace == 0)
11435 {
11436 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11437
11438 dictstat_fp = fopen (dictstat, "rb");
11439
11440 if (dictstat_fp)
11441 {
11442 #ifdef _POSIX
11443 struct stat tmpstat;
11444
11445 fstat (fileno (dictstat_fp), &tmpstat);
11446 #endif
11447
11448 #ifdef _WIN
11449 struct stat64 tmpstat;
11450
11451 _fstat64 (fileno (dictstat_fp), &tmpstat);
11452 #endif
11453
11454 if (tmpstat.st_mtime < COMPTIME)
11455 {
11456 /* with v0.15 the format changed so we have to ensure user is using a good version
11457 since there is no version-header in the dictstat file */
11458
11459 fclose (dictstat_fp);
11460
11461 unlink (dictstat);
11462 }
11463 else
11464 {
11465 while (!feof (dictstat_fp))
11466 {
11467 dictstat_t d;
11468
11469 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11470
11471 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11472
11473 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11474 {
11475 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11476
11477 return -1;
11478 }
11479 }
11480
11481 fclose (dictstat_fp);
11482 }
11483 }
11484 }
11485
11486 /**
11487 * potfile
11488 */
11489
11490 char potfile[256] = { 0 };
11491
11492 if (potfile_path == NULL)
11493 {
11494 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11495 }
11496 else
11497 {
11498 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11499 }
11500
11501 data.pot_fp = NULL;
11502
11503 FILE *out_fp = NULL;
11504 FILE *pot_fp = NULL;
11505
11506 if (show == 1 || left == 1)
11507 {
11508 pot_fp = fopen (potfile, "rb");
11509
11510 if (pot_fp == NULL)
11511 {
11512 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11513
11514 return (-1);
11515 }
11516
11517 if (outfile != NULL)
11518 {
11519 if ((out_fp = fopen (outfile, "ab")) == NULL)
11520 {
11521 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11522
11523 fclose (pot_fp);
11524
11525 return (-1);
11526 }
11527 }
11528 else
11529 {
11530 out_fp = stdout;
11531 }
11532 }
11533 else
11534 {
11535 if (potfile_disable == 0)
11536 {
11537 pot_fp = fopen (potfile, "ab");
11538
11539 if (pot_fp == NULL)
11540 {
11541 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11542
11543 return (-1);
11544 }
11545
11546 data.pot_fp = pot_fp;
11547 }
11548 }
11549
11550 pot_t *pot = NULL;
11551
11552 uint pot_cnt = 0;
11553 uint pot_avail = 0;
11554
11555 if (show == 1 || left == 1)
11556 {
11557 SUPPRESS_OUTPUT = 1;
11558
11559 pot_avail = count_lines (pot_fp);
11560
11561 rewind (pot_fp);
11562
11563 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11564
11565 uint pot_hashes_avail = 0;
11566
11567 uint line_num = 0;
11568
11569 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11570
11571 while (!feof (pot_fp))
11572 {
11573 line_num++;
11574
11575 int line_len = fgetl (pot_fp, line_buf);
11576
11577 if (line_len == 0) continue;
11578
11579 char *plain_buf = line_buf + line_len;
11580
11581 pot_t *pot_ptr = &pot[pot_cnt];
11582
11583 hash_t *hashes_buf = &pot_ptr->hash;
11584
11585 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11586 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11587
11588 if (pot_cnt == pot_hashes_avail)
11589 {
11590 uint pos = 0;
11591
11592 for (pos = 0; pos < INCR_POT; pos++)
11593 {
11594 if ((pot_cnt + pos) >= pot_avail) break;
11595
11596 pot_t *tmp_pot = &pot[pot_cnt + pos];
11597
11598 hash_t *tmp_hash = &tmp_pot->hash;
11599
11600 tmp_hash->digest = mymalloc (dgst_size);
11601
11602 if (isSalted)
11603 {
11604 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11605 }
11606
11607 if (esalt_size)
11608 {
11609 tmp_hash->esalt = mymalloc (esalt_size);
11610 }
11611
11612 pot_hashes_avail++;
11613 }
11614 }
11615
11616 int plain_len = 0;
11617
11618 int parser_status;
11619
11620 int iter = MAX_CUT_TRIES;
11621
11622 do
11623 {
11624 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11625 {
11626 if (line_buf[i] == ':')
11627 {
11628 line_len--;
11629
11630 break;
11631 }
11632 }
11633
11634 if (data.hash_mode != 2500)
11635 {
11636 parser_status = parse_func (line_buf, line_len, hashes_buf);
11637 }
11638 else
11639 {
11640 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11641
11642 if (line_len > max_salt_size)
11643 {
11644 parser_status = PARSER_GLOBAL_LENGTH;
11645 }
11646 else
11647 {
11648 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11649
11650 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11651
11652 hashes_buf->salt->salt_len = line_len;
11653
11654 parser_status = PARSER_OK;
11655 }
11656 }
11657
11658 // if NOT parsed without error, we add the ":" to the plain
11659
11660 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11661 {
11662 plain_len++;
11663 plain_buf--;
11664 }
11665
11666 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11667
11668 if (parser_status < PARSER_GLOBAL_ZERO)
11669 {
11670 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11671
11672 continue;
11673 }
11674
11675 if (plain_len >= 255) continue;
11676
11677 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11678
11679 pot_ptr->plain_len = plain_len;
11680
11681 pot_cnt++;
11682 }
11683
11684 myfree (line_buf);
11685
11686 fclose (pot_fp);
11687
11688 SUPPRESS_OUTPUT = 0;
11689
11690 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11691 }
11692
11693 /**
11694 * word len
11695 */
11696
11697 uint pw_min = PW_MIN;
11698 uint pw_max = PW_MAX;
11699
11700 switch (hash_mode)
11701 {
11702 case 125: if (pw_max > 32) pw_max = 32;
11703 break;
11704 case 400: if (pw_max > 40) pw_max = 40;
11705 break;
11706 case 500: if (pw_max > 16) pw_max = 16;
11707 break;
11708 case 1500: if (pw_max > 8) pw_max = 8;
11709 break;
11710 case 1600: if (pw_max > 16) pw_max = 16;
11711 break;
11712 case 1800: if (pw_max > 16) pw_max = 16;
11713 break;
11714 case 2100: if (pw_max > 16) pw_max = 16;
11715 break;
11716 case 2500: if (pw_min < 8) pw_min = 8;
11717 break;
11718 case 3000: if (pw_max > 7) pw_max = 7;
11719 break;
11720 case 5200: if (pw_max > 24) pw_max = 24;
11721 break;
11722 case 5800: if (pw_max > 16) pw_max = 16;
11723 break;
11724 case 6300: if (pw_max > 16) pw_max = 16;
11725 break;
11726 case 7400: if (pw_max > 16) pw_max = 16;
11727 break;
11728 case 7700: if (pw_max > 8) pw_max = 8;
11729 break;
11730 case 7900: if (pw_max > 48) pw_max = 48;
11731 break;
11732 case 8500: if (pw_max > 8) pw_max = 8;
11733 break;
11734 case 8600: if (pw_max > 16) pw_max = 16;
11735 break;
11736 case 9710: pw_min = 5;
11737 pw_max = 5;
11738 break;
11739 case 9810: pw_min = 5;
11740 pw_max = 5;
11741 break;
11742 case 10410: pw_min = 5;
11743 pw_max = 5;
11744 break;
11745 case 10300: if (pw_max < 3) pw_min = 3;
11746 if (pw_max > 40) pw_max = 40;
11747 break;
11748 case 10500: if (pw_max < 3) pw_min = 3;
11749 if (pw_max > 40) pw_max = 40;
11750 break;
11751 case 10700: if (pw_max > 16) pw_max = 16;
11752 break;
11753 case 11300: if (pw_max > 40) pw_max = 40;
11754 break;
11755 case 11600: if (pw_max > 32) pw_max = 32;
11756 break;
11757 case 12500: if (pw_max > 20) pw_max = 20;
11758 break;
11759 case 12800: if (pw_max > 24) pw_max = 24;
11760 break;
11761 }
11762
11763 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11764 {
11765 switch (attack_kern)
11766 {
11767 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11768 break;
11769 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11770 break;
11771 }
11772 }
11773
11774 /**
11775 * charsets : keep them together for more easy maintainnce
11776 */
11777
11778 cs_t mp_sys[6] = { { { 0 }, 0 } };
11779 cs_t mp_usr[4] = { { { 0 }, 0 } };
11780
11781 mp_setup_sys (mp_sys);
11782
11783 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11784 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11785 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11786 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11787
11788 /**
11789 * load hashes, part I: find input mode, count hashes
11790 */
11791
11792 uint hashlist_mode = 0;
11793 uint hashlist_format = HLFMT_HASHCAT;
11794
11795 uint hashes_avail = 0;
11796
11797 if ((benchmark == 0) && (stdout_flag == 0))
11798 {
11799 struct stat f;
11800
11801 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11802
11803 if ((hash_mode == 2500) ||
11804 (hash_mode == 5200) ||
11805 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11806 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11807 (hash_mode == 9000))
11808 {
11809 hashlist_mode = HL_MODE_ARG;
11810
11811 char *hashfile = myargv[optind];
11812
11813 data.hashfile = hashfile;
11814
11815 logfile_top_var_string ("target", hashfile);
11816 }
11817
11818 if (hashlist_mode == HL_MODE_ARG)
11819 {
11820 if (hash_mode == 2500)
11821 {
11822 struct stat st;
11823
11824 if (stat (data.hashfile, &st) == -1)
11825 {
11826 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11827
11828 return (-1);
11829 }
11830
11831 hashes_avail = st.st_size / sizeof (hccap_t);
11832 }
11833 else
11834 {
11835 hashes_avail = 1;
11836 }
11837 }
11838 else if (hashlist_mode == HL_MODE_FILE)
11839 {
11840 char *hashfile = myargv[optind];
11841
11842 data.hashfile = hashfile;
11843
11844 logfile_top_var_string ("target", hashfile);
11845
11846 FILE *fp = NULL;
11847
11848 if ((fp = fopen (hashfile, "rb")) == NULL)
11849 {
11850 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11851
11852 return (-1);
11853 }
11854
11855 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11856
11857 hashes_avail = count_lines (fp);
11858
11859 rewind (fp);
11860
11861 if (hashes_avail == 0)
11862 {
11863 log_error ("ERROR: hashfile is empty or corrupt");
11864
11865 fclose (fp);
11866
11867 return (-1);
11868 }
11869
11870 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11871
11872 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11873 {
11874 log_error ("ERROR: remove not supported in native hashfile-format mode");
11875
11876 fclose (fp);
11877
11878 return (-1);
11879 }
11880
11881 fclose (fp);
11882 }
11883 }
11884 else
11885 {
11886 hashlist_mode = HL_MODE_ARG;
11887
11888 hashes_avail = 1;
11889 }
11890
11891 if (hash_mode == 3000) hashes_avail *= 2;
11892
11893 data.hashlist_mode = hashlist_mode;
11894 data.hashlist_format = hashlist_format;
11895
11896 logfile_top_uint (hashlist_mode);
11897 logfile_top_uint (hashlist_format);
11898
11899 /**
11900 * load hashes, part II: allocate required memory, set pointers
11901 */
11902
11903 hash_t *hashes_buf = NULL;
11904 void *digests_buf = NULL;
11905 salt_t *salts_buf = NULL;
11906 void *esalts_buf = NULL;
11907
11908 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11909
11910 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11911
11912 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11913 {
11914 u32 hash_pos;
11915
11916 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11917 {
11918 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11919
11920 hashes_buf[hash_pos].hash_info = hash_info;
11921
11922 if (username && (remove || show || left))
11923 {
11924 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11925 }
11926
11927 if (benchmark)
11928 {
11929 hash_info->orighash = (char *) mymalloc (256);
11930 }
11931 }
11932 }
11933
11934 if (isSalted)
11935 {
11936 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11937
11938 if (esalt_size)
11939 {
11940 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11941 }
11942 }
11943 else
11944 {
11945 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11946 }
11947
11948 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11949 {
11950 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11951
11952 if (isSalted)
11953 {
11954 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11955
11956 if (esalt_size)
11957 {
11958 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11959 }
11960 }
11961 else
11962 {
11963 hashes_buf[hash_pos].salt = &salts_buf[0];
11964 }
11965 }
11966
11967 /**
11968 * load hashes, part III: parse hashes or generate them if benchmark
11969 */
11970
11971 uint hashes_cnt = 0;
11972
11973 if (benchmark == 0)
11974 {
11975 if (keyspace == 1)
11976 {
11977 // useless to read hash file for keyspace, cheat a little bit w/ optind
11978 }
11979 else if (stdout_flag == 1)
11980 {
11981 // useless to read hash file for stdout, cheat a little bit w/ optind
11982 }
11983 else if (hashes_avail == 0)
11984 {
11985 }
11986 else if (hashlist_mode == HL_MODE_ARG)
11987 {
11988 char *input_buf = myargv[optind];
11989
11990 uint input_len = strlen (input_buf);
11991
11992 logfile_top_var_string ("target", input_buf);
11993
11994 char *hash_buf = NULL;
11995 int hash_len = 0;
11996
11997 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11998
11999 bool hash_fmt_error = 0;
12000
12001 if (hash_len < 1) hash_fmt_error = 1;
12002 if (hash_buf == NULL) hash_fmt_error = 1;
12003
12004 if (hash_fmt_error)
12005 {
12006 log_info ("WARNING: Failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12007 }
12008 else
12009 {
12010 if (opts_type & OPTS_TYPE_HASH_COPY)
12011 {
12012 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12013
12014 hash_info_tmp->orighash = mystrdup (hash_buf);
12015 }
12016
12017 if (isSalted)
12018 {
12019 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
12020 }
12021
12022 int parser_status = PARSER_OK;
12023
12024 if (hash_mode == 2500)
12025 {
12026 if (hash_len == 0)
12027 {
12028 log_error ("ERROR: hccap file not specified");
12029
12030 return (-1);
12031 }
12032
12033 hashlist_mode = HL_MODE_FILE;
12034
12035 data.hashlist_mode = hashlist_mode;
12036
12037 FILE *fp = fopen (hash_buf, "rb");
12038
12039 if (fp == NULL)
12040 {
12041 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
12042
12043 return (-1);
12044 }
12045
12046 if (hashes_avail < 1)
12047 {
12048 log_error ("ERROR: hccap file is empty or corrupt");
12049
12050 fclose (fp);
12051
12052 return (-1);
12053 }
12054
12055 uint hccap_size = sizeof (hccap_t);
12056
12057 char *in = (char *) mymalloc (hccap_size);
12058
12059 while (!feof (fp))
12060 {
12061 int n = fread (in, hccap_size, 1, fp);
12062
12063 if (n != 1)
12064 {
12065 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
12066
12067 break;
12068 }
12069
12070 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
12071
12072 if (parser_status != PARSER_OK)
12073 {
12074 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
12075
12076 continue;
12077 }
12078
12079 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
12080
12081 if ((show == 1) || (left == 1))
12082 {
12083 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
12084
12085 char *salt_ptr = (char *) tmp_salt->salt_buf;
12086
12087 int cur_pos = tmp_salt->salt_len;
12088 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12089
12090 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
12091
12092 // do the appending task
12093
12094 snprintf (salt_ptr + cur_pos,
12095 rem_len,
12096 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
12097 wpa->orig_mac1[0],
12098 wpa->orig_mac1[1],
12099 wpa->orig_mac1[2],
12100 wpa->orig_mac1[3],
12101 wpa->orig_mac1[4],
12102 wpa->orig_mac1[5],
12103 wpa->orig_mac2[0],
12104 wpa->orig_mac2[1],
12105 wpa->orig_mac2[2],
12106 wpa->orig_mac2[3],
12107 wpa->orig_mac2[4],
12108 wpa->orig_mac2[5]);
12109
12110 // memset () the remaining part of the salt
12111
12112 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
12113 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12114
12115 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
12116
12117 tmp_salt->salt_len += 1 + 12 + 1 + 12;
12118 }
12119
12120 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);
12121 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);
12122
12123 hashes_cnt++;
12124 }
12125
12126 fclose (fp);
12127
12128 myfree (in);
12129 }
12130 else if (hash_mode == 3000)
12131 {
12132 if (hash_len == 32)
12133 {
12134 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12135
12136 hash_t *lm_hash_left = NULL;
12137
12138 if (parser_status == PARSER_OK)
12139 {
12140 lm_hash_left = &hashes_buf[hashes_cnt];
12141
12142 hashes_cnt++;
12143 }
12144 else
12145 {
12146 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12147 }
12148
12149 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12150
12151 hash_t *lm_hash_right = NULL;
12152
12153 if (parser_status == PARSER_OK)
12154 {
12155 lm_hash_right = &hashes_buf[hashes_cnt];
12156
12157 hashes_cnt++;
12158 }
12159 else
12160 {
12161 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12162 }
12163
12164 // show / left
12165
12166 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12167 {
12168 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);
12169 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);
12170 }
12171 }
12172 else
12173 {
12174 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12175
12176 if (parser_status == PARSER_OK)
12177 {
12178 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12179 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12180 }
12181
12182 if (parser_status == PARSER_OK)
12183 {
12184 hashes_cnt++;
12185 }
12186 else
12187 {
12188 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12189 }
12190 }
12191 }
12192 else
12193 {
12194 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12195
12196 if (parser_status == PARSER_OK)
12197 {
12198 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12199 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12200 }
12201
12202 if (parser_status == PARSER_OK)
12203 {
12204 hashes_cnt++;
12205 }
12206 else
12207 {
12208 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12209 }
12210 }
12211 }
12212 }
12213 else if (hashlist_mode == HL_MODE_FILE)
12214 {
12215 char *hashfile = data.hashfile;
12216
12217 FILE *fp;
12218
12219 if ((fp = fopen (hashfile, "rb")) == NULL)
12220 {
12221 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12222
12223 return (-1);
12224 }
12225
12226 uint line_num = 0;
12227
12228 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12229
12230 while (!feof (fp))
12231 {
12232 line_num++;
12233
12234 int line_len = fgetl (fp, line_buf);
12235
12236 if (line_len == 0) continue;
12237
12238 char *hash_buf = NULL;
12239 int hash_len = 0;
12240
12241 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12242
12243 bool hash_fmt_error = 0;
12244
12245 if (hash_len < 1) hash_fmt_error = 1;
12246 if (hash_buf == NULL) hash_fmt_error = 1;
12247
12248 if (hash_fmt_error)
12249 {
12250 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12251
12252 continue;
12253 }
12254
12255 if (username)
12256 {
12257 char *user_buf = NULL;
12258 int user_len = 0;
12259
12260 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12261
12262 if (remove || show)
12263 {
12264 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12265
12266 *user = (user_t *) mymalloc (sizeof (user_t));
12267
12268 user_t *user_ptr = *user;
12269
12270 if (user_buf != NULL)
12271 {
12272 user_ptr->user_name = mystrdup (user_buf);
12273 }
12274 else
12275 {
12276 user_ptr->user_name = mystrdup ("");
12277 }
12278
12279 user_ptr->user_len = user_len;
12280 }
12281 }
12282
12283 if (opts_type & OPTS_TYPE_HASH_COPY)
12284 {
12285 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12286
12287 hash_info_tmp->orighash = mystrdup (hash_buf);
12288 }
12289
12290 if (isSalted)
12291 {
12292 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12293 }
12294
12295 if (hash_mode == 3000)
12296 {
12297 if (hash_len == 32)
12298 {
12299 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12300
12301 if (parser_status < PARSER_GLOBAL_ZERO)
12302 {
12303 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12304
12305 continue;
12306 }
12307
12308 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12309
12310 hashes_cnt++;
12311
12312 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12313
12314 if (parser_status < PARSER_GLOBAL_ZERO)
12315 {
12316 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12317
12318 continue;
12319 }
12320
12321 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12322
12323 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);
12324
12325 hashes_cnt++;
12326
12327 // show / left
12328
12329 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);
12330 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);
12331 }
12332 else
12333 {
12334 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12335
12336 if (parser_status < PARSER_GLOBAL_ZERO)
12337 {
12338 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12339
12340 continue;
12341 }
12342
12343 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);
12344
12345 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12346 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12347
12348 hashes_cnt++;
12349 }
12350 }
12351 else
12352 {
12353 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12354
12355 if (parser_status < PARSER_GLOBAL_ZERO)
12356 {
12357 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12358
12359 continue;
12360 }
12361
12362 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);
12363
12364 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12365 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12366
12367 hashes_cnt++;
12368 }
12369 }
12370
12371 myfree (line_buf);
12372
12373 fclose (fp);
12374
12375 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12376
12377 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12378 }
12379 }
12380 else
12381 {
12382 if (isSalted)
12383 {
12384 hashes_buf[0].salt->salt_len = 8;
12385
12386 // special salt handling
12387
12388 switch (hash_mode)
12389 {
12390 case 1500: hashes_buf[0].salt->salt_len = 2;
12391 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12392 break;
12393 case 1731: hashes_buf[0].salt->salt_len = 4;
12394 break;
12395 case 2410: hashes_buf[0].salt->salt_len = 4;
12396 break;
12397 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12398 break;
12399 case 3100: hashes_buf[0].salt->salt_len = 1;
12400 break;
12401 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
12402 break;
12403 case 5800: hashes_buf[0].salt->salt_len = 16;
12404 break;
12405 case 6800: hashes_buf[0].salt->salt_len = 32;
12406 break;
12407 case 8400: hashes_buf[0].salt->salt_len = 40;
12408 break;
12409 case 8800: hashes_buf[0].salt->salt_len = 16;
12410 break;
12411 case 8900: hashes_buf[0].salt->salt_len = 16;
12412 hashes_buf[0].salt->scrypt_N = 1024;
12413 hashes_buf[0].salt->scrypt_r = 1;
12414 hashes_buf[0].salt->scrypt_p = 1;
12415 break;
12416 case 9100: hashes_buf[0].salt->salt_len = 16;
12417 break;
12418 case 9300: hashes_buf[0].salt->salt_len = 14;
12419 hashes_buf[0].salt->scrypt_N = 16384;
12420 hashes_buf[0].salt->scrypt_r = 1;
12421 hashes_buf[0].salt->scrypt_p = 1;
12422 break;
12423 case 9400: hashes_buf[0].salt->salt_len = 16;
12424 break;
12425 case 9500: hashes_buf[0].salt->salt_len = 16;
12426 break;
12427 case 9600: hashes_buf[0].salt->salt_len = 16;
12428 break;
12429 case 9700: hashes_buf[0].salt->salt_len = 16;
12430 break;
12431 case 9710: hashes_buf[0].salt->salt_len = 16;
12432 break;
12433 case 9720: hashes_buf[0].salt->salt_len = 16;
12434 break;
12435 case 9800: hashes_buf[0].salt->salt_len = 16;
12436 break;
12437 case 9810: hashes_buf[0].salt->salt_len = 16;
12438 break;
12439 case 9820: hashes_buf[0].salt->salt_len = 16;
12440 break;
12441 case 10300: hashes_buf[0].salt->salt_len = 12;
12442 break;
12443 case 11500: hashes_buf[0].salt->salt_len = 4;
12444 break;
12445 case 11600: hashes_buf[0].salt->salt_len = 4;
12446 break;
12447 case 12400: hashes_buf[0].salt->salt_len = 4;
12448 break;
12449 case 12500: hashes_buf[0].salt->salt_len = 8;
12450 break;
12451 case 12600: hashes_buf[0].salt->salt_len = 64;
12452 break;
12453 }
12454
12455 // special esalt handling
12456
12457 switch (hash_mode)
12458 {
12459 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12460 break;
12461 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12462 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12463 break;
12464 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12465 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12466 break;
12467 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12468 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12469 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12470 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12471 break;
12472 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12473 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12474 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12475 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12476 break;
12477 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12478 break;
12479 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12480 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12481 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12482 break;
12483 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12484 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12485 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12486 break;
12487 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12488 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12489 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12490 break;
12491 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12492 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12493 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12494 break;
12495 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12496 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12497 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12498 break;
12499 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12500 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12501 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12502 break;
12503 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12504 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12505 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12506 break;
12507 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12508 break;
12509 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12510 break;
12511 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12512 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12513 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12514 break;
12515 }
12516 }
12517
12518 // set hashfile
12519
12520 switch (hash_mode)
12521 {
12522 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12523 break;
12524 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12525 break;
12526 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12527 break;
12528 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12529 break;
12530 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12531 break;
12532 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12533 break;
12534 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12535 break;
12536 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12537 break;
12538 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12539 break;
12540 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12541 break;
12542 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12543 break;
12544 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12545 break;
12546 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12547 break;
12548 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12549 break;
12550 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12551 break;
12552 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12553 break;
12554 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12555 break;
12556 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12557 break;
12558 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12559 break;
12560 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12561 break;
12562 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12563 break;
12564 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12565 break;
12566 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12567 break;
12568 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12569 break;
12570 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12571 break;
12572 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12573 break;
12574 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12575 break;
12576 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12577 break;
12578 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12579 break;
12580 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12581 break;
12582 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12583 break;
12584 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12585 break;
12586 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12587 break;
12588 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12589 break;
12590 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12591 break;
12592 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12593 break;
12594 }
12595
12596 // set default iterations
12597
12598 switch (hash_mode)
12599 {
12600 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12601 break;
12602 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12603 break;
12604 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12605 break;
12606 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12607 break;
12608 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12609 break;
12610 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12611 break;
12612 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12613 break;
12614 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12615 break;
12616 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12617 break;
12618 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12619 break;
12620 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12621 break;
12622 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12623 break;
12624 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12625 break;
12626 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12627 break;
12628 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12629 break;
12630 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12631 break;
12632 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12633 break;
12634 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12635 break;
12636 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12637 break;
12638 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12639 break;
12640 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12641 break;
12642 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12643 break;
12644 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12645 break;
12646 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12647 break;
12648 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12649 break;
12650 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12651 break;
12652 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12653 break;
12654 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12655 break;
12656 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12657 break;
12658 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12659 break;
12660 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12661 break;
12662 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12663 break;
12664 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12665 break;
12666 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12667 break;
12668 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12669 break;
12670 case 8900: hashes_buf[0].salt->salt_iter = 1;
12671 break;
12672 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12673 break;
12674 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12675 break;
12676 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12677 break;
12678 case 9300: hashes_buf[0].salt->salt_iter = 1;
12679 break;
12680 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12681 break;
12682 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12683 break;
12684 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12685 break;
12686 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12687 break;
12688 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12689 break;
12690 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12691 break;
12692 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12693 break;
12694 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12695 break;
12696 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12697 break;
12698 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12699 break;
12700 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12701 break;
12702 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12703 break;
12704 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12705 break;
12706 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12707 break;
12708 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12709 break;
12710 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12711 break;
12712 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12713 break;
12714 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12715 break;
12716 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12717 break;
12718 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12719 break;
12720 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12721 break;
12722 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12723 break;
12724 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12725 break;
12726 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12727 break;
12728 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12729 break;
12730 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12731 break;
12732 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12733 break;
12734 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12735 break;
12736 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12737 break;
12738 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12739 break;
12740 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12741 break;
12742 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12743 break;
12744 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12745 break;
12746 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12747 break;
12748 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12749 break;
12750 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12751 break;
12752 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12753 break;
12754 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12755 break;
12756 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12757 break;
12758 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12759 break;
12760 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12761 break;
12762 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12763 break;
12764 }
12765
12766 hashes_cnt = 1;
12767 }
12768
12769 if (show == 1 || left == 1)
12770 {
12771 for (uint i = 0; i < pot_cnt; i++)
12772 {
12773 pot_t *pot_ptr = &pot[i];
12774
12775 hash_t *hashes_buf = &pot_ptr->hash;
12776
12777 local_free (hashes_buf->digest);
12778
12779 if (isSalted)
12780 {
12781 local_free (hashes_buf->salt);
12782 }
12783 }
12784
12785 local_free (pot);
12786
12787 if (data.quiet == 0) log_info_nn ("");
12788
12789 return (0);
12790 }
12791
12792 if ((keyspace == 0) && (stdout_flag == 0))
12793 {
12794 if (hashes_cnt == 0)
12795 {
12796 log_error ("ERROR: No hashes loaded");
12797
12798 return (-1);
12799 }
12800 }
12801
12802 /**
12803 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12804 */
12805
12806 if (data.outfile != NULL)
12807 {
12808 if (data.hashfile != NULL)
12809 {
12810 #ifdef _POSIX
12811 struct stat tmpstat_outfile;
12812 struct stat tmpstat_hashfile;
12813 #endif
12814
12815 #ifdef _WIN
12816 struct stat64 tmpstat_outfile;
12817 struct stat64 tmpstat_hashfile;
12818 #endif
12819
12820 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12821
12822 if (tmp_outfile_fp)
12823 {
12824 #ifdef _POSIX
12825 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12826 #endif
12827
12828 #ifdef _WIN
12829 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12830 #endif
12831
12832 fclose (tmp_outfile_fp);
12833 }
12834
12835 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12836
12837 if (tmp_hashfile_fp)
12838 {
12839 #ifdef _POSIX
12840 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12841 #endif
12842
12843 #ifdef _WIN
12844 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12845 #endif
12846
12847 fclose (tmp_hashfile_fp);
12848 }
12849
12850 if (tmp_outfile_fp && tmp_outfile_fp)
12851 {
12852 tmpstat_outfile.st_mode = 0;
12853 tmpstat_outfile.st_nlink = 0;
12854 tmpstat_outfile.st_uid = 0;
12855 tmpstat_outfile.st_gid = 0;
12856 tmpstat_outfile.st_rdev = 0;
12857 tmpstat_outfile.st_atime = 0;
12858
12859 tmpstat_hashfile.st_mode = 0;
12860 tmpstat_hashfile.st_nlink = 0;
12861 tmpstat_hashfile.st_uid = 0;
12862 tmpstat_hashfile.st_gid = 0;
12863 tmpstat_hashfile.st_rdev = 0;
12864 tmpstat_hashfile.st_atime = 0;
12865
12866 #ifdef _POSIX
12867 tmpstat_outfile.st_blksize = 0;
12868 tmpstat_outfile.st_blocks = 0;
12869
12870 tmpstat_hashfile.st_blksize = 0;
12871 tmpstat_hashfile.st_blocks = 0;
12872 #endif
12873
12874 #ifdef _POSIX
12875 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12876 {
12877 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12878
12879 return (-1);
12880 }
12881 #endif
12882
12883 #ifdef _WIN
12884 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12885 {
12886 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12887
12888 return (-1);
12889 }
12890 #endif
12891 }
12892 }
12893 }
12894
12895 /**
12896 * Remove duplicates
12897 */
12898
12899 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12900
12901 if (isSalted)
12902 {
12903 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12904 }
12905 else
12906 {
12907 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12908 }
12909
12910 uint hashes_cnt_orig = hashes_cnt;
12911
12912 hashes_cnt = 1;
12913
12914 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12915 {
12916 if (isSalted)
12917 {
12918 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12919 {
12920 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12921 }
12922 }
12923 else
12924 {
12925 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12926 }
12927
12928 if (hashes_pos > hashes_cnt)
12929 {
12930 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12931 }
12932
12933 hashes_cnt++;
12934 }
12935
12936 /**
12937 * Potfile removes
12938 */
12939
12940 uint potfile_remove_cracks = 0;
12941
12942 if (potfile_disable == 0)
12943 {
12944 hash_t hash_buf;
12945
12946 hash_buf.digest = mymalloc (dgst_size);
12947 hash_buf.salt = NULL;
12948 hash_buf.esalt = NULL;
12949 hash_buf.hash_info = NULL;
12950 hash_buf.cracked = 0;
12951
12952 if (isSalted)
12953 {
12954 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12955 }
12956
12957 if (esalt_size)
12958 {
12959 hash_buf.esalt = mymalloc (esalt_size);
12960 }
12961
12962 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12963
12964 // no solution for these special hash types (for instane because they use hashfile in output etc)
12965 if ((hash_mode != 5200) &&
12966 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12967 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12968 (hash_mode != 9000))
12969 {
12970 FILE *fp = fopen (potfile, "rb");
12971
12972 if (fp != NULL)
12973 {
12974 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12975
12976 // to be safe work with a copy (because of line_len loop, i etc)
12977 // moved up here because it's easier to handle continue case
12978 // it's just 64kb
12979
12980 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12981
12982 while (!feof (fp))
12983 {
12984 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12985
12986 if (ptr == NULL) break;
12987
12988 int line_len = strlen (line_buf);
12989
12990 if (line_len == 0) continue;
12991
12992 int iter = MAX_CUT_TRIES;
12993
12994 for (int i = line_len - 1; i && iter; i--, line_len--)
12995 {
12996 if (line_buf[i] != ':') continue;
12997
12998 if (isSalted)
12999 {
13000 memset (hash_buf.salt, 0, sizeof (salt_t));
13001 }
13002
13003 hash_t *found = NULL;
13004
13005 if (hash_mode == 6800)
13006 {
13007 if (i < 64) // 64 = 16 * uint in salt_buf[]
13008 {
13009 // manipulate salt_buf
13010 memcpy (hash_buf.salt->salt_buf, line_buf, i);
13011
13012 hash_buf.salt->salt_len = i;
13013
13014 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
13015 }
13016 }
13017 else if (hash_mode == 2500)
13018 {
13019 if (i < 64) // 64 = 16 * uint in salt_buf[]
13020 {
13021 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
13022 // manipulate salt_buf
13023
13024 memset (line_buf_cpy, 0, HCBUFSIZ);
13025 memcpy (line_buf_cpy, line_buf, i);
13026
13027 char *mac2_pos = strrchr (line_buf_cpy, ':');
13028
13029 if (mac2_pos == NULL) continue;
13030
13031 mac2_pos[0] = 0;
13032 mac2_pos++;
13033
13034 if (strlen (mac2_pos) != 12) continue;
13035
13036 char *mac1_pos = strrchr (line_buf_cpy, ':');
13037
13038 if (mac1_pos == NULL) continue;
13039
13040 mac1_pos[0] = 0;
13041 mac1_pos++;
13042
13043 if (strlen (mac1_pos) != 12) continue;
13044
13045 uint essid_length = mac1_pos - line_buf_cpy - 1;
13046
13047 // here we need the ESSID
13048 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
13049
13050 hash_buf.salt->salt_len = essid_length;
13051
13052 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
13053
13054 if (found)
13055 {
13056 wpa_t *wpa = (wpa_t *) found->esalt;
13057
13058 // compare hex string(s) vs binary MAC address(es)
13059
13060 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13061 {
13062 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
13063 {
13064 found = NULL;
13065
13066 break;
13067 }
13068 }
13069
13070 // early skip ;)
13071 if (!found) continue;
13072
13073 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13074 {
13075 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
13076 {
13077 found = NULL;
13078
13079 break;
13080 }
13081 }
13082 }
13083 }
13084 }
13085 else
13086 {
13087 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
13088
13089 if (parser_status == PARSER_OK)
13090 {
13091 if (isSalted)
13092 {
13093 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
13094 }
13095 else
13096 {
13097 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
13098 }
13099 }
13100 }
13101
13102 if (found == NULL) continue;
13103
13104 if (!found->cracked) potfile_remove_cracks++;
13105
13106 found->cracked = 1;
13107
13108 if (found) break;
13109
13110 iter--;
13111 }
13112 }
13113
13114 myfree (line_buf_cpy);
13115
13116 myfree (line_buf);
13117
13118 fclose (fp);
13119 }
13120 }
13121
13122 if (esalt_size)
13123 {
13124 local_free (hash_buf.esalt);
13125 }
13126
13127 if (isSalted)
13128 {
13129 local_free (hash_buf.salt);
13130 }
13131
13132 local_free (hash_buf.digest);
13133 }
13134
13135 /**
13136 * Now generate all the buffers required for later
13137 */
13138
13139 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
13140
13141 salt_t *salts_buf_new = NULL;
13142 void *esalts_buf_new = NULL;
13143
13144 if (isSalted)
13145 {
13146 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
13147
13148 if (esalt_size)
13149 {
13150 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
13151 }
13152 }
13153 else
13154 {
13155 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13156 }
13157
13158 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13159
13160 uint digests_cnt = hashes_cnt;
13161 uint digests_done = 0;
13162
13163 size_t size_digests = digests_cnt * dgst_size;
13164 size_t size_shown = digests_cnt * sizeof (uint);
13165
13166 uint *digests_shown = (uint *) mymalloc (size_shown);
13167 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13168
13169 uint salts_cnt = 0;
13170 uint salts_done = 0;
13171
13172 hashinfo_t **hash_info = NULL;
13173
13174 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13175 {
13176 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13177
13178 if (username && (remove || show))
13179 {
13180 uint user_pos;
13181
13182 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13183 {
13184 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13185
13186 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13187 }
13188 }
13189 }
13190
13191 uint *salts_shown = (uint *) mymalloc (size_shown);
13192
13193 salt_t *salt_buf;
13194
13195 {
13196 // copied from inner loop
13197
13198 salt_buf = &salts_buf_new[salts_cnt];
13199
13200 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13201
13202 if (esalt_size)
13203 {
13204 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13205 }
13206
13207 salt_buf->digests_cnt = 0;
13208 salt_buf->digests_done = 0;
13209 salt_buf->digests_offset = 0;
13210
13211 salts_cnt++;
13212 }
13213
13214 if (hashes_buf[0].cracked == 1)
13215 {
13216 digests_shown[0] = 1;
13217
13218 digests_done++;
13219
13220 salt_buf->digests_done++;
13221 }
13222
13223 salt_buf->digests_cnt++;
13224
13225 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13226
13227 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13228 {
13229 hash_info[0] = hashes_buf[0].hash_info;
13230 }
13231
13232 // copy from inner loop
13233
13234 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13235 {
13236 if (isSalted)
13237 {
13238 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13239 {
13240 salt_buf = &salts_buf_new[salts_cnt];
13241
13242 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13243
13244 if (esalt_size)
13245 {
13246 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13247 }
13248
13249 salt_buf->digests_cnt = 0;
13250 salt_buf->digests_done = 0;
13251 salt_buf->digests_offset = hashes_pos;
13252
13253 salts_cnt++;
13254 }
13255 }
13256
13257 if (hashes_buf[hashes_pos].cracked == 1)
13258 {
13259 digests_shown[hashes_pos] = 1;
13260
13261 digests_done++;
13262
13263 salt_buf->digests_done++;
13264 }
13265
13266 salt_buf->digests_cnt++;
13267
13268 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13269
13270 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13271 {
13272 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13273 }
13274 }
13275
13276 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13277 {
13278 salt_t *salt_buf = &salts_buf_new[salt_pos];
13279
13280 if (salt_buf->digests_done == salt_buf->digests_cnt)
13281 {
13282 salts_shown[salt_pos] = 1;
13283
13284 salts_done++;
13285 }
13286
13287 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13288 }
13289
13290 local_free (digests_buf);
13291 local_free (salts_buf);
13292 local_free (esalts_buf);
13293
13294 digests_buf = digests_buf_new;
13295 salts_buf = salts_buf_new;
13296 esalts_buf = esalts_buf_new;
13297
13298 local_free (hashes_buf);
13299
13300 /**
13301 * special modification not set from parser
13302 */
13303
13304 switch (hash_mode)
13305 {
13306 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13307 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13308 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13309 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13310 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13311 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13312 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13313 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13314 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13315 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13316 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13317 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13318 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13319 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13320 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13321 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13322 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13323 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13324 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13325 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13326 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13327 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13328 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13329 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13330 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13331 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13332 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13333 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13334 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13335 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13336 }
13337
13338 if (truecrypt_keyfiles)
13339 {
13340 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13341
13342 char *keyfiles = strdup (truecrypt_keyfiles);
13343
13344 char *keyfile = strtok (keyfiles, ",");
13345
13346 do
13347 {
13348 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13349
13350 } while ((keyfile = strtok (NULL, ",")) != NULL);
13351
13352 free (keyfiles);
13353 }
13354
13355 if (veracrypt_keyfiles)
13356 {
13357 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13358
13359 char *keyfiles = strdup (veracrypt_keyfiles);
13360
13361 char *keyfile = strtok (keyfiles, ",");
13362
13363 do
13364 {
13365 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13366
13367 } while ((keyfile = strtok (NULL, ",")) != NULL);
13368
13369 free (keyfiles);
13370 }
13371
13372 data.digests_cnt = digests_cnt;
13373 data.digests_done = digests_done;
13374 data.digests_buf = digests_buf;
13375 data.digests_shown = digests_shown;
13376 data.digests_shown_tmp = digests_shown_tmp;
13377
13378 data.salts_cnt = salts_cnt;
13379 data.salts_done = salts_done;
13380 data.salts_buf = salts_buf;
13381 data.salts_shown = salts_shown;
13382
13383 data.esalts_buf = esalts_buf;
13384 data.hash_info = hash_info;
13385
13386 /**
13387 * Automatic Optimizers
13388 */
13389
13390 if (salts_cnt == 1)
13391 opti_type |= OPTI_TYPE_SINGLE_SALT;
13392
13393 if (digests_cnt == 1)
13394 opti_type |= OPTI_TYPE_SINGLE_HASH;
13395
13396 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13397 opti_type |= OPTI_TYPE_NOT_ITERATED;
13398
13399 if (attack_mode == ATTACK_MODE_BF)
13400 opti_type |= OPTI_TYPE_BRUTE_FORCE;
13401
13402 data.opti_type = opti_type;
13403
13404 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13405 {
13406 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13407 {
13408 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13409 {
13410 if (opts_type & OPTS_TYPE_ST_ADD80)
13411 {
13412 opts_type &= ~OPTS_TYPE_ST_ADD80;
13413 opts_type |= OPTS_TYPE_PT_ADD80;
13414 }
13415
13416 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13417 {
13418 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13419 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13420 }
13421
13422 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13423 {
13424 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13425 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13426 }
13427 }
13428 }
13429 }
13430
13431 /**
13432 * Some algorithm, like descrypt, can benefit from JIT compilation
13433 */
13434
13435 int force_jit_compilation = -1;
13436
13437 if (hash_mode == 8900)
13438 {
13439 force_jit_compilation = 8900;
13440 }
13441 else if (hash_mode == 9300)
13442 {
13443 force_jit_compilation = 8900;
13444 }
13445 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13446 {
13447 force_jit_compilation = 1500;
13448 }
13449
13450 /**
13451 * generate bitmap tables
13452 */
13453
13454 const uint bitmap_shift1 = 5;
13455 const uint bitmap_shift2 = 13;
13456
13457 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13458
13459 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13460 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13461 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13462 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13463 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13464 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13465 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13466 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13467
13468 uint bitmap_bits;
13469 uint bitmap_nums;
13470 uint bitmap_mask;
13471 uint bitmap_size;
13472
13473 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13474 {
13475 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13476
13477 bitmap_nums = 1 << bitmap_bits;
13478
13479 bitmap_mask = bitmap_nums - 1;
13480
13481 bitmap_size = bitmap_nums * sizeof (uint);
13482
13483 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13484
13485 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;
13486 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;
13487
13488 break;
13489 }
13490
13491 bitmap_nums = 1 << bitmap_bits;
13492
13493 bitmap_mask = bitmap_nums - 1;
13494
13495 bitmap_size = bitmap_nums * sizeof (uint);
13496
13497 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);
13498 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);
13499
13500 /**
13501 * prepare quick rule
13502 */
13503
13504 data.rule_buf_l = rule_buf_l;
13505 data.rule_buf_r = rule_buf_r;
13506
13507 int rule_len_l = (int) strlen (rule_buf_l);
13508 int rule_len_r = (int) strlen (rule_buf_r);
13509
13510 data.rule_len_l = rule_len_l;
13511 data.rule_len_r = rule_len_r;
13512
13513 /**
13514 * load rules
13515 */
13516
13517 uint *all_kernel_rules_cnt = NULL;
13518
13519 kernel_rule_t **all_kernel_rules_buf = NULL;
13520
13521 if (rp_files_cnt)
13522 {
13523 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13524
13525 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13526 }
13527
13528 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13529
13530 int rule_len = 0;
13531
13532 for (uint i = 0; i < rp_files_cnt; i++)
13533 {
13534 uint kernel_rules_avail = 0;
13535
13536 uint kernel_rules_cnt = 0;
13537
13538 kernel_rule_t *kernel_rules_buf = NULL;
13539
13540 char *rp_file = rp_files[i];
13541
13542 char in[BLOCK_SIZE] = { 0 };
13543 char out[BLOCK_SIZE] = { 0 };
13544
13545 FILE *fp = NULL;
13546
13547 uint rule_line = 0;
13548
13549 if ((fp = fopen (rp_file, "rb")) == NULL)
13550 {
13551 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13552
13553 return (-1);
13554 }
13555
13556 while (!feof (fp))
13557 {
13558 memset (rule_buf, 0, HCBUFSIZ);
13559
13560 rule_len = fgetl (fp, rule_buf);
13561
13562 rule_line++;
13563
13564 if (rule_len == 0) continue;
13565
13566 if (rule_buf[0] == '#') continue;
13567
13568 if (kernel_rules_avail == kernel_rules_cnt)
13569 {
13570 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13571
13572 kernel_rules_avail += INCR_RULES;
13573 }
13574
13575 memset (in, 0, BLOCK_SIZE);
13576 memset (out, 0, BLOCK_SIZE);
13577
13578 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13579
13580 if (result == -1)
13581 {
13582 log_info ("WARNING: Skipping invalid or unsupported rule in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13583
13584 continue;
13585 }
13586
13587 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13588 {
13589 log_info ("WARNING: Cannot convert rule for use on OpenCL device in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13590
13591 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13592
13593 continue;
13594 }
13595
13596 /* its so slow
13597 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13598 {
13599 log_info ("Duplicate rule for use on OpenCL device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13600
13601 continue;
13602 }
13603 */
13604
13605 kernel_rules_cnt++;
13606 }
13607
13608 fclose (fp);
13609
13610 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13611
13612 all_kernel_rules_buf[i] = kernel_rules_buf;
13613 }
13614
13615 /**
13616 * merge rules or automatic rule generator
13617 */
13618
13619 uint kernel_rules_cnt = 0;
13620
13621 kernel_rule_t *kernel_rules_buf = NULL;
13622
13623 if (attack_mode == ATTACK_MODE_STRAIGHT)
13624 {
13625 if (rp_files_cnt)
13626 {
13627 kernel_rules_cnt = 1;
13628
13629 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13630
13631 repeats[0] = kernel_rules_cnt;
13632
13633 for (uint i = 0; i < rp_files_cnt; i++)
13634 {
13635 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13636
13637 repeats[i + 1] = kernel_rules_cnt;
13638 }
13639
13640 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13641
13642 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13643
13644 for (uint i = 0; i < kernel_rules_cnt; i++)
13645 {
13646 uint out_pos = 0;
13647
13648 kernel_rule_t *out = &kernel_rules_buf[i];
13649
13650 for (uint j = 0; j < rp_files_cnt; j++)
13651 {
13652 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13653 uint in_pos;
13654
13655 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13656
13657 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13658 {
13659 if (out_pos == RULES_MAX - 1)
13660 {
13661 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13662
13663 break;
13664 }
13665
13666 out->cmds[out_pos] = in->cmds[in_pos];
13667 }
13668 }
13669 }
13670
13671 local_free (repeats);
13672 }
13673 else if (rp_gen)
13674 {
13675 uint kernel_rules_avail = 0;
13676
13677 while (kernel_rules_cnt < rp_gen)
13678 {
13679 if (kernel_rules_avail == kernel_rules_cnt)
13680 {
13681 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13682
13683 kernel_rules_avail += INCR_RULES;
13684 }
13685
13686 memset (rule_buf, 0, HCBUFSIZ);
13687
13688 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13689
13690 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13691
13692 kernel_rules_cnt++;
13693 }
13694 }
13695 }
13696
13697 myfree (rule_buf);
13698
13699 /**
13700 * generate NOP rules
13701 */
13702
13703 if ((rp_files_cnt == 0) && (rp_gen == 0))
13704 {
13705 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13706
13707 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13708
13709 kernel_rules_cnt++;
13710 }
13711
13712 data.kernel_rules_cnt = kernel_rules_cnt;
13713 data.kernel_rules_buf = kernel_rules_buf;
13714
13715 if (kernel_rules_cnt == 0)
13716 {
13717 log_error ("ERROR: No valid rules left");
13718
13719 return (-1);
13720 }
13721
13722 /**
13723 * OpenCL platforms: detect
13724 */
13725
13726 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13727 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13728
13729 cl_uint platforms_cnt = 0;
13730 cl_uint platform_devices_cnt = 0;
13731
13732 if (keyspace == 0)
13733 {
13734 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13735
13736 if (platforms_cnt == 0)
13737 {
13738 log_info ("");
13739 log_info ("ATTENTION! No OpenCL compatible platform found");
13740 log_info ("");
13741 log_info ("You're probably missing the OpenCL runtime installation");
13742 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13743 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13744 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13745 log_info ("");
13746
13747 return (-1);
13748 }
13749
13750 if (opencl_platforms_filter != (uint) -1)
13751 {
13752 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13753
13754 if (opencl_platforms_filter > platform_cnt_mask)
13755 {
13756 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13757
13758 return (-1);
13759 }
13760 }
13761 }
13762
13763 if (opencl_device_types == NULL)
13764 {
13765 /**
13766 * OpenCL device types:
13767 * 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.
13768 */
13769
13770 cl_device_type device_types_all = 0;
13771
13772 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13773 {
13774 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13775
13776 cl_platform_id platform = platforms[platform_id];
13777
13778 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13779
13780 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13781 {
13782 cl_device_id device = platform_devices[platform_devices_id];
13783
13784 cl_device_type device_type;
13785
13786 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13787
13788 device_types_all |= device_type;
13789 }
13790 }
13791
13792 // In such a case, automatically enable CPU device type support, since it's disabled by default.
13793
13794 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13795 {
13796 device_types_filter |= CL_DEVICE_TYPE_CPU;
13797 }
13798
13799 // In another case, when the user uses --stdout, using CPU devices is much faster to setup
13800 // If we have a CPU device, force it to be used
13801
13802 if (stdout_flag == 1)
13803 {
13804 if (device_types_all & CL_DEVICE_TYPE_CPU)
13805 {
13806 device_types_filter = CL_DEVICE_TYPE_CPU;
13807 }
13808 }
13809 }
13810
13811 /**
13812 * OpenCL devices: simply push all devices from all platforms into the same device array
13813 */
13814
13815 int need_adl = 0;
13816 int need_nvapi = 0;
13817 int need_nvml = 0;
13818 int need_xnvctrl = 0;
13819
13820 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13821
13822 data.devices_param = devices_param;
13823
13824 uint devices_cnt = 0;
13825
13826 uint devices_active = 0;
13827
13828 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13829 {
13830 cl_platform_id platform = platforms[platform_id];
13831
13832 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13833
13834 char platform_vendor[INFOSZ] = { 0 };
13835
13836 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13837
13838 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13839 // this causes trouble with vendor id based macros
13840 // we'll assign generic to those without special optimization available
13841
13842 cl_uint platform_vendor_id = 0;
13843
13844 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13845 {
13846 platform_vendor_id = VENDOR_ID_AMD;
13847 }
13848 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13849 {
13850 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13851 }
13852 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13853 {
13854 platform_vendor_id = VENDOR_ID_APPLE;
13855 }
13856 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13857 {
13858 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13859 }
13860 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13861 {
13862 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13863 }
13864 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13865 {
13866 platform_vendor_id = VENDOR_ID_MESA;
13867 }
13868 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13869 {
13870 platform_vendor_id = VENDOR_ID_NV;
13871 }
13872 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13873 {
13874 platform_vendor_id = VENDOR_ID_POCL;
13875 }
13876 else
13877 {
13878 platform_vendor_id = VENDOR_ID_GENERIC;
13879 }
13880
13881 const uint platform_skipped = ((opencl_platforms_filter & (1 << platform_id)) == 0);
13882
13883 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13884 {
13885 if (machine_readable == 0)
13886 {
13887 if (platform_skipped == 0)
13888 {
13889 const int len = log_info ("OpenCL Platform #%u: %s", platform_id + 1, platform_vendor);
13890
13891 char line[256] = { 0 };
13892
13893 for (int i = 0; i < len; i++) line[i] = '=';
13894
13895 log_info (line);
13896 }
13897 else
13898 {
13899 log_info ("OpenCL Platform #%u: %s, skipped", platform_id + 1, platform_vendor);
13900 log_info ("");
13901 }
13902 }
13903 }
13904
13905 if (platform_skipped == 1) continue;
13906
13907 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13908 {
13909 size_t param_value_size = 0;
13910
13911 const uint device_id = devices_cnt;
13912
13913 hc_device_param_t *device_param = &data.devices_param[device_id];
13914
13915 device_param->platform_vendor_id = platform_vendor_id;
13916
13917 device_param->device = platform_devices[platform_devices_id];
13918
13919 device_param->device_id = device_id;
13920
13921 device_param->platform_devices_id = platform_devices_id;
13922
13923 device_param->platform = platform;
13924
13925 // device_type
13926
13927 cl_device_type device_type;
13928
13929 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13930
13931 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13932
13933 device_param->device_type = device_type;
13934
13935 // device_name
13936
13937 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13938
13939 char *device_name = (char *) mymalloc (param_value_size);
13940
13941 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13942
13943 device_param->device_name = device_name;
13944
13945 // device_vendor
13946
13947 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13948
13949 char *device_vendor = (char *) mymalloc (param_value_size);
13950
13951 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13952
13953 device_param->device_vendor = device_vendor;
13954
13955 cl_uint device_vendor_id = 0;
13956
13957 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13958 {
13959 device_vendor_id = VENDOR_ID_AMD;
13960 }
13961 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13962 {
13963 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13964 }
13965 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13966 {
13967 device_vendor_id = VENDOR_ID_APPLE;
13968 }
13969 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13970 {
13971 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13972 }
13973 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13974 {
13975 device_vendor_id = VENDOR_ID_INTEL_SDK;
13976 }
13977 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13978 {
13979 device_vendor_id = VENDOR_ID_MESA;
13980 }
13981 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13982 {
13983 device_vendor_id = VENDOR_ID_NV;
13984 }
13985 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13986 {
13987 device_vendor_id = VENDOR_ID_POCL;
13988 }
13989 else
13990 {
13991 device_vendor_id = VENDOR_ID_GENERIC;
13992 }
13993
13994 device_param->device_vendor_id = device_vendor_id;
13995
13996 // tuning db
13997
13998 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13999
14000 // device_version
14001
14002 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
14003
14004 char *device_version = (char *) mymalloc (param_value_size);
14005
14006 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
14007
14008 device_param->device_version = device_version;
14009
14010 // device_opencl_version
14011
14012 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
14013
14014 char *device_opencl_version = (char *) mymalloc (param_value_size);
14015
14016 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
14017
14018 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
14019
14020 myfree (device_opencl_version);
14021
14022 // vector_width
14023
14024 cl_uint vector_width;
14025
14026 if (opencl_vector_width_chgd == 0)
14027 {
14028 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
14029 {
14030 if (opti_type & OPTI_TYPE_USES_BITS_64)
14031 {
14032 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
14033 }
14034 else
14035 {
14036 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
14037 }
14038 }
14039 else
14040 {
14041 vector_width = (cl_uint) tuningdb_entry->vector_width;
14042 }
14043 }
14044 else
14045 {
14046 vector_width = opencl_vector_width;
14047 }
14048
14049 if (vector_width > 16) vector_width = 16;
14050
14051 device_param->vector_width = vector_width;
14052
14053 // max_compute_units
14054
14055 cl_uint device_processors;
14056
14057 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
14058
14059 device_param->device_processors = device_processors;
14060
14061 // device_maxmem_alloc
14062 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
14063
14064 cl_ulong device_maxmem_alloc;
14065
14066 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
14067
14068 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
14069
14070 // device_global_mem
14071
14072 cl_ulong device_global_mem;
14073
14074 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
14075
14076 device_param->device_global_mem = device_global_mem;
14077
14078 // max_work_group_size
14079
14080 size_t device_maxworkgroup_size;
14081
14082 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
14083
14084 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
14085
14086 // max_clock_frequency
14087
14088 cl_uint device_maxclock_frequency;
14089
14090 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
14091
14092 device_param->device_maxclock_frequency = device_maxclock_frequency;
14093
14094 // device_endian_little
14095
14096 cl_bool device_endian_little;
14097
14098 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
14099
14100 if (device_endian_little == CL_FALSE)
14101 {
14102 log_info ("- Device #%u: WARNING: Not a little endian device", device_id + 1);
14103
14104 device_param->skipped = 1;
14105 }
14106
14107 // device_available
14108
14109 cl_bool device_available;
14110
14111 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
14112
14113 if (device_available == CL_FALSE)
14114 {
14115 log_info ("- Device #%u: WARNING: Device not available", device_id + 1);
14116
14117 device_param->skipped = 1;
14118 }
14119
14120 // device_compiler_available
14121
14122 cl_bool device_compiler_available;
14123
14124 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
14125
14126 if (device_compiler_available == CL_FALSE)
14127 {
14128 log_info ("- Device #%u: WARNING: No compiler available for device", device_id + 1);
14129
14130 device_param->skipped = 1;
14131 }
14132
14133 // device_execution_capabilities
14134
14135 cl_device_exec_capabilities device_execution_capabilities;
14136
14137 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
14138
14139 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
14140 {
14141 log_info ("- Device #%u: WARNING: Device does not support executing kernels", device_id + 1);
14142
14143 device_param->skipped = 1;
14144 }
14145
14146 // device_extensions
14147
14148 size_t device_extensions_size;
14149
14150 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
14151
14152 char *device_extensions = mymalloc (device_extensions_size + 1);
14153
14154 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
14155
14156 if (strstr (device_extensions, "base_atomics") == 0)
14157 {
14158 log_info ("- Device #%u: WARNING: Device does not support base atomics", device_id + 1);
14159
14160 device_param->skipped = 1;
14161 }
14162
14163 if (strstr (device_extensions, "byte_addressable_store") == 0)
14164 {
14165 log_info ("- Device #%u: WARNING: Device does not support byte addressable store", device_id + 1);
14166
14167 device_param->skipped = 1;
14168 }
14169
14170 myfree (device_extensions);
14171
14172 // device_local_mem_size
14173
14174 cl_ulong device_local_mem_size;
14175
14176 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
14177
14178 if (device_local_mem_size < 32768)
14179 {
14180 log_info ("- Device #%u: WARNING: Device local mem size is too small", device_id + 1);
14181
14182 device_param->skipped = 1;
14183 }
14184
14185 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
14186 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
14187 // This results in both utilizing it for 50%
14188 // However, Intel has much better SIMD control over their own hardware
14189 // It makes sense to give them full control over their own hardware
14190
14191 if (device_type & CL_DEVICE_TYPE_CPU)
14192 {
14193 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14194 {
14195 if (data.force == 0)
14196 {
14197 if (algorithm_pos == 0)
14198 {
14199 log_info ("- Device #%u: WARNING: Not a native Intel OpenCL runtime, expect massive speed loss", device_id + 1);
14200 log_info (" You can use --force to override this but do not post error reports if you do so");
14201 }
14202
14203 device_param->skipped = 1;
14204 }
14205 }
14206 }
14207
14208 // skipped
14209
14210 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14211 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14212
14213 // driver_version
14214
14215 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14216
14217 char *driver_version = (char *) mymalloc (param_value_size);
14218
14219 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14220
14221 device_param->driver_version = driver_version;
14222
14223 // device_name_chksum
14224
14225 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14226
14227 #if __x86_64__
14228 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);
14229 #else
14230 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);
14231 #endif
14232
14233 uint device_name_digest[4] = { 0 };
14234
14235 md5_64 ((uint *) device_name_chksum, device_name_digest);
14236
14237 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14238
14239 device_param->device_name_chksum = device_name_chksum;
14240
14241 // vendor specific
14242
14243 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14244 {
14245 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14246 {
14247 need_adl = 1;
14248 }
14249
14250 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14251 {
14252 need_nvml = 1;
14253
14254 #ifdef LINUX
14255 need_xnvctrl = 1;
14256 #endif
14257
14258 #ifdef WIN
14259 need_nvapi = 1;
14260 #endif
14261 }
14262 }
14263
14264 if (device_type & CL_DEVICE_TYPE_GPU)
14265 {
14266 if (device_vendor_id == VENDOR_ID_NV)
14267 {
14268 cl_uint kernel_exec_timeout = 0;
14269
14270 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14271
14272 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14273
14274 device_param->kernel_exec_timeout = kernel_exec_timeout;
14275
14276 cl_uint sm_minor = 0;
14277 cl_uint sm_major = 0;
14278
14279 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14280 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14281
14282 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14283 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14284
14285 device_param->sm_minor = sm_minor;
14286 device_param->sm_major = sm_major;
14287
14288 // CPU burning loop damper
14289 // Value is given as number between 0-100
14290 // By default 100%
14291
14292 device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14293
14294 if (nvidia_spin_damp_chgd == 0)
14295 {
14296 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14297 {
14298 /**
14299 * the workaround is not a friend of rule based attacks
14300 * the words from the wordlist combined with fast and slow rules cause
14301 * fluctuations which cause inaccurate wait time estimations
14302 * using a reduced damping percentage almost compensates this
14303 */
14304
14305 device_param->nvidia_spin_damp = 64;
14306 }
14307 }
14308
14309 device_param->nvidia_spin_damp /= 100;
14310 }
14311 }
14312
14313 // display results
14314
14315 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14316 {
14317 if (machine_readable == 0)
14318 {
14319 if (device_param->skipped == 0)
14320 {
14321 log_info ("- Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14322 device_id + 1,
14323 device_name,
14324 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14325 (unsigned int) (device_global_mem / 1024 / 1024),
14326 (unsigned int) device_processors);
14327 }
14328 else
14329 {
14330 log_info ("- Device #%u: %s, skipped",
14331 device_id + 1,
14332 device_name);
14333 }
14334 }
14335 }
14336
14337 // common driver check
14338
14339 if (device_param->skipped == 0)
14340 {
14341 if (device_type & CL_DEVICE_TYPE_GPU)
14342 {
14343 if (platform_vendor_id == VENDOR_ID_AMD)
14344 {
14345 int catalyst_check = (force == 1) ? 0 : 1;
14346
14347 int catalyst_warn = 0;
14348
14349 int catalyst_broken = 0;
14350
14351 if (catalyst_check == 1)
14352 {
14353 catalyst_warn = 1;
14354
14355 // v14.9 and higher
14356 if (atoi (device_param->driver_version) >= 1573)
14357 {
14358 catalyst_warn = 0;
14359 }
14360
14361 catalyst_check = 0;
14362 }
14363
14364 if (catalyst_broken == 1)
14365 {
14366 log_info ("");
14367 log_info ("ATTENTION! The Catalyst driver installed on your system is known to be broken!");
14368 log_info ("It passes over cracked hashes and will not report them as cracked");
14369 log_info ("You are STRONGLY encouraged not to use it");
14370 log_info ("You can use --force to override this but do not post error reports if you do so");
14371 log_info ("");
14372
14373 return (-1);
14374 }
14375
14376 if (catalyst_warn == 1)
14377 {
14378 log_info ("");
14379 log_info ("ATTENTION! Unsupported or incorrectly installed Catalyst driver detected!");
14380 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver");
14381 log_info ("See hashcat's homepage for official supported catalyst drivers");
14382 #ifdef _WIN
14383 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14384 #endif
14385 log_info ("You can use --force to override this but do not post error reports if you do so");
14386 log_info ("");
14387
14388 return (-1);
14389 }
14390 }
14391 else if (platform_vendor_id == VENDOR_ID_NV)
14392 {
14393 if (device_param->kernel_exec_timeout != 0)
14394 {
14395 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);
14396 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14397 }
14398 }
14399 }
14400
14401 /* turns out pocl still creates segfaults (because of llvm)
14402 if (device_type & CL_DEVICE_TYPE_CPU)
14403 {
14404 if (platform_vendor_id == VENDOR_ID_AMD)
14405 {
14406 if (force == 0)
14407 {
14408 log_info ("");
14409 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14410 log_info ("You are STRONGLY encouraged not to use it");
14411 log_info ("You can use --force to override this but do not post error reports if you do so");
14412 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14413 log_info ("");
14414
14415 return (-1);
14416 }
14417 }
14418 }
14419 */
14420
14421 /**
14422 * kernel accel and loops tuning db adjustment
14423 */
14424
14425 device_param->kernel_accel_min = 1;
14426 device_param->kernel_accel_max = 1024;
14427
14428 device_param->kernel_loops_min = 1;
14429 device_param->kernel_loops_max = 1024;
14430
14431 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14432
14433 if (tuningdb_entry)
14434 {
14435 u32 _kernel_accel = tuningdb_entry->kernel_accel;
14436 u32 _kernel_loops = tuningdb_entry->kernel_loops;
14437
14438 if (_kernel_accel)
14439 {
14440 device_param->kernel_accel_min = _kernel_accel;
14441 device_param->kernel_accel_max = _kernel_accel;
14442 }
14443
14444 if (_kernel_loops)
14445 {
14446 if (workload_profile == 1)
14447 {
14448 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14449 }
14450 else if (workload_profile == 2)
14451 {
14452 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14453 }
14454
14455 device_param->kernel_loops_min = _kernel_loops;
14456 device_param->kernel_loops_max = _kernel_loops;
14457 }
14458 }
14459
14460 // commandline parameters overwrite tuningdb entries
14461
14462 if (kernel_accel)
14463 {
14464 device_param->kernel_accel_min = kernel_accel;
14465 device_param->kernel_accel_max = kernel_accel;
14466 }
14467
14468 if (kernel_loops)
14469 {
14470 device_param->kernel_loops_min = kernel_loops;
14471 device_param->kernel_loops_max = kernel_loops;
14472 }
14473
14474 /**
14475 * activate device
14476 */
14477
14478 devices_active++;
14479 }
14480
14481 // next please
14482
14483 devices_cnt++;
14484 }
14485
14486 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14487 {
14488 if (machine_readable == 0)
14489 {
14490 log_info ("");
14491 }
14492 }
14493 }
14494
14495 if (keyspace == 0 && devices_active == 0)
14496 {
14497 log_error ("ERROR: No devices found/left");
14498
14499 return (-1);
14500 }
14501
14502 // 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)
14503
14504 if (devices_filter != (uint) -1)
14505 {
14506 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14507
14508 if (devices_filter > devices_cnt_mask)
14509 {
14510 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14511
14512 return (-1);
14513 }
14514 }
14515
14516 data.devices_cnt = devices_cnt;
14517
14518 data.devices_active = devices_active;
14519
14520 /**
14521 * HM devices: init
14522 */
14523
14524 #ifdef HAVE_HWMON
14525 hm_attrs_t hm_adapters_adl[DEVICES_MAX];
14526 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX];
14527 hm_attrs_t hm_adapters_nvml[DEVICES_MAX];
14528 hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX];
14529
14530 memset (hm_adapters_adl, 0, sizeof (hm_adapters_adl));
14531 memset (hm_adapters_nvapi, 0, sizeof (hm_adapters_nvapi));
14532 memset (hm_adapters_nvml, 0, sizeof (hm_adapters_nvml));
14533 memset (hm_adapters_xnvctrl, 0, sizeof (hm_adapters_xnvctrl));
14534
14535 if (gpu_temp_disable == 0)
14536 {
14537 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14538 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14539 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14540 XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));
14541
14542 data.hm_adl = NULL;
14543 data.hm_nvapi = NULL;
14544 data.hm_nvml = NULL;
14545 data.hm_xnvctrl = NULL;
14546
14547 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14548 {
14549 data.hm_nvml = nvml;
14550 }
14551
14552 if (data.hm_nvml)
14553 {
14554 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14555 {
14556 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14557
14558 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14559
14560 int tmp_out = 0;
14561
14562 for (int i = 0; i < tmp_in; i++)
14563 {
14564 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14565 }
14566
14567 for (int i = 0; i < tmp_out; i++)
14568 {
14569 unsigned int speed;
14570
14571 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14572
14573 // doesn't seem to create any advantages
14574 //hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14575 //hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14576 }
14577 }
14578 }
14579
14580 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14581 {
14582 data.hm_nvapi = nvapi;
14583 }
14584
14585 if (data.hm_nvapi)
14586 {
14587 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14588 {
14589 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14590
14591 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14592
14593 int tmp_out = 0;
14594
14595 for (int i = 0; i < tmp_in; i++)
14596 {
14597 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14598 }
14599 }
14600 }
14601
14602 if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0))
14603 {
14604 data.hm_xnvctrl = xnvctrl;
14605 }
14606
14607 if (data.hm_xnvctrl)
14608 {
14609 if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
14610 {
14611 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14612 {
14613 hc_device_param_t *device_param = &data.devices_param[device_id];
14614
14615 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14616
14617 hm_adapters_xnvctrl[device_id].xnvctrl = device_id;
14618
14619 int speed = 0;
14620
14621 if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
14622 }
14623 }
14624 }
14625
14626 if ((need_adl == 1) && (adl_init (adl) == 0))
14627 {
14628 data.hm_adl = adl;
14629 }
14630
14631 if (data.hm_adl)
14632 {
14633 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14634 {
14635 // total number of adapters
14636
14637 int hm_adapters_num;
14638
14639 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14640
14641 // adapter info
14642
14643 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14644
14645 if (lpAdapterInfo == NULL) return (-1);
14646
14647 // get a list (of ids of) valid/usable adapters
14648
14649 int num_adl_adapters = 0;
14650
14651 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14652
14653 if (num_adl_adapters > 0)
14654 {
14655 hc_thread_mutex_lock (mux_adl);
14656
14657 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14658
14659 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14660
14661 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14662 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14663
14664 hc_thread_mutex_unlock (mux_adl);
14665 }
14666
14667 myfree (valid_adl_device_list);
14668 myfree (lpAdapterInfo);
14669 }
14670 }
14671
14672 if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14673 {
14674 gpu_temp_disable = 1;
14675 }
14676 }
14677
14678 /**
14679 * OpenCL devices: allocate buffer for device specific information
14680 */
14681
14682 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14683
14684 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14685
14686 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14687
14688 /**
14689 * User-defined GPU temp handling
14690 */
14691
14692 if (gpu_temp_disable == 1)
14693 {
14694 gpu_temp_abort = 0;
14695 gpu_temp_retain = 0;
14696 }
14697
14698 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14699 {
14700 if (gpu_temp_abort < gpu_temp_retain)
14701 {
14702 log_error ("ERROR: Invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14703
14704 return (-1);
14705 }
14706 }
14707
14708 data.gpu_temp_disable = gpu_temp_disable;
14709 data.gpu_temp_abort = gpu_temp_abort;
14710 data.gpu_temp_retain = gpu_temp_retain;
14711 #endif
14712
14713 /**
14714 * enable custom signal handler(s)
14715 */
14716
14717 if (benchmark == 0)
14718 {
14719 hc_signal (sigHandler_default);
14720 }
14721 else
14722 {
14723 hc_signal (sigHandler_benchmark);
14724 }
14725
14726 /**
14727 * inform the user
14728 */
14729
14730 if (data.quiet == 0)
14731 {
14732 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14733
14734 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);
14735
14736 if (attack_mode == ATTACK_MODE_STRAIGHT)
14737 {
14738 log_info ("Rules: %u", kernel_rules_cnt);
14739 }
14740
14741 if (opti_type)
14742 {
14743 log_info ("Applicable Optimizers:");
14744
14745 for (uint i = 0; i < 32; i++)
14746 {
14747 const uint opti_bit = 1u << i;
14748
14749 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14750 }
14751 }
14752
14753 /**
14754 * Watchdog and Temperature balance
14755 */
14756
14757 #ifdef HAVE_HWMON
14758 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14759 {
14760 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14761 }
14762
14763 if (gpu_temp_abort == 0)
14764 {
14765 log_info ("Watchdog: Temperature abort trigger disabled");
14766 }
14767 else
14768 {
14769 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14770 }
14771
14772 if (gpu_temp_retain == 0)
14773 {
14774 log_info ("Watchdog: Temperature retain trigger disabled");
14775 }
14776 else
14777 {
14778 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14779 }
14780
14781 if (data.quiet == 0) log_info ("");
14782 #endif
14783 }
14784
14785 #ifdef HAVE_HWMON
14786
14787 /**
14788 * HM devices: copy
14789 */
14790
14791 if (gpu_temp_disable == 0)
14792 {
14793 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14794 {
14795 hc_device_param_t *device_param = &data.devices_param[device_id];
14796
14797 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14798
14799 if (device_param->skipped) continue;
14800
14801 const uint platform_devices_id = device_param->platform_devices_id;
14802
14803 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14804 {
14805 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14806 data.hm_device[device_id].nvapi = 0;
14807 data.hm_device[device_id].nvml = 0;
14808 data.hm_device[device_id].xnvctrl = 0;
14809 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14810 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14811 data.hm_device[device_id].fan_set_supported = 0;
14812 }
14813
14814 if (device_param->device_vendor_id == VENDOR_ID_NV)
14815 {
14816 data.hm_device[device_id].adl = 0;
14817 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14818 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14819 data.hm_device[device_id].xnvctrl = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
14820 data.hm_device[device_id].od_version = 0;
14821 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14822 data.hm_device[device_id].fan_set_supported = 0;
14823 }
14824 }
14825 }
14826
14827 /**
14828 * powertune on user request
14829 */
14830
14831 if (powertune_enable == 1)
14832 {
14833 hc_thread_mutex_lock (mux_adl);
14834
14835 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14836 {
14837 hc_device_param_t *device_param = &data.devices_param[device_id];
14838
14839 if (device_param->skipped) continue;
14840
14841 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14842 {
14843 /**
14844 * Temporary fix:
14845 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14846 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14847 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14848 * Driver / ADL bug?
14849 */
14850
14851 if (data.hm_device[device_id].od_version == 6)
14852 {
14853 int ADL_rc;
14854
14855 // check powertune capabilities first, if not available then skip device
14856
14857 int powertune_supported = 0;
14858
14859 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14860 {
14861 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14862
14863 return (-1);
14864 }
14865
14866 // first backup current value, we will restore it later
14867
14868 if (powertune_supported != 0)
14869 {
14870 // powercontrol settings
14871
14872 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14873
14874 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14875 {
14876 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14877 }
14878
14879 if (ADL_rc != ADL_OK)
14880 {
14881 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14882
14883 return (-1);
14884 }
14885
14886 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14887 {
14888 log_error ("ERROR: Failed to set new ADL PowerControl values");
14889
14890 return (-1);
14891 }
14892
14893 // clocks
14894
14895 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14896
14897 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14898
14899 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)
14900 {
14901 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14902
14903 return (-1);
14904 }
14905
14906 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14907
14908 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14909
14910 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14911 {
14912 log_error ("ERROR: Failed to get ADL device capabilities");
14913
14914 return (-1);
14915 }
14916
14917 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14918 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14919
14920 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14921 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14922
14923 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14924 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14925
14926 // warning if profile has too low max values
14927
14928 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14929 {
14930 log_info ("WARN: The custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14931 }
14932
14933 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14934 {
14935 log_info ("WARN: The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14936 }
14937
14938 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14939
14940 performance_state->iNumberOfPerformanceLevels = 2;
14941
14942 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14943 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14944 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14945 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14946
14947 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)
14948 {
14949 log_info ("ERROR: Failed to set ADL performance state");
14950
14951 return (-1);
14952 }
14953
14954 local_free (performance_state);
14955 }
14956
14957 // set powertune value only
14958
14959 if (powertune_supported != 0)
14960 {
14961 // powertune set
14962 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14963
14964 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14965 {
14966 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14967
14968 return (-1);
14969 }
14970
14971 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14972 {
14973 log_error ("ERROR: Failed to set new ADL PowerControl values");
14974
14975 return (-1);
14976 }
14977 }
14978 }
14979 }
14980
14981 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14982 {
14983 // first backup current value, we will restore it later
14984
14985 unsigned int limit;
14986
14987 int powertune_supported = 0;
14988
14989 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14990 {
14991 powertune_supported = 1;
14992 }
14993
14994 // if backup worked, activate the maximum allowed
14995
14996 if (powertune_supported != 0)
14997 {
14998 unsigned int minLimit;
14999 unsigned int maxLimit;
15000
15001 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
15002 {
15003 if (maxLimit > 0)
15004 {
15005 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
15006 {
15007 // now we can be sure we need to reset later
15008
15009 nvml_power_limit[device_id] = limit;
15010 }
15011 }
15012 }
15013 }
15014 }
15015 }
15016
15017 hc_thread_mutex_unlock (mux_adl);
15018 }
15019
15020 #endif // HAVE_HWMON
15021
15022 #ifdef DEBUG
15023 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
15024 #endif
15025
15026 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
15027
15028 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15029 {
15030 /**
15031 * host buffer
15032 */
15033
15034 hc_device_param_t *device_param = &data.devices_param[device_id];
15035
15036 if (device_param->skipped) continue;
15037
15038 /**
15039 * device properties
15040 */
15041
15042 const char *device_name_chksum = device_param->device_name_chksum;
15043 const u32 device_processors = device_param->device_processors;
15044
15045 /**
15046 * create context for each device
15047 */
15048
15049 cl_context_properties properties[3];
15050
15051 properties[0] = CL_CONTEXT_PLATFORM;
15052 properties[1] = (cl_context_properties) device_param->platform;
15053 properties[2] = 0;
15054
15055 device_param->context = hc_clCreateContext (data.ocl, properties, 1, &device_param->device, NULL, NULL);
15056
15057 /**
15058 * create command-queue
15059 */
15060
15061 // not supported with NV
15062 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
15063
15064 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
15065
15066 /**
15067 * kernel threads: some algorithms need a fixed kernel-threads count
15068 * because of shared memory usage or bitslice
15069 * there needs to be some upper limit, otherwise there's too much overhead
15070 */
15071
15072 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
15073
15074 if (hash_mode == 8900) kernel_threads = 64; // Scrypt
15075 if (hash_mode == 9300) kernel_threads = 64; // Scrypt
15076
15077 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
15078 {
15079 kernel_threads = KERNEL_THREADS_MAX_CPU;
15080 }
15081
15082 if (hash_mode == 1500) kernel_threads = 64; // DES
15083 if (hash_mode == 3000) kernel_threads = 64; // DES
15084 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
15085 if (hash_mode == 7500) kernel_threads = 64; // RC4
15086 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
15087 if (hash_mode == 9700) kernel_threads = 64; // RC4
15088 if (hash_mode == 9710) kernel_threads = 64; // RC4
15089 if (hash_mode == 9800) kernel_threads = 64; // RC4
15090 if (hash_mode == 9810) kernel_threads = 64; // RC4
15091 if (hash_mode == 10400) kernel_threads = 64; // RC4
15092 if (hash_mode == 10410) kernel_threads = 64; // RC4
15093 if (hash_mode == 10500) kernel_threads = 64; // RC4
15094 if (hash_mode == 13100) kernel_threads = 64; // RC4
15095
15096 device_param->kernel_threads = kernel_threads;
15097
15098 device_param->hardware_power = device_processors * kernel_threads;
15099
15100 /**
15101 * create input buffers on device : calculate size of fixed memory buffers
15102 */
15103
15104 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
15105 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
15106
15107 device_param->size_root_css = size_root_css;
15108 device_param->size_markov_css = size_markov_css;
15109
15110 size_t size_results = sizeof (uint);
15111
15112 device_param->size_results = size_results;
15113
15114 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
15115 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
15116
15117 size_t size_plains = digests_cnt * sizeof (plain_t);
15118 size_t size_salts = salts_cnt * sizeof (salt_t);
15119 size_t size_esalts = salts_cnt * esalt_size;
15120
15121 device_param->size_plains = size_plains;
15122 device_param->size_digests = size_digests;
15123 device_param->size_shown = size_shown;
15124 device_param->size_salts = size_salts;
15125
15126 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
15127 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
15128 size_t size_tm = 32 * sizeof (bs_word_t);
15129
15130 // scryptV stuff
15131
15132 size_t size_scrypt = 4;
15133
15134 if ((hash_mode == 8900) || (hash_mode == 9300))
15135 {
15136 // we need to check that all hashes have the same scrypt settings
15137
15138 const u32 scrypt_N = data.salts_buf[0].scrypt_N;
15139 const u32 scrypt_r = data.salts_buf[0].scrypt_r;
15140 const u32 scrypt_p = data.salts_buf[0].scrypt_p;
15141
15142 for (uint i = 1; i < salts_cnt; i++)
15143 {
15144 if ((data.salts_buf[i].scrypt_N != scrypt_N)
15145 || (data.salts_buf[i].scrypt_r != scrypt_r)
15146 || (data.salts_buf[i].scrypt_p != scrypt_p))
15147 {
15148 log_error ("ERROR: Mixed scrypt settings not supported");
15149
15150 return -1;
15151 }
15152 }
15153
15154 uint tmto_start = 0;
15155 uint tmto_stop = 10;
15156
15157 if (scrypt_tmto)
15158 {
15159 tmto_start = scrypt_tmto;
15160 }
15161 else
15162 {
15163 // in case the user did not specify the tmto manually
15164 // use some values known to run best (tested on 290x for AMD and GTX1080 for NV)
15165
15166 if (hash_mode == 8900)
15167 {
15168 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15169 {
15170 tmto_start = 3;
15171 }
15172 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15173 {
15174 tmto_start = 2;
15175 }
15176 }
15177 else if (hash_mode == 9300)
15178 {
15179 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15180 {
15181 tmto_start = 2;
15182 }
15183 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15184 {
15185 tmto_start = 4;
15186 }
15187 }
15188 }
15189
15190 data.scrypt_tmp_size = (128 * scrypt_r * scrypt_p);
15191
15192 device_param->kernel_accel_min = 1;
15193 device_param->kernel_accel_max = 8;
15194
15195 uint tmto;
15196
15197 for (tmto = tmto_start; tmto < tmto_stop; tmto++)
15198 {
15199 size_scrypt = (128 * scrypt_r) * scrypt_N;
15200
15201 size_scrypt /= 1 << tmto;
15202
15203 size_scrypt *= device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel_max;
15204
15205 if ((size_scrypt / 4) > device_param->device_maxmem_alloc)
15206 {
15207 if (quiet == 0) log_info ("WARNING: Not enough single-block device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15208
15209 continue;
15210 }
15211
15212 if (size_scrypt > device_param->device_global_mem)
15213 {
15214 if (quiet == 0) log_info ("WARNING: Not enough total device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15215
15216 continue;
15217 }
15218
15219 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
15220 {
15221 data.scrypt_tmto_final = tmto;
15222 }
15223
15224 break;
15225 }
15226
15227 if (tmto == tmto_stop)
15228 {
15229 log_error ("ERROR: Can't allocate enough device memory");
15230
15231 return -1;
15232 }
15233
15234 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %llu\n", data.scrypt_tmto_final, (unsigned long long int) size_scrypt);
15235 }
15236
15237 size_t size_scrypt4 = size_scrypt / 4;
15238
15239 /**
15240 * some algorithms need a fixed kernel-loops count
15241 */
15242
15243 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15244 {
15245 const u32 kernel_loops_fixed = 1024;
15246
15247 device_param->kernel_loops_min = kernel_loops_fixed;
15248 device_param->kernel_loops_max = kernel_loops_fixed;
15249 }
15250
15251 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15252 {
15253 const u32 kernel_loops_fixed = 1024;
15254
15255 device_param->kernel_loops_min = kernel_loops_fixed;
15256 device_param->kernel_loops_max = kernel_loops_fixed;
15257 }
15258
15259 if (hash_mode == 8900)
15260 {
15261 const u32 kernel_loops_fixed = 1;
15262
15263 device_param->kernel_loops_min = kernel_loops_fixed;
15264 device_param->kernel_loops_max = kernel_loops_fixed;
15265 }
15266
15267 if (hash_mode == 9300)
15268 {
15269 const u32 kernel_loops_fixed = 1;
15270
15271 device_param->kernel_loops_min = kernel_loops_fixed;
15272 device_param->kernel_loops_max = kernel_loops_fixed;
15273 }
15274
15275 if (hash_mode == 12500)
15276 {
15277 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15278
15279 device_param->kernel_loops_min = kernel_loops_fixed;
15280 device_param->kernel_loops_max = kernel_loops_fixed;
15281 }
15282
15283 /**
15284 * some algorithms have a maximum kernel-loops count
15285 */
15286
15287 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15288 {
15289 u32 innerloop_cnt = 0;
15290
15291 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15292 {
15293 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15294 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15295 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15296 }
15297 else
15298 {
15299 innerloop_cnt = data.salts_buf[0].salt_iter;
15300 }
15301
15302 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15303 (innerloop_cnt <= device_param->kernel_loops_max))
15304 {
15305 device_param->kernel_loops_max = innerloop_cnt;
15306 }
15307 }
15308
15309 u32 kernel_accel_min = device_param->kernel_accel_min;
15310 u32 kernel_accel_max = device_param->kernel_accel_max;
15311
15312 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15313
15314 size_t size_pws = 4;
15315 size_t size_tmps = 4;
15316 size_t size_hooks = 4;
15317
15318 while (kernel_accel_max >= kernel_accel_min)
15319 {
15320 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15321
15322 // size_pws
15323
15324 size_pws = kernel_power_max * sizeof (pw_t);
15325
15326 // size_tmps
15327
15328 switch (hash_mode)
15329 {
15330 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15331 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15332 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15333 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15334 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15335 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15336 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15337 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15338 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15339 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15340 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15341 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15342 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15343 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15344 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15345 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15346 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15347 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15348 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15349 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15350 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15351 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15352 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15353 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
15354 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
15355 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
15356 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
15357 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
15358 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15359 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15360 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
15361 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
15362 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15363 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
15364 case 8900: size_tmps = kernel_power_max * data.scrypt_tmp_size; break;
15365 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
15366 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
15367 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15368 case 9300: size_tmps = kernel_power_max * data.scrypt_tmp_size; break;
15369 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
15370 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
15371 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
15372 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15373 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
15374 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
15375 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
15376 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
15377 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15378 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
15379 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
15380 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
15381 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15382 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15383 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
15384 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
15385 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
15386 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
15387 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
15388 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15389 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15390 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15391 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
15392 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
15393 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15394 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15395 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15396 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15397 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15398 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15399 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15400 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15401 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15402 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15403 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15404 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15405 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15406 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15407 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15408 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15409 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15410 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15411 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15412 };
15413
15414 // size_hooks
15415
15416 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15417 {
15418 switch (hash_mode)
15419 {
15420 }
15421 }
15422
15423 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15424 // if not, decrease amplifier and try again
15425
15426 int memory_limit_hit = 0;
15427
15428 if (size_pws > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15429 if (size_tmps > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15430 if (size_hooks > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15431
15432 const u64 size_total
15433 = bitmap_size
15434 + bitmap_size
15435 + bitmap_size
15436 + bitmap_size
15437 + bitmap_size
15438 + bitmap_size
15439 + bitmap_size
15440 + bitmap_size
15441 + size_bfs
15442 + size_combs
15443 + size_digests
15444 + size_esalts
15445 + size_hooks
15446 + size_markov_css
15447 + size_plains
15448 + size_pws
15449 + size_pws // not a bug
15450 + size_results
15451 + size_root_css
15452 + size_rules
15453 + size_rules_c
15454 + size_salts
15455 + size_scrypt4
15456 + size_scrypt4
15457 + size_scrypt4
15458 + size_scrypt4
15459 + size_shown
15460 + size_tm
15461 + size_tmps;
15462
15463 if (size_total > device_param->device_global_mem) memory_limit_hit = 1;
15464
15465 if (memory_limit_hit == 1)
15466 {
15467 kernel_accel_max--;
15468
15469 continue;
15470 }
15471
15472 break;
15473 }
15474
15475 if (kernel_accel_max < kernel_accel_min)
15476 {
15477 log_error ("- Device #%u: Device does not provide enough allocatable device-memory to handle this attack", device_id + 1);
15478
15479 return -1;
15480 }
15481
15482 device_param->kernel_accel_min = kernel_accel_min;
15483 device_param->kernel_accel_max = kernel_accel_max;
15484
15485 /*
15486 if (kernel_accel_max < kernel_accel)
15487 {
15488 if (quiet == 0) log_info ("- Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
15489
15490 device_param->kernel_accel = kernel_accel_max;
15491 }
15492 */
15493
15494 device_param->size_bfs = size_bfs;
15495 device_param->size_combs = size_combs;
15496 device_param->size_rules = size_rules;
15497 device_param->size_rules_c = size_rules_c;
15498 device_param->size_pws = size_pws;
15499 device_param->size_tmps = size_tmps;
15500 device_param->size_hooks = size_hooks;
15501
15502 /**
15503 * default building options
15504 */
15505
15506 char cpath[1024] = { 0 };
15507
15508 char build_opts[1024] = { 0 };
15509
15510 #if _WIN
15511
15512 snprintf (cpath, sizeof (cpath) - 1, "%s\\OpenCL\\", shared_dir);
15513
15514 char *cpath_real = mymalloc (MAX_PATH);
15515
15516 if (GetFullPathName (cpath, MAX_PATH, cpath_real, NULL) == 0)
15517 {
15518 log_error ("ERROR: %s: %s", cpath, "GetFullPathName()");
15519
15520 return -1;
15521 }
15522
15523 naive_replace (cpath_real, '\\', '/');
15524
15525 // not escaping here, windows has quotes
15526
15527 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\"", cpath_real);
15528
15529 #else
15530
15531 snprintf (cpath, sizeof (cpath) - 1, "%s/OpenCL/", shared_dir);
15532
15533 char *cpath_real = mymalloc (PATH_MAX);
15534
15535 if (realpath (cpath, cpath_real) == NULL)
15536 {
15537 log_error ("ERROR: %s: %s", cpath, strerror (errno));
15538
15539 return -1;
15540 }
15541
15542 naive_escape (cpath_real, PATH_MAX, ' ', '\\');
15543
15544 snprintf (build_opts, sizeof (build_opts) - 1, "-I %s", cpath_real);
15545
15546 #endif
15547
15548 // include check
15549 // this test needs to be done manually because of osx opencl runtime
15550 // if there's a problem with permission, its not reporting back and erroring out silently
15551
15552 #define files_cnt 15
15553
15554 const char *files_names[files_cnt] =
15555 {
15556 "inc_cipher_aes256.cl",
15557 "inc_cipher_serpent256.cl",
15558 "inc_cipher_twofish256.cl",
15559 "inc_common.cl",
15560 "inc_comp_multi_bs.cl",
15561 "inc_comp_multi.cl",
15562 "inc_comp_single_bs.cl",
15563 "inc_comp_single.cl",
15564 "inc_hash_constants.h",
15565 "inc_hash_functions.cl",
15566 "inc_rp.cl",
15567 "inc_rp.h",
15568 "inc_simd.cl",
15569 "inc_types.cl",
15570 "inc_vendor.cl",
15571 };
15572
15573 for (int i = 0; i < files_cnt; i++)
15574 {
15575 char path[1024] = { 0 };
15576
15577 snprintf (path, sizeof (path) - 1, "%s/%s", cpath_real, files_names[i]);
15578
15579 FILE *fd = fopen (path, "r");
15580
15581 if (fd == NULL)
15582 {
15583 log_error ("ERROR: %s: fopen(): %s", path, strerror (errno));
15584
15585 return -1;
15586 }
15587
15588 char buf[1];
15589
15590 size_t n = fread (buf, 1, 1, fd);
15591
15592 if (n != 1)
15593 {
15594 log_error ("ERROR: %s: fread(): %s", path, strerror (errno));
15595
15596 return -1;
15597 }
15598
15599 fclose (fd);
15600 }
15601
15602 myfree (cpath_real);
15603
15604 // we don't have sm_* on vendors not NV but it doesn't matter
15605
15606 char build_opts_new[1024] = { 0 };
15607
15608 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);
15609
15610 strncpy (build_opts, build_opts_new, sizeof (build_opts));
15611
15612 #ifdef DEBUG
15613 log_info ("- Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15614 #endif
15615
15616 /**
15617 * main kernel
15618 */
15619
15620 {
15621 /**
15622 * kernel source filename
15623 */
15624
15625 char source_file[256] = { 0 };
15626
15627 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15628
15629 struct stat sst;
15630
15631 if (stat (source_file, &sst) == -1)
15632 {
15633 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15634
15635 return -1;
15636 }
15637
15638 /**
15639 * kernel cached filename
15640 */
15641
15642 char cached_file[256] = { 0 };
15643
15644 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15645
15646 int cached = 1;
15647
15648 struct stat cst;
15649
15650 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15651 {
15652 cached = 0;
15653 }
15654
15655 /**
15656 * kernel compile or load
15657 */
15658
15659 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15660
15661 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15662
15663 if (force_jit_compilation == -1)
15664 {
15665 if (cached == 0)
15666 {
15667 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));
15668
15669 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15670
15671 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15672
15673 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15674
15675 #ifdef DEBUG
15676 size_t build_log_size = 0;
15677
15678 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15679
15680 if (build_log_size > 1)
15681 {
15682 char *build_log = (char *) malloc (build_log_size + 1);
15683
15684 memset (build_log, 0, build_log_size + 1);
15685
15686 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15687
15688 puts (build_log);
15689
15690 free (build_log);
15691 }
15692 #endif
15693
15694 if (rc != 0)
15695 {
15696 device_param->skipped = true;
15697
15698 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15699
15700 continue;
15701 }
15702
15703 size_t binary_size;
15704
15705 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15706
15707 u8 *binary = (u8 *) mymalloc (binary_size);
15708
15709 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15710
15711 writeProgramBin (cached_file, binary, binary_size);
15712
15713 local_free (binary);
15714 }
15715 else
15716 {
15717 #ifdef DEBUG
15718 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15719 #endif
15720
15721 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15722
15723 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15724
15725 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15726 }
15727 }
15728 else
15729 {
15730 #ifdef DEBUG
15731 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15732 #endif
15733
15734 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15735
15736 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15737
15738 char build_opts_update[1024] = { 0 };
15739
15740 if (force_jit_compilation == 1500)
15741 {
15742 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%u", build_opts, data.salts_buf[0].salt_buf[0]);
15743 }
15744 else if (force_jit_compilation == 8900)
15745 {
15746 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);
15747 }
15748 else
15749 {
15750 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15751 }
15752
15753 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15754
15755 #ifdef DEBUG
15756 size_t build_log_size = 0;
15757
15758 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15759
15760 if (build_log_size > 1)
15761 {
15762 char *build_log = (char *) malloc (build_log_size + 1);
15763
15764 memset (build_log, 0, build_log_size + 1);
15765
15766 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15767
15768 puts (build_log);
15769
15770 free (build_log);
15771 }
15772 #endif
15773
15774 if (rc != 0)
15775 {
15776 device_param->skipped = true;
15777
15778 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15779 }
15780 }
15781
15782 local_free (kernel_lengths);
15783 local_free (kernel_sources[0]);
15784 local_free (kernel_sources);
15785 }
15786
15787 /**
15788 * word generator kernel
15789 */
15790
15791 if (attack_mode != ATTACK_MODE_STRAIGHT)
15792 {
15793 /**
15794 * kernel mp source filename
15795 */
15796
15797 char source_file[256] = { 0 };
15798
15799 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15800
15801 struct stat sst;
15802
15803 if (stat (source_file, &sst) == -1)
15804 {
15805 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15806
15807 return -1;
15808 }
15809
15810 /**
15811 * kernel mp cached filename
15812 */
15813
15814 char cached_file[256] = { 0 };
15815
15816 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15817
15818 int cached = 1;
15819
15820 struct stat cst;
15821
15822 if (stat (cached_file, &cst) == -1)
15823 {
15824 cached = 0;
15825 }
15826
15827 /**
15828 * kernel compile or load
15829 */
15830
15831 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15832
15833 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15834
15835 if (cached == 0)
15836 {
15837 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));
15838 if (quiet == 0) log_info ("");
15839
15840 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15841
15842 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15843
15844 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15845
15846 if (rc != 0)
15847 {
15848 device_param->skipped = true;
15849
15850 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15851
15852 continue;
15853 }
15854
15855 size_t binary_size;
15856
15857 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15858
15859 u8 *binary = (u8 *) mymalloc (binary_size);
15860
15861 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15862
15863 writeProgramBin (cached_file, binary, binary_size);
15864
15865 local_free (binary);
15866 }
15867 else
15868 {
15869 #ifdef DEBUG
15870 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15871 #endif
15872
15873 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15874
15875 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15876
15877 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15878 }
15879
15880 local_free (kernel_lengths);
15881 local_free (kernel_sources[0]);
15882 local_free (kernel_sources);
15883 }
15884
15885 /**
15886 * amplifier kernel
15887 */
15888
15889 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15890 {
15891
15892 }
15893 else
15894 {
15895 /**
15896 * kernel amp source filename
15897 */
15898
15899 char source_file[256] = { 0 };
15900
15901 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15902
15903 struct stat sst;
15904
15905 if (stat (source_file, &sst) == -1)
15906 {
15907 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15908
15909 return -1;
15910 }
15911
15912 /**
15913 * kernel amp cached filename
15914 */
15915
15916 char cached_file[256] = { 0 };
15917
15918 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15919
15920 int cached = 1;
15921
15922 struct stat cst;
15923
15924 if (stat (cached_file, &cst) == -1)
15925 {
15926 cached = 0;
15927 }
15928
15929 /**
15930 * kernel compile or load
15931 */
15932
15933 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15934
15935 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15936
15937 if (cached == 0)
15938 {
15939 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));
15940 if (quiet == 0) log_info ("");
15941
15942 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15943
15944 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15945
15946 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15947
15948 if (rc != 0)
15949 {
15950 device_param->skipped = true;
15951
15952 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15953
15954 continue;
15955 }
15956
15957 size_t binary_size;
15958
15959 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15960
15961 u8 *binary = (u8 *) mymalloc (binary_size);
15962
15963 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15964
15965 writeProgramBin (cached_file, binary, binary_size);
15966
15967 local_free (binary);
15968 }
15969 else
15970 {
15971 #ifdef DEBUG
15972 if (quiet == 0) log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15973 #endif
15974
15975 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15976
15977 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15978
15979 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15980 }
15981
15982 local_free (kernel_lengths);
15983 local_free (kernel_sources[0]);
15984 local_free (kernel_sources);
15985 }
15986
15987 // some algorithm collide too fast, make that impossible
15988
15989 if (benchmark == 1)
15990 {
15991 ((uint *) digests_buf)[0] = -1;
15992 ((uint *) digests_buf)[1] = -1;
15993 ((uint *) digests_buf)[2] = -1;
15994 ((uint *) digests_buf)[3] = -1;
15995 }
15996
15997 /**
15998 * global buffers
15999 */
16000
16001 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
16002 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
16003 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
16004 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
16005 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
16006 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
16007 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
16008 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
16009 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
16010 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
16011 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
16012 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
16013 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
16014 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
16015 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
16016 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
16017 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
16018 device_param->d_scryptV0_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
16019 device_param->d_scryptV1_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
16020 device_param->d_scryptV2_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
16021 device_param->d_scryptV3_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
16022
16023 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);
16024 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);
16025 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);
16026 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);
16027 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);
16028 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);
16029 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);
16030 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);
16031 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
16032 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
16033 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
16034
16035 /**
16036 * special buffers
16037 */
16038
16039 if (attack_kern == ATTACK_KERN_STRAIGHT)
16040 {
16041 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
16042 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
16043
16044 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
16045 }
16046 else if (attack_kern == ATTACK_KERN_COMBI)
16047 {
16048 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
16049 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
16050 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
16051 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
16052 }
16053 else if (attack_kern == ATTACK_KERN_BF)
16054 {
16055 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
16056 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
16057 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
16058 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
16059 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
16060 }
16061
16062 if (size_esalts)
16063 {
16064 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
16065
16066 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
16067 }
16068
16069 /**
16070 * main host data
16071 */
16072
16073 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
16074
16075 device_param->pws_buf = pws_buf;
16076
16077 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
16078
16079 device_param->combs_buf = combs_buf;
16080
16081 void *hooks_buf = mymalloc (size_hooks);
16082
16083 device_param->hooks_buf = hooks_buf;
16084
16085 /**
16086 * kernel args
16087 */
16088
16089 device_param->kernel_params_buf32[24] = bitmap_mask;
16090 device_param->kernel_params_buf32[25] = bitmap_shift1;
16091 device_param->kernel_params_buf32[26] = bitmap_shift2;
16092 device_param->kernel_params_buf32[27] = 0; // salt_pos
16093 device_param->kernel_params_buf32[28] = 0; // loop_pos
16094 device_param->kernel_params_buf32[29] = 0; // loop_cnt
16095 device_param->kernel_params_buf32[30] = 0; // kernel_rules_cnt
16096 device_param->kernel_params_buf32[31] = 0; // digests_cnt
16097 device_param->kernel_params_buf32[32] = 0; // digests_offset
16098 device_param->kernel_params_buf32[33] = 0; // combs_mode
16099 device_param->kernel_params_buf32[34] = 0; // gid_max
16100
16101 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16102 ? &device_param->d_pws_buf
16103 : &device_param->d_pws_amp_buf;
16104 device_param->kernel_params[ 1] = &device_param->d_rules_c;
16105 device_param->kernel_params[ 2] = &device_param->d_combs_c;
16106 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
16107 device_param->kernel_params[ 4] = &device_param->d_tmps;
16108 device_param->kernel_params[ 5] = &device_param->d_hooks;
16109 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
16110 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
16111 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
16112 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
16113 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
16114 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
16115 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
16116 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
16117 device_param->kernel_params[14] = &device_param->d_plain_bufs;
16118 device_param->kernel_params[15] = &device_param->d_digests_buf;
16119 device_param->kernel_params[16] = &device_param->d_digests_shown;
16120 device_param->kernel_params[17] = &device_param->d_salt_bufs;
16121 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
16122 device_param->kernel_params[19] = &device_param->d_result;
16123 device_param->kernel_params[20] = &device_param->d_scryptV0_buf;
16124 device_param->kernel_params[21] = &device_param->d_scryptV1_buf;
16125 device_param->kernel_params[22] = &device_param->d_scryptV2_buf;
16126 device_param->kernel_params[23] = &device_param->d_scryptV3_buf;
16127 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
16128 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
16129 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
16130 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
16131 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
16132 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
16133 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
16134 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
16135 device_param->kernel_params[32] = &device_param->kernel_params_buf32[32];
16136 device_param->kernel_params[33] = &device_param->kernel_params_buf32[33];
16137 device_param->kernel_params[34] = &device_param->kernel_params_buf32[34];
16138
16139 device_param->kernel_params_mp_buf64[3] = 0;
16140 device_param->kernel_params_mp_buf32[4] = 0;
16141 device_param->kernel_params_mp_buf32[5] = 0;
16142 device_param->kernel_params_mp_buf32[6] = 0;
16143 device_param->kernel_params_mp_buf32[7] = 0;
16144 device_param->kernel_params_mp_buf32[8] = 0;
16145
16146 device_param->kernel_params_mp[0] = NULL;
16147 device_param->kernel_params_mp[1] = NULL;
16148 device_param->kernel_params_mp[2] = NULL;
16149 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
16150 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
16151 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
16152 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
16153 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
16154 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
16155
16156 device_param->kernel_params_mp_l_buf64[3] = 0;
16157 device_param->kernel_params_mp_l_buf32[4] = 0;
16158 device_param->kernel_params_mp_l_buf32[5] = 0;
16159 device_param->kernel_params_mp_l_buf32[6] = 0;
16160 device_param->kernel_params_mp_l_buf32[7] = 0;
16161 device_param->kernel_params_mp_l_buf32[8] = 0;
16162 device_param->kernel_params_mp_l_buf32[9] = 0;
16163
16164 device_param->kernel_params_mp_l[0] = NULL;
16165 device_param->kernel_params_mp_l[1] = NULL;
16166 device_param->kernel_params_mp_l[2] = NULL;
16167 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
16168 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
16169 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
16170 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
16171 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
16172 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
16173 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
16174
16175 device_param->kernel_params_mp_r_buf64[3] = 0;
16176 device_param->kernel_params_mp_r_buf32[4] = 0;
16177 device_param->kernel_params_mp_r_buf32[5] = 0;
16178 device_param->kernel_params_mp_r_buf32[6] = 0;
16179 device_param->kernel_params_mp_r_buf32[7] = 0;
16180 device_param->kernel_params_mp_r_buf32[8] = 0;
16181
16182 device_param->kernel_params_mp_r[0] = NULL;
16183 device_param->kernel_params_mp_r[1] = NULL;
16184 device_param->kernel_params_mp_r[2] = NULL;
16185 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
16186 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
16187 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
16188 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
16189 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
16190 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
16191
16192 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
16193 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
16194
16195 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
16196 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
16197 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
16198 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
16199 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
16200 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
16201 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
16202
16203 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
16204 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
16205
16206 device_param->kernel_params_memset_buf32[1] = 0; // value
16207 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
16208
16209 device_param->kernel_params_memset[0] = NULL;
16210 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
16211 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
16212
16213 /**
16214 * kernel name
16215 */
16216
16217 size_t kernel_wgs_tmp;
16218
16219 char kernel_name[64] = { 0 };
16220
16221 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16222 {
16223 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16224 {
16225 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
16226
16227 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16228
16229 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
16230
16231 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16232
16233 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
16234
16235 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16236 }
16237 else
16238 {
16239 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
16240
16241 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16242
16243 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
16244
16245 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16246
16247 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
16248
16249 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16250 }
16251
16252 if (data.attack_mode == ATTACK_MODE_BF)
16253 {
16254 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16255 {
16256 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
16257
16258 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16259
16260 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);
16261 }
16262 }
16263 }
16264 else
16265 {
16266 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
16267
16268 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16269
16270 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
16271
16272 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16273
16274 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
16275
16276 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16277
16278 if (opts_type & OPTS_TYPE_HOOK12)
16279 {
16280 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
16281
16282 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16283
16284 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);
16285 }
16286
16287 if (opts_type & OPTS_TYPE_HOOK23)
16288 {
16289 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
16290
16291 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16292
16293 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);
16294 }
16295 }
16296
16297 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);
16298 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);
16299 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);
16300
16301 for (uint i = 0; i <= 23; i++)
16302 {
16303 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
16304 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
16305 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
16306
16307 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
16308 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
16309 }
16310
16311 for (uint i = 24; i <= 34; i++)
16312 {
16313 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
16314 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
16315 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
16316
16317 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
16318 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
16319 }
16320
16321 // GPU memset
16322
16323 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
16324
16325 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);
16326
16327 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
16328 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
16329 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
16330
16331 // MP start
16332
16333 if (attack_mode == ATTACK_MODE_BF)
16334 {
16335 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
16336 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
16337
16338 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);
16339 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);
16340
16341 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16342 {
16343 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
16344 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
16345 }
16346 }
16347 else if (attack_mode == ATTACK_MODE_HYBRID1)
16348 {
16349 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16350
16351 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);
16352 }
16353 else if (attack_mode == ATTACK_MODE_HYBRID2)
16354 {
16355 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16356
16357 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);
16358 }
16359
16360 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16361 {
16362 // nothing to do
16363 }
16364 else
16365 {
16366 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
16367
16368 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);
16369 }
16370
16371 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16372 {
16373 // nothing to do
16374 }
16375 else
16376 {
16377 for (uint i = 0; i < 5; i++)
16378 {
16379 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
16380 }
16381
16382 for (uint i = 5; i < 7; i++)
16383 {
16384 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
16385 }
16386 }
16387
16388 // maybe this has been updated by clGetKernelWorkGroupInfo()
16389 // value can only be decreased, so we don't need to reallocate buffers
16390
16391 device_param->kernel_threads = kernel_threads;
16392
16393 // zero some data buffers
16394
16395 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
16396 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
16397 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
16398 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
16399 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
16400 run_kernel_bzero (device_param, device_param->d_result, size_results);
16401
16402 /**
16403 * special buffers
16404 */
16405
16406 if (attack_kern == ATTACK_KERN_STRAIGHT)
16407 {
16408 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
16409 }
16410 else if (attack_kern == ATTACK_KERN_COMBI)
16411 {
16412 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
16413 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
16414 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16415 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16416 }
16417 else if (attack_kern == ATTACK_KERN_BF)
16418 {
16419 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
16420 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
16421 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
16422 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16423 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16424 }
16425
16426 #if defined(HAVE_HWMON)
16427
16428 /**
16429 * Store initial fanspeed if gpu_temp_retain is enabled
16430 */
16431
16432 if (gpu_temp_disable == 0)
16433 {
16434 if (gpu_temp_retain != 0)
16435 {
16436 hc_thread_mutex_lock (mux_adl);
16437
16438 if (data.hm_device[device_id].fan_get_supported == 1)
16439 {
16440 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
16441 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
16442
16443 // we also set it to tell the OS we take control over the fan and it's automatic controller
16444 // if it was set to automatic. we do not control user-defined fanspeeds.
16445
16446 if (fanpolicy == 1)
16447 {
16448 data.hm_device[device_id].fan_set_supported = 1;
16449
16450 int rc = -1;
16451
16452 if (device_param->device_vendor_id == VENDOR_ID_AMD)
16453 {
16454 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
16455 }
16456 else if (device_param->device_vendor_id == VENDOR_ID_NV)
16457 {
16458 #ifdef LINUX
16459 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE);
16460 #endif
16461
16462 #ifdef WIN
16463 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
16464 #endif
16465 }
16466
16467 if (rc == 0)
16468 {
16469 data.hm_device[device_id].fan_set_supported = 1;
16470 }
16471 else
16472 {
16473 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
16474
16475 data.hm_device[device_id].fan_set_supported = 0;
16476 }
16477 }
16478 else
16479 {
16480 data.hm_device[device_id].fan_set_supported = 0;
16481 }
16482 }
16483
16484 hc_thread_mutex_unlock (mux_adl);
16485 }
16486 }
16487
16488 #endif // HAVE_HWMON
16489 }
16490
16491 if (data.quiet == 0) log_info_nn ("");
16492
16493 /**
16494 * In benchmark-mode, inform user which algorithm is checked
16495 */
16496
16497 if (benchmark == 1)
16498 {
16499 if (machine_readable == 0)
16500 {
16501 quiet = 0;
16502
16503 data.quiet = quiet;
16504
16505 char *hash_type = strhashtype (data.hash_mode); // not a bug
16506
16507 log_info ("Hashtype: %s", hash_type);
16508 log_info ("");
16509 }
16510 }
16511
16512 /**
16513 * keep track of the progress
16514 */
16515
16516 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16517 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16518 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16519
16520 /**
16521 * open filehandles
16522 */
16523
16524 #if _WIN
16525 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
16526 {
16527 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
16528
16529 return (-1);
16530 }
16531
16532 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
16533 {
16534 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
16535
16536 return (-1);
16537 }
16538
16539 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
16540 {
16541 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
16542
16543 return (-1);
16544 }
16545 #endif
16546
16547 /**
16548 * dictionary pad
16549 */
16550
16551 segment_size *= (1024 * 1024);
16552
16553 data.segment_size = segment_size;
16554
16555 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
16556
16557 wl_data->buf = (char *) mymalloc (segment_size);
16558 wl_data->avail = segment_size;
16559 wl_data->incr = segment_size;
16560 wl_data->cnt = 0;
16561 wl_data->pos = 0;
16562
16563 cs_t *css_buf = NULL;
16564 uint css_cnt = 0;
16565 uint dictcnt = 0;
16566 uint maskcnt = 1;
16567 char **masks = NULL;
16568 char **dictfiles = NULL;
16569
16570 uint mask_from_file = 0;
16571
16572 if (attack_mode == ATTACK_MODE_STRAIGHT)
16573 {
16574 if (wordlist_mode == WL_MODE_FILE)
16575 {
16576 int wls_left = myargc - (optind + 1);
16577
16578 for (int i = 0; i < wls_left; i++)
16579 {
16580 char *l0_filename = myargv[optind + 1 + i];
16581
16582 struct stat l0_stat;
16583
16584 if (stat (l0_filename, &l0_stat) == -1)
16585 {
16586 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
16587
16588 return (-1);
16589 }
16590
16591 uint is_dir = S_ISDIR (l0_stat.st_mode);
16592
16593 if (is_dir == 0)
16594 {
16595 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16596
16597 dictcnt++;
16598
16599 dictfiles[dictcnt - 1] = l0_filename;
16600 }
16601 else
16602 {
16603 // do not allow --keyspace w/ a directory
16604
16605 if (keyspace == 1)
16606 {
16607 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16608
16609 return (-1);
16610 }
16611
16612 char **dictionary_files = NULL;
16613
16614 dictionary_files = scan_directory (l0_filename);
16615
16616 if (dictionary_files != NULL)
16617 {
16618 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16619
16620 for (int d = 0; dictionary_files[d] != NULL; d++)
16621 {
16622 char *l1_filename = dictionary_files[d];
16623
16624 struct stat l1_stat;
16625
16626 if (stat (l1_filename, &l1_stat) == -1)
16627 {
16628 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16629
16630 return (-1);
16631 }
16632
16633 if (S_ISREG (l1_stat.st_mode))
16634 {
16635 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16636
16637 dictcnt++;
16638
16639 dictfiles[dictcnt - 1] = strdup (l1_filename);
16640 }
16641 }
16642 }
16643
16644 local_free (dictionary_files);
16645 }
16646 }
16647
16648 if (dictcnt < 1)
16649 {
16650 log_error ("ERROR: No usable dictionary file found.");
16651
16652 return (-1);
16653 }
16654 }
16655 else if (wordlist_mode == WL_MODE_STDIN)
16656 {
16657 dictcnt = 1;
16658 }
16659 }
16660 else if (attack_mode == ATTACK_MODE_COMBI)
16661 {
16662 // display
16663
16664 char *dictfile1 = myargv[optind + 1 + 0];
16665 char *dictfile2 = myargv[optind + 1 + 1];
16666
16667 // find the bigger dictionary and use as base
16668
16669 FILE *fp1 = NULL;
16670 FILE *fp2 = NULL;
16671
16672 struct stat tmp_stat;
16673
16674 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16675 {
16676 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16677
16678 return (-1);
16679 }
16680
16681 if (stat (dictfile1, &tmp_stat) == -1)
16682 {
16683 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16684
16685 fclose (fp1);
16686
16687 return (-1);
16688 }
16689
16690 if (S_ISDIR (tmp_stat.st_mode))
16691 {
16692 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16693
16694 fclose (fp1);
16695
16696 return (-1);
16697 }
16698
16699 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16700 {
16701 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16702
16703 fclose (fp1);
16704
16705 return (-1);
16706 }
16707
16708 if (stat (dictfile2, &tmp_stat) == -1)
16709 {
16710 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16711
16712 fclose (fp1);
16713 fclose (fp2);
16714
16715 return (-1);
16716 }
16717
16718 if (S_ISDIR (tmp_stat.st_mode))
16719 {
16720 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16721
16722 fclose (fp1);
16723 fclose (fp2);
16724
16725 return (-1);
16726 }
16727
16728 data.combs_cnt = 1;
16729
16730 data.quiet = 1;
16731
16732 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16733
16734 data.quiet = quiet;
16735
16736 if (words1_cnt == 0)
16737 {
16738 log_error ("ERROR: %s: empty file", dictfile1);
16739
16740 fclose (fp1);
16741 fclose (fp2);
16742
16743 return (-1);
16744 }
16745
16746 data.combs_cnt = 1;
16747
16748 data.quiet = 1;
16749
16750 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16751
16752 data.quiet = quiet;
16753
16754 if (words2_cnt == 0)
16755 {
16756 log_error ("ERROR: %s: empty file", dictfile2);
16757
16758 fclose (fp1);
16759 fclose (fp2);
16760
16761 return (-1);
16762 }
16763
16764 fclose (fp1);
16765 fclose (fp2);
16766
16767 data.dictfile = dictfile1;
16768 data.dictfile2 = dictfile2;
16769
16770 if (words1_cnt >= words2_cnt)
16771 {
16772 data.combs_cnt = words2_cnt;
16773 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16774
16775 dictfiles = &data.dictfile;
16776
16777 dictcnt = 1;
16778 }
16779 else
16780 {
16781 data.combs_cnt = words1_cnt;
16782 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16783
16784 dictfiles = &data.dictfile2;
16785
16786 dictcnt = 1;
16787
16788 // we also have to switch wordlist related rules!
16789
16790 char *tmpc = data.rule_buf_l;
16791
16792 data.rule_buf_l = data.rule_buf_r;
16793 data.rule_buf_r = tmpc;
16794
16795 int tmpi = data.rule_len_l;
16796
16797 data.rule_len_l = data.rule_len_r;
16798 data.rule_len_r = tmpi;
16799 }
16800 }
16801 else if (attack_mode == ATTACK_MODE_BF)
16802 {
16803 char *mask = NULL;
16804
16805 maskcnt = 0;
16806
16807 if (benchmark == 0)
16808 {
16809 mask = myargv[optind + 1];
16810
16811 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16812
16813 if ((optind + 2) <= myargc)
16814 {
16815 struct stat file_stat;
16816
16817 if (stat (mask, &file_stat) == -1)
16818 {
16819 maskcnt = 1;
16820
16821 masks[maskcnt - 1] = mystrdup (mask);
16822 }
16823 else
16824 {
16825 int wls_left = myargc - (optind + 1);
16826
16827 uint masks_avail = INCR_MASKS;
16828
16829 for (int i = 0; i < wls_left; i++)
16830 {
16831 if (i != 0)
16832 {
16833 mask = myargv[optind + 1 + i];
16834
16835 if (stat (mask, &file_stat) == -1)
16836 {
16837 log_error ("ERROR: %s: %s", mask, strerror (errno));
16838
16839 return (-1);
16840 }
16841 }
16842
16843 uint is_file = S_ISREG (file_stat.st_mode);
16844
16845 if (is_file == 1)
16846 {
16847 FILE *mask_fp;
16848
16849 if ((mask_fp = fopen (mask, "r")) == NULL)
16850 {
16851 log_error ("ERROR: %s: %s", mask, strerror (errno));
16852
16853 return (-1);
16854 }
16855
16856 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16857
16858 while (!feof (mask_fp))
16859 {
16860 memset (line_buf, 0, HCBUFSIZ);
16861
16862 int line_len = fgetl (mask_fp, line_buf);
16863
16864 if (line_len == 0) continue;
16865
16866 if (line_buf[0] == '#') continue;
16867
16868 if (masks_avail == maskcnt)
16869 {
16870 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16871
16872 masks_avail += INCR_MASKS;
16873 }
16874
16875 masks[maskcnt] = mystrdup (line_buf);
16876
16877 maskcnt++;
16878 }
16879
16880 myfree (line_buf);
16881
16882 fclose (mask_fp);
16883 }
16884 else
16885 {
16886 log_error ("ERROR: %s: unsupported file-type", mask);
16887
16888 return (-1);
16889 }
16890 }
16891
16892 mask_from_file = 1;
16893 }
16894 }
16895 else
16896 {
16897 custom_charset_1 = (char *) "?l?d?u";
16898 custom_charset_2 = (char *) "?l?d";
16899 custom_charset_3 = (char *) "?l?d*!$@_";
16900
16901 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16902 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16903 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16904
16905 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16906
16907 wordlist_mode = WL_MODE_MASK;
16908
16909 data.wordlist_mode = wordlist_mode;
16910
16911 increment = 1;
16912
16913 maskcnt = 1;
16914 }
16915 }
16916 else
16917 {
16918 /**
16919 * generate full masks and charsets
16920 */
16921
16922 masks = (char **) mymalloc (sizeof (char *));
16923
16924 switch (hash_mode)
16925 {
16926 case 1731: pw_min = 5;
16927 pw_max = 5;
16928 mask = mystrdup ("?b?b?b?b?b");
16929 break;
16930 case 12500: pw_min = 5;
16931 pw_max = 5;
16932 mask = mystrdup ("?b?b?b?b?b");
16933 break;
16934 default: pw_min = 7;
16935 pw_max = 7;
16936 mask = mystrdup ("?b?b?b?b?b?b?b");
16937 break;
16938 }
16939
16940 maskcnt = 1;
16941
16942 masks[maskcnt - 1] = mystrdup (mask);
16943
16944 wordlist_mode = WL_MODE_MASK;
16945
16946 data.wordlist_mode = wordlist_mode;
16947
16948 increment = 1;
16949 }
16950
16951 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16952
16953 if (increment)
16954 {
16955 if (increment_min > pw_min) pw_min = increment_min;
16956
16957 if (increment_max < pw_max) pw_max = increment_max;
16958 }
16959 }
16960 else if (attack_mode == ATTACK_MODE_HYBRID1)
16961 {
16962 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16963
16964 // display
16965
16966 char *mask = myargv[myargc - 1];
16967
16968 maskcnt = 0;
16969
16970 masks = (char **) mymalloc (1 * sizeof (char *));
16971
16972 // mod
16973
16974 struct stat file_stat;
16975
16976 if (stat (mask, &file_stat) == -1)
16977 {
16978 maskcnt = 1;
16979
16980 masks[maskcnt - 1] = mystrdup (mask);
16981 }
16982 else
16983 {
16984 uint is_file = S_ISREG (file_stat.st_mode);
16985
16986 if (is_file == 1)
16987 {
16988 FILE *mask_fp;
16989
16990 if ((mask_fp = fopen (mask, "r")) == NULL)
16991 {
16992 log_error ("ERROR: %s: %s", mask, strerror (errno));
16993
16994 return (-1);
16995 }
16996
16997 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16998
16999 uint masks_avail = 1;
17000
17001 while (!feof (mask_fp))
17002 {
17003 memset (line_buf, 0, HCBUFSIZ);
17004
17005 int line_len = fgetl (mask_fp, line_buf);
17006
17007 if (line_len == 0) continue;
17008
17009 if (line_buf[0] == '#') continue;
17010
17011 if (masks_avail == maskcnt)
17012 {
17013 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
17014
17015 masks_avail += INCR_MASKS;
17016 }
17017
17018 masks[maskcnt] = mystrdup (line_buf);
17019
17020 maskcnt++;
17021 }
17022
17023 myfree (line_buf);
17024
17025 fclose (mask_fp);
17026
17027 mask_from_file = 1;
17028 }
17029 else
17030 {
17031 maskcnt = 1;
17032
17033 masks[maskcnt - 1] = mystrdup (mask);
17034 }
17035 }
17036
17037 // base
17038
17039 int wls_left = myargc - (optind + 2);
17040
17041 for (int i = 0; i < wls_left; i++)
17042 {
17043 char *filename = myargv[optind + 1 + i];
17044
17045 struct stat file_stat;
17046
17047 if (stat (filename, &file_stat) == -1)
17048 {
17049 log_error ("ERROR: %s: %s", filename, strerror (errno));
17050
17051 return (-1);
17052 }
17053
17054 uint is_dir = S_ISDIR (file_stat.st_mode);
17055
17056 if (is_dir == 0)
17057 {
17058 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17059
17060 dictcnt++;
17061
17062 dictfiles[dictcnt - 1] = filename;
17063 }
17064 else
17065 {
17066 // do not allow --keyspace w/ a directory
17067
17068 if (keyspace == 1)
17069 {
17070 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17071
17072 return (-1);
17073 }
17074
17075 char **dictionary_files = NULL;
17076
17077 dictionary_files = scan_directory (filename);
17078
17079 if (dictionary_files != NULL)
17080 {
17081 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17082
17083 for (int d = 0; dictionary_files[d] != NULL; d++)
17084 {
17085 char *l1_filename = dictionary_files[d];
17086
17087 struct stat l1_stat;
17088
17089 if (stat (l1_filename, &l1_stat) == -1)
17090 {
17091 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17092
17093 return (-1);
17094 }
17095
17096 if (S_ISREG (l1_stat.st_mode))
17097 {
17098 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17099
17100 dictcnt++;
17101
17102 dictfiles[dictcnt - 1] = strdup (l1_filename);
17103 }
17104 }
17105 }
17106
17107 local_free (dictionary_files);
17108 }
17109 }
17110
17111 if (dictcnt < 1)
17112 {
17113 log_error ("ERROR: No usable dictionary file found.");
17114
17115 return (-1);
17116 }
17117
17118 if (increment)
17119 {
17120 maskcnt = 0;
17121
17122 uint mask_min = increment_min; // we can't reject smaller masks here
17123 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17124
17125 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17126 {
17127 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17128
17129 if (cur_mask == NULL) break;
17130
17131 masks[maskcnt] = cur_mask;
17132
17133 maskcnt++;
17134
17135 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17136 }
17137 }
17138 }
17139 else if (attack_mode == ATTACK_MODE_HYBRID2)
17140 {
17141 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
17142
17143 // display
17144
17145 char *mask = myargv[optind + 1 + 0];
17146
17147 maskcnt = 0;
17148
17149 masks = (char **) mymalloc (1 * sizeof (char *));
17150
17151 // mod
17152
17153 struct stat file_stat;
17154
17155 if (stat (mask, &file_stat) == -1)
17156 {
17157 maskcnt = 1;
17158
17159 masks[maskcnt - 1] = mystrdup (mask);
17160 }
17161 else
17162 {
17163 uint is_file = S_ISREG (file_stat.st_mode);
17164
17165 if (is_file == 1)
17166 {
17167 FILE *mask_fp;
17168
17169 if ((mask_fp = fopen (mask, "r")) == NULL)
17170 {
17171 log_error ("ERROR: %s: %s", mask, strerror (errno));
17172
17173 return (-1);
17174 }
17175
17176 char *line_buf = (char *) mymalloc (HCBUFSIZ);
17177
17178 uint masks_avail = 1;
17179
17180 while (!feof (mask_fp))
17181 {
17182 memset (line_buf, 0, HCBUFSIZ);
17183
17184 int line_len = fgetl (mask_fp, line_buf);
17185
17186 if (line_len == 0) continue;
17187
17188 if (line_buf[0] == '#') continue;
17189
17190 if (masks_avail == maskcnt)
17191 {
17192 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
17193
17194 masks_avail += INCR_MASKS;
17195 }
17196
17197 masks[maskcnt] = mystrdup (line_buf);
17198
17199 maskcnt++;
17200 }
17201
17202 myfree (line_buf);
17203
17204 fclose (mask_fp);
17205
17206 mask_from_file = 1;
17207 }
17208 else
17209 {
17210 maskcnt = 1;
17211
17212 masks[maskcnt - 1] = mystrdup (mask);
17213 }
17214 }
17215
17216 // base
17217
17218 int wls_left = myargc - (optind + 2);
17219
17220 for (int i = 0; i < wls_left; i++)
17221 {
17222 char *filename = myargv[optind + 2 + i];
17223
17224 struct stat file_stat;
17225
17226 if (stat (filename, &file_stat) == -1)
17227 {
17228 log_error ("ERROR: %s: %s", filename, strerror (errno));
17229
17230 return (-1);
17231 }
17232
17233 uint is_dir = S_ISDIR (file_stat.st_mode);
17234
17235 if (is_dir == 0)
17236 {
17237 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17238
17239 dictcnt++;
17240
17241 dictfiles[dictcnt - 1] = filename;
17242 }
17243 else
17244 {
17245 // do not allow --keyspace w/ a directory
17246
17247 if (keyspace == 1)
17248 {
17249 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17250
17251 return (-1);
17252 }
17253
17254 char **dictionary_files = NULL;
17255
17256 dictionary_files = scan_directory (filename);
17257
17258 if (dictionary_files != NULL)
17259 {
17260 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17261
17262 for (int d = 0; dictionary_files[d] != NULL; d++)
17263 {
17264 char *l1_filename = dictionary_files[d];
17265
17266 struct stat l1_stat;
17267
17268 if (stat (l1_filename, &l1_stat) == -1)
17269 {
17270 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17271
17272 return (-1);
17273 }
17274
17275 if (S_ISREG (l1_stat.st_mode))
17276 {
17277 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17278
17279 dictcnt++;
17280
17281 dictfiles[dictcnt - 1] = strdup (l1_filename);
17282 }
17283 }
17284 }
17285
17286 local_free (dictionary_files);
17287 }
17288 }
17289
17290 if (dictcnt < 1)
17291 {
17292 log_error ("ERROR: No usable dictionary file found.");
17293
17294 return (-1);
17295 }
17296
17297 if (increment)
17298 {
17299 maskcnt = 0;
17300
17301 uint mask_min = increment_min; // we can't reject smaller masks here
17302 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17303
17304 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17305 {
17306 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17307
17308 if (cur_mask == NULL) break;
17309
17310 masks[maskcnt] = cur_mask;
17311
17312 maskcnt++;
17313
17314 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17315 }
17316 }
17317 }
17318
17319 data.pw_min = pw_min;
17320 data.pw_max = pw_max;
17321
17322 /**
17323 * weak hash check
17324 */
17325
17326 if (weak_hash_threshold >= salts_cnt)
17327 {
17328 hc_device_param_t *device_param = NULL;
17329
17330 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17331 {
17332 device_param = &data.devices_param[device_id];
17333
17334 if (device_param->skipped) continue;
17335
17336 break;
17337 }
17338
17339 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
17340
17341 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
17342 {
17343 weak_hash_check (device_param, salt_pos);
17344 }
17345
17346 // Display hack, guarantee that there is at least one \r before real start
17347
17348 //if (data.quiet == 0) log_info ("");
17349 }
17350
17351 /**
17352 * status and monitor threads
17353 */
17354
17355 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17356 {
17357 data.devices_status = STATUS_STARTING;
17358 }
17359
17360 uint inner_threads_cnt = 0;
17361
17362 hc_thread_t *inner_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17363
17364 data.shutdown_inner = 0;
17365
17366 /**
17367 * Outfile remove
17368 */
17369
17370 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
17371 {
17372 hc_thread_create (inner_threads[inner_threads_cnt], thread_monitor, NULL);
17373
17374 inner_threads_cnt++;
17375
17376 if (outfile_check_timer != 0)
17377 {
17378 if (data.outfile_check_directory != NULL)
17379 {
17380 if ((hash_mode != 5200) &&
17381 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
17382 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
17383 (hash_mode != 9000))
17384 {
17385 hc_thread_create (inner_threads[inner_threads_cnt], thread_outfile_remove, NULL);
17386
17387 inner_threads_cnt++;
17388 }
17389 else
17390 {
17391 outfile_check_timer = 0;
17392 }
17393 }
17394 else
17395 {
17396 outfile_check_timer = 0;
17397 }
17398 }
17399 }
17400
17401 /**
17402 * Inform the user if we got some hashes remove because of the pot file remove feature
17403 */
17404
17405 if (data.quiet == 0)
17406 {
17407 if (potfile_remove_cracks > 0)
17408 {
17409 if (potfile_remove_cracks == 1) log_info ("INFO: Removed 1 hash found in pot file\n");
17410 else log_info ("INFO: Removed %u hashes found in pot file\n", potfile_remove_cracks);
17411 }
17412 }
17413
17414 data.outfile_check_timer = outfile_check_timer;
17415
17416 /**
17417 * main loop
17418 */
17419
17420 char **induction_dictionaries = NULL;
17421
17422 int induction_dictionaries_cnt = 0;
17423
17424 hcstat_table_t *root_table_buf = NULL;
17425 hcstat_table_t *markov_table_buf = NULL;
17426
17427 uint initial_restore_done = 0;
17428
17429 data.maskcnt = maskcnt;
17430
17431 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
17432 {
17433 if (data.devices_status == STATUS_CRACKED) continue;
17434 if (data.devices_status == STATUS_ABORTED) continue;
17435 if (data.devices_status == STATUS_QUIT) continue;
17436
17437 if (maskpos > rd->maskpos)
17438 {
17439 rd->dictpos = 0;
17440 }
17441
17442 rd->maskpos = maskpos;
17443 data.maskpos = maskpos;
17444
17445 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
17446 {
17447 char *mask = masks[maskpos];
17448
17449 if (mask_from_file == 1)
17450 {
17451 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
17452
17453 char *str_ptr;
17454 uint str_pos;
17455
17456 uint mask_offset = 0;
17457
17458 uint separator_cnt;
17459
17460 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
17461 {
17462 str_ptr = strstr (mask + mask_offset, ",");
17463
17464 if (str_ptr == NULL) break;
17465
17466 str_pos = str_ptr - mask;
17467
17468 // escaped separator, i.e. "\,"
17469
17470 if (str_pos > 0)
17471 {
17472 if (mask[str_pos - 1] == '\\')
17473 {
17474 separator_cnt --;
17475
17476 mask_offset = str_pos + 1;
17477
17478 continue;
17479 }
17480 }
17481
17482 // reset the offset
17483
17484 mask_offset = 0;
17485
17486 mask[str_pos] = '\0';
17487
17488 switch (separator_cnt)
17489 {
17490 case 0:
17491 mp_reset_usr (mp_usr, 0);
17492
17493 custom_charset_1 = mask;
17494 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17495 break;
17496
17497 case 1:
17498 mp_reset_usr (mp_usr, 1);
17499
17500 custom_charset_2 = mask;
17501 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17502 break;
17503
17504 case 2:
17505 mp_reset_usr (mp_usr, 2);
17506
17507 custom_charset_3 = mask;
17508 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17509 break;
17510
17511 case 3:
17512 mp_reset_usr (mp_usr, 3);
17513
17514 custom_charset_4 = mask;
17515 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
17516 break;
17517 }
17518
17519 mask = mask + str_pos + 1;
17520 }
17521
17522 /**
17523 * What follows is a very special case where "\," is within the mask field of a line in a .hcmask file only because otherwise (without the "\")
17524 * it would be interpreted as a custom charset definition.
17525 *
17526 * We need to replace all "\," with just "," within the mask (but allow the special case "\\," which means "\" followed by ",")
17527 * Note: "\\" is not needed to replace all "\" within the mask! The meaning of "\\" within a line containing the string "\\," is just to allow "\" followed by ","
17528 */
17529
17530 uint mask_len_cur = strlen (mask);
17531
17532 uint mask_out_pos = 0;
17533 char mask_prev = 0;
17534
17535 for (uint mask_iter = 0; mask_iter < mask_len_cur; mask_iter++, mask_out_pos++)
17536 {
17537 if (mask[mask_iter] == ',')
17538 {
17539 if (mask_prev == '\\')
17540 {
17541 mask_out_pos -= 1; // this means: skip the previous "\"
17542 }
17543 }
17544
17545 mask_prev = mask[mask_iter];
17546
17547 mask[mask_out_pos] = mask[mask_iter];
17548 }
17549
17550 mask[mask_out_pos] = '\0';
17551 }
17552
17553 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17554 {
17555 if (maskpos > 0)
17556 {
17557 local_free (css_buf);
17558 local_free (data.root_css_buf);
17559 local_free (data.markov_css_buf);
17560
17561 local_free (masks[maskpos - 1]);
17562 }
17563
17564 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17565
17566 data.mask = mask;
17567 data.css_cnt = css_cnt;
17568 data.css_buf = css_buf;
17569
17570 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17571
17572 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17573
17574 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17575 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17576
17577 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17578
17579 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17580
17581 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17582 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17583
17584 data.root_css_buf = root_css_buf;
17585 data.markov_css_buf = markov_css_buf;
17586
17587 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17588
17589 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17590
17591 local_free (root_table_buf);
17592 local_free (markov_table_buf);
17593
17594 // args
17595
17596 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17597 {
17598 hc_device_param_t *device_param = &data.devices_param[device_id];
17599
17600 if (device_param->skipped) continue;
17601
17602 device_param->kernel_params_mp[0] = &device_param->d_combs;
17603 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
17604 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
17605
17606 device_param->kernel_params_mp_buf64[3] = 0;
17607 device_param->kernel_params_mp_buf32[4] = css_cnt;
17608 device_param->kernel_params_mp_buf32[5] = 0;
17609 device_param->kernel_params_mp_buf32[6] = 0;
17610 device_param->kernel_params_mp_buf32[7] = 0;
17611
17612 if (attack_mode == ATTACK_MODE_HYBRID1)
17613 {
17614 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
17615 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
17616 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
17617 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
17618 }
17619 else if (attack_mode == ATTACK_MODE_HYBRID2)
17620 {
17621 device_param->kernel_params_mp_buf32[5] = 0;
17622 device_param->kernel_params_mp_buf32[6] = 0;
17623 device_param->kernel_params_mp_buf32[7] = 0;
17624 }
17625
17626 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]);
17627 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]);
17628 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]);
17629
17630 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);
17631 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);
17632 }
17633 }
17634 else if (attack_mode == ATTACK_MODE_BF)
17635 {
17636 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
17637
17638 if (increment)
17639 {
17640 for (uint i = 0; i < dictcnt; i++)
17641 {
17642 local_free (dictfiles[i]);
17643 }
17644
17645 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17646 {
17647 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17648
17649 if (l1_filename == NULL) break;
17650
17651 dictcnt++;
17652
17653 dictfiles[dictcnt - 1] = l1_filename;
17654 }
17655 }
17656 else
17657 {
17658 dictcnt++;
17659
17660 dictfiles[dictcnt - 1] = mask;
17661 }
17662
17663 if (dictcnt == 0)
17664 {
17665 log_error ("ERROR: Mask is too small");
17666
17667 return (-1);
17668 }
17669 }
17670 }
17671
17672 free (induction_dictionaries);
17673
17674 // induction_dictionaries_cnt = 0; // implied
17675
17676 if (attack_mode != ATTACK_MODE_BF)
17677 {
17678 if (keyspace == 0)
17679 {
17680 induction_dictionaries = scan_directory (induction_directory);
17681
17682 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17683 }
17684 }
17685
17686 if (induction_dictionaries_cnt)
17687 {
17688 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17689 }
17690
17691 /**
17692 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17693 */
17694 if (keyspace == 1)
17695 {
17696 if ((maskcnt > 1) || (dictcnt > 1))
17697 {
17698 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17699
17700 return (-1);
17701 }
17702 }
17703
17704 for (uint dictpos = rd->dictpos; dictpos < dictcnt; dictpos++)
17705 {
17706 if (data.devices_status == STATUS_CRACKED) continue;
17707 if (data.devices_status == STATUS_ABORTED) continue;
17708 if (data.devices_status == STATUS_QUIT) continue;
17709
17710 rd->dictpos = dictpos;
17711
17712 char *subid = logfile_generate_subid ();
17713
17714 data.subid = subid;
17715
17716 logfile_sub_msg ("START");
17717
17718 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17719 {
17720 data.devices_status = STATUS_INIT;
17721 }
17722
17723 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17724 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17725 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17726
17727 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17728
17729 data.cpt_pos = 0;
17730
17731 data.cpt_start = time (NULL);
17732
17733 data.cpt_total = 0;
17734
17735 if (data.restore == 0)
17736 {
17737 rd->words_cur = skip;
17738
17739 skip = 0;
17740
17741 data.skip = 0;
17742 }
17743
17744 data.ms_paused = 0;
17745
17746 data.kernel_power_final = 0;
17747
17748 data.words_cur = rd->words_cur;
17749
17750 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17751 {
17752 hc_device_param_t *device_param = &data.devices_param[device_id];
17753
17754 if (device_param->skipped) continue;
17755
17756 device_param->speed_pos = 0;
17757
17758 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17759 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17760
17761 device_param->exec_pos = 0;
17762
17763 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17764
17765 device_param->outerloop_pos = 0;
17766 device_param->outerloop_left = 0;
17767 device_param->innerloop_pos = 0;
17768 device_param->innerloop_left = 0;
17769
17770 // some more resets:
17771
17772 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17773
17774 device_param->pws_cnt = 0;
17775
17776 device_param->words_off = 0;
17777 device_param->words_done = 0;
17778 }
17779
17780 // figure out some workload
17781
17782 if (attack_mode == ATTACK_MODE_STRAIGHT)
17783 {
17784 if (data.wordlist_mode == WL_MODE_FILE)
17785 {
17786 char *dictfile = NULL;
17787
17788 if (induction_dictionaries_cnt)
17789 {
17790 dictfile = induction_dictionaries[0];
17791 }
17792 else
17793 {
17794 dictfile = dictfiles[dictpos];
17795 }
17796
17797 data.dictfile = dictfile;
17798
17799 logfile_sub_string (dictfile);
17800
17801 for (uint i = 0; i < rp_files_cnt; i++)
17802 {
17803 logfile_sub_var_string ("rulefile", rp_files[i]);
17804 }
17805
17806 FILE *fd2 = fopen (dictfile, "rb");
17807
17808 if (fd2 == NULL)
17809 {
17810 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17811
17812 return (-1);
17813 }
17814
17815 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17816
17817 fclose (fd2);
17818
17819 if (data.words_cnt == 0)
17820 {
17821 logfile_sub_msg ("STOP");
17822
17823 continue;
17824 }
17825 }
17826 }
17827 else if (attack_mode == ATTACK_MODE_COMBI)
17828 {
17829 char *dictfile = data.dictfile;
17830 char *dictfile2 = data.dictfile2;
17831
17832 logfile_sub_string (dictfile);
17833 logfile_sub_string (dictfile2);
17834
17835 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17836 {
17837 FILE *fd2 = fopen (dictfile, "rb");
17838
17839 if (fd2 == NULL)
17840 {
17841 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17842
17843 return (-1);
17844 }
17845
17846 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17847
17848 fclose (fd2);
17849 }
17850 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17851 {
17852 FILE *fd2 = fopen (dictfile2, "rb");
17853
17854 if (fd2 == NULL)
17855 {
17856 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17857
17858 return (-1);
17859 }
17860
17861 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17862
17863 fclose (fd2);
17864 }
17865
17866 if (data.words_cnt == 0)
17867 {
17868 logfile_sub_msg ("STOP");
17869
17870 continue;
17871 }
17872 }
17873 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17874 {
17875 char *dictfile = NULL;
17876
17877 if (induction_dictionaries_cnt)
17878 {
17879 dictfile = induction_dictionaries[0];
17880 }
17881 else
17882 {
17883 dictfile = dictfiles[dictpos];
17884 }
17885
17886 data.dictfile = dictfile;
17887
17888 char *mask = data.mask;
17889
17890 logfile_sub_string (dictfile);
17891 logfile_sub_string (mask);
17892
17893 FILE *fd2 = fopen (dictfile, "rb");
17894
17895 if (fd2 == NULL)
17896 {
17897 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17898
17899 return (-1);
17900 }
17901
17902 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17903
17904 fclose (fd2);
17905
17906 if (data.words_cnt == 0)
17907 {
17908 logfile_sub_msg ("STOP");
17909
17910 continue;
17911 }
17912 }
17913 else if (attack_mode == ATTACK_MODE_BF)
17914 {
17915 local_free (css_buf);
17916 local_free (data.root_css_buf);
17917 local_free (data.markov_css_buf);
17918
17919 char *mask = dictfiles[dictpos];
17920
17921 logfile_sub_string (mask);
17922
17923 // base
17924
17925 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17926
17927 if (opts_type & OPTS_TYPE_PT_UNICODE)
17928 {
17929 uint css_cnt_unicode = css_cnt * 2;
17930
17931 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17932
17933 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17934 {
17935 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17936
17937 css_buf_unicode[j + 1].cs_buf[0] = 0;
17938 css_buf_unicode[j + 1].cs_len = 1;
17939 }
17940
17941 free (css_buf);
17942
17943 css_buf = css_buf_unicode;
17944 css_cnt = css_cnt_unicode;
17945 }
17946
17947 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17948
17949 uint mask_min = pw_min;
17950 uint mask_max = pw_max;
17951
17952 if (opts_type & OPTS_TYPE_PT_UNICODE)
17953 {
17954 mask_min *= 2;
17955 mask_max *= 2;
17956 }
17957
17958 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17959 {
17960 if (css_cnt < mask_min)
17961 {
17962 log_info ("WARNING: Skipping mask '%s' because it is smaller than the minimum password length", mask);
17963 }
17964
17965 if (css_cnt > mask_max)
17966 {
17967 log_info ("WARNING: Skipping mask '%s' because it is larger than the maximum password length", mask);
17968 }
17969
17970 // skip to next mask
17971
17972 logfile_sub_msg ("STOP");
17973
17974 continue;
17975 }
17976
17977 uint save_css_cnt = css_cnt;
17978
17979 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17980 {
17981 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17982 {
17983 uint salt_len = (uint) data.salts_buf[0].salt_len;
17984 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17985
17986 uint css_cnt_salt = css_cnt + salt_len;
17987
17988 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17989
17990 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17991
17992 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17993 {
17994 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17995 css_buf_salt[j].cs_len = 1;
17996 }
17997
17998 free (css_buf);
17999
18000 css_buf = css_buf_salt;
18001 css_cnt = css_cnt_salt;
18002 }
18003 }
18004
18005 data.mask = mask;
18006 data.css_cnt = css_cnt;
18007 data.css_buf = css_buf;
18008
18009 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
18010
18011 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
18012
18013 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
18014
18015 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
18016 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
18017
18018 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
18019
18020 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
18021
18022 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
18023 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
18024
18025 data.root_css_buf = root_css_buf;
18026 data.markov_css_buf = markov_css_buf;
18027
18028 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
18029
18030 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
18031
18032 local_free (root_table_buf);
18033 local_free (markov_table_buf);
18034
18035 // copy + args
18036
18037 uint css_cnt_l = css_cnt;
18038 uint css_cnt_r;
18039
18040 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
18041 {
18042 if (save_css_cnt < 6)
18043 {
18044 css_cnt_r = 1;
18045 }
18046 else if (save_css_cnt == 6)
18047 {
18048 css_cnt_r = 2;
18049 }
18050 else
18051 {
18052 if (opts_type & OPTS_TYPE_PT_UNICODE)
18053 {
18054 if (save_css_cnt == 8 || save_css_cnt == 10)
18055 {
18056 css_cnt_r = 2;
18057 }
18058 else
18059 {
18060 css_cnt_r = 4;
18061 }
18062 }
18063 else
18064 {
18065 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
18066 {
18067 css_cnt_r = 3;
18068 }
18069 else
18070 {
18071 css_cnt_r = 4;
18072 }
18073 }
18074 }
18075 }
18076 else
18077 {
18078 css_cnt_r = 1;
18079
18080 /* unfinished code?
18081 int sum = css_buf[css_cnt_r - 1].cs_len;
18082
18083 for (uint i = 1; i < 4 && i < css_cnt; i++)
18084 {
18085 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
18086
18087 css_cnt_r++;
18088
18089 sum *= css_buf[css_cnt_r - 1].cs_len;
18090 }
18091 */
18092 }
18093
18094 css_cnt_l -= css_cnt_r;
18095
18096 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
18097
18098 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18099 {
18100 hc_device_param_t *device_param = &data.devices_param[device_id];
18101
18102 if (device_param->skipped) continue;
18103
18104 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
18105 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
18106 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
18107
18108 device_param->kernel_params_mp_l_buf64[3] = 0;
18109 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
18110 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
18111 device_param->kernel_params_mp_l_buf32[6] = 0;
18112 device_param->kernel_params_mp_l_buf32[7] = 0;
18113 device_param->kernel_params_mp_l_buf32[8] = 0;
18114
18115 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
18116 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
18117 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
18118 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
18119
18120 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
18121 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
18122 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
18123
18124 device_param->kernel_params_mp_r_buf64[3] = 0;
18125 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
18126 device_param->kernel_params_mp_r_buf32[5] = 0;
18127 device_param->kernel_params_mp_r_buf32[6] = 0;
18128 device_param->kernel_params_mp_r_buf32[7] = 0;
18129
18130 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]);
18131 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]);
18132 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]);
18133
18134 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]);
18135 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]);
18136 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]);
18137
18138 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);
18139 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);
18140 }
18141 }
18142
18143 u64 words_base = data.words_cnt;
18144
18145 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18146 {
18147 if (data.kernel_rules_cnt)
18148 {
18149 words_base /= data.kernel_rules_cnt;
18150 }
18151 }
18152 else if (data.attack_kern == ATTACK_KERN_COMBI)
18153 {
18154 if (data.combs_cnt)
18155 {
18156 words_base /= data.combs_cnt;
18157 }
18158 }
18159 else if (data.attack_kern == ATTACK_KERN_BF)
18160 {
18161 if (data.bfs_cnt)
18162 {
18163 words_base /= data.bfs_cnt;
18164 }
18165 }
18166
18167 data.words_base = words_base;
18168
18169 if (keyspace == 1)
18170 {
18171 log_info ("%llu", (unsigned long long int) words_base);
18172
18173 return (0);
18174 }
18175
18176 if (data.words_cur > data.words_base)
18177 {
18178 log_error ("ERROR: Restore value greater keyspace");
18179
18180 return (-1);
18181 }
18182
18183 if (data.words_cur)
18184 {
18185 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18186 {
18187 for (uint i = 0; i < data.salts_cnt; i++)
18188 {
18189 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
18190 }
18191 }
18192 else if (data.attack_kern == ATTACK_KERN_COMBI)
18193 {
18194 for (uint i = 0; i < data.salts_cnt; i++)
18195 {
18196 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
18197 }
18198 }
18199 else if (data.attack_kern == ATTACK_KERN_BF)
18200 {
18201 for (uint i = 0; i < data.salts_cnt; i++)
18202 {
18203 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
18204 }
18205 }
18206 }
18207
18208 /*
18209 * Update loopback file
18210 */
18211
18212 if (loopback == 1)
18213 {
18214 time_t now;
18215
18216 time (&now);
18217
18218 uint random_num = get_random_num (0, 9999);
18219
18220 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
18221
18222 data.loopback_file = loopback_file;
18223 }
18224
18225 /*
18226 * Update dictionary statistic
18227 */
18228
18229 if (keyspace == 0)
18230 {
18231 dictstat_fp = fopen (dictstat, "wb");
18232
18233 if (dictstat_fp)
18234 {
18235 lock_file (dictstat_fp);
18236
18237 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
18238
18239 fclose (dictstat_fp);
18240 }
18241 }
18242
18243 /**
18244 * create autotune threads
18245 */
18246
18247 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
18248
18249 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18250 {
18251 data.devices_status = STATUS_AUTOTUNE;
18252 }
18253
18254 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18255 {
18256 hc_device_param_t *device_param = &devices_param[device_id];
18257
18258 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
18259 }
18260
18261 hc_thread_wait (data.devices_cnt, c_threads);
18262
18263 /*
18264 * Inform user about possible slow speeds
18265 */
18266
18267 uint hardware_power_all = 0;
18268
18269 uint kernel_power_all = 0;
18270
18271 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18272 {
18273 hc_device_param_t *device_param = &devices_param[device_id];
18274
18275 hardware_power_all += device_param->hardware_power;
18276
18277 kernel_power_all += device_param->kernel_power;
18278 }
18279
18280 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
18281
18282 data.kernel_power_all = kernel_power_all;
18283
18284 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18285 {
18286 if (data.words_base < kernel_power_all)
18287 {
18288 if (quiet == 0)
18289 {
18290 clear_prompt ();
18291
18292 log_info ("ATTENTION!");
18293 log_info (" The wordlist or mask you are using is too small.");
18294 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
18295 log_info (" The cracking speed will drop.");
18296 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
18297 log_info ("");
18298 }
18299 }
18300 }
18301
18302 /**
18303 * create cracker threads
18304 */
18305
18306 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18307 {
18308 data.devices_status = STATUS_RUNNING;
18309 }
18310
18311 if (initial_restore_done == 0)
18312 {
18313 if (data.restore_disable == 0) cycle_restore ();
18314
18315 initial_restore_done = 1;
18316 }
18317
18318 hc_timer_set (&data.timer_running);
18319
18320 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18321 {
18322 if ((quiet == 0) && (status == 0) && (benchmark == 0))
18323 {
18324 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
18325 if (quiet == 0) fflush (stdout);
18326 }
18327 }
18328 else if (wordlist_mode == WL_MODE_STDIN)
18329 {
18330 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
18331 if (data.quiet == 0) log_info ("");
18332 }
18333
18334 time_t runtime_start;
18335
18336 time (&runtime_start);
18337
18338 data.runtime_start = runtime_start;
18339
18340 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18341 {
18342 hc_device_param_t *device_param = &devices_param[device_id];
18343
18344 if (wordlist_mode == WL_MODE_STDIN)
18345 {
18346 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
18347 }
18348 else
18349 {
18350 hc_thread_create (c_threads[device_id], thread_calc, device_param);
18351 }
18352 }
18353
18354 hc_thread_wait (data.devices_cnt, c_threads);
18355
18356 local_free (c_threads);
18357
18358 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18359 {
18360 data.devices_status = STATUS_EXHAUSTED;
18361 }
18362
18363 logfile_sub_var_uint ("status-after-work", data.devices_status);
18364
18365 data.restore = 0;
18366
18367 if (induction_dictionaries_cnt)
18368 {
18369 unlink (induction_dictionaries[0]);
18370 }
18371
18372 free (induction_dictionaries);
18373
18374 if (attack_mode != ATTACK_MODE_BF)
18375 {
18376 induction_dictionaries = scan_directory (induction_directory);
18377
18378 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18379 }
18380
18381 if (benchmark == 1)
18382 {
18383 status_benchmark ();
18384
18385 if (machine_readable == 0)
18386 {
18387 log_info ("");
18388 }
18389 }
18390 else
18391 {
18392 if (quiet == 0)
18393 {
18394 clear_prompt ();
18395
18396 log_info ("");
18397
18398 status_display ();
18399
18400 log_info ("");
18401 }
18402 else
18403 {
18404 if (status == 1)
18405 {
18406 status_display ();
18407 }
18408 }
18409 }
18410
18411 if (induction_dictionaries_cnt)
18412 {
18413 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18414
18415 // yeah, this next statement is a little hack to make sure that --loopback runs correctly (because with it we guarantee that the loop iterates one more time)
18416
18417 dictpos--;
18418 }
18419
18420 time_t runtime_stop;
18421
18422 time (&runtime_stop);
18423
18424 data.runtime_stop = runtime_stop;
18425
18426 logfile_sub_uint (runtime_start);
18427 logfile_sub_uint (runtime_stop);
18428
18429 logfile_sub_msg ("STOP");
18430
18431 global_free (subid);
18432
18433 // from this point we handle bypass as running
18434
18435 if (data.devices_status == STATUS_BYPASS)
18436 {
18437 data.devices_status = STATUS_RUNNING;
18438 }
18439
18440 // and overwrite benchmark aborts as well
18441
18442 if (data.benchmark == 1)
18443 {
18444 if (data.devices_status == STATUS_ABORTED)
18445 {
18446 data.devices_status = STATUS_RUNNING;
18447 }
18448 }
18449
18450 // finalize task
18451
18452 if (data.devices_status == STATUS_CRACKED) break;
18453 if (data.devices_status == STATUS_ABORTED) break;
18454 if (data.devices_status == STATUS_QUIT) break;
18455 }
18456
18457 if (data.devices_status == STATUS_CRACKED) break;
18458 if (data.devices_status == STATUS_ABORTED) break;
18459 if (data.devices_status == STATUS_QUIT) break;
18460 }
18461
18462 // 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
18463 if (attack_mode == ATTACK_MODE_STRAIGHT)
18464 {
18465 if (data.wordlist_mode == WL_MODE_FILE)
18466 {
18467 if (data.dictfile == NULL)
18468 {
18469 if (dictfiles != NULL)
18470 {
18471 data.dictfile = dictfiles[0];
18472
18473 hc_timer_set (&data.timer_running);
18474 }
18475 }
18476 }
18477 }
18478 // NOTE: combi is okay because it is already set beforehand
18479 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
18480 {
18481 if (data.dictfile == NULL)
18482 {
18483 if (dictfiles != NULL)
18484 {
18485 hc_timer_set (&data.timer_running);
18486
18487 data.dictfile = dictfiles[0];
18488 }
18489 }
18490 }
18491 else if (attack_mode == ATTACK_MODE_BF)
18492 {
18493 if (data.mask == NULL)
18494 {
18495 hc_timer_set (&data.timer_running);
18496
18497 data.mask = masks[0];
18498 }
18499 }
18500
18501 // if cracked / aborted remove last induction dictionary
18502
18503 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
18504 {
18505 struct stat induct_stat;
18506
18507 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
18508 {
18509 unlink (induction_dictionaries[file_pos]);
18510 }
18511 }
18512
18513 // wait for inner threads
18514
18515 data.shutdown_inner = 1;
18516
18517 for (uint thread_idx = 0; thread_idx < inner_threads_cnt; thread_idx++)
18518 {
18519 hc_thread_wait (1, &inner_threads[thread_idx]);
18520 }
18521
18522 local_free (inner_threads);
18523
18524 // we dont need restore file anymore
18525 if (data.restore_disable == 0)
18526 {
18527 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
18528 {
18529 unlink (eff_restore_file);
18530 unlink (new_restore_file);
18531 }
18532 else
18533 {
18534 cycle_restore ();
18535 }
18536 }
18537
18538 // finally save left hashes
18539
18540 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
18541 {
18542 save_hash ();
18543 }
18544
18545 /**
18546 * Clean up
18547 */
18548
18549 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18550 {
18551 hc_device_param_t *device_param = &data.devices_param[device_id];
18552
18553 if (device_param->skipped) continue;
18554
18555 local_free (device_param->combs_buf);
18556 local_free (device_param->hooks_buf);
18557 local_free (device_param->device_name);
18558 local_free (device_param->device_name_chksum);
18559 local_free (device_param->device_version);
18560 local_free (device_param->driver_version);
18561
18562 if (device_param->pws_buf) myfree (device_param->pws_buf);
18563 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
18564 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
18565 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
18566 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
18567 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
18568 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
18569 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
18570 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
18571 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
18572 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
18573 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
18574 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
18575 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
18576 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
18577 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
18578 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
18579 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
18580 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
18581 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
18582 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
18583 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
18584 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
18585 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
18586 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
18587 if (device_param->d_scryptV0_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV0_buf);
18588 if (device_param->d_scryptV1_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV1_buf);
18589 if (device_param->d_scryptV2_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV2_buf);
18590 if (device_param->d_scryptV3_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV3_buf);
18591 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
18592 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
18593 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
18594
18595 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
18596 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
18597 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
18598 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
18599 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
18600 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
18601 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
18602 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
18603 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
18604 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
18605 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
18606
18607 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
18608 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
18609 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
18610
18611 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
18612 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
18613 }
18614
18615 // reset default fan speed
18616
18617 #ifdef HAVE_HWMON
18618 if (gpu_temp_disable == 0)
18619 {
18620 if (gpu_temp_retain != 0)
18621 {
18622 hc_thread_mutex_lock (mux_adl);
18623
18624 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18625 {
18626 hc_device_param_t *device_param = &data.devices_param[device_id];
18627
18628 if (device_param->skipped) continue;
18629
18630 if (data.hm_device[device_id].fan_set_supported == 1)
18631 {
18632 int rc = -1;
18633
18634 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18635 {
18636 rc = hm_set_fanspeed_with_device_id_adl (device_id, 100, 0);
18637 }
18638 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18639 {
18640 #ifdef LINUX
18641 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE);
18642 #endif
18643
18644 #ifdef WIN
18645 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, 100, 0);
18646 #endif
18647 }
18648
18649 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18650 }
18651 }
18652
18653 hc_thread_mutex_unlock (mux_adl);
18654 }
18655 }
18656
18657 // reset power tuning
18658
18659 if (powertune_enable == 1)
18660 {
18661 hc_thread_mutex_lock (mux_adl);
18662
18663 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18664 {
18665 hc_device_param_t *device_param = &data.devices_param[device_id];
18666
18667 if (device_param->skipped) continue;
18668
18669 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18670 {
18671 if (data.hm_device[device_id].od_version == 6)
18672 {
18673 // check powertune capabilities first, if not available then skip device
18674
18675 int powertune_supported = 0;
18676
18677 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18678 {
18679 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18680
18681 return (-1);
18682 }
18683
18684 if (powertune_supported != 0)
18685 {
18686 // powercontrol settings
18687
18688 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18689 {
18690 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18691
18692 return (-1);
18693 }
18694
18695 // clocks
18696
18697 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18698
18699 performance_state->iNumberOfPerformanceLevels = 2;
18700
18701 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18702 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18703 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18704 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18705
18706 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18707 {
18708 log_info ("ERROR: Failed to restore ADL performance state");
18709
18710 return (-1);
18711 }
18712
18713 local_free (performance_state);
18714 }
18715 }
18716 }
18717
18718 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18719 {
18720 unsigned int limit = nvml_power_limit[device_id];
18721
18722 if (limit > 0)
18723 {
18724 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18725 }
18726 }
18727 }
18728
18729 hc_thread_mutex_unlock (mux_adl);
18730 }
18731
18732 if (gpu_temp_disable == 0)
18733 {
18734 if (data.hm_nvml)
18735 {
18736 hm_NVML_nvmlShutdown (data.hm_nvml);
18737
18738 nvml_close (data.hm_nvml);
18739
18740 data.hm_nvml = NULL;
18741 }
18742
18743 if (data.hm_nvapi)
18744 {
18745 hm_NvAPI_Unload (data.hm_nvapi);
18746
18747 nvapi_close (data.hm_nvapi);
18748
18749 data.hm_nvapi = NULL;
18750 }
18751
18752 if (data.hm_xnvctrl)
18753 {
18754 hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);
18755
18756 xnvctrl_close (data.hm_xnvctrl);
18757
18758 data.hm_xnvctrl = NULL;
18759 }
18760
18761 if (data.hm_adl)
18762 {
18763 hm_ADL_Main_Control_Destroy (data.hm_adl);
18764
18765 adl_close (data.hm_adl);
18766
18767 data.hm_adl = NULL;
18768 }
18769 }
18770 #endif // HAVE_HWMON
18771
18772 // free memory
18773
18774 local_free (masks);
18775
18776 local_free (dictstat_base);
18777
18778 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18779 {
18780 pot_t *pot_ptr = &pot[pot_pos];
18781
18782 hash_t *hash = &pot_ptr->hash;
18783
18784 local_free (hash->digest);
18785
18786 if (isSalted)
18787 {
18788 local_free (hash->salt);
18789 }
18790 }
18791
18792 local_free (pot);
18793
18794 local_free (all_kernel_rules_cnt);
18795 local_free (all_kernel_rules_buf);
18796
18797 local_free (wl_data->buf);
18798 local_free (wl_data);
18799
18800 local_free (bitmap_s1_a);
18801 local_free (bitmap_s1_b);
18802 local_free (bitmap_s1_c);
18803 local_free (bitmap_s1_d);
18804 local_free (bitmap_s2_a);
18805 local_free (bitmap_s2_b);
18806 local_free (bitmap_s2_c);
18807 local_free (bitmap_s2_d);
18808
18809 #ifdef HAVE_HWMON
18810 local_free (od_clock_mem_status);
18811 local_free (od_power_control_status);
18812 local_free (nvml_power_limit);
18813 #endif
18814
18815 global_free (devices_param);
18816
18817 global_free (kernel_rules_buf);
18818
18819 global_free (root_css_buf);
18820 global_free (markov_css_buf);
18821
18822 global_free (digests_buf);
18823 global_free (digests_shown);
18824 global_free (digests_shown_tmp);
18825
18826 global_free (salts_buf);
18827 global_free (salts_shown);
18828
18829 global_free (esalts_buf);
18830
18831 global_free (words_progress_done);
18832 global_free (words_progress_rejected);
18833 global_free (words_progress_restored);
18834
18835 if (pot_fp) fclose (pot_fp);
18836
18837 if (data.devices_status == STATUS_QUIT) break;
18838 }
18839
18840 // wait for outer threads
18841
18842 data.shutdown_outer = 1;
18843
18844 for (uint thread_idx = 0; thread_idx < outer_threads_cnt; thread_idx++)
18845 {
18846 hc_thread_wait (1, &outer_threads[thread_idx]);
18847 }
18848
18849 local_free (outer_threads);
18850
18851 // destroy others mutex
18852
18853 hc_thread_mutex_delete (mux_dispatcher);
18854 hc_thread_mutex_delete (mux_counter);
18855 hc_thread_mutex_delete (mux_display);
18856 hc_thread_mutex_delete (mux_adl);
18857
18858 // free memory
18859
18860 local_free (eff_restore_file);
18861 local_free (new_restore_file);
18862
18863 local_free (rd);
18864
18865 // tuning db
18866
18867 tuning_db_destroy (tuning_db);
18868
18869 // loopback
18870
18871 local_free (loopback_file);
18872
18873 if (loopback == 1) unlink (loopback_file);
18874
18875 // induction directory
18876
18877 if (induction_dir == NULL)
18878 {
18879 if (attack_mode != ATTACK_MODE_BF)
18880 {
18881 if (rmdir (induction_directory) == -1)
18882 {
18883 if (errno == ENOENT)
18884 {
18885 // good, we can ignore
18886 }
18887 else if (errno == ENOTEMPTY)
18888 {
18889 // good, we can ignore
18890 }
18891 else
18892 {
18893 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18894
18895 return (-1);
18896 }
18897 }
18898
18899 local_free (induction_directory);
18900 }
18901 }
18902
18903 // outfile-check directory
18904
18905 if (outfile_check_dir == NULL)
18906 {
18907 if (rmdir (outfile_check_directory) == -1)
18908 {
18909 if (errno == ENOENT)
18910 {
18911 // good, we can ignore
18912 }
18913 else if (errno == ENOTEMPTY)
18914 {
18915 // good, we can ignore
18916 }
18917 else
18918 {
18919 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18920
18921 return (-1);
18922 }
18923 }
18924
18925 local_free (outfile_check_directory);
18926 }
18927
18928 time_t proc_stop;
18929
18930 time (&proc_stop);
18931
18932 logfile_top_uint (proc_start);
18933 logfile_top_uint (proc_stop);
18934
18935 logfile_top_msg ("STOP");
18936
18937 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18938 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18939
18940 if (data.ocl) ocl_close (data.ocl);
18941
18942 if (data.devices_status == STATUS_ABORTED) return 2;
18943 if (data.devices_status == STATUS_QUIT) return 2;
18944 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18945 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18946 if (data.devices_status == STATUS_CRACKED) return 0;
18947
18948 return -1;
18949 }
Hashcat additions to support pwdhash