projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Move keyspress detecting thread to outer loop
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define STDOUT_FLAG 0
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define MACHINE_READABLE 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define NVIDIA_SPIN_DAMP 100
79 #define GPU_TEMP_DISABLE 0
80 #define GPU_TEMP_ABORT 90
81 #define GPU_TEMP_RETAIN 65
82 #define WORKLOAD_PROFILE 2
83 #define KERNEL_ACCEL 0
84 #define KERNEL_LOOPS 0
85 #define KERNEL_RULES 1024
86 #define KERNEL_COMBS 1024
87 #define KERNEL_BFS 1024
88 #define KERNEL_THREADS_MAX 256
89 #define KERNEL_THREADS_MAX_CPU 16
90 #define POWERTUNE_ENABLE 0
91 #define LOGFILE_DISABLE 0
92 #define SCRYPT_TMTO 0
93 #define OPENCL_VECTOR_WIDTH 0
94
95 #define WL_MODE_STDIN 1
96 #define WL_MODE_FILE 2
97 #define WL_MODE_MASK 3
98
99 #define HL_MODE_FILE 4
100 #define HL_MODE_ARG 5
101
102 #define HLFMTS_CNT 11
103 #define HLFMT_HASHCAT 0
104 #define HLFMT_PWDUMP 1
105 #define HLFMT_PASSWD 2
106 #define HLFMT_SHADOW 3
107 #define HLFMT_DCC 4
108 #define HLFMT_DCC2 5
109 #define HLFMT_NETNTLM1 7
110 #define HLFMT_NETNTLM2 8
111 #define HLFMT_NSLDAP 9
112 #define HLFMT_NSLDAPS 10
113
114 #define HLFMT_TEXT_HASHCAT "native hashcat"
115 #define HLFMT_TEXT_PWDUMP "pwdump"
116 #define HLFMT_TEXT_PASSWD "passwd"
117 #define HLFMT_TEXT_SHADOW "shadow"
118 #define HLFMT_TEXT_DCC "DCC"
119 #define HLFMT_TEXT_DCC2 "DCC 2"
120 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
121 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
122 #define HLFMT_TEXT_NSLDAP "nsldap"
123 #define HLFMT_TEXT_NSLDAPS "nsldaps"
124
125 #define ATTACK_MODE_STRAIGHT 0
126 #define ATTACK_MODE_COMBI 1
127 #define ATTACK_MODE_TOGGLE 2
128 #define ATTACK_MODE_BF 3
129 #define ATTACK_MODE_PERM 4
130 #define ATTACK_MODE_TABLE 5
131 #define ATTACK_MODE_HYBRID1 6
132 #define ATTACK_MODE_HYBRID2 7
133 #define ATTACK_MODE_NONE 100
134
135 #define ATTACK_KERN_STRAIGHT 0
136 #define ATTACK_KERN_COMBI 1
137 #define ATTACK_KERN_BF 3
138 #define ATTACK_KERN_NONE 100
139
140 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
141 #define ATTACK_EXEC_INSIDE_KERNEL 11
142
143 #define COMBINATOR_MODE_BASE_LEFT 10001
144 #define COMBINATOR_MODE_BASE_RIGHT 10002
145
146 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
147 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
148
149 #define MAX_CUT_TRIES 4
150
151 #define MAX_DICTSTAT 10000
152
153 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
154
155 #define NVIDIA_100PERCENTCPU_WORKAROUND 100
156
157 #define global_free(attr) \
158 { \
159 myfree ((void *) data.attr); \
160 \
161 data.attr = NULL; \
162 }
163
164 #define local_free(attr) \
165 { \
166 myfree ((void *) attr); \
167 \
168 attr = NULL; \
169 }
170
171 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
172 #define HC_API_CALL __stdcall
173 #else
174 #define HC_API_CALL
175 #endif
176
177 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
178 {
179 900,
180 0,
181 5100,
182 100,
183 1400,
184 10800,
185 1700,
186 5000,
187 10100,
188 6000,
189 6100,
190 6900,
191 11700,
192 11800,
193 400,
194 8900,
195 11900,
196 12000,
197 10900,
198 12100,
199 23,
200 2500,
201 5300,
202 5400,
203 5500,
204 5600,
205 7300,
206 7500,
207 13100,
208 8300,
209 11100,
210 11200,
211 11400,
212 121,
213 2611,
214 2711,
215 2811,
216 8400,
217 11,
218 2612,
219 7900,
220 21,
221 11000,
222 124,
223 10000,
224 3711,
225 7600,
226 12,
227 131,
228 132,
229 1731,
230 200,
231 300,
232 3100,
233 112,
234 12300,
235 8000,
236 141,
237 1441,
238 1600,
239 12600,
240 1421,
241 101,
242 111,
243 1711,
244 3000,
245 1000,
246 1100,
247 2100,
248 12800,
249 1500,
250 12400,
251 500,
252 3200,
253 7400,
254 1800,
255 122,
256 1722,
257 7100,
258 6300,
259 6700,
260 6400,
261 6500,
262 2400,
263 2410,
264 5700,
265 9200,
266 9300,
267 22,
268 501,
269 5800,
270 8100,
271 8500,
272 7200,
273 9900,
274 7700,
275 7800,
276 10300,
277 8600,
278 8700,
279 9100,
280 133,
281 13500,
282 11600,
283 13600,
284 12500,
285 13000,
286 13200,
287 13300,
288 6211,
289 6221,
290 6231,
291 6241,
292 13711,
293 13721,
294 13731,
295 13741,
296 13751,
297 13761,
298 8800,
299 12900,
300 12200,
301 9700,
302 9710,
303 9800,
304 9810,
305 9400,
306 9500,
307 9600,
308 10400,
309 10410,
310 10500,
311 10600,
312 10700,
313 9000,
314 5200,
315 6800,
316 6600,
317 8200,
318 11300,
319 12700,
320 13400,
321 125
322 };
323
324 /**
325 * types
326 */
327
328 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
329
330 /**
331 * globals
332 */
333
334 static unsigned int full01 = 0x01010101;
335 static unsigned int full80 = 0x80808080;
336
337 int SUPPRESS_OUTPUT = 0;
338
339 hc_thread_mutex_t mux_adl;
340 hc_thread_mutex_t mux_counter;
341 hc_thread_mutex_t mux_dispatcher;
342 hc_thread_mutex_t mux_display;
343
344 hc_global_data_t data;
345
346 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
347
348 const char *USAGE_MINI[] =
349 {
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "Try --help for more help.",
353 NULL
354 };
355
356 const char *USAGE_BIG[] =
357 {
358 "%s, advanced password recovery",
359 "",
360 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
361 "",
362 "- [ Options ] -",
363 "",
364 " Options Short / Long | Type | Description | Example",
365 "===============================|======|======================================================|=======================",
366 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
367 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
368 " -V, --version | | Print version |",
369 " -h, --help | | Print help |",
370 " --quiet | | Suppress output |",
371 " --hex-charset | | Assume charset is given in hex |",
372 " --hex-salt | | Assume salt is given in hex |",
373 " --hex-wordlist | | Assume words in wordlist is given in hex |",
374 " --force | | Ignore warnings |",
375 " --status | | Enable automatic update of the status-screen |",
376 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
377 " --machine-readable | | Display the status view in a machine readable format |",
378 " --loopback | | Add new plains to induct directory |",
379 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
380 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
381 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
382 " --markov-classic | | Enables classic markov-chains, no per-position |",
383 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
384 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
385 " --session | Str | Define specific session name | --session=mysession",
386 " --restore | | Restore session from --session |",
387 " --restore-disable | | Do not write restore file |",
388 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
389 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
390 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
391 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
392 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
393 " --stdout | | Do not crack a hash, instead print candidates only |",
394 " --show | | Show cracked passwords only |",
395 " --left | | Show un-cracked passwords only |",
396 " --username | | Enable ignoring of usernames in hashfile |",
397 " --remove | | Enable remove of hash once it is cracked |",
398 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
399 " --potfile-disable | | Do not write potfile |",
400 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
401 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
402 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
403 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
404 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
405 " --logfile-disable | | Disable the logfile |",
406 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
407 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
408 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
409 " -b, --benchmark | | Run benchmark |",
410 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
411 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
412 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
413 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
414 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
415 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
416 " -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 "If you have no idea what just happened then visit the following pages:",
732 "",
733 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
734 "* https://hashcat.net/wiki/#frequently_asked_questions",
735 "",
736 NULL
737 };
738
739 /**
740 * hashcat specific functions
741 */
742
743 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
744 {
745 int exec_pos = (int) device_param->exec_pos - last_num_entries;
746
747 if (exec_pos < 0) exec_pos += EXEC_CACHE;
748
749 double exec_ms_sum = 0;
750
751 int exec_ms_cnt = 0;
752
753 for (int i = 0; i < last_num_entries; i++)
754 {
755 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
756
757 if (exec_ms)
758 {
759 exec_ms_sum += exec_ms;
760
761 exec_ms_cnt++;
762 }
763 }
764
765 if (exec_ms_cnt == 0) return 0;
766
767 return exec_ms_sum / exec_ms_cnt;
768 }
769
770 void status_display_machine_readable ()
771 {
772 FILE *out = stdout;
773
774 fprintf (out, "STATUS\t%u\t", data.devices_status);
775
776 /**
777 * speed new
778 */
779
780 fprintf (out, "SPEED\t");
781
782 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
783 {
784 hc_device_param_t *device_param = &data.devices_param[device_id];
785
786 if (device_param->skipped) continue;
787
788 u64 speed_cnt = 0;
789 double speed_ms = 0;
790
791 for (int i = 0; i < SPEED_CACHE; i++)
792 {
793 speed_cnt += device_param->speed_cnt[i];
794 speed_ms += device_param->speed_ms[i];
795 }
796
797 speed_cnt /= SPEED_CACHE;
798 speed_ms /= SPEED_CACHE;
799
800 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
801 }
802
803 /**
804 * exec time
805 */
806
807 fprintf (out, "EXEC_RUNTIME\t");
808
809 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
810 {
811 hc_device_param_t *device_param = &data.devices_param[device_id];
812
813 if (device_param->skipped) continue;
814
815 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
816
817 fprintf (out, "%f\t", exec_ms_avg);
818 }
819
820 /**
821 * words_cur
822 */
823
824 u64 words_cur = get_lowest_words_done ();
825
826 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
827
828 /**
829 * counter
830 */
831
832 u64 progress_total = data.words_cnt * data.salts_cnt;
833
834 u64 all_done = 0;
835 u64 all_rejected = 0;
836 u64 all_restored = 0;
837
838 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
839 {
840 all_done += data.words_progress_done[salt_pos];
841 all_rejected += data.words_progress_rejected[salt_pos];
842 all_restored += data.words_progress_restored[salt_pos];
843 }
844
845 u64 progress_cur = all_restored + all_done + all_rejected;
846 u64 progress_end = progress_total;
847
848 u64 progress_skip = 0;
849
850 if (data.skip)
851 {
852 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
853
854 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
855 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
856 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
857 }
858
859 if (data.limit)
860 {
861 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
862
863 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
864 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
865 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
866 }
867
868 u64 progress_cur_relative_skip = progress_cur - progress_skip;
869 u64 progress_end_relative_skip = progress_end - progress_skip;
870
871 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
872
873 /**
874 * cracks
875 */
876
877 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
878 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
879
880 /**
881 * temperature
882 */
883
884 #ifdef HAVE_HWMON
885 if (data.gpu_temp_disable == 0)
886 {
887 fprintf (out, "TEMP\t");
888
889 hc_thread_mutex_lock (mux_adl);
890
891 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
892 {
893 hc_device_param_t *device_param = &data.devices_param[device_id];
894
895 if (device_param->skipped) continue;
896
897 int temp = hm_get_temperature_with_device_id (device_id);
898
899 fprintf (out, "%d\t", temp);
900 }
901
902 hc_thread_mutex_unlock (mux_adl);
903 }
904 #endif // HAVE_HWMON
905
906 /**
907 * flush
908 */
909
910 #ifdef _WIN
911 fputc ('\r', out);
912 fputc ('\n', out);
913 #endif
914
915 #ifdef _POSIX
916 fputc ('\n', out);
917 #endif
918
919 fflush (out);
920 }
921
922 void status_display ()
923 {
924 if (data.devices_status == STATUS_INIT) return;
925 if (data.devices_status == STATUS_STARTING) return;
926 if (data.devices_status == STATUS_BYPASS) return;
927
928 if (data.machine_readable == 1)
929 {
930 status_display_machine_readable ();
931
932 return;
933 }
934
935 char tmp_buf[1000] = { 0 };
936
937 uint tmp_len = 0;
938
939 log_info ("Session.Name...: %s", data.session);
940
941 char *status_type = strstatus (data.devices_status);
942
943 uint hash_mode = data.hash_mode;
944
945 char *hash_type = strhashtype (hash_mode); // not a bug
946
947 log_info ("Status.........: %s", status_type);
948
949 /**
950 * show rules
951 */
952
953 if (data.rp_files_cnt)
954 {
955 uint i;
956
957 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
958 {
959 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
960 }
961
962 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
963
964 log_info ("Rules.Type.....: %s", tmp_buf);
965
966 tmp_len = 0;
967 }
968
969 if (data.rp_gen)
970 {
971 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
972
973 if (data.rp_gen_seed)
974 {
975 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
976 }
977 }
978
979 /**
980 * show input
981 */
982
983 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
984 {
985 if (data.wordlist_mode == WL_MODE_FILE)
986 {
987 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
988 }
989 else if (data.wordlist_mode == WL_MODE_STDIN)
990 {
991 log_info ("Input.Mode.....: Pipe");
992 }
993 }
994 else if (data.attack_mode == ATTACK_MODE_COMBI)
995 {
996 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
997 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
998 }
999 else if (data.attack_mode == ATTACK_MODE_BF)
1000 {
1001 char *mask = data.mask;
1002
1003 if (mask != NULL)
1004 {
1005 uint mask_len = data.css_cnt;
1006
1007 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1008
1009 if (mask_len > 0)
1010 {
1011 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1012 {
1013 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1014 {
1015 mask_len -= data.salts_buf[0].salt_len;
1016 }
1017 }
1018
1019 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1020
1021 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1022 }
1023
1024 if (data.maskcnt > 1)
1025 {
1026 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1027
1028 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1029 }
1030
1031 log_info ("Input.Mode.....: %s", tmp_buf);
1032 }
1033
1034 tmp_len = 0;
1035 }
1036 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1037 {
1038 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1039 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1040 }
1041 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1042 {
1043 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1044 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1045 }
1046
1047 if (data.digests_cnt == 1)
1048 {
1049 if (data.hash_mode == 2500)
1050 {
1051 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1052
1053 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1054 (char *) data.salts_buf[0].salt_buf,
1055 wpa->orig_mac1[0],
1056 wpa->orig_mac1[1],
1057 wpa->orig_mac1[2],
1058 wpa->orig_mac1[3],
1059 wpa->orig_mac1[4],
1060 wpa->orig_mac1[5],
1061 wpa->orig_mac2[0],
1062 wpa->orig_mac2[1],
1063 wpa->orig_mac2[2],
1064 wpa->orig_mac2[3],
1065 wpa->orig_mac2[4],
1066 wpa->orig_mac2[5]);
1067 }
1068 else if (data.hash_mode == 5200)
1069 {
1070 log_info ("Hash.Target....: File (%s)", data.hashfile);
1071 }
1072 else if (data.hash_mode == 9000)
1073 {
1074 log_info ("Hash.Target....: File (%s)", data.hashfile);
1075 }
1076 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1077 {
1078 log_info ("Hash.Target....: File (%s)", data.hashfile);
1079 }
1080 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1081 {
1082 log_info ("Hash.Target....: File (%s)", data.hashfile);
1083 }
1084 else
1085 {
1086 char out_buf[HCBUFSIZ] = { 0 };
1087
1088 ascii_digest (out_buf, 0, 0);
1089
1090 // limit length
1091 if (strlen (out_buf) > 40)
1092 {
1093 out_buf[41] = '.';
1094 out_buf[42] = '.';
1095 out_buf[43] = '.';
1096 out_buf[44] = 0;
1097 }
1098
1099 log_info ("Hash.Target....: %s", out_buf);
1100 }
1101 }
1102 else
1103 {
1104 if (data.hash_mode == 3000)
1105 {
1106 char out_buf1[32] = { 0 };
1107 char out_buf2[32] = { 0 };
1108
1109 ascii_digest (out_buf1, 0, 0);
1110 ascii_digest (out_buf2, 0, 1);
1111
1112 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1113 }
1114 else
1115 {
1116 log_info ("Hash.Target....: File (%s)", data.hashfile);
1117 }
1118 }
1119
1120 log_info ("Hash.Type......: %s", hash_type);
1121
1122 /**
1123 * speed new
1124 */
1125
1126 u64 speed_cnt[DEVICES_MAX] = { 0 };
1127 double speed_ms[DEVICES_MAX] = { 0 };
1128
1129 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1130 {
1131 hc_device_param_t *device_param = &data.devices_param[device_id];
1132
1133 if (device_param->skipped) continue;
1134
1135 speed_cnt[device_id] = 0;
1136 speed_ms[device_id] = 0;
1137
1138 for (int i = 0; i < SPEED_CACHE; i++)
1139 {
1140 speed_cnt[device_id] += device_param->speed_cnt[i];
1141 speed_ms[device_id] += device_param->speed_ms[i];
1142 }
1143
1144 speed_cnt[device_id] /= SPEED_CACHE;
1145 speed_ms[device_id] /= SPEED_CACHE;
1146 }
1147
1148 double hashes_all_ms = 0;
1149
1150 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1151
1152 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1153 {
1154 hc_device_param_t *device_param = &data.devices_param[device_id];
1155
1156 if (device_param->skipped) continue;
1157
1158 hashes_dev_ms[device_id] = 0;
1159
1160 if (speed_ms[device_id])
1161 {
1162 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1163
1164 hashes_all_ms += hashes_dev_ms[device_id];
1165 }
1166 }
1167
1168 /**
1169 * exec time
1170 */
1171
1172 double exec_all_ms[DEVICES_MAX] = { 0 };
1173
1174 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1175 {
1176 hc_device_param_t *device_param = &data.devices_param[device_id];
1177
1178 if (device_param->skipped) continue;
1179
1180 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1181
1182 exec_all_ms[device_id] = exec_ms_avg;
1183 }
1184
1185 /**
1186 * timers
1187 */
1188
1189 double ms_running = 0;
1190
1191 hc_timer_get (data.timer_running, ms_running);
1192
1193 double ms_paused = data.ms_paused;
1194
1195 if (data.devices_status == STATUS_PAUSED)
1196 {
1197 double ms_paused_tmp = 0;
1198
1199 hc_timer_get (data.timer_paused, ms_paused_tmp);
1200
1201 ms_paused += ms_paused_tmp;
1202 }
1203
1204 #ifdef WIN
1205
1206 __time64_t sec_run = ms_running / 1000;
1207
1208 #else
1209
1210 time_t sec_run = ms_running / 1000;
1211
1212 #endif
1213
1214 if (sec_run)
1215 {
1216 char display_run[32] = { 0 };
1217
1218 struct tm tm_run;
1219
1220 struct tm *tmp = NULL;
1221
1222 #ifdef WIN
1223
1224 tmp = _gmtime64 (&sec_run);
1225
1226 #else
1227
1228 tmp = gmtime (&sec_run);
1229
1230 #endif
1231
1232 if (tmp != NULL)
1233 {
1234 memset (&tm_run, 0, sizeof (tm_run));
1235
1236 memcpy (&tm_run, tmp, sizeof (tm_run));
1237
1238 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1239
1240 char *start = ctime (&data.proc_start);
1241
1242 size_t start_len = strlen (start);
1243
1244 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1245 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1246
1247 log_info ("Time.Started...: %s (%s)", start, display_run);
1248 }
1249 }
1250 else
1251 {
1252 log_info ("Time.Started...: 0 secs");
1253 }
1254
1255 /**
1256 * counters
1257 */
1258
1259 u64 progress_total = data.words_cnt * data.salts_cnt;
1260
1261 u64 all_done = 0;
1262 u64 all_rejected = 0;
1263 u64 all_restored = 0;
1264
1265 u64 progress_noneed = 0;
1266
1267 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1268 {
1269 all_done += data.words_progress_done[salt_pos];
1270 all_rejected += data.words_progress_rejected[salt_pos];
1271 all_restored += data.words_progress_restored[salt_pos];
1272
1273 // Important for ETA only
1274
1275 if (data.salts_shown[salt_pos] == 1)
1276 {
1277 const u64 all = data.words_progress_done[salt_pos]
1278 + data.words_progress_rejected[salt_pos]
1279 + data.words_progress_restored[salt_pos];
1280
1281 const u64 left = data.words_cnt - all;
1282
1283 progress_noneed += left;
1284 }
1285 }
1286
1287 u64 progress_cur = all_restored + all_done + all_rejected;
1288 u64 progress_end = progress_total;
1289
1290 u64 progress_skip = 0;
1291
1292 if (data.skip)
1293 {
1294 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1295
1296 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1297 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1298 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1299 }
1300
1301 if (data.limit)
1302 {
1303 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1304
1305 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1306 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1307 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1308 }
1309
1310 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1311 u64 progress_end_relative_skip = progress_end - progress_skip;
1312
1313 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1314 {
1315 if (data.devices_status != STATUS_CRACKED)
1316 {
1317 #ifdef WIN
1318 __time64_t sec_etc = 0;
1319 #else
1320 time_t sec_etc = 0;
1321 #endif
1322
1323 if (hashes_all_ms)
1324 {
1325 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1326
1327 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1328
1329 sec_etc = ms_left / 1000;
1330 }
1331
1332 if (sec_etc == 0)
1333 {
1334 //log_info ("Time.Estimated.: 0 secs");
1335 }
1336 else if ((u64) sec_etc > ETC_MAX)
1337 {
1338 log_info ("Time.Estimated.: > 10 Years");
1339 }
1340 else
1341 {
1342 char display_etc[32] = { 0 };
1343
1344 struct tm tm_etc;
1345
1346 struct tm *tmp = NULL;
1347
1348 #ifdef WIN
1349
1350 tmp = _gmtime64 (&sec_etc);
1351
1352 #else
1353
1354 tmp = gmtime (&sec_etc);
1355
1356 #endif
1357
1358 if (tmp != NULL)
1359 {
1360 memset (&tm_etc, 0, sizeof (tm_etc));
1361
1362 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1363
1364 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1365
1366 time_t now;
1367
1368 time (&now);
1369
1370 now += sec_etc;
1371
1372 char *etc = ctime (&now);
1373
1374 size_t etc_len = strlen (etc);
1375
1376 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1377 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1378
1379 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1380 }
1381 }
1382 }
1383 }
1384
1385 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1386 {
1387 hc_device_param_t *device_param = &data.devices_param[device_id];
1388
1389 if (device_param->skipped) continue;
1390
1391 char display_dev_cur[16] = { 0 };
1392
1393 strncpy (display_dev_cur, "0.00", 4);
1394
1395 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1396
1397 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1398 }
1399
1400 char display_all_cur[16] = { 0 };
1401
1402 strncpy (display_all_cur, "0.00", 4);
1403
1404 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1405
1406 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1407
1408 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1409 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1410
1411 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1412
1413 // crack-per-time
1414
1415 if (data.digests_cnt > 100)
1416 {
1417 time_t now = time (NULL);
1418
1419 int cpt_cur_min = 0;
1420 int cpt_cur_hour = 0;
1421 int cpt_cur_day = 0;
1422
1423 for (int i = 0; i < CPT_BUF; i++)
1424 {
1425 const uint cracked = data.cpt_buf[i].cracked;
1426 const time_t timestamp = data.cpt_buf[i].timestamp;
1427
1428 if ((timestamp + 60) > now)
1429 {
1430 cpt_cur_min += cracked;
1431 }
1432
1433 if ((timestamp + 3600) > now)
1434 {
1435 cpt_cur_hour += cracked;
1436 }
1437
1438 if ((timestamp + 86400) > now)
1439 {
1440 cpt_cur_day += cracked;
1441 }
1442 }
1443
1444 double ms_real = ms_running - ms_paused;
1445
1446 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1447 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1448 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1449
1450 if ((data.cpt_start + 86400) < now)
1451 {
1452 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1453 cpt_cur_min,
1454 cpt_cur_hour,
1455 cpt_cur_day,
1456 cpt_avg_min,
1457 cpt_avg_hour,
1458 cpt_avg_day);
1459 }
1460 else if ((data.cpt_start + 3600) < now)
1461 {
1462 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1463 cpt_cur_min,
1464 cpt_cur_hour,
1465 cpt_avg_min,
1466 cpt_avg_hour,
1467 cpt_avg_day);
1468 }
1469 else if ((data.cpt_start + 60) < now)
1470 {
1471 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1472 cpt_cur_min,
1473 cpt_avg_min,
1474 cpt_avg_hour,
1475 cpt_avg_day);
1476 }
1477 else
1478 {
1479 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1480 cpt_avg_min,
1481 cpt_avg_hour,
1482 cpt_avg_day);
1483 }
1484 }
1485
1486 // Restore point
1487
1488 u64 restore_point = get_lowest_words_done ();
1489
1490 u64 restore_total = data.words_base;
1491
1492 float percent_restore = 0;
1493
1494 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1495
1496 if (progress_end_relative_skip)
1497 {
1498 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1499 {
1500 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1501 float percent_rejected = 0.0;
1502
1503 if (progress_cur)
1504 {
1505 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1506 }
1507
1508 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1509 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1510
1511 if (data.restore_disable == 0)
1512 {
1513 if (percent_finished != 1)
1514 {
1515 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1516 }
1517 }
1518 }
1519 }
1520 else
1521 {
1522 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1523 {
1524 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1525 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1526
1527 if (data.restore_disable == 0)
1528 {
1529 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1530 }
1531 }
1532 else
1533 {
1534 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1535 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1536
1537 // --restore not allowed if stdin is used -- really? why?
1538
1539 //if (data.restore_disable == 0)
1540 //{
1541 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1542 //}
1543 }
1544 }
1545
1546 #ifdef HAVE_HWMON
1547
1548 if (data.devices_status == STATUS_EXHAUSTED) return;
1549 if (data.devices_status == STATUS_CRACKED) return;
1550 if (data.devices_status == STATUS_ABORTED) return;
1551 if (data.devices_status == STATUS_QUIT) return;
1552
1553 if (data.gpu_temp_disable == 0)
1554 {
1555 hc_thread_mutex_lock (mux_adl);
1556
1557 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1558 {
1559 hc_device_param_t *device_param = &data.devices_param[device_id];
1560
1561 if (device_param->skipped) continue;
1562
1563 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1564 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1565 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1566 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1567 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1568 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1569 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1570
1571 char output_buf[256] = { 0 };
1572
1573 int output_len = 0;
1574
1575 if (num_temperature >= 0)
1576 {
1577 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1578
1579 output_len = strlen (output_buf);
1580 }
1581
1582 if (num_fanspeed >= 0)
1583 {
1584 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1585
1586 output_len = strlen (output_buf);
1587 }
1588
1589 if (num_utilization >= 0)
1590 {
1591 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1592
1593 output_len = strlen (output_buf);
1594 }
1595
1596 if (num_corespeed >= 0)
1597 {
1598 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1599
1600 output_len = strlen (output_buf);
1601 }
1602
1603 if (num_memoryspeed >= 0)
1604 {
1605 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1606
1607 output_len = strlen (output_buf);
1608 }
1609
1610 if (num_buslanes >= 0)
1611 {
1612 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1613
1614 output_len = strlen (output_buf);
1615 }
1616
1617 if (num_throttle == 1)
1618 {
1619 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1620
1621 output_len = strlen (output_buf);
1622 }
1623
1624 if (output_len == 0)
1625 {
1626 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1627
1628 output_len = strlen (output_buf);
1629 }
1630
1631 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1632 }
1633
1634 hc_thread_mutex_unlock (mux_adl);
1635 }
1636
1637 #endif // HAVE_HWMON
1638 }
1639
1640 static void status_benchmark_automate ()
1641 {
1642 u64 speed_cnt[DEVICES_MAX] = { 0 };
1643 double speed_ms[DEVICES_MAX] = { 0 };
1644
1645 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1646 {
1647 hc_device_param_t *device_param = &data.devices_param[device_id];
1648
1649 if (device_param->skipped) continue;
1650
1651 speed_cnt[device_id] = device_param->speed_cnt[0];
1652 speed_ms[device_id] = device_param->speed_ms[0];
1653 }
1654
1655 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1656
1657 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1658 {
1659 hc_device_param_t *device_param = &data.devices_param[device_id];
1660
1661 if (device_param->skipped) continue;
1662
1663 hashes_dev_ms[device_id] = 0;
1664
1665 if (speed_ms[device_id])
1666 {
1667 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1668 }
1669 }
1670
1671 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1672 {
1673 hc_device_param_t *device_param = &data.devices_param[device_id];
1674
1675 if (device_param->skipped) continue;
1676
1677 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1678 }
1679 }
1680
1681 static void status_benchmark ()
1682 {
1683 if (data.devices_status == STATUS_INIT) return;
1684 if (data.devices_status == STATUS_STARTING) return;
1685 if (data.devices_status == STATUS_BYPASS) return;
1686
1687 if (data.machine_readable == 1)
1688 {
1689 status_benchmark_automate ();
1690
1691 return;
1692 }
1693
1694 u64 speed_cnt[DEVICES_MAX] = { 0 };
1695 double speed_ms[DEVICES_MAX] = { 0 };
1696
1697 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1698 {
1699 hc_device_param_t *device_param = &data.devices_param[device_id];
1700
1701 if (device_param->skipped) continue;
1702
1703 speed_cnt[device_id] = device_param->speed_cnt[0];
1704 speed_ms[device_id] = device_param->speed_ms[0];
1705 }
1706
1707 double hashes_all_ms = 0;
1708
1709 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1710
1711 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1712 {
1713 hc_device_param_t *device_param = &data.devices_param[device_id];
1714
1715 if (device_param->skipped) continue;
1716
1717 hashes_dev_ms[device_id] = 0;
1718
1719 if (speed_ms[device_id])
1720 {
1721 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1722
1723 hashes_all_ms += hashes_dev_ms[device_id];
1724 }
1725 }
1726
1727 /**
1728 * exec time
1729 */
1730
1731 double exec_all_ms[DEVICES_MAX] = { 0 };
1732
1733 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1734 {
1735 hc_device_param_t *device_param = &data.devices_param[device_id];
1736
1737 if (device_param->skipped) continue;
1738
1739 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1740
1741 exec_all_ms[device_id] = exec_ms_avg;
1742 }
1743
1744 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1745 {
1746 hc_device_param_t *device_param = &data.devices_param[device_id];
1747
1748 if (device_param->skipped) continue;
1749
1750 char display_dev_cur[16] = { 0 };
1751
1752 strncpy (display_dev_cur, "0.00", 4);
1753
1754 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1755
1756 if (data.devices_active >= 10)
1757 {
1758 log_info ("Speed.Dev.#%d: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1759 }
1760 else
1761 {
1762 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1763 }
1764 }
1765
1766 char display_all_cur[16] = { 0 };
1767
1768 strncpy (display_all_cur, "0.00", 4);
1769
1770 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1771
1772 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1773 }
1774
1775 /**
1776 * hashcat -only- functions
1777 */
1778
1779 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1780 {
1781 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1782 {
1783 if (attack_kern == ATTACK_KERN_STRAIGHT)
1784 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1785 else if (attack_kern == ATTACK_KERN_COMBI)
1786 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1787 else if (attack_kern == ATTACK_KERN_BF)
1788 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1789 }
1790 else
1791 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1792 }
1793
1794 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1795 {
1796 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1797 {
1798 if (attack_kern == ATTACK_KERN_STRAIGHT)
1799 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1800 else if (attack_kern == ATTACK_KERN_COMBI)
1801 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1802 else if (attack_kern == ATTACK_KERN_BF)
1803 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1804 }
1805 else
1806 {
1807 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1808 }
1809 }
1810
1811 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1812 {
1813 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1814 {
1815 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1816 }
1817 else
1818 {
1819 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1820 }
1821 }
1822
1823 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1824 {
1825 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1826 {
1827 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1828 }
1829 else
1830 {
1831 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1832 }
1833 }
1834
1835 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1836 {
1837 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1838 }
1839
1840 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1841 {
1842 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1843 }
1844
1845 static char *filename_from_filepath (char *filepath)
1846 {
1847 char *ptr = NULL;
1848
1849 if ((ptr = strrchr (filepath, '/')) != NULL)
1850 {
1851 ptr++;
1852 }
1853 else if ((ptr = strrchr (filepath, '\\')) != NULL)
1854 {
1855 ptr++;
1856 }
1857 else
1858 {
1859 ptr = filepath;
1860 }
1861
1862 return ptr;
1863 }
1864
1865 static uint convert_from_hex (char *line_buf, const uint line_len)
1866 {
1867 if (line_len & 1) return (line_len); // not in hex
1868
1869 if (data.hex_wordlist == 1)
1870 {
1871 uint i;
1872 uint j;
1873
1874 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1875 {
1876 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1877 }
1878
1879 memset (line_buf + i, 0, line_len - i);
1880
1881 return (i);
1882 }
1883 else if (line_len >= 6) // $HEX[] = 6
1884 {
1885 if (line_buf[0] != '$') return (line_len);
1886 if (line_buf[1] != 'H') return (line_len);
1887 if (line_buf[2] != 'E') return (line_len);
1888 if (line_buf[3] != 'X') return (line_len);
1889 if (line_buf[4] != '[') return (line_len);
1890 if (line_buf[line_len - 1] != ']') return (line_len);
1891
1892 uint i;
1893 uint j;
1894
1895 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1896 {
1897 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1898 }
1899
1900 memset (line_buf + i, 0, line_len - i);
1901
1902 return (i);
1903 }
1904
1905 return (line_len);
1906 }
1907
1908 static void clear_prompt ()
1909 {
1910 fputc ('\r', stdout);
1911
1912 for (size_t i = 0; i < strlen (PROMPT); i++)
1913 {
1914 fputc (' ', stdout);
1915 }
1916
1917 fputc ('\r', stdout);
1918
1919 fflush (stdout);
1920 }
1921
1922 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1923 {
1924 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1925 }
1926
1927 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1928 {
1929 char *outfile = data.outfile;
1930 uint quiet = data.quiet;
1931 FILE *pot_fp = data.pot_fp;
1932 uint loopback = data.loopback;
1933 uint debug_mode = data.debug_mode;
1934 char *debug_file = data.debug_file;
1935
1936 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1937 int debug_rule_len = 0; // -1 error
1938 uint debug_plain_len = 0;
1939
1940 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1941
1942 // hash
1943
1944 char out_buf[HCBUFSIZ] = { 0 };
1945
1946 const u32 salt_pos = plain->salt_pos;
1947 const u32 digest_pos = plain->digest_pos; // relative
1948 const u32 gidvid = plain->gidvid;
1949 const u32 il_pos = plain->il_pos;
1950
1951 ascii_digest (out_buf, salt_pos, digest_pos);
1952
1953 // plain
1954
1955 u64 crackpos = device_param->words_off;
1956
1957 uint plain_buf[16] = { 0 };
1958
1959 u8 *plain_ptr = (u8 *) plain_buf;
1960
1961 unsigned int plain_len = 0;
1962
1963 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1964 {
1965 pw_t pw;
1966
1967 gidd_to_pw_t (device_param, gidvid, &pw);
1968
1969 for (int i = 0; i < 16; i++)
1970 {
1971 plain_buf[i] = pw.i[i];
1972 }
1973
1974 plain_len = pw.pw_len;
1975
1976 const uint off = device_param->innerloop_pos + il_pos;
1977
1978 if (debug_mode > 0)
1979 {
1980 debug_rule_len = 0;
1981
1982 // save rule
1983 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1984 {
1985 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1986
1987 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1988 }
1989
1990 // save plain
1991 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1992 {
1993 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1994
1995 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1996
1997 debug_plain_len = plain_len;
1998 }
1999 }
2000
2001 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2002
2003 crackpos += gidvid;
2004 crackpos *= data.kernel_rules_cnt;
2005 crackpos += device_param->innerloop_pos + il_pos;
2006
2007 if (plain_len > data.pw_max) plain_len = data.pw_max;
2008 }
2009 else if (data.attack_mode == ATTACK_MODE_COMBI)
2010 {
2011 pw_t pw;
2012
2013 gidd_to_pw_t (device_param, gidvid, &pw);
2014
2015 for (int i = 0; i < 16; i++)
2016 {
2017 plain_buf[i] = pw.i[i];
2018 }
2019
2020 plain_len = pw.pw_len;
2021
2022 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2023 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2024
2025 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2026 {
2027 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2028 }
2029 else
2030 {
2031 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2032
2033 memcpy (plain_ptr, comb_buf, comb_len);
2034 }
2035
2036 plain_len += comb_len;
2037
2038 crackpos += gidvid;
2039 crackpos *= data.combs_cnt;
2040 crackpos += device_param->innerloop_pos + il_pos;
2041
2042 if (data.pw_max != PW_DICTMAX1)
2043 {
2044 if (plain_len > data.pw_max) plain_len = data.pw_max;
2045 }
2046 }
2047 else if (data.attack_mode == ATTACK_MODE_BF)
2048 {
2049 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2050 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2051
2052 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2053 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2054
2055 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2056 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2057
2058 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2059 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2060
2061 plain_len = data.css_cnt;
2062
2063 crackpos += gidvid;
2064 crackpos *= data.bfs_cnt;
2065 crackpos += device_param->innerloop_pos + il_pos;
2066 }
2067 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2068 {
2069 pw_t pw;
2070
2071 gidd_to_pw_t (device_param, gidvid, &pw);
2072
2073 for (int i = 0; i < 16; i++)
2074 {
2075 plain_buf[i] = pw.i[i];
2076 }
2077
2078 plain_len = pw.pw_len;
2079
2080 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2081
2082 uint start = 0;
2083 uint stop = device_param->kernel_params_mp_buf32[4];
2084
2085 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2086
2087 plain_len += start + stop;
2088
2089 crackpos += gidvid;
2090 crackpos *= data.combs_cnt;
2091 crackpos += device_param->innerloop_pos + il_pos;
2092
2093 if (data.pw_max != PW_DICTMAX1)
2094 {
2095 if (plain_len > data.pw_max) plain_len = data.pw_max;
2096 }
2097 }
2098 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2099 {
2100 pw_t pw;
2101
2102 gidd_to_pw_t (device_param, gidvid, &pw);
2103
2104 for (int i = 0; i < 16; i++)
2105 {
2106 plain_buf[i] = pw.i[i];
2107 }
2108
2109 plain_len = pw.pw_len;
2110
2111 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2112
2113 uint start = 0;
2114 uint stop = device_param->kernel_params_mp_buf32[4];
2115
2116 memmove (plain_ptr + stop, plain_ptr, plain_len);
2117
2118 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2119
2120 plain_len += start + stop;
2121
2122 crackpos += gidvid;
2123 crackpos *= data.combs_cnt;
2124 crackpos += device_param->innerloop_pos + il_pos;
2125
2126 if (data.pw_max != PW_DICTMAX1)
2127 {
2128 if (plain_len > data.pw_max) plain_len = data.pw_max;
2129 }
2130 }
2131
2132 if (data.attack_mode == ATTACK_MODE_BF)
2133 {
2134 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2135 {
2136 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2137 {
2138 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2139 {
2140 plain_len = plain_len - data.salts_buf[0].salt_len;
2141 }
2142 }
2143
2144 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2145 {
2146 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2147 {
2148 plain_ptr[j] = plain_ptr[i];
2149 }
2150
2151 plain_len = plain_len / 2;
2152 }
2153 }
2154 }
2155
2156 // if enabled, update also the potfile
2157
2158 if (pot_fp)
2159 {
2160 lock_file (pot_fp);
2161
2162 fprintf (pot_fp, "%s:", out_buf);
2163
2164 format_plain (pot_fp, plain_ptr, plain_len, 1);
2165
2166 fputc ('\n', pot_fp);
2167
2168 fflush (pot_fp);
2169
2170 unlock_file (pot_fp);
2171 }
2172
2173 // outfile
2174
2175 FILE *out_fp = NULL;
2176
2177 if (outfile != NULL)
2178 {
2179 if ((out_fp = fopen (outfile, "ab")) == NULL)
2180 {
2181 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2182
2183 out_fp = stdout;
2184 }
2185
2186 lock_file (out_fp);
2187 }
2188 else
2189 {
2190 out_fp = stdout;
2191
2192 if (quiet == 0) clear_prompt ();
2193 }
2194
2195 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2196
2197 if (outfile != NULL)
2198 {
2199 if (out_fp != stdout)
2200 {
2201 fclose (out_fp);
2202 }
2203 }
2204 else
2205 {
2206 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2207 {
2208 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2209 {
2210 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2211 if (quiet == 0) fflush (stdout);
2212 }
2213 }
2214 }
2215
2216 // loopback
2217
2218 if (loopback)
2219 {
2220 char *loopback_file = data.loopback_file;
2221
2222 FILE *fb_fp = NULL;
2223
2224 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2225 {
2226 lock_file (fb_fp);
2227
2228 format_plain (fb_fp, plain_ptr, plain_len, 1);
2229
2230 fputc ('\n', fb_fp);
2231
2232 fclose (fb_fp);
2233 }
2234 }
2235
2236 // (rule) debug mode
2237
2238 // the next check implies that:
2239 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2240 // - debug_mode > 0
2241
2242 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2243 {
2244 if (debug_rule_len < 0) debug_rule_len = 0;
2245
2246 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2247
2248 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2249
2250 if ((quiet == 0) && (debug_file == NULL))
2251 {
2252 fprintf (stdout, "%s", PROMPT);
2253
2254 fflush (stdout);
2255 }
2256 }
2257 }
2258
2259 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2260 {
2261 salt_t *salt_buf = &data.salts_buf[salt_pos];
2262
2263 u32 num_cracked;
2264
2265 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2266
2267 if (num_cracked)
2268 {
2269 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2270
2271 log_info_nn ("");
2272
2273 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2274
2275 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, 0, num_cracked * sizeof (plain_t), cracked, 0, NULL, NULL);
2276
2277 uint cpt_cracked = 0;
2278
2279 hc_thread_mutex_lock (mux_display);
2280
2281 for (uint i = 0; i < num_cracked; i++)
2282 {
2283 const uint hash_pos = cracked[i].hash_pos;
2284
2285 if (data.digests_shown[hash_pos] == 1) continue;
2286
2287 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2288 {
2289 data.digests_shown[hash_pos] = 1;
2290
2291 data.digests_done++;
2292
2293 cpt_cracked++;
2294
2295 salt_buf->digests_done++;
2296
2297 if (salt_buf->digests_done == salt_buf->digests_cnt)
2298 {
2299 data.salts_shown[salt_pos] = 1;
2300
2301 data.salts_done++;
2302 }
2303 }
2304
2305 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2306
2307 check_hash (device_param, &cracked[i]);
2308 }
2309
2310 hc_thread_mutex_unlock (mux_display);
2311
2312 myfree (cracked);
2313
2314 if (cpt_cracked > 0)
2315 {
2316 hc_thread_mutex_lock (mux_display);
2317
2318 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2319 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2320
2321 data.cpt_pos++;
2322
2323 data.cpt_total += cpt_cracked;
2324
2325 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2326
2327 hc_thread_mutex_unlock (mux_display);
2328 }
2329
2330 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2331 {
2332 // we need to reset cracked state on the device
2333 // otherwise host thinks again and again the hash was cracked
2334 // and returns invalid password each time
2335
2336 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2337
2338 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2339 }
2340
2341 num_cracked = 0;
2342
2343 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2344 }
2345 }
2346
2347 // stolen from princeprocessor ;)
2348
2349 typedef struct
2350 {
2351 FILE *fp;
2352
2353 char buf[BUFSIZ];
2354 int len;
2355
2356 } out_t;
2357
2358 static void out_flush (out_t *out)
2359 {
2360 fwrite (out->buf, 1, out->len, out->fp);
2361
2362 out->len = 0;
2363 }
2364
2365 static void out_push (out_t *out, const u8 *pw_buf, const int pw_len)
2366 {
2367 char *ptr = out->buf + out->len;
2368
2369 memcpy (ptr, pw_buf, pw_len);
2370
2371 ptr[pw_len] = '\n';
2372
2373 out->len += pw_len + 1;
2374
2375 if (out->len >= BUFSIZ - 100)
2376 {
2377 out_flush (out);
2378 }
2379 }
2380
2381 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2382 {
2383 out_t out;
2384
2385 out.fp = stdout;
2386 out.len = 0;
2387
2388 uint plain_buf[16] = { 0 };
2389
2390 u8 *plain_ptr = (u8 *) plain_buf;
2391
2392 uint plain_len = 0;
2393
2394 const uint il_cnt = device_param->kernel_params_buf32[27]; // ugly, i know
2395
2396 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2397 {
2398 pw_t pw;
2399
2400 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2401 {
2402 gidd_to_pw_t (device_param, gidvid, &pw);
2403
2404 const uint pos = device_param->innerloop_pos;
2405
2406 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2407 {
2408 for (int i = 0; i < 8; i++)
2409 {
2410 plain_buf[i] = pw.i[i];
2411 }
2412
2413 plain_len = pw.pw_len;
2414
2415 plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2416
2417 if (plain_len > data.pw_max) plain_len = data.pw_max;
2418
2419 out_push (&out, plain_ptr, plain_len);
2420 }
2421 }
2422 }
2423 else if (data.attack_mode == ATTACK_MODE_COMBI)
2424 {
2425 pw_t pw;
2426
2427 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2428 {
2429 gidd_to_pw_t (device_param, gidvid, &pw);
2430
2431 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2432 {
2433 for (int i = 0; i < 8; i++)
2434 {
2435 plain_buf[i] = pw.i[i];
2436 }
2437
2438 plain_len = pw.pw_len;
2439
2440 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2441 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2442
2443 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2444 {
2445 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2446 }
2447 else
2448 {
2449 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2450
2451 memcpy (plain_ptr, comb_buf, comb_len);
2452 }
2453
2454 plain_len += comb_len;
2455
2456 if (data.pw_max != PW_DICTMAX1)
2457 {
2458 if (plain_len > data.pw_max) plain_len = data.pw_max;
2459 }
2460
2461 out_push (&out, plain_ptr, plain_len);
2462 }
2463 }
2464 }
2465 else if (data.attack_mode == ATTACK_MODE_BF)
2466 {
2467 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2468 {
2469 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2470 {
2471 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2472 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2473
2474 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2475 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2476
2477 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2478 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2479
2480 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2481 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2482
2483 plain_len = data.css_cnt;
2484
2485 out_push (&out, plain_ptr, plain_len);
2486 }
2487 }
2488 }
2489 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2490 {
2491 pw_t pw;
2492
2493 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2494 {
2495 gidd_to_pw_t (device_param, gidvid, &pw);
2496
2497 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2498 {
2499 for (int i = 0; i < 8; i++)
2500 {
2501 plain_buf[i] = pw.i[i];
2502 }
2503
2504 plain_len = pw.pw_len;
2505
2506 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2507
2508 uint start = 0;
2509 uint stop = device_param->kernel_params_mp_buf32[4];
2510
2511 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2512
2513 plain_len += start + stop;
2514
2515 out_push (&out, plain_ptr, plain_len);
2516 }
2517 }
2518 }
2519 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2520 {
2521 pw_t pw;
2522
2523 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2524 {
2525 gidd_to_pw_t (device_param, gidvid, &pw);
2526
2527 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2528 {
2529 for (int i = 0; i < 8; i++)
2530 {
2531 plain_buf[i] = pw.i[i];
2532 }
2533
2534 plain_len = pw.pw_len;
2535
2536 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2537
2538 uint start = 0;
2539 uint stop = device_param->kernel_params_mp_buf32[4];
2540
2541 memmove (plain_ptr + stop, plain_ptr, plain_len);
2542
2543 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2544
2545 plain_len += start + stop;
2546
2547 out_push (&out, plain_ptr, plain_len);
2548 }
2549 }
2550 }
2551
2552 out_flush (&out);
2553 }
2554
2555 static void save_hash ()
2556 {
2557 char *hashfile = data.hashfile;
2558
2559 char new_hashfile[256] = { 0 };
2560 char old_hashfile[256] = { 0 };
2561
2562 snprintf (new_hashfile, 255, "%s.new", hashfile);
2563 snprintf (old_hashfile, 255, "%s.old", hashfile);
2564
2565 unlink (new_hashfile);
2566
2567 char separator = data.separator;
2568
2569 FILE *fp = fopen (new_hashfile, "wb");
2570
2571 if (fp == NULL)
2572 {
2573 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2574
2575 exit (-1);
2576 }
2577
2578 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2579 {
2580 if (data.salts_shown[salt_pos] == 1) continue;
2581
2582 salt_t *salt_buf = &data.salts_buf[salt_pos];
2583
2584 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2585 {
2586 uint idx = salt_buf->digests_offset + digest_pos;
2587
2588 if (data.digests_shown[idx] == 1) continue;
2589
2590 if (data.hash_mode != 2500)
2591 {
2592 if (data.username == 1)
2593 {
2594 user_t *user = data.hash_info[idx]->user;
2595
2596 uint i;
2597
2598 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2599
2600 fputc (separator, fp);
2601 }
2602
2603 char out_buf[HCBUFSIZ]; // scratch buffer
2604
2605 out_buf[0] = 0;
2606
2607 ascii_digest (out_buf, salt_pos, digest_pos);
2608
2609 fputs (out_buf, fp);
2610
2611 fputc ('\n', fp);
2612 }
2613 else
2614 {
2615 hccap_t hccap;
2616
2617 to_hccap_t (&hccap, salt_pos, digest_pos);
2618
2619 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2620 }
2621 }
2622 }
2623
2624 fflush (fp);
2625
2626 fclose (fp);
2627
2628 unlink (old_hashfile);
2629
2630 if (rename (hashfile, old_hashfile) != 0)
2631 {
2632 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2633
2634 exit (-1);
2635 }
2636
2637 unlink (hashfile);
2638
2639 if (rename (new_hashfile, hashfile) != 0)
2640 {
2641 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2642
2643 exit (-1);
2644 }
2645
2646 unlink (old_hashfile);
2647 }
2648
2649 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2650 {
2651 uint num_elements = num;
2652
2653 device_param->kernel_params_buf32[30] = data.combs_mode;
2654 device_param->kernel_params_buf32[31] = num;
2655
2656 uint kernel_threads = device_param->kernel_threads;
2657
2658 while (num_elements % kernel_threads) num_elements++;
2659
2660 cl_kernel kernel = NULL;
2661
2662 switch (kern_run)
2663 {
2664 case KERN_RUN_1: kernel = device_param->kernel1; break;
2665 case KERN_RUN_12: kernel = device_param->kernel12; break;
2666 case KERN_RUN_2: kernel = device_param->kernel2; break;
2667 case KERN_RUN_23: kernel = device_param->kernel23; break;
2668 case KERN_RUN_3: kernel = device_param->kernel3; break;
2669 }
2670
2671 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2672 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2673 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2674 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2675 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2676 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2677 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2678 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2679 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2680 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2681 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2682
2683 cl_event event;
2684
2685 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2686 {
2687 const size_t global_work_size[3] = { num_elements, 32, 1 };
2688 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2689
2690 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2691 }
2692 else
2693 {
2694 if (kern_run == KERN_RUN_2)
2695 {
2696 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2697 {
2698 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2699 }
2700 }
2701
2702 while (num_elements % kernel_threads) num_elements++;
2703
2704 const size_t global_work_size[3] = { num_elements, 1, 1 };
2705 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2706
2707 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2708 }
2709
2710 hc_clFlush (data.ocl, device_param->command_queue);
2711
2712 if (device_param->nvidia_spin_damp)
2713 {
2714 if (data.devices_status == STATUS_RUNNING)
2715 {
2716 if (iteration < EXPECTED_ITERATIONS)
2717 {
2718 switch (kern_run)
2719 {
2720 case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration] * device_param->nvidia_spin_damp); break;
2721 case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration] * device_param->nvidia_spin_damp); break;
2722 case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration] * device_param->nvidia_spin_damp); break;
2723 }
2724 }
2725 }
2726 }
2727
2728 hc_clWaitForEvents (data.ocl, 1, &event);
2729
2730 cl_ulong time_start;
2731 cl_ulong time_end;
2732
2733 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2734 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2735
2736 const double exec_us = (double) (time_end - time_start) / 1000;
2737
2738 if (data.devices_status == STATUS_RUNNING)
2739 {
2740 if (iteration < EXPECTED_ITERATIONS)
2741 {
2742 switch (kern_run)
2743 {
2744 case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2745 case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2746 case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2747 }
2748 }
2749 }
2750
2751 if (event_update)
2752 {
2753 uint exec_pos = device_param->exec_pos;
2754
2755 device_param->exec_ms[exec_pos] = exec_us / 1000;
2756
2757 exec_pos++;
2758
2759 if (exec_pos == EXEC_CACHE)
2760 {
2761 exec_pos = 0;
2762 }
2763
2764 device_param->exec_pos = exec_pos;
2765 }
2766
2767 hc_clReleaseEvent (data.ocl, event);
2768
2769 hc_clFinish (data.ocl, device_param->command_queue);
2770 }
2771
2772 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2773 {
2774 uint num_elements = num;
2775
2776 switch (kern_run)
2777 {
2778 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2779 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2780 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2781 }
2782
2783 // causes problems with special threads like in bcrypt
2784 // const uint kernel_threads = device_param->kernel_threads;
2785
2786 uint kernel_threads = device_param->kernel_threads;
2787
2788 while (num_elements % kernel_threads) num_elements++;
2789
2790 cl_kernel kernel = NULL;
2791
2792 switch (kern_run)
2793 {
2794 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2795 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2796 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2797 }
2798
2799 switch (kern_run)
2800 {
2801 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2802 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2803 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2804 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2805 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2806 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2807 break;
2808 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2809 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2810 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2811 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2812 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2813 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2814 break;
2815 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2816 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2817 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2818 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2819 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2820 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2821 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2822 break;
2823 }
2824
2825 const size_t global_work_size[3] = { num_elements, 1, 1 };
2826 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2827
2828 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2829
2830 hc_clFlush (data.ocl, device_param->command_queue);
2831
2832 hc_clFinish (data.ocl, device_param->command_queue);
2833 }
2834
2835 static void run_kernel_tm (hc_device_param_t *device_param)
2836 {
2837 const uint num_elements = 1024; // fixed
2838
2839 uint kernel_threads = 32;
2840
2841 cl_kernel kernel = device_param->kernel_tm;
2842
2843 const size_t global_work_size[3] = { num_elements, 1, 1 };
2844 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2845
2846 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2847
2848 hc_clFlush (data.ocl, device_param->command_queue);
2849
2850 hc_clFinish (data.ocl, device_param->command_queue);
2851 }
2852
2853 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2854 {
2855 uint num_elements = num;
2856
2857 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2858 device_param->kernel_params_amp_buf32[6] = num_elements;
2859
2860 // causes problems with special threads like in bcrypt
2861 // const uint kernel_threads = device_param->kernel_threads;
2862
2863 uint kernel_threads = device_param->kernel_threads;
2864
2865 while (num_elements % kernel_threads) num_elements++;
2866
2867 cl_kernel kernel = device_param->kernel_amp;
2868
2869 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2870 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2871
2872 const size_t global_work_size[3] = { num_elements, 1, 1 };
2873 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2874
2875 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2876
2877 hc_clFlush (data.ocl, device_param->command_queue);
2878
2879 hc_clFinish (data.ocl, device_param->command_queue);
2880 }
2881
2882 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2883 {
2884 const u32 num16d = num / 16;
2885 const u32 num16m = num % 16;
2886
2887 if (num16d)
2888 {
2889 device_param->kernel_params_memset_buf32[1] = value;
2890 device_param->kernel_params_memset_buf32[2] = num16d;
2891
2892 uint kernel_threads = device_param->kernel_threads;
2893
2894 uint num_elements = num16d;
2895
2896 while (num_elements % kernel_threads) num_elements++;
2897
2898 cl_kernel kernel = device_param->kernel_memset;
2899
2900 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2901 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2902 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2903
2904 const size_t global_work_size[3] = { num_elements, 1, 1 };
2905 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2906
2907 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2908
2909 hc_clFlush (data.ocl, device_param->command_queue);
2910
2911 hc_clFinish (data.ocl, device_param->command_queue);
2912 }
2913
2914 if (num16m)
2915 {
2916 u32 tmp[4];
2917
2918 tmp[0] = value;
2919 tmp[1] = value;
2920 tmp[2] = value;
2921 tmp[3] = value;
2922
2923 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2924 }
2925 }
2926
2927 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2928 {
2929 run_kernel_memset (device_param, buf, 0, size);
2930
2931 /*
2932 int rc = -1;
2933
2934 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2935 {
2936 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2937
2938 const cl_uchar zero = 0;
2939
2940 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2941 }
2942
2943 if (rc != 0)
2944 {
2945 // NOTE: clEnqueueFillBuffer () always fails with -59
2946 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2947 // How's that possible, OpenCL 1.2 support is advertised??
2948 // We need to workaround...
2949
2950 #define FILLSZ 0x100000
2951
2952 char *tmp = (char *) mymalloc (FILLSZ);
2953
2954 for (size_t i = 0; i < size; i += FILLSZ)
2955 {
2956 const size_t left = size - i;
2957
2958 const size_t fillsz = MIN (FILLSZ, left);
2959
2960 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2961 }
2962
2963 myfree (tmp);
2964 }
2965 */
2966 }
2967
2968 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt, const uint fast_iteration)
2969 {
2970 if (data.hash_mode == 2000)
2971 {
2972 process_stdout (device_param, pws_cnt);
2973
2974 return;
2975 }
2976
2977 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2978 {
2979 if (attack_mode == ATTACK_MODE_BF)
2980 {
2981 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2982 {
2983 const uint size_tm = 32 * sizeof (bs_word_t);
2984
2985 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2986
2987 run_kernel_tm (device_param);
2988
2989 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2990 }
2991 }
2992
2993 if (highest_pw_len < 16)
2994 {
2995 run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
2996 }
2997 else if (highest_pw_len < 32)
2998 {
2999 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
3000 }
3001 else
3002 {
3003 run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
3004 }
3005 }
3006 else
3007 {
3008 run_kernel_amp (device_param, pws_cnt);
3009
3010 run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
3011
3012 if (opts_type & OPTS_TYPE_HOOK12)
3013 {
3014 run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
3015
3016 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
3017
3018 // do something with data
3019
3020 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
3021 }
3022
3023 uint iter = salt_buf->salt_iter;
3024
3025 uint loop_step = device_param->kernel_loops;
3026
3027 for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
3028 {
3029 uint loop_left = iter - loop_pos;
3030
3031 loop_left = MIN (loop_left, loop_step);
3032
3033 device_param->kernel_params_buf32[25] = loop_pos;
3034 device_param->kernel_params_buf32[26] = loop_left;
3035
3036 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
3037
3038 if (data.devices_status == STATUS_CRACKED) break;
3039 if (data.devices_status == STATUS_ABORTED) break;
3040 if (data.devices_status == STATUS_QUIT) break;
3041
3042 /**
3043 * speed
3044 */
3045
3046 const float iter_part = (float) (loop_pos + loop_left) / iter;
3047
3048 const u64 perf_sum_all = pws_cnt * iter_part;
3049
3050 double speed_ms;
3051
3052 hc_timer_get (device_param->timer_speed, speed_ms);
3053
3054 const u32 speed_pos = device_param->speed_pos;
3055
3056 device_param->speed_cnt[speed_pos] = perf_sum_all;
3057
3058 device_param->speed_ms[speed_pos] = speed_ms;
3059
3060 if (data.benchmark == 1)
3061 {
3062 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
3063 }
3064 }
3065
3066 if (opts_type & OPTS_TYPE_HOOK23)
3067 {
3068 run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
3069
3070 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
3071
3072 // do something with data
3073
3074 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
3075 }
3076
3077 run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3078 }
3079 }
3080
3081 static int run_rule_engine (const int rule_len, const char *rule_buf)
3082 {
3083 if (rule_len == 0)
3084 {
3085 return 0;
3086 }
3087 else if (rule_len == 1)
3088 {
3089 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3090 }
3091
3092 return 1;
3093 }
3094
3095 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3096 {
3097 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3098 {
3099 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3100 }
3101 else if (data.attack_kern == ATTACK_KERN_COMBI)
3102 {
3103 if (data.attack_mode == ATTACK_MODE_COMBI)
3104 {
3105 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3106 {
3107 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3108 {
3109 for (u32 i = 0; i < pws_cnt; i++)
3110 {
3111 const u32 pw_len = device_param->pws_buf[i].pw_len;
3112
3113 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3114
3115 ptr[pw_len] = 0x01;
3116 }
3117 }
3118 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3119 {
3120 for (u32 i = 0; i < pws_cnt; i++)
3121 {
3122 const u32 pw_len = device_param->pws_buf[i].pw_len;
3123
3124 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3125
3126 ptr[pw_len] = 0x80;
3127 }
3128 }
3129 }
3130 }
3131 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3132 {
3133 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3134 {
3135 for (u32 i = 0; i < pws_cnt; i++)
3136 {
3137 const u32 pw_len = device_param->pws_buf[i].pw_len;
3138
3139 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3140
3141 ptr[pw_len] = 0x01;
3142 }
3143 }
3144 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3145 {
3146 for (u32 i = 0; i < pws_cnt; i++)
3147 {
3148 const u32 pw_len = device_param->pws_buf[i].pw_len;
3149
3150 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3151
3152 ptr[pw_len] = 0x80;
3153 }
3154 }
3155 }
3156
3157 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3158 }
3159 else if (data.attack_kern == ATTACK_KERN_BF)
3160 {
3161 const u64 off = device_param->words_off;
3162
3163 device_param->kernel_params_mp_l_buf64[3] = off;
3164
3165 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3166 }
3167 }
3168
3169 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3170 {
3171 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3172
3173 device_param->kernel_params_buf32[25] = 0;
3174 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
3175 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3176
3177 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3178 {
3179 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3180 }
3181 else
3182 {
3183 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3184 }
3185
3186 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3187
3188 return exec_ms_prev;
3189 }
3190
3191 static void autotune (hc_device_param_t *device_param)
3192 {
3193 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3194
3195 const u32 kernel_accel_min = device_param->kernel_accel_min;
3196 const u32 kernel_accel_max = device_param->kernel_accel_max;
3197
3198 const u32 kernel_loops_min = device_param->kernel_loops_min;
3199 const u32 kernel_loops_max = device_param->kernel_loops_max;
3200
3201 u32 kernel_accel = kernel_accel_min;
3202 u32 kernel_loops = kernel_loops_min;
3203
3204 // in this case the user specified a fixed -u and -n on the commandline
3205 // no way to tune anything
3206 // but we need to run a few caching rounds
3207
3208 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3209 {
3210 if (data.hash_mode != 2000)
3211 {
3212 try_run (device_param, kernel_accel, kernel_loops);
3213 try_run (device_param, kernel_accel, kernel_loops);
3214 try_run (device_param, kernel_accel, kernel_loops);
3215 try_run (device_param, kernel_accel, kernel_loops);
3216 }
3217
3218 device_param->kernel_accel = kernel_accel;
3219 device_param->kernel_loops = kernel_loops;
3220
3221 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3222
3223 device_param->kernel_power = kernel_power;
3224
3225 return;
3226 }
3227
3228 // from here it's clear we are allowed to autotune
3229 // so let's init some fake words
3230
3231 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3232
3233 if (data.attack_kern == ATTACK_KERN_BF)
3234 {
3235 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3236 }
3237 else
3238 {
3239 for (u32 i = 0; i < kernel_power_max; i++)
3240 {
3241 device_param->pws_buf[i].i[0] = i;
3242 device_param->pws_buf[i].i[1] = 0x01234567;
3243 device_param->pws_buf[i].pw_len = 7 + (i & 7);
3244 }
3245
3246 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3247 }
3248
3249 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3250 {
3251 if (data.kernel_rules_cnt > 1)
3252 {
3253 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, 0, 0, MIN (kernel_loops_max, KERNEL_RULES) * sizeof (kernel_rule_t), 0, NULL, NULL);
3254 }
3255 }
3256 else
3257 {
3258 run_kernel_amp (device_param, kernel_power_max);
3259 }
3260
3261 #define VERIFIER_CNT 1
3262
3263 // first find out highest kernel-loops that stays below target_ms
3264
3265 if (kernel_loops_min < kernel_loops_max)
3266 {
3267 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3268 {
3269 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3270
3271 for (int i = 0; i < VERIFIER_CNT; i++)
3272 {
3273 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3274
3275 exec_ms = MIN (exec_ms, exec_ms_v);
3276 }
3277
3278 if (exec_ms < target_ms) break;
3279 }
3280 }
3281
3282 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3283
3284 #define STEPS_CNT 10
3285
3286 if (kernel_accel_min < kernel_accel_max)
3287 {
3288 for (int i = 0; i < STEPS_CNT; i++)
3289 {
3290 const u32 kernel_accel_try = 1 << i;
3291
3292 if (kernel_accel_try < kernel_accel_min) continue;
3293 if (kernel_accel_try > kernel_accel_max) break;
3294
3295 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3296
3297 for (int i = 0; i < VERIFIER_CNT; i++)
3298 {
3299 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3300
3301 exec_ms = MIN (exec_ms, exec_ms_v);
3302 }
3303
3304 if (exec_ms > target_ms) break;
3305
3306 kernel_accel = kernel_accel_try;
3307 }
3308 }
3309
3310 // at this point we want to know the actual runtime for the following reason:
3311 // we need a reference for the balancing loop following up, and this
3312 // the balancing loop can have an effect that the creates a new opportunity, for example:
3313 // if the target is 95 ms and the current runtime is 48ms the above loop
3314 // stopped the execution because the previous exec_ms was > 95ms
3315 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3316 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3317
3318 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3319
3320 for (int i = 0; i < VERIFIER_CNT; i++)
3321 {
3322 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3323
3324 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3325 }
3326
3327 u32 diff = kernel_loops - kernel_accel;
3328
3329 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3330 {
3331 u32 kernel_accel_orig = kernel_accel;
3332 u32 kernel_loops_orig = kernel_loops;
3333
3334 for (u32 f = 1; f < 1024; f++)
3335 {
3336 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3337 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3338
3339 if (kernel_accel_try > kernel_accel_max) break;
3340 if (kernel_loops_try < kernel_loops_min) break;
3341
3342 u32 diff_new = kernel_loops_try - kernel_accel_try;
3343
3344 if (diff_new > diff) break;
3345
3346 diff_new = diff;
3347
3348 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3349
3350 for (int i = 0; i < VERIFIER_CNT; i++)
3351 {
3352 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3353
3354 exec_ms = MIN (exec_ms, exec_ms_v);
3355 }
3356
3357 if (exec_ms < exec_ms_pre_final)
3358 {
3359 exec_ms_pre_final = exec_ms;
3360
3361 kernel_accel = kernel_accel_try;
3362 kernel_loops = kernel_loops_try;
3363 }
3364 }
3365 }
3366
3367 const double exec_left = target_ms / exec_ms_pre_final;
3368
3369 const double accel_left = kernel_accel_max / kernel_accel;
3370
3371 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3372
3373 if (exec_accel_min >= 1.0)
3374 {
3375 // this is safe to not overflow kernel_accel_max because of accel_left
3376
3377 kernel_accel = (double) kernel_accel * exec_accel_min;
3378 }
3379
3380 // reset them fake words
3381
3382 /*
3383 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3384
3385 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3386 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3387 */
3388
3389 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3390
3391 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3392 {
3393 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3394 }
3395
3396 // reset timer
3397
3398 device_param->exec_pos = 0;
3399
3400 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3401
3402 memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3403 memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3404 memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3405
3406 // store
3407
3408 device_param->kernel_accel = kernel_accel;
3409 device_param->kernel_loops = kernel_loops;
3410
3411 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3412
3413 device_param->kernel_power = kernel_power;
3414
3415 #ifdef DEBUG
3416
3417 if (data.quiet == 0)
3418 {
3419 clear_prompt ();
3420
3421 log_info ("- Device #%u: autotuned kernel-accel to %u\n"
3422 "- Device #%u: autotuned kernel-loops to %u\n",
3423 device_param->device_id + 1, kernel_accel,
3424 device_param->device_id + 1, kernel_loops);
3425
3426 fprintf (stdout, "%s", PROMPT);
3427
3428 fflush (stdout);
3429 }
3430
3431 #endif
3432 }
3433
3434 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3435 {
3436 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3437
3438 // init speed timer
3439
3440 uint speed_pos = device_param->speed_pos;
3441
3442 #ifdef _POSIX
3443 if (device_param->timer_speed.tv_sec == 0)
3444 {
3445 hc_timer_set (&device_param->timer_speed);
3446 }
3447 #endif
3448
3449 #ifdef _WIN
3450 if (device_param->timer_speed.QuadPart == 0)
3451 {
3452 hc_timer_set (&device_param->timer_speed);
3453 }
3454 #endif
3455
3456 // find higest password length, this is for optimization stuff
3457
3458 uint highest_pw_len = 0;
3459
3460 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3461 {
3462 }
3463 else if (data.attack_kern == ATTACK_KERN_COMBI)
3464 {
3465 }
3466 else if (data.attack_kern == ATTACK_KERN_BF)
3467 {
3468 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3469 + device_param->kernel_params_mp_l_buf32[5];
3470 }
3471
3472 // iteration type
3473
3474 uint innerloop_step = 0;
3475 uint innerloop_cnt = 0;
3476
3477 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3478 else innerloop_step = 1;
3479
3480 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3481 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3482 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3483
3484 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3485
3486 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3487 {
3488 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3489
3490 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3491
3492 if (data.devices_status == STATUS_CRACKED) break;
3493 if (data.devices_status == STATUS_ABORTED) break;
3494 if (data.devices_status == STATUS_QUIT) break;
3495 if (data.devices_status == STATUS_BYPASS) break;
3496
3497 salt_t *salt_buf = &data.salts_buf[salt_pos];
3498
3499 device_param->kernel_params_buf32[24] = salt_pos;
3500 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3501 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3502
3503 FILE *combs_fp = device_param->combs_fp;
3504
3505 if (data.attack_mode == ATTACK_MODE_COMBI)
3506 {
3507 rewind (combs_fp);
3508 }
3509
3510 // innerloops
3511
3512 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3513 {
3514 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3515
3516 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3517
3518 if (data.devices_status == STATUS_CRACKED) break;
3519 if (data.devices_status == STATUS_ABORTED) break;
3520 if (data.devices_status == STATUS_QUIT) break;
3521 if (data.devices_status == STATUS_BYPASS) break;
3522
3523 uint fast_iteration = 0;
3524
3525 uint innerloop_left = innerloop_cnt - innerloop_pos;
3526
3527 if (innerloop_left > innerloop_step)
3528 {
3529 innerloop_left = innerloop_step;
3530
3531 fast_iteration = 1;
3532 }
3533
3534 device_param->innerloop_pos = innerloop_pos;
3535 device_param->innerloop_left = innerloop_left;
3536
3537 device_param->kernel_params_buf32[27] = innerloop_left;
3538
3539 // i think we can get rid of this
3540 if (innerloop_left == 0)
3541 {
3542 puts ("bug, how should this happen????\n");
3543
3544 continue;
3545 }
3546
3547 if (data.salts_shown[salt_pos] == 1)
3548 {
3549 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3550
3551 continue;
3552 }
3553
3554 // initialize amplifiers
3555
3556 if (data.attack_mode == ATTACK_MODE_COMBI)
3557 {
3558 uint i = 0;
3559
3560 while (i < innerloop_left)
3561 {
3562 if (feof (combs_fp)) break;
3563
3564 int line_len = fgetl (combs_fp, line_buf);
3565
3566 if (line_len >= PW_MAX1) continue;
3567
3568 line_len = convert_from_hex (line_buf, line_len);
3569
3570 char *line_buf_new = line_buf;
3571
3572 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3573 {
3574 char rule_buf_out[BLOCK_SIZE] = { 0 };
3575
3576 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3577
3578 if (rule_len_out < 0)
3579 {
3580 data.words_progress_rejected[salt_pos] += pws_cnt;
3581
3582 continue;
3583 }
3584
3585 line_len = rule_len_out;
3586
3587 line_buf_new = rule_buf_out;
3588 }
3589
3590 line_len = MIN (line_len, PW_DICTMAX);
3591
3592 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3593
3594 memcpy (ptr, line_buf_new, line_len);
3595
3596 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3597
3598 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3599 {
3600 uppercase (ptr, line_len);
3601 }
3602
3603 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3604 {
3605 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3606 {
3607 ptr[line_len] = 0x80;
3608 }
3609
3610 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3611 {
3612 ptr[line_len] = 0x01;
3613 }
3614 }
3615
3616 device_param->combs_buf[i].pw_len = line_len;
3617
3618 i++;
3619 }
3620
3621 for (uint j = i; j < innerloop_left; j++)
3622 {
3623 device_param->combs_buf[j].i[0] = 0;
3624 device_param->combs_buf[j].i[1] = 0;
3625 device_param->combs_buf[j].i[2] = 0;
3626 device_param->combs_buf[j].i[3] = 0;
3627 device_param->combs_buf[j].i[4] = 0;
3628 device_param->combs_buf[j].i[5] = 0;
3629 device_param->combs_buf[j].i[6] = 0;
3630 device_param->combs_buf[j].i[7] = 0;
3631
3632 device_param->combs_buf[j].pw_len = 0;
3633 }
3634
3635 innerloop_left = i;
3636 }
3637 else if (data.attack_mode == ATTACK_MODE_BF)
3638 {
3639 u64 off = innerloop_pos;
3640
3641 device_param->kernel_params_mp_r_buf64[3] = off;
3642
3643 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3644 }
3645 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3646 {
3647 u64 off = innerloop_pos;
3648
3649 device_param->kernel_params_mp_buf64[3] = off;
3650
3651 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3652 }
3653 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3654 {
3655 u64 off = innerloop_pos;
3656
3657 device_param->kernel_params_mp_buf64[3] = off;
3658
3659 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3660 }
3661
3662 // copy amplifiers
3663
3664 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3665 {
3666 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
3667 }
3668 else if (data.attack_mode == ATTACK_MODE_COMBI)
3669 {
3670 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
3671 }
3672 else if (data.attack_mode == ATTACK_MODE_BF)
3673 {
3674 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
3675 }
3676 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3677 {
3678 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3679 }
3680 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3681 {
3682 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3683 }
3684
3685 if (data.benchmark == 1)
3686 {
3687 hc_timer_set (&device_param->timer_speed);
3688 }
3689
3690 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
3691
3692 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3693
3694 if (data.devices_status == STATUS_CRACKED) break;
3695 if (data.devices_status == STATUS_ABORTED) break;
3696 if (data.devices_status == STATUS_QUIT) break;
3697
3698 /**
3699 * result
3700 */
3701
3702 if (data.benchmark == 0)
3703 {
3704 check_cracked (device_param, salt_pos);
3705 }
3706
3707 /**
3708 * progress
3709 */
3710
3711 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3712
3713 hc_thread_mutex_lock (mux_counter);
3714
3715 data.words_progress_done[salt_pos] += perf_sum_all;
3716
3717 hc_thread_mutex_unlock (mux_counter);
3718
3719 /**
3720 * speed
3721 */
3722
3723 double speed_ms;
3724
3725 hc_timer_get (device_param->timer_speed, speed_ms);
3726
3727 hc_timer_set (&device_param->timer_speed);
3728
3729 // current speed
3730
3731 //hc_thread_mutex_lock (mux_display);
3732
3733 device_param->speed_cnt[speed_pos] = perf_sum_all;
3734
3735 device_param->speed_ms[speed_pos] = speed_ms;
3736
3737 //hc_thread_mutex_unlock (mux_display);
3738
3739 speed_pos++;
3740
3741 if (speed_pos == SPEED_CACHE)
3742 {
3743 speed_pos = 0;
3744 }
3745
3746 /**
3747 * benchmark
3748 */
3749
3750 if (data.benchmark == 1) break;
3751 }
3752 }
3753
3754 device_param->speed_pos = speed_pos;
3755
3756 myfree (line_buf);
3757 }
3758
3759 static void load_segment (wl_data_t *wl_data, FILE *fd)
3760 {
3761 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3762
3763 wl_data->pos = 0;
3764
3765 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3766
3767 wl_data->buf[wl_data->cnt] = 0;
3768
3769 if (wl_data->cnt == 0) return;
3770
3771 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3772
3773 while (!feof (fd))
3774 {
3775 if (wl_data->cnt == wl_data->avail)
3776 {
3777 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3778
3779 wl_data->avail += wl_data->incr;
3780 }
3781
3782 const int c = fgetc (fd);
3783
3784 if (c == EOF) break;
3785
3786 wl_data->buf[wl_data->cnt] = (char) c;
3787
3788 wl_data->cnt++;
3789
3790 if (c == '\n') break;
3791 }
3792
3793 // ensure stream ends with a newline
3794
3795 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3796 {
3797 wl_data->cnt++;
3798
3799 wl_data->buf[wl_data->cnt - 1] = '\n';
3800 }
3801
3802 return;
3803 }
3804
3805 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3806 {
3807 char *ptr = buf;
3808
3809 for (u32 i = 0; i < sz; i++, ptr++)
3810 {
3811 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3812
3813 if (i == 7)
3814 {
3815 *off = i;
3816 *len = i;
3817
3818 return;
3819 }
3820
3821 if (*ptr != '\n') continue;
3822
3823 *off = i + 1;
3824
3825 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3826
3827 *len = i;
3828
3829 return;
3830 }
3831
3832 *off = sz;
3833 *len = sz;
3834 }
3835
3836 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3837 {
3838 char *ptr = buf;
3839
3840 for (u32 i = 0; i < sz; i++, ptr++)
3841 {
3842 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3843
3844 if (*ptr != '\n') continue;
3845
3846 *off = i + 1;
3847
3848 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3849
3850 *len = i;
3851
3852 return;
3853 }
3854
3855 *off = sz;
3856 *len = sz;
3857 }
3858
3859 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3860 {
3861 char *ptr = buf;
3862
3863 for (u32 i = 0; i < sz; i++, ptr++)
3864 {
3865 if (*ptr != '\n') continue;
3866
3867 *off = i + 1;
3868
3869 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3870
3871 *len = i;
3872
3873 return;
3874 }
3875
3876 *off = sz;
3877 *len = sz;
3878 }
3879
3880 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3881 {
3882 while (wl_data->pos < wl_data->cnt)
3883 {
3884 uint off;
3885 uint len;
3886
3887 char *ptr = wl_data->buf + wl_data->pos;
3888
3889 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3890
3891 wl_data->pos += off;
3892
3893 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3894 {
3895 char rule_buf_out[BLOCK_SIZE] = { 0 };
3896
3897 int rule_len_out = -1;
3898
3899 if (len < BLOCK_SIZE)
3900 {
3901 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3902 }
3903
3904 if (rule_len_out < 0)
3905 {
3906 continue;
3907 }
3908
3909 if (rule_len_out > PW_MAX)
3910 {
3911 continue;
3912 }
3913 }
3914 else
3915 {
3916 if (len > PW_MAX)
3917 {
3918 continue;
3919 }
3920 }
3921
3922 *out_buf = ptr;
3923 *out_len = len;
3924
3925 return;
3926 }
3927
3928 if (feof (fd))
3929 {
3930 fprintf (stderr, "BUG feof()!!\n");
3931
3932 return;
3933 }
3934
3935 load_segment (wl_data, fd);
3936
3937 get_next_word (wl_data, fd, out_buf, out_len);
3938 }
3939
3940 #ifdef _POSIX
3941 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3942 #endif
3943
3944 #ifdef _WIN
3945 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3946 #endif
3947 {
3948 hc_signal (NULL);
3949
3950 dictstat_t d;
3951
3952 d.cnt = 0;
3953
3954 #ifdef _POSIX
3955 fstat (fileno (fd), &d.stat);
3956 #endif
3957
3958 #ifdef _WIN
3959 _fstat64 (fileno (fd), &d.stat);
3960 #endif
3961
3962 d.stat.st_mode = 0;
3963 d.stat.st_nlink = 0;
3964 d.stat.st_uid = 0;
3965 d.stat.st_gid = 0;
3966 d.stat.st_rdev = 0;
3967 d.stat.st_atime = 0;
3968
3969 #ifdef _POSIX
3970 d.stat.st_blksize = 0;
3971 d.stat.st_blocks = 0;
3972 #endif
3973
3974 if (d.stat.st_size == 0) return 0;
3975
3976 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3977
3978 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3979 {
3980 if (d_cache)
3981 {
3982 u64 cnt = d_cache->cnt;
3983
3984 u64 keyspace = cnt;
3985
3986 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3987 {
3988 keyspace *= data.kernel_rules_cnt;
3989 }
3990 else if (data.attack_kern == ATTACK_KERN_COMBI)
3991 {
3992 keyspace *= data.combs_cnt;
3993 }
3994
3995 if (data.quiet == 0) log_info ("Cache-hit dictionary stats %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) d.stat.st_size, (unsigned long long int) cnt, (unsigned long long int) keyspace);
3996 if (data.quiet == 0) log_info ("");
3997
3998 hc_signal (sigHandler_default);
3999
4000 return (keyspace);
4001 }
4002 }
4003
4004 time_t now = 0;
4005 time_t prev = 0;
4006
4007 u64 comp = 0;
4008 u64 cnt = 0;
4009 u64 cnt2 = 0;
4010
4011 while (!feof (fd))
4012 {
4013 load_segment (wl_data, fd);
4014
4015 comp += wl_data->cnt;
4016
4017 u32 i = 0;
4018
4019 while (i < wl_data->cnt)
4020 {
4021 u32 len;
4022 u32 off;
4023
4024 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
4025
4026 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4027 {
4028 char rule_buf_out[BLOCK_SIZE] = { 0 };
4029
4030 int rule_len_out = -1;
4031
4032 if (len < BLOCK_SIZE)
4033 {
4034 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
4035 }
4036
4037 if (rule_len_out < 0)
4038 {
4039 len = PW_MAX1;
4040 }
4041 else
4042 {
4043 len = rule_len_out;
4044 }
4045 }
4046
4047 if (len < PW_MAX1)
4048 {
4049 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4050 {
4051 cnt += data.kernel_rules_cnt;
4052 }
4053 else if (data.attack_kern == ATTACK_KERN_COMBI)
4054 {
4055 cnt += data.combs_cnt;
4056 }
4057
4058 d.cnt++;
4059 }
4060
4061 i += off;
4062
4063 cnt2++;
4064 }
4065
4066 time (&now);
4067
4068 if ((now - prev) == 0) continue;
4069
4070 float percent = (float) comp / (float) d.stat.st_size;
4071
4072 if (data.quiet == 0) log_info_nn ("Generating dictionary stats for %s: %llu bytes (%.2f%%), %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, percent * 100, (unsigned long long int) cnt2, (unsigned long long int) cnt);
4073
4074 time (&prev);
4075 }
4076
4077 if (data.quiet == 0) log_info ("Generated dictionary stats for %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, (unsigned long long int) cnt2, (unsigned long long int) cnt);
4078 if (data.quiet == 0) log_info ("");
4079
4080 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4081
4082 hc_signal (sigHandler_default);
4083
4084 return (cnt);
4085 }
4086
4087 static void *thread_monitor (void *p)
4088 {
4089 uint runtime_check = 0;
4090 uint remove_check = 0;
4091 uint status_check = 0;
4092 uint restore_check = 0;
4093
4094 uint restore_left = data.restore_timer;
4095 uint remove_left = data.remove_timer;
4096 uint status_left = data.status_timer;
4097
4098 #ifdef HAVE_HWMON
4099 uint hwmon_check = 0;
4100
4101 int slowdown_warnings = 0;
4102
4103 // these variables are mainly used for fan control
4104
4105 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4106
4107 // temperature controller "loopback" values
4108
4109 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4110 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4111
4112 int temp_threshold = 1; // degrees celcius
4113
4114 int fan_speed_min = 15; // in percentage
4115 int fan_speed_max = 100;
4116
4117 time_t last_temp_check_time;
4118 #endif // HAVE_HWMON
4119
4120 uint sleep_time = 1;
4121
4122 if (data.runtime)
4123 {
4124 runtime_check = 1;
4125 }
4126
4127 if (data.restore_timer)
4128 {
4129 restore_check = 1;
4130 }
4131
4132 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4133 {
4134 remove_check = 1;
4135 }
4136
4137 if (data.status == 1)
4138 {
4139 status_check = 1;
4140 }
4141
4142 #ifdef HAVE_HWMON
4143 if (data.gpu_temp_disable == 0)
4144 {
4145 time (&last_temp_check_time);
4146
4147 hwmon_check = 1;
4148 }
4149 #endif
4150
4151 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4152 {
4153 #ifdef HAVE_HWMON
4154 if (hwmon_check == 0)
4155 #endif
4156 return (p);
4157 }
4158
4159 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4160 {
4161 hc_sleep (sleep_time);
4162
4163 if (data.devices_status != STATUS_RUNNING) continue;
4164
4165 #ifdef HAVE_HWMON
4166
4167 if (hwmon_check == 1)
4168 {
4169 hc_thread_mutex_lock (mux_adl);
4170
4171 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4172 {
4173 hc_device_param_t *device_param = &data.devices_param[device_id];
4174
4175 if (device_param->skipped) continue;
4176
4177 if (device_param->device_vendor_id == VENDOR_ID_NV)
4178 {
4179 if (data.hm_nvapi)
4180 {
4181 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
4182 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
4183
4184 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4185 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4186
4187 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4188
4189 perfPolicies_status.info_value = perfPolicies_info.info_value;
4190
4191 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4192
4193 if (perfPolicies_status.throttle & 2)
4194 {
4195 if (slowdown_warnings < 3)
4196 {
4197 if (data.quiet == 0) clear_prompt ();
4198
4199 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4200
4201 if (slowdown_warnings == 2)
4202 {
4203 log_info ("");
4204 }
4205
4206 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4207 if (data.quiet == 0) fflush (stdout);
4208
4209 slowdown_warnings++;
4210 }
4211 }
4212 else
4213 {
4214 slowdown_warnings = 0;
4215 }
4216 }
4217 }
4218 }
4219
4220 hc_thread_mutex_unlock (mux_adl);
4221 }
4222
4223 if (hwmon_check == 1)
4224 {
4225 hc_thread_mutex_lock (mux_adl);
4226
4227 time_t temp_check_time;
4228
4229 time (&temp_check_time);
4230
4231 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4232
4233 if (Ta == 0) Ta = 1;
4234
4235 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4236 {
4237 hc_device_param_t *device_param = &data.devices_param[device_id];
4238
4239 if (device_param->skipped) continue;
4240
4241 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4242
4243 const int temperature = hm_get_temperature_with_device_id (device_id);
4244
4245 if (temperature > (int) data.gpu_temp_abort)
4246 {
4247 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4248
4249 if (data.devices_status != STATUS_QUIT) myabort ();
4250
4251 break;
4252 }
4253
4254 const int gpu_temp_retain = data.gpu_temp_retain;
4255
4256 if (gpu_temp_retain)
4257 {
4258 if (data.hm_device[device_id].fan_set_supported == 1)
4259 {
4260 int temp_cur = temperature;
4261
4262 int temp_diff_new = gpu_temp_retain - temp_cur;
4263
4264 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4265
4266 // calculate Ta value (time difference in seconds between the last check and this check)
4267
4268 last_temp_check_time = temp_check_time;
4269
4270 float Kp = 1.8;
4271 float Ki = 0.005;
4272 float Kd = 6;
4273
4274 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4275
4276 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[device_id] + Kd * ((float)(temp_diff_new - temp_diff_old[device_id])) / Ta);
4277
4278 if (abs (fan_diff_required) >= temp_threshold)
4279 {
4280 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4281
4282 int fan_speed_level = fan_speed_cur;
4283
4284 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4285
4286 int fan_speed_new = fan_speed_level - fan_diff_required;
4287
4288 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4289 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4290
4291 if (fan_speed_new != fan_speed_cur)
4292 {
4293 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4294 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4295
4296 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4297 {
4298 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4299 {
4300 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4301 }
4302 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4303 {
4304 #ifdef WIN
4305 hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1);
4306 #endif
4307
4308 #ifdef LINUX
4309 hm_set_fanspeed_with_device_id_xnvctrl (device_id, fan_speed_new);
4310 #endif
4311 }
4312
4313 fan_speed_chgd[device_id] = 1;
4314 }
4315
4316 temp_diff_old[device_id] = temp_diff_new;
4317 }
4318 }
4319 }
4320 }
4321 }
4322
4323 hc_thread_mutex_unlock (mux_adl);
4324 }
4325 #endif // HAVE_HWMON
4326
4327 if (restore_check == 1)
4328 {
4329 restore_left--;
4330
4331 if (restore_left == 0)
4332 {
4333 if (data.restore_disable == 0) cycle_restore ();
4334
4335 restore_left = data.restore_timer;
4336 }
4337 }
4338
4339 if ((runtime_check == 1) && (data.runtime_start > 0))
4340 {
4341 time_t runtime_cur;
4342
4343 time (&runtime_cur);
4344
4345 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4346
4347 if (runtime_left <= 0)
4348 {
4349 if (data.benchmark == 0)
4350 {
4351 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4352 }
4353
4354 if (data.devices_status != STATUS_QUIT) myabort ();
4355 }
4356 }
4357
4358 if (remove_check == 1)
4359 {
4360 remove_left--;
4361
4362 if (remove_left == 0)
4363 {
4364 if (data.digests_saved != data.digests_done)
4365 {
4366 data.digests_saved = data.digests_done;
4367
4368 save_hash ();
4369 }
4370
4371 remove_left = data.remove_timer;
4372 }
4373 }
4374
4375 if (status_check == 1)
4376 {
4377 status_left--;
4378
4379 if (status_left == 0)
4380 {
4381 //hc_thread_mutex_lock (mux_display);
4382
4383 if (data.quiet == 0) clear_prompt ();
4384
4385 if (data.quiet == 0) log_info ("");
4386
4387 status_display ();
4388
4389 if (data.quiet == 0) log_info ("");
4390
4391 //hc_thread_mutex_unlock (mux_display);
4392
4393 status_left = data.status_timer;
4394 }
4395 }
4396 }
4397
4398 #ifdef HAVE_HWMON
4399 myfree (fan_speed_chgd);
4400
4401 myfree (temp_diff_old);
4402 myfree (temp_diff_sum);
4403 #endif
4404
4405 p = NULL;
4406
4407 return (p);
4408 }
4409
4410 static void *thread_outfile_remove (void *p)
4411 {
4412 // some hash-dependent constants
4413 char *outfile_dir = data.outfile_check_directory;
4414 uint dgst_size = data.dgst_size;
4415 uint isSalted = data.isSalted;
4416 uint esalt_size = data.esalt_size;
4417 uint hash_mode = data.hash_mode;
4418
4419 uint outfile_check_timer = data.outfile_check_timer;
4420
4421 char separator = data.separator;
4422
4423 // some hash-dependent functions
4424 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4425 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4426
4427 // buffers
4428 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4429
4430 hash_buf.digest = mymalloc (dgst_size);
4431
4432 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4433
4434 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4435
4436 uint digest_buf[64] = { 0 };
4437
4438 outfile_data_t *out_info = NULL;
4439
4440 char **out_files = NULL;
4441
4442 time_t folder_mtime = 0;
4443
4444 int out_cnt = 0;
4445
4446 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4447
4448 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4449 {
4450 hc_sleep (1);
4451
4452 if (data.devices_status != STATUS_RUNNING) continue;
4453
4454 check_left--;
4455
4456 if (check_left == 0)
4457 {
4458 struct stat outfile_check_stat;
4459
4460 if (stat (outfile_dir, &outfile_check_stat) == 0)
4461 {
4462 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4463
4464 if (is_dir == 1)
4465 {
4466 if (outfile_check_stat.st_mtime > folder_mtime)
4467 {
4468 char **out_files_new = scan_directory (outfile_dir);
4469
4470 int out_cnt_new = count_dictionaries (out_files_new);
4471
4472 outfile_data_t *out_info_new = NULL;
4473
4474 if (out_cnt_new > 0)
4475 {
4476 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4477
4478 for (int i = 0; i < out_cnt_new; i++)
4479 {
4480 out_info_new[i].file_name = out_files_new[i];
4481
4482 // check if there are files that we have seen/checked before (and not changed)
4483
4484 for (int j = 0; j < out_cnt; j++)
4485 {
4486 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4487 {
4488 struct stat outfile_stat;
4489
4490 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4491 {
4492 if (outfile_stat.st_ctime == out_info[j].ctime)
4493 {
4494 out_info_new[i].ctime = out_info[j].ctime;
4495 out_info_new[i].seek = out_info[j].seek;
4496 }
4497 }
4498 }
4499 }
4500 }
4501 }
4502
4503 local_free (out_info);
4504 local_free (out_files);
4505
4506 out_files = out_files_new;
4507 out_cnt = out_cnt_new;
4508 out_info = out_info_new;
4509
4510 folder_mtime = outfile_check_stat.st_mtime;
4511 }
4512
4513 for (int j = 0; j < out_cnt; j++)
4514 {
4515 FILE *fp = fopen (out_info[j].file_name, "rb");
4516
4517 if (fp != NULL)
4518 {
4519 //hc_thread_mutex_lock (mux_display);
4520
4521 #ifdef _POSIX
4522 struct stat outfile_stat;
4523
4524 fstat (fileno (fp), &outfile_stat);
4525 #endif
4526
4527 #ifdef _WIN
4528 struct stat64 outfile_stat;
4529
4530 _fstat64 (fileno (fp), &outfile_stat);
4531 #endif
4532
4533 if (outfile_stat.st_ctime > out_info[j].ctime)
4534 {
4535 out_info[j].ctime = outfile_stat.st_ctime;
4536 out_info[j].seek = 0;
4537 }
4538
4539 fseek (fp, out_info[j].seek, SEEK_SET);
4540
4541 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4542
4543 while (!feof (fp))
4544 {
4545 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4546
4547 if (ptr == NULL) break;
4548
4549 int line_len = strlen (line_buf);
4550
4551 if (line_len <= 0) continue;
4552
4553 int iter = MAX_CUT_TRIES;
4554
4555 for (uint i = line_len - 1; i && iter; i--, line_len--)
4556 {
4557 if (line_buf[i] != separator) continue;
4558
4559 int parser_status = PARSER_OK;
4560
4561 if ((hash_mode != 2500) && (hash_mode != 6800))
4562 {
4563 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4564 }
4565
4566 uint found = 0;
4567
4568 if (parser_status == PARSER_OK)
4569 {
4570 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4571 {
4572 if (data.salts_shown[salt_pos] == 1) continue;
4573
4574 salt_t *salt_buf = &data.salts_buf[salt_pos];
4575
4576 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4577 {
4578 uint idx = salt_buf->digests_offset + digest_pos;
4579
4580 if (data.digests_shown[idx] == 1) continue;
4581
4582 uint cracked = 0;
4583
4584 if (hash_mode == 6800)
4585 {
4586 if (i == salt_buf->salt_len)
4587 {
4588 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4589 }
4590 }
4591 else if (hash_mode == 2500)
4592 {
4593 // BSSID : MAC1 : MAC2 (:plain)
4594 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4595 {
4596 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4597
4598 if (!cracked) continue;
4599
4600 // now compare MAC1 and MAC2 too, since we have this additional info
4601 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4602 char *mac2_pos = mac1_pos + 12 + 1;
4603
4604 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4605 wpa_t *wpa = &wpas[salt_pos];
4606
4607 // compare hex string(s) vs binary MAC address(es)
4608
4609 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4610 {
4611 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4612 {
4613 cracked = 0;
4614
4615 break;
4616 }
4617 }
4618
4619 // early skip ;)
4620 if (!cracked) continue;
4621
4622 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4623 {
4624 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4625 {
4626 cracked = 0;
4627
4628 break;
4629 }
4630 }
4631 }
4632 }
4633 else
4634 {
4635 char *digests_buf_ptr = (char *) data.digests_buf;
4636
4637 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4638
4639 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4640 }
4641
4642 if (cracked == 1)
4643 {
4644 found = 1;
4645
4646 data.digests_shown[idx] = 1;
4647
4648 data.digests_done++;
4649
4650 salt_buf->digests_done++;
4651
4652 if (salt_buf->digests_done == salt_buf->digests_cnt)
4653 {
4654 data.salts_shown[salt_pos] = 1;
4655
4656 data.salts_done++;
4657
4658 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4659 }
4660 }
4661 }
4662
4663 if (data.devices_status == STATUS_CRACKED) break;
4664 }
4665 }
4666
4667 if (found) break;
4668
4669 if (data.devices_status == STATUS_CRACKED) break;
4670
4671 iter--;
4672 }
4673
4674 if (data.devices_status == STATUS_CRACKED) break;
4675 }
4676
4677 myfree (line_buf);
4678
4679 out_info[j].seek = ftell (fp);
4680
4681 //hc_thread_mutex_unlock (mux_display);
4682
4683 fclose (fp);
4684 }
4685 }
4686 }
4687 }
4688
4689 check_left = outfile_check_timer;
4690 }
4691 }
4692
4693 if (esalt_size) local_free (hash_buf.esalt);
4694
4695 if (isSalted) local_free (hash_buf.salt);
4696
4697 local_free (hash_buf.digest);
4698
4699 local_free (out_info);
4700
4701 local_free (out_files);
4702
4703 p = NULL;
4704
4705 return (p);
4706 }
4707
4708 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4709 {
4710 //if (device_param->pws_cnt < device_param->kernel_power)
4711 //{
4712 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4713
4714 u8 *ptr = (u8 *) pw->i;
4715
4716 memcpy (ptr, pw_buf, pw_len);
4717
4718 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4719
4720 pw->pw_len = pw_len;
4721
4722 device_param->pws_cnt++;
4723 //}
4724 //else
4725 //{
4726 // fprintf (stderr, "BUG pw_add()!!\n");
4727 //
4728 // return;
4729 //}
4730 }
4731
4732 static void set_kernel_power_final (const u64 kernel_power_final)
4733 {
4734 if (data.quiet == 0)
4735 {
4736 clear_prompt ();
4737
4738 //log_info ("");
4739
4740 log_info ("INFO: approaching final keyspace, workload adjusted");
4741 log_info ("");
4742
4743 fprintf (stdout, "%s", PROMPT);
4744
4745 fflush (stdout);
4746 }
4747
4748 data.kernel_power_final = kernel_power_final;
4749 }
4750
4751 static u32 get_power (hc_device_param_t *device_param)
4752 {
4753 const u64 kernel_power_final = data.kernel_power_final;
4754
4755 if (kernel_power_final)
4756 {
4757 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4758
4759 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4760
4761 // work should be at least the hardware power available without any accelerator
4762
4763 const u64 work = MAX (words_left_device, device_param->hardware_power);
4764
4765 return work;
4766 }
4767
4768 return device_param->kernel_power;
4769 }
4770
4771 static uint get_work (hc_device_param_t *device_param, const u64 max)
4772 {
4773 hc_thread_mutex_lock (mux_dispatcher);
4774
4775 const u64 words_cur = data.words_cur;
4776 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4777
4778 device_param->words_off = words_cur;
4779
4780 const u64 kernel_power_all = data.kernel_power_all;
4781
4782 const u64 words_left = words_base - words_cur;
4783
4784 if (words_left < kernel_power_all)
4785 {
4786 if (data.kernel_power_final == 0)
4787 {
4788 set_kernel_power_final (words_left);
4789 }
4790 }
4791
4792 const u32 kernel_power = get_power (device_param);
4793
4794 uint work = MIN (words_left, kernel_power);
4795
4796 work = MIN (work, max);
4797
4798 data.words_cur += work;
4799
4800 hc_thread_mutex_unlock (mux_dispatcher);
4801
4802 return work;
4803 }
4804
4805 static void *thread_autotune (void *p)
4806 {
4807 hc_device_param_t *device_param = (hc_device_param_t *) p;
4808
4809 if (device_param->skipped) return NULL;
4810
4811 autotune (device_param);
4812
4813 return NULL;
4814 }
4815
4816 static void *thread_calc_stdin (void *p)
4817 {
4818 hc_device_param_t *device_param = (hc_device_param_t *) p;
4819
4820 if (device_param->skipped) return NULL;
4821
4822 char *buf = (char *) mymalloc (HCBUFSIZ);
4823
4824 const uint attack_kern = data.attack_kern;
4825
4826 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4827 {
4828 hc_thread_mutex_lock (mux_dispatcher);
4829
4830 if (feof (stdin) != 0)
4831 {
4832 hc_thread_mutex_unlock (mux_dispatcher);
4833
4834 break;
4835 }
4836
4837 uint words_cur = 0;
4838
4839 while (words_cur < device_param->kernel_power)
4840 {
4841 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4842
4843 if (line_buf == NULL) break;
4844
4845 uint line_len = in_superchop (line_buf);
4846
4847 line_len = convert_from_hex (line_buf, line_len);
4848
4849 // post-process rule engine
4850
4851 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4852 {
4853 char rule_buf_out[BLOCK_SIZE] = { 0 };
4854
4855 int rule_len_out = -1;
4856
4857 if (line_len < BLOCK_SIZE)
4858 {
4859 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4860 }
4861
4862 if (rule_len_out < 0) continue;
4863
4864 line_buf = rule_buf_out;
4865 line_len = rule_len_out;
4866 }
4867
4868 if (line_len > PW_MAX)
4869 {
4870 continue;
4871 }
4872
4873 // hmm that's always the case, or?
4874
4875 if (attack_kern == ATTACK_KERN_STRAIGHT)
4876 {
4877 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4878 {
4879 hc_thread_mutex_lock (mux_counter);
4880
4881 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4882 {
4883 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4884 }
4885
4886 hc_thread_mutex_unlock (mux_counter);
4887
4888 continue;
4889 }
4890 }
4891
4892 pw_add (device_param, (u8 *) line_buf, line_len);
4893
4894 words_cur++;
4895
4896 if (data.devices_status == STATUS_CRACKED) break;
4897 if (data.devices_status == STATUS_ABORTED) break;
4898 if (data.devices_status == STATUS_QUIT) break;
4899 if (data.devices_status == STATUS_BYPASS) break;
4900 }
4901
4902 hc_thread_mutex_unlock (mux_dispatcher);
4903
4904 if (data.devices_status == STATUS_CRACKED) break;
4905 if (data.devices_status == STATUS_ABORTED) break;
4906 if (data.devices_status == STATUS_QUIT) break;
4907 if (data.devices_status == STATUS_BYPASS) break;
4908
4909 // flush
4910
4911 const uint pws_cnt = device_param->pws_cnt;
4912
4913 if (pws_cnt)
4914 {
4915 run_copy (device_param, pws_cnt);
4916
4917 run_cracker (device_param, pws_cnt);
4918
4919 device_param->pws_cnt = 0;
4920
4921 /*
4922 still required?
4923 if (attack_kern == ATTACK_KERN_STRAIGHT)
4924 {
4925 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4926 }
4927 else if (attack_kern == ATTACK_KERN_COMBI)
4928 {
4929 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4930 }
4931 */
4932 }
4933 }
4934
4935 device_param->kernel_accel = 0;
4936 device_param->kernel_loops = 0;
4937
4938 myfree (buf);
4939
4940 return NULL;
4941 }
4942
4943 static void *thread_calc (void *p)
4944 {
4945 hc_device_param_t *device_param = (hc_device_param_t *) p;
4946
4947 if (device_param->skipped) return NULL;
4948
4949 const uint attack_mode = data.attack_mode;
4950 const uint attack_kern = data.attack_kern;
4951
4952 if (attack_mode == ATTACK_MODE_BF)
4953 {
4954 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4955 {
4956 const uint work = get_work (device_param, -1);
4957
4958 if (work == 0) break;
4959
4960 const u64 words_off = device_param->words_off;
4961 const u64 words_fin = words_off + work;
4962
4963 const uint pws_cnt = work;
4964
4965 device_param->pws_cnt = pws_cnt;
4966
4967 if (pws_cnt)
4968 {
4969 run_copy (device_param, pws_cnt);
4970
4971 run_cracker (device_param, pws_cnt);
4972
4973 device_param->pws_cnt = 0;
4974
4975 /*
4976 still required?
4977 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4978 */
4979 }
4980
4981 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4982
4983 if (data.devices_status == STATUS_CRACKED) break;
4984 if (data.devices_status == STATUS_ABORTED) break;
4985 if (data.devices_status == STATUS_QUIT) break;
4986 if (data.devices_status == STATUS_BYPASS) break;
4987
4988 if (data.benchmark == 1) break;
4989
4990 device_param->words_done = words_fin;
4991 }
4992 }
4993 else
4994 {
4995 const uint segment_size = data.segment_size;
4996
4997 char *dictfile = data.dictfile;
4998
4999 if (attack_mode == ATTACK_MODE_COMBI)
5000 {
5001 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5002 {
5003 dictfile = data.dictfile2;
5004 }
5005 }
5006
5007 FILE *fd = fopen (dictfile, "rb");
5008
5009 if (fd == NULL)
5010 {
5011 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
5012
5013 return NULL;
5014 }
5015
5016 if (attack_mode == ATTACK_MODE_COMBI)
5017 {
5018 const uint combs_mode = data.combs_mode;
5019
5020 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
5021 {
5022 const char *dictfilec = data.dictfile2;
5023
5024 FILE *combs_fp = fopen (dictfilec, "rb");
5025
5026 if (combs_fp == NULL)
5027 {
5028 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5029
5030 fclose (fd);
5031
5032 return NULL;
5033 }
5034
5035 device_param->combs_fp = combs_fp;
5036 }
5037 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5038 {
5039 const char *dictfilec = data.dictfile;
5040
5041 FILE *combs_fp = fopen (dictfilec, "rb");
5042
5043 if (combs_fp == NULL)
5044 {
5045 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5046
5047 fclose (fd);
5048
5049 return NULL;
5050 }
5051
5052 device_param->combs_fp = combs_fp;
5053 }
5054 }
5055
5056 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
5057
5058 wl_data->buf = (char *) mymalloc (segment_size);
5059 wl_data->avail = segment_size;
5060 wl_data->incr = segment_size;
5061 wl_data->cnt = 0;
5062 wl_data->pos = 0;
5063
5064 u64 words_cur = 0;
5065
5066 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5067 {
5068 u64 words_off = 0;
5069 u64 words_fin = 0;
5070
5071 u64 max = -1;
5072
5073 while (max)
5074 {
5075 const uint work = get_work (device_param, max);
5076
5077 if (work == 0) break;
5078
5079 max = 0;
5080
5081 words_off = device_param->words_off;
5082 words_fin = words_off + work;
5083
5084 char *line_buf;
5085 uint line_len;
5086
5087 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5088
5089 for ( ; words_cur < words_fin; words_cur++)
5090 {
5091 get_next_word (wl_data, fd, &line_buf, &line_len);
5092
5093 line_len = convert_from_hex (line_buf, line_len);
5094
5095 // post-process rule engine
5096
5097 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5098 {
5099 char rule_buf_out[BLOCK_SIZE] = { 0 };
5100
5101 int rule_len_out = -1;
5102
5103 if (line_len < BLOCK_SIZE)
5104 {
5105 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5106 }
5107
5108 if (rule_len_out < 0) continue;
5109
5110 line_buf = rule_buf_out;
5111 line_len = rule_len_out;
5112 }
5113
5114 if (attack_kern == ATTACK_KERN_STRAIGHT)
5115 {
5116 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5117 {
5118 max++;
5119
5120 hc_thread_mutex_lock (mux_counter);
5121
5122 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5123 {
5124 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5125 }
5126
5127 hc_thread_mutex_unlock (mux_counter);
5128
5129 continue;
5130 }
5131 }
5132 else if (attack_kern == ATTACK_KERN_COMBI)
5133 {
5134 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5135 // since we still need to combine the plains
5136
5137 if (line_len > data.pw_max)
5138 {
5139 max++;
5140
5141 hc_thread_mutex_lock (mux_counter);
5142
5143 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5144 {
5145 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5146 }
5147
5148 hc_thread_mutex_unlock (mux_counter);
5149
5150 continue;
5151 }
5152 }
5153
5154 pw_add (device_param, (u8 *) line_buf, line_len);
5155
5156 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5157
5158 if (data.devices_status == STATUS_CRACKED) break;
5159 if (data.devices_status == STATUS_ABORTED) break;
5160 if (data.devices_status == STATUS_QUIT) break;
5161 if (data.devices_status == STATUS_BYPASS) break;
5162 }
5163
5164 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5165
5166 if (data.devices_status == STATUS_CRACKED) break;
5167 if (data.devices_status == STATUS_ABORTED) break;
5168 if (data.devices_status == STATUS_QUIT) break;
5169 if (data.devices_status == STATUS_BYPASS) break;
5170 }
5171
5172 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5173
5174 if (data.devices_status == STATUS_CRACKED) break;
5175 if (data.devices_status == STATUS_ABORTED) break;
5176 if (data.devices_status == STATUS_QUIT) break;
5177 if (data.devices_status == STATUS_BYPASS) break;
5178
5179 //
5180 // flush
5181 //
5182
5183 const uint pws_cnt = device_param->pws_cnt;
5184
5185 if (pws_cnt)
5186 {
5187 run_copy (device_param, pws_cnt);
5188
5189 run_cracker (device_param, pws_cnt);
5190
5191 device_param->pws_cnt = 0;
5192
5193 /*
5194 still required?
5195 if (attack_kern == ATTACK_KERN_STRAIGHT)
5196 {
5197 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5198 }
5199 else if (attack_kern == ATTACK_KERN_COMBI)
5200 {
5201 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5202 }
5203 */
5204 }
5205
5206 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5207
5208 if (data.devices_status == STATUS_CRACKED) break;
5209 if (data.devices_status == STATUS_ABORTED) break;
5210 if (data.devices_status == STATUS_QUIT) break;
5211 if (data.devices_status == STATUS_BYPASS) break;
5212
5213 if (words_fin == 0) break;
5214
5215 device_param->words_done = words_fin;
5216 }
5217
5218 if (attack_mode == ATTACK_MODE_COMBI)
5219 {
5220 fclose (device_param->combs_fp);
5221 }
5222
5223 free (wl_data->buf);
5224 free (wl_data);
5225
5226 fclose (fd);
5227 }
5228
5229 device_param->kernel_accel = 0;
5230 device_param->kernel_loops = 0;
5231
5232 return NULL;
5233 }
5234
5235 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5236 {
5237 if (!device_param)
5238 {
5239 log_error ("ERROR: %s : Invalid argument", __func__);
5240
5241 exit (-1);
5242 }
5243
5244 salt_t *salt_buf = &data.salts_buf[salt_pos];
5245
5246 device_param->kernel_params_buf32[24] = salt_pos;
5247 device_param->kernel_params_buf32[27] = 1;
5248 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
5249 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
5250 device_param->kernel_params_buf32[30] = 0;
5251 device_param->kernel_params_buf32[31] = 1;
5252
5253 char *dictfile_old = data.dictfile;
5254
5255 const char *weak_hash_check = "weak-hash-check";
5256
5257 data.dictfile = (char *) weak_hash_check;
5258
5259 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5260
5261 data.kernel_rules_buf[0].cmds[0] = 0;
5262
5263 /**
5264 * run the kernel
5265 */
5266
5267 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5268 {
5269 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5270 }
5271 else
5272 {
5273 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5274
5275 uint loop_step = 16;
5276
5277 const uint iter = salt_buf->salt_iter;
5278
5279 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5280 {
5281 uint loop_left = iter - loop_pos;
5282
5283 loop_left = MIN (loop_left, loop_step);
5284
5285 device_param->kernel_params_buf32[25] = loop_pos;
5286 device_param->kernel_params_buf32[26] = loop_left;
5287
5288 run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5289 }
5290
5291 run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5292 }
5293
5294 /**
5295 * result
5296 */
5297
5298 check_cracked (device_param, salt_pos);
5299
5300 /**
5301 * cleanup
5302 */
5303
5304 device_param->kernel_params_buf32[24] = 0;
5305 device_param->kernel_params_buf32[25] = 0;
5306 device_param->kernel_params_buf32[26] = 0;
5307 device_param->kernel_params_buf32[27] = 0;
5308 device_param->kernel_params_buf32[28] = 0;
5309 device_param->kernel_params_buf32[29] = 0;
5310 device_param->kernel_params_buf32[30] = 0;
5311 device_param->kernel_params_buf32[31] = 0;
5312
5313 data.dictfile = dictfile_old;
5314
5315 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5316 }
5317
5318 // hlfmt hashcat
5319
5320 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5321 {
5322 if (data.username == 0)
5323 {
5324 *hashbuf_pos = line_buf;
5325 *hashbuf_len = line_len;
5326 }
5327 else
5328 {
5329 char *pos = line_buf;
5330 int len = line_len;
5331
5332 for (int i = 0; i < line_len; i++, pos++, len--)
5333 {
5334 if (line_buf[i] == data.separator)
5335 {
5336 pos++;
5337
5338 len--;
5339
5340 break;
5341 }
5342 }
5343
5344 *hashbuf_pos = pos;
5345 *hashbuf_len = len;
5346 }
5347 }
5348
5349 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5350 {
5351 char *pos = NULL;
5352 int len = 0;
5353
5354 int sep_cnt = 0;
5355
5356 for (int i = 0; i < line_len; i++)
5357 {
5358 if (line_buf[i] == data.separator)
5359 {
5360 sep_cnt++;
5361
5362 continue;
5363 }
5364
5365 if (sep_cnt == 0)
5366 {
5367 if (pos == NULL) pos = line_buf + i;
5368
5369 len++;
5370 }
5371 }
5372
5373 *userbuf_pos = pos;
5374 *userbuf_len = len;
5375 }
5376
5377 // hlfmt pwdump
5378
5379 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5380 {
5381 int sep_cnt = 0;
5382
5383 int sep2_len = 0;
5384 int sep3_len = 0;
5385
5386 for (int i = 0; i < line_len; i++)
5387 {
5388 if (line_buf[i] == ':')
5389 {
5390 sep_cnt++;
5391
5392 continue;
5393 }
5394
5395 if (sep_cnt == 2) sep2_len++;
5396 if (sep_cnt == 3) sep3_len++;
5397 }
5398
5399 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5400
5401 return 0;
5402 }
5403
5404 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5405 {
5406 char *pos = NULL;
5407 int len = 0;
5408
5409 int sep_cnt = 0;
5410
5411 for (int i = 0; i < line_len; i++)
5412 {
5413 if (line_buf[i] == ':')
5414 {
5415 sep_cnt++;
5416
5417 continue;
5418 }
5419
5420 if (data.hash_mode == 1000)
5421 {
5422 if (sep_cnt == 3)
5423 {
5424 if (pos == NULL) pos = line_buf + i;
5425
5426 len++;
5427 }
5428 }
5429 else if (data.hash_mode == 3000)
5430 {
5431 if (sep_cnt == 2)
5432 {
5433 if (pos == NULL) pos = line_buf + i;
5434
5435 len++;
5436 }
5437 }
5438 }
5439
5440 *hashbuf_pos = pos;
5441 *hashbuf_len = len;
5442 }
5443
5444 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5445 {
5446 char *pos = NULL;
5447 int len = 0;
5448
5449 int sep_cnt = 0;
5450
5451 for (int i = 0; i < line_len; i++)
5452 {
5453 if (line_buf[i] == ':')
5454 {
5455 sep_cnt++;
5456
5457 continue;
5458 }
5459
5460 if (sep_cnt == 0)
5461 {
5462 if (pos == NULL) pos = line_buf + i;
5463
5464 len++;
5465 }
5466 }
5467
5468 *userbuf_pos = pos;
5469 *userbuf_len = len;
5470 }
5471
5472 // hlfmt passwd
5473
5474 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5475 {
5476 int sep_cnt = 0;
5477
5478 char sep5_first = 0;
5479 char sep6_first = 0;
5480
5481 for (int i = 0; i < line_len; i++)
5482 {
5483 if (line_buf[i] == ':')
5484 {
5485 sep_cnt++;
5486
5487 continue;
5488 }
5489
5490 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5491 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5492 }
5493
5494 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5495
5496 return 0;
5497 }
5498
5499 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5500 {
5501 char *pos = NULL;
5502 int len = 0;
5503
5504 int sep_cnt = 0;
5505
5506 for (int i = 0; i < line_len; i++)
5507 {
5508 if (line_buf[i] == ':')
5509 {
5510 sep_cnt++;
5511
5512 continue;
5513 }
5514
5515 if (sep_cnt == 1)
5516 {
5517 if (pos == NULL) pos = line_buf + i;
5518
5519 len++;
5520 }
5521 }
5522
5523 *hashbuf_pos = pos;
5524 *hashbuf_len = len;
5525 }
5526
5527 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5528 {
5529 char *pos = NULL;
5530 int len = 0;
5531
5532 int sep_cnt = 0;
5533
5534 for (int i = 0; i < line_len; i++)
5535 {
5536 if (line_buf[i] == ':')
5537 {
5538 sep_cnt++;
5539
5540 continue;
5541 }
5542
5543 if (sep_cnt == 0)
5544 {
5545 if (pos == NULL) pos = line_buf + i;
5546
5547 len++;
5548 }
5549 }
5550
5551 *userbuf_pos = pos;
5552 *userbuf_len = len;
5553 }
5554
5555 // hlfmt shadow
5556
5557 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5558 {
5559 int sep_cnt = 0;
5560
5561 for (int i = 0; i < line_len; i++)
5562 {
5563 if (line_buf[i] == ':') sep_cnt++;
5564 }
5565
5566 if (sep_cnt == 8) return 1;
5567
5568 return 0;
5569 }
5570
5571 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5572 {
5573 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5574 }
5575
5576 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5577 {
5578 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5579 }
5580
5581 // hlfmt main
5582
5583 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5584 {
5585 switch (hashfile_format)
5586 {
5587 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5588 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5589 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5590 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5591 }
5592 }
5593
5594 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5595 {
5596 switch (hashfile_format)
5597 {
5598 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5599 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5600 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5601 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5602 }
5603 }
5604
5605 char *strhlfmt (const uint hashfile_format)
5606 {
5607 switch (hashfile_format)
5608 {
5609 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5610 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5611 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5612 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5613 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5614 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5615 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5616 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5617 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5618 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5619 }
5620
5621 return ((char *) "Unknown");
5622 }
5623
5624 static uint hlfmt_detect (FILE *fp, uint max_check)
5625 {
5626 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5627
5628 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5629 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5630
5631 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5632
5633 uint num_check = 0;
5634
5635 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5636
5637 while (!feof (fp))
5638 {
5639 int line_len = fgetl (fp, line_buf);
5640
5641 if (line_len == 0) continue;
5642
5643 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5644 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5645 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5646
5647 if (num_check == max_check) break;
5648
5649 num_check++;
5650 }
5651
5652 myfree (line_buf);
5653
5654 uint hashlist_format = HLFMT_HASHCAT;
5655
5656 for (int i = 1; i < HLFMTS_CNT; i++)
5657 {
5658 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5659
5660 hashlist_format = i;
5661 }
5662
5663 free (formats_cnt);
5664
5665 return hashlist_format;
5666 }
5667
5668 /**
5669 * some further helper function
5670 */
5671
5672 // wrapper around mymalloc for ADL
5673
5674 #if defined(HAVE_HWMON)
5675 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5676 {
5677 return mymalloc (iSize);
5678 }
5679 #endif
5680
5681 static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, const uint dgst_shifts, char *digests_buf_ptr, const uint bitmap_mask, const uint bitmap_size, uint *bitmap_a, uint *bitmap_b, uint *bitmap_c, uint *bitmap_d, const u64 collisions_max)
5682 {
5683 u64 collisions = 0;
5684
5685 const uint dgst_pos0 = data.dgst_pos0;
5686 const uint dgst_pos1 = data.dgst_pos1;
5687 const uint dgst_pos2 = data.dgst_pos2;
5688 const uint dgst_pos3 = data.dgst_pos3;
5689
5690 memset (bitmap_a, 0, bitmap_size);
5691 memset (bitmap_b, 0, bitmap_size);
5692 memset (bitmap_c, 0, bitmap_size);
5693 memset (bitmap_d, 0, bitmap_size);
5694
5695 for (uint i = 0; i < digests_cnt; i++)
5696 {
5697 uint *digest_ptr = (uint *) digests_buf_ptr;
5698
5699 digests_buf_ptr += dgst_size;
5700
5701 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5702 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5703 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5704 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5705
5706 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5707 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5708 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5709 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5710
5711 if (bitmap_a[idx0] & val0) collisions++;
5712 if (bitmap_b[idx1] & val1) collisions++;
5713 if (bitmap_c[idx2] & val2) collisions++;
5714 if (bitmap_d[idx3] & val3) collisions++;
5715
5716 bitmap_a[idx0] |= val0;
5717 bitmap_b[idx1] |= val1;
5718 bitmap_c[idx2] |= val2;
5719 bitmap_d[idx3] |= val3;
5720
5721 if (collisions >= collisions_max) return 0x7fffffff;
5722 }
5723
5724 return collisions;
5725 }
5726
5727 /**
5728 * main
5729 */
5730
5731 #ifdef WIN
5732 void SetConsoleWindowSize (const int x)
5733 {
5734 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5735
5736 if (h == INVALID_HANDLE_VALUE) return;
5737
5738 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5739
5740 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5741
5742 SMALL_RECT *sr = &bufferInfo.srWindow;
5743
5744 sr->Right = MAX (sr->Right, x - 1);
5745
5746 COORD co;
5747
5748 co.X = sr->Right + 1;
5749 co.Y = 9999;
5750
5751 if (!SetConsoleScreenBufferSize (h, co)) return;
5752
5753 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5754 }
5755 #endif
5756
5757 int main (int argc, char **argv)
5758 {
5759 #ifdef WIN
5760 SetConsoleWindowSize (132);
5761 #endif
5762
5763 /**
5764 * To help users a bit
5765 */
5766
5767 char *compute = getenv ("COMPUTE");
5768
5769 if (compute)
5770 {
5771 static char display[100];
5772
5773 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5774
5775 putenv (display);
5776 }
5777 else
5778 {
5779 if (getenv ("DISPLAY") == NULL)
5780 putenv ((char *) "DISPLAY=:0");
5781 }
5782
5783 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5784 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5785
5786 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5787 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5788
5789 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5790 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5791
5792 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5793 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5794
5795 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5796 putenv ((char *) "POCL_KERNEL_CACHE=0");
5797
5798 umask (077);
5799
5800 /**
5801 * Real init
5802 */
5803
5804 memset (&data, 0, sizeof (hc_global_data_t));
5805
5806 time_t proc_start;
5807
5808 time (&proc_start);
5809
5810 data.proc_start = proc_start;
5811
5812 int myargc = argc;
5813 char **myargv = argv;
5814
5815 hc_thread_mutex_init (mux_dispatcher);
5816 hc_thread_mutex_init (mux_counter);
5817 hc_thread_mutex_init (mux_display);
5818 hc_thread_mutex_init (mux_adl);
5819
5820 /**
5821 * commandline parameters
5822 */
5823
5824 uint usage = USAGE;
5825 uint version = VERSION;
5826 uint quiet = QUIET;
5827 uint benchmark = BENCHMARK;
5828 uint stdout_flag = STDOUT_FLAG;
5829 uint show = SHOW;
5830 uint left = LEFT;
5831 uint username = USERNAME;
5832 uint remove = REMOVE;
5833 uint remove_timer = REMOVE_TIMER;
5834 u64 skip = SKIP;
5835 u64 limit = LIMIT;
5836 uint keyspace = KEYSPACE;
5837 uint potfile_disable = POTFILE_DISABLE;
5838 char *potfile_path = NULL;
5839 uint debug_mode = DEBUG_MODE;
5840 char *debug_file = NULL;
5841 char *induction_dir = NULL;
5842 char *outfile_check_dir = NULL;
5843 uint force = FORCE;
5844 uint runtime = RUNTIME;
5845 uint hash_mode = HASH_MODE;
5846 uint attack_mode = ATTACK_MODE;
5847 uint markov_disable = MARKOV_DISABLE;
5848 uint markov_classic = MARKOV_CLASSIC;
5849 uint markov_threshold = MARKOV_THRESHOLD;
5850 char *markov_hcstat = NULL;
5851 char *outfile = NULL;
5852 uint outfile_format = OUTFILE_FORMAT;
5853 uint outfile_autohex = OUTFILE_AUTOHEX;
5854 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5855 uint restore = RESTORE;
5856 uint restore_timer = RESTORE_TIMER;
5857 uint restore_disable = RESTORE_DISABLE;
5858 uint status = STATUS;
5859 uint status_timer = STATUS_TIMER;
5860 uint machine_readable = MACHINE_READABLE;
5861 uint loopback = LOOPBACK;
5862 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5863 char *session = NULL;
5864 uint hex_charset = HEX_CHARSET;
5865 uint hex_salt = HEX_SALT;
5866 uint hex_wordlist = HEX_WORDLIST;
5867 uint rp_gen = RP_GEN;
5868 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5869 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5870 uint rp_gen_seed = RP_GEN_SEED;
5871 char *rule_buf_l = (char *) RULE_BUF_L;
5872 char *rule_buf_r = (char *) RULE_BUF_R;
5873 uint increment = INCREMENT;
5874 uint increment_min = INCREMENT_MIN;
5875 uint increment_max = INCREMENT_MAX;
5876 char *cpu_affinity = NULL;
5877 OCL_PTR *ocl = NULL;
5878 char *opencl_devices = NULL;
5879 char *opencl_platforms = NULL;
5880 char *opencl_device_types = NULL;
5881 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5882 char *truecrypt_keyfiles = NULL;
5883 char *veracrypt_keyfiles = NULL;
5884 uint veracrypt_pim = 0;
5885 uint workload_profile = WORKLOAD_PROFILE;
5886 uint kernel_accel = KERNEL_ACCEL;
5887 uint kernel_loops = KERNEL_LOOPS;
5888 uint nvidia_spin_damp = NVIDIA_SPIN_DAMP;
5889 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5890 #ifdef HAVE_HWMON
5891 uint gpu_temp_abort = GPU_TEMP_ABORT;
5892 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5893 uint powertune_enable = POWERTUNE_ENABLE;
5894 #endif
5895 uint logfile_disable = LOGFILE_DISABLE;
5896 uint segment_size = SEGMENT_SIZE;
5897 uint scrypt_tmto = SCRYPT_TMTO;
5898 char separator = SEPARATOR;
5899 uint bitmap_min = BITMAP_MIN;
5900 uint bitmap_max = BITMAP_MAX;
5901 char *custom_charset_1 = NULL;
5902 char *custom_charset_2 = NULL;
5903 char *custom_charset_3 = NULL;
5904 char *custom_charset_4 = NULL;
5905
5906 #define IDX_HELP 'h'
5907 #define IDX_VERSION 'V'
5908 #define IDX_VERSION_LOWER 'v'
5909 #define IDX_QUIET 0xff02
5910 #define IDX_SHOW 0xff03
5911 #define IDX_LEFT 0xff04
5912 #define IDX_REMOVE 0xff05
5913 #define IDX_REMOVE_TIMER 0xff37
5914 #define IDX_SKIP 's'
5915 #define IDX_LIMIT 'l'
5916 #define IDX_KEYSPACE 0xff35
5917 #define IDX_POTFILE_DISABLE 0xff06
5918 #define IDX_POTFILE_PATH 0xffe0
5919 #define IDX_DEBUG_MODE 0xff43
5920 #define IDX_DEBUG_FILE 0xff44
5921 #define IDX_INDUCTION_DIR 0xff46
5922 #define IDX_OUTFILE_CHECK_DIR 0xff47
5923 #define IDX_USERNAME 0xff07
5924 #define IDX_FORCE 0xff08
5925 #define IDX_RUNTIME 0xff09
5926 #define IDX_BENCHMARK 'b'
5927 #define IDX_STDOUT_FLAG 0xff77
5928 #define IDX_HASH_MODE 'm'
5929 #define IDX_ATTACK_MODE 'a'
5930 #define IDX_RP_FILE 'r'
5931 #define IDX_RP_GEN 'g'
5932 #define IDX_RP_GEN_FUNC_MIN 0xff10
5933 #define IDX_RP_GEN_FUNC_MAX 0xff11
5934 #define IDX_RP_GEN_SEED 0xff34
5935 #define IDX_RULE_BUF_L 'j'
5936 #define IDX_RULE_BUF_R 'k'
5937 #define IDX_INCREMENT 'i'
5938 #define IDX_INCREMENT_MIN 0xff12
5939 #define IDX_INCREMENT_MAX 0xff13
5940 #define IDX_OUTFILE 'o'
5941 #define IDX_OUTFILE_FORMAT 0xff14
5942 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5943 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5944 #define IDX_RESTORE 0xff15
5945 #define IDX_RESTORE_DISABLE 0xff27
5946 #define IDX_STATUS 0xff17
5947 #define IDX_STATUS_TIMER 0xff18
5948 #define IDX_MACHINE_READABLE 0xff50
5949 #define IDX_LOOPBACK 0xff38
5950 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5951 #define IDX_SESSION 0xff19
5952 #define IDX_HEX_CHARSET 0xff20
5953 #define IDX_HEX_SALT 0xff21
5954 #define IDX_HEX_WORDLIST 0xff40
5955 #define IDX_MARKOV_DISABLE 0xff22
5956 #define IDX_MARKOV_CLASSIC 0xff23
5957 #define IDX_MARKOV_THRESHOLD 't'
5958 #define IDX_MARKOV_HCSTAT 0xff24
5959 #define IDX_CPU_AFFINITY 0xff25
5960 #define IDX_OPENCL_DEVICES 'd'
5961 #define IDX_OPENCL_PLATFORMS 0xff72
5962 #define IDX_OPENCL_DEVICE_TYPES 'D'
5963 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5964 #define IDX_WORKLOAD_PROFILE 'w'
5965 #define IDX_KERNEL_ACCEL 'n'
5966 #define IDX_KERNEL_LOOPS 'u'
5967 #define IDX_NVIDIA_SPIN_DAMP 0xff79
5968 #define IDX_GPU_TEMP_DISABLE 0xff29
5969 #define IDX_GPU_TEMP_ABORT 0xff30
5970 #define IDX_GPU_TEMP_RETAIN 0xff31
5971 #define IDX_POWERTUNE_ENABLE 0xff41
5972 #define IDX_LOGFILE_DISABLE 0xff51
5973 #define IDX_TRUECRYPT_KEYFILES 0xff52
5974 #define IDX_VERACRYPT_KEYFILES 0xff53
5975 #define IDX_VERACRYPT_PIM 0xff54
5976 #define IDX_SCRYPT_TMTO 0xff61
5977 #define IDX_SEGMENT_SIZE 'c'
5978 #define IDX_SEPARATOR 'p'
5979 #define IDX_BITMAP_MIN 0xff70
5980 #define IDX_BITMAP_MAX 0xff71
5981 #define IDX_CUSTOM_CHARSET_1 '1'
5982 #define IDX_CUSTOM_CHARSET_2 '2'
5983 #define IDX_CUSTOM_CHARSET_3 '3'
5984 #define IDX_CUSTOM_CHARSET_4 '4'
5985
5986 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:D:n:u:c:p:s:l:1:2:3:4:ibw:";
5987
5988 struct option long_options[] =
5989 {
5990 {"help", no_argument, 0, IDX_HELP},
5991 {"version", no_argument, 0, IDX_VERSION},
5992 {"quiet", no_argument, 0, IDX_QUIET},
5993 {"show", no_argument, 0, IDX_SHOW},
5994 {"left", no_argument, 0, IDX_LEFT},
5995 {"username", no_argument, 0, IDX_USERNAME},
5996 {"remove", no_argument, 0, IDX_REMOVE},
5997 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5998 {"skip", required_argument, 0, IDX_SKIP},
5999 {"limit", required_argument, 0, IDX_LIMIT},
6000 {"keyspace", no_argument, 0, IDX_KEYSPACE},
6001 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
6002 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
6003 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
6004 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
6005 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
6006 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
6007 {"force", no_argument, 0, IDX_FORCE},
6008 {"benchmark", no_argument, 0, IDX_BENCHMARK},
6009 {"stdout", no_argument, 0, IDX_STDOUT_FLAG},
6010 {"restore", no_argument, 0, IDX_RESTORE},
6011 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
6012 {"status", no_argument, 0, IDX_STATUS},
6013 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
6014 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
6015 {"loopback", no_argument, 0, IDX_LOOPBACK},
6016 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
6017 {"session", required_argument, 0, IDX_SESSION},
6018 {"runtime", required_argument, 0, IDX_RUNTIME},
6019 {"generate-rules", required_argument, 0, IDX_RP_GEN},
6020 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
6021 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
6022 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
6023 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
6024 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
6025 {"hash-type", required_argument, 0, IDX_HASH_MODE},
6026 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
6027 {"rules-file", required_argument, 0, IDX_RP_FILE},
6028 {"outfile", required_argument, 0, IDX_OUTFILE},
6029 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
6030 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
6031 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
6032 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
6033 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
6034 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
6035 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
6036 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
6037 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
6038 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
6039 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
6040 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
6041 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
6042 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
6043 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
6044 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
6045 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
6046 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
6047 {"nvidia-spin-damp", required_argument, 0, IDX_NVIDIA_SPIN_DAMP},
6048 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
6049 #ifdef HAVE_HWMON
6050 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
6051 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
6052 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
6053 #endif // HAVE_HWMON
6054 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
6055 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
6056 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
6057 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
6058 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
6059 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
6060 {"seperator", required_argument, 0, IDX_SEPARATOR},
6061 {"separator", required_argument, 0, IDX_SEPARATOR},
6062 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
6063 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
6064 {"increment", no_argument, 0, IDX_INCREMENT},
6065 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
6066 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
6067 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
6068 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
6069 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
6070 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
6071 {0, 0, 0, 0}
6072 };
6073
6074 uint rp_files_cnt = 0;
6075
6076 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6077
6078 int option_index = 0;
6079 int c = -1;
6080
6081 optind = 1;
6082 optopt = 0;
6083
6084 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6085 {
6086 switch (c)
6087 {
6088 case IDX_HELP: usage = 1; break;
6089 case IDX_VERSION:
6090 case IDX_VERSION_LOWER: version = 1; break;
6091 case IDX_RESTORE: restore = 1; break;
6092 case IDX_SESSION: session = optarg; break;
6093 case IDX_SHOW: show = 1; break;
6094 case IDX_LEFT: left = 1; break;
6095 case '?': return (-1);
6096 }
6097 }
6098
6099 if (optopt != 0)
6100 {
6101 log_error ("ERROR: Invalid argument specified");
6102
6103 return (-1);
6104 }
6105
6106 /**
6107 * exit functions
6108 */
6109
6110 if (version)
6111 {
6112 log_info ("%s", VERSION_TAG);
6113
6114 return (0);
6115 }
6116
6117 if (usage)
6118 {
6119 usage_big_print (PROGNAME);
6120
6121 return (0);
6122 }
6123
6124 /**
6125 * session needs to be set, always!
6126 */
6127
6128 if (session == NULL) session = (char *) PROGNAME;
6129
6130 /**
6131 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6132 */
6133
6134 char *exec_path = get_exec_path ();
6135
6136 #ifdef LINUX
6137
6138 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6139 char *resolved_exec_path = realpath (exec_path, NULL);
6140
6141 char *install_dir = get_install_dir (resolved_exec_path);
6142 char *profile_dir = NULL;
6143 char *session_dir = NULL;
6144 char *shared_dir = NULL;
6145
6146 if (strcmp (install_dir, resolved_install_folder) == 0)
6147 {
6148 struct passwd *pw = getpwuid (getuid ());
6149
6150 const char *homedir = pw->pw_dir;
6151
6152 profile_dir = get_profile_dir (homedir);
6153 session_dir = get_session_dir (profile_dir);
6154 shared_dir = strdup (SHARED_FOLDER);
6155
6156 mkdir (profile_dir, 0700);
6157 mkdir (session_dir, 0700);
6158 }
6159 else
6160 {
6161 profile_dir = install_dir;
6162 session_dir = install_dir;
6163 shared_dir = install_dir;
6164 }
6165
6166 myfree (resolved_install_folder);
6167 myfree (resolved_exec_path);
6168
6169 #else
6170
6171 char *install_dir = get_install_dir (exec_path);
6172 char *profile_dir = install_dir;
6173 char *session_dir = install_dir;
6174 char *shared_dir = install_dir;
6175
6176 #endif
6177
6178 data.install_dir = install_dir;
6179 data.profile_dir = profile_dir;
6180 data.session_dir = session_dir;
6181 data.shared_dir = shared_dir;
6182
6183 myfree (exec_path);
6184
6185 /**
6186 * kernel cache, we need to make sure folder exist
6187 */
6188
6189 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6190
6191 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6192
6193 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6194
6195 mkdir (kernels_folder, 0700);
6196
6197 myfree (kernels_folder);
6198
6199 /**
6200 * session
6201 */
6202
6203 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6204
6205 data.session = session;
6206
6207 char *eff_restore_file = (char *) mymalloc (session_size);
6208 char *new_restore_file = (char *) mymalloc (session_size);
6209
6210 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
6211 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6212
6213 data.eff_restore_file = eff_restore_file;
6214 data.new_restore_file = new_restore_file;
6215
6216 if (((show == 1) || (left == 1)) && (restore == 1))
6217 {
6218 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6219 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6220
6221 return (-1);
6222 }
6223
6224 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6225 if ((show == 1) || (left == 1))
6226 {
6227 restore_disable = 1;
6228
6229 restore = 0;
6230 }
6231
6232 data.restore_disable = restore_disable;
6233
6234 restore_data_t *rd = init_restore (argc, argv);
6235
6236 data.rd = rd;
6237
6238 /**
6239 * restore file
6240 */
6241
6242 if (restore == 1)
6243 {
6244 read_restore (eff_restore_file, rd);
6245
6246 if (rd->version_bin < RESTORE_MIN)
6247 {
6248 log_error ("ERROR: Incompatible restore-file version");
6249
6250 return (-1);
6251 }
6252
6253 myargc = rd->argc;
6254 myargv = rd->argv;
6255
6256 #ifdef _POSIX
6257 rd->pid = getpid ();
6258 #elif _WIN
6259 rd->pid = GetCurrentProcessId ();
6260 #endif
6261 }
6262
6263 uint hash_mode_chgd = 0;
6264 uint runtime_chgd = 0;
6265 uint kernel_loops_chgd = 0;
6266 uint kernel_accel_chgd = 0;
6267 uint nvidia_spin_damp_chgd = 0;
6268 uint attack_mode_chgd = 0;
6269 uint outfile_format_chgd = 0;
6270 uint rp_gen_seed_chgd = 0;
6271 uint remove_timer_chgd = 0;
6272 uint increment_min_chgd = 0;
6273 uint increment_max_chgd = 0;
6274 uint workload_profile_chgd = 0;
6275 uint opencl_vector_width_chgd = 0;
6276
6277 optind = 1;
6278 optopt = 0;
6279 option_index = 0;
6280
6281 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6282 {
6283 switch (c)
6284 {
6285 //case IDX_HELP: usage = 1; break;
6286 //case IDX_VERSION: version = 1; break;
6287 //case IDX_RESTORE: restore = 1; break;
6288 case IDX_QUIET: quiet = 1; break;
6289 //case IDX_SHOW: show = 1; break;
6290 case IDX_SHOW: break;
6291 //case IDX_LEFT: left = 1; break;
6292 case IDX_LEFT: break;
6293 case IDX_USERNAME: username = 1; break;
6294 case IDX_REMOVE: remove = 1; break;
6295 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6296 remove_timer_chgd = 1; break;
6297 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6298 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6299 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6300 case IDX_DEBUG_FILE: debug_file = optarg; break;
6301 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6302 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6303 case IDX_FORCE: force = 1; break;
6304 case IDX_SKIP: skip = atoll (optarg); break;
6305 case IDX_LIMIT: limit = atoll (optarg); break;
6306 case IDX_KEYSPACE: keyspace = 1; break;
6307 case IDX_BENCHMARK: benchmark = 1; break;
6308 case IDX_STDOUT_FLAG: stdout_flag = 1; break;
6309 case IDX_RESTORE: break;
6310 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6311 case IDX_STATUS: status = 1; break;
6312 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6313 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6314 case IDX_LOOPBACK: loopback = 1; break;
6315 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6316 //case IDX_SESSION: session = optarg; break;
6317 case IDX_SESSION: break;
6318 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6319 hash_mode_chgd = 1; break;
6320 case IDX_RUNTIME: runtime = atoi (optarg);
6321 runtime_chgd = 1; break;
6322 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6323 attack_mode_chgd = 1; break;
6324 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6325 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6326 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6327 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6328 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6329 rp_gen_seed_chgd = 1; break;
6330 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6331 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6332 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6333 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6334 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6335 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6336 case IDX_OUTFILE: outfile = optarg; break;
6337 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6338 outfile_format_chgd = 1; break;
6339 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6340 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6341 case IDX_HEX_CHARSET: hex_charset = 1; break;
6342 case IDX_HEX_SALT: hex_salt = 1; break;
6343 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6344 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6345 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6346 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6347 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6348 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6349 opencl_vector_width_chgd = 1; break;
6350 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6351 workload_profile_chgd = 1; break;
6352 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6353 kernel_accel_chgd = 1; break;
6354 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6355 kernel_loops_chgd = 1; break;
6356 case IDX_NVIDIA_SPIN_DAMP: nvidia_spin_damp = atoi (optarg);
6357 nvidia_spin_damp_chgd = 1; break;
6358 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6359 #ifdef HAVE_HWMON
6360 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6361 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6362 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6363 #endif // HAVE_HWMON
6364 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6365 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6366 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6367 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6368 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6369 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6370 case IDX_SEPARATOR: separator = optarg[0]; break;
6371 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6372 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6373 case IDX_INCREMENT: increment = 1; break;
6374 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6375 increment_min_chgd = 1; break;
6376 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6377 increment_max_chgd = 1; break;
6378 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6379 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6380 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6381 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6382
6383 default:
6384 log_error ("ERROR: Invalid argument specified");
6385 return (-1);
6386 }
6387 }
6388
6389 if (optopt != 0)
6390 {
6391 log_error ("ERROR: Invalid argument specified");
6392
6393 return (-1);
6394 }
6395
6396 /**
6397 * Inform user things getting started,
6398 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6399 * - we do not need to check algorithm_pos
6400 */
6401
6402 if (quiet == 0)
6403 {
6404 if (benchmark == 1)
6405 {
6406 if (machine_readable == 0)
6407 {
6408 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6409 log_info ("");
6410 }
6411 else
6412 {
6413 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6414 }
6415 }
6416 else if (restore == 1)
6417 {
6418 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6419 log_info ("");
6420 }
6421 else if (stdout_flag == 1)
6422 {
6423 // do nothing
6424 }
6425 else
6426 {
6427 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6428 log_info ("");
6429 }
6430 }
6431
6432 /**
6433 * sanity check
6434 */
6435
6436 if (attack_mode > 7)
6437 {
6438 log_error ("ERROR: Invalid attack-mode specified");
6439
6440 return (-1);
6441 }
6442
6443 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6444 {
6445 log_error ("ERROR: Invalid runtime specified");
6446
6447 return (-1);
6448 }
6449
6450 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6451 {
6452 log_error ("ERROR: Invalid hash-type specified");
6453
6454 return (-1);
6455 }
6456
6457 // renamed hash modes
6458
6459 if (hash_mode_chgd)
6460 {
6461 int n = -1;
6462
6463 switch (hash_mode)
6464 {
6465 case 123: n = 124;
6466 break;
6467 }
6468
6469 if (n >= 0)
6470 {
6471 log_error ("Old -m specified, use -m %d instead", n);
6472
6473 return (-1);
6474 }
6475 }
6476
6477 if (username == 1)
6478 {
6479 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6480 {
6481 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6482
6483 return (-1);
6484 }
6485 }
6486
6487 if (outfile_format > 16)
6488 {
6489 log_error ("ERROR: Invalid outfile-format specified");
6490
6491 return (-1);
6492 }
6493
6494 if (left == 1)
6495 {
6496 if (outfile_format_chgd == 1)
6497 {
6498 if (outfile_format > 1)
6499 {
6500 log_error ("ERROR: Mixing outfile-format > 1 with left parameter is not allowed");
6501
6502 return (-1);
6503 }
6504 }
6505 else
6506 {
6507 outfile_format = OUTFILE_FMT_HASH;
6508 }
6509 }
6510
6511 if (show == 1)
6512 {
6513 if (outfile_format_chgd == 1)
6514 {
6515 if ((outfile_format > 7) && (outfile_format < 16))
6516 {
6517 log_error ("ERROR: Mixing outfile-format > 7 with show parameter is not allowed");
6518
6519 return (-1);
6520 }
6521 }
6522 }
6523
6524 if (increment_min < INCREMENT_MIN)
6525 {
6526 log_error ("ERROR: Invalid increment-min specified");
6527
6528 return (-1);
6529 }
6530
6531 if (increment_max > INCREMENT_MAX)
6532 {
6533 log_error ("ERROR: Invalid increment-max specified");
6534
6535 return (-1);
6536 }
6537
6538 if (increment_min > increment_max)
6539 {
6540 log_error ("ERROR: Invalid increment-min specified");
6541
6542 return (-1);
6543 }
6544
6545 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6546 {
6547 log_error ("ERROR: Increment is not allowed in attack-mode 0");
6548
6549 return (-1);
6550 }
6551
6552 if ((increment == 0) && (increment_min_chgd == 1))
6553 {
6554 log_error ("ERROR: Increment-min is only supported combined with increment switch");
6555
6556 return (-1);
6557 }
6558
6559 if ((increment == 0) && (increment_max_chgd == 1))
6560 {
6561 log_error ("ERROR: Increment-max is only supported combined with increment switch");
6562
6563 return (-1);
6564 }
6565
6566 if (rp_files_cnt && rp_gen)
6567 {
6568 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6569
6570 return (-1);
6571 }
6572
6573 if (rp_files_cnt || rp_gen)
6574 {
6575 if (attack_mode != ATTACK_MODE_STRAIGHT)
6576 {
6577 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6578
6579 return (-1);
6580 }
6581 }
6582
6583 if (rp_gen_func_min > rp_gen_func_max)
6584 {
6585 log_error ("ERROR: Invalid rp-gen-func-min specified");
6586
6587 return (-1);
6588 }
6589
6590 if (kernel_accel_chgd == 1)
6591 {
6592 if (force == 0)
6593 {
6594 log_info ("The manual use of the -n option (or --kernel-accel) is outdated");
6595 log_info ("Please consider using the -w option instead");
6596 log_info ("You can use --force to override this but do not post error reports if you do so");
6597 log_info ("");
6598
6599 return (-1);
6600 }
6601
6602 if (kernel_accel < 1)
6603 {
6604 log_error ("ERROR: Invalid kernel-accel specified");
6605
6606 return (-1);
6607 }
6608
6609 if (kernel_accel > 1024)
6610 {
6611 log_error ("ERROR: Invalid kernel-accel specified");
6612
6613 return (-1);
6614 }
6615 }
6616
6617 if (kernel_loops_chgd == 1)
6618 {
6619 if (force == 0)
6620 {
6621 log_info ("The manual use of the -u option (or --kernel-loops) is outdated");
6622 log_info ("Please consider using the -w option instead");
6623 log_info ("You can use --force to override this but do not post error reports if you do so");
6624 log_info ("");
6625
6626 return (-1);
6627 }
6628
6629 if (kernel_loops < 1)
6630 {
6631 log_error ("ERROR: Invalid kernel-loops specified");
6632
6633 return (-1);
6634 }
6635
6636 if (kernel_loops > 1024)
6637 {
6638 log_error ("ERROR: Invalid kernel-loops specified");
6639
6640 return (-1);
6641 }
6642 }
6643
6644 if ((workload_profile < 1) || (workload_profile > 4))
6645 {
6646 log_error ("ERROR: workload-profile %i not available", workload_profile);
6647
6648 return (-1);
6649 }
6650
6651 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6652 {
6653 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6654
6655 return (-1);
6656 }
6657
6658 if (show == 1 || left == 1)
6659 {
6660 attack_mode = ATTACK_MODE_NONE;
6661
6662 if (remove == 1)
6663 {
6664 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6665
6666 return (-1);
6667 }
6668
6669 if (potfile_disable == 1)
6670 {
6671 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6672
6673 return (-1);
6674 }
6675 }
6676
6677 uint attack_kern = ATTACK_KERN_NONE;
6678
6679 switch (attack_mode)
6680 {
6681 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6682 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6683 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6684 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6685 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6686 }
6687
6688 if (benchmark == 1)
6689 {
6690 if (myargv[optind] != 0)
6691 {
6692 log_error ("ERROR: Invalid argument for benchmark mode specified");
6693
6694 return (-1);
6695 }
6696
6697 if (attack_mode_chgd == 1)
6698 {
6699 if (attack_mode != ATTACK_MODE_BF)
6700 {
6701 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6702
6703 return (-1);
6704 }
6705 }
6706 }
6707 else
6708 {
6709 if (stdout_flag == 1) // no hash here
6710 {
6711 optind--;
6712 }
6713
6714 if (keyspace == 1)
6715 {
6716 int num_additional_params = 1;
6717
6718 if (attack_kern == ATTACK_KERN_COMBI)
6719 {
6720 num_additional_params = 2;
6721 }
6722
6723 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6724
6725 if (keyspace_wordlist_specified == 0) optind--;
6726 }
6727
6728 if (attack_kern == ATTACK_KERN_NONE)
6729 {
6730 if ((optind + 1) != myargc)
6731 {
6732 usage_mini_print (myargv[0]);
6733
6734 return (-1);
6735 }
6736 }
6737 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6738 {
6739 if ((optind + 1) > myargc)
6740 {
6741 usage_mini_print (myargv[0]);
6742
6743 return (-1);
6744 }
6745 }
6746 else if (attack_kern == ATTACK_KERN_COMBI)
6747 {
6748 if ((optind + 3) != myargc)
6749 {
6750 usage_mini_print (myargv[0]);
6751
6752 return (-1);
6753 }
6754 }
6755 else if (attack_kern == ATTACK_KERN_BF)
6756 {
6757 if ((optind + 1) > myargc)
6758 {
6759 usage_mini_print (myargv[0]);
6760
6761 return (-1);
6762 }
6763 }
6764 else
6765 {
6766 usage_mini_print (myargv[0]);
6767
6768 return (-1);
6769 }
6770 }
6771
6772 if (skip != 0 && limit != 0)
6773 {
6774 limit += skip;
6775 }
6776
6777 if (keyspace == 1)
6778 {
6779 if (show == 1)
6780 {
6781 log_error ("ERROR: Combining show parameter with keyspace parameter is not allowed");
6782
6783 return (-1);
6784 }
6785 else if (left == 1)
6786 {
6787 log_error ("ERROR: Combining left parameter with keyspace parameter is not allowed");
6788
6789 return (-1);
6790 }
6791
6792 potfile_disable = 1;
6793
6794 restore_disable = 1;
6795
6796 restore = 0;
6797
6798 weak_hash_threshold = 0;
6799
6800 quiet = 1;
6801 }
6802
6803 if (stdout_flag == 1)
6804 {
6805 status_timer = 0;
6806 restore_timer = 0;
6807 restore_disable = 1;
6808 restore = 0;
6809 potfile_disable = 1;
6810 weak_hash_threshold = 0;
6811 gpu_temp_disable = 1;
6812 hash_mode = 2000;
6813 quiet = 1;
6814 outfile_format = OUTFILE_FMT_PLAIN;
6815 kernel_accel = 1024;
6816 kernel_loops = 1024;
6817 force = 1;
6818 outfile_check_timer = 0;
6819 session = "stdout";
6820 opencl_vector_width = 1;
6821 }
6822
6823 if (remove_timer_chgd == 1)
6824 {
6825 if (remove == 0)
6826 {
6827 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6828
6829 return (-1);
6830 }
6831
6832 if (remove_timer < 1)
6833 {
6834 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6835
6836 return (-1);
6837 }
6838 }
6839
6840 if (loopback == 1)
6841 {
6842 if (attack_mode == ATTACK_MODE_STRAIGHT)
6843 {
6844 if ((rp_files_cnt == 0) && (rp_gen == 0))
6845 {
6846 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6847
6848 return (-1);
6849 }
6850 }
6851 else
6852 {
6853 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6854
6855 return (-1);
6856 }
6857 }
6858
6859 if (debug_mode > 0)
6860 {
6861 if (attack_mode != ATTACK_MODE_STRAIGHT)
6862 {
6863 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6864
6865 return (-1);
6866 }
6867
6868 if ((rp_files_cnt == 0) && (rp_gen == 0))
6869 {
6870 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6871
6872 return (-1);
6873 }
6874 }
6875
6876 if (debug_mode > 4)
6877 {
6878 log_error ("ERROR: Invalid debug-mode specified");
6879
6880 return (-1);
6881 }
6882
6883 if (debug_file != NULL)
6884 {
6885 if (debug_mode < 1)
6886 {
6887 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6888
6889 return (-1);
6890 }
6891 }
6892
6893 if (induction_dir != NULL)
6894 {
6895 if (attack_mode == ATTACK_MODE_BF)
6896 {
6897 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6898
6899 return (-1);
6900 }
6901 }
6902
6903 if (attack_mode != ATTACK_MODE_STRAIGHT)
6904 {
6905 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6906 {
6907 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6908
6909 return (-1);
6910 }
6911
6912 weak_hash_threshold = 0;
6913 }
6914
6915 if (nvidia_spin_damp > 100)
6916 {
6917 log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)");
6918
6919 return (-1);
6920 }
6921
6922
6923 /**
6924 * induction directory
6925 */
6926
6927 char *induction_directory = NULL;
6928
6929 if (attack_mode != ATTACK_MODE_BF)
6930 {
6931 if (induction_dir == NULL)
6932 {
6933 induction_directory = (char *) mymalloc (session_size);
6934
6935 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6936
6937 // create induction folder if it does not already exist
6938
6939 if (keyspace == 0)
6940 {
6941 if (rmdir (induction_directory) == -1)
6942 {
6943 if (errno == ENOENT)
6944 {
6945 // good, we can ignore
6946 }
6947 else if (errno == ENOTEMPTY)
6948 {
6949 char *induction_directory_mv = (char *) mymalloc (session_size);
6950
6951 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6952
6953 if (rename (induction_directory, induction_directory_mv) != 0)
6954 {
6955 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6956
6957 return (-1);
6958 }
6959 }
6960 else
6961 {
6962 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6963
6964 return (-1);
6965 }
6966 }
6967
6968 if (mkdir (induction_directory, 0700) == -1)
6969 {
6970 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6971
6972 return (-1);
6973 }
6974 }
6975 }
6976 else
6977 {
6978 induction_directory = induction_dir;
6979 }
6980 }
6981
6982 data.induction_directory = induction_directory;
6983
6984 /**
6985 * loopback
6986 */
6987
6988 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6989
6990 char *loopback_file = (char *) mymalloc (loopback_size);
6991
6992 /**
6993 * tuning db
6994 */
6995
6996 char tuning_db_file[256] = { 0 };
6997
6998 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6999
7000 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
7001
7002 /**
7003 * outfile-check directory
7004 */
7005
7006 char *outfile_check_directory = NULL;
7007
7008 if (outfile_check_dir == NULL)
7009 {
7010 outfile_check_directory = (char *) mymalloc (session_size);
7011
7012 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
7013 }
7014 else
7015 {
7016 outfile_check_directory = outfile_check_dir;
7017 }
7018
7019 data.outfile_check_directory = outfile_check_directory;
7020
7021 if (keyspace == 0)
7022 {
7023 struct stat outfile_check_stat;
7024
7025 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
7026 {
7027 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
7028
7029 if (is_dir == 0)
7030 {
7031 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
7032
7033 return (-1);
7034 }
7035 }
7036 else if (outfile_check_dir == NULL)
7037 {
7038 if (mkdir (outfile_check_directory, 0700) == -1)
7039 {
7040 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
7041
7042 return (-1);
7043 }
7044 }
7045 }
7046
7047 /**
7048 * special other stuff
7049 */
7050
7051 if (hash_mode == 9710)
7052 {
7053 outfile_format = 5;
7054 outfile_format_chgd = 1;
7055 }
7056
7057 if (hash_mode == 9810)
7058 {
7059 outfile_format = 5;
7060 outfile_format_chgd = 1;
7061 }
7062
7063 if (hash_mode == 10410)
7064 {
7065 outfile_format = 5;
7066 outfile_format_chgd = 1;
7067 }
7068
7069 /**
7070 * store stuff
7071 */
7072
7073 data.hash_mode = hash_mode;
7074 data.restore = restore;
7075 data.restore_timer = restore_timer;
7076 data.restore_disable = restore_disable;
7077 data.status = status;
7078 data.status_timer = status_timer;
7079 data.machine_readable = machine_readable;
7080 data.loopback = loopback;
7081 data.runtime = runtime;
7082 data.remove = remove;
7083 data.remove_timer = remove_timer;
7084 data.debug_mode = debug_mode;
7085 data.debug_file = debug_file;
7086 data.username = username;
7087 data.quiet = quiet;
7088 data.outfile = outfile;
7089 data.outfile_format = outfile_format;
7090 data.outfile_autohex = outfile_autohex;
7091 data.hex_charset = hex_charset;
7092 data.hex_salt = hex_salt;
7093 data.hex_wordlist = hex_wordlist;
7094 data.separator = separator;
7095 data.rp_files = rp_files;
7096 data.rp_files_cnt = rp_files_cnt;
7097 data.rp_gen = rp_gen;
7098 data.rp_gen_seed = rp_gen_seed;
7099 data.force = force;
7100 data.benchmark = benchmark;
7101 data.skip = skip;
7102 data.limit = limit;
7103 #ifdef HAVE_HWMON
7104 data.powertune_enable = powertune_enable;
7105 #endif
7106 data.logfile_disable = logfile_disable;
7107 data.truecrypt_keyfiles = truecrypt_keyfiles;
7108 data.veracrypt_keyfiles = veracrypt_keyfiles;
7109 data.veracrypt_pim = veracrypt_pim;
7110 data.scrypt_tmto = scrypt_tmto;
7111 data.workload_profile = workload_profile;
7112
7113 /**
7114 * cpu affinity
7115 */
7116
7117 if (cpu_affinity)
7118 {
7119 set_cpu_affinity (cpu_affinity);
7120 }
7121
7122 if (rp_gen_seed_chgd == 0)
7123 {
7124 srand (proc_start);
7125 }
7126 else
7127 {
7128 srand (rp_gen_seed);
7129 }
7130
7131 /**
7132 * logfile init
7133 */
7134
7135 if (logfile_disable == 0)
7136 {
7137 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7138
7139 char *logfile = (char *) mymalloc (logfile_size);
7140
7141 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7142
7143 data.logfile = logfile;
7144
7145 char *topid = logfile_generate_topid ();
7146
7147 data.topid = topid;
7148 }
7149
7150 // logfile_append() checks for logfile_disable internally to make it easier from here
7151
7152 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7153 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7154 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7155 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7156 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7157 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7158 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7159 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7160 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7161 #define logfile_sub_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s\t%s", data.topid, data.subid, (var), (val));
7162
7163 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7164 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7165 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7166 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7167 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7168 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7169 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7170 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7171
7172 logfile_top_msg ("START");
7173
7174 logfile_top_uint (attack_mode);
7175 logfile_top_uint (attack_kern);
7176 logfile_top_uint (benchmark);
7177 logfile_top_uint (stdout_flag);
7178 logfile_top_uint (bitmap_min);
7179 logfile_top_uint (bitmap_max);
7180 logfile_top_uint (debug_mode);
7181 logfile_top_uint (force);
7182 logfile_top_uint (kernel_accel);
7183 logfile_top_uint (kernel_loops);
7184 logfile_top_uint (nvidia_spin_damp);
7185 logfile_top_uint (gpu_temp_disable);
7186 #ifdef HAVE_HWMON
7187 logfile_top_uint (gpu_temp_abort);
7188 logfile_top_uint (gpu_temp_retain);
7189 #endif
7190 logfile_top_uint (hash_mode);
7191 logfile_top_uint (hex_charset);
7192 logfile_top_uint (hex_salt);
7193 logfile_top_uint (hex_wordlist);
7194 logfile_top_uint (increment);
7195 logfile_top_uint (increment_max);
7196 logfile_top_uint (increment_min);
7197 logfile_top_uint (keyspace);
7198 logfile_top_uint (left);
7199 logfile_top_uint (logfile_disable);
7200 logfile_top_uint (loopback);
7201 logfile_top_uint (markov_classic);
7202 logfile_top_uint (markov_disable);
7203 logfile_top_uint (markov_threshold);
7204 logfile_top_uint (outfile_autohex);
7205 logfile_top_uint (outfile_check_timer);
7206 logfile_top_uint (outfile_format);
7207 logfile_top_uint (potfile_disable);
7208 logfile_top_string (potfile_path);
7209 #if defined(HAVE_HWMON)
7210 logfile_top_uint (powertune_enable);
7211 #endif
7212 logfile_top_uint (scrypt_tmto);
7213 logfile_top_uint (quiet);
7214 logfile_top_uint (remove);
7215 logfile_top_uint (remove_timer);
7216 logfile_top_uint (restore);
7217 logfile_top_uint (restore_disable);
7218 logfile_top_uint (restore_timer);
7219 logfile_top_uint (rp_gen);
7220 logfile_top_uint (rp_gen_func_max);
7221 logfile_top_uint (rp_gen_func_min);
7222 logfile_top_uint (rp_gen_seed);
7223 logfile_top_uint (runtime);
7224 logfile_top_uint (segment_size);
7225 logfile_top_uint (show);
7226 logfile_top_uint (status);
7227 logfile_top_uint (machine_readable);
7228 logfile_top_uint (status_timer);
7229 logfile_top_uint (usage);
7230 logfile_top_uint (username);
7231 logfile_top_uint (version);
7232 logfile_top_uint (weak_hash_threshold);
7233 logfile_top_uint (workload_profile);
7234 logfile_top_uint64 (limit);
7235 logfile_top_uint64 (skip);
7236 logfile_top_char (separator);
7237 logfile_top_string (cpu_affinity);
7238 logfile_top_string (custom_charset_1);
7239 logfile_top_string (custom_charset_2);
7240 logfile_top_string (custom_charset_3);
7241 logfile_top_string (custom_charset_4);
7242 logfile_top_string (debug_file);
7243 logfile_top_string (opencl_devices);
7244 logfile_top_string (opencl_platforms);
7245 logfile_top_string (opencl_device_types);
7246 logfile_top_uint (opencl_vector_width);
7247 logfile_top_string (induction_dir);
7248 logfile_top_string (markov_hcstat);
7249 logfile_top_string (outfile);
7250 logfile_top_string (outfile_check_dir);
7251 logfile_top_string (rule_buf_l);
7252 logfile_top_string (rule_buf_r);
7253 logfile_top_string (session);
7254 logfile_top_string (truecrypt_keyfiles);
7255 logfile_top_string (veracrypt_keyfiles);
7256 logfile_top_uint (veracrypt_pim);
7257
7258 /**
7259 * Init OpenCL library loader
7260 */
7261
7262 if (keyspace == 0)
7263 {
7264 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7265
7266 ocl_init (ocl);
7267
7268 data.ocl = ocl;
7269 }
7270
7271 /**
7272 * OpenCL platform selection
7273 */
7274
7275 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7276
7277 /**
7278 * OpenCL device selection
7279 */
7280
7281 u32 devices_filter = setup_devices_filter (opencl_devices);
7282
7283 /**
7284 * OpenCL device type selection
7285 */
7286
7287 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7288
7289 /**
7290 * benchmark
7291 */
7292
7293 if (benchmark == 1)
7294 {
7295 /**
7296 * disable useless stuff for benchmark
7297 */
7298
7299 status_timer = 0;
7300 restore_timer = 0;
7301 restore_disable = 1;
7302 potfile_disable = 1;
7303 weak_hash_threshold = 0;
7304 nvidia_spin_damp = 0;
7305 gpu_temp_disable = 1;
7306 outfile_check_timer = 0;
7307
7308 #ifdef HAVE_HWMON
7309 if (powertune_enable == 1)
7310 {
7311 gpu_temp_disable = 0;
7312 }
7313 #endif
7314
7315 data.status_timer = status_timer;
7316 data.restore_timer = restore_timer;
7317 data.restore_disable = restore_disable;
7318 data.outfile_check_timer = outfile_check_timer;
7319
7320 /**
7321 * force attack mode to be bruteforce
7322 */
7323
7324 attack_mode = ATTACK_MODE_BF;
7325 attack_kern = ATTACK_KERN_BF;
7326
7327 if (workload_profile_chgd == 0)
7328 {
7329 workload_profile = 3;
7330
7331 data.workload_profile = workload_profile;
7332 }
7333 }
7334
7335 /**
7336 * status, monitor and outfile remove threads
7337 */
7338
7339 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
7340
7341 data.wordlist_mode = wordlist_mode;
7342
7343 if (wordlist_mode == WL_MODE_STDIN)
7344 {
7345 status = 1;
7346
7347 data.status = status;
7348 }
7349
7350 uint i_threads_cnt = 0;
7351
7352 hc_thread_t *i_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
7353
7354 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
7355 {
7356 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
7357 {
7358 hc_thread_create (i_threads[i_threads_cnt], thread_keypress, NULL);
7359
7360 i_threads_cnt++;
7361 }
7362 }
7363
7364 /**
7365 * config
7366 */
7367
7368 uint hash_type = 0;
7369 uint salt_type = 0;
7370 uint attack_exec = 0;
7371 uint opts_type = 0;
7372 uint kern_type = 0;
7373 uint dgst_size = 0;
7374 uint esalt_size = 0;
7375 uint opti_type = 0;
7376 uint dgst_pos0 = -1;
7377 uint dgst_pos1 = -1;
7378 uint dgst_pos2 = -1;
7379 uint dgst_pos3 = -1;
7380
7381 int (*parse_func) (char *, uint, hash_t *);
7382 int (*sort_by_digest) (const void *, const void *);
7383
7384 uint algorithm_pos = 0;
7385 uint algorithm_max = 1;
7386
7387 uint *algorithms = default_benchmark_algorithms;
7388
7389 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7390
7391 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7392 {
7393 /*
7394 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7395 * the following algos are skipped entirely
7396 */
7397
7398 if (algorithm_pos > 0)
7399 {
7400 local_free (rd);
7401
7402 rd = init_restore (argc, argv);
7403
7404 data.rd = rd;
7405 }
7406
7407 /**
7408 * update hash_mode in case of multihash benchmark
7409 */
7410
7411 if (benchmark == 1)
7412 {
7413 if (hash_mode_chgd == 0)
7414 {
7415 hash_mode = algorithms[algorithm_pos];
7416
7417 data.hash_mode = hash_mode;
7418 }
7419
7420 quiet = 1;
7421
7422 data.quiet = quiet;
7423 }
7424
7425 switch (hash_mode)
7426 {
7427 case 0: hash_type = HASH_TYPE_MD5;
7428 salt_type = SALT_TYPE_NONE;
7429 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7430 opts_type = OPTS_TYPE_PT_GENERATE_LE
7431 | OPTS_TYPE_PT_ADD80
7432 | OPTS_TYPE_PT_ADDBITS14;
7433 kern_type = KERN_TYPE_MD5;
7434 dgst_size = DGST_SIZE_4_4;
7435 parse_func = md5_parse_hash;
7436 sort_by_digest = sort_by_digest_4_4;
7437 opti_type = OPTI_TYPE_ZERO_BYTE
7438 | OPTI_TYPE_PRECOMPUTE_INIT
7439 | OPTI_TYPE_PRECOMPUTE_MERKLE
7440 | OPTI_TYPE_MEET_IN_MIDDLE
7441 | OPTI_TYPE_EARLY_SKIP
7442 | OPTI_TYPE_NOT_ITERATED
7443 | OPTI_TYPE_NOT_SALTED
7444 | OPTI_TYPE_RAW_HASH;
7445 dgst_pos0 = 0;
7446 dgst_pos1 = 3;
7447 dgst_pos2 = 2;
7448 dgst_pos3 = 1;
7449 break;
7450
7451 case 10: hash_type = HASH_TYPE_MD5;
7452 salt_type = SALT_TYPE_INTERN;
7453 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7454 opts_type = OPTS_TYPE_PT_GENERATE_LE
7455 | OPTS_TYPE_ST_ADD80
7456 | OPTS_TYPE_ST_ADDBITS14;
7457 kern_type = KERN_TYPE_MD5_PWSLT;
7458 dgst_size = DGST_SIZE_4_4;
7459 parse_func = md5s_parse_hash;
7460 sort_by_digest = sort_by_digest_4_4;
7461 opti_type = OPTI_TYPE_ZERO_BYTE
7462 | OPTI_TYPE_PRECOMPUTE_INIT
7463 | OPTI_TYPE_PRECOMPUTE_MERKLE
7464 | OPTI_TYPE_MEET_IN_MIDDLE
7465 | OPTI_TYPE_EARLY_SKIP
7466 | OPTI_TYPE_NOT_ITERATED
7467 | OPTI_TYPE_APPENDED_SALT
7468 | OPTI_TYPE_RAW_HASH;
7469 dgst_pos0 = 0;
7470 dgst_pos1 = 3;
7471 dgst_pos2 = 2;
7472 dgst_pos3 = 1;
7473 break;
7474
7475 case 11: hash_type = HASH_TYPE_MD5;
7476 salt_type = SALT_TYPE_INTERN;
7477 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7478 opts_type = OPTS_TYPE_PT_GENERATE_LE
7479 | OPTS_TYPE_ST_ADD80
7480 | OPTS_TYPE_ST_ADDBITS14;
7481 kern_type = KERN_TYPE_MD5_PWSLT;
7482 dgst_size = DGST_SIZE_4_4;
7483 parse_func = joomla_parse_hash;
7484 sort_by_digest = sort_by_digest_4_4;
7485 opti_type = OPTI_TYPE_ZERO_BYTE
7486 | OPTI_TYPE_PRECOMPUTE_INIT
7487 | OPTI_TYPE_PRECOMPUTE_MERKLE
7488 | OPTI_TYPE_MEET_IN_MIDDLE
7489 | OPTI_TYPE_EARLY_SKIP
7490 | OPTI_TYPE_NOT_ITERATED
7491 | OPTI_TYPE_APPENDED_SALT
7492 | OPTI_TYPE_RAW_HASH;
7493 dgst_pos0 = 0;
7494 dgst_pos1 = 3;
7495 dgst_pos2 = 2;
7496 dgst_pos3 = 1;
7497 break;
7498
7499 case 12: hash_type = HASH_TYPE_MD5;
7500 salt_type = SALT_TYPE_INTERN;
7501 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7502 opts_type = OPTS_TYPE_PT_GENERATE_LE
7503 | OPTS_TYPE_ST_ADD80
7504 | OPTS_TYPE_ST_ADDBITS14;
7505 kern_type = KERN_TYPE_MD5_PWSLT;
7506 dgst_size = DGST_SIZE_4_4;
7507 parse_func = postgresql_parse_hash;
7508 sort_by_digest = sort_by_digest_4_4;
7509 opti_type = OPTI_TYPE_ZERO_BYTE
7510 | OPTI_TYPE_PRECOMPUTE_INIT
7511 | OPTI_TYPE_PRECOMPUTE_MERKLE
7512 | OPTI_TYPE_MEET_IN_MIDDLE
7513 | OPTI_TYPE_EARLY_SKIP
7514 | OPTI_TYPE_NOT_ITERATED
7515 | OPTI_TYPE_APPENDED_SALT
7516 | OPTI_TYPE_RAW_HASH;
7517 dgst_pos0 = 0;
7518 dgst_pos1 = 3;
7519 dgst_pos2 = 2;
7520 dgst_pos3 = 1;
7521 break;
7522
7523 case 20: hash_type = HASH_TYPE_MD5;
7524 salt_type = SALT_TYPE_INTERN;
7525 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7526 opts_type = OPTS_TYPE_PT_GENERATE_LE
7527 | OPTS_TYPE_PT_ADD80
7528 | OPTS_TYPE_PT_ADDBITS14;
7529 kern_type = KERN_TYPE_MD5_SLTPW;
7530 dgst_size = DGST_SIZE_4_4;
7531 parse_func = md5s_parse_hash;
7532 sort_by_digest = sort_by_digest_4_4;
7533 opti_type = OPTI_TYPE_ZERO_BYTE
7534 | OPTI_TYPE_PRECOMPUTE_INIT
7535 | OPTI_TYPE_PRECOMPUTE_MERKLE
7536 | OPTI_TYPE_EARLY_SKIP
7537 | OPTI_TYPE_NOT_ITERATED
7538 | OPTI_TYPE_PREPENDED_SALT
7539 | OPTI_TYPE_RAW_HASH;
7540 dgst_pos0 = 0;
7541 dgst_pos1 = 3;
7542 dgst_pos2 = 2;
7543 dgst_pos3 = 1;
7544 break;
7545
7546 case 21: hash_type = HASH_TYPE_MD5;
7547 salt_type = SALT_TYPE_INTERN;
7548 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7549 opts_type = OPTS_TYPE_PT_GENERATE_LE
7550 | OPTS_TYPE_PT_ADD80
7551 | OPTS_TYPE_PT_ADDBITS14;
7552 kern_type = KERN_TYPE_MD5_SLTPW;
7553 dgst_size = DGST_SIZE_4_4;
7554 parse_func = osc_parse_hash;
7555 sort_by_digest = sort_by_digest_4_4;
7556 opti_type = OPTI_TYPE_ZERO_BYTE
7557 | OPTI_TYPE_PRECOMPUTE_INIT
7558 | OPTI_TYPE_PRECOMPUTE_MERKLE
7559 | OPTI_TYPE_EARLY_SKIP
7560 | OPTI_TYPE_NOT_ITERATED
7561 | OPTI_TYPE_PREPENDED_SALT
7562 | OPTI_TYPE_RAW_HASH;
7563 dgst_pos0 = 0;
7564 dgst_pos1 = 3;
7565 dgst_pos2 = 2;
7566 dgst_pos3 = 1;
7567 break;
7568
7569 case 22: hash_type = HASH_TYPE_MD5;
7570 salt_type = SALT_TYPE_EMBEDDED;
7571 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7572 opts_type = OPTS_TYPE_PT_GENERATE_LE
7573 | OPTS_TYPE_PT_ADD80
7574 | OPTS_TYPE_PT_ADDBITS14;
7575 kern_type = KERN_TYPE_MD5_SLTPW;
7576 dgst_size = DGST_SIZE_4_4;
7577 parse_func = netscreen_parse_hash;
7578 sort_by_digest = sort_by_digest_4_4;
7579 opti_type = OPTI_TYPE_ZERO_BYTE
7580 | OPTI_TYPE_PRECOMPUTE_INIT
7581 | OPTI_TYPE_PRECOMPUTE_MERKLE
7582 | OPTI_TYPE_EARLY_SKIP
7583 | OPTI_TYPE_NOT_ITERATED
7584 | OPTI_TYPE_PREPENDED_SALT
7585 | OPTI_TYPE_RAW_HASH;
7586 dgst_pos0 = 0;
7587 dgst_pos1 = 3;
7588 dgst_pos2 = 2;
7589 dgst_pos3 = 1;
7590 break;
7591
7592 case 23: hash_type = HASH_TYPE_MD5;
7593 salt_type = SALT_TYPE_EMBEDDED;
7594 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7595 opts_type = OPTS_TYPE_PT_GENERATE_LE
7596 | OPTS_TYPE_PT_ADD80
7597 | OPTS_TYPE_PT_ADDBITS14;
7598 kern_type = KERN_TYPE_MD5_SLTPW;
7599 dgst_size = DGST_SIZE_4_4;
7600 parse_func = skype_parse_hash;
7601 sort_by_digest = sort_by_digest_4_4;
7602 opti_type = OPTI_TYPE_ZERO_BYTE
7603 | OPTI_TYPE_PRECOMPUTE_INIT
7604 | OPTI_TYPE_PRECOMPUTE_MERKLE
7605 | OPTI_TYPE_EARLY_SKIP
7606 | OPTI_TYPE_NOT_ITERATED
7607 | OPTI_TYPE_PREPENDED_SALT
7608 | OPTI_TYPE_RAW_HASH;
7609 dgst_pos0 = 0;
7610 dgst_pos1 = 3;
7611 dgst_pos2 = 2;
7612 dgst_pos3 = 1;
7613 break;
7614
7615 case 30: hash_type = HASH_TYPE_MD5;
7616 salt_type = SALT_TYPE_INTERN;
7617 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7618 opts_type = OPTS_TYPE_PT_GENERATE_LE
7619 | OPTS_TYPE_PT_UNICODE
7620 | OPTS_TYPE_ST_ADD80
7621 | OPTS_TYPE_ST_ADDBITS14;
7622 kern_type = KERN_TYPE_MD5_PWUSLT;
7623 dgst_size = DGST_SIZE_4_4;
7624 parse_func = md5s_parse_hash;
7625 sort_by_digest = sort_by_digest_4_4;
7626 opti_type = OPTI_TYPE_ZERO_BYTE
7627 | OPTI_TYPE_PRECOMPUTE_INIT
7628 | OPTI_TYPE_PRECOMPUTE_MERKLE
7629 | OPTI_TYPE_MEET_IN_MIDDLE
7630 | OPTI_TYPE_EARLY_SKIP
7631 | OPTI_TYPE_NOT_ITERATED
7632 | OPTI_TYPE_APPENDED_SALT
7633 | OPTI_TYPE_RAW_HASH;
7634 dgst_pos0 = 0;
7635 dgst_pos1 = 3;
7636 dgst_pos2 = 2;
7637 dgst_pos3 = 1;
7638 break;
7639
7640 case 40: hash_type = HASH_TYPE_MD5;
7641 salt_type = SALT_TYPE_INTERN;
7642 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7643 opts_type = OPTS_TYPE_PT_GENERATE_LE
7644 | OPTS_TYPE_PT_ADD80
7645 | OPTS_TYPE_PT_ADDBITS14
7646 | OPTS_TYPE_PT_UNICODE;
7647 kern_type = KERN_TYPE_MD5_SLTPWU;
7648 dgst_size = DGST_SIZE_4_4;
7649 parse_func = md5s_parse_hash;
7650 sort_by_digest = sort_by_digest_4_4;
7651 opti_type = OPTI_TYPE_ZERO_BYTE
7652 | OPTI_TYPE_PRECOMPUTE_INIT
7653 | OPTI_TYPE_PRECOMPUTE_MERKLE
7654 | OPTI_TYPE_EARLY_SKIP
7655 | OPTI_TYPE_NOT_ITERATED
7656 | OPTI_TYPE_PREPENDED_SALT
7657 | OPTI_TYPE_RAW_HASH;
7658 dgst_pos0 = 0;
7659 dgst_pos1 = 3;
7660 dgst_pos2 = 2;
7661 dgst_pos3 = 1;
7662 break;
7663
7664 case 50: hash_type = HASH_TYPE_MD5;
7665 salt_type = SALT_TYPE_INTERN;
7666 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7667 opts_type = OPTS_TYPE_PT_GENERATE_LE
7668 | OPTS_TYPE_ST_ADD80
7669 | OPTS_TYPE_ST_ADDBITS14;
7670 kern_type = KERN_TYPE_HMACMD5_PW;
7671 dgst_size = DGST_SIZE_4_4;
7672 parse_func = hmacmd5_parse_hash;
7673 sort_by_digest = sort_by_digest_4_4;
7674 opti_type = OPTI_TYPE_ZERO_BYTE
7675 | OPTI_TYPE_NOT_ITERATED;
7676 dgst_pos0 = 0;
7677 dgst_pos1 = 3;
7678 dgst_pos2 = 2;
7679 dgst_pos3 = 1;
7680 break;
7681
7682 case 60: hash_type = HASH_TYPE_MD5;
7683 salt_type = SALT_TYPE_INTERN;
7684 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7685 opts_type = OPTS_TYPE_PT_GENERATE_LE
7686 | OPTS_TYPE_PT_ADD80
7687 | OPTS_TYPE_PT_ADDBITS14;
7688 kern_type = KERN_TYPE_HMACMD5_SLT;
7689 dgst_size = DGST_SIZE_4_4;
7690 parse_func = hmacmd5_parse_hash;
7691 sort_by_digest = sort_by_digest_4_4;
7692 opti_type = OPTI_TYPE_ZERO_BYTE
7693 | OPTI_TYPE_NOT_ITERATED;
7694 dgst_pos0 = 0;
7695 dgst_pos1 = 3;
7696 dgst_pos2 = 2;
7697 dgst_pos3 = 1;
7698 break;
7699
7700 case 100: hash_type = HASH_TYPE_SHA1;
7701 salt_type = SALT_TYPE_NONE;
7702 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7703 opts_type = OPTS_TYPE_PT_GENERATE_BE
7704 | OPTS_TYPE_PT_ADD80
7705 | OPTS_TYPE_PT_ADDBITS15;
7706 kern_type = KERN_TYPE_SHA1;
7707 dgst_size = DGST_SIZE_4_5;
7708 parse_func = sha1_parse_hash;
7709 sort_by_digest = sort_by_digest_4_5;
7710 opti_type = OPTI_TYPE_ZERO_BYTE
7711 | OPTI_TYPE_PRECOMPUTE_INIT
7712 | OPTI_TYPE_PRECOMPUTE_MERKLE
7713 | OPTI_TYPE_EARLY_SKIP
7714 | OPTI_TYPE_NOT_ITERATED
7715 | OPTI_TYPE_NOT_SALTED
7716 | OPTI_TYPE_RAW_HASH;
7717 dgst_pos0 = 3;
7718 dgst_pos1 = 4;
7719 dgst_pos2 = 2;
7720 dgst_pos3 = 1;
7721 break;
7722
7723 case 101: hash_type = HASH_TYPE_SHA1;
7724 salt_type = SALT_TYPE_NONE;
7725 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7726 opts_type = OPTS_TYPE_PT_GENERATE_BE
7727 | OPTS_TYPE_PT_ADD80
7728 | OPTS_TYPE_PT_ADDBITS15;
7729 kern_type = KERN_TYPE_SHA1;
7730 dgst_size = DGST_SIZE_4_5;
7731 parse_func = sha1b64_parse_hash;
7732 sort_by_digest = sort_by_digest_4_5;
7733 opti_type = OPTI_TYPE_ZERO_BYTE
7734 | OPTI_TYPE_PRECOMPUTE_INIT
7735 | OPTI_TYPE_PRECOMPUTE_MERKLE
7736 | OPTI_TYPE_EARLY_SKIP
7737 | OPTI_TYPE_NOT_ITERATED
7738 | OPTI_TYPE_NOT_SALTED
7739 | OPTI_TYPE_RAW_HASH;
7740 dgst_pos0 = 3;
7741 dgst_pos1 = 4;
7742 dgst_pos2 = 2;
7743 dgst_pos3 = 1;
7744 break;
7745
7746 case 110: hash_type = HASH_TYPE_SHA1;
7747 salt_type = SALT_TYPE_INTERN;
7748 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7749 opts_type = OPTS_TYPE_PT_GENERATE_BE
7750 | OPTS_TYPE_ST_ADD80
7751 | OPTS_TYPE_ST_ADDBITS15;
7752 kern_type = KERN_TYPE_SHA1_PWSLT;
7753 dgst_size = DGST_SIZE_4_5;
7754 parse_func = sha1s_parse_hash;
7755 sort_by_digest = sort_by_digest_4_5;
7756 opti_type = OPTI_TYPE_ZERO_BYTE
7757 | OPTI_TYPE_PRECOMPUTE_INIT
7758 | OPTI_TYPE_PRECOMPUTE_MERKLE
7759 | OPTI_TYPE_EARLY_SKIP
7760 | OPTI_TYPE_NOT_ITERATED
7761 | OPTI_TYPE_APPENDED_SALT
7762 | OPTI_TYPE_RAW_HASH;
7763 dgst_pos0 = 3;
7764 dgst_pos1 = 4;
7765 dgst_pos2 = 2;
7766 dgst_pos3 = 1;
7767 break;
7768
7769 case 111: hash_type = HASH_TYPE_SHA1;
7770 salt_type = SALT_TYPE_EMBEDDED;
7771 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7772 opts_type = OPTS_TYPE_PT_GENERATE_BE
7773 | OPTS_TYPE_ST_ADD80
7774 | OPTS_TYPE_ST_ADDBITS15;
7775 kern_type = KERN_TYPE_SHA1_PWSLT;
7776 dgst_size = DGST_SIZE_4_5;
7777 parse_func = sha1b64s_parse_hash;
7778 sort_by_digest = sort_by_digest_4_5;
7779 opti_type = OPTI_TYPE_ZERO_BYTE
7780 | OPTI_TYPE_PRECOMPUTE_INIT
7781 | OPTI_TYPE_PRECOMPUTE_MERKLE
7782 | OPTI_TYPE_EARLY_SKIP
7783 | OPTI_TYPE_NOT_ITERATED
7784 | OPTI_TYPE_APPENDED_SALT
7785 | OPTI_TYPE_RAW_HASH;
7786 dgst_pos0 = 3;
7787 dgst_pos1 = 4;
7788 dgst_pos2 = 2;
7789 dgst_pos3 = 1;
7790 break;
7791
7792 case 112: hash_type = HASH_TYPE_SHA1;
7793 salt_type = SALT_TYPE_INTERN;
7794 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7795 opts_type = OPTS_TYPE_PT_GENERATE_BE
7796 | OPTS_TYPE_ST_ADD80
7797 | OPTS_TYPE_ST_ADDBITS15
7798 | OPTS_TYPE_ST_HEX;
7799 kern_type = KERN_TYPE_SHA1_PWSLT;
7800 dgst_size = DGST_SIZE_4_5;
7801 parse_func = oracles_parse_hash;
7802 sort_by_digest = sort_by_digest_4_5;
7803 opti_type = OPTI_TYPE_ZERO_BYTE
7804 | OPTI_TYPE_PRECOMPUTE_INIT
7805 | OPTI_TYPE_PRECOMPUTE_MERKLE
7806 | OPTI_TYPE_EARLY_SKIP
7807 | OPTI_TYPE_NOT_ITERATED
7808 | OPTI_TYPE_APPENDED_SALT
7809 | OPTI_TYPE_RAW_HASH;
7810 dgst_pos0 = 3;
7811 dgst_pos1 = 4;
7812 dgst_pos2 = 2;
7813 dgst_pos3 = 1;
7814 break;
7815
7816 case 120: hash_type = HASH_TYPE_SHA1;
7817 salt_type = SALT_TYPE_INTERN;
7818 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7819 opts_type = OPTS_TYPE_PT_GENERATE_BE
7820 | OPTS_TYPE_PT_ADD80
7821 | OPTS_TYPE_PT_ADDBITS15;
7822 kern_type = KERN_TYPE_SHA1_SLTPW;
7823 dgst_size = DGST_SIZE_4_5;
7824 parse_func = sha1s_parse_hash;
7825 sort_by_digest = sort_by_digest_4_5;
7826 opti_type = OPTI_TYPE_ZERO_BYTE
7827 | OPTI_TYPE_PRECOMPUTE_INIT
7828 | OPTI_TYPE_PRECOMPUTE_MERKLE
7829 | OPTI_TYPE_EARLY_SKIP
7830 | OPTI_TYPE_NOT_ITERATED
7831 | OPTI_TYPE_PREPENDED_SALT
7832 | OPTI_TYPE_RAW_HASH;
7833 dgst_pos0 = 3;
7834 dgst_pos1 = 4;
7835 dgst_pos2 = 2;
7836 dgst_pos3 = 1;
7837 break;
7838
7839 case 121: hash_type = HASH_TYPE_SHA1;
7840 salt_type = SALT_TYPE_INTERN;
7841 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7842 opts_type = OPTS_TYPE_PT_GENERATE_BE
7843 | OPTS_TYPE_PT_ADD80
7844 | OPTS_TYPE_PT_ADDBITS15
7845 | OPTS_TYPE_ST_LOWER;
7846 kern_type = KERN_TYPE_SHA1_SLTPW;
7847 dgst_size = DGST_SIZE_4_5;
7848 parse_func = smf_parse_hash;
7849 sort_by_digest = sort_by_digest_4_5;
7850 opti_type = OPTI_TYPE_ZERO_BYTE
7851 | OPTI_TYPE_PRECOMPUTE_INIT
7852 | OPTI_TYPE_PRECOMPUTE_MERKLE
7853 | OPTI_TYPE_EARLY_SKIP
7854 | OPTI_TYPE_NOT_ITERATED
7855 | OPTI_TYPE_PREPENDED_SALT
7856 | OPTI_TYPE_RAW_HASH;
7857 dgst_pos0 = 3;
7858 dgst_pos1 = 4;
7859 dgst_pos2 = 2;
7860 dgst_pos3 = 1;
7861 break;
7862
7863 case 122: hash_type = HASH_TYPE_SHA1;
7864 salt_type = SALT_TYPE_EMBEDDED;
7865 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7866 opts_type = OPTS_TYPE_PT_GENERATE_BE
7867 | OPTS_TYPE_PT_ADD80
7868 | OPTS_TYPE_PT_ADDBITS15
7869 | OPTS_TYPE_ST_HEX;
7870 kern_type = KERN_TYPE_SHA1_SLTPW;
7871 dgst_size = DGST_SIZE_4_5;
7872 parse_func = osx1_parse_hash;
7873 sort_by_digest = sort_by_digest_4_5;
7874 opti_type = OPTI_TYPE_ZERO_BYTE
7875 | OPTI_TYPE_PRECOMPUTE_INIT
7876 | OPTI_TYPE_PRECOMPUTE_MERKLE
7877 | OPTI_TYPE_EARLY_SKIP
7878 | OPTI_TYPE_NOT_ITERATED
7879 | OPTI_TYPE_PREPENDED_SALT
7880 | OPTI_TYPE_RAW_HASH;
7881 dgst_pos0 = 3;
7882 dgst_pos1 = 4;
7883 dgst_pos2 = 2;
7884 dgst_pos3 = 1;
7885 break;
7886
7887 case 124: hash_type = HASH_TYPE_SHA1;
7888 salt_type = SALT_TYPE_EMBEDDED;
7889 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7890 opts_type = OPTS_TYPE_PT_GENERATE_BE
7891 | OPTS_TYPE_PT_ADD80
7892 | OPTS_TYPE_PT_ADDBITS15;
7893 kern_type = KERN_TYPE_SHA1_SLTPW;
7894 dgst_size = DGST_SIZE_4_5;
7895 parse_func = djangosha1_parse_hash;
7896 sort_by_digest = sort_by_digest_4_5;
7897 opti_type = OPTI_TYPE_ZERO_BYTE
7898 | OPTI_TYPE_PRECOMPUTE_INIT
7899 | OPTI_TYPE_PRECOMPUTE_MERKLE
7900 | OPTI_TYPE_EARLY_SKIP
7901 | OPTI_TYPE_NOT_ITERATED
7902 | OPTI_TYPE_PREPENDED_SALT
7903 | OPTI_TYPE_RAW_HASH;
7904 dgst_pos0 = 3;
7905 dgst_pos1 = 4;
7906 dgst_pos2 = 2;
7907 dgst_pos3 = 1;
7908 break;
7909
7910 case 125: hash_type = HASH_TYPE_SHA1;
7911 salt_type = SALT_TYPE_EMBEDDED;
7912 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7913 opts_type = OPTS_TYPE_PT_GENERATE_BE
7914 | OPTS_TYPE_PT_ADD80
7915 | OPTS_TYPE_PT_ADDBITS15
7916 | OPTS_TYPE_ST_HEX;
7917 kern_type = KERN_TYPE_SHA1_SLTPW;
7918 dgst_size = DGST_SIZE_4_5;
7919 parse_func = arubaos_parse_hash;
7920 sort_by_digest = sort_by_digest_4_5;
7921 opti_type = OPTI_TYPE_ZERO_BYTE
7922 | OPTI_TYPE_PRECOMPUTE_INIT
7923 | OPTI_TYPE_PRECOMPUTE_MERKLE
7924 | OPTI_TYPE_EARLY_SKIP
7925 | OPTI_TYPE_NOT_ITERATED
7926 | OPTI_TYPE_PREPENDED_SALT
7927 | OPTI_TYPE_RAW_HASH;
7928 dgst_pos0 = 3;
7929 dgst_pos1 = 4;
7930 dgst_pos2 = 2;
7931 dgst_pos3 = 1;
7932 break;
7933
7934 case 130: hash_type = HASH_TYPE_SHA1;
7935 salt_type = SALT_TYPE_INTERN;
7936 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7937 opts_type = OPTS_TYPE_PT_GENERATE_BE
7938 | OPTS_TYPE_PT_UNICODE
7939 | OPTS_TYPE_ST_ADD80
7940 | OPTS_TYPE_ST_ADDBITS15;
7941 kern_type = KERN_TYPE_SHA1_PWUSLT;
7942 dgst_size = DGST_SIZE_4_5;
7943 parse_func = sha1s_parse_hash;
7944 sort_by_digest = sort_by_digest_4_5;
7945 opti_type = OPTI_TYPE_ZERO_BYTE
7946 | OPTI_TYPE_PRECOMPUTE_INIT
7947 | OPTI_TYPE_PRECOMPUTE_MERKLE
7948 | OPTI_TYPE_EARLY_SKIP
7949 | OPTI_TYPE_NOT_ITERATED
7950 | OPTI_TYPE_APPENDED_SALT
7951 | OPTI_TYPE_RAW_HASH;
7952 dgst_pos0 = 3;
7953 dgst_pos1 = 4;
7954 dgst_pos2 = 2;
7955 dgst_pos3 = 1;
7956 break;
7957
7958 case 131: hash_type = HASH_TYPE_SHA1;
7959 salt_type = SALT_TYPE_EMBEDDED;
7960 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7961 opts_type = OPTS_TYPE_PT_GENERATE_BE
7962 | OPTS_TYPE_PT_UNICODE
7963 | OPTS_TYPE_PT_UPPER
7964 | OPTS_TYPE_ST_ADD80
7965 | OPTS_TYPE_ST_ADDBITS15
7966 | OPTS_TYPE_ST_HEX;
7967 kern_type = KERN_TYPE_SHA1_PWUSLT;
7968 dgst_size = DGST_SIZE_4_5;
7969 parse_func = mssql2000_parse_hash;
7970 sort_by_digest = sort_by_digest_4_5;
7971 opti_type = OPTI_TYPE_ZERO_BYTE
7972 | OPTI_TYPE_PRECOMPUTE_INIT
7973 | OPTI_TYPE_PRECOMPUTE_MERKLE
7974 | OPTI_TYPE_EARLY_SKIP
7975 | OPTI_TYPE_NOT_ITERATED
7976 | OPTI_TYPE_APPENDED_SALT
7977 | OPTI_TYPE_RAW_HASH;
7978 dgst_pos0 = 3;
7979 dgst_pos1 = 4;
7980 dgst_pos2 = 2;
7981 dgst_pos3 = 1;
7982 break;
7983
7984 case 132: hash_type = HASH_TYPE_SHA1;
7985 salt_type = SALT_TYPE_EMBEDDED;
7986 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7987 opts_type = OPTS_TYPE_PT_GENERATE_BE
7988 | OPTS_TYPE_PT_UNICODE
7989 | OPTS_TYPE_ST_ADD80
7990 | OPTS_TYPE_ST_ADDBITS15
7991 | OPTS_TYPE_ST_HEX;
7992 kern_type = KERN_TYPE_SHA1_PWUSLT;
7993 dgst_size = DGST_SIZE_4_5;
7994 parse_func = mssql2005_parse_hash;
7995 sort_by_digest = sort_by_digest_4_5;
7996 opti_type = OPTI_TYPE_ZERO_BYTE
7997 | OPTI_TYPE_PRECOMPUTE_INIT
7998 | OPTI_TYPE_PRECOMPUTE_MERKLE
7999 | OPTI_TYPE_EARLY_SKIP
8000 | OPTI_TYPE_NOT_ITERATED
8001 | OPTI_TYPE_APPENDED_SALT
8002 | OPTI_TYPE_RAW_HASH;
8003 dgst_pos0 = 3;
8004 dgst_pos1 = 4;
8005 dgst_pos2 = 2;
8006 dgst_pos3 = 1;
8007 break;
8008
8009 case 133: hash_type = HASH_TYPE_SHA1;
8010 salt_type = SALT_TYPE_EMBEDDED;
8011 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8012 opts_type = OPTS_TYPE_PT_GENERATE_BE
8013 | OPTS_TYPE_PT_UNICODE
8014 | OPTS_TYPE_ST_ADD80
8015 | OPTS_TYPE_ST_ADDBITS15;
8016 kern_type = KERN_TYPE_SHA1_PWUSLT;
8017 dgst_size = DGST_SIZE_4_5;
8018 parse_func = peoplesoft_parse_hash;
8019 sort_by_digest = sort_by_digest_4_5;
8020 opti_type = OPTI_TYPE_ZERO_BYTE
8021 | OPTI_TYPE_PRECOMPUTE_INIT
8022 | OPTI_TYPE_PRECOMPUTE_MERKLE
8023 | OPTI_TYPE_EARLY_SKIP
8024 | OPTI_TYPE_NOT_ITERATED
8025 | OPTI_TYPE_APPENDED_SALT
8026 | OPTI_TYPE_RAW_HASH;
8027 dgst_pos0 = 3;
8028 dgst_pos1 = 4;
8029 dgst_pos2 = 2;
8030 dgst_pos3 = 1;
8031 break;
8032
8033 case 140: hash_type = HASH_TYPE_SHA1;
8034 salt_type = SALT_TYPE_INTERN;
8035 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8036 opts_type = OPTS_TYPE_PT_GENERATE_BE
8037 | OPTS_TYPE_PT_ADD80
8038 | OPTS_TYPE_PT_ADDBITS15
8039 | OPTS_TYPE_PT_UNICODE;
8040 kern_type = KERN_TYPE_SHA1_SLTPWU;
8041 dgst_size = DGST_SIZE_4_5;
8042 parse_func = sha1s_parse_hash;
8043 sort_by_digest = sort_by_digest_4_5;
8044 opti_type = OPTI_TYPE_ZERO_BYTE
8045 | OPTI_TYPE_PRECOMPUTE_INIT
8046 | OPTI_TYPE_PRECOMPUTE_MERKLE
8047 | OPTI_TYPE_EARLY_SKIP
8048 | OPTI_TYPE_NOT_ITERATED
8049 | OPTI_TYPE_PREPENDED_SALT
8050 | OPTI_TYPE_RAW_HASH;
8051 dgst_pos0 = 3;
8052 dgst_pos1 = 4;
8053 dgst_pos2 = 2;
8054 dgst_pos3 = 1;
8055 break;
8056
8057 case 141: hash_type = HASH_TYPE_SHA1;
8058 salt_type = SALT_TYPE_EMBEDDED;
8059 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8060 opts_type = OPTS_TYPE_PT_GENERATE_BE
8061 | OPTS_TYPE_PT_ADD80
8062 | OPTS_TYPE_PT_ADDBITS15
8063 | OPTS_TYPE_PT_UNICODE
8064 | OPTS_TYPE_ST_BASE64;
8065 kern_type = KERN_TYPE_SHA1_SLTPWU;
8066 dgst_size = DGST_SIZE_4_5;
8067 parse_func = episerver_parse_hash;
8068 sort_by_digest = sort_by_digest_4_5;
8069 opti_type = OPTI_TYPE_ZERO_BYTE
8070 | OPTI_TYPE_PRECOMPUTE_INIT
8071 | OPTI_TYPE_PRECOMPUTE_MERKLE
8072 | OPTI_TYPE_EARLY_SKIP
8073 | OPTI_TYPE_NOT_ITERATED
8074 | OPTI_TYPE_PREPENDED_SALT
8075 | OPTI_TYPE_RAW_HASH;
8076 dgst_pos0 = 3;
8077 dgst_pos1 = 4;
8078 dgst_pos2 = 2;
8079 dgst_pos3 = 1;
8080 break;
8081
8082 case 150: hash_type = HASH_TYPE_SHA1;
8083 salt_type = SALT_TYPE_INTERN;
8084 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8085 opts_type = OPTS_TYPE_PT_GENERATE_BE
8086 | OPTS_TYPE_ST_ADD80
8087 | OPTS_TYPE_ST_ADDBITS15;
8088 kern_type = KERN_TYPE_HMACSHA1_PW;
8089 dgst_size = DGST_SIZE_4_5;
8090 parse_func = hmacsha1_parse_hash;
8091 sort_by_digest = sort_by_digest_4_5;
8092 opti_type = OPTI_TYPE_ZERO_BYTE
8093 | OPTI_TYPE_NOT_ITERATED;
8094 dgst_pos0 = 3;
8095 dgst_pos1 = 4;
8096 dgst_pos2 = 2;
8097 dgst_pos3 = 1;
8098 break;
8099
8100 case 160: hash_type = HASH_TYPE_SHA1;
8101 salt_type = SALT_TYPE_INTERN;
8102 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8103 opts_type = OPTS_TYPE_PT_GENERATE_BE
8104 | OPTS_TYPE_PT_ADD80
8105 | OPTS_TYPE_PT_ADDBITS15;
8106 kern_type = KERN_TYPE_HMACSHA1_SLT;
8107 dgst_size = DGST_SIZE_4_5;
8108 parse_func = hmacsha1_parse_hash;
8109 sort_by_digest = sort_by_digest_4_5;
8110 opti_type = OPTI_TYPE_ZERO_BYTE
8111 | OPTI_TYPE_NOT_ITERATED;
8112 dgst_pos0 = 3;
8113 dgst_pos1 = 4;
8114 dgst_pos2 = 2;
8115 dgst_pos3 = 1;
8116 break;
8117
8118 case 200: hash_type = HASH_TYPE_MYSQL;
8119 salt_type = SALT_TYPE_NONE;
8120 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8121 opts_type = 0;
8122 kern_type = KERN_TYPE_MYSQL;
8123 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8124 parse_func = mysql323_parse_hash;
8125 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8126 opti_type = OPTI_TYPE_ZERO_BYTE;
8127 dgst_pos0 = 0;
8128 dgst_pos1 = 1;
8129 dgst_pos2 = 2;
8130 dgst_pos3 = 3;
8131 break;
8132
8133 case 300: hash_type = HASH_TYPE_SHA1;
8134 salt_type = SALT_TYPE_NONE;
8135 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8136 opts_type = OPTS_TYPE_PT_GENERATE_BE
8137 | OPTS_TYPE_PT_ADD80
8138 | OPTS_TYPE_PT_ADDBITS15;
8139 kern_type = KERN_TYPE_MYSQL41;
8140 dgst_size = DGST_SIZE_4_5;
8141 parse_func = sha1_parse_hash;
8142 sort_by_digest = sort_by_digest_4_5;
8143 opti_type = OPTI_TYPE_ZERO_BYTE
8144 | OPTI_TYPE_PRECOMPUTE_INIT
8145 | OPTI_TYPE_PRECOMPUTE_MERKLE
8146 | OPTI_TYPE_EARLY_SKIP
8147 | OPTI_TYPE_NOT_ITERATED
8148 | OPTI_TYPE_NOT_SALTED;
8149 dgst_pos0 = 3;
8150 dgst_pos1 = 4;
8151 dgst_pos2 = 2;
8152 dgst_pos3 = 1;
8153 break;
8154
8155 case 400: hash_type = HASH_TYPE_MD5;
8156 salt_type = SALT_TYPE_EMBEDDED;
8157 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8158 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8159 kern_type = KERN_TYPE_PHPASS;
8160 dgst_size = DGST_SIZE_4_4;
8161 parse_func = phpass_parse_hash;
8162 sort_by_digest = sort_by_digest_4_4;
8163 opti_type = OPTI_TYPE_ZERO_BYTE
8164 | OPTI_TYPE_SLOW_HASH_SIMD;
8165 dgst_pos0 = 0;
8166 dgst_pos1 = 1;
8167 dgst_pos2 = 2;
8168 dgst_pos3 = 3;
8169 break;
8170
8171 case 500: hash_type = HASH_TYPE_MD5;
8172 salt_type = SALT_TYPE_EMBEDDED;
8173 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8174 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8175 kern_type = KERN_TYPE_MD5CRYPT;
8176 dgst_size = DGST_SIZE_4_4;
8177 parse_func = md5crypt_parse_hash;
8178 sort_by_digest = sort_by_digest_4_4;
8179 opti_type = OPTI_TYPE_ZERO_BYTE;
8180 dgst_pos0 = 0;
8181 dgst_pos1 = 1;
8182 dgst_pos2 = 2;
8183 dgst_pos3 = 3;
8184 break;
8185
8186 case 501: hash_type = HASH_TYPE_MD5;
8187 salt_type = SALT_TYPE_EMBEDDED;
8188 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8189 opts_type = OPTS_TYPE_PT_GENERATE_LE
8190 | OPTS_TYPE_HASH_COPY;
8191 kern_type = KERN_TYPE_MD5CRYPT;
8192 dgst_size = DGST_SIZE_4_4;
8193 parse_func = juniper_parse_hash;
8194 sort_by_digest = sort_by_digest_4_4;
8195 opti_type = OPTI_TYPE_ZERO_BYTE;
8196 dgst_pos0 = 0;
8197 dgst_pos1 = 1;
8198 dgst_pos2 = 2;
8199 dgst_pos3 = 3;
8200 break;
8201
8202 case 900: hash_type = HASH_TYPE_MD4;
8203 salt_type = SALT_TYPE_NONE;
8204 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8205 opts_type = OPTS_TYPE_PT_GENERATE_LE
8206 | OPTS_TYPE_PT_ADD80
8207 | OPTS_TYPE_PT_ADDBITS14;
8208 kern_type = KERN_TYPE_MD4;
8209 dgst_size = DGST_SIZE_4_4;
8210 parse_func = md4_parse_hash;
8211 sort_by_digest = sort_by_digest_4_4;
8212 opti_type = OPTI_TYPE_ZERO_BYTE
8213 | OPTI_TYPE_PRECOMPUTE_INIT
8214 | OPTI_TYPE_PRECOMPUTE_MERKLE
8215 | OPTI_TYPE_MEET_IN_MIDDLE
8216 | OPTI_TYPE_EARLY_SKIP
8217 | OPTI_TYPE_NOT_ITERATED
8218 | OPTI_TYPE_NOT_SALTED
8219 | OPTI_TYPE_RAW_HASH;
8220 dgst_pos0 = 0;
8221 dgst_pos1 = 3;
8222 dgst_pos2 = 2;
8223 dgst_pos3 = 1;
8224 break;
8225
8226 case 1000: hash_type = HASH_TYPE_MD4;
8227 salt_type = SALT_TYPE_NONE;
8228 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8229 opts_type = OPTS_TYPE_PT_GENERATE_LE
8230 | OPTS_TYPE_PT_ADD80
8231 | OPTS_TYPE_PT_ADDBITS14
8232 | OPTS_TYPE_PT_UNICODE;
8233 kern_type = KERN_TYPE_MD4_PWU;
8234 dgst_size = DGST_SIZE_4_4;
8235 parse_func = md4_parse_hash;
8236 sort_by_digest = sort_by_digest_4_4;
8237 opti_type = OPTI_TYPE_ZERO_BYTE
8238 | OPTI_TYPE_PRECOMPUTE_INIT
8239 | OPTI_TYPE_PRECOMPUTE_MERKLE
8240 | OPTI_TYPE_MEET_IN_MIDDLE
8241 | OPTI_TYPE_EARLY_SKIP
8242 | OPTI_TYPE_NOT_ITERATED
8243 | OPTI_TYPE_NOT_SALTED
8244 | OPTI_TYPE_RAW_HASH;
8245 dgst_pos0 = 0;
8246 dgst_pos1 = 3;
8247 dgst_pos2 = 2;
8248 dgst_pos3 = 1;
8249 break;
8250
8251 case 1100: hash_type = HASH_TYPE_MD4;
8252 salt_type = SALT_TYPE_INTERN;
8253 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8254 opts_type = OPTS_TYPE_PT_GENERATE_LE
8255 | OPTS_TYPE_PT_ADD80
8256 | OPTS_TYPE_PT_ADDBITS14
8257 | OPTS_TYPE_PT_UNICODE
8258 | OPTS_TYPE_ST_ADD80
8259 | OPTS_TYPE_ST_UNICODE
8260 | OPTS_TYPE_ST_LOWER;
8261 kern_type = KERN_TYPE_MD44_PWUSLT;
8262 dgst_size = DGST_SIZE_4_4;
8263 parse_func = dcc_parse_hash;
8264 sort_by_digest = sort_by_digest_4_4;
8265 opti_type = OPTI_TYPE_ZERO_BYTE
8266 | OPTI_TYPE_PRECOMPUTE_INIT
8267 | OPTI_TYPE_PRECOMPUTE_MERKLE
8268 | OPTI_TYPE_EARLY_SKIP
8269 | OPTI_TYPE_NOT_ITERATED;
8270 dgst_pos0 = 0;
8271 dgst_pos1 = 3;
8272 dgst_pos2 = 2;
8273 dgst_pos3 = 1;
8274 break;
8275
8276 case 1400: hash_type = HASH_TYPE_SHA256;
8277 salt_type = SALT_TYPE_NONE;
8278 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8279 opts_type = OPTS_TYPE_PT_GENERATE_BE
8280 | OPTS_TYPE_PT_ADD80
8281 | OPTS_TYPE_PT_ADDBITS15;
8282 kern_type = KERN_TYPE_SHA256;
8283 dgst_size = DGST_SIZE_4_8;
8284 parse_func = sha256_parse_hash;
8285 sort_by_digest = sort_by_digest_4_8;
8286 opti_type = OPTI_TYPE_ZERO_BYTE
8287 | OPTI_TYPE_PRECOMPUTE_INIT
8288 | OPTI_TYPE_PRECOMPUTE_MERKLE
8289 | OPTI_TYPE_EARLY_SKIP
8290 | OPTI_TYPE_NOT_ITERATED
8291 | OPTI_TYPE_NOT_SALTED
8292 | OPTI_TYPE_RAW_HASH;
8293 dgst_pos0 = 3;
8294 dgst_pos1 = 7;
8295 dgst_pos2 = 2;
8296 dgst_pos3 = 6;
8297 break;
8298
8299 case 1410: hash_type = HASH_TYPE_SHA256;
8300 salt_type = SALT_TYPE_INTERN;
8301 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8302 opts_type = OPTS_TYPE_PT_GENERATE_BE
8303 | OPTS_TYPE_ST_ADD80
8304 | OPTS_TYPE_ST_ADDBITS15;
8305 kern_type = KERN_TYPE_SHA256_PWSLT;
8306 dgst_size = DGST_SIZE_4_8;
8307 parse_func = sha256s_parse_hash;
8308 sort_by_digest = sort_by_digest_4_8;
8309 opti_type = OPTI_TYPE_ZERO_BYTE
8310 | OPTI_TYPE_PRECOMPUTE_INIT
8311 | OPTI_TYPE_PRECOMPUTE_MERKLE
8312 | OPTI_TYPE_EARLY_SKIP
8313 | OPTI_TYPE_NOT_ITERATED
8314 | OPTI_TYPE_APPENDED_SALT
8315 | OPTI_TYPE_RAW_HASH;
8316 dgst_pos0 = 3;
8317 dgst_pos1 = 7;
8318 dgst_pos2 = 2;
8319 dgst_pos3 = 6;
8320 break;
8321
8322 case 1420: hash_type = HASH_TYPE_SHA256;
8323 salt_type = SALT_TYPE_INTERN;
8324 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8325 opts_type = OPTS_TYPE_PT_GENERATE_BE
8326 | OPTS_TYPE_PT_ADD80
8327 | OPTS_TYPE_PT_ADDBITS15;
8328 kern_type = KERN_TYPE_SHA256_SLTPW;
8329 dgst_size = DGST_SIZE_4_8;
8330 parse_func = sha256s_parse_hash;
8331 sort_by_digest = sort_by_digest_4_8;
8332 opti_type = OPTI_TYPE_ZERO_BYTE
8333 | OPTI_TYPE_PRECOMPUTE_INIT
8334 | OPTI_TYPE_PRECOMPUTE_MERKLE
8335 | OPTI_TYPE_EARLY_SKIP
8336 | OPTI_TYPE_NOT_ITERATED
8337 | OPTI_TYPE_PREPENDED_SALT
8338 | OPTI_TYPE_RAW_HASH;
8339 dgst_pos0 = 3;
8340 dgst_pos1 = 7;
8341 dgst_pos2 = 2;
8342 dgst_pos3 = 6;
8343 break;
8344
8345 case 1421: hash_type = HASH_TYPE_SHA256;
8346 salt_type = SALT_TYPE_EMBEDDED;
8347 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8348 opts_type = OPTS_TYPE_PT_GENERATE_BE
8349 | OPTS_TYPE_PT_ADD80
8350 | OPTS_TYPE_PT_ADDBITS15;
8351 kern_type = KERN_TYPE_SHA256_SLTPW;
8352 dgst_size = DGST_SIZE_4_8;
8353 parse_func = hmailserver_parse_hash;
8354 sort_by_digest = sort_by_digest_4_8;
8355 opti_type = OPTI_TYPE_ZERO_BYTE
8356 | OPTI_TYPE_PRECOMPUTE_INIT
8357 | OPTI_TYPE_PRECOMPUTE_MERKLE
8358 | OPTI_TYPE_EARLY_SKIP
8359 | OPTI_TYPE_NOT_ITERATED
8360 | OPTI_TYPE_PREPENDED_SALT
8361 | OPTI_TYPE_RAW_HASH;
8362 dgst_pos0 = 3;
8363 dgst_pos1 = 7;
8364 dgst_pos2 = 2;
8365 dgst_pos3 = 6;
8366 break;
8367
8368 case 1430: hash_type = HASH_TYPE_SHA256;
8369 salt_type = SALT_TYPE_INTERN;
8370 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8371 opts_type = OPTS_TYPE_PT_GENERATE_BE
8372 | OPTS_TYPE_PT_UNICODE
8373 | OPTS_TYPE_ST_ADD80
8374 | OPTS_TYPE_ST_ADDBITS15;
8375 kern_type = KERN_TYPE_SHA256_PWUSLT;
8376 dgst_size = DGST_SIZE_4_8;
8377 parse_func = sha256s_parse_hash;
8378 sort_by_digest = sort_by_digest_4_8;
8379 opti_type = OPTI_TYPE_ZERO_BYTE
8380 | OPTI_TYPE_PRECOMPUTE_INIT
8381 | OPTI_TYPE_PRECOMPUTE_MERKLE
8382 | OPTI_TYPE_EARLY_SKIP
8383 | OPTI_TYPE_NOT_ITERATED
8384 | OPTI_TYPE_APPENDED_SALT
8385 | OPTI_TYPE_RAW_HASH;
8386 dgst_pos0 = 3;
8387 dgst_pos1 = 7;
8388 dgst_pos2 = 2;
8389 dgst_pos3 = 6;
8390 break;
8391
8392 case 1440: hash_type = HASH_TYPE_SHA256;
8393 salt_type = SALT_TYPE_INTERN;
8394 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8395 opts_type = OPTS_TYPE_PT_GENERATE_BE
8396 | OPTS_TYPE_PT_ADD80
8397 | OPTS_TYPE_PT_ADDBITS15
8398 | OPTS_TYPE_PT_UNICODE;
8399 kern_type = KERN_TYPE_SHA256_SLTPWU;
8400 dgst_size = DGST_SIZE_4_8;
8401 parse_func = sha256s_parse_hash;
8402 sort_by_digest = sort_by_digest_4_8;
8403 opti_type = OPTI_TYPE_ZERO_BYTE
8404 | OPTI_TYPE_PRECOMPUTE_INIT
8405 | OPTI_TYPE_PRECOMPUTE_MERKLE
8406 | OPTI_TYPE_EARLY_SKIP
8407 | OPTI_TYPE_NOT_ITERATED
8408 | OPTI_TYPE_PREPENDED_SALT
8409 | OPTI_TYPE_RAW_HASH;
8410 dgst_pos0 = 3;
8411 dgst_pos1 = 7;
8412 dgst_pos2 = 2;
8413 dgst_pos3 = 6;
8414 break;
8415
8416 case 1441: hash_type = HASH_TYPE_SHA256;
8417 salt_type = SALT_TYPE_EMBEDDED;
8418 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8419 opts_type = OPTS_TYPE_PT_GENERATE_BE
8420 | OPTS_TYPE_PT_ADD80
8421 | OPTS_TYPE_PT_ADDBITS15
8422 | OPTS_TYPE_PT_UNICODE
8423 | OPTS_TYPE_ST_BASE64;
8424 kern_type = KERN_TYPE_SHA256_SLTPWU;
8425 dgst_size = DGST_SIZE_4_8;
8426 parse_func = episerver4_parse_hash;
8427 sort_by_digest = sort_by_digest_4_8;
8428 opti_type = OPTI_TYPE_ZERO_BYTE
8429 | OPTI_TYPE_PRECOMPUTE_INIT
8430 | OPTI_TYPE_PRECOMPUTE_MERKLE
8431 | OPTI_TYPE_EARLY_SKIP
8432 | OPTI_TYPE_NOT_ITERATED
8433 | OPTI_TYPE_PREPENDED_SALT
8434 | OPTI_TYPE_RAW_HASH;
8435 dgst_pos0 = 3;
8436 dgst_pos1 = 7;
8437 dgst_pos2 = 2;
8438 dgst_pos3 = 6;
8439 break;
8440
8441 case 1450: hash_type = HASH_TYPE_SHA256;
8442 salt_type = SALT_TYPE_INTERN;
8443 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8444 opts_type = OPTS_TYPE_PT_GENERATE_BE
8445 | OPTS_TYPE_ST_ADD80;
8446 kern_type = KERN_TYPE_HMACSHA256_PW;
8447 dgst_size = DGST_SIZE_4_8;
8448 parse_func = hmacsha256_parse_hash;
8449 sort_by_digest = sort_by_digest_4_8;
8450 opti_type = OPTI_TYPE_ZERO_BYTE
8451 | OPTI_TYPE_NOT_ITERATED;
8452 dgst_pos0 = 3;
8453 dgst_pos1 = 7;
8454 dgst_pos2 = 2;
8455 dgst_pos3 = 6;
8456 break;
8457
8458 case 1460: hash_type = HASH_TYPE_SHA256;
8459 salt_type = SALT_TYPE_INTERN;
8460 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8461 opts_type = OPTS_TYPE_PT_GENERATE_BE
8462 | OPTS_TYPE_PT_ADD80
8463 | OPTS_TYPE_PT_ADDBITS15;
8464 kern_type = KERN_TYPE_HMACSHA256_SLT;
8465 dgst_size = DGST_SIZE_4_8;
8466 parse_func = hmacsha256_parse_hash;
8467 sort_by_digest = sort_by_digest_4_8;
8468 opti_type = OPTI_TYPE_ZERO_BYTE
8469 | OPTI_TYPE_NOT_ITERATED;
8470 dgst_pos0 = 3;
8471 dgst_pos1 = 7;
8472 dgst_pos2 = 2;
8473 dgst_pos3 = 6;
8474 break;
8475
8476 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8477 salt_type = SALT_TYPE_EMBEDDED;
8478 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8479 opts_type = OPTS_TYPE_PT_GENERATE_LE
8480 | OPTS_TYPE_PT_BITSLICE;
8481 kern_type = KERN_TYPE_DESCRYPT;
8482 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8483 parse_func = descrypt_parse_hash;
8484 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8485 opti_type = OPTI_TYPE_ZERO_BYTE
8486 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8487 dgst_pos0 = 0;
8488 dgst_pos1 = 1;
8489 dgst_pos2 = 2;
8490 dgst_pos3 = 3;
8491 break;
8492
8493 case 1600: hash_type = HASH_TYPE_MD5;
8494 salt_type = SALT_TYPE_EMBEDDED;
8495 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8496 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8497 kern_type = KERN_TYPE_APR1CRYPT;
8498 dgst_size = DGST_SIZE_4_4;
8499 parse_func = md5apr1_parse_hash;
8500 sort_by_digest = sort_by_digest_4_4;
8501 opti_type = OPTI_TYPE_ZERO_BYTE;
8502 dgst_pos0 = 0;
8503 dgst_pos1 = 1;
8504 dgst_pos2 = 2;
8505 dgst_pos3 = 3;
8506 break;
8507
8508 case 1700: hash_type = HASH_TYPE_SHA512;
8509 salt_type = SALT_TYPE_NONE;
8510 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8511 opts_type = OPTS_TYPE_PT_GENERATE_BE
8512 | OPTS_TYPE_PT_ADD80
8513 | OPTS_TYPE_PT_ADDBITS15;
8514 kern_type = KERN_TYPE_SHA512;
8515 dgst_size = DGST_SIZE_8_8;
8516 parse_func = sha512_parse_hash;
8517 sort_by_digest = sort_by_digest_8_8;
8518 opti_type = OPTI_TYPE_ZERO_BYTE
8519 | OPTI_TYPE_PRECOMPUTE_INIT
8520 | OPTI_TYPE_PRECOMPUTE_MERKLE
8521 | OPTI_TYPE_EARLY_SKIP
8522 | OPTI_TYPE_NOT_ITERATED
8523 | OPTI_TYPE_NOT_SALTED
8524 | OPTI_TYPE_USES_BITS_64
8525 | OPTI_TYPE_RAW_HASH;
8526 dgst_pos0 = 14;
8527 dgst_pos1 = 15;
8528 dgst_pos2 = 6;
8529 dgst_pos3 = 7;
8530 break;
8531
8532 case 1710: hash_type = HASH_TYPE_SHA512;
8533 salt_type = SALT_TYPE_INTERN;
8534 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8535 opts_type = OPTS_TYPE_PT_GENERATE_BE
8536 | OPTS_TYPE_ST_ADD80
8537 | OPTS_TYPE_ST_ADDBITS15;
8538 kern_type = KERN_TYPE_SHA512_PWSLT;
8539 dgst_size = DGST_SIZE_8_8;
8540 parse_func = sha512s_parse_hash;
8541 sort_by_digest = sort_by_digest_8_8;
8542 opti_type = OPTI_TYPE_ZERO_BYTE
8543 | OPTI_TYPE_PRECOMPUTE_INIT
8544 | OPTI_TYPE_PRECOMPUTE_MERKLE
8545 | OPTI_TYPE_EARLY_SKIP
8546 | OPTI_TYPE_NOT_ITERATED
8547 | OPTI_TYPE_APPENDED_SALT
8548 | OPTI_TYPE_USES_BITS_64
8549 | OPTI_TYPE_RAW_HASH;
8550 dgst_pos0 = 14;
8551 dgst_pos1 = 15;
8552 dgst_pos2 = 6;
8553 dgst_pos3 = 7;
8554 break;
8555
8556 case 1711: hash_type = HASH_TYPE_SHA512;
8557 salt_type = SALT_TYPE_EMBEDDED;
8558 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8559 opts_type = OPTS_TYPE_PT_GENERATE_BE
8560 | OPTS_TYPE_ST_ADD80
8561 | OPTS_TYPE_ST_ADDBITS15;
8562 kern_type = KERN_TYPE_SHA512_PWSLT;
8563 dgst_size = DGST_SIZE_8_8;
8564 parse_func = sha512b64s_parse_hash;
8565 sort_by_digest = sort_by_digest_8_8;
8566 opti_type = OPTI_TYPE_ZERO_BYTE
8567 | OPTI_TYPE_PRECOMPUTE_INIT
8568 | OPTI_TYPE_PRECOMPUTE_MERKLE
8569 | OPTI_TYPE_EARLY_SKIP
8570 | OPTI_TYPE_NOT_ITERATED
8571 | OPTI_TYPE_APPENDED_SALT
8572 | OPTI_TYPE_USES_BITS_64
8573 | OPTI_TYPE_RAW_HASH;
8574 dgst_pos0 = 14;
8575 dgst_pos1 = 15;
8576 dgst_pos2 = 6;
8577 dgst_pos3 = 7;
8578 break;
8579
8580 case 1720: hash_type = HASH_TYPE_SHA512;
8581 salt_type = SALT_TYPE_INTERN;
8582 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8583 opts_type = OPTS_TYPE_PT_GENERATE_BE
8584 | OPTS_TYPE_PT_ADD80
8585 | OPTS_TYPE_PT_ADDBITS15;
8586 kern_type = KERN_TYPE_SHA512_SLTPW;
8587 dgst_size = DGST_SIZE_8_8;
8588 parse_func = sha512s_parse_hash;
8589 sort_by_digest = sort_by_digest_8_8;
8590 opti_type = OPTI_TYPE_ZERO_BYTE
8591 | OPTI_TYPE_PRECOMPUTE_INIT
8592 | OPTI_TYPE_PRECOMPUTE_MERKLE
8593 | OPTI_TYPE_EARLY_SKIP
8594 | OPTI_TYPE_NOT_ITERATED
8595 | OPTI_TYPE_PREPENDED_SALT
8596 | OPTI_TYPE_USES_BITS_64
8597 | OPTI_TYPE_RAW_HASH;
8598 dgst_pos0 = 14;
8599 dgst_pos1 = 15;
8600 dgst_pos2 = 6;
8601 dgst_pos3 = 7;
8602 break;
8603
8604 case 1722: hash_type = HASH_TYPE_SHA512;
8605 salt_type = SALT_TYPE_EMBEDDED;
8606 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8607 opts_type = OPTS_TYPE_PT_GENERATE_BE
8608 | OPTS_TYPE_PT_ADD80
8609 | OPTS_TYPE_PT_ADDBITS15
8610 | OPTS_TYPE_ST_HEX;
8611 kern_type = KERN_TYPE_SHA512_SLTPW;
8612 dgst_size = DGST_SIZE_8_8;
8613 parse_func = osx512_parse_hash;
8614 sort_by_digest = sort_by_digest_8_8;
8615 opti_type = OPTI_TYPE_ZERO_BYTE
8616 | OPTI_TYPE_PRECOMPUTE_INIT
8617 | OPTI_TYPE_PRECOMPUTE_MERKLE
8618 | OPTI_TYPE_EARLY_SKIP
8619 | OPTI_TYPE_NOT_ITERATED
8620 | OPTI_TYPE_PREPENDED_SALT
8621 | OPTI_TYPE_USES_BITS_64
8622 | OPTI_TYPE_RAW_HASH;
8623 dgst_pos0 = 14;
8624 dgst_pos1 = 15;
8625 dgst_pos2 = 6;
8626 dgst_pos3 = 7;
8627 break;
8628
8629 case 1730: hash_type = HASH_TYPE_SHA512;
8630 salt_type = SALT_TYPE_INTERN;
8631 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8632 opts_type = OPTS_TYPE_PT_GENERATE_BE
8633 | OPTS_TYPE_PT_UNICODE
8634 | OPTS_TYPE_ST_ADD80
8635 | OPTS_TYPE_ST_ADDBITS15;
8636 kern_type = KERN_TYPE_SHA512_PWSLTU;
8637 dgst_size = DGST_SIZE_8_8;
8638 parse_func = sha512s_parse_hash;
8639 sort_by_digest = sort_by_digest_8_8;
8640 opti_type = OPTI_TYPE_ZERO_BYTE
8641 | OPTI_TYPE_PRECOMPUTE_INIT
8642 | OPTI_TYPE_PRECOMPUTE_MERKLE
8643 | OPTI_TYPE_EARLY_SKIP
8644 | OPTI_TYPE_NOT_ITERATED
8645 | OPTI_TYPE_APPENDED_SALT
8646 | OPTI_TYPE_USES_BITS_64
8647 | OPTI_TYPE_RAW_HASH;
8648 dgst_pos0 = 14;
8649 dgst_pos1 = 15;
8650 dgst_pos2 = 6;
8651 dgst_pos3 = 7;
8652 break;
8653
8654 case 1731: hash_type = HASH_TYPE_SHA512;
8655 salt_type = SALT_TYPE_EMBEDDED;
8656 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8657 opts_type = OPTS_TYPE_PT_GENERATE_BE
8658 | OPTS_TYPE_PT_UNICODE
8659 | OPTS_TYPE_ST_ADD80
8660 | OPTS_TYPE_ST_ADDBITS15
8661 | OPTS_TYPE_ST_HEX;
8662 kern_type = KERN_TYPE_SHA512_PWSLTU;
8663 dgst_size = DGST_SIZE_8_8;
8664 parse_func = mssql2012_parse_hash;
8665 sort_by_digest = sort_by_digest_8_8;
8666 opti_type = OPTI_TYPE_ZERO_BYTE
8667 | OPTI_TYPE_PRECOMPUTE_INIT
8668 | OPTI_TYPE_PRECOMPUTE_MERKLE
8669 | OPTI_TYPE_EARLY_SKIP
8670 | OPTI_TYPE_NOT_ITERATED
8671 | OPTI_TYPE_APPENDED_SALT
8672 | OPTI_TYPE_USES_BITS_64
8673 | OPTI_TYPE_RAW_HASH;
8674 dgst_pos0 = 14;
8675 dgst_pos1 = 15;
8676 dgst_pos2 = 6;
8677 dgst_pos3 = 7;
8678 break;
8679
8680 case 1740: hash_type = HASH_TYPE_SHA512;
8681 salt_type = SALT_TYPE_INTERN;
8682 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8683 opts_type = OPTS_TYPE_PT_GENERATE_BE
8684 | OPTS_TYPE_PT_ADD80
8685 | OPTS_TYPE_PT_ADDBITS15
8686 | OPTS_TYPE_PT_UNICODE;
8687 kern_type = KERN_TYPE_SHA512_SLTPWU;
8688 dgst_size = DGST_SIZE_8_8;
8689 parse_func = sha512s_parse_hash;
8690 sort_by_digest = sort_by_digest_8_8;
8691 opti_type = OPTI_TYPE_ZERO_BYTE
8692 | OPTI_TYPE_PRECOMPUTE_INIT
8693 | OPTI_TYPE_PRECOMPUTE_MERKLE
8694 | OPTI_TYPE_EARLY_SKIP
8695 | OPTI_TYPE_NOT_ITERATED
8696 | OPTI_TYPE_PREPENDED_SALT
8697 | OPTI_TYPE_USES_BITS_64
8698 | OPTI_TYPE_RAW_HASH;
8699 dgst_pos0 = 14;
8700 dgst_pos1 = 15;
8701 dgst_pos2 = 6;
8702 dgst_pos3 = 7;
8703 break;
8704
8705 case 1750: hash_type = HASH_TYPE_SHA512;
8706 salt_type = SALT_TYPE_INTERN;
8707 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8708 opts_type = OPTS_TYPE_PT_GENERATE_BE
8709 | OPTS_TYPE_ST_ADD80;
8710 kern_type = KERN_TYPE_HMACSHA512_PW;
8711 dgst_size = DGST_SIZE_8_8;
8712 parse_func = hmacsha512_parse_hash;
8713 sort_by_digest = sort_by_digest_8_8;
8714 opti_type = OPTI_TYPE_ZERO_BYTE
8715 | OPTI_TYPE_USES_BITS_64
8716 | OPTI_TYPE_NOT_ITERATED;
8717 dgst_pos0 = 14;
8718 dgst_pos1 = 15;
8719 dgst_pos2 = 6;
8720 dgst_pos3 = 7;
8721 break;
8722
8723 case 1760: hash_type = HASH_TYPE_SHA512;
8724 salt_type = SALT_TYPE_INTERN;
8725 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8726 opts_type = OPTS_TYPE_PT_GENERATE_BE
8727 | OPTS_TYPE_PT_ADD80
8728 | OPTS_TYPE_PT_ADDBITS15;
8729 kern_type = KERN_TYPE_HMACSHA512_SLT;
8730 dgst_size = DGST_SIZE_8_8;
8731 parse_func = hmacsha512_parse_hash;
8732 sort_by_digest = sort_by_digest_8_8;
8733 opti_type = OPTI_TYPE_ZERO_BYTE
8734 | OPTI_TYPE_USES_BITS_64
8735 | OPTI_TYPE_NOT_ITERATED;
8736 dgst_pos0 = 14;
8737 dgst_pos1 = 15;
8738 dgst_pos2 = 6;
8739 dgst_pos3 = 7;
8740 break;
8741
8742 case 1800: hash_type = HASH_TYPE_SHA512;
8743 salt_type = SALT_TYPE_EMBEDDED;
8744 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8745 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8746 kern_type = KERN_TYPE_SHA512CRYPT;
8747 dgst_size = DGST_SIZE_8_8;
8748 parse_func = sha512crypt_parse_hash;
8749 sort_by_digest = sort_by_digest_8_8;
8750 opti_type = OPTI_TYPE_ZERO_BYTE
8751 | OPTI_TYPE_USES_BITS_64;
8752 dgst_pos0 = 0;
8753 dgst_pos1 = 1;
8754 dgst_pos2 = 2;
8755 dgst_pos3 = 3;
8756 break;
8757
8758 case 2000: hash_type = HASH_TYPE_STDOUT;
8759 salt_type = SALT_TYPE_NONE;
8760 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8761 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8762 kern_type = KERN_TYPE_STDOUT;
8763 dgst_size = DGST_SIZE_4_4;
8764 parse_func = NULL;
8765 sort_by_digest = NULL;
8766 opti_type = 0;
8767 dgst_pos0 = 0;
8768 dgst_pos1 = 0;
8769 dgst_pos2 = 0;
8770 dgst_pos3 = 0;
8771 break;
8772
8773 case 2100: hash_type = HASH_TYPE_DCC2;
8774 salt_type = SALT_TYPE_EMBEDDED;
8775 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8776 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8777 | OPTS_TYPE_ST_LOWER
8778 | OPTS_TYPE_ST_UNICODE;
8779 kern_type = KERN_TYPE_DCC2;
8780 dgst_size = DGST_SIZE_4_4;
8781 parse_func = dcc2_parse_hash;
8782 sort_by_digest = sort_by_digest_4_4;
8783 opti_type = OPTI_TYPE_ZERO_BYTE
8784 | OPTI_TYPE_SLOW_HASH_SIMD;
8785 dgst_pos0 = 0;
8786 dgst_pos1 = 1;
8787 dgst_pos2 = 2;
8788 dgst_pos3 = 3;
8789 break;
8790
8791 case 2400: hash_type = HASH_TYPE_MD5;
8792 salt_type = SALT_TYPE_NONE;
8793 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8794 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8795 kern_type = KERN_TYPE_MD5PIX;
8796 dgst_size = DGST_SIZE_4_4;
8797 parse_func = md5pix_parse_hash;
8798 sort_by_digest = sort_by_digest_4_4;
8799 opti_type = OPTI_TYPE_ZERO_BYTE
8800 | OPTI_TYPE_PRECOMPUTE_INIT
8801 | OPTI_TYPE_PRECOMPUTE_MERKLE
8802 | OPTI_TYPE_EARLY_SKIP
8803 | OPTI_TYPE_NOT_ITERATED
8804 | OPTI_TYPE_NOT_SALTED;
8805 dgst_pos0 = 0;
8806 dgst_pos1 = 3;
8807 dgst_pos2 = 2;
8808 dgst_pos3 = 1;
8809 break;
8810
8811 case 2410: hash_type = HASH_TYPE_MD5;
8812 salt_type = SALT_TYPE_INTERN;
8813 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8814 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8815 kern_type = KERN_TYPE_MD5ASA;
8816 dgst_size = DGST_SIZE_4_4;
8817 parse_func = md5asa_parse_hash;
8818 sort_by_digest = sort_by_digest_4_4;
8819 opti_type = OPTI_TYPE_ZERO_BYTE
8820 | OPTI_TYPE_PRECOMPUTE_INIT
8821 | OPTI_TYPE_PRECOMPUTE_MERKLE
8822 | OPTI_TYPE_EARLY_SKIP
8823 | OPTI_TYPE_NOT_ITERATED;
8824 dgst_pos0 = 0;
8825 dgst_pos1 = 3;
8826 dgst_pos2 = 2;
8827 dgst_pos3 = 1;
8828 break;
8829
8830 case 2500: hash_type = HASH_TYPE_WPA;
8831 salt_type = SALT_TYPE_EMBEDDED;
8832 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8833 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8834 kern_type = KERN_TYPE_WPA;
8835 dgst_size = DGST_SIZE_4_4;
8836 parse_func = wpa_parse_hash;
8837 sort_by_digest = sort_by_digest_4_4;
8838 opti_type = OPTI_TYPE_ZERO_BYTE
8839 | OPTI_TYPE_SLOW_HASH_SIMD;
8840 dgst_pos0 = 0;
8841 dgst_pos1 = 1;
8842 dgst_pos2 = 2;
8843 dgst_pos3 = 3;
8844 break;
8845
8846 case 2600: hash_type = HASH_TYPE_MD5;
8847 salt_type = SALT_TYPE_VIRTUAL;
8848 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8849 opts_type = OPTS_TYPE_PT_GENERATE_LE
8850 | OPTS_TYPE_PT_ADD80
8851 | OPTS_TYPE_PT_ADDBITS14
8852 | OPTS_TYPE_ST_ADD80;
8853 kern_type = KERN_TYPE_MD55_PWSLT1;
8854 dgst_size = DGST_SIZE_4_4;
8855 parse_func = md5md5_parse_hash;
8856 sort_by_digest = sort_by_digest_4_4;
8857 opti_type = OPTI_TYPE_ZERO_BYTE
8858 | OPTI_TYPE_PRECOMPUTE_INIT
8859 | OPTI_TYPE_PRECOMPUTE_MERKLE
8860 | OPTI_TYPE_EARLY_SKIP;
8861 dgst_pos0 = 0;
8862 dgst_pos1 = 3;
8863 dgst_pos2 = 2;
8864 dgst_pos3 = 1;
8865 break;
8866
8867 case 2611: hash_type = HASH_TYPE_MD5;
8868 salt_type = SALT_TYPE_INTERN;
8869 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8870 opts_type = OPTS_TYPE_PT_GENERATE_LE
8871 | OPTS_TYPE_PT_ADD80
8872 | OPTS_TYPE_PT_ADDBITS14
8873 | OPTS_TYPE_ST_ADD80;
8874 kern_type = KERN_TYPE_MD55_PWSLT1;
8875 dgst_size = DGST_SIZE_4_4;
8876 parse_func = vb3_parse_hash;
8877 sort_by_digest = sort_by_digest_4_4;
8878 opti_type = OPTI_TYPE_ZERO_BYTE
8879 | OPTI_TYPE_PRECOMPUTE_INIT
8880 | OPTI_TYPE_PRECOMPUTE_MERKLE
8881 | OPTI_TYPE_EARLY_SKIP;
8882 dgst_pos0 = 0;
8883 dgst_pos1 = 3;
8884 dgst_pos2 = 2;
8885 dgst_pos3 = 1;
8886 break;
8887
8888 case 2612: hash_type = HASH_TYPE_MD5;
8889 salt_type = SALT_TYPE_EMBEDDED;
8890 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8891 opts_type = OPTS_TYPE_PT_GENERATE_LE
8892 | OPTS_TYPE_PT_ADD80
8893 | OPTS_TYPE_PT_ADDBITS14
8894 | OPTS_TYPE_ST_ADD80
8895 | OPTS_TYPE_ST_HEX;
8896 kern_type = KERN_TYPE_MD55_PWSLT1;
8897 dgst_size = DGST_SIZE_4_4;
8898 parse_func = phps_parse_hash;
8899 sort_by_digest = sort_by_digest_4_4;
8900 opti_type = OPTI_TYPE_ZERO_BYTE
8901 | OPTI_TYPE_PRECOMPUTE_INIT
8902 | OPTI_TYPE_PRECOMPUTE_MERKLE
8903 | OPTI_TYPE_EARLY_SKIP;
8904 dgst_pos0 = 0;
8905 dgst_pos1 = 3;
8906 dgst_pos2 = 2;
8907 dgst_pos3 = 1;
8908 break;
8909
8910 case 2711: hash_type = HASH_TYPE_MD5;
8911 salt_type = SALT_TYPE_INTERN;
8912 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8913 opts_type = OPTS_TYPE_PT_GENERATE_LE
8914 | OPTS_TYPE_PT_ADD80
8915 | OPTS_TYPE_PT_ADDBITS14
8916 | OPTS_TYPE_ST_ADD80;
8917 kern_type = KERN_TYPE_MD55_PWSLT2;
8918 dgst_size = DGST_SIZE_4_4;
8919 parse_func = vb30_parse_hash;
8920 sort_by_digest = sort_by_digest_4_4;
8921 opti_type = OPTI_TYPE_ZERO_BYTE
8922 | OPTI_TYPE_PRECOMPUTE_INIT
8923 | OPTI_TYPE_EARLY_SKIP;
8924 dgst_pos0 = 0;
8925 dgst_pos1 = 3;
8926 dgst_pos2 = 2;
8927 dgst_pos3 = 1;
8928 break;
8929
8930 case 2811: hash_type = HASH_TYPE_MD5;
8931 salt_type = SALT_TYPE_INTERN;
8932 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8933 opts_type = OPTS_TYPE_PT_GENERATE_LE
8934 | OPTS_TYPE_PT_ADD80
8935 | OPTS_TYPE_PT_ADDBITS14;
8936 kern_type = KERN_TYPE_MD55_SLTPW;
8937 dgst_size = DGST_SIZE_4_4;
8938 parse_func = ipb2_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_EARLY_SKIP;
8943 dgst_pos0 = 0;
8944 dgst_pos1 = 3;
8945 dgst_pos2 = 2;
8946 dgst_pos3 = 1;
8947 break;
8948
8949 case 3000: hash_type = HASH_TYPE_LM;
8950 salt_type = SALT_TYPE_NONE;
8951 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8952 opts_type = OPTS_TYPE_PT_GENERATE_LE
8953 | OPTS_TYPE_PT_UPPER
8954 | OPTS_TYPE_PT_BITSLICE;
8955 kern_type = KERN_TYPE_LM;
8956 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8957 parse_func = lm_parse_hash;
8958 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8959 opti_type = OPTI_TYPE_ZERO_BYTE
8960 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8961 dgst_pos0 = 0;
8962 dgst_pos1 = 1;
8963 dgst_pos2 = 2;
8964 dgst_pos3 = 3;
8965 break;
8966
8967 case 3100: hash_type = HASH_TYPE_ORACLEH;
8968 salt_type = SALT_TYPE_INTERN;
8969 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8970 opts_type = OPTS_TYPE_PT_GENERATE_LE
8971 | OPTS_TYPE_PT_UPPER
8972 | OPTS_TYPE_ST_UPPER;
8973 kern_type = KERN_TYPE_ORACLEH;
8974 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8975 parse_func = oracleh_parse_hash;
8976 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8977 opti_type = OPTI_TYPE_ZERO_BYTE;
8978 dgst_pos0 = 0;
8979 dgst_pos1 = 1;
8980 dgst_pos2 = 2;
8981 dgst_pos3 = 3;
8982 break;
8983
8984 case 3200: hash_type = HASH_TYPE_BCRYPT;
8985 salt_type = SALT_TYPE_EMBEDDED;
8986 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8987 opts_type = OPTS_TYPE_PT_GENERATE_LE
8988 | OPTS_TYPE_ST_GENERATE_LE;
8989 kern_type = KERN_TYPE_BCRYPT;
8990 dgst_size = DGST_SIZE_4_6;
8991 parse_func = bcrypt_parse_hash;
8992 sort_by_digest = sort_by_digest_4_6;
8993 opti_type = OPTI_TYPE_ZERO_BYTE;
8994 dgst_pos0 = 0;
8995 dgst_pos1 = 1;
8996 dgst_pos2 = 2;
8997 dgst_pos3 = 3;
8998 break;
8999
9000 case 3710: hash_type = HASH_TYPE_MD5;
9001 salt_type = SALT_TYPE_INTERN;
9002 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9003 opts_type = OPTS_TYPE_PT_GENERATE_LE
9004 | OPTS_TYPE_PT_ADD80
9005 | OPTS_TYPE_PT_ADDBITS14;
9006 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9007 dgst_size = DGST_SIZE_4_4;
9008 parse_func = md5s_parse_hash;
9009 sort_by_digest = sort_by_digest_4_4;
9010 opti_type = OPTI_TYPE_ZERO_BYTE
9011 | OPTI_TYPE_PRECOMPUTE_INIT
9012 | OPTI_TYPE_PRECOMPUTE_MERKLE
9013 | OPTI_TYPE_EARLY_SKIP;
9014 dgst_pos0 = 0;
9015 dgst_pos1 = 3;
9016 dgst_pos2 = 2;
9017 dgst_pos3 = 1;
9018 break;
9019
9020 case 3711: hash_type = HASH_TYPE_MD5;
9021 salt_type = SALT_TYPE_EMBEDDED;
9022 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9023 opts_type = OPTS_TYPE_PT_GENERATE_LE
9024 | OPTS_TYPE_PT_ADD80
9025 | OPTS_TYPE_PT_ADDBITS14;
9026 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9027 dgst_size = DGST_SIZE_4_4;
9028 parse_func = mediawiki_b_parse_hash;
9029 sort_by_digest = sort_by_digest_4_4;
9030 opti_type = OPTI_TYPE_ZERO_BYTE
9031 | OPTI_TYPE_PRECOMPUTE_INIT
9032 | OPTI_TYPE_PRECOMPUTE_MERKLE
9033 | OPTI_TYPE_EARLY_SKIP;
9034 dgst_pos0 = 0;
9035 dgst_pos1 = 3;
9036 dgst_pos2 = 2;
9037 dgst_pos3 = 1;
9038 break;
9039
9040 case 3800: hash_type = HASH_TYPE_MD5;
9041 salt_type = SALT_TYPE_INTERN;
9042 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9043 opts_type = OPTS_TYPE_PT_GENERATE_LE
9044 | OPTS_TYPE_ST_ADDBITS14;
9045 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
9046 dgst_size = DGST_SIZE_4_4;
9047 parse_func = md5s_parse_hash;
9048 sort_by_digest = sort_by_digest_4_4;
9049 opti_type = OPTI_TYPE_ZERO_BYTE
9050 | OPTI_TYPE_PRECOMPUTE_INIT
9051 | OPTI_TYPE_PRECOMPUTE_MERKLE
9052 | OPTI_TYPE_EARLY_SKIP
9053 | OPTI_TYPE_NOT_ITERATED
9054 | OPTI_TYPE_RAW_HASH;
9055 dgst_pos0 = 0;
9056 dgst_pos1 = 3;
9057 dgst_pos2 = 2;
9058 dgst_pos3 = 1;
9059 break;
9060
9061 case 4300: hash_type = HASH_TYPE_MD5;
9062 salt_type = SALT_TYPE_VIRTUAL;
9063 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9064 opts_type = OPTS_TYPE_PT_GENERATE_LE
9065 | OPTS_TYPE_PT_ADD80
9066 | OPTS_TYPE_PT_ADDBITS14
9067 | OPTS_TYPE_ST_ADD80;
9068 kern_type = KERN_TYPE_MD5U5_PWSLT1;
9069 dgst_size = DGST_SIZE_4_4;
9070 parse_func = md5md5_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
9083 case 4400: hash_type = HASH_TYPE_MD5;
9084 salt_type = SALT_TYPE_NONE;
9085 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9086 opts_type = OPTS_TYPE_PT_GENERATE_BE
9087 | OPTS_TYPE_PT_ADD80
9088 | OPTS_TYPE_PT_ADDBITS15;
9089 kern_type = KERN_TYPE_MD5_SHA1;
9090 dgst_size = DGST_SIZE_4_4;
9091 parse_func = md5_parse_hash;
9092 sort_by_digest = sort_by_digest_4_4;
9093 opti_type = OPTI_TYPE_ZERO_BYTE
9094 | OPTI_TYPE_PRECOMPUTE_INIT
9095 | OPTI_TYPE_PRECOMPUTE_MERKLE
9096 | OPTI_TYPE_EARLY_SKIP
9097 | OPTI_TYPE_NOT_ITERATED
9098 | OPTI_TYPE_NOT_SALTED
9099 | OPTI_TYPE_RAW_HASH;
9100 dgst_pos0 = 0;
9101 dgst_pos1 = 3;
9102 dgst_pos2 = 2;
9103 dgst_pos3 = 1;
9104 break;
9105
9106 case 4500: hash_type = HASH_TYPE_SHA1;
9107 salt_type = SALT_TYPE_NONE;
9108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9109 opts_type = OPTS_TYPE_PT_GENERATE_BE
9110 | OPTS_TYPE_PT_ADD80
9111 | OPTS_TYPE_PT_ADDBITS15;
9112 kern_type = KERN_TYPE_SHA11;
9113 dgst_size = DGST_SIZE_4_5;
9114 parse_func = sha1_parse_hash;
9115 sort_by_digest = sort_by_digest_4_5;
9116 opti_type = OPTI_TYPE_ZERO_BYTE
9117 | OPTI_TYPE_PRECOMPUTE_INIT
9118 | OPTI_TYPE_PRECOMPUTE_MERKLE
9119 | OPTI_TYPE_EARLY_SKIP
9120 | OPTI_TYPE_NOT_SALTED;
9121 dgst_pos0 = 3;
9122 dgst_pos1 = 4;
9123 dgst_pos2 = 2;
9124 dgst_pos3 = 1;
9125 break;
9126
9127 case 4700: hash_type = HASH_TYPE_SHA1;
9128 salt_type = SALT_TYPE_NONE;
9129 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9130 opts_type = OPTS_TYPE_PT_GENERATE_LE
9131 | OPTS_TYPE_PT_ADD80
9132 | OPTS_TYPE_PT_ADDBITS14;
9133 kern_type = KERN_TYPE_SHA1_MD5;
9134 dgst_size = DGST_SIZE_4_5;
9135 parse_func = sha1_parse_hash;
9136 sort_by_digest = sort_by_digest_4_5;
9137 opti_type = OPTI_TYPE_ZERO_BYTE
9138 | OPTI_TYPE_PRECOMPUTE_INIT
9139 | OPTI_TYPE_PRECOMPUTE_MERKLE
9140 | OPTI_TYPE_EARLY_SKIP
9141 | OPTI_TYPE_NOT_ITERATED
9142 | OPTI_TYPE_NOT_SALTED
9143 | OPTI_TYPE_RAW_HASH;
9144 dgst_pos0 = 3;
9145 dgst_pos1 = 4;
9146 dgst_pos2 = 2;
9147 dgst_pos3 = 1;
9148 break;
9149
9150 case 4800: hash_type = HASH_TYPE_MD5;
9151 salt_type = SALT_TYPE_EMBEDDED;
9152 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9153 opts_type = OPTS_TYPE_PT_GENERATE_LE
9154 | OPTS_TYPE_PT_ADDBITS14;
9155 kern_type = KERN_TYPE_MD5_CHAP;
9156 dgst_size = DGST_SIZE_4_4;
9157 parse_func = chap_parse_hash;
9158 sort_by_digest = sort_by_digest_4_4;
9159 opti_type = OPTI_TYPE_ZERO_BYTE
9160 | OPTI_TYPE_PRECOMPUTE_INIT
9161 | OPTI_TYPE_PRECOMPUTE_MERKLE
9162 | OPTI_TYPE_MEET_IN_MIDDLE
9163 | OPTI_TYPE_EARLY_SKIP
9164 | OPTI_TYPE_NOT_ITERATED
9165 | OPTI_TYPE_RAW_HASH;
9166 dgst_pos0 = 0;
9167 dgst_pos1 = 3;
9168 dgst_pos2 = 2;
9169 dgst_pos3 = 1;
9170 break;
9171
9172 case 4900: hash_type = HASH_TYPE_SHA1;
9173 salt_type = SALT_TYPE_INTERN;
9174 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9175 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9176 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9177 dgst_size = DGST_SIZE_4_5;
9178 parse_func = sha1s_parse_hash;
9179 sort_by_digest = sort_by_digest_4_5;
9180 opti_type = OPTI_TYPE_ZERO_BYTE
9181 | OPTI_TYPE_PRECOMPUTE_INIT
9182 | OPTI_TYPE_PRECOMPUTE_MERKLE
9183 | OPTI_TYPE_EARLY_SKIP;
9184 dgst_pos0 = 3;
9185 dgst_pos1 = 4;
9186 dgst_pos2 = 2;
9187 dgst_pos3 = 1;
9188 break;
9189
9190 case 5000: hash_type = HASH_TYPE_KECCAK;
9191 salt_type = SALT_TYPE_EMBEDDED;
9192 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9193 opts_type = OPTS_TYPE_PT_GENERATE_LE
9194 | OPTS_TYPE_PT_ADD01;
9195 kern_type = KERN_TYPE_KECCAK;
9196 dgst_size = DGST_SIZE_8_25;
9197 parse_func = keccak_parse_hash;
9198 sort_by_digest = sort_by_digest_8_25;
9199 opti_type = OPTI_TYPE_ZERO_BYTE
9200 | OPTI_TYPE_USES_BITS_64
9201 | OPTI_TYPE_RAW_HASH;
9202 dgst_pos0 = 2;
9203 dgst_pos1 = 3;
9204 dgst_pos2 = 4;
9205 dgst_pos3 = 5;
9206 break;
9207
9208 case 5100: hash_type = HASH_TYPE_MD5H;
9209 salt_type = SALT_TYPE_NONE;
9210 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9211 opts_type = OPTS_TYPE_PT_GENERATE_LE
9212 | OPTS_TYPE_PT_ADD80
9213 | OPTS_TYPE_PT_ADDBITS14;
9214 kern_type = KERN_TYPE_MD5H;
9215 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9216 parse_func = md5half_parse_hash;
9217 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9218 opti_type = OPTI_TYPE_ZERO_BYTE
9219 | OPTI_TYPE_RAW_HASH;
9220 dgst_pos0 = 0;
9221 dgst_pos1 = 1;
9222 dgst_pos2 = 2;
9223 dgst_pos3 = 3;
9224 break;
9225
9226 case 5200: hash_type = HASH_TYPE_SHA256;
9227 salt_type = SALT_TYPE_EMBEDDED;
9228 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9229 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9230 kern_type = KERN_TYPE_PSAFE3;
9231 dgst_size = DGST_SIZE_4_8;
9232 parse_func = psafe3_parse_hash;
9233 sort_by_digest = sort_by_digest_4_8;
9234 opti_type = OPTI_TYPE_ZERO_BYTE;
9235 dgst_pos0 = 0;
9236 dgst_pos1 = 1;
9237 dgst_pos2 = 2;
9238 dgst_pos3 = 3;
9239 break;
9240
9241 case 5300: hash_type = HASH_TYPE_MD5;
9242 salt_type = SALT_TYPE_EMBEDDED;
9243 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9244 opts_type = OPTS_TYPE_PT_GENERATE_LE
9245 | OPTS_TYPE_ST_ADD80;
9246 kern_type = KERN_TYPE_IKEPSK_MD5;
9247 dgst_size = DGST_SIZE_4_4;
9248 parse_func = ikepsk_md5_parse_hash;
9249 sort_by_digest = sort_by_digest_4_4;
9250 opti_type = OPTI_TYPE_ZERO_BYTE;
9251 dgst_pos0 = 0;
9252 dgst_pos1 = 3;
9253 dgst_pos2 = 2;
9254 dgst_pos3 = 1;
9255 break;
9256
9257 case 5400: hash_type = HASH_TYPE_SHA1;
9258 salt_type = SALT_TYPE_EMBEDDED;
9259 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9260 opts_type = OPTS_TYPE_PT_GENERATE_BE
9261 | OPTS_TYPE_ST_ADD80;
9262 kern_type = KERN_TYPE_IKEPSK_SHA1;
9263 dgst_size = DGST_SIZE_4_5;
9264 parse_func = ikepsk_sha1_parse_hash;
9265 sort_by_digest = sort_by_digest_4_5;
9266 opti_type = OPTI_TYPE_ZERO_BYTE;
9267 dgst_pos0 = 3;
9268 dgst_pos1 = 4;
9269 dgst_pos2 = 2;
9270 dgst_pos3 = 1;
9271 break;
9272
9273 case 5500: hash_type = HASH_TYPE_NETNTLM;
9274 salt_type = SALT_TYPE_EMBEDDED;
9275 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9276 opts_type = OPTS_TYPE_PT_GENERATE_LE
9277 | OPTS_TYPE_PT_ADD80
9278 | OPTS_TYPE_PT_ADDBITS14
9279 | OPTS_TYPE_PT_UNICODE
9280 | OPTS_TYPE_ST_HEX;
9281 kern_type = KERN_TYPE_NETNTLMv1;
9282 dgst_size = DGST_SIZE_4_4;
9283 parse_func = netntlmv1_parse_hash;
9284 sort_by_digest = sort_by_digest_4_4;
9285 opti_type = OPTI_TYPE_ZERO_BYTE
9286 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9287 dgst_pos0 = 0;
9288 dgst_pos1 = 1;
9289 dgst_pos2 = 2;
9290 dgst_pos3 = 3;
9291 break;
9292
9293 case 5600: hash_type = HASH_TYPE_MD5;
9294 salt_type = SALT_TYPE_EMBEDDED;
9295 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9296 opts_type = OPTS_TYPE_PT_GENERATE_LE
9297 | OPTS_TYPE_PT_ADD80
9298 | OPTS_TYPE_PT_ADDBITS14
9299 | OPTS_TYPE_PT_UNICODE;
9300 kern_type = KERN_TYPE_NETNTLMv2;
9301 dgst_size = DGST_SIZE_4_4;
9302 parse_func = netntlmv2_parse_hash;
9303 sort_by_digest = sort_by_digest_4_4;
9304 opti_type = OPTI_TYPE_ZERO_BYTE;
9305 dgst_pos0 = 0;
9306 dgst_pos1 = 3;
9307 dgst_pos2 = 2;
9308 dgst_pos3 = 1;
9309 break;
9310
9311 case 5700: hash_type = HASH_TYPE_SHA256;
9312 salt_type = SALT_TYPE_NONE;
9313 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9314 opts_type = OPTS_TYPE_PT_GENERATE_BE
9315 | OPTS_TYPE_PT_ADD80
9316 | OPTS_TYPE_PT_ADDBITS15;
9317 kern_type = KERN_TYPE_SHA256;
9318 dgst_size = DGST_SIZE_4_8;
9319 parse_func = cisco4_parse_hash;
9320 sort_by_digest = sort_by_digest_4_8;
9321 opti_type = OPTI_TYPE_ZERO_BYTE
9322 | OPTI_TYPE_PRECOMPUTE_INIT
9323 | OPTI_TYPE_PRECOMPUTE_MERKLE
9324 | OPTI_TYPE_EARLY_SKIP
9325 | OPTI_TYPE_NOT_ITERATED
9326 | OPTI_TYPE_NOT_SALTED
9327 | OPTI_TYPE_RAW_HASH;
9328 dgst_pos0 = 3;
9329 dgst_pos1 = 7;
9330 dgst_pos2 = 2;
9331 dgst_pos3 = 6;
9332 break;
9333
9334 case 5800: hash_type = HASH_TYPE_SHA1;
9335 salt_type = SALT_TYPE_INTERN;
9336 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9337 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9338 | OPTS_TYPE_ST_ADD80;
9339 kern_type = KERN_TYPE_ANDROIDPIN;
9340 dgst_size = DGST_SIZE_4_5;
9341 parse_func = androidpin_parse_hash;
9342 sort_by_digest = sort_by_digest_4_5;
9343 opti_type = OPTI_TYPE_ZERO_BYTE;
9344 dgst_pos0 = 0;
9345 dgst_pos1 = 1;
9346 dgst_pos2 = 2;
9347 dgst_pos3 = 3;
9348 break;
9349
9350 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9351 salt_type = SALT_TYPE_NONE;
9352 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9353 opts_type = OPTS_TYPE_PT_GENERATE_LE
9354 | OPTS_TYPE_PT_ADD80;
9355 kern_type = KERN_TYPE_RIPEMD160;
9356 dgst_size = DGST_SIZE_4_5;
9357 parse_func = ripemd160_parse_hash;
9358 sort_by_digest = sort_by_digest_4_5;
9359 opti_type = OPTI_TYPE_ZERO_BYTE;
9360 dgst_pos0 = 0;
9361 dgst_pos1 = 1;
9362 dgst_pos2 = 2;
9363 dgst_pos3 = 3;
9364 break;
9365
9366 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9367 salt_type = SALT_TYPE_NONE;
9368 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9369 opts_type = OPTS_TYPE_PT_GENERATE_BE
9370 | OPTS_TYPE_PT_ADD80;
9371 kern_type = KERN_TYPE_WHIRLPOOL;
9372 dgst_size = DGST_SIZE_4_16;
9373 parse_func = whirlpool_parse_hash;
9374 sort_by_digest = sort_by_digest_4_16;
9375 opti_type = OPTI_TYPE_ZERO_BYTE;
9376 dgst_pos0 = 0;
9377 dgst_pos1 = 1;
9378 dgst_pos2 = 2;
9379 dgst_pos3 = 3;
9380 break;
9381
9382 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9383 salt_type = SALT_TYPE_EMBEDDED;
9384 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9385 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9386 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9387 dgst_size = DGST_SIZE_4_5;
9388 parse_func = truecrypt_parse_hash_2k;
9389 sort_by_digest = sort_by_digest_4_5;
9390 opti_type = OPTI_TYPE_ZERO_BYTE;
9391 dgst_pos0 = 0;
9392 dgst_pos1 = 1;
9393 dgst_pos2 = 2;
9394 dgst_pos3 = 3;
9395 break;
9396
9397 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9398 salt_type = SALT_TYPE_EMBEDDED;
9399 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9400 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9401 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9402 dgst_size = DGST_SIZE_4_5;
9403 parse_func = truecrypt_parse_hash_2k;
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 6213: hash_type = HASH_TYPE_RIPEMD160;
9413 salt_type = SALT_TYPE_EMBEDDED;
9414 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9415 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9416 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9417 dgst_size = DGST_SIZE_4_5;
9418 parse_func = truecrypt_parse_hash_2k;
9419 sort_by_digest = sort_by_digest_4_5;
9420 opti_type = OPTI_TYPE_ZERO_BYTE;
9421 dgst_pos0 = 0;
9422 dgst_pos1 = 1;
9423 dgst_pos2 = 2;
9424 dgst_pos3 = 3;
9425 break;
9426
9427 case 6221: hash_type = HASH_TYPE_SHA512;
9428 salt_type = SALT_TYPE_EMBEDDED;
9429 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9430 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9431 kern_type = KERN_TYPE_TCSHA512_XTS512;
9432 dgst_size = DGST_SIZE_8_8;
9433 parse_func = truecrypt_parse_hash_1k;
9434 sort_by_digest = sort_by_digest_8_8;
9435 opti_type = OPTI_TYPE_ZERO_BYTE
9436 | OPTI_TYPE_USES_BITS_64;
9437 dgst_pos0 = 0;
9438 dgst_pos1 = 1;
9439 dgst_pos2 = 2;
9440 dgst_pos3 = 3;
9441 break;
9442
9443 case 6222: hash_type = HASH_TYPE_SHA512;
9444 salt_type = SALT_TYPE_EMBEDDED;
9445 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9446 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9447 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9448 dgst_size = DGST_SIZE_8_8;
9449 parse_func = truecrypt_parse_hash_1k;
9450 sort_by_digest = sort_by_digest_8_8;
9451 opti_type = OPTI_TYPE_ZERO_BYTE
9452 | OPTI_TYPE_USES_BITS_64;
9453 dgst_pos0 = 0;
9454 dgst_pos1 = 1;
9455 dgst_pos2 = 2;
9456 dgst_pos3 = 3;
9457 break;
9458
9459 case 6223: hash_type = HASH_TYPE_SHA512;
9460 salt_type = SALT_TYPE_EMBEDDED;
9461 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9462 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9463 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9464 dgst_size = DGST_SIZE_8_8;
9465 parse_func = truecrypt_parse_hash_1k;
9466 sort_by_digest = sort_by_digest_8_8;
9467 opti_type = OPTI_TYPE_ZERO_BYTE
9468 | OPTI_TYPE_USES_BITS_64;
9469 dgst_pos0 = 0;
9470 dgst_pos1 = 1;
9471 dgst_pos2 = 2;
9472 dgst_pos3 = 3;
9473 break;
9474
9475 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9476 salt_type = SALT_TYPE_EMBEDDED;
9477 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9478 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9479 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9480 dgst_size = DGST_SIZE_4_8;
9481 parse_func = truecrypt_parse_hash_1k;
9482 sort_by_digest = sort_by_digest_4_8;
9483 opti_type = OPTI_TYPE_ZERO_BYTE;
9484 dgst_pos0 = 0;
9485 dgst_pos1 = 1;
9486 dgst_pos2 = 2;
9487 dgst_pos3 = 3;
9488 break;
9489
9490 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9491 salt_type = SALT_TYPE_EMBEDDED;
9492 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9493 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9494 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9495 dgst_size = DGST_SIZE_4_8;
9496 parse_func = truecrypt_parse_hash_1k;
9497 sort_by_digest = sort_by_digest_4_8;
9498 opti_type = OPTI_TYPE_ZERO_BYTE;
9499 dgst_pos0 = 0;
9500 dgst_pos1 = 1;
9501 dgst_pos2 = 2;
9502 dgst_pos3 = 3;
9503 break;
9504
9505 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9506 salt_type = SALT_TYPE_EMBEDDED;
9507 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9508 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9509 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9510 dgst_size = DGST_SIZE_4_8;
9511 parse_func = truecrypt_parse_hash_1k;
9512 sort_by_digest = sort_by_digest_4_8;
9513 opti_type = OPTI_TYPE_ZERO_BYTE;
9514 dgst_pos0 = 0;
9515 dgst_pos1 = 1;
9516 dgst_pos2 = 2;
9517 dgst_pos3 = 3;
9518 break;
9519
9520 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9521 salt_type = SALT_TYPE_EMBEDDED;
9522 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9523 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9524 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9525 dgst_size = DGST_SIZE_4_5;
9526 parse_func = truecrypt_parse_hash_1k;
9527 sort_by_digest = sort_by_digest_4_5;
9528 opti_type = OPTI_TYPE_ZERO_BYTE;
9529 dgst_pos0 = 0;
9530 dgst_pos1 = 1;
9531 dgst_pos2 = 2;
9532 dgst_pos3 = 3;
9533 break;
9534
9535 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9536 salt_type = SALT_TYPE_EMBEDDED;
9537 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9538 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9539 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9540 dgst_size = DGST_SIZE_4_5;
9541 parse_func = truecrypt_parse_hash_1k;
9542 sort_by_digest = sort_by_digest_4_5;
9543 opti_type = OPTI_TYPE_ZERO_BYTE;
9544 dgst_pos0 = 0;
9545 dgst_pos1 = 1;
9546 dgst_pos2 = 2;
9547 dgst_pos3 = 3;
9548 break;
9549
9550 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9551 salt_type = SALT_TYPE_EMBEDDED;
9552 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9553 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9554 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9555 dgst_size = DGST_SIZE_4_5;
9556 parse_func = truecrypt_parse_hash_1k;
9557 sort_by_digest = sort_by_digest_4_5;
9558 opti_type = OPTI_TYPE_ZERO_BYTE;
9559 dgst_pos0 = 0;
9560 dgst_pos1 = 1;
9561 dgst_pos2 = 2;
9562 dgst_pos3 = 3;
9563 break;
9564
9565 case 6300: hash_type = HASH_TYPE_MD5;
9566 salt_type = SALT_TYPE_EMBEDDED;
9567 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9568 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9569 kern_type = KERN_TYPE_MD5AIX;
9570 dgst_size = DGST_SIZE_4_4;
9571 parse_func = md5aix_parse_hash;
9572 sort_by_digest = sort_by_digest_4_4;
9573 opti_type = OPTI_TYPE_ZERO_BYTE;
9574 dgst_pos0 = 0;
9575 dgst_pos1 = 1;
9576 dgst_pos2 = 2;
9577 dgst_pos3 = 3;
9578 break;
9579
9580 case 6400: hash_type = HASH_TYPE_SHA256;
9581 salt_type = SALT_TYPE_EMBEDDED;
9582 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9583 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9584 kern_type = KERN_TYPE_SHA256AIX;
9585 dgst_size = DGST_SIZE_4_8;
9586 parse_func = sha256aix_parse_hash;
9587 sort_by_digest = sort_by_digest_4_8;
9588 opti_type = OPTI_TYPE_ZERO_BYTE;
9589 dgst_pos0 = 0;
9590 dgst_pos1 = 1;
9591 dgst_pos2 = 2;
9592 dgst_pos3 = 3;
9593 break;
9594
9595 case 6500: hash_type = HASH_TYPE_SHA512;
9596 salt_type = SALT_TYPE_EMBEDDED;
9597 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9598 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9599 kern_type = KERN_TYPE_SHA512AIX;
9600 dgst_size = DGST_SIZE_8_8;
9601 parse_func = sha512aix_parse_hash;
9602 sort_by_digest = sort_by_digest_8_8;
9603 opti_type = OPTI_TYPE_ZERO_BYTE
9604 | OPTI_TYPE_USES_BITS_64;
9605 dgst_pos0 = 0;
9606 dgst_pos1 = 1;
9607 dgst_pos2 = 2;
9608 dgst_pos3 = 3;
9609 break;
9610
9611 case 6600: hash_type = HASH_TYPE_AES;
9612 salt_type = SALT_TYPE_EMBEDDED;
9613 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9614 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9615 kern_type = KERN_TYPE_AGILEKEY;
9616 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9617 parse_func = agilekey_parse_hash;
9618 sort_by_digest = sort_by_digest_4_5;
9619 opti_type = OPTI_TYPE_ZERO_BYTE;
9620 dgst_pos0 = 0;
9621 dgst_pos1 = 1;
9622 dgst_pos2 = 2;
9623 dgst_pos3 = 3;
9624 break;
9625
9626 case 6700: hash_type = HASH_TYPE_SHA1;
9627 salt_type = SALT_TYPE_EMBEDDED;
9628 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9629 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9630 kern_type = KERN_TYPE_SHA1AIX;
9631 dgst_size = DGST_SIZE_4_5;
9632 parse_func = sha1aix_parse_hash;
9633 sort_by_digest = sort_by_digest_4_5;
9634 opti_type = OPTI_TYPE_ZERO_BYTE;
9635 dgst_pos0 = 0;
9636 dgst_pos1 = 1;
9637 dgst_pos2 = 2;
9638 dgst_pos3 = 3;
9639 break;
9640
9641 case 6800: hash_type = HASH_TYPE_AES;
9642 salt_type = SALT_TYPE_EMBEDDED;
9643 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9644 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9645 kern_type = KERN_TYPE_LASTPASS;
9646 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9647 parse_func = lastpass_parse_hash;
9648 sort_by_digest = sort_by_digest_4_8;
9649 opti_type = OPTI_TYPE_ZERO_BYTE;
9650 dgst_pos0 = 0;
9651 dgst_pos1 = 1;
9652 dgst_pos2 = 2;
9653 dgst_pos3 = 3;
9654 break;
9655
9656 case 6900: hash_type = HASH_TYPE_GOST;
9657 salt_type = SALT_TYPE_NONE;
9658 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9659 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9660 kern_type = KERN_TYPE_GOST;
9661 dgst_size = DGST_SIZE_4_8;
9662 parse_func = gost_parse_hash;
9663 sort_by_digest = sort_by_digest_4_8;
9664 opti_type = OPTI_TYPE_ZERO_BYTE;
9665 dgst_pos0 = 0;
9666 dgst_pos1 = 1;
9667 dgst_pos2 = 2;
9668 dgst_pos3 = 3;
9669 break;
9670
9671 case 7100: hash_type = HASH_TYPE_SHA512;
9672 salt_type = SALT_TYPE_EMBEDDED;
9673 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9674 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9675 kern_type = KERN_TYPE_PBKDF2_SHA512;
9676 dgst_size = DGST_SIZE_8_16;
9677 parse_func = sha512osx_parse_hash;
9678 sort_by_digest = sort_by_digest_8_16;
9679 opti_type = OPTI_TYPE_ZERO_BYTE
9680 | OPTI_TYPE_USES_BITS_64
9681 | OPTI_TYPE_SLOW_HASH_SIMD;
9682 dgst_pos0 = 0;
9683 dgst_pos1 = 1;
9684 dgst_pos2 = 2;
9685 dgst_pos3 = 3;
9686 break;
9687
9688 case 7200: hash_type = HASH_TYPE_SHA512;
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_PBKDF2_SHA512;
9693 dgst_size = DGST_SIZE_8_16;
9694 parse_func = sha512grub_parse_hash;
9695 sort_by_digest = sort_by_digest_8_16;
9696 opti_type = OPTI_TYPE_ZERO_BYTE
9697 | OPTI_TYPE_USES_BITS_64
9698 | OPTI_TYPE_SLOW_HASH_SIMD;
9699 dgst_pos0 = 0;
9700 dgst_pos1 = 1;
9701 dgst_pos2 = 2;
9702 dgst_pos3 = 3;
9703 break;
9704
9705 case 7300: hash_type = HASH_TYPE_SHA1;
9706 salt_type = SALT_TYPE_EMBEDDED;
9707 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9708 opts_type = OPTS_TYPE_PT_GENERATE_BE
9709 | OPTS_TYPE_ST_ADD80
9710 | OPTS_TYPE_ST_ADDBITS15;
9711 kern_type = KERN_TYPE_RAKP;
9712 dgst_size = DGST_SIZE_4_5;
9713 parse_func = rakp_parse_hash;
9714 sort_by_digest = sort_by_digest_4_5;
9715 opti_type = OPTI_TYPE_ZERO_BYTE
9716 | OPTI_TYPE_NOT_ITERATED;
9717 dgst_pos0 = 3;
9718 dgst_pos1 = 4;
9719 dgst_pos2 = 2;
9720 dgst_pos3 = 1;
9721 break;
9722
9723 case 7400: hash_type = HASH_TYPE_SHA256;
9724 salt_type = SALT_TYPE_EMBEDDED;
9725 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9726 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9727 kern_type = KERN_TYPE_SHA256CRYPT;
9728 dgst_size = DGST_SIZE_4_8;
9729 parse_func = sha256crypt_parse_hash;
9730 sort_by_digest = sort_by_digest_4_8;
9731 opti_type = OPTI_TYPE_ZERO_BYTE;
9732 dgst_pos0 = 0;
9733 dgst_pos1 = 1;
9734 dgst_pos2 = 2;
9735 dgst_pos3 = 3;
9736 break;
9737
9738 case 7500: hash_type = HASH_TYPE_KRB5PA;
9739 salt_type = SALT_TYPE_EMBEDDED;
9740 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9741 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9742 kern_type = KERN_TYPE_KRB5PA;
9743 dgst_size = DGST_SIZE_4_4;
9744 parse_func = krb5pa_parse_hash;
9745 sort_by_digest = sort_by_digest_4_4;
9746 opti_type = OPTI_TYPE_ZERO_BYTE
9747 | OPTI_TYPE_NOT_ITERATED;
9748 dgst_pos0 = 0;
9749 dgst_pos1 = 1;
9750 dgst_pos2 = 2;
9751 dgst_pos3 = 3;
9752 break;
9753
9754 case 7600: hash_type = HASH_TYPE_SHA1;
9755 salt_type = SALT_TYPE_INTERN;
9756 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9757 opts_type = OPTS_TYPE_PT_GENERATE_BE
9758 | OPTS_TYPE_PT_ADD80
9759 | OPTS_TYPE_PT_ADDBITS15;
9760 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9761 dgst_size = DGST_SIZE_4_5;
9762 parse_func = redmine_parse_hash;
9763 sort_by_digest = sort_by_digest_4_5;
9764 opti_type = OPTI_TYPE_ZERO_BYTE
9765 | OPTI_TYPE_PRECOMPUTE_INIT
9766 | OPTI_TYPE_EARLY_SKIP
9767 | OPTI_TYPE_NOT_ITERATED
9768 | OPTI_TYPE_PREPENDED_SALT;
9769 dgst_pos0 = 3;
9770 dgst_pos1 = 4;
9771 dgst_pos2 = 2;
9772 dgst_pos3 = 1;
9773 break;
9774
9775 case 7700: hash_type = HASH_TYPE_SAPB;
9776 salt_type = SALT_TYPE_EMBEDDED;
9777 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9778 opts_type = OPTS_TYPE_PT_GENERATE_LE
9779 | OPTS_TYPE_PT_UPPER
9780 | OPTS_TYPE_ST_UPPER;
9781 kern_type = KERN_TYPE_SAPB;
9782 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9783 parse_func = sapb_parse_hash;
9784 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9785 opti_type = OPTI_TYPE_ZERO_BYTE
9786 | OPTI_TYPE_PRECOMPUTE_INIT
9787 | OPTI_TYPE_NOT_ITERATED;
9788 dgst_pos0 = 0;
9789 dgst_pos1 = 1;
9790 dgst_pos2 = 2;
9791 dgst_pos3 = 3;
9792 break;
9793
9794 case 7800: hash_type = HASH_TYPE_SAPG;
9795 salt_type = SALT_TYPE_EMBEDDED;
9796 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9797 opts_type = OPTS_TYPE_PT_GENERATE_BE
9798 | OPTS_TYPE_ST_ADD80
9799 | OPTS_TYPE_ST_UPPER;
9800 kern_type = KERN_TYPE_SAPG;
9801 dgst_size = DGST_SIZE_4_5;
9802 parse_func = sapg_parse_hash;
9803 sort_by_digest = sort_by_digest_4_5;
9804 opti_type = OPTI_TYPE_ZERO_BYTE
9805 | OPTI_TYPE_PRECOMPUTE_INIT
9806 | OPTI_TYPE_NOT_ITERATED;
9807 dgst_pos0 = 3;
9808 dgst_pos1 = 4;
9809 dgst_pos2 = 2;
9810 dgst_pos3 = 1;
9811 break;
9812
9813 case 7900: hash_type = HASH_TYPE_SHA512;
9814 salt_type = SALT_TYPE_EMBEDDED;
9815 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9816 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9817 kern_type = KERN_TYPE_DRUPAL7;
9818 dgst_size = DGST_SIZE_8_8;
9819 parse_func = drupal7_parse_hash;
9820 sort_by_digest = sort_by_digest_8_8;
9821 opti_type = OPTI_TYPE_ZERO_BYTE
9822 | OPTI_TYPE_USES_BITS_64;
9823 dgst_pos0 = 0;
9824 dgst_pos1 = 1;
9825 dgst_pos2 = 2;
9826 dgst_pos3 = 3;
9827 break;
9828
9829 case 8000: hash_type = HASH_TYPE_SHA256;
9830 salt_type = SALT_TYPE_EMBEDDED;
9831 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9832 opts_type = OPTS_TYPE_PT_GENERATE_BE
9833 | OPTS_TYPE_PT_UNICODE
9834 | OPTS_TYPE_ST_ADD80
9835 | OPTS_TYPE_ST_HEX;
9836 kern_type = KERN_TYPE_SYBASEASE;
9837 dgst_size = DGST_SIZE_4_8;
9838 parse_func = sybasease_parse_hash;
9839 sort_by_digest = sort_by_digest_4_8;
9840 opti_type = OPTI_TYPE_ZERO_BYTE
9841 | OPTI_TYPE_PRECOMPUTE_INIT
9842 | OPTI_TYPE_EARLY_SKIP
9843 | OPTI_TYPE_NOT_ITERATED
9844 | OPTI_TYPE_RAW_HASH;
9845 dgst_pos0 = 3;
9846 dgst_pos1 = 7;
9847 dgst_pos2 = 2;
9848 dgst_pos3 = 6;
9849 break;
9850
9851 case 8100: hash_type = HASH_TYPE_SHA1;
9852 salt_type = SALT_TYPE_EMBEDDED;
9853 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9854 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9855 kern_type = KERN_TYPE_NETSCALER;
9856 dgst_size = DGST_SIZE_4_5;
9857 parse_func = netscaler_parse_hash;
9858 sort_by_digest = sort_by_digest_4_5;
9859 opti_type = OPTI_TYPE_ZERO_BYTE
9860 | OPTI_TYPE_PRECOMPUTE_INIT
9861 | OPTI_TYPE_PRECOMPUTE_MERKLE
9862 | OPTI_TYPE_EARLY_SKIP
9863 | OPTI_TYPE_NOT_ITERATED
9864 | OPTI_TYPE_PREPENDED_SALT
9865 | OPTI_TYPE_RAW_HASH;
9866 dgst_pos0 = 3;
9867 dgst_pos1 = 4;
9868 dgst_pos2 = 2;
9869 dgst_pos3 = 1;
9870 break;
9871
9872 case 8200: hash_type = HASH_TYPE_SHA256;
9873 salt_type = SALT_TYPE_EMBEDDED;
9874 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9875 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9876 kern_type = KERN_TYPE_CLOUDKEY;
9877 dgst_size = DGST_SIZE_4_8;
9878 parse_func = cloudkey_parse_hash;
9879 sort_by_digest = sort_by_digest_4_8;
9880 opti_type = OPTI_TYPE_ZERO_BYTE;
9881 dgst_pos0 = 0;
9882 dgst_pos1 = 1;
9883 dgst_pos2 = 2;
9884 dgst_pos3 = 3;
9885 break;
9886
9887 case 8300: hash_type = HASH_TYPE_SHA1;
9888 salt_type = SALT_TYPE_EMBEDDED;
9889 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9890 opts_type = OPTS_TYPE_PT_GENERATE_BE
9891 | OPTS_TYPE_ST_HEX
9892 | OPTS_TYPE_ST_ADD80;
9893 kern_type = KERN_TYPE_NSEC3;
9894 dgst_size = DGST_SIZE_4_5;
9895 parse_func = nsec3_parse_hash;
9896 sort_by_digest = sort_by_digest_4_5;
9897 opti_type = OPTI_TYPE_ZERO_BYTE;
9898 dgst_pos0 = 3;
9899 dgst_pos1 = 4;
9900 dgst_pos2 = 2;
9901 dgst_pos3 = 1;
9902 break;
9903
9904 case 8400: hash_type = HASH_TYPE_SHA1;
9905 salt_type = SALT_TYPE_INTERN;
9906 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9907 opts_type = OPTS_TYPE_PT_GENERATE_BE
9908 | OPTS_TYPE_PT_ADD80
9909 | OPTS_TYPE_PT_ADDBITS15;
9910 kern_type = KERN_TYPE_WBB3;
9911 dgst_size = DGST_SIZE_4_5;
9912 parse_func = wbb3_parse_hash;
9913 sort_by_digest = sort_by_digest_4_5;
9914 opti_type = OPTI_TYPE_ZERO_BYTE
9915 | OPTI_TYPE_PRECOMPUTE_INIT
9916 | OPTI_TYPE_NOT_ITERATED;
9917 dgst_pos0 = 3;
9918 dgst_pos1 = 4;
9919 dgst_pos2 = 2;
9920 dgst_pos3 = 1;
9921 break;
9922
9923 case 8500: hash_type = HASH_TYPE_DESRACF;
9924 salt_type = SALT_TYPE_EMBEDDED;
9925 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9926 opts_type = OPTS_TYPE_PT_GENERATE_LE
9927 | OPTS_TYPE_ST_UPPER;
9928 kern_type = KERN_TYPE_RACF;
9929 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9930 parse_func = racf_parse_hash;
9931 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9932 opti_type = OPTI_TYPE_ZERO_BYTE
9933 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9934 dgst_pos0 = 0;
9935 dgst_pos1 = 1;
9936 dgst_pos2 = 2;
9937 dgst_pos3 = 3;
9938 break;
9939
9940 case 8600: hash_type = HASH_TYPE_LOTUS5;
9941 salt_type = SALT_TYPE_NONE;
9942 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9943 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9944 kern_type = KERN_TYPE_LOTUS5;
9945 dgst_size = DGST_SIZE_4_4;
9946 parse_func = lotus5_parse_hash;
9947 sort_by_digest = sort_by_digest_4_4;
9948 opti_type = OPTI_TYPE_EARLY_SKIP
9949 | OPTI_TYPE_NOT_ITERATED
9950 | OPTI_TYPE_NOT_SALTED
9951 | OPTI_TYPE_RAW_HASH;
9952 dgst_pos0 = 0;
9953 dgst_pos1 = 1;
9954 dgst_pos2 = 2;
9955 dgst_pos3 = 3;
9956 break;
9957
9958 case 8700: hash_type = HASH_TYPE_LOTUS6;
9959 salt_type = SALT_TYPE_EMBEDDED;
9960 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9961 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9962 kern_type = KERN_TYPE_LOTUS6;
9963 dgst_size = DGST_SIZE_4_4;
9964 parse_func = lotus6_parse_hash;
9965 sort_by_digest = sort_by_digest_4_4;
9966 opti_type = OPTI_TYPE_EARLY_SKIP
9967 | OPTI_TYPE_NOT_ITERATED
9968 | OPTI_TYPE_RAW_HASH;
9969 dgst_pos0 = 0;
9970 dgst_pos1 = 1;
9971 dgst_pos2 = 2;
9972 dgst_pos3 = 3;
9973 break;
9974
9975 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9976 salt_type = SALT_TYPE_EMBEDDED;
9977 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9978 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9979 kern_type = KERN_TYPE_ANDROIDFDE;
9980 dgst_size = DGST_SIZE_4_4;
9981 parse_func = androidfde_parse_hash;
9982 sort_by_digest = sort_by_digest_4_4;
9983 opti_type = OPTI_TYPE_ZERO_BYTE;
9984 dgst_pos0 = 0;
9985 dgst_pos1 = 1;
9986 dgst_pos2 = 2;
9987 dgst_pos3 = 3;
9988 break;
9989
9990 case 8900: hash_type = HASH_TYPE_SCRYPT;
9991 salt_type = SALT_TYPE_EMBEDDED;
9992 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9993 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9994 kern_type = KERN_TYPE_SCRYPT;
9995 dgst_size = DGST_SIZE_4_8;
9996 parse_func = scrypt_parse_hash;
9997 sort_by_digest = sort_by_digest_4_8;
9998 opti_type = OPTI_TYPE_ZERO_BYTE;
9999 dgst_pos0 = 0;
10000 dgst_pos1 = 1;
10001 dgst_pos2 = 2;
10002 dgst_pos3 = 3;
10003 break;
10004
10005 case 9000: hash_type = HASH_TYPE_SHA1;
10006 salt_type = SALT_TYPE_EMBEDDED;
10007 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10008 opts_type = OPTS_TYPE_PT_GENERATE_LE
10009 | OPTS_TYPE_ST_GENERATE_LE;
10010 kern_type = KERN_TYPE_PSAFE2;
10011 dgst_size = DGST_SIZE_4_5;
10012 parse_func = psafe2_parse_hash;
10013 sort_by_digest = sort_by_digest_4_5;
10014 opti_type = OPTI_TYPE_ZERO_BYTE;
10015 dgst_pos0 = 0;
10016 dgst_pos1 = 1;
10017 dgst_pos2 = 2;
10018 dgst_pos3 = 3;
10019 break;
10020
10021 case 9100: hash_type = HASH_TYPE_LOTUS8;
10022 salt_type = SALT_TYPE_EMBEDDED;
10023 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10024 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10025 kern_type = KERN_TYPE_LOTUS8;
10026 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10027 parse_func = lotus8_parse_hash;
10028 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10029 opti_type = OPTI_TYPE_ZERO_BYTE;
10030 dgst_pos0 = 0;
10031 dgst_pos1 = 1;
10032 dgst_pos2 = 2;
10033 dgst_pos3 = 3;
10034 break;
10035
10036 case 9200: hash_type = HASH_TYPE_SHA256;
10037 salt_type = SALT_TYPE_EMBEDDED;
10038 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10039 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10040 kern_type = KERN_TYPE_PBKDF2_SHA256;
10041 dgst_size = DGST_SIZE_4_32;
10042 parse_func = cisco8_parse_hash;
10043 sort_by_digest = sort_by_digest_4_32;
10044 opti_type = OPTI_TYPE_ZERO_BYTE
10045 | OPTI_TYPE_SLOW_HASH_SIMD;
10046 dgst_pos0 = 0;
10047 dgst_pos1 = 1;
10048 dgst_pos2 = 2;
10049 dgst_pos3 = 3;
10050 break;
10051
10052 case 9300: 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 = cisco9_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 9400: hash_type = HASH_TYPE_OFFICE2007;
10068 salt_type = SALT_TYPE_EMBEDDED;
10069 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10070 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10071 kern_type = KERN_TYPE_OFFICE2007;
10072 dgst_size = DGST_SIZE_4_4;
10073 parse_func = office2007_parse_hash;
10074 sort_by_digest = sort_by_digest_4_4;
10075 opti_type = OPTI_TYPE_ZERO_BYTE;
10076 dgst_pos0 = 0;
10077 dgst_pos1 = 1;
10078 dgst_pos2 = 2;
10079 dgst_pos3 = 3;
10080 break;
10081
10082 case 9500: hash_type = HASH_TYPE_OFFICE2010;
10083 salt_type = SALT_TYPE_EMBEDDED;
10084 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10085 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10086 kern_type = KERN_TYPE_OFFICE2010;
10087 dgst_size = DGST_SIZE_4_4;
10088 parse_func = office2010_parse_hash;
10089 sort_by_digest = sort_by_digest_4_4;
10090 opti_type = OPTI_TYPE_ZERO_BYTE;
10091 dgst_pos0 = 0;
10092 dgst_pos1 = 1;
10093 dgst_pos2 = 2;
10094 dgst_pos3 = 3;
10095 break;
10096
10097 case 9600: hash_type = HASH_TYPE_OFFICE2013;
10098 salt_type = SALT_TYPE_EMBEDDED;
10099 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10100 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10101 kern_type = KERN_TYPE_OFFICE2013;
10102 dgst_size = DGST_SIZE_4_4;
10103 parse_func = office2013_parse_hash;
10104 sort_by_digest = sort_by_digest_4_4;
10105 opti_type = OPTI_TYPE_ZERO_BYTE;
10106 dgst_pos0 = 0;
10107 dgst_pos1 = 1;
10108 dgst_pos2 = 2;
10109 dgst_pos3 = 3;
10110 break;
10111
10112 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
10113 salt_type = SALT_TYPE_EMBEDDED;
10114 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10115 opts_type = OPTS_TYPE_PT_GENERATE_LE
10116 | OPTS_TYPE_PT_ADD80
10117 | OPTS_TYPE_PT_UNICODE;
10118 kern_type = KERN_TYPE_OLDOFFICE01;
10119 dgst_size = DGST_SIZE_4_4;
10120 parse_func = oldoffice01_parse_hash;
10121 sort_by_digest = sort_by_digest_4_4;
10122 opti_type = OPTI_TYPE_ZERO_BYTE
10123 | OPTI_TYPE_PRECOMPUTE_INIT
10124 | OPTI_TYPE_NOT_ITERATED;
10125 dgst_pos0 = 0;
10126 dgst_pos1 = 1;
10127 dgst_pos2 = 2;
10128 dgst_pos3 = 3;
10129 break;
10130
10131 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
10132 salt_type = SALT_TYPE_EMBEDDED;
10133 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10134 opts_type = OPTS_TYPE_PT_GENERATE_LE
10135 | OPTS_TYPE_PT_ADD80;
10136 kern_type = KERN_TYPE_OLDOFFICE01CM1;
10137 dgst_size = DGST_SIZE_4_4;
10138 parse_func = oldoffice01cm1_parse_hash;
10139 sort_by_digest = sort_by_digest_4_4;
10140 opti_type = OPTI_TYPE_ZERO_BYTE
10141 | OPTI_TYPE_PRECOMPUTE_INIT
10142 | OPTI_TYPE_NOT_ITERATED;
10143 dgst_pos0 = 0;
10144 dgst_pos1 = 1;
10145 dgst_pos2 = 2;
10146 dgst_pos3 = 3;
10147 break;
10148
10149 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
10150 salt_type = SALT_TYPE_EMBEDDED;
10151 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10152 opts_type = OPTS_TYPE_PT_GENERATE_LE
10153 | OPTS_TYPE_PT_ADD80
10154 | OPTS_TYPE_PT_UNICODE
10155 | OPTS_TYPE_PT_NEVERCRACK;
10156 kern_type = KERN_TYPE_OLDOFFICE01CM2;
10157 dgst_size = DGST_SIZE_4_4;
10158 parse_func = oldoffice01cm2_parse_hash;
10159 sort_by_digest = sort_by_digest_4_4;
10160 opti_type = OPTI_TYPE_ZERO_BYTE
10161 | OPTI_TYPE_PRECOMPUTE_INIT
10162 | OPTI_TYPE_NOT_ITERATED;
10163 dgst_pos0 = 0;
10164 dgst_pos1 = 1;
10165 dgst_pos2 = 2;
10166 dgst_pos3 = 3;
10167 break;
10168
10169 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
10170 salt_type = SALT_TYPE_EMBEDDED;
10171 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10172 opts_type = OPTS_TYPE_PT_GENERATE_BE
10173 | OPTS_TYPE_PT_ADD80
10174 | OPTS_TYPE_PT_UNICODE;
10175 kern_type = KERN_TYPE_OLDOFFICE34;
10176 dgst_size = DGST_SIZE_4_4;
10177 parse_func = oldoffice34_parse_hash;
10178 sort_by_digest = sort_by_digest_4_4;
10179 opti_type = OPTI_TYPE_ZERO_BYTE
10180 | OPTI_TYPE_PRECOMPUTE_INIT
10181 | OPTI_TYPE_NOT_ITERATED;
10182 dgst_pos0 = 0;
10183 dgst_pos1 = 1;
10184 dgst_pos2 = 2;
10185 dgst_pos3 = 3;
10186 break;
10187
10188 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10189 salt_type = SALT_TYPE_EMBEDDED;
10190 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10191 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10192 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10193 dgst_size = DGST_SIZE_4_4;
10194 parse_func = oldoffice34cm1_parse_hash;
10195 sort_by_digest = sort_by_digest_4_4;
10196 opti_type = OPTI_TYPE_ZERO_BYTE
10197 | OPTI_TYPE_PRECOMPUTE_INIT
10198 | OPTI_TYPE_NOT_ITERATED;
10199 dgst_pos0 = 0;
10200 dgst_pos1 = 1;
10201 dgst_pos2 = 2;
10202 dgst_pos3 = 3;
10203 break;
10204
10205 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10206 salt_type = SALT_TYPE_EMBEDDED;
10207 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10208 opts_type = OPTS_TYPE_PT_GENERATE_BE
10209 | OPTS_TYPE_PT_ADD80
10210 | OPTS_TYPE_PT_UNICODE
10211 | OPTS_TYPE_PT_NEVERCRACK;
10212 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10213 dgst_size = DGST_SIZE_4_4;
10214 parse_func = oldoffice34cm2_parse_hash;
10215 sort_by_digest = sort_by_digest_4_4;
10216 opti_type = OPTI_TYPE_ZERO_BYTE
10217 | OPTI_TYPE_PRECOMPUTE_INIT
10218 | OPTI_TYPE_NOT_ITERATED;
10219 dgst_pos0 = 0;
10220 dgst_pos1 = 1;
10221 dgst_pos2 = 2;
10222 dgst_pos3 = 3;
10223 break;
10224
10225 case 9900: hash_type = HASH_TYPE_MD5;
10226 salt_type = SALT_TYPE_NONE;
10227 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10228 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10229 kern_type = KERN_TYPE_RADMIN2;
10230 dgst_size = DGST_SIZE_4_4;
10231 parse_func = radmin2_parse_hash;
10232 sort_by_digest = sort_by_digest_4_4;
10233 opti_type = OPTI_TYPE_ZERO_BYTE
10234 | OPTI_TYPE_PRECOMPUTE_INIT
10235 | OPTI_TYPE_EARLY_SKIP
10236 | OPTI_TYPE_NOT_ITERATED
10237 | OPTI_TYPE_NOT_SALTED;
10238 dgst_pos0 = 0;
10239 dgst_pos1 = 3;
10240 dgst_pos2 = 2;
10241 dgst_pos3 = 1;
10242 break;
10243
10244 case 10000: hash_type = HASH_TYPE_SHA256;
10245 salt_type = SALT_TYPE_EMBEDDED;
10246 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10247 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10248 kern_type = KERN_TYPE_PBKDF2_SHA256;
10249 dgst_size = DGST_SIZE_4_32;
10250 parse_func = djangopbkdf2_parse_hash;
10251 sort_by_digest = sort_by_digest_4_32;
10252 opti_type = OPTI_TYPE_ZERO_BYTE
10253 | OPTI_TYPE_SLOW_HASH_SIMD;
10254 dgst_pos0 = 0;
10255 dgst_pos1 = 1;
10256 dgst_pos2 = 2;
10257 dgst_pos3 = 3;
10258 break;
10259
10260 case 10100: hash_type = HASH_TYPE_SIPHASH;
10261 salt_type = SALT_TYPE_EMBEDDED;
10262 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10263 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10264 kern_type = KERN_TYPE_SIPHASH;
10265 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10266 parse_func = siphash_parse_hash;
10267 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10268 opti_type = OPTI_TYPE_ZERO_BYTE
10269 | OPTI_TYPE_NOT_ITERATED
10270 | OPTI_TYPE_RAW_HASH;
10271 dgst_pos0 = 0;
10272 dgst_pos1 = 1;
10273 dgst_pos2 = 2;
10274 dgst_pos3 = 3;
10275 break;
10276
10277 case 10200: hash_type = HASH_TYPE_MD5;
10278 salt_type = SALT_TYPE_EMBEDDED;
10279 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10280 opts_type = OPTS_TYPE_PT_GENERATE_LE
10281 | OPTS_TYPE_ST_ADD80
10282 | OPTS_TYPE_ST_ADDBITS14;
10283 kern_type = KERN_TYPE_HMACMD5_PW;
10284 dgst_size = DGST_SIZE_4_4;
10285 parse_func = crammd5_parse_hash;
10286 sort_by_digest = sort_by_digest_4_4;
10287 opti_type = OPTI_TYPE_ZERO_BYTE
10288 | OPTI_TYPE_NOT_ITERATED;
10289 dgst_pos0 = 0;
10290 dgst_pos1 = 3;
10291 dgst_pos2 = 2;
10292 dgst_pos3 = 1;
10293 break;
10294
10295 case 10300: hash_type = HASH_TYPE_SHA1;
10296 salt_type = SALT_TYPE_EMBEDDED;
10297 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10298 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10299 kern_type = KERN_TYPE_SAPH_SHA1;
10300 dgst_size = DGST_SIZE_4_5;
10301 parse_func = saph_sha1_parse_hash;
10302 sort_by_digest = sort_by_digest_4_5;
10303 opti_type = OPTI_TYPE_ZERO_BYTE;
10304 dgst_pos0 = 0;
10305 dgst_pos1 = 1;
10306 dgst_pos2 = 2;
10307 dgst_pos3 = 3;
10308 break;
10309
10310 case 10400: hash_type = HASH_TYPE_PDFU16;
10311 salt_type = SALT_TYPE_EMBEDDED;
10312 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10313 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10314 kern_type = KERN_TYPE_PDF11;
10315 dgst_size = DGST_SIZE_4_4;
10316 parse_func = pdf11_parse_hash;
10317 sort_by_digest = sort_by_digest_4_4;
10318 opti_type = OPTI_TYPE_ZERO_BYTE
10319 | OPTI_TYPE_NOT_ITERATED;
10320 dgst_pos0 = 0;
10321 dgst_pos1 = 1;
10322 dgst_pos2 = 2;
10323 dgst_pos3 = 3;
10324 break;
10325
10326 case 10410: hash_type = HASH_TYPE_PDFU16;
10327 salt_type = SALT_TYPE_EMBEDDED;
10328 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10329 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10330 kern_type = KERN_TYPE_PDF11CM1;
10331 dgst_size = DGST_SIZE_4_4;
10332 parse_func = pdf11cm1_parse_hash;
10333 sort_by_digest = sort_by_digest_4_4;
10334 opti_type = OPTI_TYPE_ZERO_BYTE
10335 | OPTI_TYPE_NOT_ITERATED;
10336 dgst_pos0 = 0;
10337 dgst_pos1 = 1;
10338 dgst_pos2 = 2;
10339 dgst_pos3 = 3;
10340 break;
10341
10342 case 10420: hash_type = HASH_TYPE_PDFU16;
10343 salt_type = SALT_TYPE_EMBEDDED;
10344 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10345 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10346 kern_type = KERN_TYPE_PDF11CM2;
10347 dgst_size = DGST_SIZE_4_4;
10348 parse_func = pdf11cm2_parse_hash;
10349 sort_by_digest = sort_by_digest_4_4;
10350 opti_type = OPTI_TYPE_ZERO_BYTE
10351 | OPTI_TYPE_NOT_ITERATED;
10352 dgst_pos0 = 0;
10353 dgst_pos1 = 1;
10354 dgst_pos2 = 2;
10355 dgst_pos3 = 3;
10356 break;
10357
10358 case 10500: hash_type = HASH_TYPE_PDFU16;
10359 salt_type = SALT_TYPE_EMBEDDED;
10360 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10361 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10362 kern_type = KERN_TYPE_PDF14;
10363 dgst_size = DGST_SIZE_4_4;
10364 parse_func = pdf14_parse_hash;
10365 sort_by_digest = sort_by_digest_4_4;
10366 opti_type = OPTI_TYPE_ZERO_BYTE
10367 | OPTI_TYPE_NOT_ITERATED;
10368 dgst_pos0 = 0;
10369 dgst_pos1 = 1;
10370 dgst_pos2 = 2;
10371 dgst_pos3 = 3;
10372 break;
10373
10374 case 10600: hash_type = HASH_TYPE_SHA256;
10375 salt_type = SALT_TYPE_EMBEDDED;
10376 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10377 opts_type = OPTS_TYPE_PT_GENERATE_BE
10378 | OPTS_TYPE_ST_ADD80
10379 | OPTS_TYPE_ST_ADDBITS15
10380 | OPTS_TYPE_HASH_COPY;
10381 kern_type = KERN_TYPE_SHA256_PWSLT;
10382 dgst_size = DGST_SIZE_4_8;
10383 parse_func = pdf17l3_parse_hash;
10384 sort_by_digest = sort_by_digest_4_8;
10385 opti_type = OPTI_TYPE_ZERO_BYTE
10386 | OPTI_TYPE_PRECOMPUTE_INIT
10387 | OPTI_TYPE_PRECOMPUTE_MERKLE
10388 | OPTI_TYPE_EARLY_SKIP
10389 | OPTI_TYPE_NOT_ITERATED
10390 | OPTI_TYPE_APPENDED_SALT
10391 | OPTI_TYPE_RAW_HASH;
10392 dgst_pos0 = 3;
10393 dgst_pos1 = 7;
10394 dgst_pos2 = 2;
10395 dgst_pos3 = 6;
10396 break;
10397
10398 case 10700: hash_type = HASH_TYPE_PDFU32;
10399 salt_type = SALT_TYPE_EMBEDDED;
10400 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10401 opts_type = OPTS_TYPE_PT_GENERATE_LE
10402 | OPTS_TYPE_HASH_COPY;
10403 kern_type = KERN_TYPE_PDF17L8;
10404 dgst_size = DGST_SIZE_4_8;
10405 parse_func = pdf17l8_parse_hash;
10406 sort_by_digest = sort_by_digest_4_8;
10407 opti_type = OPTI_TYPE_ZERO_BYTE
10408 | OPTI_TYPE_NOT_ITERATED;
10409 dgst_pos0 = 0;
10410 dgst_pos1 = 1;
10411 dgst_pos2 = 2;
10412 dgst_pos3 = 3;
10413 break;
10414
10415 case 10800: hash_type = HASH_TYPE_SHA384;
10416 salt_type = SALT_TYPE_NONE;
10417 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10418 opts_type = OPTS_TYPE_PT_GENERATE_BE
10419 | OPTS_TYPE_PT_ADD80
10420 | OPTS_TYPE_PT_ADDBITS15;
10421 kern_type = KERN_TYPE_SHA384;
10422 dgst_size = DGST_SIZE_8_8;
10423 parse_func = sha384_parse_hash;
10424 sort_by_digest = sort_by_digest_8_8;
10425 opti_type = OPTI_TYPE_ZERO_BYTE
10426 | OPTI_TYPE_PRECOMPUTE_INIT
10427 | OPTI_TYPE_PRECOMPUTE_MERKLE
10428 | OPTI_TYPE_EARLY_SKIP
10429 | OPTI_TYPE_NOT_ITERATED
10430 | OPTI_TYPE_NOT_SALTED
10431 | OPTI_TYPE_USES_BITS_64
10432 | OPTI_TYPE_RAW_HASH;
10433 dgst_pos0 = 6;
10434 dgst_pos1 = 7;
10435 dgst_pos2 = 4;
10436 dgst_pos3 = 5;
10437 break;
10438
10439 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10440 salt_type = SALT_TYPE_EMBEDDED;
10441 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10442 opts_type = OPTS_TYPE_PT_GENERATE_LE
10443 | OPTS_TYPE_ST_BASE64
10444 | OPTS_TYPE_HASH_COPY;
10445 kern_type = KERN_TYPE_PBKDF2_SHA256;
10446 dgst_size = DGST_SIZE_4_32;
10447 parse_func = pbkdf2_sha256_parse_hash;
10448 sort_by_digest = sort_by_digest_4_32;
10449 opti_type = OPTI_TYPE_ZERO_BYTE
10450 | OPTI_TYPE_SLOW_HASH_SIMD;
10451 dgst_pos0 = 0;
10452 dgst_pos1 = 1;
10453 dgst_pos2 = 2;
10454 dgst_pos3 = 3;
10455 break;
10456
10457 case 11000: hash_type = HASH_TYPE_MD5;
10458 salt_type = SALT_TYPE_INTERN;
10459 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10460 opts_type = OPTS_TYPE_PT_GENERATE_LE
10461 | OPTS_TYPE_PT_ADD80;
10462 kern_type = KERN_TYPE_PRESTASHOP;
10463 dgst_size = DGST_SIZE_4_4;
10464 parse_func = prestashop_parse_hash;
10465 sort_by_digest = sort_by_digest_4_4;
10466 opti_type = OPTI_TYPE_ZERO_BYTE
10467 | OPTI_TYPE_PRECOMPUTE_INIT
10468 | OPTI_TYPE_NOT_ITERATED
10469 | OPTI_TYPE_PREPENDED_SALT;
10470 dgst_pos0 = 0;
10471 dgst_pos1 = 3;
10472 dgst_pos2 = 2;
10473 dgst_pos3 = 1;
10474 break;
10475
10476 case 11100: hash_type = HASH_TYPE_MD5;
10477 salt_type = SALT_TYPE_EMBEDDED;
10478 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10479 opts_type = OPTS_TYPE_PT_GENERATE_LE
10480 | OPTS_TYPE_ST_ADD80;
10481 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10482 dgst_size = DGST_SIZE_4_4;
10483 parse_func = postgresql_auth_parse_hash;
10484 sort_by_digest = sort_by_digest_4_4;
10485 opti_type = OPTI_TYPE_ZERO_BYTE
10486 | OPTI_TYPE_PRECOMPUTE_INIT
10487 | OPTI_TYPE_PRECOMPUTE_MERKLE
10488 | OPTI_TYPE_EARLY_SKIP;
10489 dgst_pos0 = 0;
10490 dgst_pos1 = 3;
10491 dgst_pos2 = 2;
10492 dgst_pos3 = 1;
10493 break;
10494
10495 case 11200: hash_type = HASH_TYPE_SHA1;
10496 salt_type = SALT_TYPE_EMBEDDED;
10497 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10498 opts_type = OPTS_TYPE_PT_GENERATE_BE
10499 | OPTS_TYPE_PT_ADD80
10500 | OPTS_TYPE_ST_HEX;
10501 kern_type = KERN_TYPE_MYSQL_AUTH;
10502 dgst_size = DGST_SIZE_4_5;
10503 parse_func = mysql_auth_parse_hash;
10504 sort_by_digest = sort_by_digest_4_5;
10505 opti_type = OPTI_TYPE_ZERO_BYTE
10506 | OPTI_TYPE_EARLY_SKIP;
10507 dgst_pos0 = 3;
10508 dgst_pos1 = 4;
10509 dgst_pos2 = 2;
10510 dgst_pos3 = 1;
10511 break;
10512
10513 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10514 salt_type = SALT_TYPE_EMBEDDED;
10515 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10516 opts_type = OPTS_TYPE_PT_GENERATE_LE
10517 | OPTS_TYPE_ST_HEX
10518 | OPTS_TYPE_ST_ADD80;
10519 kern_type = KERN_TYPE_BITCOIN_WALLET;
10520 dgst_size = DGST_SIZE_4_4;
10521 parse_func = bitcoin_wallet_parse_hash;
10522 sort_by_digest = sort_by_digest_4_4;
10523 opti_type = OPTI_TYPE_ZERO_BYTE;
10524 dgst_pos0 = 0;
10525 dgst_pos1 = 1;
10526 dgst_pos2 = 2;
10527 dgst_pos3 = 3;
10528 break;
10529
10530 case 11400: hash_type = HASH_TYPE_MD5;
10531 salt_type = SALT_TYPE_EMBEDDED;
10532 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10533 opts_type = OPTS_TYPE_PT_GENERATE_LE
10534 | OPTS_TYPE_PT_ADD80
10535 | OPTS_TYPE_HASH_COPY;
10536 kern_type = KERN_TYPE_SIP_AUTH;
10537 dgst_size = DGST_SIZE_4_4;
10538 parse_func = sip_auth_parse_hash;
10539 sort_by_digest = sort_by_digest_4_4;
10540 opti_type = OPTI_TYPE_ZERO_BYTE;
10541 dgst_pos0 = 0;
10542 dgst_pos1 = 3;
10543 dgst_pos2 = 2;
10544 dgst_pos3 = 1;
10545 break;
10546
10547 case 11500: hash_type = HASH_TYPE_CRC32;
10548 salt_type = SALT_TYPE_INTERN;
10549 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10550 opts_type = OPTS_TYPE_PT_GENERATE_LE
10551 | OPTS_TYPE_ST_GENERATE_LE
10552 | OPTS_TYPE_ST_HEX;
10553 kern_type = KERN_TYPE_CRC32;
10554 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10555 parse_func = crc32_parse_hash;
10556 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10557 opti_type = OPTI_TYPE_ZERO_BYTE;
10558 dgst_pos0 = 0;
10559 dgst_pos1 = 1;
10560 dgst_pos2 = 2;
10561 dgst_pos3 = 3;
10562 break;
10563
10564 case 11600: hash_type = HASH_TYPE_AES;
10565 salt_type = SALT_TYPE_EMBEDDED;
10566 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10567 opts_type = OPTS_TYPE_PT_GENERATE_LE
10568 | OPTS_TYPE_PT_NEVERCRACK;
10569 kern_type = KERN_TYPE_SEVEN_ZIP;
10570 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10571 parse_func = seven_zip_parse_hash;
10572 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10573 opti_type = OPTI_TYPE_ZERO_BYTE;
10574 dgst_pos0 = 0;
10575 dgst_pos1 = 1;
10576 dgst_pos2 = 2;
10577 dgst_pos3 = 3;
10578 break;
10579
10580 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10581 salt_type = SALT_TYPE_NONE;
10582 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10583 opts_type = OPTS_TYPE_PT_GENERATE_LE
10584 | OPTS_TYPE_PT_ADD01;
10585 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10586 dgst_size = DGST_SIZE_4_8;
10587 parse_func = gost2012sbog_256_parse_hash;
10588 sort_by_digest = sort_by_digest_4_8;
10589 opti_type = OPTI_TYPE_ZERO_BYTE;
10590 dgst_pos0 = 0;
10591 dgst_pos1 = 1;
10592 dgst_pos2 = 2;
10593 dgst_pos3 = 3;
10594 break;
10595
10596 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10597 salt_type = SALT_TYPE_NONE;
10598 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10599 opts_type = OPTS_TYPE_PT_GENERATE_LE
10600 | OPTS_TYPE_PT_ADD01;
10601 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10602 dgst_size = DGST_SIZE_4_16;
10603 parse_func = gost2012sbog_512_parse_hash;
10604 sort_by_digest = sort_by_digest_4_16;
10605 opti_type = OPTI_TYPE_ZERO_BYTE;
10606 dgst_pos0 = 0;
10607 dgst_pos1 = 1;
10608 dgst_pos2 = 2;
10609 dgst_pos3 = 3;
10610 break;
10611
10612 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10613 salt_type = SALT_TYPE_EMBEDDED;
10614 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10615 opts_type = OPTS_TYPE_PT_GENERATE_LE
10616 | OPTS_TYPE_ST_BASE64
10617 | OPTS_TYPE_HASH_COPY;
10618 kern_type = KERN_TYPE_PBKDF2_MD5;
10619 dgst_size = DGST_SIZE_4_32;
10620 parse_func = pbkdf2_md5_parse_hash;
10621 sort_by_digest = sort_by_digest_4_32;
10622 opti_type = OPTI_TYPE_ZERO_BYTE
10623 | OPTI_TYPE_SLOW_HASH_SIMD;
10624 dgst_pos0 = 0;
10625 dgst_pos1 = 1;
10626 dgst_pos2 = 2;
10627 dgst_pos3 = 3;
10628 break;
10629
10630 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10631 salt_type = SALT_TYPE_EMBEDDED;
10632 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10633 opts_type = OPTS_TYPE_PT_GENERATE_LE
10634 | OPTS_TYPE_ST_BASE64
10635 | OPTS_TYPE_HASH_COPY;
10636 kern_type = KERN_TYPE_PBKDF2_SHA1;
10637 dgst_size = DGST_SIZE_4_32;
10638 parse_func = pbkdf2_sha1_parse_hash;
10639 sort_by_digest = sort_by_digest_4_32;
10640 opti_type = OPTI_TYPE_ZERO_BYTE
10641 | OPTI_TYPE_SLOW_HASH_SIMD;
10642 dgst_pos0 = 0;
10643 dgst_pos1 = 1;
10644 dgst_pos2 = 2;
10645 dgst_pos3 = 3;
10646 break;
10647
10648 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10649 salt_type = SALT_TYPE_EMBEDDED;
10650 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10651 opts_type = OPTS_TYPE_PT_GENERATE_LE
10652 | OPTS_TYPE_ST_BASE64
10653 | OPTS_TYPE_HASH_COPY;
10654 kern_type = KERN_TYPE_PBKDF2_SHA512;
10655 dgst_size = DGST_SIZE_8_16;
10656 parse_func = pbkdf2_sha512_parse_hash;
10657 sort_by_digest = sort_by_digest_8_16;
10658 opti_type = OPTI_TYPE_ZERO_BYTE
10659 | OPTI_TYPE_USES_BITS_64
10660 | OPTI_TYPE_SLOW_HASH_SIMD;
10661 dgst_pos0 = 0;
10662 dgst_pos1 = 1;
10663 dgst_pos2 = 2;
10664 dgst_pos3 = 3;
10665 break;
10666
10667 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10668 salt_type = SALT_TYPE_EMBEDDED;
10669 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10670 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10671 kern_type = KERN_TYPE_ECRYPTFS;
10672 dgst_size = DGST_SIZE_8_8;
10673 parse_func = ecryptfs_parse_hash;
10674 sort_by_digest = sort_by_digest_8_8;
10675 opti_type = OPTI_TYPE_ZERO_BYTE
10676 | OPTI_TYPE_USES_BITS_64;
10677 dgst_pos0 = 0;
10678 dgst_pos1 = 1;
10679 dgst_pos2 = 2;
10680 dgst_pos3 = 3;
10681 break;
10682
10683 case 12300: hash_type = HASH_TYPE_ORACLET;
10684 salt_type = SALT_TYPE_EMBEDDED;
10685 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10686 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10687 kern_type = KERN_TYPE_ORACLET;
10688 dgst_size = DGST_SIZE_8_16;
10689 parse_func = oraclet_parse_hash;
10690 sort_by_digest = sort_by_digest_8_16;
10691 opti_type = OPTI_TYPE_ZERO_BYTE
10692 | OPTI_TYPE_USES_BITS_64;
10693 dgst_pos0 = 0;
10694 dgst_pos1 = 1;
10695 dgst_pos2 = 2;
10696 dgst_pos3 = 3;
10697 break;
10698
10699 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10700 salt_type = SALT_TYPE_EMBEDDED;
10701 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10702 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10703 kern_type = KERN_TYPE_BSDICRYPT;
10704 dgst_size = DGST_SIZE_4_4;
10705 parse_func = bsdicrypt_parse_hash;
10706 sort_by_digest = sort_by_digest_4_4;
10707 opti_type = OPTI_TYPE_ZERO_BYTE
10708 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10709 dgst_pos0 = 0;
10710 dgst_pos1 = 1;
10711 dgst_pos2 = 2;
10712 dgst_pos3 = 3;
10713 break;
10714
10715 case 12500: hash_type = HASH_TYPE_RAR3HP;
10716 salt_type = SALT_TYPE_EMBEDDED;
10717 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10718 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10719 kern_type = KERN_TYPE_RAR3;
10720 dgst_size = DGST_SIZE_4_4;
10721 parse_func = rar3hp_parse_hash;
10722 sort_by_digest = sort_by_digest_4_4;
10723 opti_type = OPTI_TYPE_ZERO_BYTE;
10724 dgst_pos0 = 0;
10725 dgst_pos1 = 1;
10726 dgst_pos2 = 2;
10727 dgst_pos3 = 3;
10728 break;
10729
10730 case 12600: hash_type = HASH_TYPE_SHA256;
10731 salt_type = SALT_TYPE_INTERN;
10732 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10733 opts_type = OPTS_TYPE_PT_GENERATE_BE
10734 | OPTS_TYPE_PT_ADD80;
10735 kern_type = KERN_TYPE_CF10;
10736 dgst_size = DGST_SIZE_4_8;
10737 parse_func = cf10_parse_hash;
10738 sort_by_digest = sort_by_digest_4_8;
10739 opti_type = OPTI_TYPE_ZERO_BYTE
10740 | OPTI_TYPE_PRECOMPUTE_INIT
10741 | OPTI_TYPE_EARLY_SKIP
10742 | OPTI_TYPE_NOT_ITERATED;
10743 dgst_pos0 = 3;
10744 dgst_pos1 = 7;
10745 dgst_pos2 = 2;
10746 dgst_pos3 = 6;
10747 break;
10748
10749 case 12700: hash_type = HASH_TYPE_AES;
10750 salt_type = SALT_TYPE_EMBEDDED;
10751 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10752 opts_type = OPTS_TYPE_PT_GENERATE_LE
10753 | OPTS_TYPE_HASH_COPY;
10754 kern_type = KERN_TYPE_MYWALLET;
10755 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10756 parse_func = mywallet_parse_hash;
10757 sort_by_digest = sort_by_digest_4_5;
10758 opti_type = OPTI_TYPE_ZERO_BYTE;
10759 dgst_pos0 = 0;
10760 dgst_pos1 = 1;
10761 dgst_pos2 = 2;
10762 dgst_pos3 = 3;
10763 break;
10764
10765 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10766 salt_type = SALT_TYPE_EMBEDDED;
10767 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10768 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10769 kern_type = KERN_TYPE_MS_DRSR;
10770 dgst_size = DGST_SIZE_4_8;
10771 parse_func = ms_drsr_parse_hash;
10772 sort_by_digest = sort_by_digest_4_8;
10773 opti_type = OPTI_TYPE_ZERO_BYTE;
10774 dgst_pos0 = 0;
10775 dgst_pos1 = 1;
10776 dgst_pos2 = 2;
10777 dgst_pos3 = 3;
10778 break;
10779
10780 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10781 salt_type = SALT_TYPE_EMBEDDED;
10782 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10783 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10784 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10785 dgst_size = DGST_SIZE_4_8;
10786 parse_func = androidfde_samsung_parse_hash;
10787 sort_by_digest = sort_by_digest_4_8;
10788 opti_type = OPTI_TYPE_ZERO_BYTE;
10789 dgst_pos0 = 0;
10790 dgst_pos1 = 1;
10791 dgst_pos2 = 2;
10792 dgst_pos3 = 3;
10793 break;
10794
10795 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10796 salt_type = SALT_TYPE_EMBEDDED;
10797 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10798 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10799 kern_type = KERN_TYPE_RAR5;
10800 dgst_size = DGST_SIZE_4_4;
10801 parse_func = rar5_parse_hash;
10802 sort_by_digest = sort_by_digest_4_4;
10803 opti_type = OPTI_TYPE_ZERO_BYTE;
10804 dgst_pos0 = 0;
10805 dgst_pos1 = 1;
10806 dgst_pos2 = 2;
10807 dgst_pos3 = 3;
10808 break;
10809
10810 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10811 salt_type = SALT_TYPE_EMBEDDED;
10812 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10813 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10814 kern_type = KERN_TYPE_KRB5TGS;
10815 dgst_size = DGST_SIZE_4_4;
10816 parse_func = krb5tgs_parse_hash;
10817 sort_by_digest = sort_by_digest_4_4;
10818 opti_type = OPTI_TYPE_ZERO_BYTE
10819 | OPTI_TYPE_NOT_ITERATED;
10820 dgst_pos0 = 0;
10821 dgst_pos1 = 1;
10822 dgst_pos2 = 2;
10823 dgst_pos3 = 3;
10824 break;
10825
10826 case 13200: hash_type = HASH_TYPE_AES;
10827 salt_type = SALT_TYPE_EMBEDDED;
10828 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10829 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10830 kern_type = KERN_TYPE_AXCRYPT;
10831 dgst_size = DGST_SIZE_4_4;
10832 parse_func = axcrypt_parse_hash;
10833 sort_by_digest = sort_by_digest_4_4;
10834 opti_type = OPTI_TYPE_ZERO_BYTE;
10835 dgst_pos0 = 0;
10836 dgst_pos1 = 1;
10837 dgst_pos2 = 2;
10838 dgst_pos3 = 3;
10839 break;
10840
10841 case 13300: hash_type = HASH_TYPE_SHA1;
10842 salt_type = SALT_TYPE_NONE;
10843 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10844 opts_type = OPTS_TYPE_PT_GENERATE_BE
10845 | OPTS_TYPE_PT_ADD80
10846 | OPTS_TYPE_PT_ADDBITS15;
10847 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10848 dgst_size = DGST_SIZE_4_5;
10849 parse_func = sha1axcrypt_parse_hash;
10850 sort_by_digest = sort_by_digest_4_5;
10851 opti_type = OPTI_TYPE_ZERO_BYTE
10852 | OPTI_TYPE_PRECOMPUTE_INIT
10853 | OPTI_TYPE_EARLY_SKIP
10854 | OPTI_TYPE_NOT_ITERATED
10855 | OPTI_TYPE_NOT_SALTED;
10856 dgst_pos0 = 0;
10857 dgst_pos1 = 4;
10858 dgst_pos2 = 3;
10859 dgst_pos3 = 2;
10860 break;
10861
10862 case 13400: hash_type = HASH_TYPE_AES;
10863 salt_type = SALT_TYPE_EMBEDDED;
10864 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10865 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10866 kern_type = KERN_TYPE_KEEPASS;
10867 dgst_size = DGST_SIZE_4_4;
10868 parse_func = keepass_parse_hash;
10869 sort_by_digest = sort_by_digest_4_4;
10870 opti_type = OPTI_TYPE_ZERO_BYTE;
10871 dgst_pos0 = 0;
10872 dgst_pos1 = 1;
10873 dgst_pos2 = 2;
10874 dgst_pos3 = 3;
10875 break;
10876
10877 case 13500: hash_type = HASH_TYPE_SHA1;
10878 salt_type = SALT_TYPE_EMBEDDED;
10879 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10880 opts_type = OPTS_TYPE_PT_GENERATE_BE
10881 | OPTS_TYPE_PT_UNICODE
10882 | OPTS_TYPE_PT_ADD80;
10883 kern_type = KERN_TYPE_PSTOKEN;
10884 dgst_size = DGST_SIZE_4_5;
10885 parse_func = pstoken_parse_hash;
10886 sort_by_digest = sort_by_digest_4_5;
10887 opti_type = OPTI_TYPE_ZERO_BYTE
10888 | OPTI_TYPE_PRECOMPUTE_INIT
10889 | OPTI_TYPE_EARLY_SKIP
10890 | OPTI_TYPE_NOT_ITERATED
10891 | OPTI_TYPE_PREPENDED_SALT
10892 | OPTI_TYPE_RAW_HASH;
10893 dgst_pos0 = 3;
10894 dgst_pos1 = 4;
10895 dgst_pos2 = 2;
10896 dgst_pos3 = 1;
10897 break;
10898
10899 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10900 salt_type = SALT_TYPE_EMBEDDED;
10901 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10902 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10903 kern_type = KERN_TYPE_ZIP2;
10904 dgst_size = DGST_SIZE_4_4;
10905 parse_func = zip2_parse_hash;
10906 sort_by_digest = sort_by_digest_4_4;
10907 opti_type = OPTI_TYPE_ZERO_BYTE;
10908 dgst_pos0 = 0;
10909 dgst_pos1 = 1;
10910 dgst_pos2 = 2;
10911 dgst_pos3 = 3;
10912 break;
10913
10914 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10915 salt_type = SALT_TYPE_EMBEDDED;
10916 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10917 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10918 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10919 dgst_size = DGST_SIZE_4_5;
10920 parse_func = veracrypt_parse_hash_655331;
10921 sort_by_digest = sort_by_digest_4_5;
10922 opti_type = OPTI_TYPE_ZERO_BYTE;
10923 dgst_pos0 = 0;
10924 dgst_pos1 = 1;
10925 dgst_pos2 = 2;
10926 dgst_pos3 = 3;
10927 break;
10928
10929 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10930 salt_type = SALT_TYPE_EMBEDDED;
10931 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10932 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10933 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10934 dgst_size = DGST_SIZE_4_5;
10935 parse_func = veracrypt_parse_hash_655331;
10936 sort_by_digest = sort_by_digest_4_5;
10937 opti_type = OPTI_TYPE_ZERO_BYTE;
10938 dgst_pos0 = 0;
10939 dgst_pos1 = 1;
10940 dgst_pos2 = 2;
10941 dgst_pos3 = 3;
10942 break;
10943
10944 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10945 salt_type = SALT_TYPE_EMBEDDED;
10946 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10947 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10948 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10949 dgst_size = DGST_SIZE_4_5;
10950 parse_func = veracrypt_parse_hash_655331;
10951 sort_by_digest = sort_by_digest_4_5;
10952 opti_type = OPTI_TYPE_ZERO_BYTE;
10953 dgst_pos0 = 0;
10954 dgst_pos1 = 1;
10955 dgst_pos2 = 2;
10956 dgst_pos3 = 3;
10957 break;
10958
10959 case 13721: hash_type = HASH_TYPE_SHA512;
10960 salt_type = SALT_TYPE_EMBEDDED;
10961 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10962 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10963 kern_type = KERN_TYPE_TCSHA512_XTS512;
10964 dgst_size = DGST_SIZE_8_8;
10965 parse_func = veracrypt_parse_hash_500000;
10966 sort_by_digest = sort_by_digest_8_8;
10967 opti_type = OPTI_TYPE_ZERO_BYTE
10968 | OPTI_TYPE_USES_BITS_64;
10969 dgst_pos0 = 0;
10970 dgst_pos1 = 1;
10971 dgst_pos2 = 2;
10972 dgst_pos3 = 3;
10973 break;
10974
10975 case 13722: hash_type = HASH_TYPE_SHA512;
10976 salt_type = SALT_TYPE_EMBEDDED;
10977 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10978 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10979 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10980 dgst_size = DGST_SIZE_8_8;
10981 parse_func = veracrypt_parse_hash_500000;
10982 sort_by_digest = sort_by_digest_8_8;
10983 opti_type = OPTI_TYPE_ZERO_BYTE
10984 | OPTI_TYPE_USES_BITS_64;
10985 dgst_pos0 = 0;
10986 dgst_pos1 = 1;
10987 dgst_pos2 = 2;
10988 dgst_pos3 = 3;
10989 break;
10990
10991 case 13723: hash_type = HASH_TYPE_SHA512;
10992 salt_type = SALT_TYPE_EMBEDDED;
10993 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10994 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10995 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10996 dgst_size = DGST_SIZE_8_8;
10997 parse_func = veracrypt_parse_hash_500000;
10998 sort_by_digest = sort_by_digest_8_8;
10999 opti_type = OPTI_TYPE_ZERO_BYTE
11000 | OPTI_TYPE_USES_BITS_64;
11001 dgst_pos0 = 0;
11002 dgst_pos1 = 1;
11003 dgst_pos2 = 2;
11004 dgst_pos3 = 3;
11005 break;
11006
11007 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
11008 salt_type = SALT_TYPE_EMBEDDED;
11009 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11010 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11011 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
11012 dgst_size = DGST_SIZE_4_8;
11013 parse_func = veracrypt_parse_hash_500000;
11014 sort_by_digest = sort_by_digest_4_8;
11015 opti_type = OPTI_TYPE_ZERO_BYTE;
11016 dgst_pos0 = 0;
11017 dgst_pos1 = 1;
11018 dgst_pos2 = 2;
11019 dgst_pos3 = 3;
11020 break;
11021
11022 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
11023 salt_type = SALT_TYPE_EMBEDDED;
11024 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11025 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11026 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
11027 dgst_size = DGST_SIZE_4_8;
11028 parse_func = veracrypt_parse_hash_500000;
11029 sort_by_digest = sort_by_digest_4_8;
11030 opti_type = OPTI_TYPE_ZERO_BYTE;
11031 dgst_pos0 = 0;
11032 dgst_pos1 = 1;
11033 dgst_pos2 = 2;
11034 dgst_pos3 = 3;
11035 break;
11036
11037 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
11038 salt_type = SALT_TYPE_EMBEDDED;
11039 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11040 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11041 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
11042 dgst_size = DGST_SIZE_4_8;
11043 parse_func = veracrypt_parse_hash_500000;
11044 sort_by_digest = sort_by_digest_4_8;
11045 opti_type = OPTI_TYPE_ZERO_BYTE;
11046 dgst_pos0 = 0;
11047 dgst_pos1 = 1;
11048 dgst_pos2 = 2;
11049 dgst_pos3 = 3;
11050 break;
11051
11052 case 13741: hash_type = HASH_TYPE_RIPEMD160;
11053 salt_type = SALT_TYPE_EMBEDDED;
11054 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11055 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11056 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
11057 dgst_size = DGST_SIZE_4_5;
11058 parse_func = veracrypt_parse_hash_327661;
11059 sort_by_digest = sort_by_digest_4_5;
11060 opti_type = OPTI_TYPE_ZERO_BYTE;
11061 dgst_pos0 = 0;
11062 dgst_pos1 = 1;
11063 dgst_pos2 = 2;
11064 dgst_pos3 = 3;
11065 break;
11066
11067 case 13742: hash_type = HASH_TYPE_RIPEMD160;
11068 salt_type = SALT_TYPE_EMBEDDED;
11069 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11070 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11071 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
11072 dgst_size = DGST_SIZE_4_5;
11073 parse_func = veracrypt_parse_hash_327661;
11074 sort_by_digest = sort_by_digest_4_5;
11075 opti_type = OPTI_TYPE_ZERO_BYTE;
11076 dgst_pos0 = 0;
11077 dgst_pos1 = 1;
11078 dgst_pos2 = 2;
11079 dgst_pos3 = 3;
11080 break;
11081
11082 case 13743: hash_type = HASH_TYPE_RIPEMD160;
11083 salt_type = SALT_TYPE_EMBEDDED;
11084 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11085 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11086 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11087 dgst_size = DGST_SIZE_4_5;
11088 parse_func = veracrypt_parse_hash_327661;
11089 sort_by_digest = sort_by_digest_4_5;
11090 opti_type = OPTI_TYPE_ZERO_BYTE;
11091 dgst_pos0 = 0;
11092 dgst_pos1 = 1;
11093 dgst_pos2 = 2;
11094 dgst_pos3 = 3;
11095 break;
11096
11097 case 13751: hash_type = HASH_TYPE_SHA256;
11098 salt_type = SALT_TYPE_EMBEDDED;
11099 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11100 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11101 kern_type = KERN_TYPE_VCSHA256_XTS512;
11102 dgst_size = DGST_SIZE_4_8;
11103 parse_func = veracrypt_parse_hash_500000;
11104 sort_by_digest = sort_by_digest_4_8;
11105 opti_type = OPTI_TYPE_ZERO_BYTE;
11106 dgst_pos0 = 0;
11107 dgst_pos1 = 1;
11108 dgst_pos2 = 2;
11109 dgst_pos3 = 3;
11110 break;
11111
11112 case 13752: hash_type = HASH_TYPE_SHA256;
11113 salt_type = SALT_TYPE_EMBEDDED;
11114 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11115 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11116 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11117 dgst_size = DGST_SIZE_4_8;
11118 parse_func = veracrypt_parse_hash_500000;
11119 sort_by_digest = sort_by_digest_4_8;
11120 opti_type = OPTI_TYPE_ZERO_BYTE;
11121 dgst_pos0 = 0;
11122 dgst_pos1 = 1;
11123 dgst_pos2 = 2;
11124 dgst_pos3 = 3;
11125 break;
11126
11127 case 13753: hash_type = HASH_TYPE_SHA256;
11128 salt_type = SALT_TYPE_EMBEDDED;
11129 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11130 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11131 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11132 dgst_size = DGST_SIZE_4_8;
11133 parse_func = veracrypt_parse_hash_500000;
11134 sort_by_digest = sort_by_digest_4_8;
11135 opti_type = OPTI_TYPE_ZERO_BYTE;
11136 dgst_pos0 = 0;
11137 dgst_pos1 = 1;
11138 dgst_pos2 = 2;
11139 dgst_pos3 = 3;
11140 break;
11141
11142 case 13761: hash_type = HASH_TYPE_SHA256;
11143 salt_type = SALT_TYPE_EMBEDDED;
11144 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11145 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11146 kern_type = KERN_TYPE_VCSHA256_XTS512;
11147 dgst_size = DGST_SIZE_4_8;
11148 parse_func = veracrypt_parse_hash_200000;
11149 sort_by_digest = sort_by_digest_4_8;
11150 opti_type = OPTI_TYPE_ZERO_BYTE;
11151 dgst_pos0 = 0;
11152 dgst_pos1 = 1;
11153 dgst_pos2 = 2;
11154 dgst_pos3 = 3;
11155 break;
11156
11157 case 13762: hash_type = HASH_TYPE_SHA256;
11158 salt_type = SALT_TYPE_EMBEDDED;
11159 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11160 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11161 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11162 dgst_size = DGST_SIZE_4_8;
11163 parse_func = veracrypt_parse_hash_200000;
11164 sort_by_digest = sort_by_digest_4_8;
11165 opti_type = OPTI_TYPE_ZERO_BYTE;
11166 dgst_pos0 = 0;
11167 dgst_pos1 = 1;
11168 dgst_pos2 = 2;
11169 dgst_pos3 = 3;
11170 break;
11171
11172 case 13763: hash_type = HASH_TYPE_SHA256;
11173 salt_type = SALT_TYPE_EMBEDDED;
11174 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11175 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11176 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11177 dgst_size = DGST_SIZE_4_8;
11178 parse_func = veracrypt_parse_hash_200000;
11179 sort_by_digest = sort_by_digest_4_8;
11180 opti_type = OPTI_TYPE_ZERO_BYTE;
11181 dgst_pos0 = 0;
11182 dgst_pos1 = 1;
11183 dgst_pos2 = 2;
11184 dgst_pos3 = 3;
11185 break;
11186
11187 case 13800: hash_type = HASH_TYPE_SHA256;
11188 salt_type = SALT_TYPE_EMBEDDED;
11189 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11190 opts_type = OPTS_TYPE_PT_GENERATE_BE
11191 | OPTS_TYPE_PT_UNICODE;
11192 kern_type = KERN_TYPE_WIN8PHONE;
11193 dgst_size = DGST_SIZE_4_8;
11194 parse_func = win8phone_parse_hash;
11195 sort_by_digest = sort_by_digest_4_8;
11196 opti_type = OPTI_TYPE_ZERO_BYTE
11197 | OPTI_TYPE_PRECOMPUTE_INIT
11198 | OPTI_TYPE_EARLY_SKIP
11199 | OPTI_TYPE_NOT_ITERATED
11200 | OPTI_TYPE_RAW_HASH;
11201 dgst_pos0 = 3;
11202 dgst_pos1 = 7;
11203 dgst_pos2 = 2;
11204 dgst_pos3 = 6;
11205 break;
11206
11207 default: usage_mini_print (PROGNAME); return (-1);
11208 }
11209
11210 /**
11211 * parser
11212 */
11213
11214 data.parse_func = parse_func;
11215
11216 /**
11217 * misc stuff
11218 */
11219
11220 if (hex_salt)
11221 {
11222 if (salt_type == SALT_TYPE_INTERN)
11223 {
11224 opts_type |= OPTS_TYPE_ST_HEX;
11225 }
11226 else
11227 {
11228 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11229
11230 return (-1);
11231 }
11232 }
11233
11234 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11235 | (salt_type == SALT_TYPE_EXTERN)
11236 | (salt_type == SALT_TYPE_EMBEDDED)
11237 | (salt_type == SALT_TYPE_VIRTUAL));
11238
11239 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
11240
11241 data.hash_type = hash_type;
11242 data.attack_mode = attack_mode;
11243 data.attack_kern = attack_kern;
11244 data.attack_exec = attack_exec;
11245 data.kern_type = kern_type;
11246 data.opts_type = opts_type;
11247 data.dgst_size = dgst_size;
11248 data.salt_type = salt_type;
11249 data.isSalted = isSalted;
11250 data.sort_by_digest = sort_by_digest;
11251 data.dgst_pos0 = dgst_pos0;
11252 data.dgst_pos1 = dgst_pos1;
11253 data.dgst_pos2 = dgst_pos2;
11254 data.dgst_pos3 = dgst_pos3;
11255
11256 esalt_size = 0;
11257
11258 switch (hash_mode)
11259 {
11260 case 2500: esalt_size = sizeof (wpa_t); break;
11261 case 5300: esalt_size = sizeof (ikepsk_t); break;
11262 case 5400: esalt_size = sizeof (ikepsk_t); break;
11263 case 5500: esalt_size = sizeof (netntlm_t); break;
11264 case 5600: esalt_size = sizeof (netntlm_t); break;
11265 case 6211: esalt_size = sizeof (tc_t); break;
11266 case 6212: esalt_size = sizeof (tc_t); break;
11267 case 6213: esalt_size = sizeof (tc_t); break;
11268 case 6221: esalt_size = sizeof (tc_t); break;
11269 case 6222: esalt_size = sizeof (tc_t); break;
11270 case 6223: esalt_size = sizeof (tc_t); break;
11271 case 6231: esalt_size = sizeof (tc_t); break;
11272 case 6232: esalt_size = sizeof (tc_t); break;
11273 case 6233: esalt_size = sizeof (tc_t); break;
11274 case 6241: esalt_size = sizeof (tc_t); break;
11275 case 6242: esalt_size = sizeof (tc_t); break;
11276 case 6243: esalt_size = sizeof (tc_t); break;
11277 case 6600: esalt_size = sizeof (agilekey_t); break;
11278 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11279 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
11280 case 7300: esalt_size = sizeof (rakp_t); break;
11281 case 7500: esalt_size = sizeof (krb5pa_t); break;
11282 case 8200: esalt_size = sizeof (cloudkey_t); break;
11283 case 8800: esalt_size = sizeof (androidfde_t); break;
11284 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
11285 case 9400: esalt_size = sizeof (office2007_t); break;
11286 case 9500: esalt_size = sizeof (office2010_t); break;
11287 case 9600: esalt_size = sizeof (office2013_t); break;
11288 case 9700: esalt_size = sizeof (oldoffice01_t); break;
11289 case 9710: esalt_size = sizeof (oldoffice01_t); break;
11290 case 9720: esalt_size = sizeof (oldoffice01_t); break;
11291 case 9800: esalt_size = sizeof (oldoffice34_t); break;
11292 case 9810: esalt_size = sizeof (oldoffice34_t); break;
11293 case 9820: esalt_size = sizeof (oldoffice34_t); break;
11294 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
11295 case 10200: esalt_size = sizeof (cram_md5_t); break;
11296 case 10400: esalt_size = sizeof (pdf_t); break;
11297 case 10410: esalt_size = sizeof (pdf_t); break;
11298 case 10420: esalt_size = sizeof (pdf_t); break;
11299 case 10500: esalt_size = sizeof (pdf_t); break;
11300 case 10600: esalt_size = sizeof (pdf_t); break;
11301 case 10700: esalt_size = sizeof (pdf_t); break;
11302 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
11303 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
11304 case 11400: esalt_size = sizeof (sip_t); break;
11305 case 11600: esalt_size = sizeof (seven_zip_t); break;
11306 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
11307 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
11308 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11309 case 13000: esalt_size = sizeof (rar5_t); break;
11310 case 13100: esalt_size = sizeof (krb5tgs_t); break;
11311 case 13400: esalt_size = sizeof (keepass_t); break;
11312 case 13500: esalt_size = sizeof (pstoken_t); break;
11313 case 13600: esalt_size = sizeof (zip2_t); break;
11314 case 13711: esalt_size = sizeof (tc_t); break;
11315 case 13712: esalt_size = sizeof (tc_t); break;
11316 case 13713: esalt_size = sizeof (tc_t); break;
11317 case 13721: esalt_size = sizeof (tc_t); break;
11318 case 13722: esalt_size = sizeof (tc_t); break;
11319 case 13723: esalt_size = sizeof (tc_t); break;
11320 case 13731: esalt_size = sizeof (tc_t); break;
11321 case 13732: esalt_size = sizeof (tc_t); break;
11322 case 13733: esalt_size = sizeof (tc_t); break;
11323 case 13741: esalt_size = sizeof (tc_t); break;
11324 case 13742: esalt_size = sizeof (tc_t); break;
11325 case 13743: esalt_size = sizeof (tc_t); break;
11326 case 13751: esalt_size = sizeof (tc_t); break;
11327 case 13752: esalt_size = sizeof (tc_t); break;
11328 case 13753: esalt_size = sizeof (tc_t); break;
11329 case 13761: esalt_size = sizeof (tc_t); break;
11330 case 13762: esalt_size = sizeof (tc_t); break;
11331 case 13763: esalt_size = sizeof (tc_t); break;
11332 case 13800: esalt_size = sizeof (win8phone_t); break;
11333 }
11334
11335 data.esalt_size = esalt_size;
11336
11337 /**
11338 * choose dictionary parser
11339 */
11340
11341 if (hash_type == HASH_TYPE_LM)
11342 {
11343 get_next_word_func = get_next_word_lm;
11344 }
11345 else if (opts_type & OPTS_TYPE_PT_UPPER)
11346 {
11347 get_next_word_func = get_next_word_uc;
11348 }
11349 else
11350 {
11351 get_next_word_func = get_next_word_std;
11352 }
11353
11354 /**
11355 * dictstat
11356 */
11357
11358 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11359
11360 #ifdef _POSIX
11361 size_t dictstat_nmemb = 0;
11362 #endif
11363
11364 #ifdef _WIN
11365 uint dictstat_nmemb = 0;
11366 #endif
11367
11368 char dictstat[256] = { 0 };
11369
11370 FILE *dictstat_fp = NULL;
11371
11372 if (keyspace == 0)
11373 {
11374 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11375
11376 dictstat_fp = fopen (dictstat, "rb");
11377
11378 if (dictstat_fp)
11379 {
11380 #ifdef _POSIX
11381 struct stat tmpstat;
11382
11383 fstat (fileno (dictstat_fp), &tmpstat);
11384 #endif
11385
11386 #ifdef _WIN
11387 struct stat64 tmpstat;
11388
11389 _fstat64 (fileno (dictstat_fp), &tmpstat);
11390 #endif
11391
11392 if (tmpstat.st_mtime < COMPTIME)
11393 {
11394 /* with v0.15 the format changed so we have to ensure user is using a good version
11395 since there is no version-header in the dictstat file */
11396
11397 fclose (dictstat_fp);
11398
11399 unlink (dictstat);
11400 }
11401 else
11402 {
11403 while (!feof (dictstat_fp))
11404 {
11405 dictstat_t d;
11406
11407 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11408
11409 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11410
11411 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11412 {
11413 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11414
11415 return -1;
11416 }
11417 }
11418
11419 fclose (dictstat_fp);
11420 }
11421 }
11422 }
11423
11424 /**
11425 * potfile
11426 */
11427
11428 char potfile[256] = { 0 };
11429
11430 if (potfile_path == NULL)
11431 {
11432 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11433 }
11434 else
11435 {
11436 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11437 }
11438
11439 data.pot_fp = NULL;
11440
11441 FILE *out_fp = NULL;
11442 FILE *pot_fp = NULL;
11443
11444 if (show == 1 || left == 1)
11445 {
11446 pot_fp = fopen (potfile, "rb");
11447
11448 if (pot_fp == NULL)
11449 {
11450 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11451
11452 return (-1);
11453 }
11454
11455 if (outfile != NULL)
11456 {
11457 if ((out_fp = fopen (outfile, "ab")) == NULL)
11458 {
11459 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11460
11461 fclose (pot_fp);
11462
11463 return (-1);
11464 }
11465 }
11466 else
11467 {
11468 out_fp = stdout;
11469 }
11470 }
11471 else
11472 {
11473 if (potfile_disable == 0)
11474 {
11475 pot_fp = fopen (potfile, "ab");
11476
11477 if (pot_fp == NULL)
11478 {
11479 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11480
11481 return (-1);
11482 }
11483
11484 data.pot_fp = pot_fp;
11485 }
11486 }
11487
11488 pot_t *pot = NULL;
11489
11490 uint pot_cnt = 0;
11491 uint pot_avail = 0;
11492
11493 if (show == 1 || left == 1)
11494 {
11495 SUPPRESS_OUTPUT = 1;
11496
11497 pot_avail = count_lines (pot_fp);
11498
11499 rewind (pot_fp);
11500
11501 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11502
11503 uint pot_hashes_avail = 0;
11504
11505 uint line_num = 0;
11506
11507 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11508
11509 while (!feof (pot_fp))
11510 {
11511 line_num++;
11512
11513 int line_len = fgetl (pot_fp, line_buf);
11514
11515 if (line_len == 0) continue;
11516
11517 char *plain_buf = line_buf + line_len;
11518
11519 pot_t *pot_ptr = &pot[pot_cnt];
11520
11521 hash_t *hashes_buf = &pot_ptr->hash;
11522
11523 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11524 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11525
11526 if (pot_cnt == pot_hashes_avail)
11527 {
11528 uint pos = 0;
11529
11530 for (pos = 0; pos < INCR_POT; pos++)
11531 {
11532 if ((pot_cnt + pos) >= pot_avail) break;
11533
11534 pot_t *tmp_pot = &pot[pot_cnt + pos];
11535
11536 hash_t *tmp_hash = &tmp_pot->hash;
11537
11538 tmp_hash->digest = mymalloc (dgst_size);
11539
11540 if (isSalted)
11541 {
11542 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11543 }
11544
11545 if (esalt_size)
11546 {
11547 tmp_hash->esalt = mymalloc (esalt_size);
11548 }
11549
11550 pot_hashes_avail++;
11551 }
11552 }
11553
11554 int plain_len = 0;
11555
11556 int parser_status;
11557
11558 int iter = MAX_CUT_TRIES;
11559
11560 do
11561 {
11562 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11563 {
11564 if (line_buf[i] == ':')
11565 {
11566 line_len--;
11567
11568 break;
11569 }
11570 }
11571
11572 if (data.hash_mode != 2500)
11573 {
11574 parser_status = parse_func (line_buf, line_len, hashes_buf);
11575 }
11576 else
11577 {
11578 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11579
11580 if (line_len > max_salt_size)
11581 {
11582 parser_status = PARSER_GLOBAL_LENGTH;
11583 }
11584 else
11585 {
11586 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11587
11588 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11589
11590 hashes_buf->salt->salt_len = line_len;
11591
11592 parser_status = PARSER_OK;
11593 }
11594 }
11595
11596 // if NOT parsed without error, we add the ":" to the plain
11597
11598 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11599 {
11600 plain_len++;
11601 plain_buf--;
11602 }
11603
11604 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11605
11606 if (parser_status < PARSER_GLOBAL_ZERO)
11607 {
11608 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11609
11610 continue;
11611 }
11612
11613 if (plain_len >= 255) continue;
11614
11615 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11616
11617 pot_ptr->plain_len = plain_len;
11618
11619 pot_cnt++;
11620 }
11621
11622 myfree (line_buf);
11623
11624 fclose (pot_fp);
11625
11626 SUPPRESS_OUTPUT = 0;
11627
11628 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11629 }
11630
11631 /**
11632 * word len
11633 */
11634
11635 uint pw_min = PW_MIN;
11636 uint pw_max = PW_MAX;
11637
11638 switch (hash_mode)
11639 {
11640 case 125: if (pw_max > 32) pw_max = 32;
11641 break;
11642 case 400: if (pw_max > 40) pw_max = 40;
11643 break;
11644 case 500: if (pw_max > 16) pw_max = 16;
11645 break;
11646 case 1500: if (pw_max > 8) pw_max = 8;
11647 break;
11648 case 1600: if (pw_max > 16) pw_max = 16;
11649 break;
11650 case 1800: if (pw_max > 16) pw_max = 16;
11651 break;
11652 case 2100: if (pw_max > 16) pw_max = 16;
11653 break;
11654 case 2500: if (pw_min < 8) pw_min = 8;
11655 break;
11656 case 3000: if (pw_max > 7) pw_max = 7;
11657 break;
11658 case 5200: if (pw_max > 24) pw_max = 24;
11659 break;
11660 case 5800: if (pw_max > 16) pw_max = 16;
11661 break;
11662 case 6300: if (pw_max > 16) pw_max = 16;
11663 break;
11664 case 7400: if (pw_max > 16) pw_max = 16;
11665 break;
11666 case 7700: if (pw_max > 8) pw_max = 8;
11667 break;
11668 case 7900: if (pw_max > 48) pw_max = 48;
11669 break;
11670 case 8500: if (pw_max > 8) pw_max = 8;
11671 break;
11672 case 8600: if (pw_max > 16) pw_max = 16;
11673 break;
11674 case 9710: pw_min = 5;
11675 pw_max = 5;
11676 break;
11677 case 9810: pw_min = 5;
11678 pw_max = 5;
11679 break;
11680 case 10410: pw_min = 5;
11681 pw_max = 5;
11682 break;
11683 case 10300: if (pw_max < 3) pw_min = 3;
11684 if (pw_max > 40) pw_max = 40;
11685 break;
11686 case 10500: if (pw_max < 3) pw_min = 3;
11687 if (pw_max > 40) pw_max = 40;
11688 break;
11689 case 10700: if (pw_max > 16) pw_max = 16;
11690 break;
11691 case 11300: if (pw_max > 40) pw_max = 40;
11692 break;
11693 case 11600: if (pw_max > 32) pw_max = 32;
11694 break;
11695 case 12500: if (pw_max > 20) pw_max = 20;
11696 break;
11697 case 12800: if (pw_max > 24) pw_max = 24;
11698 break;
11699 }
11700
11701 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11702 {
11703 switch (attack_kern)
11704 {
11705 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11706 break;
11707 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11708 break;
11709 }
11710 }
11711
11712 /**
11713 * charsets : keep them together for more easy maintainnce
11714 */
11715
11716 cs_t mp_sys[6] = { { { 0 }, 0 } };
11717 cs_t mp_usr[4] = { { { 0 }, 0 } };
11718
11719 mp_setup_sys (mp_sys);
11720
11721 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11722 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11723 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11724 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11725
11726 /**
11727 * load hashes, part I: find input mode, count hashes
11728 */
11729
11730 uint hashlist_mode = 0;
11731 uint hashlist_format = HLFMT_HASHCAT;
11732
11733 uint hashes_avail = 0;
11734
11735 if ((benchmark == 0) && (stdout_flag == 0))
11736 {
11737 struct stat f;
11738
11739 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11740
11741 if ((hash_mode == 2500) ||
11742 (hash_mode == 5200) ||
11743 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11744 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11745 (hash_mode == 9000))
11746 {
11747 hashlist_mode = HL_MODE_ARG;
11748
11749 char *hashfile = myargv[optind];
11750
11751 data.hashfile = hashfile;
11752
11753 logfile_top_var_string ("target", hashfile);
11754 }
11755
11756 if (hashlist_mode == HL_MODE_ARG)
11757 {
11758 if (hash_mode == 2500)
11759 {
11760 struct stat st;
11761
11762 if (stat (data.hashfile, &st) == -1)
11763 {
11764 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11765
11766 return (-1);
11767 }
11768
11769 hashes_avail = st.st_size / sizeof (hccap_t);
11770 }
11771 else
11772 {
11773 hashes_avail = 1;
11774 }
11775 }
11776 else if (hashlist_mode == HL_MODE_FILE)
11777 {
11778 char *hashfile = myargv[optind];
11779
11780 data.hashfile = hashfile;
11781
11782 logfile_top_var_string ("target", hashfile);
11783
11784 FILE *fp = NULL;
11785
11786 if ((fp = fopen (hashfile, "rb")) == NULL)
11787 {
11788 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11789
11790 return (-1);
11791 }
11792
11793 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11794
11795 hashes_avail = count_lines (fp);
11796
11797 rewind (fp);
11798
11799 if (hashes_avail == 0)
11800 {
11801 log_error ("ERROR: hashfile is empty or corrupt");
11802
11803 fclose (fp);
11804
11805 return (-1);
11806 }
11807
11808 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11809
11810 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11811 {
11812 log_error ("ERROR: remove not supported in native hashfile-format mode");
11813
11814 fclose (fp);
11815
11816 return (-1);
11817 }
11818
11819 fclose (fp);
11820 }
11821 }
11822 else
11823 {
11824 hashlist_mode = HL_MODE_ARG;
11825
11826 hashes_avail = 1;
11827 }
11828
11829 if (hash_mode == 3000) hashes_avail *= 2;
11830
11831 data.hashlist_mode = hashlist_mode;
11832 data.hashlist_format = hashlist_format;
11833
11834 logfile_top_uint (hashlist_mode);
11835 logfile_top_uint (hashlist_format);
11836
11837 /**
11838 * load hashes, part II: allocate required memory, set pointers
11839 */
11840
11841 hash_t *hashes_buf = NULL;
11842 void *digests_buf = NULL;
11843 salt_t *salts_buf = NULL;
11844 void *esalts_buf = NULL;
11845
11846 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11847
11848 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11849
11850 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11851 {
11852 u32 hash_pos;
11853
11854 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11855 {
11856 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11857
11858 hashes_buf[hash_pos].hash_info = hash_info;
11859
11860 if (username && (remove || show || left))
11861 {
11862 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11863 }
11864
11865 if (benchmark)
11866 {
11867 hash_info->orighash = (char *) mymalloc (256);
11868 }
11869 }
11870 }
11871
11872 if (isSalted)
11873 {
11874 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11875
11876 if (esalt_size)
11877 {
11878 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11879 }
11880 }
11881 else
11882 {
11883 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11884 }
11885
11886 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11887 {
11888 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11889
11890 if (isSalted)
11891 {
11892 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11893
11894 if (esalt_size)
11895 {
11896 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11897 }
11898 }
11899 else
11900 {
11901 hashes_buf[hash_pos].salt = &salts_buf[0];
11902 }
11903 }
11904
11905 /**
11906 * load hashes, part III: parse hashes or generate them if benchmark
11907 */
11908
11909 uint hashes_cnt = 0;
11910
11911 if (benchmark == 0)
11912 {
11913 if (keyspace == 1)
11914 {
11915 // useless to read hash file for keyspace, cheat a little bit w/ optind
11916 }
11917 else if (stdout_flag == 1)
11918 {
11919 // useless to read hash file for stdout, cheat a little bit w/ optind
11920 }
11921 else if (hashes_avail == 0)
11922 {
11923 }
11924 else if (hashlist_mode == HL_MODE_ARG)
11925 {
11926 char *input_buf = myargv[optind];
11927
11928 uint input_len = strlen (input_buf);
11929
11930 logfile_top_var_string ("target", input_buf);
11931
11932 char *hash_buf = NULL;
11933 int hash_len = 0;
11934
11935 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11936
11937 bool hash_fmt_error = 0;
11938
11939 if (hash_len < 1) hash_fmt_error = 1;
11940 if (hash_buf == NULL) hash_fmt_error = 1;
11941
11942 if (hash_fmt_error)
11943 {
11944 log_info ("WARNING: Failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11945 }
11946 else
11947 {
11948 if (opts_type & OPTS_TYPE_HASH_COPY)
11949 {
11950 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11951
11952 hash_info_tmp->orighash = mystrdup (hash_buf);
11953 }
11954
11955 if (isSalted)
11956 {
11957 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11958 }
11959
11960 int parser_status = PARSER_OK;
11961
11962 if (hash_mode == 2500)
11963 {
11964 if (hash_len == 0)
11965 {
11966 log_error ("ERROR: hccap file not specified");
11967
11968 return (-1);
11969 }
11970
11971 hashlist_mode = HL_MODE_FILE;
11972
11973 data.hashlist_mode = hashlist_mode;
11974
11975 FILE *fp = fopen (hash_buf, "rb");
11976
11977 if (fp == NULL)
11978 {
11979 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11980
11981 return (-1);
11982 }
11983
11984 if (hashes_avail < 1)
11985 {
11986 log_error ("ERROR: hccap file is empty or corrupt");
11987
11988 fclose (fp);
11989
11990 return (-1);
11991 }
11992
11993 uint hccap_size = sizeof (hccap_t);
11994
11995 char *in = (char *) mymalloc (hccap_size);
11996
11997 while (!feof (fp))
11998 {
11999 int n = fread (in, hccap_size, 1, fp);
12000
12001 if (n != 1)
12002 {
12003 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
12004
12005 break;
12006 }
12007
12008 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
12009
12010 if (parser_status != PARSER_OK)
12011 {
12012 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
12013
12014 continue;
12015 }
12016
12017 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
12018
12019 if ((show == 1) || (left == 1))
12020 {
12021 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
12022
12023 char *salt_ptr = (char *) tmp_salt->salt_buf;
12024
12025 int cur_pos = tmp_salt->salt_len;
12026 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12027
12028 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
12029
12030 // do the appending task
12031
12032 snprintf (salt_ptr + cur_pos,
12033 rem_len,
12034 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
12035 wpa->orig_mac1[0],
12036 wpa->orig_mac1[1],
12037 wpa->orig_mac1[2],
12038 wpa->orig_mac1[3],
12039 wpa->orig_mac1[4],
12040 wpa->orig_mac1[5],
12041 wpa->orig_mac2[0],
12042 wpa->orig_mac2[1],
12043 wpa->orig_mac2[2],
12044 wpa->orig_mac2[3],
12045 wpa->orig_mac2[4],
12046 wpa->orig_mac2[5]);
12047
12048 // memset () the remaining part of the salt
12049
12050 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
12051 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12052
12053 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
12054
12055 tmp_salt->salt_len += 1 + 12 + 1 + 12;
12056 }
12057
12058 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);
12059 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);
12060
12061 hashes_cnt++;
12062 }
12063
12064 fclose (fp);
12065
12066 myfree (in);
12067 }
12068 else if (hash_mode == 3000)
12069 {
12070 if (hash_len == 32)
12071 {
12072 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12073
12074 hash_t *lm_hash_left = NULL;
12075
12076 if (parser_status == PARSER_OK)
12077 {
12078 lm_hash_left = &hashes_buf[hashes_cnt];
12079
12080 hashes_cnt++;
12081 }
12082 else
12083 {
12084 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12085 }
12086
12087 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12088
12089 hash_t *lm_hash_right = NULL;
12090
12091 if (parser_status == PARSER_OK)
12092 {
12093 lm_hash_right = &hashes_buf[hashes_cnt];
12094
12095 hashes_cnt++;
12096 }
12097 else
12098 {
12099 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12100 }
12101
12102 // show / left
12103
12104 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12105 {
12106 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);
12107 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);
12108 }
12109 }
12110 else
12111 {
12112 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12113
12114 if (parser_status == PARSER_OK)
12115 {
12116 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12117 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12118 }
12119
12120 if (parser_status == PARSER_OK)
12121 {
12122 hashes_cnt++;
12123 }
12124 else
12125 {
12126 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12127 }
12128 }
12129 }
12130 else
12131 {
12132 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12133
12134 if (parser_status == PARSER_OK)
12135 {
12136 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12137 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12138 }
12139
12140 if (parser_status == PARSER_OK)
12141 {
12142 hashes_cnt++;
12143 }
12144 else
12145 {
12146 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12147 }
12148 }
12149 }
12150 }
12151 else if (hashlist_mode == HL_MODE_FILE)
12152 {
12153 char *hashfile = data.hashfile;
12154
12155 FILE *fp;
12156
12157 if ((fp = fopen (hashfile, "rb")) == NULL)
12158 {
12159 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12160
12161 return (-1);
12162 }
12163
12164 uint line_num = 0;
12165
12166 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12167
12168 while (!feof (fp))
12169 {
12170 line_num++;
12171
12172 int line_len = fgetl (fp, line_buf);
12173
12174 if (line_len == 0) continue;
12175
12176 char *hash_buf = NULL;
12177 int hash_len = 0;
12178
12179 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12180
12181 bool hash_fmt_error = 0;
12182
12183 if (hash_len < 1) hash_fmt_error = 1;
12184 if (hash_buf == NULL) hash_fmt_error = 1;
12185
12186 if (hash_fmt_error)
12187 {
12188 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12189
12190 continue;
12191 }
12192
12193 if (username)
12194 {
12195 char *user_buf = NULL;
12196 int user_len = 0;
12197
12198 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12199
12200 if (remove || show)
12201 {
12202 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12203
12204 *user = (user_t *) mymalloc (sizeof (user_t));
12205
12206 user_t *user_ptr = *user;
12207
12208 if (user_buf != NULL)
12209 {
12210 user_ptr->user_name = mystrdup (user_buf);
12211 }
12212 else
12213 {
12214 user_ptr->user_name = mystrdup ("");
12215 }
12216
12217 user_ptr->user_len = user_len;
12218 }
12219 }
12220
12221 if (opts_type & OPTS_TYPE_HASH_COPY)
12222 {
12223 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12224
12225 hash_info_tmp->orighash = mystrdup (hash_buf);
12226 }
12227
12228 if (isSalted)
12229 {
12230 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12231 }
12232
12233 if (hash_mode == 3000)
12234 {
12235 if (hash_len == 32)
12236 {
12237 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12238
12239 if (parser_status < PARSER_GLOBAL_ZERO)
12240 {
12241 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12242
12243 continue;
12244 }
12245
12246 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12247
12248 hashes_cnt++;
12249
12250 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12251
12252 if (parser_status < PARSER_GLOBAL_ZERO)
12253 {
12254 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12255
12256 continue;
12257 }
12258
12259 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12260
12261 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);
12262
12263 hashes_cnt++;
12264
12265 // show / left
12266
12267 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);
12268 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);
12269 }
12270 else
12271 {
12272 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12273
12274 if (parser_status < PARSER_GLOBAL_ZERO)
12275 {
12276 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12277
12278 continue;
12279 }
12280
12281 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);
12282
12283 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12284 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12285
12286 hashes_cnt++;
12287 }
12288 }
12289 else
12290 {
12291 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12292
12293 if (parser_status < PARSER_GLOBAL_ZERO)
12294 {
12295 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12296
12297 continue;
12298 }
12299
12300 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);
12301
12302 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12303 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12304
12305 hashes_cnt++;
12306 }
12307 }
12308
12309 myfree (line_buf);
12310
12311 fclose (fp);
12312
12313 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12314
12315 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12316 }
12317 }
12318 else
12319 {
12320 if (isSalted)
12321 {
12322 hashes_buf[0].salt->salt_len = 8;
12323
12324 // special salt handling
12325
12326 switch (hash_mode)
12327 {
12328 case 1500: hashes_buf[0].salt->salt_len = 2;
12329 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12330 break;
12331 case 1731: hashes_buf[0].salt->salt_len = 4;
12332 break;
12333 case 2410: hashes_buf[0].salt->salt_len = 4;
12334 break;
12335 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12336 break;
12337 case 3100: hashes_buf[0].salt->salt_len = 1;
12338 break;
12339 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
12340 break;
12341 case 5800: hashes_buf[0].salt->salt_len = 16;
12342 break;
12343 case 6800: hashes_buf[0].salt->salt_len = 32;
12344 break;
12345 case 8400: hashes_buf[0].salt->salt_len = 40;
12346 break;
12347 case 8800: hashes_buf[0].salt->salt_len = 16;
12348 break;
12349 case 8900: hashes_buf[0].salt->salt_len = 16;
12350 hashes_buf[0].salt->scrypt_N = 1024;
12351 hashes_buf[0].salt->scrypt_r = 1;
12352 hashes_buf[0].salt->scrypt_p = 1;
12353 break;
12354 case 9100: hashes_buf[0].salt->salt_len = 16;
12355 break;
12356 case 9300: hashes_buf[0].salt->salt_len = 14;
12357 hashes_buf[0].salt->scrypt_N = 16384;
12358 hashes_buf[0].salt->scrypt_r = 1;
12359 hashes_buf[0].salt->scrypt_p = 1;
12360 break;
12361 case 9400: hashes_buf[0].salt->salt_len = 16;
12362 break;
12363 case 9500: hashes_buf[0].salt->salt_len = 16;
12364 break;
12365 case 9600: hashes_buf[0].salt->salt_len = 16;
12366 break;
12367 case 9700: hashes_buf[0].salt->salt_len = 16;
12368 break;
12369 case 9710: hashes_buf[0].salt->salt_len = 16;
12370 break;
12371 case 9720: hashes_buf[0].salt->salt_len = 16;
12372 break;
12373 case 9800: hashes_buf[0].salt->salt_len = 16;
12374 break;
12375 case 9810: hashes_buf[0].salt->salt_len = 16;
12376 break;
12377 case 9820: hashes_buf[0].salt->salt_len = 16;
12378 break;
12379 case 10300: hashes_buf[0].salt->salt_len = 12;
12380 break;
12381 case 11500: hashes_buf[0].salt->salt_len = 4;
12382 break;
12383 case 11600: hashes_buf[0].salt->salt_len = 4;
12384 break;
12385 case 12400: hashes_buf[0].salt->salt_len = 4;
12386 break;
12387 case 12500: hashes_buf[0].salt->salt_len = 8;
12388 break;
12389 case 12600: hashes_buf[0].salt->salt_len = 64;
12390 break;
12391 }
12392
12393 // special esalt handling
12394
12395 switch (hash_mode)
12396 {
12397 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12398 break;
12399 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12400 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12401 break;
12402 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12403 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12404 break;
12405 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12406 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12407 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12408 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12409 break;
12410 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12411 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12412 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12413 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12414 break;
12415 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12416 break;
12417 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12418 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12419 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12420 break;
12421 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12422 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12423 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12424 break;
12425 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12426 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12427 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12428 break;
12429 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12430 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12431 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12432 break;
12433 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12434 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12435 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12436 break;
12437 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12438 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12439 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12440 break;
12441 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12442 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12443 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12444 break;
12445 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12446 break;
12447 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12448 break;
12449 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12450 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12451 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12452 break;
12453 }
12454 }
12455
12456 // set hashfile
12457
12458 switch (hash_mode)
12459 {
12460 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12461 break;
12462 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12463 break;
12464 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12465 break;
12466 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12467 break;
12468 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12469 break;
12470 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12471 break;
12472 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12473 break;
12474 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12475 break;
12476 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12477 break;
12478 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12479 break;
12480 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12481 break;
12482 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12483 break;
12484 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12485 break;
12486 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12487 break;
12488 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12489 break;
12490 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12491 break;
12492 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12493 break;
12494 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12495 break;
12496 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12497 break;
12498 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12499 break;
12500 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12501 break;
12502 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12503 break;
12504 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12505 break;
12506 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12507 break;
12508 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12509 break;
12510 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12511 break;
12512 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12513 break;
12514 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12515 break;
12516 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12517 break;
12518 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12519 break;
12520 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12521 break;
12522 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12523 break;
12524 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12525 break;
12526 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12527 break;
12528 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12529 break;
12530 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12531 break;
12532 }
12533
12534 // set default iterations
12535
12536 switch (hash_mode)
12537 {
12538 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12539 break;
12540 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12541 break;
12542 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12543 break;
12544 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12545 break;
12546 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12547 break;
12548 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12549 break;
12550 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12551 break;
12552 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12553 break;
12554 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12555 break;
12556 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12557 break;
12558 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12559 break;
12560 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12561 break;
12562 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12563 break;
12564 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12565 break;
12566 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12567 break;
12568 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12569 break;
12570 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12571 break;
12572 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12573 break;
12574 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12575 break;
12576 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12577 break;
12578 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12579 break;
12580 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12581 break;
12582 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12583 break;
12584 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12585 break;
12586 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12587 break;
12588 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12589 break;
12590 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12591 break;
12592 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12593 break;
12594 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12595 break;
12596 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12597 break;
12598 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12599 break;
12600 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12601 break;
12602 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12603 break;
12604 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12605 break;
12606 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12607 break;
12608 case 8900: hashes_buf[0].salt->salt_iter = 1;
12609 break;
12610 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12611 break;
12612 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12613 break;
12614 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12615 break;
12616 case 9300: hashes_buf[0].salt->salt_iter = 1;
12617 break;
12618 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12619 break;
12620 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12621 break;
12622 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12623 break;
12624 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12625 break;
12626 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12627 break;
12628 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12629 break;
12630 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12631 break;
12632 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12633 break;
12634 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12635 break;
12636 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12637 break;
12638 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12639 break;
12640 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12641 break;
12642 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12643 break;
12644 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12645 break;
12646 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12647 break;
12648 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12649 break;
12650 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12651 break;
12652 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12653 break;
12654 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12655 break;
12656 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12657 break;
12658 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12659 break;
12660 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12661 break;
12662 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12663 break;
12664 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12665 break;
12666 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12667 break;
12668 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12669 break;
12670 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12671 break;
12672 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12673 break;
12674 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12675 break;
12676 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12677 break;
12678 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12679 break;
12680 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12681 break;
12682 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12683 break;
12684 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12685 break;
12686 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12687 break;
12688 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12689 break;
12690 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12691 break;
12692 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12693 break;
12694 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12695 break;
12696 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12697 break;
12698 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12699 break;
12700 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12701 break;
12702 }
12703
12704 hashes_cnt = 1;
12705 }
12706
12707 if (show == 1 || left == 1)
12708 {
12709 for (uint i = 0; i < pot_cnt; i++)
12710 {
12711 pot_t *pot_ptr = &pot[i];
12712
12713 hash_t *hashes_buf = &pot_ptr->hash;
12714
12715 local_free (hashes_buf->digest);
12716
12717 if (isSalted)
12718 {
12719 local_free (hashes_buf->salt);
12720 }
12721 }
12722
12723 local_free (pot);
12724
12725 if (data.quiet == 0) log_info_nn ("");
12726
12727 return (0);
12728 }
12729
12730 if ((keyspace == 0) && (stdout_flag == 0))
12731 {
12732 if (hashes_cnt == 0)
12733 {
12734 log_error ("ERROR: No hashes loaded");
12735
12736 return (-1);
12737 }
12738 }
12739
12740 /**
12741 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12742 */
12743
12744 if (data.outfile != NULL)
12745 {
12746 if (data.hashfile != NULL)
12747 {
12748 #ifdef _POSIX
12749 struct stat tmpstat_outfile;
12750 struct stat tmpstat_hashfile;
12751 #endif
12752
12753 #ifdef _WIN
12754 struct stat64 tmpstat_outfile;
12755 struct stat64 tmpstat_hashfile;
12756 #endif
12757
12758 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12759
12760 if (tmp_outfile_fp)
12761 {
12762 #ifdef _POSIX
12763 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12764 #endif
12765
12766 #ifdef _WIN
12767 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12768 #endif
12769
12770 fclose (tmp_outfile_fp);
12771 }
12772
12773 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12774
12775 if (tmp_hashfile_fp)
12776 {
12777 #ifdef _POSIX
12778 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12779 #endif
12780
12781 #ifdef _WIN
12782 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12783 #endif
12784
12785 fclose (tmp_hashfile_fp);
12786 }
12787
12788 if (tmp_outfile_fp && tmp_outfile_fp)
12789 {
12790 tmpstat_outfile.st_mode = 0;
12791 tmpstat_outfile.st_nlink = 0;
12792 tmpstat_outfile.st_uid = 0;
12793 tmpstat_outfile.st_gid = 0;
12794 tmpstat_outfile.st_rdev = 0;
12795 tmpstat_outfile.st_atime = 0;
12796
12797 tmpstat_hashfile.st_mode = 0;
12798 tmpstat_hashfile.st_nlink = 0;
12799 tmpstat_hashfile.st_uid = 0;
12800 tmpstat_hashfile.st_gid = 0;
12801 tmpstat_hashfile.st_rdev = 0;
12802 tmpstat_hashfile.st_atime = 0;
12803
12804 #ifdef _POSIX
12805 tmpstat_outfile.st_blksize = 0;
12806 tmpstat_outfile.st_blocks = 0;
12807
12808 tmpstat_hashfile.st_blksize = 0;
12809 tmpstat_hashfile.st_blocks = 0;
12810 #endif
12811
12812 #ifdef _POSIX
12813 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12814 {
12815 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12816
12817 return (-1);
12818 }
12819 #endif
12820
12821 #ifdef _WIN
12822 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12823 {
12824 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12825
12826 return (-1);
12827 }
12828 #endif
12829 }
12830 }
12831 }
12832
12833 /**
12834 * Remove duplicates
12835 */
12836
12837 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12838
12839 if (isSalted)
12840 {
12841 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12842 }
12843 else
12844 {
12845 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12846 }
12847
12848 uint hashes_cnt_orig = hashes_cnt;
12849
12850 hashes_cnt = 1;
12851
12852 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12853 {
12854 if (isSalted)
12855 {
12856 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12857 {
12858 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12859 }
12860 }
12861 else
12862 {
12863 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12864 }
12865
12866 if (hashes_pos > hashes_cnt)
12867 {
12868 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12869 }
12870
12871 hashes_cnt++;
12872 }
12873
12874 /**
12875 * Potfile removes
12876 */
12877
12878 uint potfile_remove_cracks = 0;
12879
12880 if (potfile_disable == 0)
12881 {
12882 hash_t hash_buf;
12883
12884 hash_buf.digest = mymalloc (dgst_size);
12885 hash_buf.salt = NULL;
12886 hash_buf.esalt = NULL;
12887 hash_buf.hash_info = NULL;
12888 hash_buf.cracked = 0;
12889
12890 if (isSalted)
12891 {
12892 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12893 }
12894
12895 if (esalt_size)
12896 {
12897 hash_buf.esalt = mymalloc (esalt_size);
12898 }
12899
12900 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12901
12902 // no solution for these special hash types (for instane because they use hashfile in output etc)
12903 if ((hash_mode != 5200) &&
12904 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12905 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12906 (hash_mode != 9000))
12907 {
12908 FILE *fp = fopen (potfile, "rb");
12909
12910 if (fp != NULL)
12911 {
12912 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12913
12914 // to be safe work with a copy (because of line_len loop, i etc)
12915 // moved up here because it's easier to handle continue case
12916 // it's just 64kb
12917
12918 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12919
12920 while (!feof (fp))
12921 {
12922 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12923
12924 if (ptr == NULL) break;
12925
12926 int line_len = strlen (line_buf);
12927
12928 if (line_len == 0) continue;
12929
12930 int iter = MAX_CUT_TRIES;
12931
12932 for (int i = line_len - 1; i && iter; i--, line_len--)
12933 {
12934 if (line_buf[i] != ':') continue;
12935
12936 if (isSalted)
12937 {
12938 memset (hash_buf.salt, 0, sizeof (salt_t));
12939 }
12940
12941 hash_t *found = NULL;
12942
12943 if (hash_mode == 6800)
12944 {
12945 if (i < 64) // 64 = 16 * uint in salt_buf[]
12946 {
12947 // manipulate salt_buf
12948 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12949
12950 hash_buf.salt->salt_len = i;
12951
12952 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12953 }
12954 }
12955 else if (hash_mode == 2500)
12956 {
12957 if (i < 64) // 64 = 16 * uint in salt_buf[]
12958 {
12959 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12960 // manipulate salt_buf
12961
12962 memcpy (line_buf_cpy, line_buf, i);
12963
12964 char *mac2_pos = strrchr (line_buf_cpy, ':');
12965
12966 if (mac2_pos == NULL) continue;
12967
12968 mac2_pos[0] = 0;
12969 mac2_pos++;
12970
12971 if (strlen (mac2_pos) != 12) continue;
12972
12973 char *mac1_pos = strrchr (line_buf_cpy, ':');
12974
12975 if (mac1_pos == NULL) continue;
12976
12977 mac1_pos[0] = 0;
12978 mac1_pos++;
12979
12980 if (strlen (mac1_pos) != 12) continue;
12981
12982 uint essid_length = mac1_pos - line_buf_cpy - 1;
12983
12984 // here we need the ESSID
12985 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12986
12987 hash_buf.salt->salt_len = essid_length;
12988
12989 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12990
12991 if (found)
12992 {
12993 wpa_t *wpa = (wpa_t *) found->esalt;
12994
12995 // compare hex string(s) vs binary MAC address(es)
12996
12997 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12998 {
12999 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
13000 {
13001 found = NULL;
13002
13003 break;
13004 }
13005 }
13006
13007 // early skip ;)
13008 if (!found) continue;
13009
13010 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13011 {
13012 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
13013 {
13014 found = NULL;
13015
13016 break;
13017 }
13018 }
13019 }
13020 }
13021 }
13022 else
13023 {
13024 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
13025
13026 if (parser_status == PARSER_OK)
13027 {
13028 if (isSalted)
13029 {
13030 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
13031 }
13032 else
13033 {
13034 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
13035 }
13036 }
13037 }
13038
13039 if (found == NULL) continue;
13040
13041 if (!found->cracked) potfile_remove_cracks++;
13042
13043 found->cracked = 1;
13044
13045 if (found) break;
13046
13047 iter--;
13048 }
13049 }
13050
13051 myfree (line_buf_cpy);
13052
13053 myfree (line_buf);
13054
13055 fclose (fp);
13056 }
13057 }
13058
13059 if (esalt_size)
13060 {
13061 local_free (hash_buf.esalt);
13062 }
13063
13064 if (isSalted)
13065 {
13066 local_free (hash_buf.salt);
13067 }
13068
13069 local_free (hash_buf.digest);
13070 }
13071
13072 /**
13073 * Now generate all the buffers required for later
13074 */
13075
13076 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
13077
13078 salt_t *salts_buf_new = NULL;
13079 void *esalts_buf_new = NULL;
13080
13081 if (isSalted)
13082 {
13083 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
13084
13085 if (esalt_size)
13086 {
13087 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
13088 }
13089 }
13090 else
13091 {
13092 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13093 }
13094
13095 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13096
13097 uint digests_cnt = hashes_cnt;
13098 uint digests_done = 0;
13099
13100 size_t size_digests = digests_cnt * dgst_size;
13101 size_t size_shown = digests_cnt * sizeof (uint);
13102
13103 uint *digests_shown = (uint *) mymalloc (size_shown);
13104 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13105
13106 uint salts_cnt = 0;
13107 uint salts_done = 0;
13108
13109 hashinfo_t **hash_info = NULL;
13110
13111 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13112 {
13113 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13114
13115 if (username && (remove || show))
13116 {
13117 uint user_pos;
13118
13119 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13120 {
13121 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13122
13123 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13124 }
13125 }
13126 }
13127
13128 uint *salts_shown = (uint *) mymalloc (size_shown);
13129
13130 salt_t *salt_buf;
13131
13132 {
13133 // copied from inner loop
13134
13135 salt_buf = &salts_buf_new[salts_cnt];
13136
13137 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13138
13139 if (esalt_size)
13140 {
13141 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13142 }
13143
13144 salt_buf->digests_cnt = 0;
13145 salt_buf->digests_done = 0;
13146 salt_buf->digests_offset = 0;
13147
13148 salts_cnt++;
13149 }
13150
13151 if (hashes_buf[0].cracked == 1)
13152 {
13153 digests_shown[0] = 1;
13154
13155 digests_done++;
13156
13157 salt_buf->digests_done++;
13158 }
13159
13160 salt_buf->digests_cnt++;
13161
13162 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13163
13164 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13165 {
13166 hash_info[0] = hashes_buf[0].hash_info;
13167 }
13168
13169 // copy from inner loop
13170
13171 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13172 {
13173 if (isSalted)
13174 {
13175 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13176 {
13177 salt_buf = &salts_buf_new[salts_cnt];
13178
13179 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13180
13181 if (esalt_size)
13182 {
13183 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13184 }
13185
13186 salt_buf->digests_cnt = 0;
13187 salt_buf->digests_done = 0;
13188 salt_buf->digests_offset = hashes_pos;
13189
13190 salts_cnt++;
13191 }
13192 }
13193
13194 if (hashes_buf[hashes_pos].cracked == 1)
13195 {
13196 digests_shown[hashes_pos] = 1;
13197
13198 digests_done++;
13199
13200 salt_buf->digests_done++;
13201 }
13202
13203 salt_buf->digests_cnt++;
13204
13205 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13206
13207 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13208 {
13209 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13210 }
13211 }
13212
13213 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13214 {
13215 salt_t *salt_buf = &salts_buf_new[salt_pos];
13216
13217 if (salt_buf->digests_done == salt_buf->digests_cnt)
13218 {
13219 salts_shown[salt_pos] = 1;
13220
13221 salts_done++;
13222 }
13223
13224 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13225 }
13226
13227 local_free (digests_buf);
13228 local_free (salts_buf);
13229 local_free (esalts_buf);
13230
13231 digests_buf = digests_buf_new;
13232 salts_buf = salts_buf_new;
13233 esalts_buf = esalts_buf_new;
13234
13235 local_free (hashes_buf);
13236
13237 /**
13238 * special modification not set from parser
13239 */
13240
13241 switch (hash_mode)
13242 {
13243 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13244 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13245 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13246 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13247 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13248 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13249 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13250 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13251 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13252 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13253 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13254 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13255 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13256 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13257 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13258 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13259 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13260 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13261 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13262 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13263 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13264 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13265 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13266 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13267 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13268 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13269 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13270 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13271 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13272 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13273 }
13274
13275 if (truecrypt_keyfiles)
13276 {
13277 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13278
13279 char *keyfiles = strdup (truecrypt_keyfiles);
13280
13281 char *keyfile = strtok (keyfiles, ",");
13282
13283 do
13284 {
13285 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13286
13287 } while ((keyfile = strtok (NULL, ",")) != NULL);
13288
13289 free (keyfiles);
13290 }
13291
13292 if (veracrypt_keyfiles)
13293 {
13294 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13295
13296 char *keyfiles = strdup (veracrypt_keyfiles);
13297
13298 char *keyfile = strtok (keyfiles, ",");
13299
13300 do
13301 {
13302 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13303
13304 } while ((keyfile = strtok (NULL, ",")) != NULL);
13305
13306 free (keyfiles);
13307 }
13308
13309 data.digests_cnt = digests_cnt;
13310 data.digests_done = digests_done;
13311 data.digests_buf = digests_buf;
13312 data.digests_shown = digests_shown;
13313 data.digests_shown_tmp = digests_shown_tmp;
13314
13315 data.salts_cnt = salts_cnt;
13316 data.salts_done = salts_done;
13317 data.salts_buf = salts_buf;
13318 data.salts_shown = salts_shown;
13319
13320 data.esalts_buf = esalts_buf;
13321 data.hash_info = hash_info;
13322
13323 /**
13324 * Automatic Optimizers
13325 */
13326
13327 if (salts_cnt == 1)
13328 opti_type |= OPTI_TYPE_SINGLE_SALT;
13329
13330 if (digests_cnt == 1)
13331 opti_type |= OPTI_TYPE_SINGLE_HASH;
13332
13333 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13334 opti_type |= OPTI_TYPE_NOT_ITERATED;
13335
13336 if (attack_mode == ATTACK_MODE_BF)
13337 opti_type |= OPTI_TYPE_BRUTE_FORCE;
13338
13339 data.opti_type = opti_type;
13340
13341 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13342 {
13343 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13344 {
13345 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13346 {
13347 if (opts_type & OPTS_TYPE_ST_ADD80)
13348 {
13349 opts_type &= ~OPTS_TYPE_ST_ADD80;
13350 opts_type |= OPTS_TYPE_PT_ADD80;
13351 }
13352
13353 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13354 {
13355 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13356 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13357 }
13358
13359 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13360 {
13361 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13362 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13363 }
13364 }
13365 }
13366 }
13367
13368 /**
13369 * Some algorithm, like descrypt, can benefit from JIT compilation
13370 */
13371
13372 int force_jit_compilation = -1;
13373
13374 if (hash_mode == 8900)
13375 {
13376 force_jit_compilation = 8900;
13377 }
13378 else if (hash_mode == 9300)
13379 {
13380 force_jit_compilation = 8900;
13381 }
13382 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13383 {
13384 force_jit_compilation = 1500;
13385 }
13386
13387 /**
13388 * generate bitmap tables
13389 */
13390
13391 const uint bitmap_shift1 = 5;
13392 const uint bitmap_shift2 = 13;
13393
13394 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13395
13396 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13397 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13398 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13399 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13400 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13401 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13402 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13403 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13404
13405 uint bitmap_bits;
13406 uint bitmap_nums;
13407 uint bitmap_mask;
13408 uint bitmap_size;
13409
13410 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13411 {
13412 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13413
13414 bitmap_nums = 1 << bitmap_bits;
13415
13416 bitmap_mask = bitmap_nums - 1;
13417
13418 bitmap_size = bitmap_nums * sizeof (uint);
13419
13420 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13421
13422 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;
13423 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;
13424
13425 break;
13426 }
13427
13428 bitmap_nums = 1 << bitmap_bits;
13429
13430 bitmap_mask = bitmap_nums - 1;
13431
13432 bitmap_size = bitmap_nums * sizeof (uint);
13433
13434 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);
13435 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);
13436
13437 /**
13438 * prepare quick rule
13439 */
13440
13441 data.rule_buf_l = rule_buf_l;
13442 data.rule_buf_r = rule_buf_r;
13443
13444 int rule_len_l = (int) strlen (rule_buf_l);
13445 int rule_len_r = (int) strlen (rule_buf_r);
13446
13447 data.rule_len_l = rule_len_l;
13448 data.rule_len_r = rule_len_r;
13449
13450 /**
13451 * load rules
13452 */
13453
13454 uint *all_kernel_rules_cnt = NULL;
13455
13456 kernel_rule_t **all_kernel_rules_buf = NULL;
13457
13458 if (rp_files_cnt)
13459 {
13460 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13461
13462 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13463 }
13464
13465 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13466
13467 int rule_len = 0;
13468
13469 for (uint i = 0; i < rp_files_cnt; i++)
13470 {
13471 uint kernel_rules_avail = 0;
13472
13473 uint kernel_rules_cnt = 0;
13474
13475 kernel_rule_t *kernel_rules_buf = NULL;
13476
13477 char *rp_file = rp_files[i];
13478
13479 char in[BLOCK_SIZE] = { 0 };
13480 char out[BLOCK_SIZE] = { 0 };
13481
13482 FILE *fp = NULL;
13483
13484 uint rule_line = 0;
13485
13486 if ((fp = fopen (rp_file, "rb")) == NULL)
13487 {
13488 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13489
13490 return (-1);
13491 }
13492
13493 while (!feof (fp))
13494 {
13495 memset (rule_buf, 0, HCBUFSIZ);
13496
13497 rule_len = fgetl (fp, rule_buf);
13498
13499 rule_line++;
13500
13501 if (rule_len == 0) continue;
13502
13503 if (rule_buf[0] == '#') continue;
13504
13505 if (kernel_rules_avail == kernel_rules_cnt)
13506 {
13507 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13508
13509 kernel_rules_avail += INCR_RULES;
13510 }
13511
13512 memset (in, 0, BLOCK_SIZE);
13513 memset (out, 0, BLOCK_SIZE);
13514
13515 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13516
13517 if (result == -1)
13518 {
13519 log_info ("WARNING: Skipping invalid or unsupported rule in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13520
13521 continue;
13522 }
13523
13524 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13525 {
13526 log_info ("WARNING: Cannot convert rule for use on device in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13527
13528 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13529
13530 continue;
13531 }
13532
13533 /* its so slow
13534 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13535 {
13536 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13537
13538 continue;
13539 }
13540 */
13541
13542 kernel_rules_cnt++;
13543 }
13544
13545 fclose (fp);
13546
13547 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13548
13549 all_kernel_rules_buf[i] = kernel_rules_buf;
13550 }
13551
13552 /**
13553 * merge rules or automatic rule generator
13554 */
13555
13556 uint kernel_rules_cnt = 0;
13557
13558 kernel_rule_t *kernel_rules_buf = NULL;
13559
13560 if (attack_mode == ATTACK_MODE_STRAIGHT)
13561 {
13562 if (rp_files_cnt)
13563 {
13564 kernel_rules_cnt = 1;
13565
13566 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13567
13568 repeats[0] = kernel_rules_cnt;
13569
13570 for (uint i = 0; i < rp_files_cnt; i++)
13571 {
13572 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13573
13574 repeats[i + 1] = kernel_rules_cnt;
13575 }
13576
13577 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13578
13579 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13580
13581 for (uint i = 0; i < kernel_rules_cnt; i++)
13582 {
13583 uint out_pos = 0;
13584
13585 kernel_rule_t *out = &kernel_rules_buf[i];
13586
13587 for (uint j = 0; j < rp_files_cnt; j++)
13588 {
13589 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13590 uint in_pos;
13591
13592 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13593
13594 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13595 {
13596 if (out_pos == RULES_MAX - 1)
13597 {
13598 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13599
13600 break;
13601 }
13602
13603 out->cmds[out_pos] = in->cmds[in_pos];
13604 }
13605 }
13606 }
13607
13608 local_free (repeats);
13609 }
13610 else if (rp_gen)
13611 {
13612 uint kernel_rules_avail = 0;
13613
13614 while (kernel_rules_cnt < rp_gen)
13615 {
13616 if (kernel_rules_avail == kernel_rules_cnt)
13617 {
13618 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13619
13620 kernel_rules_avail += INCR_RULES;
13621 }
13622
13623 memset (rule_buf, 0, HCBUFSIZ);
13624
13625 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13626
13627 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13628
13629 kernel_rules_cnt++;
13630 }
13631 }
13632 }
13633
13634 myfree (rule_buf);
13635
13636 /**
13637 * generate NOP rules
13638 */
13639
13640 if (kernel_rules_cnt == 0)
13641 {
13642 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13643
13644 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13645
13646 kernel_rules_cnt++;
13647 }
13648
13649 data.kernel_rules_cnt = kernel_rules_cnt;
13650 data.kernel_rules_buf = kernel_rules_buf;
13651
13652 /**
13653 * OpenCL platforms: detect
13654 */
13655
13656 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13657 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13658
13659 cl_uint platforms_cnt = 0;
13660 cl_uint platform_devices_cnt = 0;
13661
13662 if (keyspace == 0)
13663 {
13664 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13665
13666 if (platforms_cnt == 0)
13667 {
13668 log_info ("");
13669 log_info ("ATTENTION! No OpenCL compatible platform found");
13670 log_info ("");
13671 log_info ("You're probably missing the OpenCL runtime installation");
13672 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13673 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13674 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13675 log_info ("");
13676
13677 return (-1);
13678 }
13679
13680 if (opencl_platforms_filter != (uint) -1)
13681 {
13682 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13683
13684 if (opencl_platforms_filter > platform_cnt_mask)
13685 {
13686 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13687
13688 return (-1);
13689 }
13690 }
13691 }
13692
13693 if (opencl_device_types == NULL)
13694 {
13695 /**
13696 * OpenCL device types:
13697 * 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.
13698 */
13699
13700 cl_device_type device_types_all = 0;
13701
13702 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13703 {
13704 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13705
13706 cl_platform_id platform = platforms[platform_id];
13707
13708 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13709
13710 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13711 {
13712 cl_device_id device = platform_devices[platform_devices_id];
13713
13714 cl_device_type device_type;
13715
13716 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13717
13718 device_types_all |= device_type;
13719 }
13720 }
13721
13722 // In such a case, automatically enable CPU device type support, since it's disabled by default.
13723
13724 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13725 {
13726 device_types_filter |= CL_DEVICE_TYPE_CPU;
13727 }
13728
13729 // In another case, when the user uses --stdout, using CPU devices is much faster to setup
13730 // If we have a CPU device, force it to be used
13731
13732 if (stdout_flag == 1)
13733 {
13734 if (device_types_all & CL_DEVICE_TYPE_CPU)
13735 {
13736 device_types_filter = CL_DEVICE_TYPE_CPU;
13737 }
13738 }
13739 }
13740
13741 /**
13742 * OpenCL devices: simply push all devices from all platforms into the same device array
13743 */
13744
13745 int need_adl = 0;
13746 int need_nvapi = 0;
13747 int need_nvml = 0;
13748 int need_xnvctrl = 0;
13749
13750 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13751
13752 data.devices_param = devices_param;
13753
13754 uint devices_cnt = 0;
13755
13756 uint devices_active = 0;
13757
13758 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13759 {
13760 cl_platform_id platform = platforms[platform_id];
13761
13762 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13763
13764 char platform_vendor[INFOSZ] = { 0 };
13765
13766 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13767
13768 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13769 // this causes trouble with vendor id based macros
13770 // we'll assign generic to those without special optimization available
13771
13772 cl_uint platform_vendor_id = 0;
13773
13774 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13775 {
13776 platform_vendor_id = VENDOR_ID_AMD;
13777 }
13778 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13779 {
13780 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13781 }
13782 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13783 {
13784 platform_vendor_id = VENDOR_ID_APPLE;
13785 }
13786 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13787 {
13788 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13789 }
13790 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13791 {
13792 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13793 }
13794 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13795 {
13796 platform_vendor_id = VENDOR_ID_MESA;
13797 }
13798 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13799 {
13800 platform_vendor_id = VENDOR_ID_NV;
13801 }
13802 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13803 {
13804 platform_vendor_id = VENDOR_ID_POCL;
13805 }
13806 else
13807 {
13808 platform_vendor_id = VENDOR_ID_GENERIC;
13809 }
13810
13811 const uint platform_skipped = ((opencl_platforms_filter & (1 << platform_id)) == 0);
13812
13813 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13814 {
13815 if (machine_readable == 0)
13816 {
13817 if (platform_skipped == 0)
13818 {
13819 const int len = log_info ("OpenCL Platform #%u: %s", platform_id + 1, platform_vendor);
13820
13821 char line[256] = { 0 };
13822
13823 for (int i = 0; i < len; i++) line[i] = '=';
13824
13825 log_info (line);
13826 }
13827 else
13828 {
13829 log_info ("OpenCL Platform #%u: %s, skipped", platform_id + 1, platform_vendor);
13830 log_info ("");
13831 }
13832 }
13833 }
13834
13835 if (platform_skipped == 1) continue;
13836
13837 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13838 {
13839 size_t param_value_size = 0;
13840
13841 const uint device_id = devices_cnt;
13842
13843 hc_device_param_t *device_param = &data.devices_param[device_id];
13844
13845 device_param->platform_vendor_id = platform_vendor_id;
13846
13847 device_param->device = platform_devices[platform_devices_id];
13848
13849 device_param->device_id = device_id;
13850
13851 device_param->platform_devices_id = platform_devices_id;
13852
13853 // device_type
13854
13855 cl_device_type device_type;
13856
13857 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13858
13859 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13860
13861 device_param->device_type = device_type;
13862
13863 // device_name
13864
13865 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13866
13867 char *device_name = (char *) mymalloc (param_value_size);
13868
13869 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13870
13871 device_param->device_name = device_name;
13872
13873 // device_vendor
13874
13875 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13876
13877 char *device_vendor = (char *) mymalloc (param_value_size);
13878
13879 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13880
13881 device_param->device_vendor = device_vendor;
13882
13883 cl_uint device_vendor_id = 0;
13884
13885 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13886 {
13887 device_vendor_id = VENDOR_ID_AMD;
13888 }
13889 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13890 {
13891 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13892 }
13893 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13894 {
13895 device_vendor_id = VENDOR_ID_APPLE;
13896 }
13897 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13898 {
13899 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13900 }
13901 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13902 {
13903 device_vendor_id = VENDOR_ID_INTEL_SDK;
13904 }
13905 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13906 {
13907 device_vendor_id = VENDOR_ID_MESA;
13908 }
13909 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13910 {
13911 device_vendor_id = VENDOR_ID_NV;
13912 }
13913 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13914 {
13915 device_vendor_id = VENDOR_ID_POCL;
13916 }
13917 else
13918 {
13919 device_vendor_id = VENDOR_ID_GENERIC;
13920 }
13921
13922 device_param->device_vendor_id = device_vendor_id;
13923
13924 // tuning db
13925
13926 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13927
13928 // device_version
13929
13930 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13931
13932 char *device_version = (char *) mymalloc (param_value_size);
13933
13934 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13935
13936 device_param->device_version = device_version;
13937
13938 // device_opencl_version
13939
13940 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13941
13942 char *device_opencl_version = (char *) mymalloc (param_value_size);
13943
13944 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13945
13946 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13947
13948 myfree (device_opencl_version);
13949
13950 // vector_width
13951
13952 cl_uint vector_width;
13953
13954 if (opencl_vector_width_chgd == 0)
13955 {
13956 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13957 {
13958 if (opti_type & OPTI_TYPE_USES_BITS_64)
13959 {
13960 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13961 }
13962 else
13963 {
13964 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13965 }
13966 }
13967 else
13968 {
13969 vector_width = (cl_uint) tuningdb_entry->vector_width;
13970 }
13971 }
13972 else
13973 {
13974 vector_width = opencl_vector_width;
13975 }
13976
13977 if (vector_width > 16) vector_width = 16;
13978
13979 device_param->vector_width = vector_width;
13980
13981 // max_compute_units
13982
13983 cl_uint device_processors;
13984
13985 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13986
13987 device_param->device_processors = device_processors;
13988
13989 // device_maxmem_alloc
13990 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13991
13992 cl_ulong device_maxmem_alloc;
13993
13994 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13995
13996 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13997
13998 // device_global_mem
13999
14000 cl_ulong device_global_mem;
14001
14002 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
14003
14004 device_param->device_global_mem = device_global_mem;
14005
14006 // max_work_group_size
14007
14008 size_t device_maxworkgroup_size;
14009
14010 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
14011
14012 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
14013
14014 // max_clock_frequency
14015
14016 cl_uint device_maxclock_frequency;
14017
14018 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
14019
14020 device_param->device_maxclock_frequency = device_maxclock_frequency;
14021
14022 // device_endian_little
14023
14024 cl_bool device_endian_little;
14025
14026 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
14027
14028 if (device_endian_little == CL_FALSE)
14029 {
14030 log_info ("- Device #%u: WARNING: Not a little endian device", device_id + 1);
14031
14032 device_param->skipped = 1;
14033 }
14034
14035 // device_available
14036
14037 cl_bool device_available;
14038
14039 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
14040
14041 if (device_available == CL_FALSE)
14042 {
14043 log_info ("- Device #%u: WARNING: Device not available", device_id + 1);
14044
14045 device_param->skipped = 1;
14046 }
14047
14048 // device_compiler_available
14049
14050 cl_bool device_compiler_available;
14051
14052 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
14053
14054 if (device_compiler_available == CL_FALSE)
14055 {
14056 log_info ("- Device #%u: WARNING: No compiler available for device", device_id + 1);
14057
14058 device_param->skipped = 1;
14059 }
14060
14061 // device_execution_capabilities
14062
14063 cl_device_exec_capabilities device_execution_capabilities;
14064
14065 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
14066
14067 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
14068 {
14069 log_info ("- Device #%u: WARNING: Device does not support executing kernels", device_id + 1);
14070
14071 device_param->skipped = 1;
14072 }
14073
14074 // device_extensions
14075
14076 size_t device_extensions_size;
14077
14078 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
14079
14080 char *device_extensions = mymalloc (device_extensions_size + 1);
14081
14082 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
14083
14084 if (strstr (device_extensions, "base_atomics") == 0)
14085 {
14086 log_info ("- Device #%u: WARNING: Device does not support base atomics", device_id + 1);
14087
14088 device_param->skipped = 1;
14089 }
14090
14091 if (strstr (device_extensions, "byte_addressable_store") == 0)
14092 {
14093 log_info ("- Device #%u: WARNING: Device does not support byte addressable store", device_id + 1);
14094
14095 device_param->skipped = 1;
14096 }
14097
14098 myfree (device_extensions);
14099
14100 // device_local_mem_size
14101
14102 cl_ulong device_local_mem_size;
14103
14104 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
14105
14106 if (device_local_mem_size < 32768)
14107 {
14108 log_info ("- Device #%u: WARNING: Device local mem size is too small", device_id + 1);
14109
14110 device_param->skipped = 1;
14111 }
14112
14113 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
14114 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
14115 // This results in both utilizing it for 50%
14116 // However, Intel has much better SIMD control over their own hardware
14117 // It makes sense to give them full control over their own hardware
14118
14119 if (device_type & CL_DEVICE_TYPE_CPU)
14120 {
14121 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14122 {
14123 if (data.force == 0)
14124 {
14125 if (algorithm_pos == 0)
14126 {
14127 log_info ("- Device #%u: WARNING: Not a native Intel OpenCL runtime, expect massive speed loss", device_id + 1);
14128 log_info (" You can use --force to override this but do not post error reports if you do so");
14129 }
14130
14131 device_param->skipped = 1;
14132 }
14133 }
14134 }
14135
14136 // skipped
14137
14138 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14139 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14140
14141 // driver_version
14142
14143 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14144
14145 char *driver_version = (char *) mymalloc (param_value_size);
14146
14147 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14148
14149 device_param->driver_version = driver_version;
14150
14151 // device_name_chksum
14152
14153 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14154
14155 #if __x86_64__
14156 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);
14157 #else
14158 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);
14159 #endif
14160
14161 uint device_name_digest[4] = { 0 };
14162
14163 md5_64 ((uint *) device_name_chksum, device_name_digest);
14164
14165 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14166
14167 device_param->device_name_chksum = device_name_chksum;
14168
14169 // device_processor_cores
14170
14171 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14172 {
14173 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14174 {
14175 need_adl = 1;
14176 }
14177
14178 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14179 {
14180 need_nvml = 1;
14181
14182 #ifdef LINUX
14183 need_xnvctrl = 1;
14184 #endif
14185
14186 #ifdef WIN
14187 need_nvapi = 1;
14188 #endif
14189 }
14190 }
14191
14192 // device_processor_cores
14193
14194 if (device_type & CL_DEVICE_TYPE_CPU)
14195 {
14196 cl_uint device_processor_cores = 1;
14197
14198 device_param->device_processor_cores = device_processor_cores;
14199 }
14200
14201 if (device_type & CL_DEVICE_TYPE_GPU)
14202 {
14203 if (device_vendor_id == VENDOR_ID_AMD)
14204 {
14205 cl_uint device_processor_cores = 0;
14206
14207 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
14208
14209 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
14210
14211 device_param->device_processor_cores = device_processor_cores;
14212 }
14213 else if (device_vendor_id == VENDOR_ID_NV)
14214 {
14215 cl_uint kernel_exec_timeout = 0;
14216
14217 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14218
14219 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14220
14221 device_param->kernel_exec_timeout = kernel_exec_timeout;
14222
14223 cl_uint device_processor_cores = 0;
14224
14225 #define CL_DEVICE_WARP_SIZE_NV 0x4003
14226
14227 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
14228
14229 device_param->device_processor_cores = device_processor_cores;
14230
14231 cl_uint sm_minor = 0;
14232 cl_uint sm_major = 0;
14233
14234 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14235 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14236
14237 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14238 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14239
14240 device_param->sm_minor = sm_minor;
14241 device_param->sm_major = sm_major;
14242
14243 // CPU burning loop damper
14244 // Value is given as number between 0-100
14245 // By default 100%
14246
14247 device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14248
14249 if (nvidia_spin_damp_chgd == 0)
14250 {
14251 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14252 {
14253 /**
14254 * the workaround is not a friend of rule based attacks
14255 * the words from the wordlist combined with fast and slow rules cause
14256 * fluctuations which cause inaccurate wait time estimations
14257 * using a reduced damping percentage almost compensates this
14258 */
14259
14260 device_param->nvidia_spin_damp = 64;
14261 }
14262 }
14263
14264 device_param->nvidia_spin_damp /= 100;
14265 }
14266 else
14267 {
14268 cl_uint device_processor_cores = 1;
14269
14270 device_param->device_processor_cores = device_processor_cores;
14271 }
14272 }
14273
14274 // display results
14275
14276 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14277 {
14278 if (machine_readable == 0)
14279 {
14280 if (device_param->skipped == 0)
14281 {
14282 log_info ("- Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14283 device_id + 1,
14284 device_name,
14285 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14286 (unsigned int) (device_global_mem / 1024 / 1024),
14287 (unsigned int) device_processors);
14288 }
14289 else
14290 {
14291 log_info ("- Device #%u: %s, skipped",
14292 device_id + 1,
14293 device_name);
14294 }
14295 }
14296 }
14297
14298 // common driver check
14299
14300 if (device_param->skipped == 0)
14301 {
14302 if (device_type & CL_DEVICE_TYPE_GPU)
14303 {
14304 if (platform_vendor_id == VENDOR_ID_AMD)
14305 {
14306 int catalyst_check = (force == 1) ? 0 : 1;
14307
14308 int catalyst_warn = 0;
14309
14310 int catalyst_broken = 0;
14311
14312 if (catalyst_check == 1)
14313 {
14314 catalyst_warn = 1;
14315
14316 // v14.9 and higher
14317 if (atoi (device_param->driver_version) >= 1573)
14318 {
14319 catalyst_warn = 0;
14320 }
14321
14322 catalyst_check = 0;
14323 }
14324
14325 if (catalyst_broken == 1)
14326 {
14327 log_info ("");
14328 log_info ("ATTENTION! The Catalyst driver installed on your system is known to be broken!");
14329 log_info ("It passes over cracked hashes and will not report them as cracked");
14330 log_info ("You are STRONGLY encouraged not to use it");
14331 log_info ("You can use --force to override this but do not post error reports if you do so");
14332 log_info ("");
14333
14334 return (-1);
14335 }
14336
14337 if (catalyst_warn == 1)
14338 {
14339 log_info ("");
14340 log_info ("ATTENTION! Unsupported or incorrectly installed Catalyst driver detected!");
14341 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver");
14342 log_info ("See hashcat's homepage for official supported catalyst drivers");
14343 #ifdef _WIN
14344 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14345 #endif
14346 log_info ("You can use --force to override this but do not post error reports if you do so");
14347 log_info ("");
14348
14349 return (-1);
14350 }
14351 }
14352 else if (platform_vendor_id == VENDOR_ID_NV)
14353 {
14354 if (device_param->kernel_exec_timeout != 0)
14355 {
14356 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);
14357 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14358 }
14359 }
14360 }
14361
14362 /* turns out pocl still creates segfaults (because of llvm)
14363 if (device_type & CL_DEVICE_TYPE_CPU)
14364 {
14365 if (platform_vendor_id == VENDOR_ID_AMD)
14366 {
14367 if (force == 0)
14368 {
14369 log_info ("");
14370 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14371 log_info ("You are STRONGLY encouraged not to use it");
14372 log_info ("You can use --force to override this but do not post error reports if you do so");
14373 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14374 log_info ("");
14375
14376 return (-1);
14377 }
14378 }
14379 }
14380 */
14381
14382 /**
14383 * kernel accel and loops tuning db adjustment
14384 */
14385
14386 device_param->kernel_accel_min = 1;
14387 device_param->kernel_accel_max = 1024;
14388
14389 device_param->kernel_loops_min = 1;
14390 device_param->kernel_loops_max = 1024;
14391
14392 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14393
14394 if (tuningdb_entry)
14395 {
14396 u32 _kernel_accel = tuningdb_entry->kernel_accel;
14397 u32 _kernel_loops = tuningdb_entry->kernel_loops;
14398
14399 if (_kernel_accel)
14400 {
14401 device_param->kernel_accel_min = _kernel_accel;
14402 device_param->kernel_accel_max = _kernel_accel;
14403 }
14404
14405 if (_kernel_loops)
14406 {
14407 if (workload_profile == 1)
14408 {
14409 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14410 }
14411 else if (workload_profile == 2)
14412 {
14413 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14414 }
14415
14416 device_param->kernel_loops_min = _kernel_loops;
14417 device_param->kernel_loops_max = _kernel_loops;
14418 }
14419 }
14420
14421 // commandline parameters overwrite tuningdb entries
14422
14423 if (kernel_accel)
14424 {
14425 device_param->kernel_accel_min = kernel_accel;
14426 device_param->kernel_accel_max = kernel_accel;
14427 }
14428
14429 if (kernel_loops)
14430 {
14431 device_param->kernel_loops_min = kernel_loops;
14432 device_param->kernel_loops_max = kernel_loops;
14433 }
14434
14435 /**
14436 * activate device
14437 */
14438
14439 devices_active++;
14440 }
14441
14442 // next please
14443
14444 devices_cnt++;
14445 }
14446
14447 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14448 {
14449 if (machine_readable == 0)
14450 {
14451 log_info ("");
14452 }
14453 }
14454 }
14455
14456 if (keyspace == 0 && devices_active == 0)
14457 {
14458 log_error ("ERROR: No devices found/left");
14459
14460 return (-1);
14461 }
14462
14463 // 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)
14464
14465 if (devices_filter != (uint) -1)
14466 {
14467 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14468
14469 if (devices_filter > devices_cnt_mask)
14470 {
14471 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14472
14473 return (-1);
14474 }
14475 }
14476
14477 data.devices_cnt = devices_cnt;
14478
14479 data.devices_active = devices_active;
14480
14481 /**
14482 * HM devices: init
14483 */
14484
14485 #ifdef HAVE_HWMON
14486 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14487 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14488 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14489 hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX] = { { 0 } };
14490
14491 if (gpu_temp_disable == 0)
14492 {
14493 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14494 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14495 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14496 XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));
14497
14498 data.hm_adl = NULL;
14499 data.hm_nvapi = NULL;
14500 data.hm_nvml = NULL;
14501 data.hm_xnvctrl = NULL;
14502
14503 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14504 {
14505 data.hm_nvml = nvml;
14506 }
14507
14508 if (data.hm_nvml)
14509 {
14510 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14511 {
14512 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14513
14514 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14515
14516 int tmp_out = 0;
14517
14518 for (int i = 0; i < tmp_in; i++)
14519 {
14520 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14521 }
14522
14523 for (int i = 0; i < tmp_out; i++)
14524 {
14525 unsigned int speed;
14526
14527 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14528
14529 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14530
14531 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14532 }
14533 }
14534 }
14535
14536 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14537 {
14538 data.hm_nvapi = nvapi;
14539 }
14540
14541 if (data.hm_nvapi)
14542 {
14543 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14544 {
14545 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14546
14547 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14548
14549 int tmp_out = 0;
14550
14551 for (int i = 0; i < tmp_in; i++)
14552 {
14553 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14554 }
14555 }
14556 }
14557
14558 if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0))
14559 {
14560 data.hm_xnvctrl = xnvctrl;
14561 }
14562
14563 if (data.hm_xnvctrl)
14564 {
14565 if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
14566 {
14567 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14568 {
14569 hc_device_param_t *device_param = &data.devices_param[device_id];
14570
14571 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14572
14573 hm_adapters_xnvctrl[device_id].xnvctrl = device_id;
14574
14575 int speed = 0;
14576
14577 if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
14578 }
14579 }
14580 }
14581
14582 if ((need_adl == 1) && (adl_init (adl) == 0))
14583 {
14584 data.hm_adl = adl;
14585 }
14586
14587 if (data.hm_adl)
14588 {
14589 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14590 {
14591 // total number of adapters
14592
14593 int hm_adapters_num;
14594
14595 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14596
14597 // adapter info
14598
14599 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14600
14601 if (lpAdapterInfo == NULL) return (-1);
14602
14603 // get a list (of ids of) valid/usable adapters
14604
14605 int num_adl_adapters = 0;
14606
14607 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14608
14609 if (num_adl_adapters > 0)
14610 {
14611 hc_thread_mutex_lock (mux_adl);
14612
14613 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14614
14615 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14616
14617 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14618 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14619
14620 hc_thread_mutex_unlock (mux_adl);
14621 }
14622
14623 myfree (valid_adl_device_list);
14624 myfree (lpAdapterInfo);
14625 }
14626 }
14627
14628 if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14629 {
14630 gpu_temp_disable = 1;
14631 }
14632 }
14633
14634 /**
14635 * OpenCL devices: allocate buffer for device specific information
14636 */
14637
14638 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14639 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14640
14641 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14642
14643 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14644
14645 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14646
14647 /**
14648 * User-defined GPU temp handling
14649 */
14650
14651 if (gpu_temp_disable == 1)
14652 {
14653 gpu_temp_abort = 0;
14654 gpu_temp_retain = 0;
14655 }
14656
14657 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14658 {
14659 if (gpu_temp_abort < gpu_temp_retain)
14660 {
14661 log_error ("ERROR: Invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14662
14663 return (-1);
14664 }
14665 }
14666
14667 data.gpu_temp_disable = gpu_temp_disable;
14668 data.gpu_temp_abort = gpu_temp_abort;
14669 data.gpu_temp_retain = gpu_temp_retain;
14670 #endif
14671
14672 /**
14673 * enable custom signal handler(s)
14674 */
14675
14676 if (benchmark == 0)
14677 {
14678 hc_signal (sigHandler_default);
14679 }
14680 else
14681 {
14682 hc_signal (sigHandler_benchmark);
14683 }
14684
14685 /**
14686 * inform the user
14687 */
14688
14689 if (data.quiet == 0)
14690 {
14691 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14692
14693 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);
14694
14695 if (attack_mode == ATTACK_MODE_STRAIGHT)
14696 {
14697 log_info ("Rules: %u", kernel_rules_cnt);
14698 }
14699
14700 if (opti_type)
14701 {
14702 log_info ("Applicable Optimizers:");
14703
14704 for (uint i = 0; i < 32; i++)
14705 {
14706 const uint opti_bit = 1u << i;
14707
14708 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14709 }
14710 }
14711
14712 /**
14713 * Watchdog and Temperature balance
14714 */
14715
14716 #ifdef HAVE_HWMON
14717 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14718 {
14719 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14720 }
14721
14722 if (gpu_temp_abort == 0)
14723 {
14724 log_info ("Watchdog: Temperature abort trigger disabled");
14725 }
14726 else
14727 {
14728 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14729 }
14730
14731 if (gpu_temp_retain == 0)
14732 {
14733 log_info ("Watchdog: Temperature retain trigger disabled");
14734 }
14735 else
14736 {
14737 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14738 }
14739
14740 if (data.quiet == 0) log_info ("");
14741 #endif
14742 }
14743
14744 #ifdef HAVE_HWMON
14745
14746 /**
14747 * HM devices: copy
14748 */
14749
14750 if (gpu_temp_disable == 0)
14751 {
14752 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14753 {
14754 hc_device_param_t *device_param = &data.devices_param[device_id];
14755
14756 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14757
14758 if (device_param->skipped) continue;
14759
14760 const uint platform_devices_id = device_param->platform_devices_id;
14761
14762 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14763 {
14764 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14765 data.hm_device[device_id].nvapi = 0;
14766 data.hm_device[device_id].nvml = 0;
14767 data.hm_device[device_id].xnvctrl = 0;
14768 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14769 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14770 data.hm_device[device_id].fan_set_supported = 0;
14771 }
14772
14773 if (device_param->device_vendor_id == VENDOR_ID_NV)
14774 {
14775 data.hm_device[device_id].adl = 0;
14776 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14777 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14778 data.hm_device[device_id].xnvctrl = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
14779 data.hm_device[device_id].od_version = 0;
14780 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14781 data.hm_device[device_id].fan_set_supported = 0;
14782 }
14783 }
14784 }
14785
14786 /**
14787 * powertune on user request
14788 */
14789
14790 if (powertune_enable == 1)
14791 {
14792 hc_thread_mutex_lock (mux_adl);
14793
14794 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14795 {
14796 hc_device_param_t *device_param = &data.devices_param[device_id];
14797
14798 if (device_param->skipped) continue;
14799
14800 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14801 {
14802 /**
14803 * Temporary fix:
14804 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14805 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14806 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14807 * Driver / ADL bug?
14808 */
14809
14810 if (data.hm_device[device_id].od_version == 6)
14811 {
14812 int ADL_rc;
14813
14814 // check powertune capabilities first, if not available then skip device
14815
14816 int powertune_supported = 0;
14817
14818 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14819 {
14820 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14821
14822 return (-1);
14823 }
14824
14825 // first backup current value, we will restore it later
14826
14827 if (powertune_supported != 0)
14828 {
14829 // powercontrol settings
14830
14831 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14832
14833 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14834 {
14835 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14836 }
14837
14838 if (ADL_rc != ADL_OK)
14839 {
14840 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14841
14842 return (-1);
14843 }
14844
14845 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14846 {
14847 log_error ("ERROR: Failed to set new ADL PowerControl values");
14848
14849 return (-1);
14850 }
14851
14852 // clocks
14853
14854 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14855
14856 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14857
14858 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)
14859 {
14860 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14861
14862 return (-1);
14863 }
14864
14865 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14866
14867 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14868
14869 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14870 {
14871 log_error ("ERROR: Failed to get ADL device capabilities");
14872
14873 return (-1);
14874 }
14875
14876 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14877 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14878
14879 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14880 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14881
14882 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14883 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14884
14885 // warning if profile has too low max values
14886
14887 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14888 {
14889 log_info ("WARN: The custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14890 }
14891
14892 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14893 {
14894 log_info ("WARN: The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14895 }
14896
14897 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14898
14899 performance_state->iNumberOfPerformanceLevels = 2;
14900
14901 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14902 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14903 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14904 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14905
14906 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)
14907 {
14908 log_info ("ERROR: Failed to set ADL performance state");
14909
14910 return (-1);
14911 }
14912
14913 local_free (performance_state);
14914 }
14915
14916 // set powertune value only
14917
14918 if (powertune_supported != 0)
14919 {
14920 // powertune set
14921 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14922
14923 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14924 {
14925 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14926
14927 return (-1);
14928 }
14929
14930 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14931 {
14932 log_error ("ERROR: Failed to set new ADL PowerControl values");
14933
14934 return (-1);
14935 }
14936 }
14937 }
14938 }
14939
14940 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14941 {
14942 // first backup current value, we will restore it later
14943
14944 unsigned int limit;
14945
14946 int powertune_supported = 0;
14947
14948 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14949 {
14950 powertune_supported = 1;
14951 }
14952
14953 // if backup worked, activate the maximum allowed
14954
14955 if (powertune_supported != 0)
14956 {
14957 unsigned int minLimit;
14958 unsigned int maxLimit;
14959
14960 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14961 {
14962 if (maxLimit > 0)
14963 {
14964 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14965 {
14966 // now we can be sure we need to reset later
14967
14968 nvml_power_limit[device_id] = limit;
14969 }
14970 }
14971 }
14972 }
14973 }
14974 }
14975
14976 hc_thread_mutex_unlock (mux_adl);
14977 }
14978
14979 #endif // HAVE_HWMON
14980
14981 #ifdef DEBUG
14982 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14983 #endif
14984
14985 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14986
14987 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14988 {
14989 /**
14990 * host buffer
14991 */
14992
14993 hc_device_param_t *device_param = &data.devices_param[device_id];
14994
14995 if (device_param->skipped) continue;
14996
14997 /**
14998 * device properties
14999 */
15000
15001 const char *device_name_chksum = device_param->device_name_chksum;
15002 const u32 device_processors = device_param->device_processors;
15003 const u32 device_processor_cores = device_param->device_processor_cores;
15004
15005 /**
15006 * create context for each device
15007 */
15008
15009 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
15010
15011 /**
15012 * create command-queue
15013 */
15014
15015 // not supported with NV
15016 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
15017
15018 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
15019
15020 /**
15021 * kernel threads: some algorithms need a fixed kernel-threads count
15022 * because of shared memory usage or bitslice
15023 * there needs to be some upper limit, otherwise there's too much overhead
15024 */
15025
15026 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
15027
15028 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
15029 {
15030 kernel_threads = KERNEL_THREADS_MAX_CPU;
15031 }
15032
15033 if (hash_mode == 1500) kernel_threads = 64; // DES
15034 if (hash_mode == 3000) kernel_threads = 64; // DES
15035 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
15036 if (hash_mode == 7500) kernel_threads = 64; // RC4
15037 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
15038 if (hash_mode == 9700) kernel_threads = 64; // RC4
15039 if (hash_mode == 9710) kernel_threads = 64; // RC4
15040 if (hash_mode == 9800) kernel_threads = 64; // RC4
15041 if (hash_mode == 9810) kernel_threads = 64; // RC4
15042 if (hash_mode == 10400) kernel_threads = 64; // RC4
15043 if (hash_mode == 10410) kernel_threads = 64; // RC4
15044 if (hash_mode == 10500) kernel_threads = 64; // RC4
15045 if (hash_mode == 13100) kernel_threads = 64; // RC4
15046
15047 device_param->kernel_threads = kernel_threads;
15048
15049 device_param->hardware_power = device_processors * kernel_threads;
15050
15051 /**
15052 * create input buffers on device : calculate size of fixed memory buffers
15053 */
15054
15055 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
15056 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
15057
15058 device_param->size_root_css = size_root_css;
15059 device_param->size_markov_css = size_markov_css;
15060
15061 size_t size_results = sizeof (uint);
15062
15063 device_param->size_results = size_results;
15064
15065 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
15066 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
15067
15068 size_t size_plains = digests_cnt * sizeof (plain_t);
15069 size_t size_salts = salts_cnt * sizeof (salt_t);
15070 size_t size_esalts = salts_cnt * esalt_size;
15071
15072 device_param->size_plains = size_plains;
15073 device_param->size_digests = size_digests;
15074 device_param->size_shown = size_shown;
15075 device_param->size_salts = size_salts;
15076
15077 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
15078 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
15079 size_t size_tm = 32 * sizeof (bs_word_t);
15080
15081 // scryptV stuff
15082
15083 size_t size_scryptV = 1;
15084
15085 if ((hash_mode == 8900) || (hash_mode == 9300))
15086 {
15087 uint tmto_start = 0;
15088 uint tmto_stop = 10;
15089
15090 if (scrypt_tmto)
15091 {
15092 tmto_start = scrypt_tmto;
15093 }
15094 else
15095 {
15096 // in case the user did not specify the tmto manually
15097 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
15098 // but set the lower end only in case the user has a device with too less memory
15099
15100 if (hash_mode == 8900)
15101 {
15102 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15103 {
15104 tmto_start = 1;
15105 }
15106 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15107 {
15108 tmto_start = 2;
15109 }
15110 }
15111 else if (hash_mode == 9300)
15112 {
15113 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15114 {
15115 tmto_start = 2;
15116 }
15117 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15118 {
15119 tmto_start = 2;
15120 }
15121 }
15122 }
15123
15124 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
15125 {
15126 // TODO: in theory the following calculation needs to be done per salt, not global
15127 // we assume all hashes have the same scrypt settings
15128
15129 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
15130
15131 size_scryptV /= 1 << tmto;
15132
15133 size_scryptV *= device_processors * device_processor_cores;
15134
15135 if (size_scryptV > device_param->device_maxmem_alloc)
15136 {
15137 if (quiet == 0) log_info ("WARNING: Not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15138
15139 continue;
15140 }
15141
15142 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
15143 {
15144 data.salts_buf[salts_pos].scrypt_tmto = tmto;
15145 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
15146 }
15147
15148 break;
15149 }
15150
15151 if (data.salts_buf[0].scrypt_phy == 0)
15152 {
15153 log_error ("ERROR: Can't allocate enough device memory");
15154
15155 return -1;
15156 }
15157
15158 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
15159 }
15160
15161 /**
15162 * some algorithms need a fixed kernel-loops count
15163 */
15164
15165 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15166 {
15167 const u32 kernel_loops_fixed = 1024;
15168
15169 device_param->kernel_loops_min = kernel_loops_fixed;
15170 device_param->kernel_loops_max = kernel_loops_fixed;
15171 }
15172
15173 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15174 {
15175 const u32 kernel_loops_fixed = 1024;
15176
15177 device_param->kernel_loops_min = kernel_loops_fixed;
15178 device_param->kernel_loops_max = kernel_loops_fixed;
15179 }
15180
15181 if (hash_mode == 8900)
15182 {
15183 const u32 kernel_loops_fixed = 1;
15184
15185 device_param->kernel_loops_min = kernel_loops_fixed;
15186 device_param->kernel_loops_max = kernel_loops_fixed;
15187 }
15188
15189 if (hash_mode == 9300)
15190 {
15191 const u32 kernel_loops_fixed = 1;
15192
15193 device_param->kernel_loops_min = kernel_loops_fixed;
15194 device_param->kernel_loops_max = kernel_loops_fixed;
15195 }
15196
15197 if (hash_mode == 12500)
15198 {
15199 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15200
15201 device_param->kernel_loops_min = kernel_loops_fixed;
15202 device_param->kernel_loops_max = kernel_loops_fixed;
15203 }
15204
15205 /**
15206 * some algorithms have a maximum kernel-loops count
15207 */
15208
15209 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15210 {
15211 u32 innerloop_cnt = 0;
15212
15213 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15214 {
15215 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15216 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15217 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15218 }
15219 else
15220 {
15221 innerloop_cnt = data.salts_buf[0].salt_iter;
15222 }
15223
15224 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15225 (innerloop_cnt <= device_param->kernel_loops_max))
15226 {
15227 device_param->kernel_loops_max = innerloop_cnt;
15228 }
15229 }
15230
15231 u32 kernel_accel_min = device_param->kernel_accel_min;
15232 u32 kernel_accel_max = device_param->kernel_accel_max;
15233
15234 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15235
15236 size_t size_pws = 4;
15237 size_t size_tmps = 4;
15238 size_t size_hooks = 4;
15239
15240 while (kernel_accel_max >= kernel_accel_min)
15241 {
15242 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15243
15244 // size_pws
15245
15246 size_pws = kernel_power_max * sizeof (pw_t);
15247
15248 // size_tmps
15249
15250 switch (hash_mode)
15251 {
15252 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15253 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15254 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15255 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15256 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15257 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15258 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15259 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15260 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15261 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15262 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15263 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15264 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15265 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15266 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15267 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15268 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15269 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15270 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15271 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15272 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15273 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15274 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15275 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
15276 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
15277 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
15278 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
15279 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
15280 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15281 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15282 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
15283 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
15284 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15285 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
15286 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15287 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
15288 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
15289 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15290 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15291 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
15292 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
15293 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
15294 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15295 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
15296 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
15297 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
15298 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
15299 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15300 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
15301 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
15302 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
15303 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15304 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15305 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
15306 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
15307 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
15308 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
15309 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
15310 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15311 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15312 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15313 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
15314 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
15315 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15316 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15317 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15318 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15319 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15320 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15321 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15322 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15323 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15324 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15325 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15326 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15327 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15328 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15329 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15330 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15331 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15332 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15333 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15334 };
15335
15336 // size_hooks
15337
15338 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15339 {
15340 switch (hash_mode)
15341 {
15342 }
15343 }
15344
15345 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15346 // if not, decrease amplifier and try again
15347
15348 int memory_limit_hit = 0;
15349
15350 if (size_pws > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15351 if (size_tmps > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15352 if (size_hooks > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15353
15354 const u64 size_total
15355 = bitmap_size
15356 + bitmap_size
15357 + bitmap_size
15358 + bitmap_size
15359 + bitmap_size
15360 + bitmap_size
15361 + bitmap_size
15362 + bitmap_size
15363 + size_bfs
15364 + size_combs
15365 + size_digests
15366 + size_esalts
15367 + size_hooks
15368 + size_markov_css
15369 + size_plains
15370 + size_pws
15371 + size_pws // not a bug
15372 + size_results
15373 + size_root_css
15374 + size_rules
15375 + size_rules_c
15376 + size_salts
15377 + size_scryptV
15378 + size_shown
15379 + size_tm
15380 + size_tmps;
15381
15382 if (size_total > device_param->device_global_mem) memory_limit_hit = 1;
15383
15384 if (memory_limit_hit == 1)
15385 {
15386 kernel_accel_max--;
15387
15388 continue;
15389 }
15390
15391 break;
15392 }
15393
15394 if (kernel_accel_max < kernel_accel_min)
15395 {
15396 log_error ("- Device #%u: Device does not provide enough allocatable device-memory to handle this attack", device_id + 1);
15397
15398 return -1;
15399 }
15400
15401 device_param->kernel_accel_min = kernel_accel_min;
15402 device_param->kernel_accel_max = kernel_accel_max;
15403
15404 /*
15405 if (kernel_accel_max < kernel_accel)
15406 {
15407 if (quiet == 0) log_info ("- Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
15408
15409 device_param->kernel_accel = kernel_accel_max;
15410 }
15411 */
15412
15413 device_param->size_bfs = size_bfs;
15414 device_param->size_combs = size_combs;
15415 device_param->size_rules = size_rules;
15416 device_param->size_rules_c = size_rules_c;
15417 device_param->size_pws = size_pws;
15418 device_param->size_tmps = size_tmps;
15419 device_param->size_hooks = size_hooks;
15420
15421 /**
15422 * default building options
15423 */
15424
15425 char cpath[1024] = { 0 };
15426
15427 char build_opts[1024] = { 0 };
15428
15429 #if _WIN
15430
15431 snprintf (cpath, sizeof (cpath) - 1, "%s\\OpenCL\\", shared_dir);
15432
15433 char *cpath_real = mymalloc (MAX_PATH);
15434
15435 if (GetFullPathName (cpath, MAX_PATH, cpath_real, NULL) == 0)
15436 {
15437 log_error ("ERROR: %s: %s", cpath, "GetFullPathName()");
15438
15439 return -1;
15440 }
15441
15442 naive_replace (cpath_real, '\\', '/');
15443
15444 // not escaping here, windows has quotes
15445
15446 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\"", cpath_real);
15447
15448 myfree (cpath_real);
15449
15450 #else
15451
15452 snprintf (cpath, sizeof (cpath) - 1, "%s/OpenCL/", shared_dir);
15453
15454 char *cpath_real = mymalloc (PATH_MAX);
15455
15456 if (realpath (cpath, cpath_real) == NULL)
15457 {
15458 log_error ("ERROR: %s: %s", cpath, strerror (errno));
15459
15460 return -1;
15461 }
15462
15463 naive_escape (cpath_real, PATH_MAX, ' ', '\\');
15464
15465 snprintf (build_opts, sizeof (build_opts) - 1, "-I %s", cpath_real);
15466
15467 myfree (cpath_real);
15468
15469 #endif
15470
15471 // we don't have sm_* on vendors not NV but it doesn't matter
15472
15473 char build_opts_new[1024] = { 0 };
15474
15475 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 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, kern_type);
15476
15477 strncpy (build_opts, build_opts_new, sizeof (build_opts));
15478
15479 #ifdef DEBUG
15480 log_info ("- Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15481 #endif
15482
15483 /**
15484 * main kernel
15485 */
15486
15487 {
15488 /**
15489 * kernel source filename
15490 */
15491
15492 char source_file[256] = { 0 };
15493
15494 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15495
15496 struct stat sst;
15497
15498 if (stat (source_file, &sst) == -1)
15499 {
15500 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15501
15502 return -1;
15503 }
15504
15505 /**
15506 * kernel cached filename
15507 */
15508
15509 char cached_file[256] = { 0 };
15510
15511 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15512
15513 int cached = 1;
15514
15515 struct stat cst;
15516
15517 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15518 {
15519 cached = 0;
15520 }
15521
15522 /**
15523 * kernel compile or load
15524 */
15525
15526 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15527
15528 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15529
15530 if (force_jit_compilation == -1)
15531 {
15532 if (cached == 0)
15533 {
15534 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));
15535
15536 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15537
15538 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15539
15540 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15541
15542 #ifdef DEBUG
15543 size_t build_log_size = 0;
15544
15545 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15546
15547 if (build_log_size > 1)
15548 {
15549 char *build_log = (char *) malloc (build_log_size + 1);
15550
15551 memset (build_log, 0, build_log_size + 1);
15552
15553 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15554
15555 puts (build_log);
15556
15557 free (build_log);
15558 }
15559 #endif
15560
15561 if (rc != 0)
15562 {
15563 device_param->skipped = true;
15564
15565 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15566
15567 continue;
15568 }
15569
15570 size_t binary_size;
15571
15572 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15573
15574 u8 *binary = (u8 *) mymalloc (binary_size);
15575
15576 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15577
15578 writeProgramBin (cached_file, binary, binary_size);
15579
15580 local_free (binary);
15581 }
15582 else
15583 {
15584 #ifdef DEBUG
15585 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15586 #endif
15587
15588 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15589
15590 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15591
15592 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15593 }
15594 }
15595 else
15596 {
15597 #ifdef DEBUG
15598 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15599 #endif
15600
15601 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15602
15603 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15604
15605 char build_opts_update[1024] = { 0 };
15606
15607 if (force_jit_compilation == 1500)
15608 {
15609 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15610 }
15611 else if (force_jit_compilation == 8900)
15612 {
15613 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DSCRYPT_N=%d -DSCRYPT_R=%d -DSCRYPT_P=%d -DSCRYPT_TMTO=%d", build_opts, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, 1 << data.salts_buf[0].scrypt_tmto);
15614 }
15615 else
15616 {
15617 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15618 }
15619
15620 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15621
15622 #ifdef DEBUG
15623 size_t build_log_size = 0;
15624
15625 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15626
15627 if (build_log_size > 1)
15628 {
15629 char *build_log = (char *) malloc (build_log_size + 1);
15630
15631 memset (build_log, 0, build_log_size + 1);
15632
15633 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15634
15635 puts (build_log);
15636
15637 free (build_log);
15638 }
15639 #endif
15640
15641 if (rc != 0)
15642 {
15643 device_param->skipped = true;
15644
15645 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15646 }
15647 }
15648
15649 local_free (kernel_lengths);
15650 local_free (kernel_sources[0]);
15651 local_free (kernel_sources);
15652 }
15653
15654 /**
15655 * word generator kernel
15656 */
15657
15658 if (attack_mode != ATTACK_MODE_STRAIGHT)
15659 {
15660 /**
15661 * kernel mp source filename
15662 */
15663
15664 char source_file[256] = { 0 };
15665
15666 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15667
15668 struct stat sst;
15669
15670 if (stat (source_file, &sst) == -1)
15671 {
15672 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15673
15674 return -1;
15675 }
15676
15677 /**
15678 * kernel mp cached filename
15679 */
15680
15681 char cached_file[256] = { 0 };
15682
15683 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15684
15685 int cached = 1;
15686
15687 struct stat cst;
15688
15689 if (stat (cached_file, &cst) == -1)
15690 {
15691 cached = 0;
15692 }
15693
15694 /**
15695 * kernel compile or load
15696 */
15697
15698 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15699
15700 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15701
15702 if (cached == 0)
15703 {
15704 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));
15705 if (quiet == 0) log_info ("");
15706
15707 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15708
15709 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15710
15711 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15712
15713 if (rc != 0)
15714 {
15715 device_param->skipped = true;
15716
15717 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15718
15719 continue;
15720 }
15721
15722 size_t binary_size;
15723
15724 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15725
15726 u8 *binary = (u8 *) mymalloc (binary_size);
15727
15728 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15729
15730 writeProgramBin (cached_file, binary, binary_size);
15731
15732 local_free (binary);
15733 }
15734 else
15735 {
15736 #ifdef DEBUG
15737 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15738 #endif
15739
15740 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15741
15742 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15743
15744 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15745 }
15746
15747 local_free (kernel_lengths);
15748 local_free (kernel_sources[0]);
15749 local_free (kernel_sources);
15750 }
15751
15752 /**
15753 * amplifier kernel
15754 */
15755
15756 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15757 {
15758
15759 }
15760 else
15761 {
15762 /**
15763 * kernel amp source filename
15764 */
15765
15766 char source_file[256] = { 0 };
15767
15768 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15769
15770 struct stat sst;
15771
15772 if (stat (source_file, &sst) == -1)
15773 {
15774 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15775
15776 return -1;
15777 }
15778
15779 /**
15780 * kernel amp cached filename
15781 */
15782
15783 char cached_file[256] = { 0 };
15784
15785 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15786
15787 int cached = 1;
15788
15789 struct stat cst;
15790
15791 if (stat (cached_file, &cst) == -1)
15792 {
15793 cached = 0;
15794 }
15795
15796 /**
15797 * kernel compile or load
15798 */
15799
15800 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15801
15802 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15803
15804 if (cached == 0)
15805 {
15806 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));
15807 if (quiet == 0) log_info ("");
15808
15809 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15810
15811 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15812
15813 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15814
15815 if (rc != 0)
15816 {
15817 device_param->skipped = true;
15818
15819 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15820
15821 continue;
15822 }
15823
15824 size_t binary_size;
15825
15826 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15827
15828 u8 *binary = (u8 *) mymalloc (binary_size);
15829
15830 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15831
15832 writeProgramBin (cached_file, binary, binary_size);
15833
15834 local_free (binary);
15835 }
15836 else
15837 {
15838 #ifdef DEBUG
15839 if (quiet == 0) log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15840 #endif
15841
15842 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15843
15844 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15845
15846 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15847 }
15848
15849 local_free (kernel_lengths);
15850 local_free (kernel_sources[0]);
15851 local_free (kernel_sources);
15852 }
15853
15854 // some algorithm collide too fast, make that impossible
15855
15856 if (benchmark == 1)
15857 {
15858 ((uint *) digests_buf)[0] = -1;
15859 ((uint *) digests_buf)[1] = -1;
15860 ((uint *) digests_buf)[2] = -1;
15861 ((uint *) digests_buf)[3] = -1;
15862 }
15863
15864 /**
15865 * global buffers
15866 */
15867
15868 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15869 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15870 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15871 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15872 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15873 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15874 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15875 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15876 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15877 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15878 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15879 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15880 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15881 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15882 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15883 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15884 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15885 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15886
15887 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);
15888 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);
15889 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);
15890 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);
15891 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);
15892 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);
15893 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);
15894 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);
15895 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15896 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15897 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15898
15899 /**
15900 * special buffers
15901 */
15902
15903 if (attack_kern == ATTACK_KERN_STRAIGHT)
15904 {
15905 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15906 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15907
15908 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15909 }
15910 else if (attack_kern == ATTACK_KERN_COMBI)
15911 {
15912 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15913 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15914 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15915 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15916 }
15917 else if (attack_kern == ATTACK_KERN_BF)
15918 {
15919 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15920 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15921 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15922 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15923 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15924 }
15925
15926 if (size_esalts)
15927 {
15928 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15929
15930 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15931 }
15932
15933 /**
15934 * main host data
15935 */
15936
15937 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15938
15939 device_param->pws_buf = pws_buf;
15940
15941 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15942
15943 device_param->combs_buf = combs_buf;
15944
15945 void *hooks_buf = mymalloc (size_hooks);
15946
15947 device_param->hooks_buf = hooks_buf;
15948
15949 /**
15950 * kernel args
15951 */
15952
15953 device_param->kernel_params_buf32[21] = bitmap_mask;
15954 device_param->kernel_params_buf32[22] = bitmap_shift1;
15955 device_param->kernel_params_buf32[23] = bitmap_shift2;
15956 device_param->kernel_params_buf32[24] = 0; // salt_pos
15957 device_param->kernel_params_buf32[25] = 0; // loop_pos
15958 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15959 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15960 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15961 device_param->kernel_params_buf32[29] = 0; // digests_offset
15962 device_param->kernel_params_buf32[30] = 0; // combs_mode
15963 device_param->kernel_params_buf32[31] = 0; // gid_max
15964
15965 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15966 ? &device_param->d_pws_buf
15967 : &device_param->d_pws_amp_buf;
15968 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15969 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15970 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15971 device_param->kernel_params[ 4] = &device_param->d_tmps;
15972 device_param->kernel_params[ 5] = &device_param->d_hooks;
15973 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15974 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15975 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15976 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15977 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15978 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15979 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15980 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15981 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15982 device_param->kernel_params[15] = &device_param->d_digests_buf;
15983 device_param->kernel_params[16] = &device_param->d_digests_shown;
15984 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15985 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15986 device_param->kernel_params[19] = &device_param->d_result;
15987 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15988 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15989 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15990 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15991 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15992 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15993 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15994 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15995 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15996 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15997 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15998 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15999
16000 device_param->kernel_params_mp_buf64[3] = 0;
16001 device_param->kernel_params_mp_buf32[4] = 0;
16002 device_param->kernel_params_mp_buf32[5] = 0;
16003 device_param->kernel_params_mp_buf32[6] = 0;
16004 device_param->kernel_params_mp_buf32[7] = 0;
16005 device_param->kernel_params_mp_buf32[8] = 0;
16006
16007 device_param->kernel_params_mp[0] = NULL;
16008 device_param->kernel_params_mp[1] = NULL;
16009 device_param->kernel_params_mp[2] = NULL;
16010 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
16011 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
16012 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
16013 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
16014 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
16015 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
16016
16017 device_param->kernel_params_mp_l_buf64[3] = 0;
16018 device_param->kernel_params_mp_l_buf32[4] = 0;
16019 device_param->kernel_params_mp_l_buf32[5] = 0;
16020 device_param->kernel_params_mp_l_buf32[6] = 0;
16021 device_param->kernel_params_mp_l_buf32[7] = 0;
16022 device_param->kernel_params_mp_l_buf32[8] = 0;
16023 device_param->kernel_params_mp_l_buf32[9] = 0;
16024
16025 device_param->kernel_params_mp_l[0] = NULL;
16026 device_param->kernel_params_mp_l[1] = NULL;
16027 device_param->kernel_params_mp_l[2] = NULL;
16028 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
16029 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
16030 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
16031 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
16032 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
16033 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
16034 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
16035
16036 device_param->kernel_params_mp_r_buf64[3] = 0;
16037 device_param->kernel_params_mp_r_buf32[4] = 0;
16038 device_param->kernel_params_mp_r_buf32[5] = 0;
16039 device_param->kernel_params_mp_r_buf32[6] = 0;
16040 device_param->kernel_params_mp_r_buf32[7] = 0;
16041 device_param->kernel_params_mp_r_buf32[8] = 0;
16042
16043 device_param->kernel_params_mp_r[0] = NULL;
16044 device_param->kernel_params_mp_r[1] = NULL;
16045 device_param->kernel_params_mp_r[2] = NULL;
16046 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
16047 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
16048 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
16049 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
16050 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
16051 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
16052
16053 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
16054 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
16055
16056 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
16057 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
16058 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
16059 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
16060 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
16061 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
16062 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
16063
16064 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
16065 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
16066
16067 device_param->kernel_params_memset_buf32[1] = 0; // value
16068 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
16069
16070 device_param->kernel_params_memset[0] = NULL;
16071 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
16072 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
16073
16074 /**
16075 * kernel name
16076 */
16077
16078 size_t kernel_wgs_tmp;
16079
16080 char kernel_name[64] = { 0 };
16081
16082 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16083 {
16084 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16085 {
16086 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
16087
16088 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16089
16090 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
16091
16092 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16093
16094 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
16095
16096 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16097 }
16098 else
16099 {
16100 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
16101
16102 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16103
16104 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
16105
16106 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16107
16108 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
16109
16110 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16111 }
16112
16113 if (data.attack_mode == ATTACK_MODE_BF)
16114 {
16115 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16116 {
16117 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
16118
16119 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16120
16121 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);
16122 }
16123 }
16124 }
16125 else
16126 {
16127 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
16128
16129 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16130
16131 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
16132
16133 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16134
16135 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
16136
16137 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16138
16139 if (opts_type & OPTS_TYPE_HOOK12)
16140 {
16141 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
16142
16143 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16144
16145 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);
16146 }
16147
16148 if (opts_type & OPTS_TYPE_HOOK23)
16149 {
16150 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
16151
16152 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16153
16154 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);
16155 }
16156 }
16157
16158 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);
16159 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);
16160 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);
16161
16162 for (uint i = 0; i <= 20; i++)
16163 {
16164 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
16165 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
16166 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
16167
16168 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
16169 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
16170 }
16171
16172 for (uint i = 21; i <= 31; i++)
16173 {
16174 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
16175 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
16176 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
16177
16178 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
16179 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
16180 }
16181
16182 // GPU memset
16183
16184 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
16185
16186 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);
16187
16188 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
16189 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
16190 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
16191
16192 // MP start
16193
16194 if (attack_mode == ATTACK_MODE_BF)
16195 {
16196 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
16197 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
16198
16199 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);
16200 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);
16201
16202 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16203 {
16204 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
16205 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
16206 }
16207 }
16208 else if (attack_mode == ATTACK_MODE_HYBRID1)
16209 {
16210 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16211
16212 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);
16213 }
16214 else if (attack_mode == ATTACK_MODE_HYBRID2)
16215 {
16216 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16217
16218 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);
16219 }
16220
16221 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16222 {
16223 // nothing to do
16224 }
16225 else
16226 {
16227 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
16228
16229 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);
16230 }
16231
16232 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16233 {
16234 // nothing to do
16235 }
16236 else
16237 {
16238 for (uint i = 0; i < 5; i++)
16239 {
16240 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
16241 }
16242
16243 for (uint i = 5; i < 7; i++)
16244 {
16245 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
16246 }
16247 }
16248
16249 // maybe this has been updated by clGetKernelWorkGroupInfo()
16250 // value can only be decreased, so we don't need to reallocate buffers
16251
16252 device_param->kernel_threads = kernel_threads;
16253
16254 // zero some data buffers
16255
16256 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
16257 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
16258 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
16259 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
16260 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
16261 run_kernel_bzero (device_param, device_param->d_result, size_results);
16262
16263 /**
16264 * special buffers
16265 */
16266
16267 if (attack_kern == ATTACK_KERN_STRAIGHT)
16268 {
16269 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
16270 }
16271 else if (attack_kern == ATTACK_KERN_COMBI)
16272 {
16273 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
16274 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
16275 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16276 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16277 }
16278 else if (attack_kern == ATTACK_KERN_BF)
16279 {
16280 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
16281 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
16282 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
16283 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16284 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16285 }
16286
16287 #if defined(HAVE_HWMON)
16288
16289 /**
16290 * Store initial fanspeed if gpu_temp_retain is enabled
16291 */
16292
16293 if (gpu_temp_disable == 0)
16294 {
16295 if (gpu_temp_retain != 0)
16296 {
16297 hc_thread_mutex_lock (mux_adl);
16298
16299 if (data.hm_device[device_id].fan_get_supported == 1)
16300 {
16301 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
16302 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
16303
16304 temp_retain_fanspeed_value[device_id] = fanspeed;
16305 temp_retain_fanpolicy_value[device_id] = fanpolicy;
16306
16307 // we also set it to tell the OS we take control over the fan and it's automatic controller
16308 // if it was set to automatic. we do not control user-defined fanspeeds.
16309
16310 if (fanpolicy == 1)
16311 {
16312 data.hm_device[device_id].fan_set_supported = 1;
16313
16314 int rc = -1;
16315
16316 if (device_param->device_vendor_id == VENDOR_ID_AMD)
16317 {
16318 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
16319 }
16320 else if (device_param->device_vendor_id == VENDOR_ID_NV)
16321 {
16322 #ifdef LINUX
16323 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE);
16324 #endif
16325
16326 #ifdef WIN
16327 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
16328 #endif
16329 }
16330
16331 if (rc == 0)
16332 {
16333 data.hm_device[device_id].fan_set_supported = 1;
16334 }
16335 else
16336 {
16337 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
16338
16339 data.hm_device[device_id].fan_set_supported = 0;
16340 }
16341 }
16342 else
16343 {
16344 data.hm_device[device_id].fan_set_supported = 0;
16345 }
16346 }
16347
16348 hc_thread_mutex_unlock (mux_adl);
16349 }
16350 }
16351
16352 #endif // HAVE_HWMON
16353 }
16354
16355 if (data.quiet == 0) log_info_nn ("");
16356
16357 /**
16358 * In benchmark-mode, inform user which algorithm is checked
16359 */
16360
16361 if (benchmark == 1)
16362 {
16363 if (machine_readable == 0)
16364 {
16365 quiet = 0;
16366
16367 data.quiet = quiet;
16368
16369 char *hash_type = strhashtype (data.hash_mode); // not a bug
16370
16371 log_info ("Hashtype: %s", hash_type);
16372 log_info ("");
16373 }
16374 }
16375
16376 /**
16377 * keep track of the progress
16378 */
16379
16380 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16381 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16382 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16383
16384 /**
16385 * open filehandles
16386 */
16387
16388 #if _WIN
16389 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
16390 {
16391 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
16392
16393 return (-1);
16394 }
16395
16396 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
16397 {
16398 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
16399
16400 return (-1);
16401 }
16402
16403 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
16404 {
16405 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
16406
16407 return (-1);
16408 }
16409 #endif
16410
16411 /**
16412 * dictionary pad
16413 */
16414
16415 segment_size *= (1024 * 1024);
16416
16417 data.segment_size = segment_size;
16418
16419 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
16420
16421 wl_data->buf = (char *) mymalloc (segment_size);
16422 wl_data->avail = segment_size;
16423 wl_data->incr = segment_size;
16424 wl_data->cnt = 0;
16425 wl_data->pos = 0;
16426
16427 cs_t *css_buf = NULL;
16428 uint css_cnt = 0;
16429 uint dictcnt = 0;
16430 uint maskcnt = 1;
16431 char **masks = NULL;
16432 char **dictfiles = NULL;
16433
16434 uint mask_from_file = 0;
16435
16436 if (attack_mode == ATTACK_MODE_STRAIGHT)
16437 {
16438 if (wordlist_mode == WL_MODE_FILE)
16439 {
16440 int wls_left = myargc - (optind + 1);
16441
16442 for (int i = 0; i < wls_left; i++)
16443 {
16444 char *l0_filename = myargv[optind + 1 + i];
16445
16446 struct stat l0_stat;
16447
16448 if (stat (l0_filename, &l0_stat) == -1)
16449 {
16450 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
16451
16452 return (-1);
16453 }
16454
16455 uint is_dir = S_ISDIR (l0_stat.st_mode);
16456
16457 if (is_dir == 0)
16458 {
16459 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16460
16461 dictcnt++;
16462
16463 dictfiles[dictcnt - 1] = l0_filename;
16464 }
16465 else
16466 {
16467 // do not allow --keyspace w/ a directory
16468
16469 if (keyspace == 1)
16470 {
16471 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16472
16473 return (-1);
16474 }
16475
16476 char **dictionary_files = NULL;
16477
16478 dictionary_files = scan_directory (l0_filename);
16479
16480 if (dictionary_files != NULL)
16481 {
16482 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16483
16484 for (int d = 0; dictionary_files[d] != NULL; d++)
16485 {
16486 char *l1_filename = dictionary_files[d];
16487
16488 struct stat l1_stat;
16489
16490 if (stat (l1_filename, &l1_stat) == -1)
16491 {
16492 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16493
16494 return (-1);
16495 }
16496
16497 if (S_ISREG (l1_stat.st_mode))
16498 {
16499 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16500
16501 dictcnt++;
16502
16503 dictfiles[dictcnt - 1] = strdup (l1_filename);
16504 }
16505 }
16506 }
16507
16508 local_free (dictionary_files);
16509 }
16510 }
16511
16512 if (dictcnt < 1)
16513 {
16514 log_error ("ERROR: No usable dictionary file found.");
16515
16516 return (-1);
16517 }
16518 }
16519 else if (wordlist_mode == WL_MODE_STDIN)
16520 {
16521 dictcnt = 1;
16522 }
16523 }
16524 else if (attack_mode == ATTACK_MODE_COMBI)
16525 {
16526 // display
16527
16528 char *dictfile1 = myargv[optind + 1 + 0];
16529 char *dictfile2 = myargv[optind + 1 + 1];
16530
16531 // find the bigger dictionary and use as base
16532
16533 FILE *fp1 = NULL;
16534 FILE *fp2 = NULL;
16535
16536 struct stat tmp_stat;
16537
16538 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16539 {
16540 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16541
16542 return (-1);
16543 }
16544
16545 if (stat (dictfile1, &tmp_stat) == -1)
16546 {
16547 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16548
16549 fclose (fp1);
16550
16551 return (-1);
16552 }
16553
16554 if (S_ISDIR (tmp_stat.st_mode))
16555 {
16556 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16557
16558 fclose (fp1);
16559
16560 return (-1);
16561 }
16562
16563 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16564 {
16565 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16566
16567 fclose (fp1);
16568
16569 return (-1);
16570 }
16571
16572 if (stat (dictfile2, &tmp_stat) == -1)
16573 {
16574 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16575
16576 fclose (fp1);
16577 fclose (fp2);
16578
16579 return (-1);
16580 }
16581
16582 if (S_ISDIR (tmp_stat.st_mode))
16583 {
16584 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16585
16586 fclose (fp1);
16587 fclose (fp2);
16588
16589 return (-1);
16590 }
16591
16592 data.combs_cnt = 1;
16593
16594 data.quiet = 1;
16595
16596 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16597
16598 data.quiet = quiet;
16599
16600 if (words1_cnt == 0)
16601 {
16602 log_error ("ERROR: %s: empty file", dictfile1);
16603
16604 fclose (fp1);
16605 fclose (fp2);
16606
16607 return (-1);
16608 }
16609
16610 data.combs_cnt = 1;
16611
16612 data.quiet = 1;
16613
16614 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16615
16616 data.quiet = quiet;
16617
16618 if (words2_cnt == 0)
16619 {
16620 log_error ("ERROR: %s: empty file", dictfile2);
16621
16622 fclose (fp1);
16623 fclose (fp2);
16624
16625 return (-1);
16626 }
16627
16628 fclose (fp1);
16629 fclose (fp2);
16630
16631 data.dictfile = dictfile1;
16632 data.dictfile2 = dictfile2;
16633
16634 if (words1_cnt >= words2_cnt)
16635 {
16636 data.combs_cnt = words2_cnt;
16637 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16638
16639 dictfiles = &data.dictfile;
16640
16641 dictcnt = 1;
16642 }
16643 else
16644 {
16645 data.combs_cnt = words1_cnt;
16646 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16647
16648 dictfiles = &data.dictfile2;
16649
16650 dictcnt = 1;
16651
16652 // we also have to switch wordlist related rules!
16653
16654 char *tmpc = data.rule_buf_l;
16655
16656 data.rule_buf_l = data.rule_buf_r;
16657 data.rule_buf_r = tmpc;
16658
16659 int tmpi = data.rule_len_l;
16660
16661 data.rule_len_l = data.rule_len_r;
16662 data.rule_len_r = tmpi;
16663 }
16664 }
16665 else if (attack_mode == ATTACK_MODE_BF)
16666 {
16667 char *mask = NULL;
16668
16669 maskcnt = 0;
16670
16671 if (benchmark == 0)
16672 {
16673 mask = myargv[optind + 1];
16674
16675 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16676
16677 if ((optind + 2) <= myargc)
16678 {
16679 struct stat file_stat;
16680
16681 if (stat (mask, &file_stat) == -1)
16682 {
16683 maskcnt = 1;
16684
16685 masks[maskcnt - 1] = mystrdup (mask);
16686 }
16687 else
16688 {
16689 int wls_left = myargc - (optind + 1);
16690
16691 uint masks_avail = INCR_MASKS;
16692
16693 for (int i = 0; i < wls_left; i++)
16694 {
16695 if (i != 0)
16696 {
16697 mask = myargv[optind + 1 + i];
16698
16699 if (stat (mask, &file_stat) == -1)
16700 {
16701 log_error ("ERROR: %s: %s", mask, strerror (errno));
16702
16703 return (-1);
16704 }
16705 }
16706
16707 uint is_file = S_ISREG (file_stat.st_mode);
16708
16709 if (is_file == 1)
16710 {
16711 FILE *mask_fp;
16712
16713 if ((mask_fp = fopen (mask, "r")) == NULL)
16714 {
16715 log_error ("ERROR: %s: %s", mask, strerror (errno));
16716
16717 return (-1);
16718 }
16719
16720 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16721
16722 while (!feof (mask_fp))
16723 {
16724 memset (line_buf, 0, HCBUFSIZ);
16725
16726 int line_len = fgetl (mask_fp, line_buf);
16727
16728 if (line_len == 0) continue;
16729
16730 if (line_buf[0] == '#') continue;
16731
16732 if (masks_avail == maskcnt)
16733 {
16734 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16735
16736 masks_avail += INCR_MASKS;
16737 }
16738
16739 masks[maskcnt] = mystrdup (line_buf);
16740
16741 maskcnt++;
16742 }
16743
16744 myfree (line_buf);
16745
16746 fclose (mask_fp);
16747 }
16748 else
16749 {
16750 log_error ("ERROR: %s: unsupported file-type", mask);
16751
16752 return (-1);
16753 }
16754 }
16755
16756 mask_from_file = 1;
16757 }
16758 }
16759 else
16760 {
16761 custom_charset_1 = (char *) "?l?d?u";
16762 custom_charset_2 = (char *) "?l?d";
16763 custom_charset_3 = (char *) "?l?d*!$@_";
16764
16765 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16766 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16767 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16768
16769 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16770
16771 wordlist_mode = WL_MODE_MASK;
16772
16773 data.wordlist_mode = wordlist_mode;
16774
16775 increment = 1;
16776
16777 maskcnt = 1;
16778 }
16779 }
16780 else
16781 {
16782 /**
16783 * generate full masks and charsets
16784 */
16785
16786 masks = (char **) mymalloc (sizeof (char *));
16787
16788 switch (hash_mode)
16789 {
16790 case 1731: pw_min = 5;
16791 pw_max = 5;
16792 mask = mystrdup ("?b?b?b?b?b");
16793 break;
16794 case 12500: pw_min = 5;
16795 pw_max = 5;
16796 mask = mystrdup ("?b?b?b?b?b");
16797 break;
16798 default: pw_min = 7;
16799 pw_max = 7;
16800 mask = mystrdup ("?b?b?b?b?b?b?b");
16801 break;
16802 }
16803
16804 maskcnt = 1;
16805
16806 masks[maskcnt - 1] = mystrdup (mask);
16807
16808 wordlist_mode = WL_MODE_MASK;
16809
16810 data.wordlist_mode = wordlist_mode;
16811
16812 increment = 1;
16813 }
16814
16815 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16816
16817 if (increment)
16818 {
16819 if (increment_min > pw_min) pw_min = increment_min;
16820
16821 if (increment_max < pw_max) pw_max = increment_max;
16822 }
16823 }
16824 else if (attack_mode == ATTACK_MODE_HYBRID1)
16825 {
16826 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16827
16828 // display
16829
16830 char *mask = myargv[myargc - 1];
16831
16832 maskcnt = 0;
16833
16834 masks = (char **) mymalloc (1 * sizeof (char *));
16835
16836 // mod
16837
16838 struct stat file_stat;
16839
16840 if (stat (mask, &file_stat) == -1)
16841 {
16842 maskcnt = 1;
16843
16844 masks[maskcnt - 1] = mystrdup (mask);
16845 }
16846 else
16847 {
16848 uint is_file = S_ISREG (file_stat.st_mode);
16849
16850 if (is_file == 1)
16851 {
16852 FILE *mask_fp;
16853
16854 if ((mask_fp = fopen (mask, "r")) == NULL)
16855 {
16856 log_error ("ERROR: %s: %s", mask, strerror (errno));
16857
16858 return (-1);
16859 }
16860
16861 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16862
16863 uint masks_avail = 1;
16864
16865 while (!feof (mask_fp))
16866 {
16867 memset (line_buf, 0, HCBUFSIZ);
16868
16869 int line_len = fgetl (mask_fp, line_buf);
16870
16871 if (line_len == 0) continue;
16872
16873 if (line_buf[0] == '#') continue;
16874
16875 if (masks_avail == maskcnt)
16876 {
16877 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16878
16879 masks_avail += INCR_MASKS;
16880 }
16881
16882 masks[maskcnt] = mystrdup (line_buf);
16883
16884 maskcnt++;
16885 }
16886
16887 myfree (line_buf);
16888
16889 fclose (mask_fp);
16890
16891 mask_from_file = 1;
16892 }
16893 else
16894 {
16895 maskcnt = 1;
16896
16897 masks[maskcnt - 1] = mystrdup (mask);
16898 }
16899 }
16900
16901 // base
16902
16903 int wls_left = myargc - (optind + 2);
16904
16905 for (int i = 0; i < wls_left; i++)
16906 {
16907 char *filename = myargv[optind + 1 + i];
16908
16909 struct stat file_stat;
16910
16911 if (stat (filename, &file_stat) == -1)
16912 {
16913 log_error ("ERROR: %s: %s", filename, strerror (errno));
16914
16915 return (-1);
16916 }
16917
16918 uint is_dir = S_ISDIR (file_stat.st_mode);
16919
16920 if (is_dir == 0)
16921 {
16922 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16923
16924 dictcnt++;
16925
16926 dictfiles[dictcnt - 1] = filename;
16927 }
16928 else
16929 {
16930 // do not allow --keyspace w/ a directory
16931
16932 if (keyspace == 1)
16933 {
16934 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16935
16936 return (-1);
16937 }
16938
16939 char **dictionary_files = NULL;
16940
16941 dictionary_files = scan_directory (filename);
16942
16943 if (dictionary_files != NULL)
16944 {
16945 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16946
16947 for (int d = 0; dictionary_files[d] != NULL; d++)
16948 {
16949 char *l1_filename = dictionary_files[d];
16950
16951 struct stat l1_stat;
16952
16953 if (stat (l1_filename, &l1_stat) == -1)
16954 {
16955 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16956
16957 return (-1);
16958 }
16959
16960 if (S_ISREG (l1_stat.st_mode))
16961 {
16962 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16963
16964 dictcnt++;
16965
16966 dictfiles[dictcnt - 1] = strdup (l1_filename);
16967 }
16968 }
16969 }
16970
16971 local_free (dictionary_files);
16972 }
16973 }
16974
16975 if (dictcnt < 1)
16976 {
16977 log_error ("ERROR: No usable dictionary file found.");
16978
16979 return (-1);
16980 }
16981
16982 if (increment)
16983 {
16984 maskcnt = 0;
16985
16986 uint mask_min = increment_min; // we can't reject smaller masks here
16987 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16988
16989 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16990 {
16991 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16992
16993 if (cur_mask == NULL) break;
16994
16995 masks[maskcnt] = cur_mask;
16996
16997 maskcnt++;
16998
16999 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17000 }
17001 }
17002 }
17003 else if (attack_mode == ATTACK_MODE_HYBRID2)
17004 {
17005 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
17006
17007 // display
17008
17009 char *mask = myargv[optind + 1 + 0];
17010
17011 maskcnt = 0;
17012
17013 masks = (char **) mymalloc (1 * sizeof (char *));
17014
17015 // mod
17016
17017 struct stat file_stat;
17018
17019 if (stat (mask, &file_stat) == -1)
17020 {
17021 maskcnt = 1;
17022
17023 masks[maskcnt - 1] = mystrdup (mask);
17024 }
17025 else
17026 {
17027 uint is_file = S_ISREG (file_stat.st_mode);
17028
17029 if (is_file == 1)
17030 {
17031 FILE *mask_fp;
17032
17033 if ((mask_fp = fopen (mask, "r")) == NULL)
17034 {
17035 log_error ("ERROR: %s: %s", mask, strerror (errno));
17036
17037 return (-1);
17038 }
17039
17040 char *line_buf = (char *) mymalloc (HCBUFSIZ);
17041
17042 uint masks_avail = 1;
17043
17044 while (!feof (mask_fp))
17045 {
17046 memset (line_buf, 0, HCBUFSIZ);
17047
17048 int line_len = fgetl (mask_fp, line_buf);
17049
17050 if (line_len == 0) continue;
17051
17052 if (line_buf[0] == '#') continue;
17053
17054 if (masks_avail == maskcnt)
17055 {
17056 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
17057
17058 masks_avail += INCR_MASKS;
17059 }
17060
17061 masks[maskcnt] = mystrdup (line_buf);
17062
17063 maskcnt++;
17064 }
17065
17066 myfree (line_buf);
17067
17068 fclose (mask_fp);
17069
17070 mask_from_file = 1;
17071 }
17072 else
17073 {
17074 maskcnt = 1;
17075
17076 masks[maskcnt - 1] = mystrdup (mask);
17077 }
17078 }
17079
17080 // base
17081
17082 int wls_left = myargc - (optind + 2);
17083
17084 for (int i = 0; i < wls_left; i++)
17085 {
17086 char *filename = myargv[optind + 2 + i];
17087
17088 struct stat file_stat;
17089
17090 if (stat (filename, &file_stat) == -1)
17091 {
17092 log_error ("ERROR: %s: %s", filename, strerror (errno));
17093
17094 return (-1);
17095 }
17096
17097 uint is_dir = S_ISDIR (file_stat.st_mode);
17098
17099 if (is_dir == 0)
17100 {
17101 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17102
17103 dictcnt++;
17104
17105 dictfiles[dictcnt - 1] = filename;
17106 }
17107 else
17108 {
17109 // do not allow --keyspace w/ a directory
17110
17111 if (keyspace == 1)
17112 {
17113 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17114
17115 return (-1);
17116 }
17117
17118 char **dictionary_files = NULL;
17119
17120 dictionary_files = scan_directory (filename);
17121
17122 if (dictionary_files != NULL)
17123 {
17124 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17125
17126 for (int d = 0; dictionary_files[d] != NULL; d++)
17127 {
17128 char *l1_filename = dictionary_files[d];
17129
17130 struct stat l1_stat;
17131
17132 if (stat (l1_filename, &l1_stat) == -1)
17133 {
17134 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17135
17136 return (-1);
17137 }
17138
17139 if (S_ISREG (l1_stat.st_mode))
17140 {
17141 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17142
17143 dictcnt++;
17144
17145 dictfiles[dictcnt - 1] = strdup (l1_filename);
17146 }
17147 }
17148 }
17149
17150 local_free (dictionary_files);
17151 }
17152 }
17153
17154 if (dictcnt < 1)
17155 {
17156 log_error ("ERROR: No usable dictionary file found.");
17157
17158 return (-1);
17159 }
17160
17161 if (increment)
17162 {
17163 maskcnt = 0;
17164
17165 uint mask_min = increment_min; // we can't reject smaller masks here
17166 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17167
17168 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17169 {
17170 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17171
17172 if (cur_mask == NULL) break;
17173
17174 masks[maskcnt] = cur_mask;
17175
17176 maskcnt++;
17177
17178 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17179 }
17180 }
17181 }
17182
17183 data.pw_min = pw_min;
17184 data.pw_max = pw_max;
17185
17186 /**
17187 * weak hash check
17188 */
17189
17190 if (weak_hash_threshold >= salts_cnt)
17191 {
17192 hc_device_param_t *device_param = NULL;
17193
17194 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17195 {
17196 device_param = &data.devices_param[device_id];
17197
17198 if (device_param->skipped) continue;
17199
17200 break;
17201 }
17202
17203 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
17204
17205 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
17206 {
17207 weak_hash_check (device_param, salt_pos);
17208 }
17209
17210 // Display hack, guarantee that there is at least one \r before real start
17211
17212 //if (data.quiet == 0) log_info ("");
17213 }
17214
17215 /**
17216 * status and monitor threads
17217 */
17218
17219 if (data.devices_status == STATUS_CRACKED) break;
17220 if (data.devices_status == STATUS_ABORTED) break;
17221 if (data.devices_status == STATUS_QUIT) break;
17222
17223 data.devices_status = STATUS_STARTING;
17224
17225 uint ni_threads_cnt = 0;
17226
17227 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17228
17229 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
17230 {
17231 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
17232
17233 ni_threads_cnt++;
17234 }
17235
17236 /**
17237 * Outfile remove
17238 */
17239
17240 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
17241 {
17242 if (outfile_check_timer != 0)
17243 {
17244 if (data.outfile_check_directory != NULL)
17245 {
17246 if ((hash_mode != 5200) &&
17247 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
17248 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
17249 (hash_mode != 9000))
17250 {
17251 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
17252
17253 ni_threads_cnt++;
17254 }
17255 else
17256 {
17257 outfile_check_timer = 0;
17258 }
17259 }
17260 else
17261 {
17262 outfile_check_timer = 0;
17263 }
17264 }
17265 }
17266
17267 /**
17268 * Inform the user if we got some hashes remove because of the pot file remove feature
17269 */
17270
17271 if (data.quiet == 0)
17272 {
17273 if (potfile_remove_cracks > 0)
17274 {
17275 if (potfile_remove_cracks == 1) log_info ("INFO: Removed 1 hash found in pot file\n");
17276 else log_info ("INFO: Removed %u hashes found in pot file\n", potfile_remove_cracks);
17277 }
17278 }
17279
17280 data.outfile_check_timer = outfile_check_timer;
17281
17282 /**
17283 * main loop
17284 */
17285
17286 char **induction_dictionaries = NULL;
17287
17288 int induction_dictionaries_cnt = 0;
17289
17290 hcstat_table_t *root_table_buf = NULL;
17291 hcstat_table_t *markov_table_buf = NULL;
17292
17293 uint initial_restore_done = 0;
17294
17295 data.maskcnt = maskcnt;
17296
17297 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
17298 {
17299 if (data.devices_status == STATUS_CRACKED) break;
17300 if (data.devices_status == STATUS_ABORTED) break;
17301 if (data.devices_status == STATUS_QUIT) break;
17302
17303 data.devices_status = STATUS_INIT;
17304
17305 if (maskpos > rd->maskpos)
17306 {
17307 rd->dictpos = 0;
17308 }
17309
17310 rd->maskpos = maskpos;
17311 data.maskpos = maskpos;
17312
17313 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
17314 {
17315 char *mask = masks[maskpos];
17316
17317 if (mask_from_file == 1)
17318 {
17319 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
17320
17321 char *str_ptr;
17322 uint str_pos;
17323
17324 uint mask_offset = 0;
17325
17326 uint separator_cnt;
17327
17328 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
17329 {
17330 str_ptr = strstr (mask + mask_offset, ",");
17331
17332 if (str_ptr == NULL) break;
17333
17334 str_pos = str_ptr - mask;
17335
17336 // escaped separator, i.e. "\,"
17337
17338 if (str_pos > 0)
17339 {
17340 if (mask[str_pos - 1] == '\\')
17341 {
17342 separator_cnt --;
17343
17344 mask_offset = str_pos + 1;
17345
17346 continue;
17347 }
17348 }
17349
17350 // reset the offset
17351
17352 mask_offset = 0;
17353
17354 mask[str_pos] = '\0';
17355
17356 switch (separator_cnt)
17357 {
17358 case 0:
17359 mp_reset_usr (mp_usr, 0);
17360
17361 custom_charset_1 = mask;
17362 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17363 break;
17364
17365 case 1:
17366 mp_reset_usr (mp_usr, 1);
17367
17368 custom_charset_2 = mask;
17369 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17370 break;
17371
17372 case 2:
17373 mp_reset_usr (mp_usr, 2);
17374
17375 custom_charset_3 = mask;
17376 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17377 break;
17378
17379 case 3:
17380 mp_reset_usr (mp_usr, 3);
17381
17382 custom_charset_4 = mask;
17383 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
17384 break;
17385 }
17386
17387 mask = mask + str_pos + 1;
17388 }
17389 }
17390
17391 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17392 {
17393 if (maskpos > 0)
17394 {
17395 local_free (css_buf);
17396 local_free (data.root_css_buf);
17397 local_free (data.markov_css_buf);
17398
17399 local_free (masks[maskpos - 1]);
17400 }
17401
17402 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17403
17404 data.mask = mask;
17405 data.css_cnt = css_cnt;
17406 data.css_buf = css_buf;
17407
17408 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17409
17410 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17411
17412 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17413 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17414
17415 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17416
17417 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17418
17419 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17420 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17421
17422 data.root_css_buf = root_css_buf;
17423 data.markov_css_buf = markov_css_buf;
17424
17425 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17426
17427 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17428
17429 local_free (root_table_buf);
17430 local_free (markov_table_buf);
17431
17432 // args
17433
17434 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17435 {
17436 hc_device_param_t *device_param = &data.devices_param[device_id];
17437
17438 if (device_param->skipped) continue;
17439
17440 device_param->kernel_params_mp[0] = &device_param->d_combs;
17441 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
17442 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
17443
17444 device_param->kernel_params_mp_buf64[3] = 0;
17445 device_param->kernel_params_mp_buf32[4] = css_cnt;
17446 device_param->kernel_params_mp_buf32[5] = 0;
17447 device_param->kernel_params_mp_buf32[6] = 0;
17448 device_param->kernel_params_mp_buf32[7] = 0;
17449
17450 if (attack_mode == ATTACK_MODE_HYBRID1)
17451 {
17452 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
17453 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
17454 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
17455 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
17456 }
17457 else if (attack_mode == ATTACK_MODE_HYBRID2)
17458 {
17459 device_param->kernel_params_mp_buf32[5] = 0;
17460 device_param->kernel_params_mp_buf32[6] = 0;
17461 device_param->kernel_params_mp_buf32[7] = 0;
17462 }
17463
17464 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]);
17465 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]);
17466 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]);
17467
17468 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);
17469 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);
17470 }
17471 }
17472 else if (attack_mode == ATTACK_MODE_BF)
17473 {
17474 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
17475
17476 if (increment)
17477 {
17478 for (uint i = 0; i < dictcnt; i++)
17479 {
17480 local_free (dictfiles[i]);
17481 }
17482
17483 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17484 {
17485 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17486
17487 if (l1_filename == NULL) break;
17488
17489 dictcnt++;
17490
17491 dictfiles[dictcnt - 1] = l1_filename;
17492 }
17493 }
17494 else
17495 {
17496 dictcnt++;
17497
17498 dictfiles[dictcnt - 1] = mask;
17499 }
17500
17501 if (dictcnt == 0)
17502 {
17503 log_error ("ERROR: Mask is too small");
17504
17505 return (-1);
17506 }
17507 }
17508 }
17509
17510 free (induction_dictionaries);
17511
17512 // induction_dictionaries_cnt = 0; // implied
17513
17514 if (attack_mode != ATTACK_MODE_BF)
17515 {
17516 if (keyspace == 0)
17517 {
17518 induction_dictionaries = scan_directory (induction_directory);
17519
17520 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17521 }
17522 }
17523
17524 if (induction_dictionaries_cnt)
17525 {
17526 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17527 }
17528
17529 /**
17530 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17531 */
17532 if (keyspace == 1)
17533 {
17534 if ((maskcnt > 1) || (dictcnt > 1))
17535 {
17536 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17537
17538 return (-1);
17539 }
17540 }
17541
17542 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17543 {
17544 char *subid = logfile_generate_subid ();
17545
17546 data.subid = subid;
17547
17548 logfile_sub_msg ("START");
17549
17550 if (data.devices_status == STATUS_CRACKED) break;
17551 if (data.devices_status == STATUS_ABORTED) break;
17552 if (data.devices_status == STATUS_QUIT) break;
17553
17554 data.devices_status = STATUS_INIT;
17555
17556 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17557 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17558 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17559
17560 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17561
17562 data.cpt_pos = 0;
17563
17564 data.cpt_start = time (NULL);
17565
17566 data.cpt_total = 0;
17567
17568 if (data.restore == 0)
17569 {
17570 rd->words_cur = skip;
17571
17572 skip = 0;
17573
17574 data.skip = 0;
17575 }
17576
17577 data.ms_paused = 0;
17578
17579 data.kernel_power_final = 0;
17580
17581 data.words_cur = rd->words_cur;
17582
17583 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17584 {
17585 hc_device_param_t *device_param = &data.devices_param[device_id];
17586
17587 if (device_param->skipped) continue;
17588
17589 device_param->speed_pos = 0;
17590
17591 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17592 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17593
17594 device_param->exec_pos = 0;
17595
17596 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17597
17598 device_param->outerloop_pos = 0;
17599 device_param->outerloop_left = 0;
17600 device_param->innerloop_pos = 0;
17601 device_param->innerloop_left = 0;
17602
17603 // some more resets:
17604
17605 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17606
17607 device_param->pws_cnt = 0;
17608
17609 device_param->words_off = 0;
17610 device_param->words_done = 0;
17611 }
17612
17613 // figure out some workload
17614
17615 if (attack_mode == ATTACK_MODE_STRAIGHT)
17616 {
17617 if (data.wordlist_mode == WL_MODE_FILE)
17618 {
17619 char *dictfile = NULL;
17620
17621 if (induction_dictionaries_cnt)
17622 {
17623 dictfile = induction_dictionaries[0];
17624 }
17625 else
17626 {
17627 dictfile = dictfiles[dictpos];
17628 }
17629
17630 data.dictfile = dictfile;
17631
17632 logfile_sub_string (dictfile);
17633
17634 for (uint i = 0; i < rp_files_cnt; i++)
17635 {
17636 logfile_sub_var_string ("rulefile", rp_files[i]);
17637 }
17638
17639 FILE *fd2 = fopen (dictfile, "rb");
17640
17641 if (fd2 == NULL)
17642 {
17643 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17644
17645 return (-1);
17646 }
17647
17648 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17649
17650 fclose (fd2);
17651
17652 if (data.words_cnt == 0)
17653 {
17654 if (data.devices_status == STATUS_CRACKED) break;
17655 if (data.devices_status == STATUS_ABORTED) break;
17656
17657 dictpos++;
17658
17659 continue;
17660 }
17661 }
17662 }
17663 else if (attack_mode == ATTACK_MODE_COMBI)
17664 {
17665 char *dictfile = data.dictfile;
17666 char *dictfile2 = data.dictfile2;
17667
17668 logfile_sub_string (dictfile);
17669 logfile_sub_string (dictfile2);
17670
17671 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17672 {
17673 FILE *fd2 = fopen (dictfile, "rb");
17674
17675 if (fd2 == NULL)
17676 {
17677 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17678
17679 return (-1);
17680 }
17681
17682 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17683
17684 fclose (fd2);
17685 }
17686 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17687 {
17688 FILE *fd2 = fopen (dictfile2, "rb");
17689
17690 if (fd2 == NULL)
17691 {
17692 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17693
17694 return (-1);
17695 }
17696
17697 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17698
17699 fclose (fd2);
17700 }
17701
17702 if (data.words_cnt == 0)
17703 {
17704 if (data.devices_status == STATUS_CRACKED) break;
17705 if (data.devices_status == STATUS_ABORTED) break;
17706
17707 dictpos++;
17708
17709 continue;
17710 }
17711 }
17712 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17713 {
17714 char *dictfile = NULL;
17715
17716 if (induction_dictionaries_cnt)
17717 {
17718 dictfile = induction_dictionaries[0];
17719 }
17720 else
17721 {
17722 dictfile = dictfiles[dictpos];
17723 }
17724
17725 data.dictfile = dictfile;
17726
17727 char *mask = data.mask;
17728
17729 logfile_sub_string (dictfile);
17730 logfile_sub_string (mask);
17731
17732 FILE *fd2 = fopen (dictfile, "rb");
17733
17734 if (fd2 == NULL)
17735 {
17736 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17737
17738 return (-1);
17739 }
17740
17741 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17742
17743 fclose (fd2);
17744
17745 if (data.words_cnt == 0)
17746 {
17747 if (data.devices_status == STATUS_CRACKED) break;
17748 if (data.devices_status == STATUS_ABORTED) break;
17749
17750 dictpos++;
17751
17752 continue;
17753 }
17754 }
17755 else if (attack_mode == ATTACK_MODE_BF)
17756 {
17757 local_free (css_buf);
17758 local_free (data.root_css_buf);
17759 local_free (data.markov_css_buf);
17760
17761 char *mask = dictfiles[dictpos];
17762
17763 logfile_sub_string (mask);
17764
17765 // base
17766
17767 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17768
17769 if (opts_type & OPTS_TYPE_PT_UNICODE)
17770 {
17771 uint css_cnt_unicode = css_cnt * 2;
17772
17773 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17774
17775 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17776 {
17777 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17778
17779 css_buf_unicode[j + 1].cs_buf[0] = 0;
17780 css_buf_unicode[j + 1].cs_len = 1;
17781 }
17782
17783 free (css_buf);
17784
17785 css_buf = css_buf_unicode;
17786 css_cnt = css_cnt_unicode;
17787 }
17788
17789 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17790
17791 uint mask_min = pw_min;
17792 uint mask_max = pw_max;
17793
17794 if (opts_type & OPTS_TYPE_PT_UNICODE)
17795 {
17796 mask_min *= 2;
17797 mask_max *= 2;
17798 }
17799
17800 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17801 {
17802 if (css_cnt < mask_min)
17803 {
17804 log_info ("WARNING: Skipping mask '%s' because it is smaller than the minimum password length", mask);
17805 }
17806
17807 if (css_cnt > mask_max)
17808 {
17809 log_info ("WARNING: Skipping mask '%s' because it is larger than the maximum password length", mask);
17810 }
17811
17812 // skip to next mask
17813
17814 dictpos++;
17815
17816 rd->dictpos = dictpos;
17817
17818 logfile_sub_msg ("STOP");
17819
17820 continue;
17821 }
17822
17823 uint save_css_cnt = css_cnt;
17824
17825 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17826 {
17827 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17828 {
17829 uint salt_len = (uint) data.salts_buf[0].salt_len;
17830 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17831
17832 uint css_cnt_salt = css_cnt + salt_len;
17833
17834 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17835
17836 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17837
17838 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17839 {
17840 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17841 css_buf_salt[j].cs_len = 1;
17842 }
17843
17844 free (css_buf);
17845
17846 css_buf = css_buf_salt;
17847 css_cnt = css_cnt_salt;
17848 }
17849 }
17850
17851 data.mask = mask;
17852 data.css_cnt = css_cnt;
17853 data.css_buf = css_buf;
17854
17855 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17856
17857 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17858
17859 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17860
17861 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17862 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17863
17864 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17865
17866 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17867
17868 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17869 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17870
17871 data.root_css_buf = root_css_buf;
17872 data.markov_css_buf = markov_css_buf;
17873
17874 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17875
17876 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17877
17878 local_free (root_table_buf);
17879 local_free (markov_table_buf);
17880
17881 // copy + args
17882
17883 uint css_cnt_l = css_cnt;
17884 uint css_cnt_r;
17885
17886 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17887 {
17888 if (save_css_cnt < 6)
17889 {
17890 css_cnt_r = 1;
17891 }
17892 else if (save_css_cnt == 6)
17893 {
17894 css_cnt_r = 2;
17895 }
17896 else
17897 {
17898 if (opts_type & OPTS_TYPE_PT_UNICODE)
17899 {
17900 if (save_css_cnt == 8 || save_css_cnt == 10)
17901 {
17902 css_cnt_r = 2;
17903 }
17904 else
17905 {
17906 css_cnt_r = 4;
17907 }
17908 }
17909 else
17910 {
17911 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17912 {
17913 css_cnt_r = 3;
17914 }
17915 else
17916 {
17917 css_cnt_r = 4;
17918 }
17919 }
17920 }
17921 }
17922 else
17923 {
17924 css_cnt_r = 1;
17925
17926 /* unfinished code?
17927 int sum = css_buf[css_cnt_r - 1].cs_len;
17928
17929 for (uint i = 1; i < 4 && i < css_cnt; i++)
17930 {
17931 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17932
17933 css_cnt_r++;
17934
17935 sum *= css_buf[css_cnt_r - 1].cs_len;
17936 }
17937 */
17938 }
17939
17940 css_cnt_l -= css_cnt_r;
17941
17942 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17943
17944 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17945 {
17946 hc_device_param_t *device_param = &data.devices_param[device_id];
17947
17948 if (device_param->skipped) continue;
17949
17950 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17951 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17952 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17953
17954 device_param->kernel_params_mp_l_buf64[3] = 0;
17955 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17956 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17957 device_param->kernel_params_mp_l_buf32[6] = 0;
17958 device_param->kernel_params_mp_l_buf32[7] = 0;
17959 device_param->kernel_params_mp_l_buf32[8] = 0;
17960
17961 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17962 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17963 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17964 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17965
17966 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17967 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17968 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17969
17970 device_param->kernel_params_mp_r_buf64[3] = 0;
17971 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17972 device_param->kernel_params_mp_r_buf32[5] = 0;
17973 device_param->kernel_params_mp_r_buf32[6] = 0;
17974 device_param->kernel_params_mp_r_buf32[7] = 0;
17975
17976 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]);
17977 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]);
17978 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]);
17979
17980 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]);
17981 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]);
17982 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]);
17983
17984 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);
17985 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);
17986 }
17987 }
17988
17989 u64 words_base = data.words_cnt;
17990
17991 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17992 {
17993 if (data.kernel_rules_cnt)
17994 {
17995 words_base /= data.kernel_rules_cnt;
17996 }
17997 }
17998 else if (data.attack_kern == ATTACK_KERN_COMBI)
17999 {
18000 if (data.combs_cnt)
18001 {
18002 words_base /= data.combs_cnt;
18003 }
18004 }
18005 else if (data.attack_kern == ATTACK_KERN_BF)
18006 {
18007 if (data.bfs_cnt)
18008 {
18009 words_base /= data.bfs_cnt;
18010 }
18011 }
18012
18013 data.words_base = words_base;
18014
18015 if (keyspace == 1)
18016 {
18017 log_info ("%llu", (unsigned long long int) words_base);
18018
18019 return (0);
18020 }
18021
18022 if (data.words_cur > data.words_base)
18023 {
18024 log_error ("ERROR: Restore value greater keyspace");
18025
18026 return (-1);
18027 }
18028
18029 if (data.words_cur)
18030 {
18031 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18032 {
18033 for (uint i = 0; i < data.salts_cnt; i++)
18034 {
18035 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
18036 }
18037 }
18038 else if (data.attack_kern == ATTACK_KERN_COMBI)
18039 {
18040 for (uint i = 0; i < data.salts_cnt; i++)
18041 {
18042 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
18043 }
18044 }
18045 else if (data.attack_kern == ATTACK_KERN_BF)
18046 {
18047 for (uint i = 0; i < data.salts_cnt; i++)
18048 {
18049 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
18050 }
18051 }
18052 }
18053
18054 /*
18055 * Update loopback file
18056 */
18057
18058 if (loopback == 1)
18059 {
18060 time_t now;
18061
18062 time (&now);
18063
18064 uint random_num = get_random_num (0, 9999);
18065
18066 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
18067
18068 data.loopback_file = loopback_file;
18069 }
18070
18071 /*
18072 * Update dictionary statistic
18073 */
18074
18075 if (keyspace == 0)
18076 {
18077 dictstat_fp = fopen (dictstat, "wb");
18078
18079 if (dictstat_fp)
18080 {
18081 lock_file (dictstat_fp);
18082
18083 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
18084
18085 fclose (dictstat_fp);
18086 }
18087 }
18088
18089 /**
18090 * create autotune threads
18091 */
18092
18093 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
18094
18095 if (data.devices_status == STATUS_CRACKED) break;
18096 if (data.devices_status == STATUS_ABORTED) break;
18097 if (data.devices_status == STATUS_QUIT) break;
18098
18099 data.devices_status = STATUS_AUTOTUNE;
18100
18101 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18102 {
18103 hc_device_param_t *device_param = &devices_param[device_id];
18104
18105 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
18106 }
18107
18108 hc_thread_wait (data.devices_cnt, c_threads);
18109
18110 /*
18111 * Inform user about possible slow speeds
18112 */
18113
18114 uint hardware_power_all = 0;
18115
18116 uint kernel_power_all = 0;
18117
18118 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18119 {
18120 hc_device_param_t *device_param = &devices_param[device_id];
18121
18122 hardware_power_all += device_param->hardware_power;
18123
18124 kernel_power_all += device_param->kernel_power;
18125 }
18126
18127 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
18128
18129 data.kernel_power_all = kernel_power_all;
18130
18131 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18132 {
18133 if (data.words_base < kernel_power_all)
18134 {
18135 if (quiet == 0)
18136 {
18137 clear_prompt ();
18138
18139 log_info ("ATTENTION!");
18140 log_info (" The wordlist or mask you are using is too small.");
18141 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
18142 log_info (" The cracking speed will drop.");
18143 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
18144 log_info ("");
18145 }
18146 }
18147 }
18148
18149 /**
18150 * create cracker threads
18151 */
18152
18153 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18154
18155 if (data.devices_status == STATUS_CRACKED) break;
18156 if (data.devices_status == STATUS_ABORTED) break;
18157 if (data.devices_status == STATUS_QUIT) break;
18158
18159 data.devices_status = STATUS_RUNNING;
18160
18161 if (initial_restore_done == 0)
18162 {
18163 if (data.restore_disable == 0) cycle_restore ();
18164
18165 initial_restore_done = 1;
18166 }
18167
18168 hc_timer_set (&data.timer_running);
18169
18170 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18171 {
18172 if ((quiet == 0) && (status == 0) && (benchmark == 0))
18173 {
18174 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
18175 if (quiet == 0) fflush (stdout);
18176 }
18177 }
18178 else if (wordlist_mode == WL_MODE_STDIN)
18179 {
18180 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
18181 if (data.quiet == 0) log_info ("");
18182 }
18183
18184 time_t runtime_start;
18185
18186 time (&runtime_start);
18187
18188 data.runtime_start = runtime_start;
18189
18190 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18191 {
18192 hc_device_param_t *device_param = &devices_param[device_id];
18193
18194 if (wordlist_mode == WL_MODE_STDIN)
18195 {
18196 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
18197 }
18198 else
18199 {
18200 hc_thread_create (c_threads[device_id], thread_calc, device_param);
18201 }
18202 }
18203
18204 hc_thread_wait (data.devices_cnt, c_threads);
18205
18206 local_free (c_threads);
18207
18208 data.restore = 0;
18209
18210 // finalize task
18211
18212 logfile_sub_var_uint ("status-after-work", data.devices_status);
18213
18214 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18215
18216 if (data.devices_status == STATUS_CRACKED) break;
18217 if (data.devices_status == STATUS_ABORTED) break;
18218
18219 if (data.devices_status == STATUS_BYPASS)
18220 {
18221 data.devices_status = STATUS_RUNNING;
18222 }
18223
18224 if (induction_dictionaries_cnt)
18225 {
18226 unlink (induction_dictionaries[0]);
18227 }
18228
18229 free (induction_dictionaries);
18230
18231 if (attack_mode != ATTACK_MODE_BF)
18232 {
18233 induction_dictionaries = scan_directory (induction_directory);
18234
18235 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18236 }
18237
18238 if (benchmark == 0)
18239 {
18240 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
18241 {
18242 if (quiet == 0) clear_prompt ();
18243
18244 if (quiet == 0) log_info ("");
18245
18246 if (status == 1)
18247 {
18248 status_display ();
18249 }
18250 else
18251 {
18252 if (quiet == 0) status_display ();
18253 }
18254
18255 if (quiet == 0) log_info ("");
18256 }
18257 }
18258
18259 if (attack_mode == ATTACK_MODE_BF)
18260 {
18261 dictpos++;
18262
18263 rd->dictpos = dictpos;
18264 }
18265 else
18266 {
18267 if (induction_dictionaries_cnt)
18268 {
18269 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18270 }
18271 else
18272 {
18273 dictpos++;
18274
18275 rd->dictpos = dictpos;
18276 }
18277 }
18278
18279 time_t runtime_stop;
18280
18281 time (&runtime_stop);
18282
18283 data.runtime_stop = runtime_stop;
18284
18285 logfile_sub_uint (runtime_start);
18286 logfile_sub_uint (runtime_stop);
18287
18288 logfile_sub_msg ("STOP");
18289
18290 global_free (subid);
18291 }
18292
18293 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18294
18295 if (data.devices_status == STATUS_CRACKED) break;
18296 if (data.devices_status == STATUS_ABORTED) break;
18297 if (data.devices_status == STATUS_QUIT) break;
18298
18299 if (data.devices_status == STATUS_BYPASS)
18300 {
18301 data.devices_status = STATUS_RUNNING;
18302 }
18303 }
18304
18305 // 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
18306
18307 if (attack_mode == ATTACK_MODE_STRAIGHT)
18308 {
18309 if (data.wordlist_mode == WL_MODE_FILE)
18310 {
18311 if (data.dictfile == NULL)
18312 {
18313 if (dictfiles != NULL)
18314 {
18315 data.dictfile = dictfiles[0];
18316
18317 hc_timer_set (&data.timer_running);
18318 }
18319 }
18320 }
18321 }
18322 // NOTE: combi is okay because it is already set beforehand
18323 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
18324 {
18325 if (data.dictfile == NULL)
18326 {
18327 if (dictfiles != NULL)
18328 {
18329 hc_timer_set (&data.timer_running);
18330
18331 data.dictfile = dictfiles[0];
18332 }
18333 }
18334 }
18335 else if (attack_mode == ATTACK_MODE_BF)
18336 {
18337 if (data.mask == NULL)
18338 {
18339 hc_timer_set (&data.timer_running);
18340
18341 data.mask = masks[0];
18342 }
18343 }
18344
18345 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18346 {
18347 data.devices_status = STATUS_EXHAUSTED;
18348 }
18349
18350 // if cracked / aborted remove last induction dictionary
18351
18352 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
18353 {
18354 struct stat induct_stat;
18355
18356 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
18357 {
18358 unlink (induction_dictionaries[file_pos]);
18359 }
18360 }
18361
18362 // wait for non-interactive threads
18363
18364 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
18365 {
18366 hc_thread_wait (1, &ni_threads[thread_idx]);
18367 }
18368
18369 local_free (ni_threads);
18370
18371 // we dont need restore file anymore
18372 if (data.restore_disable == 0)
18373 {
18374 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
18375 {
18376 unlink (eff_restore_file);
18377 unlink (new_restore_file);
18378 }
18379 else
18380 {
18381 cycle_restore ();
18382 }
18383 }
18384
18385 // finally save left hashes
18386
18387 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
18388 {
18389 save_hash ();
18390 }
18391
18392 /**
18393 * Clean up
18394 */
18395
18396 if (benchmark == 1)
18397 {
18398 status_benchmark ();
18399
18400 if (machine_readable == 0)
18401 {
18402 log_info ("");
18403 }
18404 }
18405 else
18406 {
18407 if (quiet == 0) clear_prompt ();
18408
18409 if (quiet == 0) log_info ("");
18410
18411 if (status == 1 && stdout_flag == 0)
18412 {
18413 status_display ();
18414 }
18415 else
18416 {
18417 if (quiet == 0) status_display ();
18418 }
18419
18420 if (quiet == 0) log_info ("");
18421 }
18422
18423 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18424 {
18425 hc_device_param_t *device_param = &data.devices_param[device_id];
18426
18427 if (device_param->skipped) continue;
18428
18429 local_free (device_param->combs_buf);
18430
18431 local_free (device_param->hooks_buf);
18432
18433 local_free (device_param->device_name);
18434
18435 local_free (device_param->device_name_chksum);
18436
18437 local_free (device_param->device_version);
18438
18439 local_free (device_param->driver_version);
18440
18441 if (device_param->pws_buf) myfree (device_param->pws_buf);
18442 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
18443 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
18444 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
18445 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
18446 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
18447 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
18448 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
18449 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
18450 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
18451 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
18452 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
18453 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
18454 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
18455 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
18456 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
18457 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
18458 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
18459 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
18460 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
18461 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
18462 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
18463 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
18464 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
18465 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
18466 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
18467 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
18468 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
18469 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
18470
18471 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
18472 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
18473 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
18474 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
18475 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
18476 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
18477 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
18478 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
18479 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
18480 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
18481 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
18482
18483 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
18484 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
18485 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
18486
18487 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
18488 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
18489 }
18490
18491 // reset default fan speed
18492
18493 #ifdef HAVE_HWMON
18494 if (gpu_temp_disable == 0)
18495 {
18496 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
18497 {
18498 hc_thread_mutex_lock (mux_adl);
18499
18500 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18501 {
18502 hc_device_param_t *device_param = &data.devices_param[device_id];
18503
18504 if (device_param->skipped) continue;
18505
18506 if (data.hm_device[device_id].fan_set_supported == 1)
18507 {
18508 int fanspeed = temp_retain_fanspeed_value[device_id];
18509 int fanpolicy = temp_retain_fanpolicy_value[device_id];
18510
18511 if (fanpolicy == 1)
18512 {
18513 int rc = -1;
18514
18515 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18516 {
18517 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
18518 }
18519 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18520 {
18521 #ifdef LINUX
18522 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE);
18523 #endif
18524
18525 #ifdef WIN
18526 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, fanpolicy);
18527 #endif
18528 }
18529
18530 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18531 }
18532 }
18533 }
18534
18535 hc_thread_mutex_unlock (mux_adl);
18536 }
18537 }
18538
18539 // reset power tuning
18540
18541 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
18542 {
18543 hc_thread_mutex_lock (mux_adl);
18544
18545 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18546 {
18547 hc_device_param_t *device_param = &data.devices_param[device_id];
18548
18549 if (device_param->skipped) continue;
18550
18551 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18552 {
18553 if (data.hm_device[device_id].od_version == 6)
18554 {
18555 // check powertune capabilities first, if not available then skip device
18556
18557 int powertune_supported = 0;
18558
18559 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18560 {
18561 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18562
18563 return (-1);
18564 }
18565
18566 if (powertune_supported != 0)
18567 {
18568 // powercontrol settings
18569
18570 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18571 {
18572 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18573
18574 return (-1);
18575 }
18576
18577 // clocks
18578
18579 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18580
18581 performance_state->iNumberOfPerformanceLevels = 2;
18582
18583 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18584 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18585 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18586 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18587
18588 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18589 {
18590 log_info ("ERROR: Failed to restore ADL performance state");
18591
18592 return (-1);
18593 }
18594
18595 local_free (performance_state);
18596 }
18597 }
18598 }
18599
18600 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18601 {
18602 unsigned int limit = nvml_power_limit[device_id];
18603
18604 if (limit > 0)
18605 {
18606 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18607 }
18608 }
18609 }
18610
18611 hc_thread_mutex_unlock (mux_adl);
18612 }
18613
18614 if (gpu_temp_disable == 0)
18615 {
18616 if (data.hm_nvml)
18617 {
18618 hm_NVML_nvmlShutdown (data.hm_nvml);
18619
18620 nvml_close (data.hm_nvml);
18621
18622 data.hm_nvml = NULL;
18623 }
18624
18625 if (data.hm_nvapi)
18626 {
18627 hm_NvAPI_Unload (data.hm_nvapi);
18628
18629 nvapi_close (data.hm_nvapi);
18630
18631 data.hm_nvapi = NULL;
18632 }
18633
18634 if (data.hm_xnvctrl)
18635 {
18636 hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);
18637
18638 xnvctrl_close (data.hm_xnvctrl);
18639
18640 data.hm_xnvctrl = NULL;
18641 }
18642
18643 if (data.hm_adl)
18644 {
18645 hm_ADL_Main_Control_Destroy (data.hm_adl);
18646
18647 adl_close (data.hm_adl);
18648
18649 data.hm_adl = NULL;
18650 }
18651 }
18652 #endif // HAVE_HWMON
18653
18654 // free memory
18655
18656 local_free (masks);
18657
18658 local_free (dictstat_base);
18659
18660 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18661 {
18662 pot_t *pot_ptr = &pot[pot_pos];
18663
18664 hash_t *hash = &pot_ptr->hash;
18665
18666 local_free (hash->digest);
18667
18668 if (isSalted)
18669 {
18670 local_free (hash->salt);
18671 }
18672 }
18673
18674 local_free (pot);
18675
18676 local_free (all_kernel_rules_cnt);
18677 local_free (all_kernel_rules_buf);
18678
18679 local_free (wl_data->buf);
18680 local_free (wl_data);
18681
18682 local_free (bitmap_s1_a);
18683 local_free (bitmap_s1_b);
18684 local_free (bitmap_s1_c);
18685 local_free (bitmap_s1_d);
18686 local_free (bitmap_s2_a);
18687 local_free (bitmap_s2_b);
18688 local_free (bitmap_s2_c);
18689 local_free (bitmap_s2_d);
18690
18691 #ifdef HAVE_HWMON
18692 local_free (temp_retain_fanspeed_value);
18693 local_free (od_clock_mem_status);
18694 local_free (od_power_control_status);
18695 local_free (nvml_power_limit);
18696 #endif
18697
18698 global_free (devices_param);
18699
18700 global_free (kernel_rules_buf);
18701
18702 global_free (root_css_buf);
18703 global_free (markov_css_buf);
18704
18705 global_free (digests_buf);
18706 global_free (digests_shown);
18707 global_free (digests_shown_tmp);
18708
18709 global_free (salts_buf);
18710 global_free (salts_shown);
18711
18712 global_free (esalts_buf);
18713
18714 global_free (words_progress_done);
18715 global_free (words_progress_rejected);
18716 global_free (words_progress_restored);
18717
18718 if (pot_fp) fclose (pot_fp);
18719
18720 if (data.devices_status == STATUS_QUIT) break;
18721 }
18722
18723 // wait for interactive threads
18724
18725 for (uint thread_idx = 0; thread_idx < i_threads_cnt; thread_idx++)
18726 {
18727 hc_thread_wait (1, &i_threads[thread_idx]);
18728 }
18729
18730 local_free (i_threads);
18731
18732 // destroy others mutex
18733
18734 hc_thread_mutex_delete (mux_dispatcher);
18735 hc_thread_mutex_delete (mux_counter);
18736 hc_thread_mutex_delete (mux_display);
18737 hc_thread_mutex_delete (mux_adl);
18738
18739 // free memory
18740
18741 local_free (eff_restore_file);
18742 local_free (new_restore_file);
18743
18744 local_free (rd);
18745
18746 // tuning db
18747
18748 tuning_db_destroy (tuning_db);
18749
18750 // loopback
18751
18752 local_free (loopback_file);
18753
18754 if (loopback == 1) unlink (loopback_file);
18755
18756 // induction directory
18757
18758 if (induction_dir == NULL)
18759 {
18760 if (attack_mode != ATTACK_MODE_BF)
18761 {
18762 if (rmdir (induction_directory) == -1)
18763 {
18764 if (errno == ENOENT)
18765 {
18766 // good, we can ignore
18767 }
18768 else if (errno == ENOTEMPTY)
18769 {
18770 // good, we can ignore
18771 }
18772 else
18773 {
18774 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18775
18776 return (-1);
18777 }
18778 }
18779
18780 local_free (induction_directory);
18781 }
18782 }
18783
18784 // outfile-check directory
18785
18786 if (outfile_check_dir == NULL)
18787 {
18788 if (rmdir (outfile_check_directory) == -1)
18789 {
18790 if (errno == ENOENT)
18791 {
18792 // good, we can ignore
18793 }
18794 else if (errno == ENOTEMPTY)
18795 {
18796 // good, we can ignore
18797 }
18798 else
18799 {
18800 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18801
18802 return (-1);
18803 }
18804 }
18805
18806 local_free (outfile_check_directory);
18807 }
18808
18809 time_t proc_stop;
18810
18811 time (&proc_stop);
18812
18813 logfile_top_uint (proc_start);
18814 logfile_top_uint (proc_stop);
18815
18816 logfile_top_msg ("STOP");
18817
18818 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18819 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18820
18821 if (data.ocl) ocl_close (data.ocl);
18822
18823 if (data.devices_status == STATUS_ABORTED) return 2;
18824 if (data.devices_status == STATUS_QUIT) return 2;
18825 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18826 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18827 if (data.devices_status == STATUS_CRACKED) return 0;
18828
18829 return -1;
18830 }
Hashcat additions to support pwdhash