projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Set fanspeed to automatic on shutdown
[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 75
82 #define WORKLOAD_PROFILE 2
83 #define KERNEL_ACCEL 0
84 #define KERNEL_LOOPS 0
85 #define KERNEL_RULES 1024
86 #define KERNEL_COMBS 1024
87 #define KERNEL_BFS 1024
88 #define KERNEL_THREADS_MAX 256
89 #define KERNEL_THREADS_MAX_CPU 16
90 #define POWERTUNE_ENABLE 0
91 #define LOGFILE_DISABLE 0
92 #define SCRYPT_TMTO 0
93 #define OPENCL_VECTOR_WIDTH 0
94
95 #define WL_MODE_STDIN 1
96 #define WL_MODE_FILE 2
97 #define WL_MODE_MASK 3
98
99 #define HL_MODE_FILE 4
100 #define HL_MODE_ARG 5
101
102 #define HLFMTS_CNT 11
103 #define HLFMT_HASHCAT 0
104 #define HLFMT_PWDUMP 1
105 #define HLFMT_PASSWD 2
106 #define HLFMT_SHADOW 3
107 #define HLFMT_DCC 4
108 #define HLFMT_DCC2 5
109 #define HLFMT_NETNTLM1 7
110 #define HLFMT_NETNTLM2 8
111 #define HLFMT_NSLDAP 9
112 #define HLFMT_NSLDAPS 10
113
114 #define HLFMT_TEXT_HASHCAT "native hashcat"
115 #define HLFMT_TEXT_PWDUMP "pwdump"
116 #define HLFMT_TEXT_PASSWD "passwd"
117 #define HLFMT_TEXT_SHADOW "shadow"
118 #define HLFMT_TEXT_DCC "DCC"
119 #define HLFMT_TEXT_DCC2 "DCC 2"
120 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
121 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
122 #define HLFMT_TEXT_NSLDAP "nsldap"
123 #define HLFMT_TEXT_NSLDAPS "nsldaps"
124
125 #define ATTACK_MODE_STRAIGHT 0
126 #define ATTACK_MODE_COMBI 1
127 #define ATTACK_MODE_TOGGLE 2
128 #define ATTACK_MODE_BF 3
129 #define ATTACK_MODE_PERM 4
130 #define ATTACK_MODE_TABLE 5
131 #define ATTACK_MODE_HYBRID1 6
132 #define ATTACK_MODE_HYBRID2 7
133 #define ATTACK_MODE_NONE 100
134
135 #define ATTACK_KERN_STRAIGHT 0
136 #define ATTACK_KERN_COMBI 1
137 #define ATTACK_KERN_BF 3
138 #define ATTACK_KERN_NONE 100
139
140 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
141 #define ATTACK_EXEC_INSIDE_KERNEL 11
142
143 #define COMBINATOR_MODE_BASE_LEFT 10001
144 #define COMBINATOR_MODE_BASE_RIGHT 10002
145
146 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
147 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
148
149 #define MAX_CUT_TRIES 4
150
151 #define MAX_DICTSTAT 10000
152
153 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
154
155 #define NVIDIA_100PERCENTCPU_WORKAROUND 100
156
157 #define global_free(attr) \
158 { \
159 myfree ((void *) data.attr); \
160 \
161 data.attr = NULL; \
162 }
163
164 #define local_free(attr) \
165 { \
166 myfree ((void *) attr); \
167 \
168 attr = NULL; \
169 }
170
171 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
172 #define HC_API_CALL __stdcall
173 #else
174 #define HC_API_CALL
175 #endif
176
177 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
178 {
179 900,
180 0,
181 5100,
182 100,
183 1400,
184 10800,
185 1700,
186 5000,
187 10100,
188 6000,
189 6100,
190 6900,
191 11700,
192 11800,
193 400,
194 8900,
195 11900,
196 12000,
197 10900,
198 12100,
199 23,
200 2500,
201 5300,
202 5400,
203 5500,
204 5600,
205 7300,
206 7500,
207 13100,
208 8300,
209 11100,
210 11200,
211 11400,
212 121,
213 2611,
214 2711,
215 2811,
216 8400,
217 11,
218 2612,
219 7900,
220 21,
221 11000,
222 124,
223 10000,
224 3711,
225 7600,
226 12,
227 131,
228 132,
229 1731,
230 200,
231 300,
232 3100,
233 112,
234 12300,
235 8000,
236 141,
237 1441,
238 1600,
239 12600,
240 1421,
241 101,
242 111,
243 1711,
244 3000,
245 1000,
246 1100,
247 2100,
248 12800,
249 1500,
250 12400,
251 500,
252 3200,
253 7400,
254 1800,
255 122,
256 1722,
257 7100,
258 6300,
259 6700,
260 6400,
261 6500,
262 2400,
263 2410,
264 5700,
265 9200,
266 9300,
267 22,
268 501,
269 5800,
270 8100,
271 8500,
272 7200,
273 9900,
274 7700,
275 7800,
276 10300,
277 8600,
278 8700,
279 9100,
280 133,
281 13500,
282 11600,
283 13600,
284 12500,
285 13000,
286 13200,
287 13300,
288 6211,
289 6221,
290 6231,
291 6241,
292 13711,
293 13721,
294 13731,
295 13741,
296 13751,
297 13761,
298 8800,
299 12900,
300 12200,
301 9700,
302 9710,
303 9800,
304 9810,
305 9400,
306 9500,
307 9600,
308 10400,
309 10410,
310 10500,
311 10600,
312 10700,
313 9000,
314 5200,
315 6800,
316 6600,
317 8200,
318 11300,
319 12700,
320 13400,
321 125
322 };
323
324 /**
325 * types
326 */
327
328 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
329
330 /**
331 * globals
332 */
333
334 static unsigned int full01 = 0x01010101;
335 static unsigned int full80 = 0x80808080;
336
337 int SUPPRESS_OUTPUT = 0;
338
339 hc_thread_mutex_t mux_adl;
340 hc_thread_mutex_t mux_counter;
341 hc_thread_mutex_t mux_dispatcher;
342 hc_thread_mutex_t mux_display;
343
344 hc_global_data_t data;
345
346 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
347
348 const char *USAGE_MINI[] =
349 {
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "Try --help for more help.",
353 NULL
354 };
355
356 const char *USAGE_BIG[] =
357 {
358 "%s, advanced password recovery",
359 "",
360 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
361 "",
362 "- [ Options ] -",
363 "",
364 " Options Short / Long | Type | Description | Example",
365 "===============================+======+======================================================+=======================",
366 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
367 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
368 " -V, --version | | Print version |",
369 " -h, --help | | Print help |",
370 " --quiet | | Suppress output |",
371 " --hex-charset | | Assume charset is given in hex |",
372 " --hex-salt | | Assume salt is given in hex |",
373 " --hex-wordlist | | Assume words in wordlist is given in hex |",
374 " --force | | Ignore warnings |",
375 " --status | | Enable automatic update of the status-screen |",
376 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
377 " --machine-readable | | Display the status view in a machine readable format |",
378 " --loopback | | Add new plains to induct directory |",
379 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
380 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
381 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
382 " --markov-classic | | Enables classic markov-chains, no per-position |",
383 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
384 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
385 " --session | Str | Define specific session name | --session=mysession",
386 " --restore | | Restore session from --session |",
387 " --restore-disable | | Do not write restore file |",
388 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
389 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
390 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
391 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
392 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
393 " --stdout | | Do not crack a hash, instead print candidates only |",
394 " --show | | Compare hashlist with potfile; Show cracked hashes |",
395 " --left | | Compare hashlist with potfile; Show uncracked hashes |",
396 " --username | | Enable ignoring of usernames in hashfile |",
397 " --remove | | Enable remove of hash once it is cracked |",
398 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
399 " --potfile-disable | | Do not write potfile |",
400 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
401 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
402 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
403 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
404 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
405 " --logfile-disable | | Disable the logfile |",
406 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
407 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
408 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
409 " -b, --benchmark | | Run benchmark |",
410 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
411 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
412 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
413 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
414 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
415 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
416 " -D, --opencl-device-types | Str | OpenCL device-types to use, separate with comma | -D 1",
417 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
418 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
419 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
420 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
421 " --nvidia-spin-damp | Num | Workaround NVidias CPU burning loop bug, in percent | --nvidia-spin-damp=50",
422 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
423 #ifdef HAVE_HWMON
424 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
425 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
426 " --powertune-enable | | Enable power tuning, restores settings when finished |",
427 #endif
428 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
429 " -s, --skip | Num | Skip X words from the start | -s 1000000",
430 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
431 " --keyspace | | Show keyspace base:mod values and quit |",
432 " -j, --rule-left | Rule | Single rule applied to each word from left wordlist | -j 'c'",
433 " -k, --rule-right | Rule | Single rule applied to each word from right wordlist | -k '^-'",
434 " -r, --rules-file | File | Multiple rules applied to each word from wordlists | -r rules/best64.rule",
435 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
436 " --generate-rules-func-min | Num | Force min X funcs per rule |",
437 " --generate-rules-func-max | Num | Force max X funcs per rule |",
438 " --generate-rules-seed | Num | Force RNG seed set to X |",
439 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
440 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
441 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
442 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
443 " -i, --increment | | Enable mask increment mode |",
444 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
445 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
446 "",
447 "- [ Hash modes ] -",
448 "",
449 " # | Name | Category",
450 " ======+==================================================+======================================",
451 " 900 | MD4 | Raw Hash",
452 " 0 | MD5 | Raw Hash",
453 " 5100 | Half MD5 | Raw Hash",
454 " 100 | SHA1 | Raw Hash",
455 " 10800 | SHA-384 | Raw Hash",
456 " 1400 | SHA-256 | Raw Hash",
457 " 1700 | SHA-512 | Raw Hash",
458 " 5000 | SHA-3(Keccak) | Raw Hash",
459 " 10100 | SipHash | Raw Hash",
460 " 6000 | RipeMD160 | Raw Hash",
461 " 6100 | Whirlpool | Raw Hash",
462 " 6900 | GOST R 34.11-94 | Raw Hash",
463 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
464 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
465 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
466 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
467 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
468 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
469 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
470 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
471 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
472 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
473 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
474 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
475 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
476 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
477 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
478 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
479 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
480 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
481 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
482 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
483 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
484 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
485 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
486 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
487 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
488 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
489 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
490 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
491 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
492 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
493 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
494 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
495 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
496 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
497 " 400 | phpass | Generic KDF",
498 " 8900 | scrypt | Generic KDF",
499 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
500 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
501 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
502 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
503 " 23 | Skype | Network protocols",
504 " 2500 | WPA/WPA2 | Network protocols",
505 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
506 " 5300 | IKE-PSK MD5 | Network protocols",
507 " 5400 | IKE-PSK SHA1 | Network protocols",
508 " 5500 | NetNTLMv1 | Network protocols",
509 " 5500 | NetNTLMv1 + ESS | Network protocols",
510 " 5600 | NetNTLMv2 | Network protocols",
511 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
512 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
513 " 8300 | DNSSEC (NSEC3) | Network protocols",
514 " 10200 | Cram MD5 | Network protocols",
515 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
516 " 11200 | MySQL CRAM (SHA1) | Network protocols",
517 " 11400 | SIP digest authentication (MD5) | Network protocols",
518 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
519 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
520 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
521 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
522 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
523 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
524 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
525 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
526 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
527 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
528 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
529 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
530 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
531 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
532 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
533 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
534 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
535 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
536 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
537 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
538 " 12 | PostgreSQL | Database Server",
539 " 131 | MSSQL(2000) | Database Server",
540 " 132 | MSSQL(2005) | Database Server",
541 " 1731 | MSSQL(2012) | Database Server",
542 " 1731 | MSSQL(2014) | Database Server",
543 " 200 | MySQL323 | Database Server",
544 " 300 | MySQL4.1/MySQL5 | Database Server",
545 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
546 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
547 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
548 " 8000 | Sybase ASE | Database Server",
549 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
550 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
551 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
552 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
553 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
554 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
555 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
556 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
557 " 11500 | CRC32 | Checksums",
558 " 3000 | LM | Operating-Systems",
559 " 1000 | NTLM | Operating-Systems",
560 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
561 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
562 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
563 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
564 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
565 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
566 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
567 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
568 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
569 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
570 " 1722 | OSX v10.7 | Operating-Systems",
571 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
572 " 6300 | AIX {smd5} | Operating-Systems",
573 " 6700 | AIX {ssha1} | Operating-Systems",
574 " 6400 | AIX {ssha256} | Operating-Systems",
575 " 6500 | AIX {ssha512} | Operating-Systems",
576 " 2400 | Cisco-PIX | Operating-Systems",
577 " 2410 | Cisco-ASA | Operating-Systems",
578 " 500 | Cisco-IOS $1$ | Operating-Systems",
579 " 5700 | Cisco-IOS $4$ | Operating-Systems",
580 " 9200 | Cisco-IOS $8$ | Operating-Systems",
581 " 9300 | Cisco-IOS $9$ | Operating-Systems",
582 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
583 " 501 | Juniper IVE | Operating-Systems",
584 " 5800 | Android PIN | Operating-Systems",
585 " 13800 | Windows 8+ phone PIN/Password | Operating-Systems",
586 " 8100 | Citrix Netscaler | Operating-Systems",
587 " 8500 | RACF | Operating-Systems",
588 " 7200 | GRUB 2 | Operating-Systems",
589 " 9900 | Radmin2 | Operating-Systems",
590 " 125 | ArubaOS | Operating-Systems",
591 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
592 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
593 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
594 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
595 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
596 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
597 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
598 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
599 " 11600 | 7-Zip | Archives",
600 " 12500 | RAR3-hp | Archives",
601 " 13000 | RAR5 | Archives",
602 " 13200 | AxCrypt | Archives",
603 " 13300 | AxCrypt in memory SHA1 | Archives",
604 " 13600 | WinZip | Archives",
605 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
606 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
607 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
608 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
609 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
610 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
611 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
612 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
613 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
614 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
615 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
616 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
617 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
618 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
619 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
620 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
621 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
622 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
623 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
624 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
625 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
626 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
627 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
628 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
629 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
630 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
631 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
632 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
633 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
634 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
635 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
636 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
637 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
638 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
639 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
640 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
641 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
642 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
643 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
644 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
645 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
646 " 9400 | MS Office 2007 | Documents",
647 " 9500 | MS Office 2010 | Documents",
648 " 9600 | MS Office 2013 | Documents",
649 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
650 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
651 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
652 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
653 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
654 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
655 " 9000 | Password Safe v2 | Password Managers",
656 " 5200 | Password Safe v3 | Password Managers",
657 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
658 " 6600 | 1Password, agilekeychain | Password Managers",
659 " 8200 | 1Password, cloudkeychain | Password Managers",
660 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
661 " 12700 | Blockchain, My Wallet | Password Managers",
662 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
663 "",
664 "- [ Outfile Formats ] -",
665 "",
666 " # | Format",
667 " ===+========",
668 " 1 | hash[:salt]",
669 " 2 | plain",
670 " 3 | hash[:salt]:plain",
671 " 4 | hex_plain",
672 " 5 | hash[:salt]:hex_plain",
673 " 6 | plain:hex_plain",
674 " 7 | hash[:salt]:plain:hex_plain",
675 " 8 | crackpos",
676 " 9 | hash[:salt]:crack_pos",
677 " 10 | plain:crack_pos",
678 " 11 | hash[:salt]:plain:crack_pos",
679 " 12 | hex_plain:crack_pos",
680 " 13 | hash[:salt]:hex_plain:crack_pos",
681 " 14 | plain:hex_plain:crack_pos",
682 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
683 "",
684 "- [ Rule Debugging Modes ] -",
685 "",
686 " # | Format",
687 " ===+========",
688 " 1 | Finding-Rule",
689 " 2 | Original-Word",
690 " 3 | Original-Word:Finding-Rule",
691 " 4 | Original-Word:Finding-Rule:Processed-Word",
692 "",
693 "- [ Attack Modes ] -",
694 "",
695 " # | Mode",
696 " ===+======",
697 " 0 | Straight",
698 " 1 | Combination",
699 " 3 | Brute-force",
700 " 6 | Hybrid Wordlist + Mask",
701 " 7 | Hybrid Mask + Wordlist",
702 "",
703 "- [ Built-in Charsets ] -",
704 "",
705 " ? | Charset",
706 " ===+=========",
707 " l | abcdefghijklmnopqrstuvwxyz",
708 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
709 " d | 0123456789",
710 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
711 " a | ?l?u?d?s",
712 " b | 0x00 - 0xff",
713 "",
714 "- [ OpenCL Device Types ] -",
715 "",
716 " # | Device Type",
717 " ===+=============",
718 " 1 | CPU",
719 " 2 | GPU",
720 " 3 | FPGA, DSP, Co-Processor",
721 "",
722 "- [ Workload Profiles ] -",
723 "",
724 " # | Performance | Runtime | Power Consumption | Desktop Impact",
725 " ===+=============+=========+===================+=================",
726 " 1 | Low | 2 ms | Low | Minimal",
727 " 2 | Default | 12 ms | Economic | Noticeable",
728 " 3 | High | 96 ms | High | Unresponsive",
729 " 4 | Nightmare | 480 ms | Insane | Headless",
730 "",
731 "- [ Basic Examples ] -",
732 "",
733 " Attack- | Hash- |",
734 " Mode | Type | Example command",
735 " ==================+=======+==================================================================",
736 " Wordlist | $P$ | %s -a 0 -m 400 example400.hash example.dict",
737 " Wordlist + Rules | MD5 | %s -a 0 -m 0 example0.hash example.dict -r rules/best64.rule",
738 " Brute-Force | MD5 | %s -a 3 -m 0 example0.hash ?a?a?a?a?a?a",
739 " Combinator | MD5 | %s -a 1 -m 0 example0.hash example.dict example.dict",
740 "",
741 "If you still have no idea what just happened try following pages:",
742 "",
743 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
744 "* https://hashcat.net/wiki/#frequently_asked_questions",
745 NULL
746 };
747
748 /**
749 * hashcat specific functions
750 */
751
752 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
753 {
754 int exec_pos = (int) device_param->exec_pos - last_num_entries;
755
756 if (exec_pos < 0) exec_pos += EXEC_CACHE;
757
758 double exec_ms_sum = 0;
759
760 int exec_ms_cnt = 0;
761
762 for (int i = 0; i < last_num_entries; i++)
763 {
764 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
765
766 if (exec_ms)
767 {
768 exec_ms_sum += exec_ms;
769
770 exec_ms_cnt++;
771 }
772 }
773
774 if (exec_ms_cnt == 0) return 0;
775
776 return exec_ms_sum / exec_ms_cnt;
777 }
778
779 void status_display_machine_readable ()
780 {
781 FILE *out = stdout;
782
783 fprintf (out, "STATUS\t%u\t", data.devices_status);
784
785 /**
786 * speed new
787 */
788
789 fprintf (out, "SPEED\t");
790
791 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
792 {
793 hc_device_param_t *device_param = &data.devices_param[device_id];
794
795 if (device_param->skipped) continue;
796
797 u64 speed_cnt = 0;
798 double speed_ms = 0;
799
800 for (int i = 0; i < SPEED_CACHE; i++)
801 {
802 speed_cnt += device_param->speed_cnt[i];
803 speed_ms += device_param->speed_ms[i];
804 }
805
806 speed_cnt /= SPEED_CACHE;
807 speed_ms /= SPEED_CACHE;
808
809 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
810 }
811
812 /**
813 * exec time
814 */
815
816 fprintf (out, "EXEC_RUNTIME\t");
817
818 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
819 {
820 hc_device_param_t *device_param = &data.devices_param[device_id];
821
822 if (device_param->skipped) continue;
823
824 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
825
826 fprintf (out, "%f\t", exec_ms_avg);
827 }
828
829 /**
830 * words_cur
831 */
832
833 u64 words_cur = get_lowest_words_done ();
834
835 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
836
837 /**
838 * counter
839 */
840
841 u64 progress_total = data.words_cnt * data.salts_cnt;
842
843 u64 all_done = 0;
844 u64 all_rejected = 0;
845 u64 all_restored = 0;
846
847 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
848 {
849 all_done += data.words_progress_done[salt_pos];
850 all_rejected += data.words_progress_rejected[salt_pos];
851 all_restored += data.words_progress_restored[salt_pos];
852 }
853
854 u64 progress_cur = all_restored + all_done + all_rejected;
855 u64 progress_end = progress_total;
856
857 u64 progress_skip = 0;
858
859 if (data.skip)
860 {
861 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
862
863 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
864 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
865 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
866 }
867
868 if (data.limit)
869 {
870 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
871
872 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
873 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
874 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
875 }
876
877 u64 progress_cur_relative_skip = progress_cur - progress_skip;
878 u64 progress_end_relative_skip = progress_end - progress_skip;
879
880 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
881
882 /**
883 * cracks
884 */
885
886 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
887 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
888
889 /**
890 * temperature
891 */
892
893 #ifdef HAVE_HWMON
894 if (data.gpu_temp_disable == 0)
895 {
896 fprintf (out, "TEMP\t");
897
898 hc_thread_mutex_lock (mux_adl);
899
900 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
901 {
902 hc_device_param_t *device_param = &data.devices_param[device_id];
903
904 if (device_param->skipped) continue;
905
906 int temp = hm_get_temperature_with_device_id (device_id);
907
908 fprintf (out, "%d\t", temp);
909 }
910
911 hc_thread_mutex_unlock (mux_adl);
912 }
913 #endif // HAVE_HWMON
914
915 /**
916 * flush
917 */
918
919 #ifdef _WIN
920 fputc ('\r', out);
921 fputc ('\n', out);
922 #endif
923
924 #ifdef _POSIX
925 fputc ('\n', out);
926 #endif
927
928 fflush (out);
929 }
930
931 void status_display ()
932 {
933 if (data.devices_status == STATUS_INIT) return;
934 if (data.devices_status == STATUS_STARTING) return;
935
936 if (data.machine_readable == 1)
937 {
938 status_display_machine_readable ();
939
940 return;
941 }
942
943 char tmp_buf[1000] = { 0 };
944
945 uint tmp_len = 0;
946
947 log_info ("Session.Name...: %s", data.session);
948
949 char *status_type = strstatus (data.devices_status);
950
951 uint hash_mode = data.hash_mode;
952
953 char *hash_type = strhashtype (hash_mode); // not a bug
954
955 log_info ("Status.........: %s", status_type);
956
957 /**
958 * show rules
959 */
960
961 if (data.rp_files_cnt)
962 {
963 uint i;
964
965 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
966 {
967 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
968 }
969
970 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
971
972 log_info ("Rules.Type.....: %s", tmp_buf);
973
974 tmp_len = 0;
975 }
976
977 if (data.rp_gen)
978 {
979 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
980
981 if (data.rp_gen_seed)
982 {
983 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
984 }
985 }
986
987 /**
988 * show input
989 */
990
991 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
992 {
993 if (data.wordlist_mode == WL_MODE_FILE)
994 {
995 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
996 }
997 else if (data.wordlist_mode == WL_MODE_STDIN)
998 {
999 log_info ("Input.Mode.....: Pipe");
1000 }
1001 }
1002 else if (data.attack_mode == ATTACK_MODE_COMBI)
1003 {
1004 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1005 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1006 }
1007 else if (data.attack_mode == ATTACK_MODE_BF)
1008 {
1009 char *mask = data.mask;
1010
1011 if (mask != NULL)
1012 {
1013 uint mask_len = data.css_cnt;
1014
1015 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1016
1017 if (mask_len > 0)
1018 {
1019 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1020 {
1021 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1022 {
1023 mask_len -= data.salts_buf[0].salt_len;
1024 }
1025 }
1026
1027 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1028
1029 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1030 }
1031
1032 if (data.maskcnt > 1)
1033 {
1034 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1035
1036 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1037 }
1038
1039 log_info ("Input.Mode.....: %s", tmp_buf);
1040 }
1041
1042 tmp_len = 0;
1043 }
1044 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1045 {
1046 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1047 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1048 }
1049 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1050 {
1051 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1052 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1053 }
1054
1055 if (data.digests_cnt == 1)
1056 {
1057 if (data.hash_mode == 2500)
1058 {
1059 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1060
1061 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1062 (char *) data.salts_buf[0].salt_buf,
1063 wpa->orig_mac1[0],
1064 wpa->orig_mac1[1],
1065 wpa->orig_mac1[2],
1066 wpa->orig_mac1[3],
1067 wpa->orig_mac1[4],
1068 wpa->orig_mac1[5],
1069 wpa->orig_mac2[0],
1070 wpa->orig_mac2[1],
1071 wpa->orig_mac2[2],
1072 wpa->orig_mac2[3],
1073 wpa->orig_mac2[4],
1074 wpa->orig_mac2[5]);
1075 }
1076 else if (data.hash_mode == 5200)
1077 {
1078 log_info ("Hash.Target....: File (%s)", data.hashfile);
1079 }
1080 else if (data.hash_mode == 9000)
1081 {
1082 log_info ("Hash.Target....: File (%s)", data.hashfile);
1083 }
1084 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1085 {
1086 log_info ("Hash.Target....: File (%s)", data.hashfile);
1087 }
1088 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1089 {
1090 log_info ("Hash.Target....: File (%s)", data.hashfile);
1091 }
1092 else
1093 {
1094 char out_buf[HCBUFSIZ] = { 0 };
1095
1096 ascii_digest (out_buf, 0, 0);
1097
1098 // limit length
1099 if (strlen (out_buf) > 40)
1100 {
1101 out_buf[41] = '.';
1102 out_buf[42] = '.';
1103 out_buf[43] = '.';
1104 out_buf[44] = 0;
1105 }
1106
1107 log_info ("Hash.Target....: %s", out_buf);
1108 }
1109 }
1110 else
1111 {
1112 if (data.hash_mode == 3000)
1113 {
1114 char out_buf1[32] = { 0 };
1115 char out_buf2[32] = { 0 };
1116
1117 ascii_digest (out_buf1, 0, 0);
1118 ascii_digest (out_buf2, 0, 1);
1119
1120 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1121 }
1122 else
1123 {
1124 log_info ("Hash.Target....: File (%s)", data.hashfile);
1125 }
1126 }
1127
1128 log_info ("Hash.Type......: %s", hash_type);
1129
1130 /**
1131 * speed new
1132 */
1133
1134 u64 speed_cnt[DEVICES_MAX] = { 0 };
1135 double speed_ms[DEVICES_MAX] = { 0 };
1136
1137 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1138 {
1139 hc_device_param_t *device_param = &data.devices_param[device_id];
1140
1141 if (device_param->skipped) continue;
1142
1143 speed_cnt[device_id] = 0;
1144 speed_ms[device_id] = 0;
1145
1146 for (int i = 0; i < SPEED_CACHE; i++)
1147 {
1148 speed_cnt[device_id] += device_param->speed_cnt[i];
1149 speed_ms[device_id] += device_param->speed_ms[i];
1150 }
1151
1152 speed_cnt[device_id] /= SPEED_CACHE;
1153 speed_ms[device_id] /= SPEED_CACHE;
1154 }
1155
1156 double hashes_all_ms = 0;
1157
1158 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1159
1160 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1161 {
1162 hc_device_param_t *device_param = &data.devices_param[device_id];
1163
1164 if (device_param->skipped) continue;
1165
1166 hashes_dev_ms[device_id] = 0;
1167
1168 if (speed_ms[device_id])
1169 {
1170 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1171
1172 hashes_all_ms += hashes_dev_ms[device_id];
1173 }
1174 }
1175
1176 /**
1177 * exec time
1178 */
1179
1180 double exec_all_ms[DEVICES_MAX] = { 0 };
1181
1182 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1183 {
1184 hc_device_param_t *device_param = &data.devices_param[device_id];
1185
1186 if (device_param->skipped) continue;
1187
1188 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1189
1190 exec_all_ms[device_id] = exec_ms_avg;
1191 }
1192
1193 /**
1194 * timers
1195 */
1196
1197 double ms_running = 0;
1198
1199 hc_timer_get (data.timer_running, ms_running);
1200
1201 double ms_paused = data.ms_paused;
1202
1203 if (data.devices_status == STATUS_PAUSED)
1204 {
1205 double ms_paused_tmp = 0;
1206
1207 hc_timer_get (data.timer_paused, ms_paused_tmp);
1208
1209 ms_paused += ms_paused_tmp;
1210 }
1211
1212 #ifdef WIN
1213
1214 __time64_t sec_run = ms_running / 1000;
1215
1216 #else
1217
1218 time_t sec_run = ms_running / 1000;
1219
1220 #endif
1221
1222 if (sec_run)
1223 {
1224 char display_run[32] = { 0 };
1225
1226 struct tm tm_run;
1227
1228 struct tm *tmp = NULL;
1229
1230 #ifdef WIN
1231
1232 tmp = _gmtime64 (&sec_run);
1233
1234 #else
1235
1236 tmp = gmtime (&sec_run);
1237
1238 #endif
1239
1240 if (tmp != NULL)
1241 {
1242 memset (&tm_run, 0, sizeof (tm_run));
1243
1244 memcpy (&tm_run, tmp, sizeof (tm_run));
1245
1246 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1247
1248 char *start = ctime (&data.proc_start);
1249
1250 size_t start_len = strlen (start);
1251
1252 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1253 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1254
1255 log_info ("Time.Started...: %s (%s)", start, display_run);
1256 }
1257 }
1258 else
1259 {
1260 log_info ("Time.Started...: 0 secs");
1261 }
1262
1263 /**
1264 * counters
1265 */
1266
1267 u64 progress_total = data.words_cnt * data.salts_cnt;
1268
1269 u64 all_done = 0;
1270 u64 all_rejected = 0;
1271 u64 all_restored = 0;
1272
1273 u64 progress_noneed = 0;
1274
1275 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1276 {
1277 all_done += data.words_progress_done[salt_pos];
1278 all_rejected += data.words_progress_rejected[salt_pos];
1279 all_restored += data.words_progress_restored[salt_pos];
1280
1281 // Important for ETA only
1282
1283 if (data.salts_shown[salt_pos] == 1)
1284 {
1285 const u64 all = data.words_progress_done[salt_pos]
1286 + data.words_progress_rejected[salt_pos]
1287 + data.words_progress_restored[salt_pos];
1288
1289 const u64 left = data.words_cnt - all;
1290
1291 progress_noneed += left;
1292 }
1293 }
1294
1295 u64 progress_cur = all_restored + all_done + all_rejected;
1296 u64 progress_end = progress_total;
1297
1298 u64 progress_skip = 0;
1299
1300 if (data.skip)
1301 {
1302 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1303
1304 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1305 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1306 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1307 }
1308
1309 if (data.limit)
1310 {
1311 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1312
1313 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1314 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1315 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1316 }
1317
1318 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1319 u64 progress_end_relative_skip = progress_end - progress_skip;
1320
1321 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1322 {
1323 if (data.devices_status != STATUS_CRACKED)
1324 {
1325 #ifdef WIN
1326 __time64_t sec_etc = 0;
1327 #else
1328 time_t sec_etc = 0;
1329 #endif
1330
1331 if (hashes_all_ms)
1332 {
1333 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1334
1335 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1336
1337 sec_etc = ms_left / 1000;
1338 }
1339
1340 if (sec_etc == 0)
1341 {
1342 //log_info ("Time.Estimated.: 0 secs");
1343 }
1344 else if ((u64) sec_etc > ETC_MAX)
1345 {
1346 log_info ("Time.Estimated.: > 10 Years");
1347 }
1348 else
1349 {
1350 char display_etc[32] = { 0 };
1351
1352 struct tm tm_etc;
1353
1354 struct tm *tmp = NULL;
1355
1356 #ifdef WIN
1357
1358 tmp = _gmtime64 (&sec_etc);
1359
1360 #else
1361
1362 tmp = gmtime (&sec_etc);
1363
1364 #endif
1365
1366 if (tmp != NULL)
1367 {
1368 memset (&tm_etc, 0, sizeof (tm_etc));
1369
1370 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1371
1372 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1373
1374 time_t now;
1375
1376 time (&now);
1377
1378 now += sec_etc;
1379
1380 char *etc = ctime (&now);
1381
1382 size_t etc_len = strlen (etc);
1383
1384 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1385 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1386
1387 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1388 }
1389 }
1390 }
1391 }
1392
1393 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1394 {
1395 hc_device_param_t *device_param = &data.devices_param[device_id];
1396
1397 if (device_param->skipped) continue;
1398
1399 char display_dev_cur[16] = { 0 };
1400
1401 strncpy (display_dev_cur, "0.00", 4);
1402
1403 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1404
1405 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1406 }
1407
1408 char display_all_cur[16] = { 0 };
1409
1410 strncpy (display_all_cur, "0.00", 4);
1411
1412 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1413
1414 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1415
1416 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1417 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1418
1419 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);
1420
1421 // crack-per-time
1422
1423 if (data.digests_cnt > 100)
1424 {
1425 time_t now = time (NULL);
1426
1427 int cpt_cur_min = 0;
1428 int cpt_cur_hour = 0;
1429 int cpt_cur_day = 0;
1430
1431 for (int i = 0; i < CPT_BUF; i++)
1432 {
1433 const uint cracked = data.cpt_buf[i].cracked;
1434 const time_t timestamp = data.cpt_buf[i].timestamp;
1435
1436 if ((timestamp + 60) > now)
1437 {
1438 cpt_cur_min += cracked;
1439 }
1440
1441 if ((timestamp + 3600) > now)
1442 {
1443 cpt_cur_hour += cracked;
1444 }
1445
1446 if ((timestamp + 86400) > now)
1447 {
1448 cpt_cur_day += cracked;
1449 }
1450 }
1451
1452 double ms_real = ms_running - ms_paused;
1453
1454 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1455 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1456 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1457
1458 if ((data.cpt_start + 86400) < now)
1459 {
1460 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1461 cpt_cur_min,
1462 cpt_cur_hour,
1463 cpt_cur_day,
1464 cpt_avg_min,
1465 cpt_avg_hour,
1466 cpt_avg_day);
1467 }
1468 else if ((data.cpt_start + 3600) < now)
1469 {
1470 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1471 cpt_cur_min,
1472 cpt_cur_hour,
1473 cpt_avg_min,
1474 cpt_avg_hour,
1475 cpt_avg_day);
1476 }
1477 else if ((data.cpt_start + 60) < now)
1478 {
1479 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1480 cpt_cur_min,
1481 cpt_avg_min,
1482 cpt_avg_hour,
1483 cpt_avg_day);
1484 }
1485 else
1486 {
1487 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1488 cpt_avg_min,
1489 cpt_avg_hour,
1490 cpt_avg_day);
1491 }
1492 }
1493
1494 // Restore point
1495
1496 u64 restore_point = get_lowest_words_done ();
1497
1498 u64 restore_total = data.words_base;
1499
1500 float percent_restore = 0;
1501
1502 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1503
1504 if (progress_end_relative_skip)
1505 {
1506 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1507 {
1508 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1509 float percent_rejected = 0.0;
1510
1511 if (progress_cur)
1512 {
1513 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1514 }
1515
1516 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);
1517 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1518
1519 if (data.restore_disable == 0)
1520 {
1521 if (percent_finished != 1)
1522 {
1523 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1524 }
1525 }
1526 }
1527 }
1528 else
1529 {
1530 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1531 {
1532 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1533 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1534
1535 if (data.restore_disable == 0)
1536 {
1537 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1538 }
1539 }
1540 else
1541 {
1542 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1543 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1544
1545 // --restore not allowed if stdin is used -- really? why?
1546
1547 //if (data.restore_disable == 0)
1548 //{
1549 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1550 //}
1551 }
1552 }
1553
1554 #ifdef HAVE_HWMON
1555
1556 if (data.devices_status == STATUS_EXHAUSTED) return;
1557 if (data.devices_status == STATUS_CRACKED) return;
1558 if (data.devices_status == STATUS_ABORTED) return;
1559 if (data.devices_status == STATUS_QUIT) return;
1560
1561 if (data.gpu_temp_disable == 0)
1562 {
1563 hc_thread_mutex_lock (mux_adl);
1564
1565 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1566 {
1567 hc_device_param_t *device_param = &data.devices_param[device_id];
1568
1569 if (device_param->skipped) continue;
1570
1571 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1572 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1573 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1574 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1575 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1576 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1577 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1578
1579 char output_buf[256] = { 0 };
1580
1581 int output_len = 0;
1582
1583 if (num_temperature >= 0)
1584 {
1585 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1586
1587 output_len = strlen (output_buf);
1588 }
1589
1590 if (num_fanspeed >= 0)
1591 {
1592 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1593
1594 output_len = strlen (output_buf);
1595 }
1596
1597 if (num_utilization >= 0)
1598 {
1599 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1600
1601 output_len = strlen (output_buf);
1602 }
1603
1604 if (num_corespeed >= 0)
1605 {
1606 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1607
1608 output_len = strlen (output_buf);
1609 }
1610
1611 if (num_memoryspeed >= 0)
1612 {
1613 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1614
1615 output_len = strlen (output_buf);
1616 }
1617
1618 if (num_buslanes >= 0)
1619 {
1620 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1621
1622 output_len = strlen (output_buf);
1623 }
1624
1625 if (num_throttle == 1)
1626 {
1627 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1628
1629 output_len = strlen (output_buf);
1630 }
1631
1632 if (output_len == 0)
1633 {
1634 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1635
1636 output_len = strlen (output_buf);
1637 }
1638
1639 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1640 }
1641
1642 hc_thread_mutex_unlock (mux_adl);
1643 }
1644
1645 #endif // HAVE_HWMON
1646 }
1647
1648 static void status_benchmark_automate ()
1649 {
1650 u64 speed_cnt[DEVICES_MAX] = { 0 };
1651 double speed_ms[DEVICES_MAX] = { 0 };
1652
1653 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1654 {
1655 hc_device_param_t *device_param = &data.devices_param[device_id];
1656
1657 if (device_param->skipped) continue;
1658
1659 speed_cnt[device_id] = device_param->speed_cnt[0];
1660 speed_ms[device_id] = device_param->speed_ms[0];
1661 }
1662
1663 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1664
1665 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1666 {
1667 hc_device_param_t *device_param = &data.devices_param[device_id];
1668
1669 if (device_param->skipped) continue;
1670
1671 hashes_dev_ms[device_id] = 0;
1672
1673 if (speed_ms[device_id])
1674 {
1675 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1676 }
1677 }
1678
1679 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1680 {
1681 hc_device_param_t *device_param = &data.devices_param[device_id];
1682
1683 if (device_param->skipped) continue;
1684
1685 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1686 }
1687 }
1688
1689 static void status_benchmark ()
1690 {
1691 if (data.devices_status == STATUS_INIT) return;
1692 if (data.devices_status == STATUS_STARTING) return;
1693
1694 if (data.machine_readable == 1)
1695 {
1696 status_benchmark_automate ();
1697
1698 return;
1699 }
1700
1701 u64 speed_cnt[DEVICES_MAX] = { 0 };
1702 double speed_ms[DEVICES_MAX] = { 0 };
1703
1704 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1705 {
1706 hc_device_param_t *device_param = &data.devices_param[device_id];
1707
1708 if (device_param->skipped) continue;
1709
1710 speed_cnt[device_id] = device_param->speed_cnt[0];
1711 speed_ms[device_id] = device_param->speed_ms[0];
1712 }
1713
1714 double hashes_all_ms = 0;
1715
1716 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1717
1718 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1719 {
1720 hc_device_param_t *device_param = &data.devices_param[device_id];
1721
1722 if (device_param->skipped) continue;
1723
1724 hashes_dev_ms[device_id] = 0;
1725
1726 if (speed_ms[device_id])
1727 {
1728 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1729
1730 hashes_all_ms += hashes_dev_ms[device_id];
1731 }
1732 }
1733
1734 /**
1735 * exec time
1736 */
1737
1738 double exec_all_ms[DEVICES_MAX] = { 0 };
1739
1740 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1741 {
1742 hc_device_param_t *device_param = &data.devices_param[device_id];
1743
1744 if (device_param->skipped) continue;
1745
1746 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1747
1748 exec_all_ms[device_id] = exec_ms_avg;
1749 }
1750
1751 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1752 {
1753 hc_device_param_t *device_param = &data.devices_param[device_id];
1754
1755 if (device_param->skipped) continue;
1756
1757 char display_dev_cur[16] = { 0 };
1758
1759 strncpy (display_dev_cur, "0.00", 4);
1760
1761 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1762
1763 if (data.devices_active >= 10)
1764 {
1765 log_info ("Speed.Dev.#%d: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1766 }
1767 else
1768 {
1769 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1770 }
1771 }
1772
1773 char display_all_cur[16] = { 0 };
1774
1775 strncpy (display_all_cur, "0.00", 4);
1776
1777 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1778
1779 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1780 }
1781
1782 /**
1783 * hashcat -only- functions
1784 */
1785
1786 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1787 {
1788 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1789 {
1790 if (attack_kern == ATTACK_KERN_STRAIGHT)
1791 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1792 else if (attack_kern == ATTACK_KERN_COMBI)
1793 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1794 else if (attack_kern == ATTACK_KERN_BF)
1795 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1796 }
1797 else
1798 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1799 }
1800
1801 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)
1802 {
1803 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1804 {
1805 if (attack_kern == ATTACK_KERN_STRAIGHT)
1806 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1807 else if (attack_kern == ATTACK_KERN_COMBI)
1808 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1809 else if (attack_kern == ATTACK_KERN_BF)
1810 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1811 }
1812 else
1813 {
1814 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1815 }
1816 }
1817
1818 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1819 {
1820 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1821 {
1822 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1823 }
1824 else
1825 {
1826 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1827 }
1828 }
1829
1830 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)
1831 {
1832 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1833 {
1834 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1835 }
1836 else
1837 {
1838 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1839 }
1840 }
1841
1842 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1843 {
1844 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1845 }
1846
1847 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1848 {
1849 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1850 }
1851
1852 static char *filename_from_filepath (char *filepath)
1853 {
1854 char *ptr = NULL;
1855
1856 if ((ptr = strrchr (filepath, '/')) != NULL)
1857 {
1858 ptr++;
1859 }
1860 else if ((ptr = strrchr (filepath, '\\')) != NULL)
1861 {
1862 ptr++;
1863 }
1864 else
1865 {
1866 ptr = filepath;
1867 }
1868
1869 return ptr;
1870 }
1871
1872 static uint convert_from_hex (char *line_buf, const uint line_len)
1873 {
1874 if (line_len & 1) return (line_len); // not in hex
1875
1876 if (data.hex_wordlist == 1)
1877 {
1878 uint i;
1879 uint j;
1880
1881 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1882 {
1883 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1884 }
1885
1886 memset (line_buf + i, 0, line_len - i);
1887
1888 return (i);
1889 }
1890 else if (line_len >= 6) // $HEX[] = 6
1891 {
1892 if (line_buf[0] != '$') return (line_len);
1893 if (line_buf[1] != 'H') return (line_len);
1894 if (line_buf[2] != 'E') return (line_len);
1895 if (line_buf[3] != 'X') return (line_len);
1896 if (line_buf[4] != '[') return (line_len);
1897 if (line_buf[line_len - 1] != ']') return (line_len);
1898
1899 uint i;
1900 uint j;
1901
1902 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1903 {
1904 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1905 }
1906
1907 memset (line_buf + i, 0, line_len - i);
1908
1909 return (i);
1910 }
1911
1912 return (line_len);
1913 }
1914
1915 static void clear_prompt ()
1916 {
1917 fputc ('\r', stdout);
1918
1919 for (size_t i = 0; i < strlen (PROMPT); i++)
1920 {
1921 fputc (' ', stdout);
1922 }
1923
1924 fputc ('\r', stdout);
1925
1926 fflush (stdout);
1927 }
1928
1929 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1930 {
1931 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);
1932 }
1933
1934 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1935 {
1936 char *outfile = data.outfile;
1937 uint quiet = data.quiet;
1938 FILE *pot_fp = data.pot_fp;
1939 uint loopback = data.loopback;
1940 uint debug_mode = data.debug_mode;
1941 char *debug_file = data.debug_file;
1942
1943 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1944 int debug_rule_len = 0; // -1 error
1945 uint debug_plain_len = 0;
1946
1947 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1948
1949 // hash
1950
1951 char out_buf[HCBUFSIZ] = { 0 };
1952
1953 const u32 salt_pos = plain->salt_pos;
1954 const u32 digest_pos = plain->digest_pos; // relative
1955 const u32 gidvid = plain->gidvid;
1956 const u32 il_pos = plain->il_pos;
1957
1958 ascii_digest (out_buf, salt_pos, digest_pos);
1959
1960 // plain
1961
1962 u64 crackpos = device_param->words_off;
1963
1964 uint plain_buf[16] = { 0 };
1965
1966 u8 *plain_ptr = (u8 *) plain_buf;
1967
1968 unsigned int plain_len = 0;
1969
1970 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1971 {
1972 pw_t pw;
1973
1974 gidd_to_pw_t (device_param, gidvid, &pw);
1975
1976 for (int i = 0; i < 16; i++)
1977 {
1978 plain_buf[i] = pw.i[i];
1979 }
1980
1981 plain_len = pw.pw_len;
1982
1983 const uint off = device_param->innerloop_pos + il_pos;
1984
1985 if (debug_mode > 0)
1986 {
1987 debug_rule_len = 0;
1988
1989 // save rule
1990 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1991 {
1992 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1993
1994 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1995 }
1996
1997 // save plain
1998 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1999 {
2000 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
2001
2002 memcpy (debug_plain_ptr, plain_ptr, plain_len);
2003
2004 debug_plain_len = plain_len;
2005 }
2006 }
2007
2008 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2009
2010 crackpos += gidvid;
2011 crackpos *= data.kernel_rules_cnt;
2012 crackpos += device_param->innerloop_pos + il_pos;
2013
2014 if (plain_len > data.pw_max) plain_len = data.pw_max;
2015 }
2016 else if (data.attack_mode == ATTACK_MODE_COMBI)
2017 {
2018 pw_t pw;
2019
2020 gidd_to_pw_t (device_param, gidvid, &pw);
2021
2022 for (int i = 0; i < 16; i++)
2023 {
2024 plain_buf[i] = pw.i[i];
2025 }
2026
2027 plain_len = pw.pw_len;
2028
2029 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2030 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2031
2032 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2033 {
2034 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2035 }
2036 else
2037 {
2038 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2039
2040 memcpy (plain_ptr, comb_buf, comb_len);
2041 }
2042
2043 plain_len += comb_len;
2044
2045 crackpos += gidvid;
2046 crackpos *= data.combs_cnt;
2047 crackpos += device_param->innerloop_pos + il_pos;
2048
2049 if (data.pw_max != PW_DICTMAX1)
2050 {
2051 if (plain_len > data.pw_max) plain_len = data.pw_max;
2052 }
2053 }
2054 else if (data.attack_mode == ATTACK_MODE_BF)
2055 {
2056 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2057 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2058
2059 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2060 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2061
2062 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2063 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2064
2065 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2066 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2067
2068 plain_len = data.css_cnt;
2069
2070 crackpos += gidvid;
2071 crackpos *= data.bfs_cnt;
2072 crackpos += device_param->innerloop_pos + il_pos;
2073 }
2074 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2075 {
2076 pw_t pw;
2077
2078 gidd_to_pw_t (device_param, gidvid, &pw);
2079
2080 for (int i = 0; i < 16; i++)
2081 {
2082 plain_buf[i] = pw.i[i];
2083 }
2084
2085 plain_len = pw.pw_len;
2086
2087 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2088
2089 uint start = 0;
2090 uint stop = device_param->kernel_params_mp_buf32[4];
2091
2092 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2093
2094 plain_len += start + stop;
2095
2096 crackpos += gidvid;
2097 crackpos *= data.combs_cnt;
2098 crackpos += device_param->innerloop_pos + il_pos;
2099
2100 if (data.pw_max != PW_DICTMAX1)
2101 {
2102 if (plain_len > data.pw_max) plain_len = data.pw_max;
2103 }
2104 }
2105 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2106 {
2107 pw_t pw;
2108
2109 gidd_to_pw_t (device_param, gidvid, &pw);
2110
2111 for (int i = 0; i < 16; i++)
2112 {
2113 plain_buf[i] = pw.i[i];
2114 }
2115
2116 plain_len = pw.pw_len;
2117
2118 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2119
2120 uint start = 0;
2121 uint stop = device_param->kernel_params_mp_buf32[4];
2122
2123 memmove (plain_ptr + stop, plain_ptr, plain_len);
2124
2125 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2126
2127 plain_len += start + stop;
2128
2129 crackpos += gidvid;
2130 crackpos *= data.combs_cnt;
2131 crackpos += device_param->innerloop_pos + il_pos;
2132
2133 if (data.pw_max != PW_DICTMAX1)
2134 {
2135 if (plain_len > data.pw_max) plain_len = data.pw_max;
2136 }
2137 }
2138
2139 if (data.attack_mode == ATTACK_MODE_BF)
2140 {
2141 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2142 {
2143 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2144 {
2145 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2146 {
2147 plain_len = plain_len - data.salts_buf[0].salt_len;
2148 }
2149 }
2150
2151 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2152 {
2153 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2154 {
2155 plain_ptr[j] = plain_ptr[i];
2156 }
2157
2158 plain_len = plain_len / 2;
2159 }
2160 }
2161 }
2162
2163 // if enabled, update also the potfile
2164
2165 if (pot_fp)
2166 {
2167 lock_file (pot_fp);
2168
2169 fprintf (pot_fp, "%s:", out_buf);
2170
2171 format_plain (pot_fp, plain_ptr, plain_len, 1);
2172
2173 fputc ('\n', pot_fp);
2174
2175 fflush (pot_fp);
2176
2177 unlock_file (pot_fp);
2178 }
2179
2180 // outfile
2181
2182 FILE *out_fp = NULL;
2183
2184 if (outfile != NULL)
2185 {
2186 if ((out_fp = fopen (outfile, "ab")) == NULL)
2187 {
2188 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2189
2190 out_fp = stdout;
2191 }
2192
2193 lock_file (out_fp);
2194 }
2195 else
2196 {
2197 out_fp = stdout;
2198
2199 if (quiet == 0) clear_prompt ();
2200 }
2201
2202 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2203
2204 if (outfile != NULL)
2205 {
2206 if (out_fp != stdout)
2207 {
2208 fclose (out_fp);
2209 }
2210 }
2211 else
2212 {
2213 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2214 {
2215 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2216 {
2217 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2218 if (quiet == 0) fflush (stdout);
2219 }
2220 }
2221 }
2222
2223 // loopback
2224
2225 if (loopback)
2226 {
2227 char *loopback_file = data.loopback_file;
2228
2229 FILE *fb_fp = NULL;
2230
2231 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2232 {
2233 lock_file (fb_fp);
2234
2235 format_plain (fb_fp, plain_ptr, plain_len, 1);
2236
2237 fputc ('\n', fb_fp);
2238
2239 fclose (fb_fp);
2240 }
2241 }
2242
2243 // (rule) debug mode
2244
2245 // the next check implies that:
2246 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2247 // - debug_mode > 0
2248
2249 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2250 {
2251 if (debug_rule_len < 0) debug_rule_len = 0;
2252
2253 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2254
2255 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2256
2257 if ((quiet == 0) && (debug_file == NULL))
2258 {
2259 fprintf (stdout, "%s", PROMPT);
2260
2261 fflush (stdout);
2262 }
2263 }
2264 }
2265
2266 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2267 {
2268 salt_t *salt_buf = &data.salts_buf[salt_pos];
2269
2270 u32 num_cracked;
2271
2272 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2273
2274 if (num_cracked)
2275 {
2276 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2277
2278 log_info_nn ("");
2279
2280 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2281
2282 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);
2283
2284 uint cpt_cracked = 0;
2285
2286 hc_thread_mutex_lock (mux_display);
2287
2288 for (uint i = 0; i < num_cracked; i++)
2289 {
2290 const uint hash_pos = cracked[i].hash_pos;
2291
2292 if (data.digests_shown[hash_pos] == 1) continue;
2293
2294 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2295 {
2296 data.digests_shown[hash_pos] = 1;
2297
2298 data.digests_done++;
2299
2300 cpt_cracked++;
2301
2302 salt_buf->digests_done++;
2303
2304 if (salt_buf->digests_done == salt_buf->digests_cnt)
2305 {
2306 data.salts_shown[salt_pos] = 1;
2307
2308 data.salts_done++;
2309 }
2310 }
2311
2312 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2313
2314 check_hash (device_param, &cracked[i]);
2315 }
2316
2317 hc_thread_mutex_unlock (mux_display);
2318
2319 myfree (cracked);
2320
2321 if (cpt_cracked > 0)
2322 {
2323 hc_thread_mutex_lock (mux_display);
2324
2325 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2326 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2327
2328 data.cpt_pos++;
2329
2330 data.cpt_total += cpt_cracked;
2331
2332 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2333
2334 hc_thread_mutex_unlock (mux_display);
2335 }
2336
2337 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2338 {
2339 // we need to reset cracked state on the device
2340 // otherwise host thinks again and again the hash was cracked
2341 // and returns invalid password each time
2342
2343 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2344
2345 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);
2346 }
2347
2348 num_cracked = 0;
2349
2350 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2351 }
2352 }
2353
2354 // stolen from princeprocessor ;)
2355
2356 typedef struct
2357 {
2358 FILE *fp;
2359
2360 char buf[BUFSIZ];
2361 int len;
2362
2363 } out_t;
2364
2365 static void out_flush (out_t *out)
2366 {
2367 fwrite (out->buf, 1, out->len, out->fp);
2368
2369 out->len = 0;
2370 }
2371
2372 static void out_push (out_t *out, const u8 *pw_buf, const int pw_len)
2373 {
2374 char *ptr = out->buf + out->len;
2375
2376 memcpy (ptr, pw_buf, pw_len);
2377
2378 ptr[pw_len] = '\n';
2379
2380 out->len += pw_len + 1;
2381
2382 if (out->len >= BUFSIZ - 100)
2383 {
2384 out_flush (out);
2385 }
2386 }
2387
2388 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2389 {
2390 out_t out;
2391
2392 out.fp = stdout;
2393 out.len = 0;
2394
2395 uint plain_buf[16] = { 0 };
2396
2397 u8 *plain_ptr = (u8 *) plain_buf;
2398
2399 uint plain_len = 0;
2400
2401 const uint il_cnt = device_param->kernel_params_buf32[27]; // ugly, i know
2402
2403 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2404 {
2405 pw_t pw;
2406
2407 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2408 {
2409 gidd_to_pw_t (device_param, gidvid, &pw);
2410
2411 const uint pos = device_param->innerloop_pos;
2412
2413 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2414 {
2415 for (int i = 0; i < 8; i++)
2416 {
2417 plain_buf[i] = pw.i[i];
2418 }
2419
2420 plain_len = pw.pw_len;
2421
2422 plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2423
2424 if (plain_len > data.pw_max) plain_len = data.pw_max;
2425
2426 out_push (&out, plain_ptr, plain_len);
2427 }
2428 }
2429 }
2430 else if (data.attack_mode == ATTACK_MODE_COMBI)
2431 {
2432 pw_t pw;
2433
2434 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2435 {
2436 gidd_to_pw_t (device_param, gidvid, &pw);
2437
2438 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2439 {
2440 for (int i = 0; i < 8; i++)
2441 {
2442 plain_buf[i] = pw.i[i];
2443 }
2444
2445 plain_len = pw.pw_len;
2446
2447 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2448 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2449
2450 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2451 {
2452 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2453 }
2454 else
2455 {
2456 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2457
2458 memcpy (plain_ptr, comb_buf, comb_len);
2459 }
2460
2461 plain_len += comb_len;
2462
2463 if (data.pw_max != PW_DICTMAX1)
2464 {
2465 if (plain_len > data.pw_max) plain_len = data.pw_max;
2466 }
2467
2468 out_push (&out, plain_ptr, plain_len);
2469 }
2470 }
2471 }
2472 else if (data.attack_mode == ATTACK_MODE_BF)
2473 {
2474 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2475 {
2476 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2477 {
2478 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2479 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2480
2481 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2482 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2483
2484 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2485 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2486
2487 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2488 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2489
2490 plain_len = data.css_cnt;
2491
2492 out_push (&out, plain_ptr, plain_len);
2493 }
2494 }
2495 }
2496 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2497 {
2498 pw_t pw;
2499
2500 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2501 {
2502 gidd_to_pw_t (device_param, gidvid, &pw);
2503
2504 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2505 {
2506 for (int i = 0; i < 8; i++)
2507 {
2508 plain_buf[i] = pw.i[i];
2509 }
2510
2511 plain_len = pw.pw_len;
2512
2513 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2514
2515 uint start = 0;
2516 uint stop = device_param->kernel_params_mp_buf32[4];
2517
2518 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2519
2520 plain_len += start + stop;
2521
2522 out_push (&out, plain_ptr, plain_len);
2523 }
2524 }
2525 }
2526 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2527 {
2528 pw_t pw;
2529
2530 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2531 {
2532 gidd_to_pw_t (device_param, gidvid, &pw);
2533
2534 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2535 {
2536 for (int i = 0; i < 8; i++)
2537 {
2538 plain_buf[i] = pw.i[i];
2539 }
2540
2541 plain_len = pw.pw_len;
2542
2543 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2544
2545 uint start = 0;
2546 uint stop = device_param->kernel_params_mp_buf32[4];
2547
2548 memmove (plain_ptr + stop, plain_ptr, plain_len);
2549
2550 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2551
2552 plain_len += start + stop;
2553
2554 out_push (&out, plain_ptr, plain_len);
2555 }
2556 }
2557 }
2558
2559 out_flush (&out);
2560 }
2561
2562 static void save_hash ()
2563 {
2564 char *hashfile = data.hashfile;
2565
2566 char new_hashfile[256] = { 0 };
2567 char old_hashfile[256] = { 0 };
2568
2569 snprintf (new_hashfile, 255, "%s.new", hashfile);
2570 snprintf (old_hashfile, 255, "%s.old", hashfile);
2571
2572 unlink (new_hashfile);
2573
2574 char separator = data.separator;
2575
2576 FILE *fp = fopen (new_hashfile, "wb");
2577
2578 if (fp == NULL)
2579 {
2580 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2581
2582 exit (-1);
2583 }
2584
2585 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2586 {
2587 if (data.salts_shown[salt_pos] == 1) continue;
2588
2589 salt_t *salt_buf = &data.salts_buf[salt_pos];
2590
2591 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2592 {
2593 uint idx = salt_buf->digests_offset + digest_pos;
2594
2595 if (data.digests_shown[idx] == 1) continue;
2596
2597 if (data.hash_mode != 2500)
2598 {
2599 if (data.username == 1)
2600 {
2601 user_t *user = data.hash_info[idx]->user;
2602
2603 uint i;
2604
2605 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2606
2607 fputc (separator, fp);
2608 }
2609
2610 char out_buf[HCBUFSIZ]; // scratch buffer
2611
2612 out_buf[0] = 0;
2613
2614 ascii_digest (out_buf, salt_pos, digest_pos);
2615
2616 fputs (out_buf, fp);
2617
2618 fputc ('\n', fp);
2619 }
2620 else
2621 {
2622 hccap_t hccap;
2623
2624 to_hccap_t (&hccap, salt_pos, digest_pos);
2625
2626 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2627 }
2628 }
2629 }
2630
2631 fflush (fp);
2632
2633 fclose (fp);
2634
2635 unlink (old_hashfile);
2636
2637 if (rename (hashfile, old_hashfile) != 0)
2638 {
2639 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2640
2641 exit (-1);
2642 }
2643
2644 unlink (hashfile);
2645
2646 if (rename (new_hashfile, hashfile) != 0)
2647 {
2648 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2649
2650 exit (-1);
2651 }
2652
2653 unlink (old_hashfile);
2654 }
2655
2656 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2657 {
2658 uint num_elements = num;
2659
2660 device_param->kernel_params_buf32[30] = data.combs_mode;
2661 device_param->kernel_params_buf32[31] = num;
2662
2663 uint kernel_threads = device_param->kernel_threads;
2664
2665 while (num_elements % kernel_threads) num_elements++;
2666
2667 cl_kernel kernel = NULL;
2668
2669 switch (kern_run)
2670 {
2671 case KERN_RUN_1: kernel = device_param->kernel1; break;
2672 case KERN_RUN_12: kernel = device_param->kernel12; break;
2673 case KERN_RUN_2: kernel = device_param->kernel2; break;
2674 case KERN_RUN_23: kernel = device_param->kernel23; break;
2675 case KERN_RUN_3: kernel = device_param->kernel3; break;
2676 }
2677
2678 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2679 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2680 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2681 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2682 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2683 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2684 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2685 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2686 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2687 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2688 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2689
2690 cl_event event;
2691
2692 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2693 {
2694 const size_t global_work_size[3] = { num_elements, 32, 1 };
2695 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2696
2697 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2698 }
2699 else
2700 {
2701 if (kern_run == KERN_RUN_2)
2702 {
2703 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2704 {
2705 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2706 }
2707 }
2708
2709 while (num_elements % kernel_threads) num_elements++;
2710
2711 const size_t global_work_size[3] = { num_elements, 1, 1 };
2712 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2713
2714 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2715 }
2716
2717 hc_clFlush (data.ocl, device_param->command_queue);
2718
2719 if (device_param->nvidia_spin_damp)
2720 {
2721 if (data.devices_status == STATUS_RUNNING)
2722 {
2723 if (iteration < EXPECTED_ITERATIONS)
2724 {
2725 switch (kern_run)
2726 {
2727 case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration] * device_param->nvidia_spin_damp); break;
2728 case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration] * device_param->nvidia_spin_damp); break;
2729 case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration] * device_param->nvidia_spin_damp); break;
2730 }
2731 }
2732 }
2733 }
2734
2735 hc_clWaitForEvents (data.ocl, 1, &event);
2736
2737 cl_ulong time_start;
2738 cl_ulong time_end;
2739
2740 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2741 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2742
2743 const double exec_us = (double) (time_end - time_start) / 1000;
2744
2745 if (data.devices_status == STATUS_RUNNING)
2746 {
2747 if (iteration < EXPECTED_ITERATIONS)
2748 {
2749 switch (kern_run)
2750 {
2751 case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2752 case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2753 case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2754 }
2755 }
2756 }
2757
2758 if (event_update)
2759 {
2760 uint exec_pos = device_param->exec_pos;
2761
2762 device_param->exec_ms[exec_pos] = exec_us / 1000;
2763
2764 exec_pos++;
2765
2766 if (exec_pos == EXEC_CACHE)
2767 {
2768 exec_pos = 0;
2769 }
2770
2771 device_param->exec_pos = exec_pos;
2772 }
2773
2774 hc_clReleaseEvent (data.ocl, event);
2775
2776 hc_clFinish (data.ocl, device_param->command_queue);
2777 }
2778
2779 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2780 {
2781 uint num_elements = num;
2782
2783 switch (kern_run)
2784 {
2785 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2786 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2787 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2788 }
2789
2790 // causes problems with special threads like in bcrypt
2791 // const uint kernel_threads = device_param->kernel_threads;
2792
2793 uint kernel_threads = device_param->kernel_threads;
2794
2795 while (num_elements % kernel_threads) num_elements++;
2796
2797 cl_kernel kernel = NULL;
2798
2799 switch (kern_run)
2800 {
2801 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2802 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2803 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2804 }
2805
2806 switch (kern_run)
2807 {
2808 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2809 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2810 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2811 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2812 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2813 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2814 break;
2815 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2816 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2817 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2818 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2819 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2820 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2821 break;
2822 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2823 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2824 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2825 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2826 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2827 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2828 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2829 break;
2830 }
2831
2832 const size_t global_work_size[3] = { num_elements, 1, 1 };
2833 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2834
2835 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2836
2837 hc_clFlush (data.ocl, device_param->command_queue);
2838
2839 hc_clFinish (data.ocl, device_param->command_queue);
2840 }
2841
2842 static void run_kernel_tm (hc_device_param_t *device_param)
2843 {
2844 const uint num_elements = 1024; // fixed
2845
2846 uint kernel_threads = 32;
2847
2848 cl_kernel kernel = device_param->kernel_tm;
2849
2850 const size_t global_work_size[3] = { num_elements, 1, 1 };
2851 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2852
2853 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2854
2855 hc_clFlush (data.ocl, device_param->command_queue);
2856
2857 hc_clFinish (data.ocl, device_param->command_queue);
2858 }
2859
2860 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2861 {
2862 uint num_elements = num;
2863
2864 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2865 device_param->kernel_params_amp_buf32[6] = num_elements;
2866
2867 // causes problems with special threads like in bcrypt
2868 // const uint kernel_threads = device_param->kernel_threads;
2869
2870 uint kernel_threads = device_param->kernel_threads;
2871
2872 while (num_elements % kernel_threads) num_elements++;
2873
2874 cl_kernel kernel = device_param->kernel_amp;
2875
2876 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2877 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2878
2879 const size_t global_work_size[3] = { num_elements, 1, 1 };
2880 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2881
2882 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2883
2884 hc_clFlush (data.ocl, device_param->command_queue);
2885
2886 hc_clFinish (data.ocl, device_param->command_queue);
2887 }
2888
2889 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2890 {
2891 const u32 num16d = num / 16;
2892 const u32 num16m = num % 16;
2893
2894 if (num16d)
2895 {
2896 device_param->kernel_params_memset_buf32[1] = value;
2897 device_param->kernel_params_memset_buf32[2] = num16d;
2898
2899 uint kernel_threads = device_param->kernel_threads;
2900
2901 uint num_elements = num16d;
2902
2903 while (num_elements % kernel_threads) num_elements++;
2904
2905 cl_kernel kernel = device_param->kernel_memset;
2906
2907 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2908 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2909 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2910
2911 const size_t global_work_size[3] = { num_elements, 1, 1 };
2912 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2913
2914 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2915
2916 hc_clFlush (data.ocl, device_param->command_queue);
2917
2918 hc_clFinish (data.ocl, device_param->command_queue);
2919 }
2920
2921 if (num16m)
2922 {
2923 u32 tmp[4];
2924
2925 tmp[0] = value;
2926 tmp[1] = value;
2927 tmp[2] = value;
2928 tmp[3] = value;
2929
2930 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2931 }
2932 }
2933
2934 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2935 {
2936 run_kernel_memset (device_param, buf, 0, size);
2937
2938 /*
2939 int rc = -1;
2940
2941 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2942 {
2943 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2944
2945 const cl_uchar zero = 0;
2946
2947 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2948 }
2949
2950 if (rc != 0)
2951 {
2952 // NOTE: clEnqueueFillBuffer () always fails with -59
2953 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2954 // How's that possible, OpenCL 1.2 support is advertised??
2955 // We need to workaround...
2956
2957 #define FILLSZ 0x100000
2958
2959 char *tmp = (char *) mymalloc (FILLSZ);
2960
2961 for (size_t i = 0; i < size; i += FILLSZ)
2962 {
2963 const size_t left = size - i;
2964
2965 const size_t fillsz = MIN (FILLSZ, left);
2966
2967 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2968 }
2969
2970 myfree (tmp);
2971 }
2972 */
2973 }
2974
2975 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)
2976 {
2977 if (data.hash_mode == 2000)
2978 {
2979 process_stdout (device_param, pws_cnt);
2980
2981 return;
2982 }
2983
2984 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2985 {
2986 if (attack_mode == ATTACK_MODE_BF)
2987 {
2988 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2989 {
2990 const uint size_tm = 32 * sizeof (bs_word_t);
2991
2992 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2993
2994 run_kernel_tm (device_param);
2995
2996 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);
2997 }
2998 }
2999
3000 if (highest_pw_len < 16)
3001 {
3002 run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
3003 }
3004 else if (highest_pw_len < 32)
3005 {
3006 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
3007 }
3008 else
3009 {
3010 run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
3011 }
3012 }
3013 else
3014 {
3015 run_kernel_amp (device_param, pws_cnt);
3016
3017 run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
3018
3019 if (opts_type & OPTS_TYPE_HOOK12)
3020 {
3021 run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
3022
3023 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);
3024
3025 // do something with data
3026
3027 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);
3028 }
3029
3030 uint iter = salt_buf->salt_iter;
3031
3032 uint loop_step = device_param->kernel_loops;
3033
3034 for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
3035 {
3036 uint loop_left = iter - loop_pos;
3037
3038 loop_left = MIN (loop_left, loop_step);
3039
3040 device_param->kernel_params_buf32[25] = loop_pos;
3041 device_param->kernel_params_buf32[26] = loop_left;
3042
3043 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
3044
3045 if (data.devices_status == STATUS_CRACKED) break;
3046 if (data.devices_status == STATUS_ABORTED) break;
3047 if (data.devices_status == STATUS_QUIT) break;
3048
3049 /**
3050 * speed
3051 */
3052
3053 const float iter_part = (float) (loop_pos + loop_left) / iter;
3054
3055 const u64 perf_sum_all = pws_cnt * iter_part;
3056
3057 double speed_ms;
3058
3059 hc_timer_get (device_param->timer_speed, speed_ms);
3060
3061 const u32 speed_pos = device_param->speed_pos;
3062
3063 device_param->speed_cnt[speed_pos] = perf_sum_all;
3064
3065 device_param->speed_ms[speed_pos] = speed_ms;
3066
3067 if (data.benchmark == 1)
3068 {
3069 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
3070 }
3071 }
3072
3073 if (opts_type & OPTS_TYPE_HOOK23)
3074 {
3075 run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
3076
3077 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);
3078
3079 // do something with data
3080
3081 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);
3082 }
3083
3084 run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3085 }
3086 }
3087
3088 static int run_rule_engine (const int rule_len, const char *rule_buf)
3089 {
3090 if (rule_len == 0)
3091 {
3092 return 0;
3093 }
3094 else if (rule_len == 1)
3095 {
3096 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3097 }
3098
3099 return 1;
3100 }
3101
3102 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3103 {
3104 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3105 {
3106 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);
3107 }
3108 else if (data.attack_kern == ATTACK_KERN_COMBI)
3109 {
3110 if (data.attack_mode == ATTACK_MODE_COMBI)
3111 {
3112 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3113 {
3114 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3115 {
3116 for (u32 i = 0; i < pws_cnt; i++)
3117 {
3118 const u32 pw_len = device_param->pws_buf[i].pw_len;
3119
3120 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3121
3122 ptr[pw_len] = 0x01;
3123 }
3124 }
3125 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3126 {
3127 for (u32 i = 0; i < pws_cnt; i++)
3128 {
3129 const u32 pw_len = device_param->pws_buf[i].pw_len;
3130
3131 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3132
3133 ptr[pw_len] = 0x80;
3134 }
3135 }
3136 }
3137 }
3138 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3139 {
3140 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3141 {
3142 for (u32 i = 0; i < pws_cnt; i++)
3143 {
3144 const u32 pw_len = device_param->pws_buf[i].pw_len;
3145
3146 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3147
3148 ptr[pw_len] = 0x01;
3149 }
3150 }
3151 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3152 {
3153 for (u32 i = 0; i < pws_cnt; i++)
3154 {
3155 const u32 pw_len = device_param->pws_buf[i].pw_len;
3156
3157 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3158
3159 ptr[pw_len] = 0x80;
3160 }
3161 }
3162 }
3163
3164 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);
3165 }
3166 else if (data.attack_kern == ATTACK_KERN_BF)
3167 {
3168 const u64 off = device_param->words_off;
3169
3170 device_param->kernel_params_mp_l_buf64[3] = off;
3171
3172 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3173 }
3174 }
3175
3176 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3177 {
3178 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3179
3180 device_param->kernel_params_buf32[25] = 0;
3181 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
3182 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3183
3184 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3185 {
3186 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3187 }
3188 else
3189 {
3190 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3191 }
3192
3193 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3194
3195 return exec_ms_prev;
3196 }
3197
3198 static void autotune (hc_device_param_t *device_param)
3199 {
3200 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3201
3202 const u32 kernel_accel_min = device_param->kernel_accel_min;
3203 const u32 kernel_accel_max = device_param->kernel_accel_max;
3204
3205 const u32 kernel_loops_min = device_param->kernel_loops_min;
3206 const u32 kernel_loops_max = device_param->kernel_loops_max;
3207
3208 u32 kernel_accel = kernel_accel_min;
3209 u32 kernel_loops = kernel_loops_min;
3210
3211 // in this case the user specified a fixed -u and -n on the commandline
3212 // no way to tune anything
3213 // but we need to run a few caching rounds
3214
3215 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3216 {
3217 if (data.hash_mode != 2000)
3218 {
3219 try_run (device_param, kernel_accel, kernel_loops);
3220 try_run (device_param, kernel_accel, kernel_loops);
3221 try_run (device_param, kernel_accel, kernel_loops);
3222 try_run (device_param, kernel_accel, kernel_loops);
3223 }
3224
3225 device_param->kernel_accel = kernel_accel;
3226 device_param->kernel_loops = kernel_loops;
3227
3228 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3229
3230 device_param->kernel_power = kernel_power;
3231
3232 return;
3233 }
3234
3235 // from here it's clear we are allowed to autotune
3236 // so let's init some fake words
3237
3238 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3239
3240 if (data.attack_kern == ATTACK_KERN_BF)
3241 {
3242 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3243 }
3244 else
3245 {
3246 for (u32 i = 0; i < kernel_power_max; i++)
3247 {
3248 device_param->pws_buf[i].i[0] = i;
3249 device_param->pws_buf[i].i[1] = 0x01234567;
3250 device_param->pws_buf[i].pw_len = 7 + (i & 7);
3251 }
3252
3253 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);
3254 }
3255
3256 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3257 {
3258 if (data.kernel_rules_cnt > 1)
3259 {
3260 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);
3261 }
3262 }
3263 else
3264 {
3265 run_kernel_amp (device_param, kernel_power_max);
3266 }
3267
3268 #define VERIFIER_CNT 1
3269
3270 // first find out highest kernel-loops that stays below target_ms
3271
3272 if (kernel_loops_min < kernel_loops_max)
3273 {
3274 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3275 {
3276 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3277
3278 for (int i = 0; i < VERIFIER_CNT; i++)
3279 {
3280 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3281
3282 exec_ms = MIN (exec_ms, exec_ms_v);
3283 }
3284
3285 if (exec_ms < target_ms) break;
3286 }
3287 }
3288
3289 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3290
3291 #define STEPS_CNT 10
3292
3293 if (kernel_accel_min < kernel_accel_max)
3294 {
3295 for (int i = 0; i < STEPS_CNT; i++)
3296 {
3297 const u32 kernel_accel_try = 1 << i;
3298
3299 if (kernel_accel_try < kernel_accel_min) continue;
3300 if (kernel_accel_try > kernel_accel_max) break;
3301
3302 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3303
3304 for (int i = 0; i < VERIFIER_CNT; i++)
3305 {
3306 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3307
3308 exec_ms = MIN (exec_ms, exec_ms_v);
3309 }
3310
3311 if (exec_ms > target_ms) break;
3312
3313 kernel_accel = kernel_accel_try;
3314 }
3315 }
3316
3317 // at this point we want to know the actual runtime for the following reason:
3318 // we need a reference for the balancing loop following up, and this
3319 // the balancing loop can have an effect that the creates a new opportunity, for example:
3320 // if the target is 95 ms and the current runtime is 48ms the above loop
3321 // stopped the execution because the previous exec_ms was > 95ms
3322 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3323 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3324
3325 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3326
3327 for (int i = 0; i < VERIFIER_CNT; i++)
3328 {
3329 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3330
3331 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3332 }
3333
3334 u32 diff = kernel_loops - kernel_accel;
3335
3336 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3337 {
3338 u32 kernel_accel_orig = kernel_accel;
3339 u32 kernel_loops_orig = kernel_loops;
3340
3341 for (u32 f = 1; f < 1024; f++)
3342 {
3343 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3344 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3345
3346 if (kernel_accel_try > kernel_accel_max) break;
3347 if (kernel_loops_try < kernel_loops_min) break;
3348
3349 u32 diff_new = kernel_loops_try - kernel_accel_try;
3350
3351 if (diff_new > diff) break;
3352
3353 diff_new = diff;
3354
3355 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3356
3357 for (int i = 0; i < VERIFIER_CNT; i++)
3358 {
3359 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3360
3361 exec_ms = MIN (exec_ms, exec_ms_v);
3362 }
3363
3364 if (exec_ms < exec_ms_pre_final)
3365 {
3366 exec_ms_pre_final = exec_ms;
3367
3368 kernel_accel = kernel_accel_try;
3369 kernel_loops = kernel_loops_try;
3370 }
3371 }
3372 }
3373
3374 const double exec_left = target_ms / exec_ms_pre_final;
3375
3376 const double accel_left = kernel_accel_max / kernel_accel;
3377
3378 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3379
3380 if (exec_accel_min >= 1.0)
3381 {
3382 // this is safe to not overflow kernel_accel_max because of accel_left
3383
3384 kernel_accel = (double) kernel_accel * exec_accel_min;
3385 }
3386
3387 // reset them fake words
3388
3389 /*
3390 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3391
3392 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);
3393 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);
3394 */
3395
3396 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3397
3398 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3399 {
3400 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3401 }
3402
3403 // reset timer
3404
3405 device_param->exec_pos = 0;
3406
3407 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3408
3409 memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3410 memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3411 memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3412
3413 // store
3414
3415 device_param->kernel_accel = kernel_accel;
3416 device_param->kernel_loops = kernel_loops;
3417
3418 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3419
3420 device_param->kernel_power = kernel_power;
3421
3422 #ifdef DEBUG
3423
3424 if (data.quiet == 0)
3425 {
3426 clear_prompt ();
3427
3428 log_info ("- Device #%u: autotuned kernel-accel to %u\n"
3429 "- Device #%u: autotuned kernel-loops to %u\n",
3430 device_param->device_id + 1, kernel_accel,
3431 device_param->device_id + 1, kernel_loops);
3432
3433 fprintf (stdout, "%s", PROMPT);
3434
3435 fflush (stdout);
3436 }
3437
3438 #endif
3439 }
3440
3441 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3442 {
3443 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3444
3445 // init speed timer
3446
3447 uint speed_pos = device_param->speed_pos;
3448
3449 #ifdef _POSIX
3450 if (device_param->timer_speed.tv_sec == 0)
3451 {
3452 hc_timer_set (&device_param->timer_speed);
3453 }
3454 #endif
3455
3456 #ifdef _WIN
3457 if (device_param->timer_speed.QuadPart == 0)
3458 {
3459 hc_timer_set (&device_param->timer_speed);
3460 }
3461 #endif
3462
3463 // find higest password length, this is for optimization stuff
3464
3465 uint highest_pw_len = 0;
3466
3467 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3468 {
3469 }
3470 else if (data.attack_kern == ATTACK_KERN_COMBI)
3471 {
3472 }
3473 else if (data.attack_kern == ATTACK_KERN_BF)
3474 {
3475 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3476 + device_param->kernel_params_mp_l_buf32[5];
3477 }
3478
3479 // iteration type
3480
3481 uint innerloop_step = 0;
3482 uint innerloop_cnt = 0;
3483
3484 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3485 else innerloop_step = 1;
3486
3487 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3488 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3489 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3490
3491 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3492
3493 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3494 {
3495 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3496
3497 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3498
3499 if (data.devices_status == STATUS_CRACKED) break;
3500 if (data.devices_status == STATUS_ABORTED) break;
3501 if (data.devices_status == STATUS_QUIT) break;
3502 if (data.devices_status == STATUS_BYPASS) break;
3503
3504 salt_t *salt_buf = &data.salts_buf[salt_pos];
3505
3506 device_param->kernel_params_buf32[24] = salt_pos;
3507 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3508 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3509
3510 FILE *combs_fp = device_param->combs_fp;
3511
3512 if (data.attack_mode == ATTACK_MODE_COMBI)
3513 {
3514 rewind (combs_fp);
3515 }
3516
3517 // innerloops
3518
3519 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3520 {
3521 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3522
3523 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3524
3525 if (data.devices_status == STATUS_CRACKED) break;
3526 if (data.devices_status == STATUS_ABORTED) break;
3527 if (data.devices_status == STATUS_QUIT) break;
3528 if (data.devices_status == STATUS_BYPASS) break;
3529
3530 uint fast_iteration = 0;
3531
3532 uint innerloop_left = innerloop_cnt - innerloop_pos;
3533
3534 if (innerloop_left > innerloop_step)
3535 {
3536 innerloop_left = innerloop_step;
3537
3538 fast_iteration = 1;
3539 }
3540
3541 device_param->innerloop_pos = innerloop_pos;
3542 device_param->innerloop_left = innerloop_left;
3543
3544 device_param->kernel_params_buf32[27] = innerloop_left;
3545
3546 // i think we can get rid of this
3547 if (innerloop_left == 0)
3548 {
3549 puts ("bug, how should this happen????\n");
3550
3551 continue;
3552 }
3553
3554 if (data.salts_shown[salt_pos] == 1)
3555 {
3556 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3557
3558 continue;
3559 }
3560
3561 // initialize amplifiers
3562
3563 if (data.attack_mode == ATTACK_MODE_COMBI)
3564 {
3565 uint i = 0;
3566
3567 while (i < innerloop_left)
3568 {
3569 if (feof (combs_fp)) break;
3570
3571 int line_len = fgetl (combs_fp, line_buf);
3572
3573 if (line_len >= PW_MAX1) continue;
3574
3575 line_len = convert_from_hex (line_buf, line_len);
3576
3577 char *line_buf_new = line_buf;
3578
3579 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3580 {
3581 char rule_buf_out[BLOCK_SIZE] = { 0 };
3582
3583 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3584
3585 if (rule_len_out < 0)
3586 {
3587 data.words_progress_rejected[salt_pos] += pws_cnt;
3588
3589 continue;
3590 }
3591
3592 line_len = rule_len_out;
3593
3594 line_buf_new = rule_buf_out;
3595 }
3596
3597 line_len = MIN (line_len, PW_DICTMAX);
3598
3599 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3600
3601 memcpy (ptr, line_buf_new, line_len);
3602
3603 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3604
3605 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3606 {
3607 uppercase (ptr, line_len);
3608 }
3609
3610 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3611 {
3612 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3613 {
3614 ptr[line_len] = 0x80;
3615 }
3616
3617 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3618 {
3619 ptr[line_len] = 0x01;
3620 }
3621 }
3622
3623 device_param->combs_buf[i].pw_len = line_len;
3624
3625 i++;
3626 }
3627
3628 for (uint j = i; j < innerloop_left; j++)
3629 {
3630 device_param->combs_buf[j].i[0] = 0;
3631 device_param->combs_buf[j].i[1] = 0;
3632 device_param->combs_buf[j].i[2] = 0;
3633 device_param->combs_buf[j].i[3] = 0;
3634 device_param->combs_buf[j].i[4] = 0;
3635 device_param->combs_buf[j].i[5] = 0;
3636 device_param->combs_buf[j].i[6] = 0;
3637 device_param->combs_buf[j].i[7] = 0;
3638
3639 device_param->combs_buf[j].pw_len = 0;
3640 }
3641
3642 innerloop_left = i;
3643 }
3644 else if (data.attack_mode == ATTACK_MODE_BF)
3645 {
3646 u64 off = innerloop_pos;
3647
3648 device_param->kernel_params_mp_r_buf64[3] = off;
3649
3650 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3651 }
3652 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3653 {
3654 u64 off = innerloop_pos;
3655
3656 device_param->kernel_params_mp_buf64[3] = off;
3657
3658 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3659 }
3660 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3661 {
3662 u64 off = innerloop_pos;
3663
3664 device_param->kernel_params_mp_buf64[3] = off;
3665
3666 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3667 }
3668
3669 // copy amplifiers
3670
3671 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3672 {
3673 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);
3674 }
3675 else if (data.attack_mode == ATTACK_MODE_COMBI)
3676 {
3677 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);
3678 }
3679 else if (data.attack_mode == ATTACK_MODE_BF)
3680 {
3681 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);
3682 }
3683 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3684 {
3685 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);
3686 }
3687 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3688 {
3689 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);
3690 }
3691
3692 if (data.benchmark == 1)
3693 {
3694 hc_timer_set (&device_param->timer_speed);
3695 }
3696
3697 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
3698
3699 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3700
3701 if (data.devices_status == STATUS_CRACKED) break;
3702 if (data.devices_status == STATUS_ABORTED) break;
3703 if (data.devices_status == STATUS_QUIT) break;
3704
3705 /**
3706 * result
3707 */
3708
3709 if (data.benchmark == 0)
3710 {
3711 check_cracked (device_param, salt_pos);
3712 }
3713
3714 /**
3715 * progress
3716 */
3717
3718 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3719
3720 hc_thread_mutex_lock (mux_counter);
3721
3722 data.words_progress_done[salt_pos] += perf_sum_all;
3723
3724 hc_thread_mutex_unlock (mux_counter);
3725
3726 /**
3727 * speed
3728 */
3729
3730 double speed_ms;
3731
3732 hc_timer_get (device_param->timer_speed, speed_ms);
3733
3734 hc_timer_set (&device_param->timer_speed);
3735
3736 // current speed
3737
3738 //hc_thread_mutex_lock (mux_display);
3739
3740 device_param->speed_cnt[speed_pos] = perf_sum_all;
3741
3742 device_param->speed_ms[speed_pos] = speed_ms;
3743
3744 //hc_thread_mutex_unlock (mux_display);
3745
3746 speed_pos++;
3747
3748 if (speed_pos == SPEED_CACHE)
3749 {
3750 speed_pos = 0;
3751 }
3752
3753 /**
3754 * benchmark
3755 */
3756
3757 if (data.benchmark == 1) break;
3758 }
3759 }
3760
3761 device_param->speed_pos = speed_pos;
3762
3763 myfree (line_buf);
3764 }
3765
3766 static void load_segment (wl_data_t *wl_data, FILE *fd)
3767 {
3768 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3769
3770 wl_data->pos = 0;
3771
3772 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3773
3774 wl_data->buf[wl_data->cnt] = 0;
3775
3776 if (wl_data->cnt == 0) return;
3777
3778 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3779
3780 while (!feof (fd))
3781 {
3782 if (wl_data->cnt == wl_data->avail)
3783 {
3784 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3785
3786 wl_data->avail += wl_data->incr;
3787 }
3788
3789 const int c = fgetc (fd);
3790
3791 if (c == EOF) break;
3792
3793 wl_data->buf[wl_data->cnt] = (char) c;
3794
3795 wl_data->cnt++;
3796
3797 if (c == '\n') break;
3798 }
3799
3800 // ensure stream ends with a newline
3801
3802 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3803 {
3804 wl_data->cnt++;
3805
3806 wl_data->buf[wl_data->cnt - 1] = '\n';
3807 }
3808
3809 return;
3810 }
3811
3812 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3813 {
3814 char *ptr = buf;
3815
3816 for (u32 i = 0; i < sz; i++, ptr++)
3817 {
3818 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3819
3820 if (i == 7)
3821 {
3822 *off = i;
3823 *len = i;
3824
3825 return;
3826 }
3827
3828 if (*ptr != '\n') continue;
3829
3830 *off = i + 1;
3831
3832 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3833
3834 *len = i;
3835
3836 return;
3837 }
3838
3839 *off = sz;
3840 *len = sz;
3841 }
3842
3843 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3844 {
3845 char *ptr = buf;
3846
3847 for (u32 i = 0; i < sz; i++, ptr++)
3848 {
3849 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3850
3851 if (*ptr != '\n') continue;
3852
3853 *off = i + 1;
3854
3855 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3856
3857 *len = i;
3858
3859 return;
3860 }
3861
3862 *off = sz;
3863 *len = sz;
3864 }
3865
3866 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3867 {
3868 char *ptr = buf;
3869
3870 for (u32 i = 0; i < sz; i++, ptr++)
3871 {
3872 if (*ptr != '\n') continue;
3873
3874 *off = i + 1;
3875
3876 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3877
3878 *len = i;
3879
3880 return;
3881 }
3882
3883 *off = sz;
3884 *len = sz;
3885 }
3886
3887 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3888 {
3889 while (wl_data->pos < wl_data->cnt)
3890 {
3891 uint off;
3892 uint len;
3893
3894 char *ptr = wl_data->buf + wl_data->pos;
3895
3896 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3897
3898 wl_data->pos += off;
3899
3900 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3901 {
3902 char rule_buf_out[BLOCK_SIZE] = { 0 };
3903
3904 int rule_len_out = -1;
3905
3906 if (len < BLOCK_SIZE)
3907 {
3908 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3909 }
3910
3911 if (rule_len_out < 0)
3912 {
3913 continue;
3914 }
3915
3916 if (rule_len_out > PW_MAX)
3917 {
3918 continue;
3919 }
3920 }
3921 else
3922 {
3923 if (len > PW_MAX)
3924 {
3925 continue;
3926 }
3927 }
3928
3929 *out_buf = ptr;
3930 *out_len = len;
3931
3932 return;
3933 }
3934
3935 if (feof (fd))
3936 {
3937 fprintf (stderr, "BUG feof()!!\n");
3938
3939 return;
3940 }
3941
3942 load_segment (wl_data, fd);
3943
3944 get_next_word (wl_data, fd, out_buf, out_len);
3945 }
3946
3947 #ifdef _POSIX
3948 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3949 #endif
3950
3951 #ifdef _WIN
3952 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3953 #endif
3954 {
3955 hc_signal (NULL);
3956
3957 dictstat_t d;
3958
3959 d.cnt = 0;
3960
3961 #ifdef _POSIX
3962 fstat (fileno (fd), &d.stat);
3963 #endif
3964
3965 #ifdef _WIN
3966 _fstat64 (fileno (fd), &d.stat);
3967 #endif
3968
3969 d.stat.st_mode = 0;
3970 d.stat.st_nlink = 0;
3971 d.stat.st_uid = 0;
3972 d.stat.st_gid = 0;
3973 d.stat.st_rdev = 0;
3974 d.stat.st_atime = 0;
3975
3976 #ifdef _POSIX
3977 d.stat.st_blksize = 0;
3978 d.stat.st_blocks = 0;
3979 #endif
3980
3981 if (d.stat.st_size == 0) return 0;
3982
3983 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3984
3985 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3986 {
3987 if (d_cache)
3988 {
3989 u64 cnt = d_cache->cnt;
3990
3991 u64 keyspace = cnt;
3992
3993 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3994 {
3995 keyspace *= data.kernel_rules_cnt;
3996 }
3997 else if (data.attack_kern == ATTACK_KERN_COMBI)
3998 {
3999 keyspace *= data.combs_cnt;
4000 }
4001
4002 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);
4003 if (data.quiet == 0) log_info ("");
4004
4005 hc_signal (sigHandler_default);
4006
4007 return (keyspace);
4008 }
4009 }
4010
4011 time_t now = 0;
4012 time_t prev = 0;
4013
4014 u64 comp = 0;
4015 u64 cnt = 0;
4016 u64 cnt2 = 0;
4017
4018 while (!feof (fd))
4019 {
4020 load_segment (wl_data, fd);
4021
4022 comp += wl_data->cnt;
4023
4024 u32 i = 0;
4025
4026 while (i < wl_data->cnt)
4027 {
4028 u32 len;
4029 u32 off;
4030
4031 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
4032
4033 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4034 {
4035 char rule_buf_out[BLOCK_SIZE] = { 0 };
4036
4037 int rule_len_out = -1;
4038
4039 if (len < BLOCK_SIZE)
4040 {
4041 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
4042 }
4043
4044 if (rule_len_out < 0)
4045 {
4046 len = PW_MAX1;
4047 }
4048 else
4049 {
4050 len = rule_len_out;
4051 }
4052 }
4053
4054 if (len < PW_MAX1)
4055 {
4056 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4057 {
4058 cnt += data.kernel_rules_cnt;
4059 }
4060 else if (data.attack_kern == ATTACK_KERN_COMBI)
4061 {
4062 cnt += data.combs_cnt;
4063 }
4064
4065 d.cnt++;
4066 }
4067
4068 i += off;
4069
4070 cnt2++;
4071 }
4072
4073 time (&now);
4074
4075 if ((now - prev) == 0) continue;
4076
4077 float percent = (float) comp / (float) d.stat.st_size;
4078
4079 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);
4080
4081 time (&prev);
4082 }
4083
4084 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);
4085 if (data.quiet == 0) log_info ("");
4086
4087 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4088
4089 hc_signal (sigHandler_default);
4090
4091 return (cnt);
4092 }
4093
4094 static void *thread_monitor (void *p)
4095 {
4096 uint runtime_check = 0;
4097 uint remove_check = 0;
4098 uint status_check = 0;
4099 uint restore_check = 0;
4100
4101 uint restore_left = data.restore_timer;
4102 uint remove_left = data.remove_timer;
4103 uint status_left = data.status_timer;
4104
4105 #ifdef HAVE_HWMON
4106 uint hwmon_check = 0;
4107
4108 int slowdown_warnings = 0;
4109
4110 // these variables are mainly used for fan control
4111
4112 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4113
4114 // temperature controller "loopback" values
4115
4116 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4117 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4118
4119 int temp_threshold = 1; // degrees celcius
4120
4121 int fan_speed_min = 15; // in percentage
4122 int fan_speed_max = 100;
4123
4124 time_t last_temp_check_time;
4125 #endif // HAVE_HWMON
4126
4127 uint sleep_time = 1;
4128
4129 if (data.runtime)
4130 {
4131 runtime_check = 1;
4132 }
4133
4134 if (data.restore_timer)
4135 {
4136 restore_check = 1;
4137 }
4138
4139 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4140 {
4141 remove_check = 1;
4142 }
4143
4144 if (data.status == 1)
4145 {
4146 status_check = 1;
4147 }
4148
4149 #ifdef HAVE_HWMON
4150 if (data.gpu_temp_disable == 0)
4151 {
4152 time (&last_temp_check_time);
4153
4154 hwmon_check = 1;
4155 }
4156 #endif
4157
4158 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4159 {
4160 #ifdef HAVE_HWMON
4161 if (hwmon_check == 0)
4162 #endif
4163 return (p);
4164 }
4165
4166 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4167 {
4168 hc_sleep (sleep_time);
4169
4170 if (data.devices_status != STATUS_RUNNING) continue;
4171
4172 #ifdef HAVE_HWMON
4173
4174 if (hwmon_check == 1)
4175 {
4176 hc_thread_mutex_lock (mux_adl);
4177
4178 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4179 {
4180 hc_device_param_t *device_param = &data.devices_param[device_id];
4181
4182 if (device_param->skipped) continue;
4183
4184 if (device_param->device_vendor_id == VENDOR_ID_NV)
4185 {
4186 if (data.hm_nvapi)
4187 {
4188 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
4189 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
4190
4191 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4192 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4193
4194 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4195
4196 perfPolicies_status.info_value = perfPolicies_info.info_value;
4197
4198 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4199
4200 if (perfPolicies_status.throttle & 2)
4201 {
4202 if (slowdown_warnings < 3)
4203 {
4204 if (data.quiet == 0) clear_prompt ();
4205
4206 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4207
4208 if (slowdown_warnings == 2)
4209 {
4210 log_info ("");
4211 }
4212
4213 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4214 if (data.quiet == 0) fflush (stdout);
4215
4216 slowdown_warnings++;
4217 }
4218 }
4219 else
4220 {
4221 slowdown_warnings = 0;
4222 }
4223 }
4224 }
4225 }
4226
4227 hc_thread_mutex_unlock (mux_adl);
4228 }
4229
4230 if (hwmon_check == 1)
4231 {
4232 hc_thread_mutex_lock (mux_adl);
4233
4234 time_t temp_check_time;
4235
4236 time (&temp_check_time);
4237
4238 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4239
4240 if (Ta == 0) Ta = 1;
4241
4242 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4243 {
4244 hc_device_param_t *device_param = &data.devices_param[device_id];
4245
4246 if (device_param->skipped) continue;
4247
4248 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4249
4250 const int temperature = hm_get_temperature_with_device_id (device_id);
4251
4252 if (temperature > (int) data.gpu_temp_abort)
4253 {
4254 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4255
4256 if (data.devices_status != STATUS_QUIT) myabort ();
4257
4258 break;
4259 }
4260
4261 const int gpu_temp_retain = data.gpu_temp_retain;
4262
4263 if (gpu_temp_retain)
4264 {
4265 if (data.hm_device[device_id].fan_set_supported == 1)
4266 {
4267 int temp_cur = temperature;
4268
4269 int temp_diff_new = gpu_temp_retain - temp_cur;
4270
4271 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4272
4273 // calculate Ta value (time difference in seconds between the last check and this check)
4274
4275 last_temp_check_time = temp_check_time;
4276
4277 float Kp = 1.8;
4278 float Ki = 0.005;
4279 float Kd = 6;
4280
4281 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4282
4283 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);
4284
4285 if (abs (fan_diff_required) >= temp_threshold)
4286 {
4287 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4288
4289 int fan_speed_level = fan_speed_cur;
4290
4291 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4292
4293 int fan_speed_new = fan_speed_level - fan_diff_required;
4294
4295 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4296 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4297
4298 if (fan_speed_new != fan_speed_cur)
4299 {
4300 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4301 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4302
4303 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4304 {
4305 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4306 {
4307 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4308 }
4309 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4310 {
4311 #ifdef WIN
4312 hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1);
4313 #endif
4314
4315 #ifdef LINUX
4316 hm_set_fanspeed_with_device_id_xnvctrl (device_id, fan_speed_new);
4317 #endif
4318 }
4319
4320 fan_speed_chgd[device_id] = 1;
4321 }
4322
4323 temp_diff_old[device_id] = temp_diff_new;
4324 }
4325 }
4326 }
4327 }
4328 }
4329
4330 hc_thread_mutex_unlock (mux_adl);
4331 }
4332 #endif // HAVE_HWMON
4333
4334 if (restore_check == 1)
4335 {
4336 restore_left--;
4337
4338 if (restore_left == 0)
4339 {
4340 if (data.restore_disable == 0) cycle_restore ();
4341
4342 restore_left = data.restore_timer;
4343 }
4344 }
4345
4346 if ((runtime_check == 1) && (data.runtime_start > 0))
4347 {
4348 time_t runtime_cur;
4349
4350 time (&runtime_cur);
4351
4352 int runtime_left = data.proc_start + data.runtime - runtime_cur;
4353
4354 if (runtime_left <= 0)
4355 {
4356 if (data.benchmark == 0)
4357 {
4358 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4359 }
4360
4361 if (data.devices_status != STATUS_QUIT) myabort ();
4362 }
4363 }
4364
4365 if (remove_check == 1)
4366 {
4367 remove_left--;
4368
4369 if (remove_left == 0)
4370 {
4371 if (data.digests_saved != data.digests_done)
4372 {
4373 data.digests_saved = data.digests_done;
4374
4375 save_hash ();
4376 }
4377
4378 remove_left = data.remove_timer;
4379 }
4380 }
4381
4382 if (status_check == 1)
4383 {
4384 status_left--;
4385
4386 if (status_left == 0)
4387 {
4388 hc_thread_mutex_lock (mux_display);
4389
4390 if (data.quiet == 0) clear_prompt ();
4391
4392 if (data.quiet == 0) log_info ("");
4393
4394 status_display ();
4395
4396 if (data.quiet == 0) log_info ("");
4397
4398 hc_thread_mutex_unlock (mux_display);
4399
4400 status_left = data.status_timer;
4401 }
4402 }
4403 }
4404
4405 #ifdef HAVE_HWMON
4406 myfree (fan_speed_chgd);
4407
4408 myfree (temp_diff_old);
4409 myfree (temp_diff_sum);
4410 #endif
4411
4412 p = NULL;
4413
4414 return (p);
4415 }
4416
4417 static void *thread_outfile_remove (void *p)
4418 {
4419 // some hash-dependent constants
4420 char *outfile_dir = data.outfile_check_directory;
4421 uint dgst_size = data.dgst_size;
4422 uint isSalted = data.isSalted;
4423 uint esalt_size = data.esalt_size;
4424 uint hash_mode = data.hash_mode;
4425
4426 uint outfile_check_timer = data.outfile_check_timer;
4427
4428 char separator = data.separator;
4429
4430 // some hash-dependent functions
4431 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4432 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4433
4434 // buffers
4435 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4436
4437 hash_buf.digest = mymalloc (dgst_size);
4438
4439 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4440
4441 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4442
4443 uint digest_buf[64] = { 0 };
4444
4445 outfile_data_t *out_info = NULL;
4446
4447 char **out_files = NULL;
4448
4449 time_t folder_mtime = 0;
4450
4451 int out_cnt = 0;
4452
4453 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4454
4455 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4456 {
4457 hc_sleep (1);
4458
4459 if (data.devices_status != STATUS_RUNNING) continue;
4460
4461 check_left--;
4462
4463 if (check_left == 0)
4464 {
4465 struct stat outfile_check_stat;
4466
4467 if (stat (outfile_dir, &outfile_check_stat) == 0)
4468 {
4469 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4470
4471 if (is_dir == 1)
4472 {
4473 if (outfile_check_stat.st_mtime > folder_mtime)
4474 {
4475 char **out_files_new = scan_directory (outfile_dir);
4476
4477 int out_cnt_new = count_dictionaries (out_files_new);
4478
4479 outfile_data_t *out_info_new = NULL;
4480
4481 if (out_cnt_new > 0)
4482 {
4483 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4484
4485 for (int i = 0; i < out_cnt_new; i++)
4486 {
4487 out_info_new[i].file_name = out_files_new[i];
4488
4489 // check if there are files that we have seen/checked before (and not changed)
4490
4491 for (int j = 0; j < out_cnt; j++)
4492 {
4493 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4494 {
4495 struct stat outfile_stat;
4496
4497 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4498 {
4499 if (outfile_stat.st_ctime == out_info[j].ctime)
4500 {
4501 out_info_new[i].ctime = out_info[j].ctime;
4502 out_info_new[i].seek = out_info[j].seek;
4503 }
4504 }
4505 }
4506 }
4507 }
4508 }
4509
4510 local_free (out_info);
4511 local_free (out_files);
4512
4513 out_files = out_files_new;
4514 out_cnt = out_cnt_new;
4515 out_info = out_info_new;
4516
4517 folder_mtime = outfile_check_stat.st_mtime;
4518 }
4519
4520 for (int j = 0; j < out_cnt; j++)
4521 {
4522 FILE *fp = fopen (out_info[j].file_name, "rb");
4523
4524 if (fp != NULL)
4525 {
4526 //hc_thread_mutex_lock (mux_display);
4527
4528 #ifdef _POSIX
4529 struct stat outfile_stat;
4530
4531 fstat (fileno (fp), &outfile_stat);
4532 #endif
4533
4534 #ifdef _WIN
4535 struct stat64 outfile_stat;
4536
4537 _fstat64 (fileno (fp), &outfile_stat);
4538 #endif
4539
4540 if (outfile_stat.st_ctime > out_info[j].ctime)
4541 {
4542 out_info[j].ctime = outfile_stat.st_ctime;
4543 out_info[j].seek = 0;
4544 }
4545
4546 fseek (fp, out_info[j].seek, SEEK_SET);
4547
4548 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4549
4550 while (!feof (fp))
4551 {
4552 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4553
4554 if (ptr == NULL) break;
4555
4556 int line_len = strlen (line_buf);
4557
4558 if (line_len <= 0) continue;
4559
4560 int iter = MAX_CUT_TRIES;
4561
4562 for (uint i = line_len - 1; i && iter; i--, line_len--)
4563 {
4564 if (line_buf[i] != separator) continue;
4565
4566 int parser_status = PARSER_OK;
4567
4568 if ((hash_mode != 2500) && (hash_mode != 6800))
4569 {
4570 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4571 }
4572
4573 uint found = 0;
4574
4575 if (parser_status == PARSER_OK)
4576 {
4577 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4578 {
4579 if (data.salts_shown[salt_pos] == 1) continue;
4580
4581 salt_t *salt_buf = &data.salts_buf[salt_pos];
4582
4583 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4584 {
4585 uint idx = salt_buf->digests_offset + digest_pos;
4586
4587 if (data.digests_shown[idx] == 1) continue;
4588
4589 uint cracked = 0;
4590
4591 if (hash_mode == 6800)
4592 {
4593 if (i == salt_buf->salt_len)
4594 {
4595 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4596 }
4597 }
4598 else if (hash_mode == 2500)
4599 {
4600 // BSSID : MAC1 : MAC2 (:plain)
4601 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4602 {
4603 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4604
4605 if (!cracked) continue;
4606
4607 // now compare MAC1 and MAC2 too, since we have this additional info
4608 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4609 char *mac2_pos = mac1_pos + 12 + 1;
4610
4611 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4612 wpa_t *wpa = &wpas[salt_pos];
4613
4614 // compare hex string(s) vs binary MAC address(es)
4615
4616 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4617 {
4618 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4619 {
4620 cracked = 0;
4621
4622 break;
4623 }
4624 }
4625
4626 // early skip ;)
4627 if (!cracked) continue;
4628
4629 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4630 {
4631 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4632 {
4633 cracked = 0;
4634
4635 break;
4636 }
4637 }
4638 }
4639 }
4640 else
4641 {
4642 char *digests_buf_ptr = (char *) data.digests_buf;
4643
4644 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4645
4646 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4647 }
4648
4649 if (cracked == 1)
4650 {
4651 found = 1;
4652
4653 data.digests_shown[idx] = 1;
4654
4655 data.digests_done++;
4656
4657 salt_buf->digests_done++;
4658
4659 if (salt_buf->digests_done == salt_buf->digests_cnt)
4660 {
4661 data.salts_shown[salt_pos] = 1;
4662
4663 data.salts_done++;
4664
4665 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4666 }
4667 }
4668 }
4669
4670 if (data.devices_status == STATUS_CRACKED) break;
4671 }
4672 }
4673
4674 if (found) break;
4675
4676 if (data.devices_status == STATUS_CRACKED) break;
4677
4678 iter--;
4679 }
4680
4681 if (data.devices_status == STATUS_CRACKED) break;
4682 }
4683
4684 myfree (line_buf);
4685
4686 out_info[j].seek = ftell (fp);
4687
4688 //hc_thread_mutex_unlock (mux_display);
4689
4690 fclose (fp);
4691 }
4692 }
4693 }
4694 }
4695
4696 check_left = outfile_check_timer;
4697 }
4698 }
4699
4700 if (esalt_size) local_free (hash_buf.esalt);
4701
4702 if (isSalted) local_free (hash_buf.salt);
4703
4704 local_free (hash_buf.digest);
4705
4706 local_free (out_info);
4707
4708 local_free (out_files);
4709
4710 p = NULL;
4711
4712 return (p);
4713 }
4714
4715 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4716 {
4717 //if (device_param->pws_cnt < device_param->kernel_power)
4718 //{
4719 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4720
4721 u8 *ptr = (u8 *) pw->i;
4722
4723 memcpy (ptr, pw_buf, pw_len);
4724
4725 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4726
4727 pw->pw_len = pw_len;
4728
4729 device_param->pws_cnt++;
4730 //}
4731 //else
4732 //{
4733 // fprintf (stderr, "BUG pw_add()!!\n");
4734 //
4735 // return;
4736 //}
4737 }
4738
4739 static void set_kernel_power_final (const u64 kernel_power_final)
4740 {
4741 if (data.quiet == 0)
4742 {
4743 clear_prompt ();
4744
4745 //log_info ("");
4746
4747 log_info ("INFO: approaching final keyspace, workload adjusted");
4748 log_info ("");
4749
4750 fprintf (stdout, "%s", PROMPT);
4751
4752 fflush (stdout);
4753 }
4754
4755 data.kernel_power_final = kernel_power_final;
4756 }
4757
4758 static u32 get_power (hc_device_param_t *device_param)
4759 {
4760 const u64 kernel_power_final = data.kernel_power_final;
4761
4762 if (kernel_power_final)
4763 {
4764 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4765
4766 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4767
4768 // work should be at least the hardware power available without any accelerator
4769
4770 const u64 work = MAX (words_left_device, device_param->hardware_power);
4771
4772 return work;
4773 }
4774
4775 return device_param->kernel_power;
4776 }
4777
4778 static uint get_work (hc_device_param_t *device_param, const u64 max)
4779 {
4780 hc_thread_mutex_lock (mux_dispatcher);
4781
4782 const u64 words_cur = data.words_cur;
4783 const u64 words_base = (data.limit == 0) ? data.words_base : MIN (data.limit, data.words_base);
4784
4785 device_param->words_off = words_cur;
4786
4787 const u64 kernel_power_all = data.kernel_power_all;
4788
4789 const u64 words_left = words_base - words_cur;
4790
4791 if (words_left < kernel_power_all)
4792 {
4793 if (data.kernel_power_final == 0)
4794 {
4795 set_kernel_power_final (words_left);
4796 }
4797 }
4798
4799 const u32 kernel_power = get_power (device_param);
4800
4801 uint work = MIN (words_left, kernel_power);
4802
4803 work = MIN (work, max);
4804
4805 data.words_cur += work;
4806
4807 hc_thread_mutex_unlock (mux_dispatcher);
4808
4809 return work;
4810 }
4811
4812 static void *thread_autotune (void *p)
4813 {
4814 hc_device_param_t *device_param = (hc_device_param_t *) p;
4815
4816 if (device_param->skipped) return NULL;
4817
4818 autotune (device_param);
4819
4820 return NULL;
4821 }
4822
4823 static void *thread_calc_stdin (void *p)
4824 {
4825 hc_device_param_t *device_param = (hc_device_param_t *) p;
4826
4827 if (device_param->skipped) return NULL;
4828
4829 char *buf = (char *) mymalloc (HCBUFSIZ);
4830
4831 const uint attack_kern = data.attack_kern;
4832
4833 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4834 {
4835 hc_thread_mutex_lock (mux_dispatcher);
4836
4837 if (feof (stdin) != 0)
4838 {
4839 hc_thread_mutex_unlock (mux_dispatcher);
4840
4841 break;
4842 }
4843
4844 uint words_cur = 0;
4845
4846 while (words_cur < device_param->kernel_power)
4847 {
4848 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4849
4850 if (line_buf == NULL) break;
4851
4852 uint line_len = in_superchop (line_buf);
4853
4854 line_len = convert_from_hex (line_buf, line_len);
4855
4856 // post-process rule engine
4857
4858 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4859 {
4860 char rule_buf_out[BLOCK_SIZE] = { 0 };
4861
4862 int rule_len_out = -1;
4863
4864 if (line_len < BLOCK_SIZE)
4865 {
4866 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4867 }
4868
4869 if (rule_len_out < 0) continue;
4870
4871 line_buf = rule_buf_out;
4872 line_len = rule_len_out;
4873 }
4874
4875 if (line_len > PW_MAX)
4876 {
4877 continue;
4878 }
4879
4880 // hmm that's always the case, or?
4881
4882 if (attack_kern == ATTACK_KERN_STRAIGHT)
4883 {
4884 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4885 {
4886 hc_thread_mutex_lock (mux_counter);
4887
4888 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4889 {
4890 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4891 }
4892
4893 hc_thread_mutex_unlock (mux_counter);
4894
4895 continue;
4896 }
4897 }
4898
4899 pw_add (device_param, (u8 *) line_buf, line_len);
4900
4901 words_cur++;
4902
4903 if (data.devices_status == STATUS_CRACKED) break;
4904 if (data.devices_status == STATUS_ABORTED) break;
4905 if (data.devices_status == STATUS_QUIT) break;
4906 if (data.devices_status == STATUS_BYPASS) break;
4907 }
4908
4909 hc_thread_mutex_unlock (mux_dispatcher);
4910
4911 if (data.devices_status == STATUS_CRACKED) break;
4912 if (data.devices_status == STATUS_ABORTED) break;
4913 if (data.devices_status == STATUS_QUIT) break;
4914 if (data.devices_status == STATUS_BYPASS) break;
4915
4916 // flush
4917
4918 const uint pws_cnt = device_param->pws_cnt;
4919
4920 if (pws_cnt)
4921 {
4922 run_copy (device_param, pws_cnt);
4923
4924 run_cracker (device_param, pws_cnt);
4925
4926 device_param->pws_cnt = 0;
4927
4928 /*
4929 still required?
4930 if (attack_kern == ATTACK_KERN_STRAIGHT)
4931 {
4932 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4933 }
4934 else if (attack_kern == ATTACK_KERN_COMBI)
4935 {
4936 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4937 }
4938 */
4939 }
4940 }
4941
4942 device_param->kernel_accel = 0;
4943 device_param->kernel_loops = 0;
4944
4945 myfree (buf);
4946
4947 return NULL;
4948 }
4949
4950 static void *thread_calc (void *p)
4951 {
4952 hc_device_param_t *device_param = (hc_device_param_t *) p;
4953
4954 if (device_param->skipped) return NULL;
4955
4956 const uint attack_mode = data.attack_mode;
4957 const uint attack_kern = data.attack_kern;
4958
4959 if (attack_mode == ATTACK_MODE_BF)
4960 {
4961 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4962 {
4963 const uint work = get_work (device_param, -1);
4964
4965 if (work == 0) break;
4966
4967 const u64 words_off = device_param->words_off;
4968 const u64 words_fin = words_off + work;
4969
4970 const uint pws_cnt = work;
4971
4972 device_param->pws_cnt = pws_cnt;
4973
4974 if (pws_cnt)
4975 {
4976 run_copy (device_param, pws_cnt);
4977
4978 run_cracker (device_param, pws_cnt);
4979
4980 device_param->pws_cnt = 0;
4981
4982 /*
4983 still required?
4984 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4985 */
4986 }
4987
4988 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4989
4990 if (data.devices_status == STATUS_CRACKED) break;
4991 if (data.devices_status == STATUS_ABORTED) break;
4992 if (data.devices_status == STATUS_QUIT) break;
4993 if (data.devices_status == STATUS_BYPASS) break;
4994
4995 if (data.benchmark == 1) break;
4996
4997 device_param->words_done = words_fin;
4998 }
4999 }
5000 else
5001 {
5002 const uint segment_size = data.segment_size;
5003
5004 char *dictfile = data.dictfile;
5005
5006 if (attack_mode == ATTACK_MODE_COMBI)
5007 {
5008 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5009 {
5010 dictfile = data.dictfile2;
5011 }
5012 }
5013
5014 FILE *fd = fopen (dictfile, "rb");
5015
5016 if (fd == NULL)
5017 {
5018 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
5019
5020 return NULL;
5021 }
5022
5023 if (attack_mode == ATTACK_MODE_COMBI)
5024 {
5025 const uint combs_mode = data.combs_mode;
5026
5027 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
5028 {
5029 const char *dictfilec = data.dictfile2;
5030
5031 FILE *combs_fp = fopen (dictfilec, "rb");
5032
5033 if (combs_fp == NULL)
5034 {
5035 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5036
5037 fclose (fd);
5038
5039 return NULL;
5040 }
5041
5042 device_param->combs_fp = combs_fp;
5043 }
5044 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5045 {
5046 const char *dictfilec = data.dictfile;
5047
5048 FILE *combs_fp = fopen (dictfilec, "rb");
5049
5050 if (combs_fp == NULL)
5051 {
5052 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5053
5054 fclose (fd);
5055
5056 return NULL;
5057 }
5058
5059 device_param->combs_fp = combs_fp;
5060 }
5061 }
5062
5063 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
5064
5065 wl_data->buf = (char *) mymalloc (segment_size);
5066 wl_data->avail = segment_size;
5067 wl_data->incr = segment_size;
5068 wl_data->cnt = 0;
5069 wl_data->pos = 0;
5070
5071 u64 words_cur = 0;
5072
5073 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5074 {
5075 u64 words_off = 0;
5076 u64 words_fin = 0;
5077
5078 u64 max = -1;
5079
5080 while (max)
5081 {
5082 const uint work = get_work (device_param, max);
5083
5084 if (work == 0) break;
5085
5086 max = 0;
5087
5088 words_off = device_param->words_off;
5089 words_fin = words_off + work;
5090
5091 char *line_buf;
5092 uint line_len;
5093
5094 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5095
5096 for ( ; words_cur < words_fin; words_cur++)
5097 {
5098 get_next_word (wl_data, fd, &line_buf, &line_len);
5099
5100 line_len = convert_from_hex (line_buf, line_len);
5101
5102 // post-process rule engine
5103
5104 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5105 {
5106 char rule_buf_out[BLOCK_SIZE] = { 0 };
5107
5108 int rule_len_out = -1;
5109
5110 if (line_len < BLOCK_SIZE)
5111 {
5112 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5113 }
5114
5115 if (rule_len_out < 0) continue;
5116
5117 line_buf = rule_buf_out;
5118 line_len = rule_len_out;
5119 }
5120
5121 if (attack_kern == ATTACK_KERN_STRAIGHT)
5122 {
5123 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5124 {
5125 max++;
5126
5127 hc_thread_mutex_lock (mux_counter);
5128
5129 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5130 {
5131 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5132 }
5133
5134 hc_thread_mutex_unlock (mux_counter);
5135
5136 continue;
5137 }
5138 }
5139 else if (attack_kern == ATTACK_KERN_COMBI)
5140 {
5141 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5142 // since we still need to combine the plains
5143
5144 if (line_len > data.pw_max)
5145 {
5146 max++;
5147
5148 hc_thread_mutex_lock (mux_counter);
5149
5150 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5151 {
5152 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5153 }
5154
5155 hc_thread_mutex_unlock (mux_counter);
5156
5157 continue;
5158 }
5159 }
5160
5161 pw_add (device_param, (u8 *) line_buf, line_len);
5162
5163 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5164
5165 if (data.devices_status == STATUS_CRACKED) break;
5166 if (data.devices_status == STATUS_ABORTED) break;
5167 if (data.devices_status == STATUS_QUIT) break;
5168 if (data.devices_status == STATUS_BYPASS) break;
5169 }
5170
5171 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5172
5173 if (data.devices_status == STATUS_CRACKED) break;
5174 if (data.devices_status == STATUS_ABORTED) break;
5175 if (data.devices_status == STATUS_QUIT) break;
5176 if (data.devices_status == STATUS_BYPASS) break;
5177 }
5178
5179 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5180
5181 if (data.devices_status == STATUS_CRACKED) break;
5182 if (data.devices_status == STATUS_ABORTED) break;
5183 if (data.devices_status == STATUS_QUIT) break;
5184 if (data.devices_status == STATUS_BYPASS) break;
5185
5186 //
5187 // flush
5188 //
5189
5190 const uint pws_cnt = device_param->pws_cnt;
5191
5192 if (pws_cnt)
5193 {
5194 run_copy (device_param, pws_cnt);
5195
5196 run_cracker (device_param, pws_cnt);
5197
5198 device_param->pws_cnt = 0;
5199
5200 /*
5201 still required?
5202 if (attack_kern == ATTACK_KERN_STRAIGHT)
5203 {
5204 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5205 }
5206 else if (attack_kern == ATTACK_KERN_COMBI)
5207 {
5208 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5209 }
5210 */
5211 }
5212
5213 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5214
5215 if (data.devices_status == STATUS_CRACKED) break;
5216 if (data.devices_status == STATUS_ABORTED) break;
5217 if (data.devices_status == STATUS_QUIT) break;
5218 if (data.devices_status == STATUS_BYPASS) break;
5219
5220 if (words_fin == 0) break;
5221
5222 device_param->words_done = words_fin;
5223 }
5224
5225 if (attack_mode == ATTACK_MODE_COMBI)
5226 {
5227 fclose (device_param->combs_fp);
5228 }
5229
5230 free (wl_data->buf);
5231 free (wl_data);
5232
5233 fclose (fd);
5234 }
5235
5236 device_param->kernel_accel = 0;
5237 device_param->kernel_loops = 0;
5238
5239 return NULL;
5240 }
5241
5242 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5243 {
5244 if (!device_param)
5245 {
5246 log_error ("ERROR: %s : Invalid argument", __func__);
5247
5248 exit (-1);
5249 }
5250
5251 salt_t *salt_buf = &data.salts_buf[salt_pos];
5252
5253 device_param->kernel_params_buf32[24] = salt_pos;
5254 device_param->kernel_params_buf32[27] = 1;
5255 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
5256 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
5257 device_param->kernel_params_buf32[30] = 0;
5258 device_param->kernel_params_buf32[31] = 1;
5259
5260 char *dictfile_old = data.dictfile;
5261
5262 const char *weak_hash_check = "weak-hash-check";
5263
5264 data.dictfile = (char *) weak_hash_check;
5265
5266 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5267
5268 data.kernel_rules_buf[0].cmds[0] = 0;
5269
5270 /**
5271 * run the kernel
5272 */
5273
5274 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5275 {
5276 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5277 }
5278 else
5279 {
5280 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5281
5282 uint loop_step = 16;
5283
5284 const uint iter = salt_buf->salt_iter;
5285
5286 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5287 {
5288 uint loop_left = iter - loop_pos;
5289
5290 loop_left = MIN (loop_left, loop_step);
5291
5292 device_param->kernel_params_buf32[25] = loop_pos;
5293 device_param->kernel_params_buf32[26] = loop_left;
5294
5295 run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5296 }
5297
5298 run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5299 }
5300
5301 /**
5302 * result
5303 */
5304
5305 check_cracked (device_param, salt_pos);
5306
5307 /**
5308 * cleanup
5309 */
5310
5311 device_param->kernel_params_buf32[24] = 0;
5312 device_param->kernel_params_buf32[25] = 0;
5313 device_param->kernel_params_buf32[26] = 0;
5314 device_param->kernel_params_buf32[27] = 0;
5315 device_param->kernel_params_buf32[28] = 0;
5316 device_param->kernel_params_buf32[29] = 0;
5317 device_param->kernel_params_buf32[30] = 0;
5318 device_param->kernel_params_buf32[31] = 0;
5319
5320 data.dictfile = dictfile_old;
5321
5322 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5323 }
5324
5325 // hlfmt hashcat
5326
5327 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5328 {
5329 if (data.username == 0)
5330 {
5331 *hashbuf_pos = line_buf;
5332 *hashbuf_len = line_len;
5333 }
5334 else
5335 {
5336 char *pos = line_buf;
5337 int len = line_len;
5338
5339 for (int i = 0; i < line_len; i++, pos++, len--)
5340 {
5341 if (line_buf[i] == data.separator)
5342 {
5343 pos++;
5344
5345 len--;
5346
5347 break;
5348 }
5349 }
5350
5351 *hashbuf_pos = pos;
5352 *hashbuf_len = len;
5353 }
5354 }
5355
5356 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5357 {
5358 char *pos = NULL;
5359 int len = 0;
5360
5361 int sep_cnt = 0;
5362
5363 for (int i = 0; i < line_len; i++)
5364 {
5365 if (line_buf[i] == data.separator)
5366 {
5367 sep_cnt++;
5368
5369 continue;
5370 }
5371
5372 if (sep_cnt == 0)
5373 {
5374 if (pos == NULL) pos = line_buf + i;
5375
5376 len++;
5377 }
5378 }
5379
5380 *userbuf_pos = pos;
5381 *userbuf_len = len;
5382 }
5383
5384 // hlfmt pwdump
5385
5386 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5387 {
5388 int sep_cnt = 0;
5389
5390 int sep2_len = 0;
5391 int sep3_len = 0;
5392
5393 for (int i = 0; i < line_len; i++)
5394 {
5395 if (line_buf[i] == ':')
5396 {
5397 sep_cnt++;
5398
5399 continue;
5400 }
5401
5402 if (sep_cnt == 2) sep2_len++;
5403 if (sep_cnt == 3) sep3_len++;
5404 }
5405
5406 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5407
5408 return 0;
5409 }
5410
5411 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5412 {
5413 char *pos = NULL;
5414 int len = 0;
5415
5416 int sep_cnt = 0;
5417
5418 for (int i = 0; i < line_len; i++)
5419 {
5420 if (line_buf[i] == ':')
5421 {
5422 sep_cnt++;
5423
5424 continue;
5425 }
5426
5427 if (data.hash_mode == 1000)
5428 {
5429 if (sep_cnt == 3)
5430 {
5431 if (pos == NULL) pos = line_buf + i;
5432
5433 len++;
5434 }
5435 }
5436 else if (data.hash_mode == 3000)
5437 {
5438 if (sep_cnt == 2)
5439 {
5440 if (pos == NULL) pos = line_buf + i;
5441
5442 len++;
5443 }
5444 }
5445 }
5446
5447 *hashbuf_pos = pos;
5448 *hashbuf_len = len;
5449 }
5450
5451 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5452 {
5453 char *pos = NULL;
5454 int len = 0;
5455
5456 int sep_cnt = 0;
5457
5458 for (int i = 0; i < line_len; i++)
5459 {
5460 if (line_buf[i] == ':')
5461 {
5462 sep_cnt++;
5463
5464 continue;
5465 }
5466
5467 if (sep_cnt == 0)
5468 {
5469 if (pos == NULL) pos = line_buf + i;
5470
5471 len++;
5472 }
5473 }
5474
5475 *userbuf_pos = pos;
5476 *userbuf_len = len;
5477 }
5478
5479 // hlfmt passwd
5480
5481 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5482 {
5483 int sep_cnt = 0;
5484
5485 char sep5_first = 0;
5486 char sep6_first = 0;
5487
5488 for (int i = 0; i < line_len; i++)
5489 {
5490 if (line_buf[i] == ':')
5491 {
5492 sep_cnt++;
5493
5494 continue;
5495 }
5496
5497 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5498 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5499 }
5500
5501 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5502
5503 return 0;
5504 }
5505
5506 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5507 {
5508 char *pos = NULL;
5509 int len = 0;
5510
5511 int sep_cnt = 0;
5512
5513 for (int i = 0; i < line_len; i++)
5514 {
5515 if (line_buf[i] == ':')
5516 {
5517 sep_cnt++;
5518
5519 continue;
5520 }
5521
5522 if (sep_cnt == 1)
5523 {
5524 if (pos == NULL) pos = line_buf + i;
5525
5526 len++;
5527 }
5528 }
5529
5530 *hashbuf_pos = pos;
5531 *hashbuf_len = len;
5532 }
5533
5534 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5535 {
5536 char *pos = NULL;
5537 int len = 0;
5538
5539 int sep_cnt = 0;
5540
5541 for (int i = 0; i < line_len; i++)
5542 {
5543 if (line_buf[i] == ':')
5544 {
5545 sep_cnt++;
5546
5547 continue;
5548 }
5549
5550 if (sep_cnt == 0)
5551 {
5552 if (pos == NULL) pos = line_buf + i;
5553
5554 len++;
5555 }
5556 }
5557
5558 *userbuf_pos = pos;
5559 *userbuf_len = len;
5560 }
5561
5562 // hlfmt shadow
5563
5564 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5565 {
5566 int sep_cnt = 0;
5567
5568 for (int i = 0; i < line_len; i++)
5569 {
5570 if (line_buf[i] == ':') sep_cnt++;
5571 }
5572
5573 if (sep_cnt == 8) return 1;
5574
5575 return 0;
5576 }
5577
5578 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5579 {
5580 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5581 }
5582
5583 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5584 {
5585 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5586 }
5587
5588 // hlfmt main
5589
5590 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5591 {
5592 switch (hashfile_format)
5593 {
5594 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5595 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5596 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5597 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5598 }
5599 }
5600
5601 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5602 {
5603 switch (hashfile_format)
5604 {
5605 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5606 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5607 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5608 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5609 }
5610 }
5611
5612 char *strhlfmt (const uint hashfile_format)
5613 {
5614 switch (hashfile_format)
5615 {
5616 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5617 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5618 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5619 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5620 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5621 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5622 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5623 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5624 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5625 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5626 }
5627
5628 return ((char *) "Unknown");
5629 }
5630
5631 static uint hlfmt_detect (FILE *fp, uint max_check)
5632 {
5633 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5634
5635 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5636 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5637
5638 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5639
5640 uint num_check = 0;
5641
5642 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5643
5644 while (!feof (fp))
5645 {
5646 int line_len = fgetl (fp, line_buf);
5647
5648 if (line_len == 0) continue;
5649
5650 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5651 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5652 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5653
5654 if (num_check == max_check) break;
5655
5656 num_check++;
5657 }
5658
5659 myfree (line_buf);
5660
5661 uint hashlist_format = HLFMT_HASHCAT;
5662
5663 for (int i = 1; i < HLFMTS_CNT; i++)
5664 {
5665 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5666
5667 hashlist_format = i;
5668 }
5669
5670 free (formats_cnt);
5671
5672 return hashlist_format;
5673 }
5674
5675 /**
5676 * some further helper function
5677 */
5678
5679 // wrapper around mymalloc for ADL
5680
5681 #if defined(HAVE_HWMON)
5682 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5683 {
5684 return mymalloc (iSize);
5685 }
5686 #endif
5687
5688 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)
5689 {
5690 u64 collisions = 0;
5691
5692 const uint dgst_pos0 = data.dgst_pos0;
5693 const uint dgst_pos1 = data.dgst_pos1;
5694 const uint dgst_pos2 = data.dgst_pos2;
5695 const uint dgst_pos3 = data.dgst_pos3;
5696
5697 memset (bitmap_a, 0, bitmap_size);
5698 memset (bitmap_b, 0, bitmap_size);
5699 memset (bitmap_c, 0, bitmap_size);
5700 memset (bitmap_d, 0, bitmap_size);
5701
5702 for (uint i = 0; i < digests_cnt; i++)
5703 {
5704 uint *digest_ptr = (uint *) digests_buf_ptr;
5705
5706 digests_buf_ptr += dgst_size;
5707
5708 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5709 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5710 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5711 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5712
5713 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5714 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5715 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5716 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5717
5718 if (bitmap_a[idx0] & val0) collisions++;
5719 if (bitmap_b[idx1] & val1) collisions++;
5720 if (bitmap_c[idx2] & val2) collisions++;
5721 if (bitmap_d[idx3] & val3) collisions++;
5722
5723 bitmap_a[idx0] |= val0;
5724 bitmap_b[idx1] |= val1;
5725 bitmap_c[idx2] |= val2;
5726 bitmap_d[idx3] |= val3;
5727
5728 if (collisions >= collisions_max) return 0x7fffffff;
5729 }
5730
5731 return collisions;
5732 }
5733
5734 /**
5735 * main
5736 */
5737
5738 #ifdef WIN
5739 void SetConsoleWindowSize (const int x)
5740 {
5741 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5742
5743 if (h == INVALID_HANDLE_VALUE) return;
5744
5745 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5746
5747 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5748
5749 SMALL_RECT *sr = &bufferInfo.srWindow;
5750
5751 sr->Right = MAX (sr->Right, x - 1);
5752
5753 COORD co;
5754
5755 co.X = sr->Right + 1;
5756 co.Y = 9999;
5757
5758 if (!SetConsoleScreenBufferSize (h, co)) return;
5759
5760 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5761 }
5762 #endif
5763
5764 int main (int argc, char **argv)
5765 {
5766 #ifdef WIN
5767 SetConsoleWindowSize (132);
5768 #endif
5769
5770 /**
5771 * To help users a bit
5772 */
5773
5774 char *compute = getenv ("COMPUTE");
5775
5776 if (compute)
5777 {
5778 static char display[100];
5779
5780 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5781
5782 putenv (display);
5783 }
5784 else
5785 {
5786 if (getenv ("DISPLAY") == NULL)
5787 putenv ((char *) "DISPLAY=:0");
5788 }
5789
5790 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5791 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5792
5793 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5794 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5795
5796 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5797 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5798
5799 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5800 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5801
5802 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5803 putenv ((char *) "POCL_KERNEL_CACHE=0");
5804
5805 umask (077);
5806
5807 /**
5808 * Real init
5809 */
5810
5811 memset (&data, 0, sizeof (hc_global_data_t));
5812
5813 time_t proc_start;
5814
5815 time (&proc_start);
5816
5817 data.proc_start = proc_start;
5818
5819 int myargc = argc;
5820 char **myargv = argv;
5821
5822 hc_thread_mutex_init (mux_dispatcher);
5823 hc_thread_mutex_init (mux_counter);
5824 hc_thread_mutex_init (mux_display);
5825 hc_thread_mutex_init (mux_adl);
5826
5827 /**
5828 * commandline parameters
5829 */
5830
5831 uint usage = USAGE;
5832 uint version = VERSION;
5833 uint quiet = QUIET;
5834 uint benchmark = BENCHMARK;
5835 uint stdout_flag = STDOUT_FLAG;
5836 uint show = SHOW;
5837 uint left = LEFT;
5838 uint username = USERNAME;
5839 uint remove = REMOVE;
5840 uint remove_timer = REMOVE_TIMER;
5841 u64 skip = SKIP;
5842 u64 limit = LIMIT;
5843 uint keyspace = KEYSPACE;
5844 uint potfile_disable = POTFILE_DISABLE;
5845 char *potfile_path = NULL;
5846 uint debug_mode = DEBUG_MODE;
5847 char *debug_file = NULL;
5848 char *induction_dir = NULL;
5849 char *outfile_check_dir = NULL;
5850 uint force = FORCE;
5851 uint runtime = RUNTIME;
5852 uint hash_mode = HASH_MODE;
5853 uint attack_mode = ATTACK_MODE;
5854 uint markov_disable = MARKOV_DISABLE;
5855 uint markov_classic = MARKOV_CLASSIC;
5856 uint markov_threshold = MARKOV_THRESHOLD;
5857 char *markov_hcstat = NULL;
5858 char *outfile = NULL;
5859 uint outfile_format = OUTFILE_FORMAT;
5860 uint outfile_autohex = OUTFILE_AUTOHEX;
5861 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5862 uint restore = RESTORE;
5863 uint restore_timer = RESTORE_TIMER;
5864 uint restore_disable = RESTORE_DISABLE;
5865 uint status = STATUS;
5866 uint status_timer = STATUS_TIMER;
5867 uint machine_readable = MACHINE_READABLE;
5868 uint loopback = LOOPBACK;
5869 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5870 char *session = NULL;
5871 uint hex_charset = HEX_CHARSET;
5872 uint hex_salt = HEX_SALT;
5873 uint hex_wordlist = HEX_WORDLIST;
5874 uint rp_gen = RP_GEN;
5875 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5876 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5877 uint rp_gen_seed = RP_GEN_SEED;
5878 char *rule_buf_l = (char *) RULE_BUF_L;
5879 char *rule_buf_r = (char *) RULE_BUF_R;
5880 uint increment = INCREMENT;
5881 uint increment_min = INCREMENT_MIN;
5882 uint increment_max = INCREMENT_MAX;
5883 char *cpu_affinity = NULL;
5884 OCL_PTR *ocl = NULL;
5885 char *opencl_devices = NULL;
5886 char *opencl_platforms = NULL;
5887 char *opencl_device_types = NULL;
5888 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5889 char *truecrypt_keyfiles = NULL;
5890 char *veracrypt_keyfiles = NULL;
5891 uint veracrypt_pim = 0;
5892 uint workload_profile = WORKLOAD_PROFILE;
5893 uint kernel_accel = KERNEL_ACCEL;
5894 uint kernel_loops = KERNEL_LOOPS;
5895 uint nvidia_spin_damp = NVIDIA_SPIN_DAMP;
5896 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5897 #ifdef HAVE_HWMON
5898 uint gpu_temp_abort = GPU_TEMP_ABORT;
5899 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5900 uint powertune_enable = POWERTUNE_ENABLE;
5901 #endif
5902 uint logfile_disable = LOGFILE_DISABLE;
5903 uint segment_size = SEGMENT_SIZE;
5904 uint scrypt_tmto = SCRYPT_TMTO;
5905 char separator = SEPARATOR;
5906 uint bitmap_min = BITMAP_MIN;
5907 uint bitmap_max = BITMAP_MAX;
5908 char *custom_charset_1 = NULL;
5909 char *custom_charset_2 = NULL;
5910 char *custom_charset_3 = NULL;
5911 char *custom_charset_4 = NULL;
5912
5913 #define IDX_HELP 'h'
5914 #define IDX_VERSION 'V'
5915 #define IDX_VERSION_LOWER 'v'
5916 #define IDX_QUIET 0xff02
5917 #define IDX_SHOW 0xff03
5918 #define IDX_LEFT 0xff04
5919 #define IDX_REMOVE 0xff05
5920 #define IDX_REMOVE_TIMER 0xff37
5921 #define IDX_SKIP 's'
5922 #define IDX_LIMIT 'l'
5923 #define IDX_KEYSPACE 0xff35
5924 #define IDX_POTFILE_DISABLE 0xff06
5925 #define IDX_POTFILE_PATH 0xffe0
5926 #define IDX_DEBUG_MODE 0xff43
5927 #define IDX_DEBUG_FILE 0xff44
5928 #define IDX_INDUCTION_DIR 0xff46
5929 #define IDX_OUTFILE_CHECK_DIR 0xff47
5930 #define IDX_USERNAME 0xff07
5931 #define IDX_FORCE 0xff08
5932 #define IDX_RUNTIME 0xff09
5933 #define IDX_BENCHMARK 'b'
5934 #define IDX_STDOUT_FLAG 0xff77
5935 #define IDX_HASH_MODE 'm'
5936 #define IDX_ATTACK_MODE 'a'
5937 #define IDX_RP_FILE 'r'
5938 #define IDX_RP_GEN 'g'
5939 #define IDX_RP_GEN_FUNC_MIN 0xff10
5940 #define IDX_RP_GEN_FUNC_MAX 0xff11
5941 #define IDX_RP_GEN_SEED 0xff34
5942 #define IDX_RULE_BUF_L 'j'
5943 #define IDX_RULE_BUF_R 'k'
5944 #define IDX_INCREMENT 'i'
5945 #define IDX_INCREMENT_MIN 0xff12
5946 #define IDX_INCREMENT_MAX 0xff13
5947 #define IDX_OUTFILE 'o'
5948 #define IDX_OUTFILE_FORMAT 0xff14
5949 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5950 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5951 #define IDX_RESTORE 0xff15
5952 #define IDX_RESTORE_DISABLE 0xff27
5953 #define IDX_STATUS 0xff17
5954 #define IDX_STATUS_TIMER 0xff18
5955 #define IDX_MACHINE_READABLE 0xff50
5956 #define IDX_LOOPBACK 0xff38
5957 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5958 #define IDX_SESSION 0xff19
5959 #define IDX_HEX_CHARSET 0xff20
5960 #define IDX_HEX_SALT 0xff21
5961 #define IDX_HEX_WORDLIST 0xff40
5962 #define IDX_MARKOV_DISABLE 0xff22
5963 #define IDX_MARKOV_CLASSIC 0xff23
5964 #define IDX_MARKOV_THRESHOLD 't'
5965 #define IDX_MARKOV_HCSTAT 0xff24
5966 #define IDX_CPU_AFFINITY 0xff25
5967 #define IDX_OPENCL_DEVICES 'd'
5968 #define IDX_OPENCL_PLATFORMS 0xff72
5969 #define IDX_OPENCL_DEVICE_TYPES 'D'
5970 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5971 #define IDX_WORKLOAD_PROFILE 'w'
5972 #define IDX_KERNEL_ACCEL 'n'
5973 #define IDX_KERNEL_LOOPS 'u'
5974 #define IDX_NVIDIA_SPIN_DAMP 0xff79
5975 #define IDX_GPU_TEMP_DISABLE 0xff29
5976 #define IDX_GPU_TEMP_ABORT 0xff30
5977 #define IDX_GPU_TEMP_RETAIN 0xff31
5978 #define IDX_POWERTUNE_ENABLE 0xff41
5979 #define IDX_LOGFILE_DISABLE 0xff51
5980 #define IDX_TRUECRYPT_KEYFILES 0xff52
5981 #define IDX_VERACRYPT_KEYFILES 0xff53
5982 #define IDX_VERACRYPT_PIM 0xff54
5983 #define IDX_SCRYPT_TMTO 0xff61
5984 #define IDX_SEGMENT_SIZE 'c'
5985 #define IDX_SEPARATOR 'p'
5986 #define IDX_BITMAP_MIN 0xff70
5987 #define IDX_BITMAP_MAX 0xff71
5988 #define IDX_CUSTOM_CHARSET_1 '1'
5989 #define IDX_CUSTOM_CHARSET_2 '2'
5990 #define IDX_CUSTOM_CHARSET_3 '3'
5991 #define IDX_CUSTOM_CHARSET_4 '4'
5992
5993 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:D:n:u:c:p:s:l:1:2:3:4:ibw:";
5994
5995 struct option long_options[] =
5996 {
5997 {"help", no_argument, 0, IDX_HELP},
5998 {"version", no_argument, 0, IDX_VERSION},
5999 {"quiet", no_argument, 0, IDX_QUIET},
6000 {"show", no_argument, 0, IDX_SHOW},
6001 {"left", no_argument, 0, IDX_LEFT},
6002 {"username", no_argument, 0, IDX_USERNAME},
6003 {"remove", no_argument, 0, IDX_REMOVE},
6004 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
6005 {"skip", required_argument, 0, IDX_SKIP},
6006 {"limit", required_argument, 0, IDX_LIMIT},
6007 {"keyspace", no_argument, 0, IDX_KEYSPACE},
6008 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
6009 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
6010 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
6011 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
6012 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
6013 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
6014 {"force", no_argument, 0, IDX_FORCE},
6015 {"benchmark", no_argument, 0, IDX_BENCHMARK},
6016 {"stdout", no_argument, 0, IDX_STDOUT_FLAG},
6017 {"restore", no_argument, 0, IDX_RESTORE},
6018 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
6019 {"status", no_argument, 0, IDX_STATUS},
6020 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
6021 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
6022 {"loopback", no_argument, 0, IDX_LOOPBACK},
6023 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
6024 {"session", required_argument, 0, IDX_SESSION},
6025 {"runtime", required_argument, 0, IDX_RUNTIME},
6026 {"generate-rules", required_argument, 0, IDX_RP_GEN},
6027 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
6028 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
6029 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
6030 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
6031 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
6032 {"hash-type", required_argument, 0, IDX_HASH_MODE},
6033 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
6034 {"rules-file", required_argument, 0, IDX_RP_FILE},
6035 {"outfile", required_argument, 0, IDX_OUTFILE},
6036 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
6037 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
6038 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
6039 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
6040 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
6041 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
6042 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
6043 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
6044 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
6045 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
6046 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
6047 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
6048 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
6049 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
6050 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
6051 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
6052 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
6053 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
6054 {"nvidia-spin-damp", required_argument, 0, IDX_NVIDIA_SPIN_DAMP},
6055 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
6056 #ifdef HAVE_HWMON
6057 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
6058 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
6059 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
6060 #endif // HAVE_HWMON
6061 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
6062 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
6063 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
6064 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
6065 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
6066 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
6067 {"seperator", required_argument, 0, IDX_SEPARATOR},
6068 {"separator", required_argument, 0, IDX_SEPARATOR},
6069 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
6070 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
6071 {"increment", no_argument, 0, IDX_INCREMENT},
6072 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
6073 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
6074 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
6075 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
6076 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
6077 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
6078 {0, 0, 0, 0}
6079 };
6080
6081 uint rp_files_cnt = 0;
6082
6083 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6084
6085 int option_index = 0;
6086 int c = -1;
6087
6088 optind = 1;
6089 optopt = 0;
6090
6091 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6092 {
6093 switch (c)
6094 {
6095 case IDX_HELP: usage = 1; break;
6096 case IDX_VERSION:
6097 case IDX_VERSION_LOWER: version = 1; break;
6098 case IDX_RESTORE: restore = 1; break;
6099 case IDX_SESSION: session = optarg; break;
6100 case IDX_SHOW: show = 1; break;
6101 case IDX_LEFT: left = 1; break;
6102 case '?': return (-1);
6103 }
6104 }
6105
6106 if (optopt != 0)
6107 {
6108 log_error ("ERROR: Invalid argument specified");
6109
6110 return (-1);
6111 }
6112
6113 /**
6114 * exit functions
6115 */
6116
6117 if (version)
6118 {
6119 log_info ("%s", VERSION_TAG);
6120
6121 return (0);
6122 }
6123
6124 if (usage)
6125 {
6126 usage_big_print (PROGNAME);
6127
6128 return (0);
6129 }
6130
6131 /**
6132 * session needs to be set, always!
6133 */
6134
6135 if (session == NULL) session = (char *) PROGNAME;
6136
6137 /**
6138 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6139 */
6140
6141 char *exec_path = get_exec_path ();
6142
6143 #ifdef LINUX
6144
6145 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6146 char *resolved_exec_path = realpath (exec_path, NULL);
6147
6148 char *install_dir = get_install_dir (resolved_exec_path);
6149 char *profile_dir = NULL;
6150 char *session_dir = NULL;
6151 char *shared_dir = NULL;
6152
6153 if (strcmp (install_dir, resolved_install_folder) == 0)
6154 {
6155 struct passwd *pw = getpwuid (getuid ());
6156
6157 const char *homedir = pw->pw_dir;
6158
6159 profile_dir = get_profile_dir (homedir);
6160 session_dir = get_session_dir (profile_dir);
6161 shared_dir = strdup (SHARED_FOLDER);
6162
6163 mkdir (profile_dir, 0700);
6164 mkdir (session_dir, 0700);
6165 }
6166 else
6167 {
6168 profile_dir = install_dir;
6169 session_dir = install_dir;
6170 shared_dir = install_dir;
6171 }
6172
6173 myfree (resolved_install_folder);
6174 myfree (resolved_exec_path);
6175
6176 #else
6177
6178 char *install_dir = get_install_dir (exec_path);
6179 char *profile_dir = install_dir;
6180 char *session_dir = install_dir;
6181 char *shared_dir = install_dir;
6182
6183 #endif
6184
6185 data.install_dir = install_dir;
6186 data.profile_dir = profile_dir;
6187 data.session_dir = session_dir;
6188 data.shared_dir = shared_dir;
6189
6190 myfree (exec_path);
6191
6192 /**
6193 * kernel cache, we need to make sure folder exist
6194 */
6195
6196 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6197
6198 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6199
6200 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6201
6202 mkdir (kernels_folder, 0700);
6203
6204 myfree (kernels_folder);
6205
6206 /**
6207 * session
6208 */
6209
6210 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6211
6212 data.session = session;
6213
6214 char *eff_restore_file = (char *) mymalloc (session_size);
6215 char *new_restore_file = (char *) mymalloc (session_size);
6216
6217 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
6218 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6219
6220 data.eff_restore_file = eff_restore_file;
6221 data.new_restore_file = new_restore_file;
6222
6223 if (((show == 1) || (left == 1)) && (restore == 1))
6224 {
6225 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6226 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6227
6228 return (-1);
6229 }
6230
6231 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6232 if ((show == 1) || (left == 1))
6233 {
6234 restore_disable = 1;
6235
6236 restore = 0;
6237 }
6238
6239 data.restore_disable = restore_disable;
6240
6241 restore_data_t *rd = init_restore (argc, argv);
6242
6243 data.rd = rd;
6244
6245 /**
6246 * restore file
6247 */
6248
6249 if (restore == 1)
6250 {
6251 read_restore (eff_restore_file, rd);
6252
6253 if (rd->version_bin < RESTORE_MIN)
6254 {
6255 log_error ("ERROR: Incompatible restore-file version");
6256
6257 return (-1);
6258 }
6259
6260 myargc = rd->argc;
6261 myargv = rd->argv;
6262
6263 #ifdef _POSIX
6264 rd->pid = getpid ();
6265 #elif _WIN
6266 rd->pid = GetCurrentProcessId ();
6267 #endif
6268 }
6269
6270 uint hash_mode_chgd = 0;
6271 uint runtime_chgd = 0;
6272 uint kernel_loops_chgd = 0;
6273 uint kernel_accel_chgd = 0;
6274 uint nvidia_spin_damp_chgd = 0;
6275 uint attack_mode_chgd = 0;
6276 uint outfile_format_chgd = 0;
6277 uint rp_gen_seed_chgd = 0;
6278 uint remove_timer_chgd = 0;
6279 uint increment_min_chgd = 0;
6280 uint increment_max_chgd = 0;
6281 uint workload_profile_chgd = 0;
6282 uint opencl_vector_width_chgd = 0;
6283
6284 optind = 1;
6285 optopt = 0;
6286 option_index = 0;
6287
6288 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6289 {
6290 switch (c)
6291 {
6292 //case IDX_HELP: usage = 1; break;
6293 //case IDX_VERSION: version = 1; break;
6294 //case IDX_RESTORE: restore = 1; break;
6295 case IDX_QUIET: quiet = 1; break;
6296 //case IDX_SHOW: show = 1; break;
6297 case IDX_SHOW: break;
6298 //case IDX_LEFT: left = 1; break;
6299 case IDX_LEFT: break;
6300 case IDX_USERNAME: username = 1; break;
6301 case IDX_REMOVE: remove = 1; break;
6302 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6303 remove_timer_chgd = 1; break;
6304 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6305 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6306 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6307 case IDX_DEBUG_FILE: debug_file = optarg; break;
6308 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6309 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6310 case IDX_FORCE: force = 1; break;
6311 case IDX_SKIP: skip = atoll (optarg); break;
6312 case IDX_LIMIT: limit = atoll (optarg); break;
6313 case IDX_KEYSPACE: keyspace = 1; break;
6314 case IDX_BENCHMARK: benchmark = 1; break;
6315 case IDX_STDOUT_FLAG: stdout_flag = 1; break;
6316 case IDX_RESTORE: break;
6317 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6318 case IDX_STATUS: status = 1; break;
6319 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6320 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6321 case IDX_LOOPBACK: loopback = 1; break;
6322 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6323 //case IDX_SESSION: session = optarg; break;
6324 case IDX_SESSION: break;
6325 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6326 hash_mode_chgd = 1; break;
6327 case IDX_RUNTIME: runtime = atoi (optarg);
6328 runtime_chgd = 1; break;
6329 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6330 attack_mode_chgd = 1; break;
6331 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6332 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6333 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6334 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6335 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6336 rp_gen_seed_chgd = 1; break;
6337 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6338 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6339 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6340 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6341 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6342 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6343 case IDX_OUTFILE: outfile = optarg; break;
6344 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6345 outfile_format_chgd = 1; break;
6346 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6347 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6348 case IDX_HEX_CHARSET: hex_charset = 1; break;
6349 case IDX_HEX_SALT: hex_salt = 1; break;
6350 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6351 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6352 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6353 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6354 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6355 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6356 opencl_vector_width_chgd = 1; break;
6357 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6358 workload_profile_chgd = 1; break;
6359 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6360 kernel_accel_chgd = 1; break;
6361 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6362 kernel_loops_chgd = 1; break;
6363 case IDX_NVIDIA_SPIN_DAMP: nvidia_spin_damp = atoi (optarg);
6364 nvidia_spin_damp_chgd = 1; break;
6365 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6366 #ifdef HAVE_HWMON
6367 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6368 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6369 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6370 #endif // HAVE_HWMON
6371 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6372 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6373 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6374 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6375 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6376 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6377 case IDX_SEPARATOR: separator = optarg[0]; break;
6378 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6379 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6380 case IDX_INCREMENT: increment = 1; break;
6381 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6382 increment_min_chgd = 1; break;
6383 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6384 increment_max_chgd = 1; break;
6385 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6386 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6387 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6388 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6389
6390 default:
6391 log_error ("ERROR: Invalid argument specified");
6392 return (-1);
6393 }
6394 }
6395
6396 if (optopt != 0)
6397 {
6398 log_error ("ERROR: Invalid argument specified");
6399
6400 return (-1);
6401 }
6402
6403 /**
6404 * Inform user things getting started,
6405 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6406 * - we do not need to check algorithm_pos
6407 */
6408
6409 if (quiet == 0)
6410 {
6411 if (benchmark == 1)
6412 {
6413 if (machine_readable == 0)
6414 {
6415 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6416 log_info ("");
6417 }
6418 else
6419 {
6420 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6421 }
6422 }
6423 else if (restore == 1)
6424 {
6425 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6426 log_info ("");
6427 }
6428 else if (stdout_flag == 1)
6429 {
6430 // do nothing
6431 }
6432 else if (keyspace == 1)
6433 {
6434 // do nothing
6435 }
6436 else
6437 {
6438 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6439 log_info ("");
6440 }
6441 }
6442
6443 /**
6444 * sanity check
6445 */
6446
6447 if (attack_mode > 7)
6448 {
6449 log_error ("ERROR: Invalid attack-mode specified");
6450
6451 return (-1);
6452 }
6453
6454 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6455 {
6456 log_error ("ERROR: Invalid runtime specified");
6457
6458 return (-1);
6459 }
6460
6461 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6462 {
6463 log_error ("ERROR: Invalid hash-type specified");
6464
6465 return (-1);
6466 }
6467
6468 // renamed hash modes
6469
6470 if (hash_mode_chgd)
6471 {
6472 int n = -1;
6473
6474 switch (hash_mode)
6475 {
6476 case 123: n = 124;
6477 break;
6478 }
6479
6480 if (n >= 0)
6481 {
6482 log_error ("Old -m specified, use -m %d instead", n);
6483
6484 return (-1);
6485 }
6486 }
6487
6488 if (username == 1)
6489 {
6490 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6491 {
6492 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6493
6494 return (-1);
6495 }
6496 }
6497
6498 if (outfile_format > 16)
6499 {
6500 log_error ("ERROR: Invalid outfile-format specified");
6501
6502 return (-1);
6503 }
6504
6505 if (left == 1)
6506 {
6507 if (outfile_format_chgd == 1)
6508 {
6509 if (outfile_format > 1)
6510 {
6511 log_error ("ERROR: Mixing outfile-format > 1 with left parameter is not allowed");
6512
6513 return (-1);
6514 }
6515 }
6516 else
6517 {
6518 outfile_format = OUTFILE_FMT_HASH;
6519 }
6520 }
6521
6522 if (show == 1)
6523 {
6524 if (outfile_format_chgd == 1)
6525 {
6526 if ((outfile_format > 7) && (outfile_format < 16))
6527 {
6528 log_error ("ERROR: Mixing outfile-format > 7 with show parameter is not allowed");
6529
6530 return (-1);
6531 }
6532 }
6533 }
6534
6535 if (increment_min < INCREMENT_MIN)
6536 {
6537 log_error ("ERROR: Invalid increment-min specified");
6538
6539 return (-1);
6540 }
6541
6542 if (increment_max > INCREMENT_MAX)
6543 {
6544 log_error ("ERROR: Invalid increment-max specified");
6545
6546 return (-1);
6547 }
6548
6549 if (increment_min > increment_max)
6550 {
6551 log_error ("ERROR: Invalid increment-min specified");
6552
6553 return (-1);
6554 }
6555
6556 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6557 {
6558 log_error ("ERROR: Increment is not allowed in attack-mode 0");
6559
6560 return (-1);
6561 }
6562
6563 if ((increment == 0) && (increment_min_chgd == 1))
6564 {
6565 log_error ("ERROR: Increment-min is only supported combined with increment switch");
6566
6567 return (-1);
6568 }
6569
6570 if ((increment == 0) && (increment_max_chgd == 1))
6571 {
6572 log_error ("ERROR: Increment-max is only supported combined with increment switch");
6573
6574 return (-1);
6575 }
6576
6577 if (rp_files_cnt && rp_gen)
6578 {
6579 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6580
6581 return (-1);
6582 }
6583
6584 if (rp_files_cnt || rp_gen)
6585 {
6586 if (attack_mode != ATTACK_MODE_STRAIGHT)
6587 {
6588 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6589
6590 return (-1);
6591 }
6592 }
6593
6594 if (rp_gen_func_min > rp_gen_func_max)
6595 {
6596 log_error ("ERROR: Invalid rp-gen-func-min specified");
6597
6598 return (-1);
6599 }
6600
6601 if (kernel_accel_chgd == 1)
6602 {
6603 if (force == 0)
6604 {
6605 log_info ("The manual use of the -n option (or --kernel-accel) is outdated");
6606 log_info ("Please consider using the -w option instead");
6607 log_info ("You can use --force to override this but do not post error reports if you do so");
6608 log_info ("");
6609
6610 return (-1);
6611 }
6612
6613 if (kernel_accel < 1)
6614 {
6615 log_error ("ERROR: Invalid kernel-accel specified");
6616
6617 return (-1);
6618 }
6619
6620 if (kernel_accel > 1024)
6621 {
6622 log_error ("ERROR: Invalid kernel-accel specified");
6623
6624 return (-1);
6625 }
6626 }
6627
6628 if (kernel_loops_chgd == 1)
6629 {
6630 if (force == 0)
6631 {
6632 log_info ("The manual use of the -u option (or --kernel-loops) is outdated");
6633 log_info ("Please consider using the -w option instead");
6634 log_info ("You can use --force to override this but do not post error reports if you do so");
6635 log_info ("");
6636
6637 return (-1);
6638 }
6639
6640 if (kernel_loops < 1)
6641 {
6642 log_error ("ERROR: Invalid kernel-loops specified");
6643
6644 return (-1);
6645 }
6646
6647 if (kernel_loops > 1024)
6648 {
6649 log_error ("ERROR: Invalid kernel-loops specified");
6650
6651 return (-1);
6652 }
6653 }
6654
6655 if ((workload_profile < 1) || (workload_profile > 4))
6656 {
6657 log_error ("ERROR: workload-profile %i not available", workload_profile);
6658
6659 return (-1);
6660 }
6661
6662 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6663 {
6664 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6665
6666 return (-1);
6667 }
6668
6669 if (show == 1 || left == 1)
6670 {
6671 attack_mode = ATTACK_MODE_NONE;
6672
6673 if (remove == 1)
6674 {
6675 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6676
6677 return (-1);
6678 }
6679
6680 if (potfile_disable == 1)
6681 {
6682 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6683
6684 return (-1);
6685 }
6686 }
6687
6688 uint attack_kern = ATTACK_KERN_NONE;
6689
6690 switch (attack_mode)
6691 {
6692 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6693 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6694 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6695 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6696 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6697 }
6698
6699 if (benchmark == 1)
6700 {
6701 if (myargv[optind] != 0)
6702 {
6703 log_error ("ERROR: Invalid argument for benchmark mode specified");
6704
6705 return (-1);
6706 }
6707
6708 if (attack_mode_chgd == 1)
6709 {
6710 if (attack_mode != ATTACK_MODE_BF)
6711 {
6712 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6713
6714 return (-1);
6715 }
6716 }
6717 }
6718 else
6719 {
6720 if (stdout_flag == 1) // no hash here
6721 {
6722 optind--;
6723 }
6724
6725 if (keyspace == 1)
6726 {
6727 int num_additional_params = 1;
6728
6729 if (attack_kern == ATTACK_KERN_COMBI)
6730 {
6731 num_additional_params = 2;
6732 }
6733
6734 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6735
6736 if (keyspace_wordlist_specified == 0) optind--;
6737 }
6738
6739 if (attack_kern == ATTACK_KERN_NONE)
6740 {
6741 if ((optind + 1) != myargc)
6742 {
6743 usage_mini_print (myargv[0]);
6744
6745 return (-1);
6746 }
6747 }
6748 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6749 {
6750 if ((optind + 1) > myargc)
6751 {
6752 usage_mini_print (myargv[0]);
6753
6754 return (-1);
6755 }
6756 }
6757 else if (attack_kern == ATTACK_KERN_COMBI)
6758 {
6759 if ((optind + 3) != myargc)
6760 {
6761 usage_mini_print (myargv[0]);
6762
6763 return (-1);
6764 }
6765 }
6766 else if (attack_kern == ATTACK_KERN_BF)
6767 {
6768 if ((optind + 1) > myargc)
6769 {
6770 usage_mini_print (myargv[0]);
6771
6772 return (-1);
6773 }
6774 }
6775 else
6776 {
6777 usage_mini_print (myargv[0]);
6778
6779 return (-1);
6780 }
6781 }
6782
6783 if (skip != 0 && limit != 0)
6784 {
6785 limit += skip;
6786 }
6787
6788 if (keyspace == 1)
6789 {
6790 if (show == 1)
6791 {
6792 log_error ("ERROR: Combining show parameter with keyspace parameter is not allowed");
6793
6794 return (-1);
6795 }
6796 else if (left == 1)
6797 {
6798 log_error ("ERROR: Combining left parameter with keyspace parameter is not allowed");
6799
6800 return (-1);
6801 }
6802
6803 potfile_disable = 1;
6804
6805 restore_disable = 1;
6806
6807 restore = 0;
6808
6809 weak_hash_threshold = 0;
6810
6811 quiet = 1;
6812 }
6813
6814 if (stdout_flag == 1)
6815 {
6816 status_timer = 0;
6817 restore_timer = 0;
6818 restore_disable = 1;
6819 restore = 0;
6820 potfile_disable = 1;
6821 weak_hash_threshold = 0;
6822 gpu_temp_disable = 1;
6823 hash_mode = 2000;
6824 quiet = 1;
6825 outfile_format = OUTFILE_FMT_PLAIN;
6826 kernel_accel = 1024;
6827 kernel_loops = 1024;
6828 force = 1;
6829 outfile_check_timer = 0;
6830 session = "stdout";
6831 opencl_vector_width = 1;
6832 }
6833
6834 if (remove_timer_chgd == 1)
6835 {
6836 if (remove == 0)
6837 {
6838 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6839
6840 return (-1);
6841 }
6842
6843 if (remove_timer < 1)
6844 {
6845 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6846
6847 return (-1);
6848 }
6849 }
6850
6851 if (loopback == 1)
6852 {
6853 if (attack_mode == ATTACK_MODE_STRAIGHT)
6854 {
6855 if ((rp_files_cnt == 0) && (rp_gen == 0))
6856 {
6857 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6858
6859 return (-1);
6860 }
6861 }
6862 else
6863 {
6864 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6865
6866 return (-1);
6867 }
6868 }
6869
6870 if (debug_mode > 0)
6871 {
6872 if (attack_mode != ATTACK_MODE_STRAIGHT)
6873 {
6874 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6875
6876 return (-1);
6877 }
6878
6879 if ((rp_files_cnt == 0) && (rp_gen == 0))
6880 {
6881 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6882
6883 return (-1);
6884 }
6885 }
6886
6887 if (debug_mode > 4)
6888 {
6889 log_error ("ERROR: Invalid debug-mode specified");
6890
6891 return (-1);
6892 }
6893
6894 if (debug_file != NULL)
6895 {
6896 if (debug_mode < 1)
6897 {
6898 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6899
6900 return (-1);
6901 }
6902 }
6903
6904 if (induction_dir != NULL)
6905 {
6906 if (attack_mode == ATTACK_MODE_BF)
6907 {
6908 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6909
6910 return (-1);
6911 }
6912 }
6913
6914 if (attack_mode != ATTACK_MODE_STRAIGHT)
6915 {
6916 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6917 {
6918 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6919
6920 return (-1);
6921 }
6922
6923 weak_hash_threshold = 0;
6924 }
6925
6926 if (nvidia_spin_damp > 100)
6927 {
6928 log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)");
6929
6930 return (-1);
6931 }
6932
6933
6934 /**
6935 * induction directory
6936 */
6937
6938 char *induction_directory = NULL;
6939
6940 if (attack_mode != ATTACK_MODE_BF)
6941 {
6942 if (induction_dir == NULL)
6943 {
6944 induction_directory = (char *) mymalloc (session_size);
6945
6946 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6947
6948 // create induction folder if it does not already exist
6949
6950 if (keyspace == 0)
6951 {
6952 if (rmdir (induction_directory) == -1)
6953 {
6954 if (errno == ENOENT)
6955 {
6956 // good, we can ignore
6957 }
6958 else if (errno == ENOTEMPTY)
6959 {
6960 char *induction_directory_mv = (char *) mymalloc (session_size);
6961
6962 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6963
6964 if (rename (induction_directory, induction_directory_mv) != 0)
6965 {
6966 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6967
6968 return (-1);
6969 }
6970 }
6971 else
6972 {
6973 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6974
6975 return (-1);
6976 }
6977 }
6978
6979 if (mkdir (induction_directory, 0700) == -1)
6980 {
6981 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6982
6983 return (-1);
6984 }
6985 }
6986 }
6987 else
6988 {
6989 induction_directory = induction_dir;
6990 }
6991 }
6992
6993 data.induction_directory = induction_directory;
6994
6995 /**
6996 * loopback
6997 */
6998
6999 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
7000
7001 char *loopback_file = (char *) mymalloc (loopback_size);
7002
7003 /**
7004 * tuning db
7005 */
7006
7007 char tuning_db_file[256] = { 0 };
7008
7009 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
7010
7011 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
7012
7013 /**
7014 * outfile-check directory
7015 */
7016
7017 char *outfile_check_directory = NULL;
7018
7019 if (outfile_check_dir == NULL)
7020 {
7021 outfile_check_directory = (char *) mymalloc (session_size);
7022
7023 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
7024 }
7025 else
7026 {
7027 outfile_check_directory = outfile_check_dir;
7028 }
7029
7030 data.outfile_check_directory = outfile_check_directory;
7031
7032 if (keyspace == 0)
7033 {
7034 struct stat outfile_check_stat;
7035
7036 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
7037 {
7038 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
7039
7040 if (is_dir == 0)
7041 {
7042 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
7043
7044 return (-1);
7045 }
7046 }
7047 else if (outfile_check_dir == NULL)
7048 {
7049 if (mkdir (outfile_check_directory, 0700) == -1)
7050 {
7051 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
7052
7053 return (-1);
7054 }
7055 }
7056 }
7057
7058 /**
7059 * special other stuff
7060 */
7061
7062 if (hash_mode == 9710)
7063 {
7064 outfile_format = 5;
7065 outfile_format_chgd = 1;
7066 }
7067
7068 if (hash_mode == 9810)
7069 {
7070 outfile_format = 5;
7071 outfile_format_chgd = 1;
7072 }
7073
7074 if (hash_mode == 10410)
7075 {
7076 outfile_format = 5;
7077 outfile_format_chgd = 1;
7078 }
7079
7080 /**
7081 * store stuff
7082 */
7083
7084 data.hash_mode = hash_mode;
7085 data.restore = restore;
7086 data.restore_timer = restore_timer;
7087 data.restore_disable = restore_disable;
7088 data.status = status;
7089 data.status_timer = status_timer;
7090 data.machine_readable = machine_readable;
7091 data.loopback = loopback;
7092 data.runtime = runtime;
7093 data.remove = remove;
7094 data.remove_timer = remove_timer;
7095 data.debug_mode = debug_mode;
7096 data.debug_file = debug_file;
7097 data.username = username;
7098 data.quiet = quiet;
7099 data.outfile = outfile;
7100 data.outfile_format = outfile_format;
7101 data.outfile_autohex = outfile_autohex;
7102 data.hex_charset = hex_charset;
7103 data.hex_salt = hex_salt;
7104 data.hex_wordlist = hex_wordlist;
7105 data.separator = separator;
7106 data.rp_files = rp_files;
7107 data.rp_files_cnt = rp_files_cnt;
7108 data.rp_gen = rp_gen;
7109 data.rp_gen_seed = rp_gen_seed;
7110 data.force = force;
7111 data.benchmark = benchmark;
7112 data.skip = skip;
7113 data.limit = limit;
7114 #ifdef HAVE_HWMON
7115 data.powertune_enable = powertune_enable;
7116 #endif
7117 data.logfile_disable = logfile_disable;
7118 data.truecrypt_keyfiles = truecrypt_keyfiles;
7119 data.veracrypt_keyfiles = veracrypt_keyfiles;
7120 data.veracrypt_pim = veracrypt_pim;
7121 data.scrypt_tmto = scrypt_tmto;
7122 data.workload_profile = workload_profile;
7123
7124 /**
7125 * cpu affinity
7126 */
7127
7128 if (cpu_affinity)
7129 {
7130 set_cpu_affinity (cpu_affinity);
7131 }
7132
7133 if (rp_gen_seed_chgd == 0)
7134 {
7135 srand (proc_start);
7136 }
7137 else
7138 {
7139 srand (rp_gen_seed);
7140 }
7141
7142 /**
7143 * logfile init
7144 */
7145
7146 if (logfile_disable == 0)
7147 {
7148 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7149
7150 char *logfile = (char *) mymalloc (logfile_size);
7151
7152 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7153
7154 data.logfile = logfile;
7155
7156 char *topid = logfile_generate_topid ();
7157
7158 data.topid = topid;
7159 }
7160
7161 // logfile_append() checks for logfile_disable internally to make it easier from here
7162
7163 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7164 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7165 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7166 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7167 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7168 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7169 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7170 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7171 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7172 #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));
7173
7174 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7175 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7176 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7177 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7178 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7179 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7180 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7181 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7182
7183 logfile_top_msg ("START");
7184
7185 logfile_top_uint (attack_mode);
7186 logfile_top_uint (attack_kern);
7187 logfile_top_uint (benchmark);
7188 logfile_top_uint (stdout_flag);
7189 logfile_top_uint (bitmap_min);
7190 logfile_top_uint (bitmap_max);
7191 logfile_top_uint (debug_mode);
7192 logfile_top_uint (force);
7193 logfile_top_uint (kernel_accel);
7194 logfile_top_uint (kernel_loops);
7195 logfile_top_uint (nvidia_spin_damp);
7196 logfile_top_uint (gpu_temp_disable);
7197 #ifdef HAVE_HWMON
7198 logfile_top_uint (gpu_temp_abort);
7199 logfile_top_uint (gpu_temp_retain);
7200 #endif
7201 logfile_top_uint (hash_mode);
7202 logfile_top_uint (hex_charset);
7203 logfile_top_uint (hex_salt);
7204 logfile_top_uint (hex_wordlist);
7205 logfile_top_uint (increment);
7206 logfile_top_uint (increment_max);
7207 logfile_top_uint (increment_min);
7208 logfile_top_uint (keyspace);
7209 logfile_top_uint (left);
7210 logfile_top_uint (logfile_disable);
7211 logfile_top_uint (loopback);
7212 logfile_top_uint (markov_classic);
7213 logfile_top_uint (markov_disable);
7214 logfile_top_uint (markov_threshold);
7215 logfile_top_uint (outfile_autohex);
7216 logfile_top_uint (outfile_check_timer);
7217 logfile_top_uint (outfile_format);
7218 logfile_top_uint (potfile_disable);
7219 logfile_top_string (potfile_path);
7220 #if defined(HAVE_HWMON)
7221 logfile_top_uint (powertune_enable);
7222 #endif
7223 logfile_top_uint (scrypt_tmto);
7224 logfile_top_uint (quiet);
7225 logfile_top_uint (remove);
7226 logfile_top_uint (remove_timer);
7227 logfile_top_uint (restore);
7228 logfile_top_uint (restore_disable);
7229 logfile_top_uint (restore_timer);
7230 logfile_top_uint (rp_gen);
7231 logfile_top_uint (rp_gen_func_max);
7232 logfile_top_uint (rp_gen_func_min);
7233 logfile_top_uint (rp_gen_seed);
7234 logfile_top_uint (runtime);
7235 logfile_top_uint (segment_size);
7236 logfile_top_uint (show);
7237 logfile_top_uint (status);
7238 logfile_top_uint (machine_readable);
7239 logfile_top_uint (status_timer);
7240 logfile_top_uint (usage);
7241 logfile_top_uint (username);
7242 logfile_top_uint (version);
7243 logfile_top_uint (weak_hash_threshold);
7244 logfile_top_uint (workload_profile);
7245 logfile_top_uint64 (limit);
7246 logfile_top_uint64 (skip);
7247 logfile_top_char (separator);
7248 logfile_top_string (cpu_affinity);
7249 logfile_top_string (custom_charset_1);
7250 logfile_top_string (custom_charset_2);
7251 logfile_top_string (custom_charset_3);
7252 logfile_top_string (custom_charset_4);
7253 logfile_top_string (debug_file);
7254 logfile_top_string (opencl_devices);
7255 logfile_top_string (opencl_platforms);
7256 logfile_top_string (opencl_device_types);
7257 logfile_top_uint (opencl_vector_width);
7258 logfile_top_string (induction_dir);
7259 logfile_top_string (markov_hcstat);
7260 logfile_top_string (outfile);
7261 logfile_top_string (outfile_check_dir);
7262 logfile_top_string (rule_buf_l);
7263 logfile_top_string (rule_buf_r);
7264 logfile_top_string (session);
7265 logfile_top_string (truecrypt_keyfiles);
7266 logfile_top_string (veracrypt_keyfiles);
7267 logfile_top_uint (veracrypt_pim);
7268
7269 /**
7270 * Init OpenCL library loader
7271 */
7272
7273 if (keyspace == 0)
7274 {
7275 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7276
7277 ocl_init (ocl);
7278
7279 data.ocl = ocl;
7280 }
7281
7282 /**
7283 * OpenCL platform selection
7284 */
7285
7286 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7287
7288 /**
7289 * OpenCL device selection
7290 */
7291
7292 u32 devices_filter = setup_devices_filter (opencl_devices);
7293
7294 /**
7295 * OpenCL device type selection
7296 */
7297
7298 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7299
7300 /**
7301 * benchmark
7302 */
7303
7304 if (benchmark == 1)
7305 {
7306 /**
7307 * disable useless stuff for benchmark
7308 */
7309
7310 status_timer = 0;
7311 restore_timer = 0;
7312 restore_disable = 1;
7313 potfile_disable = 1;
7314 weak_hash_threshold = 0;
7315 nvidia_spin_damp = 0;
7316 gpu_temp_disable = 1;
7317 outfile_check_timer = 0;
7318
7319 #ifdef HAVE_HWMON
7320 if (powertune_enable == 1)
7321 {
7322 gpu_temp_disable = 0;
7323 }
7324 #endif
7325
7326 data.status_timer = status_timer;
7327 data.restore_timer = restore_timer;
7328 data.restore_disable = restore_disable;
7329 data.outfile_check_timer = outfile_check_timer;
7330
7331 /**
7332 * force attack mode to be bruteforce
7333 */
7334
7335 attack_mode = ATTACK_MODE_BF;
7336 attack_kern = ATTACK_KERN_BF;
7337
7338 if (workload_profile_chgd == 0)
7339 {
7340 workload_profile = 3;
7341
7342 data.workload_profile = workload_profile;
7343 }
7344 }
7345
7346 /**
7347 * status, monitor and outfile remove threads
7348 */
7349
7350 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
7351
7352 data.wordlist_mode = wordlist_mode;
7353
7354 if (wordlist_mode == WL_MODE_STDIN)
7355 {
7356 status = 1;
7357
7358 data.status = status;
7359 }
7360
7361 uint outer_threads_cnt = 0;
7362
7363 hc_thread_t *outer_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
7364
7365 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
7366 {
7367 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
7368 {
7369 hc_thread_create (outer_threads[outer_threads_cnt], thread_keypress, NULL);
7370
7371 outer_threads_cnt++;
7372 }
7373
7374 hc_thread_create (outer_threads[outer_threads_cnt], thread_monitor, NULL);
7375
7376 outer_threads_cnt++;
7377 }
7378
7379 /**
7380 * config
7381 */
7382
7383 uint hash_type = 0;
7384 uint salt_type = 0;
7385 uint attack_exec = 0;
7386 uint opts_type = 0;
7387 uint kern_type = 0;
7388 uint dgst_size = 0;
7389 uint esalt_size = 0;
7390 uint opti_type = 0;
7391 uint dgst_pos0 = -1;
7392 uint dgst_pos1 = -1;
7393 uint dgst_pos2 = -1;
7394 uint dgst_pos3 = -1;
7395
7396 int (*parse_func) (char *, uint, hash_t *);
7397 int (*sort_by_digest) (const void *, const void *);
7398
7399 uint algorithm_pos = 0;
7400 uint algorithm_max = 1;
7401
7402 uint *algorithms = default_benchmark_algorithms;
7403
7404 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7405
7406 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7407 {
7408 /*
7409 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7410 * the following algos are skipped entirely
7411 */
7412
7413 if (algorithm_pos > 0)
7414 {
7415 local_free (rd);
7416
7417 rd = init_restore (argc, argv);
7418
7419 data.rd = rd;
7420 }
7421
7422 /**
7423 * update hash_mode in case of multihash benchmark
7424 */
7425
7426 if (benchmark == 1)
7427 {
7428 if (hash_mode_chgd == 0)
7429 {
7430 hash_mode = algorithms[algorithm_pos];
7431
7432 data.hash_mode = hash_mode;
7433 }
7434
7435 quiet = 1;
7436
7437 data.quiet = quiet;
7438 }
7439
7440 switch (hash_mode)
7441 {
7442 case 0: hash_type = HASH_TYPE_MD5;
7443 salt_type = SALT_TYPE_NONE;
7444 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7445 opts_type = OPTS_TYPE_PT_GENERATE_LE
7446 | OPTS_TYPE_PT_ADD80
7447 | OPTS_TYPE_PT_ADDBITS14;
7448 kern_type = KERN_TYPE_MD5;
7449 dgst_size = DGST_SIZE_4_4;
7450 parse_func = md5_parse_hash;
7451 sort_by_digest = sort_by_digest_4_4;
7452 opti_type = OPTI_TYPE_ZERO_BYTE
7453 | OPTI_TYPE_PRECOMPUTE_INIT
7454 | OPTI_TYPE_PRECOMPUTE_MERKLE
7455 | OPTI_TYPE_MEET_IN_MIDDLE
7456 | OPTI_TYPE_EARLY_SKIP
7457 | OPTI_TYPE_NOT_ITERATED
7458 | OPTI_TYPE_NOT_SALTED
7459 | OPTI_TYPE_RAW_HASH;
7460 dgst_pos0 = 0;
7461 dgst_pos1 = 3;
7462 dgst_pos2 = 2;
7463 dgst_pos3 = 1;
7464 break;
7465
7466 case 10: hash_type = HASH_TYPE_MD5;
7467 salt_type = SALT_TYPE_INTERN;
7468 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7469 opts_type = OPTS_TYPE_PT_GENERATE_LE
7470 | OPTS_TYPE_ST_ADD80
7471 | OPTS_TYPE_ST_ADDBITS14;
7472 kern_type = KERN_TYPE_MD5_PWSLT;
7473 dgst_size = DGST_SIZE_4_4;
7474 parse_func = md5s_parse_hash;
7475 sort_by_digest = sort_by_digest_4_4;
7476 opti_type = OPTI_TYPE_ZERO_BYTE
7477 | OPTI_TYPE_PRECOMPUTE_INIT
7478 | OPTI_TYPE_PRECOMPUTE_MERKLE
7479 | OPTI_TYPE_MEET_IN_MIDDLE
7480 | OPTI_TYPE_EARLY_SKIP
7481 | OPTI_TYPE_NOT_ITERATED
7482 | OPTI_TYPE_APPENDED_SALT
7483 | OPTI_TYPE_RAW_HASH;
7484 dgst_pos0 = 0;
7485 dgst_pos1 = 3;
7486 dgst_pos2 = 2;
7487 dgst_pos3 = 1;
7488 break;
7489
7490 case 11: hash_type = HASH_TYPE_MD5;
7491 salt_type = SALT_TYPE_INTERN;
7492 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7493 opts_type = OPTS_TYPE_PT_GENERATE_LE
7494 | OPTS_TYPE_ST_ADD80
7495 | OPTS_TYPE_ST_ADDBITS14;
7496 kern_type = KERN_TYPE_MD5_PWSLT;
7497 dgst_size = DGST_SIZE_4_4;
7498 parse_func = joomla_parse_hash;
7499 sort_by_digest = sort_by_digest_4_4;
7500 opti_type = OPTI_TYPE_ZERO_BYTE
7501 | OPTI_TYPE_PRECOMPUTE_INIT
7502 | OPTI_TYPE_PRECOMPUTE_MERKLE
7503 | OPTI_TYPE_MEET_IN_MIDDLE
7504 | OPTI_TYPE_EARLY_SKIP
7505 | OPTI_TYPE_NOT_ITERATED
7506 | OPTI_TYPE_APPENDED_SALT
7507 | OPTI_TYPE_RAW_HASH;
7508 dgst_pos0 = 0;
7509 dgst_pos1 = 3;
7510 dgst_pos2 = 2;
7511 dgst_pos3 = 1;
7512 break;
7513
7514 case 12: hash_type = HASH_TYPE_MD5;
7515 salt_type = SALT_TYPE_INTERN;
7516 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7517 opts_type = OPTS_TYPE_PT_GENERATE_LE
7518 | OPTS_TYPE_ST_ADD80
7519 | OPTS_TYPE_ST_ADDBITS14;
7520 kern_type = KERN_TYPE_MD5_PWSLT;
7521 dgst_size = DGST_SIZE_4_4;
7522 parse_func = postgresql_parse_hash;
7523 sort_by_digest = sort_by_digest_4_4;
7524 opti_type = OPTI_TYPE_ZERO_BYTE
7525 | OPTI_TYPE_PRECOMPUTE_INIT
7526 | OPTI_TYPE_PRECOMPUTE_MERKLE
7527 | OPTI_TYPE_MEET_IN_MIDDLE
7528 | OPTI_TYPE_EARLY_SKIP
7529 | OPTI_TYPE_NOT_ITERATED
7530 | OPTI_TYPE_APPENDED_SALT
7531 | OPTI_TYPE_RAW_HASH;
7532 dgst_pos0 = 0;
7533 dgst_pos1 = 3;
7534 dgst_pos2 = 2;
7535 dgst_pos3 = 1;
7536 break;
7537
7538 case 20: hash_type = HASH_TYPE_MD5;
7539 salt_type = SALT_TYPE_INTERN;
7540 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7541 opts_type = OPTS_TYPE_PT_GENERATE_LE
7542 | OPTS_TYPE_PT_ADD80
7543 | OPTS_TYPE_PT_ADDBITS14;
7544 kern_type = KERN_TYPE_MD5_SLTPW;
7545 dgst_size = DGST_SIZE_4_4;
7546 parse_func = md5s_parse_hash;
7547 sort_by_digest = sort_by_digest_4_4;
7548 opti_type = OPTI_TYPE_ZERO_BYTE
7549 | OPTI_TYPE_PRECOMPUTE_INIT
7550 | OPTI_TYPE_PRECOMPUTE_MERKLE
7551 | OPTI_TYPE_EARLY_SKIP
7552 | OPTI_TYPE_NOT_ITERATED
7553 | OPTI_TYPE_PREPENDED_SALT
7554 | OPTI_TYPE_RAW_HASH;
7555 dgst_pos0 = 0;
7556 dgst_pos1 = 3;
7557 dgst_pos2 = 2;
7558 dgst_pos3 = 1;
7559 break;
7560
7561 case 21: hash_type = HASH_TYPE_MD5;
7562 salt_type = SALT_TYPE_INTERN;
7563 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7564 opts_type = OPTS_TYPE_PT_GENERATE_LE
7565 | OPTS_TYPE_PT_ADD80
7566 | OPTS_TYPE_PT_ADDBITS14;
7567 kern_type = KERN_TYPE_MD5_SLTPW;
7568 dgst_size = DGST_SIZE_4_4;
7569 parse_func = osc_parse_hash;
7570 sort_by_digest = sort_by_digest_4_4;
7571 opti_type = OPTI_TYPE_ZERO_BYTE
7572 | OPTI_TYPE_PRECOMPUTE_INIT
7573 | OPTI_TYPE_PRECOMPUTE_MERKLE
7574 | OPTI_TYPE_EARLY_SKIP
7575 | OPTI_TYPE_NOT_ITERATED
7576 | OPTI_TYPE_PREPENDED_SALT
7577 | OPTI_TYPE_RAW_HASH;
7578 dgst_pos0 = 0;
7579 dgst_pos1 = 3;
7580 dgst_pos2 = 2;
7581 dgst_pos3 = 1;
7582 break;
7583
7584 case 22: hash_type = HASH_TYPE_MD5;
7585 salt_type = SALT_TYPE_EMBEDDED;
7586 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7587 opts_type = OPTS_TYPE_PT_GENERATE_LE
7588 | OPTS_TYPE_PT_ADD80
7589 | OPTS_TYPE_PT_ADDBITS14;
7590 kern_type = KERN_TYPE_MD5_SLTPW;
7591 dgst_size = DGST_SIZE_4_4;
7592 parse_func = netscreen_parse_hash;
7593 sort_by_digest = sort_by_digest_4_4;
7594 opti_type = OPTI_TYPE_ZERO_BYTE
7595 | OPTI_TYPE_PRECOMPUTE_INIT
7596 | OPTI_TYPE_PRECOMPUTE_MERKLE
7597 | OPTI_TYPE_EARLY_SKIP
7598 | OPTI_TYPE_NOT_ITERATED
7599 | OPTI_TYPE_PREPENDED_SALT
7600 | OPTI_TYPE_RAW_HASH;
7601 dgst_pos0 = 0;
7602 dgst_pos1 = 3;
7603 dgst_pos2 = 2;
7604 dgst_pos3 = 1;
7605 break;
7606
7607 case 23: hash_type = HASH_TYPE_MD5;
7608 salt_type = SALT_TYPE_EMBEDDED;
7609 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7610 opts_type = OPTS_TYPE_PT_GENERATE_LE
7611 | OPTS_TYPE_PT_ADD80
7612 | OPTS_TYPE_PT_ADDBITS14;
7613 kern_type = KERN_TYPE_MD5_SLTPW;
7614 dgst_size = DGST_SIZE_4_4;
7615 parse_func = skype_parse_hash;
7616 sort_by_digest = sort_by_digest_4_4;
7617 opti_type = OPTI_TYPE_ZERO_BYTE
7618 | OPTI_TYPE_PRECOMPUTE_INIT
7619 | OPTI_TYPE_PRECOMPUTE_MERKLE
7620 | OPTI_TYPE_EARLY_SKIP
7621 | OPTI_TYPE_NOT_ITERATED
7622 | OPTI_TYPE_PREPENDED_SALT
7623 | OPTI_TYPE_RAW_HASH;
7624 dgst_pos0 = 0;
7625 dgst_pos1 = 3;
7626 dgst_pos2 = 2;
7627 dgst_pos3 = 1;
7628 break;
7629
7630 case 30: hash_type = HASH_TYPE_MD5;
7631 salt_type = SALT_TYPE_INTERN;
7632 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7633 opts_type = OPTS_TYPE_PT_GENERATE_LE
7634 | OPTS_TYPE_PT_UNICODE
7635 | OPTS_TYPE_ST_ADD80
7636 | OPTS_TYPE_ST_ADDBITS14;
7637 kern_type = KERN_TYPE_MD5_PWUSLT;
7638 dgst_size = DGST_SIZE_4_4;
7639 parse_func = md5s_parse_hash;
7640 sort_by_digest = sort_by_digest_4_4;
7641 opti_type = OPTI_TYPE_ZERO_BYTE
7642 | OPTI_TYPE_PRECOMPUTE_INIT
7643 | OPTI_TYPE_PRECOMPUTE_MERKLE
7644 | OPTI_TYPE_MEET_IN_MIDDLE
7645 | OPTI_TYPE_EARLY_SKIP
7646 | OPTI_TYPE_NOT_ITERATED
7647 | OPTI_TYPE_APPENDED_SALT
7648 | OPTI_TYPE_RAW_HASH;
7649 dgst_pos0 = 0;
7650 dgst_pos1 = 3;
7651 dgst_pos2 = 2;
7652 dgst_pos3 = 1;
7653 break;
7654
7655 case 40: hash_type = HASH_TYPE_MD5;
7656 salt_type = SALT_TYPE_INTERN;
7657 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7658 opts_type = OPTS_TYPE_PT_GENERATE_LE
7659 | OPTS_TYPE_PT_ADD80
7660 | OPTS_TYPE_PT_ADDBITS14
7661 | OPTS_TYPE_PT_UNICODE;
7662 kern_type = KERN_TYPE_MD5_SLTPWU;
7663 dgst_size = DGST_SIZE_4_4;
7664 parse_func = md5s_parse_hash;
7665 sort_by_digest = sort_by_digest_4_4;
7666 opti_type = OPTI_TYPE_ZERO_BYTE
7667 | OPTI_TYPE_PRECOMPUTE_INIT
7668 | OPTI_TYPE_PRECOMPUTE_MERKLE
7669 | OPTI_TYPE_EARLY_SKIP
7670 | OPTI_TYPE_NOT_ITERATED
7671 | OPTI_TYPE_PREPENDED_SALT
7672 | OPTI_TYPE_RAW_HASH;
7673 dgst_pos0 = 0;
7674 dgst_pos1 = 3;
7675 dgst_pos2 = 2;
7676 dgst_pos3 = 1;
7677 break;
7678
7679 case 50: hash_type = HASH_TYPE_MD5;
7680 salt_type = SALT_TYPE_INTERN;
7681 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7682 opts_type = OPTS_TYPE_PT_GENERATE_LE
7683 | OPTS_TYPE_ST_ADD80
7684 | OPTS_TYPE_ST_ADDBITS14;
7685 kern_type = KERN_TYPE_HMACMD5_PW;
7686 dgst_size = DGST_SIZE_4_4;
7687 parse_func = hmacmd5_parse_hash;
7688 sort_by_digest = sort_by_digest_4_4;
7689 opti_type = OPTI_TYPE_ZERO_BYTE
7690 | OPTI_TYPE_NOT_ITERATED;
7691 dgst_pos0 = 0;
7692 dgst_pos1 = 3;
7693 dgst_pos2 = 2;
7694 dgst_pos3 = 1;
7695 break;
7696
7697 case 60: hash_type = HASH_TYPE_MD5;
7698 salt_type = SALT_TYPE_INTERN;
7699 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7700 opts_type = OPTS_TYPE_PT_GENERATE_LE
7701 | OPTS_TYPE_PT_ADD80
7702 | OPTS_TYPE_PT_ADDBITS14;
7703 kern_type = KERN_TYPE_HMACMD5_SLT;
7704 dgst_size = DGST_SIZE_4_4;
7705 parse_func = hmacmd5_parse_hash;
7706 sort_by_digest = sort_by_digest_4_4;
7707 opti_type = OPTI_TYPE_ZERO_BYTE
7708 | OPTI_TYPE_NOT_ITERATED;
7709 dgst_pos0 = 0;
7710 dgst_pos1 = 3;
7711 dgst_pos2 = 2;
7712 dgst_pos3 = 1;
7713 break;
7714
7715 case 100: hash_type = HASH_TYPE_SHA1;
7716 salt_type = SALT_TYPE_NONE;
7717 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7718 opts_type = OPTS_TYPE_PT_GENERATE_BE
7719 | OPTS_TYPE_PT_ADD80
7720 | OPTS_TYPE_PT_ADDBITS15;
7721 kern_type = KERN_TYPE_SHA1;
7722 dgst_size = DGST_SIZE_4_5;
7723 parse_func = sha1_parse_hash;
7724 sort_by_digest = sort_by_digest_4_5;
7725 opti_type = OPTI_TYPE_ZERO_BYTE
7726 | OPTI_TYPE_PRECOMPUTE_INIT
7727 | OPTI_TYPE_PRECOMPUTE_MERKLE
7728 | OPTI_TYPE_EARLY_SKIP
7729 | OPTI_TYPE_NOT_ITERATED
7730 | OPTI_TYPE_NOT_SALTED
7731 | OPTI_TYPE_RAW_HASH;
7732 dgst_pos0 = 3;
7733 dgst_pos1 = 4;
7734 dgst_pos2 = 2;
7735 dgst_pos3 = 1;
7736 break;
7737
7738 case 101: hash_type = HASH_TYPE_SHA1;
7739 salt_type = SALT_TYPE_NONE;
7740 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7741 opts_type = OPTS_TYPE_PT_GENERATE_BE
7742 | OPTS_TYPE_PT_ADD80
7743 | OPTS_TYPE_PT_ADDBITS15;
7744 kern_type = KERN_TYPE_SHA1;
7745 dgst_size = DGST_SIZE_4_5;
7746 parse_func = sha1b64_parse_hash;
7747 sort_by_digest = sort_by_digest_4_5;
7748 opti_type = OPTI_TYPE_ZERO_BYTE
7749 | OPTI_TYPE_PRECOMPUTE_INIT
7750 | OPTI_TYPE_PRECOMPUTE_MERKLE
7751 | OPTI_TYPE_EARLY_SKIP
7752 | OPTI_TYPE_NOT_ITERATED
7753 | OPTI_TYPE_NOT_SALTED
7754 | OPTI_TYPE_RAW_HASH;
7755 dgst_pos0 = 3;
7756 dgst_pos1 = 4;
7757 dgst_pos2 = 2;
7758 dgst_pos3 = 1;
7759 break;
7760
7761 case 110: hash_type = HASH_TYPE_SHA1;
7762 salt_type = SALT_TYPE_INTERN;
7763 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7764 opts_type = OPTS_TYPE_PT_GENERATE_BE
7765 | OPTS_TYPE_ST_ADD80
7766 | OPTS_TYPE_ST_ADDBITS15;
7767 kern_type = KERN_TYPE_SHA1_PWSLT;
7768 dgst_size = DGST_SIZE_4_5;
7769 parse_func = sha1s_parse_hash;
7770 sort_by_digest = sort_by_digest_4_5;
7771 opti_type = OPTI_TYPE_ZERO_BYTE
7772 | OPTI_TYPE_PRECOMPUTE_INIT
7773 | OPTI_TYPE_PRECOMPUTE_MERKLE
7774 | OPTI_TYPE_EARLY_SKIP
7775 | OPTI_TYPE_NOT_ITERATED
7776 | OPTI_TYPE_APPENDED_SALT
7777 | OPTI_TYPE_RAW_HASH;
7778 dgst_pos0 = 3;
7779 dgst_pos1 = 4;
7780 dgst_pos2 = 2;
7781 dgst_pos3 = 1;
7782 break;
7783
7784 case 111: hash_type = HASH_TYPE_SHA1;
7785 salt_type = SALT_TYPE_EMBEDDED;
7786 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7787 opts_type = OPTS_TYPE_PT_GENERATE_BE
7788 | OPTS_TYPE_ST_ADD80
7789 | OPTS_TYPE_ST_ADDBITS15;
7790 kern_type = KERN_TYPE_SHA1_PWSLT;
7791 dgst_size = DGST_SIZE_4_5;
7792 parse_func = sha1b64s_parse_hash;
7793 sort_by_digest = sort_by_digest_4_5;
7794 opti_type = OPTI_TYPE_ZERO_BYTE
7795 | OPTI_TYPE_PRECOMPUTE_INIT
7796 | OPTI_TYPE_PRECOMPUTE_MERKLE
7797 | OPTI_TYPE_EARLY_SKIP
7798 | OPTI_TYPE_NOT_ITERATED
7799 | OPTI_TYPE_APPENDED_SALT
7800 | OPTI_TYPE_RAW_HASH;
7801 dgst_pos0 = 3;
7802 dgst_pos1 = 4;
7803 dgst_pos2 = 2;
7804 dgst_pos3 = 1;
7805 break;
7806
7807 case 112: hash_type = HASH_TYPE_SHA1;
7808 salt_type = SALT_TYPE_INTERN;
7809 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7810 opts_type = OPTS_TYPE_PT_GENERATE_BE
7811 | OPTS_TYPE_ST_ADD80
7812 | OPTS_TYPE_ST_ADDBITS15
7813 | OPTS_TYPE_ST_HEX;
7814 kern_type = KERN_TYPE_SHA1_PWSLT;
7815 dgst_size = DGST_SIZE_4_5;
7816 parse_func = oracles_parse_hash;
7817 sort_by_digest = sort_by_digest_4_5;
7818 opti_type = OPTI_TYPE_ZERO_BYTE
7819 | OPTI_TYPE_PRECOMPUTE_INIT
7820 | OPTI_TYPE_PRECOMPUTE_MERKLE
7821 | OPTI_TYPE_EARLY_SKIP
7822 | OPTI_TYPE_NOT_ITERATED
7823 | OPTI_TYPE_APPENDED_SALT
7824 | OPTI_TYPE_RAW_HASH;
7825 dgst_pos0 = 3;
7826 dgst_pos1 = 4;
7827 dgst_pos2 = 2;
7828 dgst_pos3 = 1;
7829 break;
7830
7831 case 120: hash_type = HASH_TYPE_SHA1;
7832 salt_type = SALT_TYPE_INTERN;
7833 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7834 opts_type = OPTS_TYPE_PT_GENERATE_BE
7835 | OPTS_TYPE_PT_ADD80
7836 | OPTS_TYPE_PT_ADDBITS15;
7837 kern_type = KERN_TYPE_SHA1_SLTPW;
7838 dgst_size = DGST_SIZE_4_5;
7839 parse_func = sha1s_parse_hash;
7840 sort_by_digest = sort_by_digest_4_5;
7841 opti_type = OPTI_TYPE_ZERO_BYTE
7842 | OPTI_TYPE_PRECOMPUTE_INIT
7843 | OPTI_TYPE_PRECOMPUTE_MERKLE
7844 | OPTI_TYPE_EARLY_SKIP
7845 | OPTI_TYPE_NOT_ITERATED
7846 | OPTI_TYPE_PREPENDED_SALT
7847 | OPTI_TYPE_RAW_HASH;
7848 dgst_pos0 = 3;
7849 dgst_pos1 = 4;
7850 dgst_pos2 = 2;
7851 dgst_pos3 = 1;
7852 break;
7853
7854 case 121: hash_type = HASH_TYPE_SHA1;
7855 salt_type = SALT_TYPE_INTERN;
7856 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7857 opts_type = OPTS_TYPE_PT_GENERATE_BE
7858 | OPTS_TYPE_PT_ADD80
7859 | OPTS_TYPE_PT_ADDBITS15
7860 | OPTS_TYPE_ST_LOWER;
7861 kern_type = KERN_TYPE_SHA1_SLTPW;
7862 dgst_size = DGST_SIZE_4_5;
7863 parse_func = smf_parse_hash;
7864 sort_by_digest = sort_by_digest_4_5;
7865 opti_type = OPTI_TYPE_ZERO_BYTE
7866 | OPTI_TYPE_PRECOMPUTE_INIT
7867 | OPTI_TYPE_PRECOMPUTE_MERKLE
7868 | OPTI_TYPE_EARLY_SKIP
7869 | OPTI_TYPE_NOT_ITERATED
7870 | OPTI_TYPE_PREPENDED_SALT
7871 | OPTI_TYPE_RAW_HASH;
7872 dgst_pos0 = 3;
7873 dgst_pos1 = 4;
7874 dgst_pos2 = 2;
7875 dgst_pos3 = 1;
7876 break;
7877
7878 case 122: hash_type = HASH_TYPE_SHA1;
7879 salt_type = SALT_TYPE_EMBEDDED;
7880 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7881 opts_type = OPTS_TYPE_PT_GENERATE_BE
7882 | OPTS_TYPE_PT_ADD80
7883 | OPTS_TYPE_PT_ADDBITS15
7884 | OPTS_TYPE_ST_HEX;
7885 kern_type = KERN_TYPE_SHA1_SLTPW;
7886 dgst_size = DGST_SIZE_4_5;
7887 parse_func = osx1_parse_hash;
7888 sort_by_digest = sort_by_digest_4_5;
7889 opti_type = OPTI_TYPE_ZERO_BYTE
7890 | OPTI_TYPE_PRECOMPUTE_INIT
7891 | OPTI_TYPE_PRECOMPUTE_MERKLE
7892 | OPTI_TYPE_EARLY_SKIP
7893 | OPTI_TYPE_NOT_ITERATED
7894 | OPTI_TYPE_PREPENDED_SALT
7895 | OPTI_TYPE_RAW_HASH;
7896 dgst_pos0 = 3;
7897 dgst_pos1 = 4;
7898 dgst_pos2 = 2;
7899 dgst_pos3 = 1;
7900 break;
7901
7902 case 124: hash_type = HASH_TYPE_SHA1;
7903 salt_type = SALT_TYPE_EMBEDDED;
7904 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7905 opts_type = OPTS_TYPE_PT_GENERATE_BE
7906 | OPTS_TYPE_PT_ADD80
7907 | OPTS_TYPE_PT_ADDBITS15;
7908 kern_type = KERN_TYPE_SHA1_SLTPW;
7909 dgst_size = DGST_SIZE_4_5;
7910 parse_func = djangosha1_parse_hash;
7911 sort_by_digest = sort_by_digest_4_5;
7912 opti_type = OPTI_TYPE_ZERO_BYTE
7913 | OPTI_TYPE_PRECOMPUTE_INIT
7914 | OPTI_TYPE_PRECOMPUTE_MERKLE
7915 | OPTI_TYPE_EARLY_SKIP
7916 | OPTI_TYPE_NOT_ITERATED
7917 | OPTI_TYPE_PREPENDED_SALT
7918 | OPTI_TYPE_RAW_HASH;
7919 dgst_pos0 = 3;
7920 dgst_pos1 = 4;
7921 dgst_pos2 = 2;
7922 dgst_pos3 = 1;
7923 break;
7924
7925 case 125: hash_type = HASH_TYPE_SHA1;
7926 salt_type = SALT_TYPE_EMBEDDED;
7927 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7928 opts_type = OPTS_TYPE_PT_GENERATE_BE
7929 | OPTS_TYPE_PT_ADD80
7930 | OPTS_TYPE_PT_ADDBITS15
7931 | OPTS_TYPE_ST_HEX;
7932 kern_type = KERN_TYPE_SHA1_SLTPW;
7933 dgst_size = DGST_SIZE_4_5;
7934 parse_func = arubaos_parse_hash;
7935 sort_by_digest = sort_by_digest_4_5;
7936 opti_type = OPTI_TYPE_ZERO_BYTE
7937 | OPTI_TYPE_PRECOMPUTE_INIT
7938 | OPTI_TYPE_PRECOMPUTE_MERKLE
7939 | OPTI_TYPE_EARLY_SKIP
7940 | OPTI_TYPE_NOT_ITERATED
7941 | OPTI_TYPE_PREPENDED_SALT
7942 | OPTI_TYPE_RAW_HASH;
7943 dgst_pos0 = 3;
7944 dgst_pos1 = 4;
7945 dgst_pos2 = 2;
7946 dgst_pos3 = 1;
7947 break;
7948
7949 case 130: hash_type = HASH_TYPE_SHA1;
7950 salt_type = SALT_TYPE_INTERN;
7951 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7952 opts_type = OPTS_TYPE_PT_GENERATE_BE
7953 | OPTS_TYPE_PT_UNICODE
7954 | OPTS_TYPE_ST_ADD80
7955 | OPTS_TYPE_ST_ADDBITS15;
7956 kern_type = KERN_TYPE_SHA1_PWUSLT;
7957 dgst_size = DGST_SIZE_4_5;
7958 parse_func = sha1s_parse_hash;
7959 sort_by_digest = sort_by_digest_4_5;
7960 opti_type = OPTI_TYPE_ZERO_BYTE
7961 | OPTI_TYPE_PRECOMPUTE_INIT
7962 | OPTI_TYPE_PRECOMPUTE_MERKLE
7963 | OPTI_TYPE_EARLY_SKIP
7964 | OPTI_TYPE_NOT_ITERATED
7965 | OPTI_TYPE_APPENDED_SALT
7966 | OPTI_TYPE_RAW_HASH;
7967 dgst_pos0 = 3;
7968 dgst_pos1 = 4;
7969 dgst_pos2 = 2;
7970 dgst_pos3 = 1;
7971 break;
7972
7973 case 131: hash_type = HASH_TYPE_SHA1;
7974 salt_type = SALT_TYPE_EMBEDDED;
7975 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7976 opts_type = OPTS_TYPE_PT_GENERATE_BE
7977 | OPTS_TYPE_PT_UNICODE
7978 | OPTS_TYPE_PT_UPPER
7979 | OPTS_TYPE_ST_ADD80
7980 | OPTS_TYPE_ST_ADDBITS15
7981 | OPTS_TYPE_ST_HEX;
7982 kern_type = KERN_TYPE_SHA1_PWUSLT;
7983 dgst_size = DGST_SIZE_4_5;
7984 parse_func = mssql2000_parse_hash;
7985 sort_by_digest = sort_by_digest_4_5;
7986 opti_type = OPTI_TYPE_ZERO_BYTE
7987 | OPTI_TYPE_PRECOMPUTE_INIT
7988 | OPTI_TYPE_PRECOMPUTE_MERKLE
7989 | OPTI_TYPE_EARLY_SKIP
7990 | OPTI_TYPE_NOT_ITERATED
7991 | OPTI_TYPE_APPENDED_SALT
7992 | OPTI_TYPE_RAW_HASH;
7993 dgst_pos0 = 3;
7994 dgst_pos1 = 4;
7995 dgst_pos2 = 2;
7996 dgst_pos3 = 1;
7997 break;
7998
7999 case 132: hash_type = HASH_TYPE_SHA1;
8000 salt_type = SALT_TYPE_EMBEDDED;
8001 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8002 opts_type = OPTS_TYPE_PT_GENERATE_BE
8003 | OPTS_TYPE_PT_UNICODE
8004 | OPTS_TYPE_ST_ADD80
8005 | OPTS_TYPE_ST_ADDBITS15
8006 | OPTS_TYPE_ST_HEX;
8007 kern_type = KERN_TYPE_SHA1_PWUSLT;
8008 dgst_size = DGST_SIZE_4_5;
8009 parse_func = mssql2005_parse_hash;
8010 sort_by_digest = sort_by_digest_4_5;
8011 opti_type = OPTI_TYPE_ZERO_BYTE
8012 | OPTI_TYPE_PRECOMPUTE_INIT
8013 | OPTI_TYPE_PRECOMPUTE_MERKLE
8014 | OPTI_TYPE_EARLY_SKIP
8015 | OPTI_TYPE_NOT_ITERATED
8016 | OPTI_TYPE_APPENDED_SALT
8017 | OPTI_TYPE_RAW_HASH;
8018 dgst_pos0 = 3;
8019 dgst_pos1 = 4;
8020 dgst_pos2 = 2;
8021 dgst_pos3 = 1;
8022 break;
8023
8024 case 133: hash_type = HASH_TYPE_SHA1;
8025 salt_type = SALT_TYPE_EMBEDDED;
8026 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8027 opts_type = OPTS_TYPE_PT_GENERATE_BE
8028 | OPTS_TYPE_PT_UNICODE
8029 | OPTS_TYPE_ST_ADD80
8030 | OPTS_TYPE_ST_ADDBITS15;
8031 kern_type = KERN_TYPE_SHA1_PWUSLT;
8032 dgst_size = DGST_SIZE_4_5;
8033 parse_func = peoplesoft_parse_hash;
8034 sort_by_digest = sort_by_digest_4_5;
8035 opti_type = OPTI_TYPE_ZERO_BYTE
8036 | OPTI_TYPE_PRECOMPUTE_INIT
8037 | OPTI_TYPE_PRECOMPUTE_MERKLE
8038 | OPTI_TYPE_EARLY_SKIP
8039 | OPTI_TYPE_NOT_ITERATED
8040 | OPTI_TYPE_APPENDED_SALT
8041 | OPTI_TYPE_RAW_HASH;
8042 dgst_pos0 = 3;
8043 dgst_pos1 = 4;
8044 dgst_pos2 = 2;
8045 dgst_pos3 = 1;
8046 break;
8047
8048 case 140: hash_type = HASH_TYPE_SHA1;
8049 salt_type = SALT_TYPE_INTERN;
8050 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8051 opts_type = OPTS_TYPE_PT_GENERATE_BE
8052 | OPTS_TYPE_PT_ADD80
8053 | OPTS_TYPE_PT_ADDBITS15
8054 | OPTS_TYPE_PT_UNICODE;
8055 kern_type = KERN_TYPE_SHA1_SLTPWU;
8056 dgst_size = DGST_SIZE_4_5;
8057 parse_func = sha1s_parse_hash;
8058 sort_by_digest = sort_by_digest_4_5;
8059 opti_type = OPTI_TYPE_ZERO_BYTE
8060 | OPTI_TYPE_PRECOMPUTE_INIT
8061 | OPTI_TYPE_PRECOMPUTE_MERKLE
8062 | OPTI_TYPE_EARLY_SKIP
8063 | OPTI_TYPE_NOT_ITERATED
8064 | OPTI_TYPE_PREPENDED_SALT
8065 | OPTI_TYPE_RAW_HASH;
8066 dgst_pos0 = 3;
8067 dgst_pos1 = 4;
8068 dgst_pos2 = 2;
8069 dgst_pos3 = 1;
8070 break;
8071
8072 case 141: hash_type = HASH_TYPE_SHA1;
8073 salt_type = SALT_TYPE_EMBEDDED;
8074 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8075 opts_type = OPTS_TYPE_PT_GENERATE_BE
8076 | OPTS_TYPE_PT_ADD80
8077 | OPTS_TYPE_PT_ADDBITS15
8078 | OPTS_TYPE_PT_UNICODE
8079 | OPTS_TYPE_ST_BASE64;
8080 kern_type = KERN_TYPE_SHA1_SLTPWU;
8081 dgst_size = DGST_SIZE_4_5;
8082 parse_func = episerver_parse_hash;
8083 sort_by_digest = sort_by_digest_4_5;
8084 opti_type = OPTI_TYPE_ZERO_BYTE
8085 | OPTI_TYPE_PRECOMPUTE_INIT
8086 | OPTI_TYPE_PRECOMPUTE_MERKLE
8087 | OPTI_TYPE_EARLY_SKIP
8088 | OPTI_TYPE_NOT_ITERATED
8089 | OPTI_TYPE_PREPENDED_SALT
8090 | OPTI_TYPE_RAW_HASH;
8091 dgst_pos0 = 3;
8092 dgst_pos1 = 4;
8093 dgst_pos2 = 2;
8094 dgst_pos3 = 1;
8095 break;
8096
8097 case 150: hash_type = HASH_TYPE_SHA1;
8098 salt_type = SALT_TYPE_INTERN;
8099 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8100 opts_type = OPTS_TYPE_PT_GENERATE_BE
8101 | OPTS_TYPE_ST_ADD80
8102 | OPTS_TYPE_ST_ADDBITS15;
8103 kern_type = KERN_TYPE_HMACSHA1_PW;
8104 dgst_size = DGST_SIZE_4_5;
8105 parse_func = hmacsha1_parse_hash;
8106 sort_by_digest = sort_by_digest_4_5;
8107 opti_type = OPTI_TYPE_ZERO_BYTE
8108 | OPTI_TYPE_NOT_ITERATED;
8109 dgst_pos0 = 3;
8110 dgst_pos1 = 4;
8111 dgst_pos2 = 2;
8112 dgst_pos3 = 1;
8113 break;
8114
8115 case 160: hash_type = HASH_TYPE_SHA1;
8116 salt_type = SALT_TYPE_INTERN;
8117 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8118 opts_type = OPTS_TYPE_PT_GENERATE_BE
8119 | OPTS_TYPE_PT_ADD80
8120 | OPTS_TYPE_PT_ADDBITS15;
8121 kern_type = KERN_TYPE_HMACSHA1_SLT;
8122 dgst_size = DGST_SIZE_4_5;
8123 parse_func = hmacsha1_parse_hash;
8124 sort_by_digest = sort_by_digest_4_5;
8125 opti_type = OPTI_TYPE_ZERO_BYTE
8126 | OPTI_TYPE_NOT_ITERATED;
8127 dgst_pos0 = 3;
8128 dgst_pos1 = 4;
8129 dgst_pos2 = 2;
8130 dgst_pos3 = 1;
8131 break;
8132
8133 case 200: hash_type = HASH_TYPE_MYSQL;
8134 salt_type = SALT_TYPE_NONE;
8135 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8136 opts_type = 0;
8137 kern_type = KERN_TYPE_MYSQL;
8138 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8139 parse_func = mysql323_parse_hash;
8140 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8141 opti_type = OPTI_TYPE_ZERO_BYTE;
8142 dgst_pos0 = 0;
8143 dgst_pos1 = 1;
8144 dgst_pos2 = 2;
8145 dgst_pos3 = 3;
8146 break;
8147
8148 case 300: hash_type = HASH_TYPE_SHA1;
8149 salt_type = SALT_TYPE_NONE;
8150 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8151 opts_type = OPTS_TYPE_PT_GENERATE_BE
8152 | OPTS_TYPE_PT_ADD80
8153 | OPTS_TYPE_PT_ADDBITS15;
8154 kern_type = KERN_TYPE_MYSQL41;
8155 dgst_size = DGST_SIZE_4_5;
8156 parse_func = sha1_parse_hash;
8157 sort_by_digest = sort_by_digest_4_5;
8158 opti_type = OPTI_TYPE_ZERO_BYTE
8159 | OPTI_TYPE_PRECOMPUTE_INIT
8160 | OPTI_TYPE_PRECOMPUTE_MERKLE
8161 | OPTI_TYPE_EARLY_SKIP
8162 | OPTI_TYPE_NOT_ITERATED
8163 | OPTI_TYPE_NOT_SALTED;
8164 dgst_pos0 = 3;
8165 dgst_pos1 = 4;
8166 dgst_pos2 = 2;
8167 dgst_pos3 = 1;
8168 break;
8169
8170 case 400: hash_type = HASH_TYPE_MD5;
8171 salt_type = SALT_TYPE_EMBEDDED;
8172 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8173 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8174 kern_type = KERN_TYPE_PHPASS;
8175 dgst_size = DGST_SIZE_4_4;
8176 parse_func = phpass_parse_hash;
8177 sort_by_digest = sort_by_digest_4_4;
8178 opti_type = OPTI_TYPE_ZERO_BYTE
8179 | OPTI_TYPE_SLOW_HASH_SIMD;
8180 dgst_pos0 = 0;
8181 dgst_pos1 = 1;
8182 dgst_pos2 = 2;
8183 dgst_pos3 = 3;
8184 break;
8185
8186 case 500: 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 kern_type = KERN_TYPE_MD5CRYPT;
8191 dgst_size = DGST_SIZE_4_4;
8192 parse_func = md5crypt_parse_hash;
8193 sort_by_digest = sort_by_digest_4_4;
8194 opti_type = OPTI_TYPE_ZERO_BYTE;
8195 dgst_pos0 = 0;
8196 dgst_pos1 = 1;
8197 dgst_pos2 = 2;
8198 dgst_pos3 = 3;
8199 break;
8200
8201 case 501: hash_type = HASH_TYPE_MD5;
8202 salt_type = SALT_TYPE_EMBEDDED;
8203 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8204 opts_type = OPTS_TYPE_PT_GENERATE_LE
8205 | OPTS_TYPE_HASH_COPY;
8206 kern_type = KERN_TYPE_MD5CRYPT;
8207 dgst_size = DGST_SIZE_4_4;
8208 parse_func = juniper_parse_hash;
8209 sort_by_digest = sort_by_digest_4_4;
8210 opti_type = OPTI_TYPE_ZERO_BYTE;
8211 dgst_pos0 = 0;
8212 dgst_pos1 = 1;
8213 dgst_pos2 = 2;
8214 dgst_pos3 = 3;
8215 break;
8216
8217 case 900: hash_type = HASH_TYPE_MD4;
8218 salt_type = SALT_TYPE_NONE;
8219 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8220 opts_type = OPTS_TYPE_PT_GENERATE_LE
8221 | OPTS_TYPE_PT_ADD80
8222 | OPTS_TYPE_PT_ADDBITS14;
8223 kern_type = KERN_TYPE_MD4;
8224 dgst_size = DGST_SIZE_4_4;
8225 parse_func = md4_parse_hash;
8226 sort_by_digest = sort_by_digest_4_4;
8227 opti_type = OPTI_TYPE_ZERO_BYTE
8228 | OPTI_TYPE_PRECOMPUTE_INIT
8229 | OPTI_TYPE_PRECOMPUTE_MERKLE
8230 | OPTI_TYPE_MEET_IN_MIDDLE
8231 | OPTI_TYPE_EARLY_SKIP
8232 | OPTI_TYPE_NOT_ITERATED
8233 | OPTI_TYPE_NOT_SALTED
8234 | OPTI_TYPE_RAW_HASH;
8235 dgst_pos0 = 0;
8236 dgst_pos1 = 3;
8237 dgst_pos2 = 2;
8238 dgst_pos3 = 1;
8239 break;
8240
8241 case 1000: hash_type = HASH_TYPE_MD4;
8242 salt_type = SALT_TYPE_NONE;
8243 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8244 opts_type = OPTS_TYPE_PT_GENERATE_LE
8245 | OPTS_TYPE_PT_ADD80
8246 | OPTS_TYPE_PT_ADDBITS14
8247 | OPTS_TYPE_PT_UNICODE;
8248 kern_type = KERN_TYPE_MD4_PWU;
8249 dgst_size = DGST_SIZE_4_4;
8250 parse_func = md4_parse_hash;
8251 sort_by_digest = sort_by_digest_4_4;
8252 opti_type = OPTI_TYPE_ZERO_BYTE
8253 | OPTI_TYPE_PRECOMPUTE_INIT
8254 | OPTI_TYPE_PRECOMPUTE_MERKLE
8255 | OPTI_TYPE_MEET_IN_MIDDLE
8256 | OPTI_TYPE_EARLY_SKIP
8257 | OPTI_TYPE_NOT_ITERATED
8258 | OPTI_TYPE_NOT_SALTED
8259 | OPTI_TYPE_RAW_HASH;
8260 dgst_pos0 = 0;
8261 dgst_pos1 = 3;
8262 dgst_pos2 = 2;
8263 dgst_pos3 = 1;
8264 break;
8265
8266 case 1100: hash_type = HASH_TYPE_MD4;
8267 salt_type = SALT_TYPE_INTERN;
8268 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8269 opts_type = OPTS_TYPE_PT_GENERATE_LE
8270 | OPTS_TYPE_PT_ADD80
8271 | OPTS_TYPE_PT_ADDBITS14
8272 | OPTS_TYPE_PT_UNICODE
8273 | OPTS_TYPE_ST_ADD80
8274 | OPTS_TYPE_ST_UNICODE
8275 | OPTS_TYPE_ST_LOWER;
8276 kern_type = KERN_TYPE_MD44_PWUSLT;
8277 dgst_size = DGST_SIZE_4_4;
8278 parse_func = dcc_parse_hash;
8279 sort_by_digest = sort_by_digest_4_4;
8280 opti_type = OPTI_TYPE_ZERO_BYTE
8281 | OPTI_TYPE_PRECOMPUTE_INIT
8282 | OPTI_TYPE_PRECOMPUTE_MERKLE
8283 | OPTI_TYPE_EARLY_SKIP
8284 | OPTI_TYPE_NOT_ITERATED;
8285 dgst_pos0 = 0;
8286 dgst_pos1 = 3;
8287 dgst_pos2 = 2;
8288 dgst_pos3 = 1;
8289 break;
8290
8291 case 1400: hash_type = HASH_TYPE_SHA256;
8292 salt_type = SALT_TYPE_NONE;
8293 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8294 opts_type = OPTS_TYPE_PT_GENERATE_BE
8295 | OPTS_TYPE_PT_ADD80
8296 | OPTS_TYPE_PT_ADDBITS15;
8297 kern_type = KERN_TYPE_SHA256;
8298 dgst_size = DGST_SIZE_4_8;
8299 parse_func = sha256_parse_hash;
8300 sort_by_digest = sort_by_digest_4_8;
8301 opti_type = OPTI_TYPE_ZERO_BYTE
8302 | OPTI_TYPE_PRECOMPUTE_INIT
8303 | OPTI_TYPE_PRECOMPUTE_MERKLE
8304 | OPTI_TYPE_EARLY_SKIP
8305 | OPTI_TYPE_NOT_ITERATED
8306 | OPTI_TYPE_NOT_SALTED
8307 | OPTI_TYPE_RAW_HASH;
8308 dgst_pos0 = 3;
8309 dgst_pos1 = 7;
8310 dgst_pos2 = 2;
8311 dgst_pos3 = 6;
8312 break;
8313
8314 case 1410: hash_type = HASH_TYPE_SHA256;
8315 salt_type = SALT_TYPE_INTERN;
8316 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8317 opts_type = OPTS_TYPE_PT_GENERATE_BE
8318 | OPTS_TYPE_ST_ADD80
8319 | OPTS_TYPE_ST_ADDBITS15;
8320 kern_type = KERN_TYPE_SHA256_PWSLT;
8321 dgst_size = DGST_SIZE_4_8;
8322 parse_func = sha256s_parse_hash;
8323 sort_by_digest = sort_by_digest_4_8;
8324 opti_type = OPTI_TYPE_ZERO_BYTE
8325 | OPTI_TYPE_PRECOMPUTE_INIT
8326 | OPTI_TYPE_PRECOMPUTE_MERKLE
8327 | OPTI_TYPE_EARLY_SKIP
8328 | OPTI_TYPE_NOT_ITERATED
8329 | OPTI_TYPE_APPENDED_SALT
8330 | OPTI_TYPE_RAW_HASH;
8331 dgst_pos0 = 3;
8332 dgst_pos1 = 7;
8333 dgst_pos2 = 2;
8334 dgst_pos3 = 6;
8335 break;
8336
8337 case 1420: hash_type = HASH_TYPE_SHA256;
8338 salt_type = SALT_TYPE_INTERN;
8339 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8340 opts_type = OPTS_TYPE_PT_GENERATE_BE
8341 | OPTS_TYPE_PT_ADD80
8342 | OPTS_TYPE_PT_ADDBITS15;
8343 kern_type = KERN_TYPE_SHA256_SLTPW;
8344 dgst_size = DGST_SIZE_4_8;
8345 parse_func = sha256s_parse_hash;
8346 sort_by_digest = sort_by_digest_4_8;
8347 opti_type = OPTI_TYPE_ZERO_BYTE
8348 | OPTI_TYPE_PRECOMPUTE_INIT
8349 | OPTI_TYPE_PRECOMPUTE_MERKLE
8350 | OPTI_TYPE_EARLY_SKIP
8351 | OPTI_TYPE_NOT_ITERATED
8352 | OPTI_TYPE_PREPENDED_SALT
8353 | OPTI_TYPE_RAW_HASH;
8354 dgst_pos0 = 3;
8355 dgst_pos1 = 7;
8356 dgst_pos2 = 2;
8357 dgst_pos3 = 6;
8358 break;
8359
8360 case 1421: hash_type = HASH_TYPE_SHA256;
8361 salt_type = SALT_TYPE_EMBEDDED;
8362 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8363 opts_type = OPTS_TYPE_PT_GENERATE_BE
8364 | OPTS_TYPE_PT_ADD80
8365 | OPTS_TYPE_PT_ADDBITS15;
8366 kern_type = KERN_TYPE_SHA256_SLTPW;
8367 dgst_size = DGST_SIZE_4_8;
8368 parse_func = hmailserver_parse_hash;
8369 sort_by_digest = sort_by_digest_4_8;
8370 opti_type = OPTI_TYPE_ZERO_BYTE
8371 | OPTI_TYPE_PRECOMPUTE_INIT
8372 | OPTI_TYPE_PRECOMPUTE_MERKLE
8373 | OPTI_TYPE_EARLY_SKIP
8374 | OPTI_TYPE_NOT_ITERATED
8375 | OPTI_TYPE_PREPENDED_SALT
8376 | OPTI_TYPE_RAW_HASH;
8377 dgst_pos0 = 3;
8378 dgst_pos1 = 7;
8379 dgst_pos2 = 2;
8380 dgst_pos3 = 6;
8381 break;
8382
8383 case 1430: hash_type = HASH_TYPE_SHA256;
8384 salt_type = SALT_TYPE_INTERN;
8385 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8386 opts_type = OPTS_TYPE_PT_GENERATE_BE
8387 | OPTS_TYPE_PT_UNICODE
8388 | OPTS_TYPE_ST_ADD80
8389 | OPTS_TYPE_ST_ADDBITS15;
8390 kern_type = KERN_TYPE_SHA256_PWUSLT;
8391 dgst_size = DGST_SIZE_4_8;
8392 parse_func = sha256s_parse_hash;
8393 sort_by_digest = sort_by_digest_4_8;
8394 opti_type = OPTI_TYPE_ZERO_BYTE
8395 | OPTI_TYPE_PRECOMPUTE_INIT
8396 | OPTI_TYPE_PRECOMPUTE_MERKLE
8397 | OPTI_TYPE_EARLY_SKIP
8398 | OPTI_TYPE_NOT_ITERATED
8399 | OPTI_TYPE_APPENDED_SALT
8400 | OPTI_TYPE_RAW_HASH;
8401 dgst_pos0 = 3;
8402 dgst_pos1 = 7;
8403 dgst_pos2 = 2;
8404 dgst_pos3 = 6;
8405 break;
8406
8407 case 1440: hash_type = HASH_TYPE_SHA256;
8408 salt_type = SALT_TYPE_INTERN;
8409 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8410 opts_type = OPTS_TYPE_PT_GENERATE_BE
8411 | OPTS_TYPE_PT_ADD80
8412 | OPTS_TYPE_PT_ADDBITS15
8413 | OPTS_TYPE_PT_UNICODE;
8414 kern_type = KERN_TYPE_SHA256_SLTPWU;
8415 dgst_size = DGST_SIZE_4_8;
8416 parse_func = sha256s_parse_hash;
8417 sort_by_digest = sort_by_digest_4_8;
8418 opti_type = OPTI_TYPE_ZERO_BYTE
8419 | OPTI_TYPE_PRECOMPUTE_INIT
8420 | OPTI_TYPE_PRECOMPUTE_MERKLE
8421 | OPTI_TYPE_EARLY_SKIP
8422 | OPTI_TYPE_NOT_ITERATED
8423 | OPTI_TYPE_PREPENDED_SALT
8424 | OPTI_TYPE_RAW_HASH;
8425 dgst_pos0 = 3;
8426 dgst_pos1 = 7;
8427 dgst_pos2 = 2;
8428 dgst_pos3 = 6;
8429 break;
8430
8431 case 1441: hash_type = HASH_TYPE_SHA256;
8432 salt_type = SALT_TYPE_EMBEDDED;
8433 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8434 opts_type = OPTS_TYPE_PT_GENERATE_BE
8435 | OPTS_TYPE_PT_ADD80
8436 | OPTS_TYPE_PT_ADDBITS15
8437 | OPTS_TYPE_PT_UNICODE
8438 | OPTS_TYPE_ST_BASE64;
8439 kern_type = KERN_TYPE_SHA256_SLTPWU;
8440 dgst_size = DGST_SIZE_4_8;
8441 parse_func = episerver4_parse_hash;
8442 sort_by_digest = sort_by_digest_4_8;
8443 opti_type = OPTI_TYPE_ZERO_BYTE
8444 | OPTI_TYPE_PRECOMPUTE_INIT
8445 | OPTI_TYPE_PRECOMPUTE_MERKLE
8446 | OPTI_TYPE_EARLY_SKIP
8447 | OPTI_TYPE_NOT_ITERATED
8448 | OPTI_TYPE_PREPENDED_SALT
8449 | OPTI_TYPE_RAW_HASH;
8450 dgst_pos0 = 3;
8451 dgst_pos1 = 7;
8452 dgst_pos2 = 2;
8453 dgst_pos3 = 6;
8454 break;
8455
8456 case 1450: hash_type = HASH_TYPE_SHA256;
8457 salt_type = SALT_TYPE_INTERN;
8458 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8459 opts_type = OPTS_TYPE_PT_GENERATE_BE
8460 | OPTS_TYPE_ST_ADD80;
8461 kern_type = KERN_TYPE_HMACSHA256_PW;
8462 dgst_size = DGST_SIZE_4_8;
8463 parse_func = hmacsha256_parse_hash;
8464 sort_by_digest = sort_by_digest_4_8;
8465 opti_type = OPTI_TYPE_ZERO_BYTE
8466 | OPTI_TYPE_NOT_ITERATED;
8467 dgst_pos0 = 3;
8468 dgst_pos1 = 7;
8469 dgst_pos2 = 2;
8470 dgst_pos3 = 6;
8471 break;
8472
8473 case 1460: hash_type = HASH_TYPE_SHA256;
8474 salt_type = SALT_TYPE_INTERN;
8475 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8476 opts_type = OPTS_TYPE_PT_GENERATE_BE
8477 | OPTS_TYPE_PT_ADD80
8478 | OPTS_TYPE_PT_ADDBITS15;
8479 kern_type = KERN_TYPE_HMACSHA256_SLT;
8480 dgst_size = DGST_SIZE_4_8;
8481 parse_func = hmacsha256_parse_hash;
8482 sort_by_digest = sort_by_digest_4_8;
8483 opti_type = OPTI_TYPE_ZERO_BYTE
8484 | OPTI_TYPE_NOT_ITERATED;
8485 dgst_pos0 = 3;
8486 dgst_pos1 = 7;
8487 dgst_pos2 = 2;
8488 dgst_pos3 = 6;
8489 break;
8490
8491 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8492 salt_type = SALT_TYPE_EMBEDDED;
8493 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8494 opts_type = OPTS_TYPE_PT_GENERATE_LE
8495 | OPTS_TYPE_PT_BITSLICE;
8496 kern_type = KERN_TYPE_DESCRYPT;
8497 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8498 parse_func = descrypt_parse_hash;
8499 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8500 opti_type = OPTI_TYPE_ZERO_BYTE
8501 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8502 dgst_pos0 = 0;
8503 dgst_pos1 = 1;
8504 dgst_pos2 = 2;
8505 dgst_pos3 = 3;
8506 break;
8507
8508 case 1600: hash_type = HASH_TYPE_MD5;
8509 salt_type = SALT_TYPE_EMBEDDED;
8510 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8511 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8512 kern_type = KERN_TYPE_APR1CRYPT;
8513 dgst_size = DGST_SIZE_4_4;
8514 parse_func = md5apr1_parse_hash;
8515 sort_by_digest = sort_by_digest_4_4;
8516 opti_type = OPTI_TYPE_ZERO_BYTE;
8517 dgst_pos0 = 0;
8518 dgst_pos1 = 1;
8519 dgst_pos2 = 2;
8520 dgst_pos3 = 3;
8521 break;
8522
8523 case 1700: hash_type = HASH_TYPE_SHA512;
8524 salt_type = SALT_TYPE_NONE;
8525 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8526 opts_type = OPTS_TYPE_PT_GENERATE_BE
8527 | OPTS_TYPE_PT_ADD80
8528 | OPTS_TYPE_PT_ADDBITS15;
8529 kern_type = KERN_TYPE_SHA512;
8530 dgst_size = DGST_SIZE_8_8;
8531 parse_func = sha512_parse_hash;
8532 sort_by_digest = sort_by_digest_8_8;
8533 opti_type = OPTI_TYPE_ZERO_BYTE
8534 | OPTI_TYPE_PRECOMPUTE_INIT
8535 | OPTI_TYPE_PRECOMPUTE_MERKLE
8536 | OPTI_TYPE_EARLY_SKIP
8537 | OPTI_TYPE_NOT_ITERATED
8538 | OPTI_TYPE_NOT_SALTED
8539 | OPTI_TYPE_USES_BITS_64
8540 | OPTI_TYPE_RAW_HASH;
8541 dgst_pos0 = 14;
8542 dgst_pos1 = 15;
8543 dgst_pos2 = 6;
8544 dgst_pos3 = 7;
8545 break;
8546
8547 case 1710: hash_type = HASH_TYPE_SHA512;
8548 salt_type = SALT_TYPE_INTERN;
8549 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8550 opts_type = OPTS_TYPE_PT_GENERATE_BE
8551 | OPTS_TYPE_ST_ADD80
8552 | OPTS_TYPE_ST_ADDBITS15;
8553 kern_type = KERN_TYPE_SHA512_PWSLT;
8554 dgst_size = DGST_SIZE_8_8;
8555 parse_func = sha512s_parse_hash;
8556 sort_by_digest = sort_by_digest_8_8;
8557 opti_type = OPTI_TYPE_ZERO_BYTE
8558 | OPTI_TYPE_PRECOMPUTE_INIT
8559 | OPTI_TYPE_PRECOMPUTE_MERKLE
8560 | OPTI_TYPE_EARLY_SKIP
8561 | OPTI_TYPE_NOT_ITERATED
8562 | OPTI_TYPE_APPENDED_SALT
8563 | OPTI_TYPE_USES_BITS_64
8564 | OPTI_TYPE_RAW_HASH;
8565 dgst_pos0 = 14;
8566 dgst_pos1 = 15;
8567 dgst_pos2 = 6;
8568 dgst_pos3 = 7;
8569 break;
8570
8571 case 1711: hash_type = HASH_TYPE_SHA512;
8572 salt_type = SALT_TYPE_EMBEDDED;
8573 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8574 opts_type = OPTS_TYPE_PT_GENERATE_BE
8575 | OPTS_TYPE_ST_ADD80
8576 | OPTS_TYPE_ST_ADDBITS15;
8577 kern_type = KERN_TYPE_SHA512_PWSLT;
8578 dgst_size = DGST_SIZE_8_8;
8579 parse_func = sha512b64s_parse_hash;
8580 sort_by_digest = sort_by_digest_8_8;
8581 opti_type = OPTI_TYPE_ZERO_BYTE
8582 | OPTI_TYPE_PRECOMPUTE_INIT
8583 | OPTI_TYPE_PRECOMPUTE_MERKLE
8584 | OPTI_TYPE_EARLY_SKIP
8585 | OPTI_TYPE_NOT_ITERATED
8586 | OPTI_TYPE_APPENDED_SALT
8587 | OPTI_TYPE_USES_BITS_64
8588 | OPTI_TYPE_RAW_HASH;
8589 dgst_pos0 = 14;
8590 dgst_pos1 = 15;
8591 dgst_pos2 = 6;
8592 dgst_pos3 = 7;
8593 break;
8594
8595 case 1720: hash_type = HASH_TYPE_SHA512;
8596 salt_type = SALT_TYPE_INTERN;
8597 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8598 opts_type = OPTS_TYPE_PT_GENERATE_BE
8599 | OPTS_TYPE_PT_ADD80
8600 | OPTS_TYPE_PT_ADDBITS15;
8601 kern_type = KERN_TYPE_SHA512_SLTPW;
8602 dgst_size = DGST_SIZE_8_8;
8603 parse_func = sha512s_parse_hash;
8604 sort_by_digest = sort_by_digest_8_8;
8605 opti_type = OPTI_TYPE_ZERO_BYTE
8606 | OPTI_TYPE_PRECOMPUTE_INIT
8607 | OPTI_TYPE_PRECOMPUTE_MERKLE
8608 | OPTI_TYPE_EARLY_SKIP
8609 | OPTI_TYPE_NOT_ITERATED
8610 | OPTI_TYPE_PREPENDED_SALT
8611 | OPTI_TYPE_USES_BITS_64
8612 | OPTI_TYPE_RAW_HASH;
8613 dgst_pos0 = 14;
8614 dgst_pos1 = 15;
8615 dgst_pos2 = 6;
8616 dgst_pos3 = 7;
8617 break;
8618
8619 case 1722: hash_type = HASH_TYPE_SHA512;
8620 salt_type = SALT_TYPE_EMBEDDED;
8621 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8622 opts_type = OPTS_TYPE_PT_GENERATE_BE
8623 | OPTS_TYPE_PT_ADD80
8624 | OPTS_TYPE_PT_ADDBITS15
8625 | OPTS_TYPE_ST_HEX;
8626 kern_type = KERN_TYPE_SHA512_SLTPW;
8627 dgst_size = DGST_SIZE_8_8;
8628 parse_func = osx512_parse_hash;
8629 sort_by_digest = sort_by_digest_8_8;
8630 opti_type = OPTI_TYPE_ZERO_BYTE
8631 | OPTI_TYPE_PRECOMPUTE_INIT
8632 | OPTI_TYPE_PRECOMPUTE_MERKLE
8633 | OPTI_TYPE_EARLY_SKIP
8634 | OPTI_TYPE_NOT_ITERATED
8635 | OPTI_TYPE_PREPENDED_SALT
8636 | OPTI_TYPE_USES_BITS_64
8637 | OPTI_TYPE_RAW_HASH;
8638 dgst_pos0 = 14;
8639 dgst_pos1 = 15;
8640 dgst_pos2 = 6;
8641 dgst_pos3 = 7;
8642 break;
8643
8644 case 1730: hash_type = HASH_TYPE_SHA512;
8645 salt_type = SALT_TYPE_INTERN;
8646 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8647 opts_type = OPTS_TYPE_PT_GENERATE_BE
8648 | OPTS_TYPE_PT_UNICODE
8649 | OPTS_TYPE_ST_ADD80
8650 | OPTS_TYPE_ST_ADDBITS15;
8651 kern_type = KERN_TYPE_SHA512_PWSLTU;
8652 dgst_size = DGST_SIZE_8_8;
8653 parse_func = sha512s_parse_hash;
8654 sort_by_digest = sort_by_digest_8_8;
8655 opti_type = OPTI_TYPE_ZERO_BYTE
8656 | OPTI_TYPE_PRECOMPUTE_INIT
8657 | OPTI_TYPE_PRECOMPUTE_MERKLE
8658 | OPTI_TYPE_EARLY_SKIP
8659 | OPTI_TYPE_NOT_ITERATED
8660 | OPTI_TYPE_APPENDED_SALT
8661 | OPTI_TYPE_USES_BITS_64
8662 | OPTI_TYPE_RAW_HASH;
8663 dgst_pos0 = 14;
8664 dgst_pos1 = 15;
8665 dgst_pos2 = 6;
8666 dgst_pos3 = 7;
8667 break;
8668
8669 case 1731: hash_type = HASH_TYPE_SHA512;
8670 salt_type = SALT_TYPE_EMBEDDED;
8671 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8672 opts_type = OPTS_TYPE_PT_GENERATE_BE
8673 | OPTS_TYPE_PT_UNICODE
8674 | OPTS_TYPE_ST_ADD80
8675 | OPTS_TYPE_ST_ADDBITS15
8676 | OPTS_TYPE_ST_HEX;
8677 kern_type = KERN_TYPE_SHA512_PWSLTU;
8678 dgst_size = DGST_SIZE_8_8;
8679 parse_func = mssql2012_parse_hash;
8680 sort_by_digest = sort_by_digest_8_8;
8681 opti_type = OPTI_TYPE_ZERO_BYTE
8682 | OPTI_TYPE_PRECOMPUTE_INIT
8683 | OPTI_TYPE_PRECOMPUTE_MERKLE
8684 | OPTI_TYPE_EARLY_SKIP
8685 | OPTI_TYPE_NOT_ITERATED
8686 | OPTI_TYPE_APPENDED_SALT
8687 | OPTI_TYPE_USES_BITS_64
8688 | OPTI_TYPE_RAW_HASH;
8689 dgst_pos0 = 14;
8690 dgst_pos1 = 15;
8691 dgst_pos2 = 6;
8692 dgst_pos3 = 7;
8693 break;
8694
8695 case 1740: hash_type = HASH_TYPE_SHA512;
8696 salt_type = SALT_TYPE_INTERN;
8697 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8698 opts_type = OPTS_TYPE_PT_GENERATE_BE
8699 | OPTS_TYPE_PT_ADD80
8700 | OPTS_TYPE_PT_ADDBITS15
8701 | OPTS_TYPE_PT_UNICODE;
8702 kern_type = KERN_TYPE_SHA512_SLTPWU;
8703 dgst_size = DGST_SIZE_8_8;
8704 parse_func = sha512s_parse_hash;
8705 sort_by_digest = sort_by_digest_8_8;
8706 opti_type = OPTI_TYPE_ZERO_BYTE
8707 | OPTI_TYPE_PRECOMPUTE_INIT
8708 | OPTI_TYPE_PRECOMPUTE_MERKLE
8709 | OPTI_TYPE_EARLY_SKIP
8710 | OPTI_TYPE_NOT_ITERATED
8711 | OPTI_TYPE_PREPENDED_SALT
8712 | OPTI_TYPE_USES_BITS_64
8713 | OPTI_TYPE_RAW_HASH;
8714 dgst_pos0 = 14;
8715 dgst_pos1 = 15;
8716 dgst_pos2 = 6;
8717 dgst_pos3 = 7;
8718 break;
8719
8720 case 1750: hash_type = HASH_TYPE_SHA512;
8721 salt_type = SALT_TYPE_INTERN;
8722 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8723 opts_type = OPTS_TYPE_PT_GENERATE_BE
8724 | OPTS_TYPE_ST_ADD80;
8725 kern_type = KERN_TYPE_HMACSHA512_PW;
8726 dgst_size = DGST_SIZE_8_8;
8727 parse_func = hmacsha512_parse_hash;
8728 sort_by_digest = sort_by_digest_8_8;
8729 opti_type = OPTI_TYPE_ZERO_BYTE
8730 | OPTI_TYPE_USES_BITS_64
8731 | OPTI_TYPE_NOT_ITERATED;
8732 dgst_pos0 = 14;
8733 dgst_pos1 = 15;
8734 dgst_pos2 = 6;
8735 dgst_pos3 = 7;
8736 break;
8737
8738 case 1760: hash_type = HASH_TYPE_SHA512;
8739 salt_type = SALT_TYPE_INTERN;
8740 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8741 opts_type = OPTS_TYPE_PT_GENERATE_BE
8742 | OPTS_TYPE_PT_ADD80
8743 | OPTS_TYPE_PT_ADDBITS15;
8744 kern_type = KERN_TYPE_HMACSHA512_SLT;
8745 dgst_size = DGST_SIZE_8_8;
8746 parse_func = hmacsha512_parse_hash;
8747 sort_by_digest = sort_by_digest_8_8;
8748 opti_type = OPTI_TYPE_ZERO_BYTE
8749 | OPTI_TYPE_USES_BITS_64
8750 | OPTI_TYPE_NOT_ITERATED;
8751 dgst_pos0 = 14;
8752 dgst_pos1 = 15;
8753 dgst_pos2 = 6;
8754 dgst_pos3 = 7;
8755 break;
8756
8757 case 1800: hash_type = HASH_TYPE_SHA512;
8758 salt_type = SALT_TYPE_EMBEDDED;
8759 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8760 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8761 kern_type = KERN_TYPE_SHA512CRYPT;
8762 dgst_size = DGST_SIZE_8_8;
8763 parse_func = sha512crypt_parse_hash;
8764 sort_by_digest = sort_by_digest_8_8;
8765 opti_type = OPTI_TYPE_ZERO_BYTE
8766 | OPTI_TYPE_USES_BITS_64;
8767 dgst_pos0 = 0;
8768 dgst_pos1 = 1;
8769 dgst_pos2 = 2;
8770 dgst_pos3 = 3;
8771 break;
8772
8773 case 2000: hash_type = HASH_TYPE_STDOUT;
8774 salt_type = SALT_TYPE_NONE;
8775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8776 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8777 kern_type = KERN_TYPE_STDOUT;
8778 dgst_size = DGST_SIZE_4_4;
8779 parse_func = NULL;
8780 sort_by_digest = NULL;
8781 opti_type = 0;
8782 dgst_pos0 = 0;
8783 dgst_pos1 = 0;
8784 dgst_pos2 = 0;
8785 dgst_pos3 = 0;
8786 break;
8787
8788 case 2100: hash_type = HASH_TYPE_DCC2;
8789 salt_type = SALT_TYPE_EMBEDDED;
8790 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8791 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8792 | OPTS_TYPE_ST_LOWER
8793 | OPTS_TYPE_ST_UNICODE;
8794 kern_type = KERN_TYPE_DCC2;
8795 dgst_size = DGST_SIZE_4_4;
8796 parse_func = dcc2_parse_hash;
8797 sort_by_digest = sort_by_digest_4_4;
8798 opti_type = OPTI_TYPE_ZERO_BYTE
8799 | OPTI_TYPE_SLOW_HASH_SIMD;
8800 dgst_pos0 = 0;
8801 dgst_pos1 = 1;
8802 dgst_pos2 = 2;
8803 dgst_pos3 = 3;
8804 break;
8805
8806 case 2400: hash_type = HASH_TYPE_MD5;
8807 salt_type = SALT_TYPE_NONE;
8808 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8809 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8810 kern_type = KERN_TYPE_MD5PIX;
8811 dgst_size = DGST_SIZE_4_4;
8812 parse_func = md5pix_parse_hash;
8813 sort_by_digest = sort_by_digest_4_4;
8814 opti_type = OPTI_TYPE_ZERO_BYTE
8815 | OPTI_TYPE_PRECOMPUTE_INIT
8816 | OPTI_TYPE_PRECOMPUTE_MERKLE
8817 | OPTI_TYPE_EARLY_SKIP
8818 | OPTI_TYPE_NOT_ITERATED
8819 | OPTI_TYPE_NOT_SALTED;
8820 dgst_pos0 = 0;
8821 dgst_pos1 = 3;
8822 dgst_pos2 = 2;
8823 dgst_pos3 = 1;
8824 break;
8825
8826 case 2410: hash_type = HASH_TYPE_MD5;
8827 salt_type = SALT_TYPE_INTERN;
8828 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8829 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8830 kern_type = KERN_TYPE_MD5ASA;
8831 dgst_size = DGST_SIZE_4_4;
8832 parse_func = md5asa_parse_hash;
8833 sort_by_digest = sort_by_digest_4_4;
8834 opti_type = OPTI_TYPE_ZERO_BYTE
8835 | OPTI_TYPE_PRECOMPUTE_INIT
8836 | OPTI_TYPE_PRECOMPUTE_MERKLE
8837 | OPTI_TYPE_EARLY_SKIP
8838 | OPTI_TYPE_NOT_ITERATED;
8839 dgst_pos0 = 0;
8840 dgst_pos1 = 3;
8841 dgst_pos2 = 2;
8842 dgst_pos3 = 1;
8843 break;
8844
8845 case 2500: hash_type = HASH_TYPE_WPA;
8846 salt_type = SALT_TYPE_EMBEDDED;
8847 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8848 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8849 kern_type = KERN_TYPE_WPA;
8850 dgst_size = DGST_SIZE_4_4;
8851 parse_func = wpa_parse_hash;
8852 sort_by_digest = sort_by_digest_4_4;
8853 opti_type = OPTI_TYPE_ZERO_BYTE
8854 | OPTI_TYPE_SLOW_HASH_SIMD;
8855 dgst_pos0 = 0;
8856 dgst_pos1 = 1;
8857 dgst_pos2 = 2;
8858 dgst_pos3 = 3;
8859 break;
8860
8861 case 2600: hash_type = HASH_TYPE_MD5;
8862 salt_type = SALT_TYPE_VIRTUAL;
8863 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8864 opts_type = OPTS_TYPE_PT_GENERATE_LE
8865 | OPTS_TYPE_PT_ADD80
8866 | OPTS_TYPE_PT_ADDBITS14
8867 | OPTS_TYPE_ST_ADD80;
8868 kern_type = KERN_TYPE_MD55_PWSLT1;
8869 dgst_size = DGST_SIZE_4_4;
8870 parse_func = md5md5_parse_hash;
8871 sort_by_digest = sort_by_digest_4_4;
8872 opti_type = OPTI_TYPE_ZERO_BYTE
8873 | OPTI_TYPE_PRECOMPUTE_INIT
8874 | OPTI_TYPE_PRECOMPUTE_MERKLE
8875 | OPTI_TYPE_EARLY_SKIP;
8876 dgst_pos0 = 0;
8877 dgst_pos1 = 3;
8878 dgst_pos2 = 2;
8879 dgst_pos3 = 1;
8880 break;
8881
8882 case 2611: hash_type = HASH_TYPE_MD5;
8883 salt_type = SALT_TYPE_INTERN;
8884 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8885 opts_type = OPTS_TYPE_PT_GENERATE_LE
8886 | OPTS_TYPE_PT_ADD80
8887 | OPTS_TYPE_PT_ADDBITS14
8888 | OPTS_TYPE_ST_ADD80;
8889 kern_type = KERN_TYPE_MD55_PWSLT1;
8890 dgst_size = DGST_SIZE_4_4;
8891 parse_func = vb3_parse_hash;
8892 sort_by_digest = sort_by_digest_4_4;
8893 opti_type = OPTI_TYPE_ZERO_BYTE
8894 | OPTI_TYPE_PRECOMPUTE_INIT
8895 | OPTI_TYPE_PRECOMPUTE_MERKLE
8896 | OPTI_TYPE_EARLY_SKIP;
8897 dgst_pos0 = 0;
8898 dgst_pos1 = 3;
8899 dgst_pos2 = 2;
8900 dgst_pos3 = 1;
8901 break;
8902
8903 case 2612: hash_type = HASH_TYPE_MD5;
8904 salt_type = SALT_TYPE_EMBEDDED;
8905 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8906 opts_type = OPTS_TYPE_PT_GENERATE_LE
8907 | OPTS_TYPE_PT_ADD80
8908 | OPTS_TYPE_PT_ADDBITS14
8909 | OPTS_TYPE_ST_ADD80
8910 | OPTS_TYPE_ST_HEX;
8911 kern_type = KERN_TYPE_MD55_PWSLT1;
8912 dgst_size = DGST_SIZE_4_4;
8913 parse_func = phps_parse_hash;
8914 sort_by_digest = sort_by_digest_4_4;
8915 opti_type = OPTI_TYPE_ZERO_BYTE
8916 | OPTI_TYPE_PRECOMPUTE_INIT
8917 | OPTI_TYPE_PRECOMPUTE_MERKLE
8918 | OPTI_TYPE_EARLY_SKIP;
8919 dgst_pos0 = 0;
8920 dgst_pos1 = 3;
8921 dgst_pos2 = 2;
8922 dgst_pos3 = 1;
8923 break;
8924
8925 case 2711: hash_type = HASH_TYPE_MD5;
8926 salt_type = SALT_TYPE_INTERN;
8927 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8928 opts_type = OPTS_TYPE_PT_GENERATE_LE
8929 | OPTS_TYPE_PT_ADD80
8930 | OPTS_TYPE_PT_ADDBITS14
8931 | OPTS_TYPE_ST_ADD80;
8932 kern_type = KERN_TYPE_MD55_PWSLT2;
8933 dgst_size = DGST_SIZE_4_4;
8934 parse_func = vb30_parse_hash;
8935 sort_by_digest = sort_by_digest_4_4;
8936 opti_type = OPTI_TYPE_ZERO_BYTE
8937 | OPTI_TYPE_PRECOMPUTE_INIT
8938 | OPTI_TYPE_EARLY_SKIP;
8939 dgst_pos0 = 0;
8940 dgst_pos1 = 3;
8941 dgst_pos2 = 2;
8942 dgst_pos3 = 1;
8943 break;
8944
8945 case 2811: hash_type = HASH_TYPE_MD5;
8946 salt_type = SALT_TYPE_INTERN;
8947 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8948 opts_type = OPTS_TYPE_PT_GENERATE_LE
8949 | OPTS_TYPE_PT_ADD80
8950 | OPTS_TYPE_PT_ADDBITS14;
8951 kern_type = KERN_TYPE_MD55_SLTPW;
8952 dgst_size = DGST_SIZE_4_4;
8953 parse_func = ipb2_parse_hash;
8954 sort_by_digest = sort_by_digest_4_4;
8955 opti_type = OPTI_TYPE_ZERO_BYTE
8956 | OPTI_TYPE_PRECOMPUTE_INIT
8957 | OPTI_TYPE_EARLY_SKIP;
8958 dgst_pos0 = 0;
8959 dgst_pos1 = 3;
8960 dgst_pos2 = 2;
8961 dgst_pos3 = 1;
8962 break;
8963
8964 case 3000: hash_type = HASH_TYPE_LM;
8965 salt_type = SALT_TYPE_NONE;
8966 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8967 opts_type = OPTS_TYPE_PT_GENERATE_LE
8968 | OPTS_TYPE_PT_UPPER
8969 | OPTS_TYPE_PT_BITSLICE;
8970 kern_type = KERN_TYPE_LM;
8971 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8972 parse_func = lm_parse_hash;
8973 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8974 opti_type = OPTI_TYPE_ZERO_BYTE
8975 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8976 dgst_pos0 = 0;
8977 dgst_pos1 = 1;
8978 dgst_pos2 = 2;
8979 dgst_pos3 = 3;
8980 break;
8981
8982 case 3100: hash_type = HASH_TYPE_ORACLEH;
8983 salt_type = SALT_TYPE_INTERN;
8984 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8985 opts_type = OPTS_TYPE_PT_GENERATE_LE
8986 | OPTS_TYPE_PT_UPPER
8987 | OPTS_TYPE_ST_UPPER;
8988 kern_type = KERN_TYPE_ORACLEH;
8989 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8990 parse_func = oracleh_parse_hash;
8991 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8992 opti_type = OPTI_TYPE_ZERO_BYTE;
8993 dgst_pos0 = 0;
8994 dgst_pos1 = 1;
8995 dgst_pos2 = 2;
8996 dgst_pos3 = 3;
8997 break;
8998
8999 case 3200: hash_type = HASH_TYPE_BCRYPT;
9000 salt_type = SALT_TYPE_EMBEDDED;
9001 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9002 opts_type = OPTS_TYPE_PT_GENERATE_LE
9003 | OPTS_TYPE_ST_GENERATE_LE;
9004 kern_type = KERN_TYPE_BCRYPT;
9005 dgst_size = DGST_SIZE_4_6;
9006 parse_func = bcrypt_parse_hash;
9007 sort_by_digest = sort_by_digest_4_6;
9008 opti_type = OPTI_TYPE_ZERO_BYTE;
9009 dgst_pos0 = 0;
9010 dgst_pos1 = 1;
9011 dgst_pos2 = 2;
9012 dgst_pos3 = 3;
9013 break;
9014
9015 case 3710: hash_type = HASH_TYPE_MD5;
9016 salt_type = SALT_TYPE_INTERN;
9017 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9018 opts_type = OPTS_TYPE_PT_GENERATE_LE
9019 | OPTS_TYPE_PT_ADD80
9020 | OPTS_TYPE_PT_ADDBITS14;
9021 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9022 dgst_size = DGST_SIZE_4_4;
9023 parse_func = md5s_parse_hash;
9024 sort_by_digest = sort_by_digest_4_4;
9025 opti_type = OPTI_TYPE_ZERO_BYTE
9026 | OPTI_TYPE_PRECOMPUTE_INIT
9027 | OPTI_TYPE_PRECOMPUTE_MERKLE
9028 | OPTI_TYPE_EARLY_SKIP;
9029 dgst_pos0 = 0;
9030 dgst_pos1 = 3;
9031 dgst_pos2 = 2;
9032 dgst_pos3 = 1;
9033 break;
9034
9035 case 3711: hash_type = HASH_TYPE_MD5;
9036 salt_type = SALT_TYPE_EMBEDDED;
9037 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9038 opts_type = OPTS_TYPE_PT_GENERATE_LE
9039 | OPTS_TYPE_PT_ADD80
9040 | OPTS_TYPE_PT_ADDBITS14;
9041 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9042 dgst_size = DGST_SIZE_4_4;
9043 parse_func = mediawiki_b_parse_hash;
9044 sort_by_digest = sort_by_digest_4_4;
9045 opti_type = OPTI_TYPE_ZERO_BYTE
9046 | OPTI_TYPE_PRECOMPUTE_INIT
9047 | OPTI_TYPE_PRECOMPUTE_MERKLE
9048 | OPTI_TYPE_EARLY_SKIP;
9049 dgst_pos0 = 0;
9050 dgst_pos1 = 3;
9051 dgst_pos2 = 2;
9052 dgst_pos3 = 1;
9053 break;
9054
9055 case 3800: hash_type = HASH_TYPE_MD5;
9056 salt_type = SALT_TYPE_INTERN;
9057 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9058 opts_type = OPTS_TYPE_PT_GENERATE_LE
9059 | OPTS_TYPE_ST_ADDBITS14;
9060 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
9061 dgst_size = DGST_SIZE_4_4;
9062 parse_func = md5s_parse_hash;
9063 sort_by_digest = sort_by_digest_4_4;
9064 opti_type = OPTI_TYPE_ZERO_BYTE
9065 | OPTI_TYPE_PRECOMPUTE_INIT
9066 | OPTI_TYPE_PRECOMPUTE_MERKLE
9067 | OPTI_TYPE_EARLY_SKIP
9068 | OPTI_TYPE_NOT_ITERATED
9069 | OPTI_TYPE_RAW_HASH;
9070 dgst_pos0 = 0;
9071 dgst_pos1 = 3;
9072 dgst_pos2 = 2;
9073 dgst_pos3 = 1;
9074 break;
9075
9076 case 4300: hash_type = HASH_TYPE_MD5;
9077 salt_type = SALT_TYPE_VIRTUAL;
9078 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9079 opts_type = OPTS_TYPE_PT_GENERATE_LE
9080 | OPTS_TYPE_PT_ADD80
9081 | OPTS_TYPE_PT_ADDBITS14
9082 | OPTS_TYPE_ST_ADD80;
9083 kern_type = KERN_TYPE_MD5U5_PWSLT1;
9084 dgst_size = DGST_SIZE_4_4;
9085 parse_func = md5md5_parse_hash;
9086 sort_by_digest = sort_by_digest_4_4;
9087 opti_type = OPTI_TYPE_ZERO_BYTE
9088 | OPTI_TYPE_PRECOMPUTE_INIT
9089 | OPTI_TYPE_PRECOMPUTE_MERKLE
9090 | OPTI_TYPE_EARLY_SKIP;
9091 dgst_pos0 = 0;
9092 dgst_pos1 = 3;
9093 dgst_pos2 = 2;
9094 dgst_pos3 = 1;
9095 break;
9096
9097
9098 case 4400: hash_type = HASH_TYPE_MD5;
9099 salt_type = SALT_TYPE_NONE;
9100 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9101 opts_type = OPTS_TYPE_PT_GENERATE_BE
9102 | OPTS_TYPE_PT_ADD80
9103 | OPTS_TYPE_PT_ADDBITS15;
9104 kern_type = KERN_TYPE_MD5_SHA1;
9105 dgst_size = DGST_SIZE_4_4;
9106 parse_func = md5_parse_hash;
9107 sort_by_digest = sort_by_digest_4_4;
9108 opti_type = OPTI_TYPE_ZERO_BYTE
9109 | OPTI_TYPE_PRECOMPUTE_INIT
9110 | OPTI_TYPE_PRECOMPUTE_MERKLE
9111 | OPTI_TYPE_EARLY_SKIP
9112 | OPTI_TYPE_NOT_ITERATED
9113 | OPTI_TYPE_NOT_SALTED
9114 | OPTI_TYPE_RAW_HASH;
9115 dgst_pos0 = 0;
9116 dgst_pos1 = 3;
9117 dgst_pos2 = 2;
9118 dgst_pos3 = 1;
9119 break;
9120
9121 case 4500: hash_type = HASH_TYPE_SHA1;
9122 salt_type = SALT_TYPE_NONE;
9123 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9124 opts_type = OPTS_TYPE_PT_GENERATE_BE
9125 | OPTS_TYPE_PT_ADD80
9126 | OPTS_TYPE_PT_ADDBITS15;
9127 kern_type = KERN_TYPE_SHA11;
9128 dgst_size = DGST_SIZE_4_5;
9129 parse_func = sha1_parse_hash;
9130 sort_by_digest = sort_by_digest_4_5;
9131 opti_type = OPTI_TYPE_ZERO_BYTE
9132 | OPTI_TYPE_PRECOMPUTE_INIT
9133 | OPTI_TYPE_PRECOMPUTE_MERKLE
9134 | OPTI_TYPE_EARLY_SKIP
9135 | OPTI_TYPE_NOT_SALTED;
9136 dgst_pos0 = 3;
9137 dgst_pos1 = 4;
9138 dgst_pos2 = 2;
9139 dgst_pos3 = 1;
9140 break;
9141
9142 case 4700: hash_type = HASH_TYPE_SHA1;
9143 salt_type = SALT_TYPE_NONE;
9144 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9145 opts_type = OPTS_TYPE_PT_GENERATE_LE
9146 | OPTS_TYPE_PT_ADD80
9147 | OPTS_TYPE_PT_ADDBITS14;
9148 kern_type = KERN_TYPE_SHA1_MD5;
9149 dgst_size = DGST_SIZE_4_5;
9150 parse_func = sha1_parse_hash;
9151 sort_by_digest = sort_by_digest_4_5;
9152 opti_type = OPTI_TYPE_ZERO_BYTE
9153 | OPTI_TYPE_PRECOMPUTE_INIT
9154 | OPTI_TYPE_PRECOMPUTE_MERKLE
9155 | OPTI_TYPE_EARLY_SKIP
9156 | OPTI_TYPE_NOT_ITERATED
9157 | OPTI_TYPE_NOT_SALTED
9158 | OPTI_TYPE_RAW_HASH;
9159 dgst_pos0 = 3;
9160 dgst_pos1 = 4;
9161 dgst_pos2 = 2;
9162 dgst_pos3 = 1;
9163 break;
9164
9165 case 4800: hash_type = HASH_TYPE_MD5;
9166 salt_type = SALT_TYPE_EMBEDDED;
9167 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9168 opts_type = OPTS_TYPE_PT_GENERATE_LE
9169 | OPTS_TYPE_PT_ADDBITS14;
9170 kern_type = KERN_TYPE_MD5_CHAP;
9171 dgst_size = DGST_SIZE_4_4;
9172 parse_func = chap_parse_hash;
9173 sort_by_digest = sort_by_digest_4_4;
9174 opti_type = OPTI_TYPE_ZERO_BYTE
9175 | OPTI_TYPE_PRECOMPUTE_INIT
9176 | OPTI_TYPE_PRECOMPUTE_MERKLE
9177 | OPTI_TYPE_MEET_IN_MIDDLE
9178 | OPTI_TYPE_EARLY_SKIP
9179 | OPTI_TYPE_NOT_ITERATED
9180 | OPTI_TYPE_RAW_HASH;
9181 dgst_pos0 = 0;
9182 dgst_pos1 = 3;
9183 dgst_pos2 = 2;
9184 dgst_pos3 = 1;
9185 break;
9186
9187 case 4900: hash_type = HASH_TYPE_SHA1;
9188 salt_type = SALT_TYPE_INTERN;
9189 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9190 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9191 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9192 dgst_size = DGST_SIZE_4_5;
9193 parse_func = sha1s_parse_hash;
9194 sort_by_digest = sort_by_digest_4_5;
9195 opti_type = OPTI_TYPE_ZERO_BYTE
9196 | OPTI_TYPE_PRECOMPUTE_INIT
9197 | OPTI_TYPE_PRECOMPUTE_MERKLE
9198 | OPTI_TYPE_EARLY_SKIP;
9199 dgst_pos0 = 3;
9200 dgst_pos1 = 4;
9201 dgst_pos2 = 2;
9202 dgst_pos3 = 1;
9203 break;
9204
9205 case 5000: hash_type = HASH_TYPE_KECCAK;
9206 salt_type = SALT_TYPE_EMBEDDED;
9207 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9208 opts_type = OPTS_TYPE_PT_GENERATE_LE
9209 | OPTS_TYPE_PT_ADD01;
9210 kern_type = KERN_TYPE_KECCAK;
9211 dgst_size = DGST_SIZE_8_25;
9212 parse_func = keccak_parse_hash;
9213 sort_by_digest = sort_by_digest_8_25;
9214 opti_type = OPTI_TYPE_ZERO_BYTE
9215 | OPTI_TYPE_USES_BITS_64
9216 | OPTI_TYPE_RAW_HASH;
9217 dgst_pos0 = 2;
9218 dgst_pos1 = 3;
9219 dgst_pos2 = 4;
9220 dgst_pos3 = 5;
9221 break;
9222
9223 case 5100: hash_type = HASH_TYPE_MD5H;
9224 salt_type = SALT_TYPE_NONE;
9225 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9226 opts_type = OPTS_TYPE_PT_GENERATE_LE
9227 | OPTS_TYPE_PT_ADD80
9228 | OPTS_TYPE_PT_ADDBITS14;
9229 kern_type = KERN_TYPE_MD5H;
9230 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9231 parse_func = md5half_parse_hash;
9232 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9233 opti_type = OPTI_TYPE_ZERO_BYTE
9234 | OPTI_TYPE_RAW_HASH;
9235 dgst_pos0 = 0;
9236 dgst_pos1 = 1;
9237 dgst_pos2 = 2;
9238 dgst_pos3 = 3;
9239 break;
9240
9241 case 5200: hash_type = HASH_TYPE_SHA256;
9242 salt_type = SALT_TYPE_EMBEDDED;
9243 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9244 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9245 kern_type = KERN_TYPE_PSAFE3;
9246 dgst_size = DGST_SIZE_4_8;
9247 parse_func = psafe3_parse_hash;
9248 sort_by_digest = sort_by_digest_4_8;
9249 opti_type = OPTI_TYPE_ZERO_BYTE;
9250 dgst_pos0 = 0;
9251 dgst_pos1 = 1;
9252 dgst_pos2 = 2;
9253 dgst_pos3 = 3;
9254 break;
9255
9256 case 5300: hash_type = HASH_TYPE_MD5;
9257 salt_type = SALT_TYPE_EMBEDDED;
9258 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9259 opts_type = OPTS_TYPE_PT_GENERATE_LE
9260 | OPTS_TYPE_ST_ADD80;
9261 kern_type = KERN_TYPE_IKEPSK_MD5;
9262 dgst_size = DGST_SIZE_4_4;
9263 parse_func = ikepsk_md5_parse_hash;
9264 sort_by_digest = sort_by_digest_4_4;
9265 opti_type = OPTI_TYPE_ZERO_BYTE;
9266 dgst_pos0 = 0;
9267 dgst_pos1 = 3;
9268 dgst_pos2 = 2;
9269 dgst_pos3 = 1;
9270 break;
9271
9272 case 5400: hash_type = HASH_TYPE_SHA1;
9273 salt_type = SALT_TYPE_EMBEDDED;
9274 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9275 opts_type = OPTS_TYPE_PT_GENERATE_BE
9276 | OPTS_TYPE_ST_ADD80;
9277 kern_type = KERN_TYPE_IKEPSK_SHA1;
9278 dgst_size = DGST_SIZE_4_5;
9279 parse_func = ikepsk_sha1_parse_hash;
9280 sort_by_digest = sort_by_digest_4_5;
9281 opti_type = OPTI_TYPE_ZERO_BYTE;
9282 dgst_pos0 = 3;
9283 dgst_pos1 = 4;
9284 dgst_pos2 = 2;
9285 dgst_pos3 = 1;
9286 break;
9287
9288 case 5500: hash_type = HASH_TYPE_NETNTLM;
9289 salt_type = SALT_TYPE_EMBEDDED;
9290 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9291 opts_type = OPTS_TYPE_PT_GENERATE_LE
9292 | OPTS_TYPE_PT_ADD80
9293 | OPTS_TYPE_PT_ADDBITS14
9294 | OPTS_TYPE_PT_UNICODE
9295 | OPTS_TYPE_ST_HEX;
9296 kern_type = KERN_TYPE_NETNTLMv1;
9297 dgst_size = DGST_SIZE_4_4;
9298 parse_func = netntlmv1_parse_hash;
9299 sort_by_digest = sort_by_digest_4_4;
9300 opti_type = OPTI_TYPE_ZERO_BYTE
9301 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9302 dgst_pos0 = 0;
9303 dgst_pos1 = 1;
9304 dgst_pos2 = 2;
9305 dgst_pos3 = 3;
9306 break;
9307
9308 case 5600: hash_type = HASH_TYPE_MD5;
9309 salt_type = SALT_TYPE_EMBEDDED;
9310 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9311 opts_type = OPTS_TYPE_PT_GENERATE_LE
9312 | OPTS_TYPE_PT_ADD80
9313 | OPTS_TYPE_PT_ADDBITS14
9314 | OPTS_TYPE_PT_UNICODE;
9315 kern_type = KERN_TYPE_NETNTLMv2;
9316 dgst_size = DGST_SIZE_4_4;
9317 parse_func = netntlmv2_parse_hash;
9318 sort_by_digest = sort_by_digest_4_4;
9319 opti_type = OPTI_TYPE_ZERO_BYTE;
9320 dgst_pos0 = 0;
9321 dgst_pos1 = 3;
9322 dgst_pos2 = 2;
9323 dgst_pos3 = 1;
9324 break;
9325
9326 case 5700: hash_type = HASH_TYPE_SHA256;
9327 salt_type = SALT_TYPE_NONE;
9328 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9329 opts_type = OPTS_TYPE_PT_GENERATE_BE
9330 | OPTS_TYPE_PT_ADD80
9331 | OPTS_TYPE_PT_ADDBITS15;
9332 kern_type = KERN_TYPE_SHA256;
9333 dgst_size = DGST_SIZE_4_8;
9334 parse_func = cisco4_parse_hash;
9335 sort_by_digest = sort_by_digest_4_8;
9336 opti_type = OPTI_TYPE_ZERO_BYTE
9337 | OPTI_TYPE_PRECOMPUTE_INIT
9338 | OPTI_TYPE_PRECOMPUTE_MERKLE
9339 | OPTI_TYPE_EARLY_SKIP
9340 | OPTI_TYPE_NOT_ITERATED
9341 | OPTI_TYPE_NOT_SALTED
9342 | OPTI_TYPE_RAW_HASH;
9343 dgst_pos0 = 3;
9344 dgst_pos1 = 7;
9345 dgst_pos2 = 2;
9346 dgst_pos3 = 6;
9347 break;
9348
9349 case 5800: hash_type = HASH_TYPE_SHA1;
9350 salt_type = SALT_TYPE_INTERN;
9351 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9352 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9353 | OPTS_TYPE_ST_ADD80;
9354 kern_type = KERN_TYPE_ANDROIDPIN;
9355 dgst_size = DGST_SIZE_4_5;
9356 parse_func = androidpin_parse_hash;
9357 sort_by_digest = sort_by_digest_4_5;
9358 opti_type = OPTI_TYPE_ZERO_BYTE;
9359 dgst_pos0 = 0;
9360 dgst_pos1 = 1;
9361 dgst_pos2 = 2;
9362 dgst_pos3 = 3;
9363 break;
9364
9365 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9366 salt_type = SALT_TYPE_NONE;
9367 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9368 opts_type = OPTS_TYPE_PT_GENERATE_LE
9369 | OPTS_TYPE_PT_ADD80;
9370 kern_type = KERN_TYPE_RIPEMD160;
9371 dgst_size = DGST_SIZE_4_5;
9372 parse_func = ripemd160_parse_hash;
9373 sort_by_digest = sort_by_digest_4_5;
9374 opti_type = OPTI_TYPE_ZERO_BYTE;
9375 dgst_pos0 = 0;
9376 dgst_pos1 = 1;
9377 dgst_pos2 = 2;
9378 dgst_pos3 = 3;
9379 break;
9380
9381 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9382 salt_type = SALT_TYPE_NONE;
9383 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9384 opts_type = OPTS_TYPE_PT_GENERATE_BE
9385 | OPTS_TYPE_PT_ADD80;
9386 kern_type = KERN_TYPE_WHIRLPOOL;
9387 dgst_size = DGST_SIZE_4_16;
9388 parse_func = whirlpool_parse_hash;
9389 sort_by_digest = sort_by_digest_4_16;
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 6211: 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_XTS512;
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 6212: 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_XTS1024;
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 6213: hash_type = HASH_TYPE_RIPEMD160;
9428 salt_type = SALT_TYPE_EMBEDDED;
9429 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9430 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9431 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9432 dgst_size = DGST_SIZE_4_5;
9433 parse_func = truecrypt_parse_hash_2k;
9434 sort_by_digest = sort_by_digest_4_5;
9435 opti_type = OPTI_TYPE_ZERO_BYTE;
9436 dgst_pos0 = 0;
9437 dgst_pos1 = 1;
9438 dgst_pos2 = 2;
9439 dgst_pos3 = 3;
9440 break;
9441
9442 case 6221: hash_type = HASH_TYPE_SHA512;
9443 salt_type = SALT_TYPE_EMBEDDED;
9444 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9445 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9446 kern_type = KERN_TYPE_TCSHA512_XTS512;
9447 dgst_size = DGST_SIZE_8_8;
9448 parse_func = truecrypt_parse_hash_1k;
9449 sort_by_digest = sort_by_digest_8_8;
9450 opti_type = OPTI_TYPE_ZERO_BYTE
9451 | OPTI_TYPE_USES_BITS_64;
9452 dgst_pos0 = 0;
9453 dgst_pos1 = 1;
9454 dgst_pos2 = 2;
9455 dgst_pos3 = 3;
9456 break;
9457
9458 case 6222: hash_type = HASH_TYPE_SHA512;
9459 salt_type = SALT_TYPE_EMBEDDED;
9460 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9461 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9462 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9463 dgst_size = DGST_SIZE_8_8;
9464 parse_func = truecrypt_parse_hash_1k;
9465 sort_by_digest = sort_by_digest_8_8;
9466 opti_type = OPTI_TYPE_ZERO_BYTE
9467 | OPTI_TYPE_USES_BITS_64;
9468 dgst_pos0 = 0;
9469 dgst_pos1 = 1;
9470 dgst_pos2 = 2;
9471 dgst_pos3 = 3;
9472 break;
9473
9474 case 6223: hash_type = HASH_TYPE_SHA512;
9475 salt_type = SALT_TYPE_EMBEDDED;
9476 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9477 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9478 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9479 dgst_size = DGST_SIZE_8_8;
9480 parse_func = truecrypt_parse_hash_1k;
9481 sort_by_digest = sort_by_digest_8_8;
9482 opti_type = OPTI_TYPE_ZERO_BYTE
9483 | OPTI_TYPE_USES_BITS_64;
9484 dgst_pos0 = 0;
9485 dgst_pos1 = 1;
9486 dgst_pos2 = 2;
9487 dgst_pos3 = 3;
9488 break;
9489
9490 case 6231: 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_XTS512;
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 6232: 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_XTS1024;
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 6233: hash_type = HASH_TYPE_WHIRLPOOL;
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_TCWHIRLPOOL_XTS1536;
9525 dgst_size = DGST_SIZE_4_8;
9526 parse_func = truecrypt_parse_hash_1k;
9527 sort_by_digest = sort_by_digest_4_8;
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 6241: 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_XTS512;
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 6242: 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_XTS1024;
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 6243: hash_type = HASH_TYPE_RIPEMD160;
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_TCRIPEMD160_XTS1536;
9570 dgst_size = DGST_SIZE_4_5;
9571 parse_func = truecrypt_parse_hash_1k;
9572 sort_by_digest = sort_by_digest_4_5;
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 6300: hash_type = HASH_TYPE_MD5;
9581 salt_type = SALT_TYPE_EMBEDDED;
9582 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9583 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9584 kern_type = KERN_TYPE_MD5AIX;
9585 dgst_size = DGST_SIZE_4_4;
9586 parse_func = md5aix_parse_hash;
9587 sort_by_digest = sort_by_digest_4_4;
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 6400: hash_type = HASH_TYPE_SHA256;
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_SHA256AIX;
9600 dgst_size = DGST_SIZE_4_8;
9601 parse_func = sha256aix_parse_hash;
9602 sort_by_digest = sort_by_digest_4_8;
9603 opti_type = OPTI_TYPE_ZERO_BYTE;
9604 dgst_pos0 = 0;
9605 dgst_pos1 = 1;
9606 dgst_pos2 = 2;
9607 dgst_pos3 = 3;
9608 break;
9609
9610 case 6500: hash_type = HASH_TYPE_SHA512;
9611 salt_type = SALT_TYPE_EMBEDDED;
9612 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9613 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9614 kern_type = KERN_TYPE_SHA512AIX;
9615 dgst_size = DGST_SIZE_8_8;
9616 parse_func = sha512aix_parse_hash;
9617 sort_by_digest = sort_by_digest_8_8;
9618 opti_type = OPTI_TYPE_ZERO_BYTE
9619 | OPTI_TYPE_USES_BITS_64;
9620 dgst_pos0 = 0;
9621 dgst_pos1 = 1;
9622 dgst_pos2 = 2;
9623 dgst_pos3 = 3;
9624 break;
9625
9626 case 6600: hash_type = HASH_TYPE_AES;
9627 salt_type = SALT_TYPE_EMBEDDED;
9628 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9629 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9630 kern_type = KERN_TYPE_AGILEKEY;
9631 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9632 parse_func = agilekey_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 6700: hash_type = HASH_TYPE_SHA1;
9642 salt_type = SALT_TYPE_EMBEDDED;
9643 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9644 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9645 kern_type = KERN_TYPE_SHA1AIX;
9646 dgst_size = DGST_SIZE_4_5;
9647 parse_func = sha1aix_parse_hash;
9648 sort_by_digest = sort_by_digest_4_5;
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 6800: hash_type = HASH_TYPE_AES;
9657 salt_type = SALT_TYPE_EMBEDDED;
9658 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9659 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9660 kern_type = KERN_TYPE_LASTPASS;
9661 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9662 parse_func = lastpass_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 6900: hash_type = HASH_TYPE_GOST;
9672 salt_type = SALT_TYPE_NONE;
9673 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9674 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9675 kern_type = KERN_TYPE_GOST;
9676 dgst_size = DGST_SIZE_4_8;
9677 parse_func = gost_parse_hash;
9678 sort_by_digest = sort_by_digest_4_8;
9679 opti_type = OPTI_TYPE_ZERO_BYTE;
9680 dgst_pos0 = 0;
9681 dgst_pos1 = 1;
9682 dgst_pos2 = 2;
9683 dgst_pos3 = 3;
9684 break;
9685
9686 case 7100: hash_type = HASH_TYPE_SHA512;
9687 salt_type = SALT_TYPE_EMBEDDED;
9688 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9689 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9690 kern_type = KERN_TYPE_PBKDF2_SHA512;
9691 dgst_size = DGST_SIZE_8_16;
9692 parse_func = sha512osx_parse_hash;
9693 sort_by_digest = sort_by_digest_8_16;
9694 opti_type = OPTI_TYPE_ZERO_BYTE
9695 | OPTI_TYPE_USES_BITS_64
9696 | OPTI_TYPE_SLOW_HASH_SIMD;
9697 dgst_pos0 = 0;
9698 dgst_pos1 = 1;
9699 dgst_pos2 = 2;
9700 dgst_pos3 = 3;
9701 break;
9702
9703 case 7200: hash_type = HASH_TYPE_SHA512;
9704 salt_type = SALT_TYPE_EMBEDDED;
9705 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9706 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9707 kern_type = KERN_TYPE_PBKDF2_SHA512;
9708 dgst_size = DGST_SIZE_8_16;
9709 parse_func = sha512grub_parse_hash;
9710 sort_by_digest = sort_by_digest_8_16;
9711 opti_type = OPTI_TYPE_ZERO_BYTE
9712 | OPTI_TYPE_USES_BITS_64
9713 | OPTI_TYPE_SLOW_HASH_SIMD;
9714 dgst_pos0 = 0;
9715 dgst_pos1 = 1;
9716 dgst_pos2 = 2;
9717 dgst_pos3 = 3;
9718 break;
9719
9720 case 7300: hash_type = HASH_TYPE_SHA1;
9721 salt_type = SALT_TYPE_EMBEDDED;
9722 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9723 opts_type = OPTS_TYPE_PT_GENERATE_BE
9724 | OPTS_TYPE_ST_ADD80
9725 | OPTS_TYPE_ST_ADDBITS15;
9726 kern_type = KERN_TYPE_RAKP;
9727 dgst_size = DGST_SIZE_4_5;
9728 parse_func = rakp_parse_hash;
9729 sort_by_digest = sort_by_digest_4_5;
9730 opti_type = OPTI_TYPE_ZERO_BYTE
9731 | OPTI_TYPE_NOT_ITERATED;
9732 dgst_pos0 = 3;
9733 dgst_pos1 = 4;
9734 dgst_pos2 = 2;
9735 dgst_pos3 = 1;
9736 break;
9737
9738 case 7400: hash_type = HASH_TYPE_SHA256;
9739 salt_type = SALT_TYPE_EMBEDDED;
9740 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9741 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9742 kern_type = KERN_TYPE_SHA256CRYPT;
9743 dgst_size = DGST_SIZE_4_8;
9744 parse_func = sha256crypt_parse_hash;
9745 sort_by_digest = sort_by_digest_4_8;
9746 opti_type = OPTI_TYPE_ZERO_BYTE;
9747 dgst_pos0 = 0;
9748 dgst_pos1 = 1;
9749 dgst_pos2 = 2;
9750 dgst_pos3 = 3;
9751 break;
9752
9753 case 7500: hash_type = HASH_TYPE_KRB5PA;
9754 salt_type = SALT_TYPE_EMBEDDED;
9755 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9756 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9757 kern_type = KERN_TYPE_KRB5PA;
9758 dgst_size = DGST_SIZE_4_4;
9759 parse_func = krb5pa_parse_hash;
9760 sort_by_digest = sort_by_digest_4_4;
9761 opti_type = OPTI_TYPE_ZERO_BYTE
9762 | OPTI_TYPE_NOT_ITERATED;
9763 dgst_pos0 = 0;
9764 dgst_pos1 = 1;
9765 dgst_pos2 = 2;
9766 dgst_pos3 = 3;
9767 break;
9768
9769 case 7600: hash_type = HASH_TYPE_SHA1;
9770 salt_type = SALT_TYPE_INTERN;
9771 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9772 opts_type = OPTS_TYPE_PT_GENERATE_BE
9773 | OPTS_TYPE_PT_ADD80
9774 | OPTS_TYPE_PT_ADDBITS15;
9775 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9776 dgst_size = DGST_SIZE_4_5;
9777 parse_func = redmine_parse_hash;
9778 sort_by_digest = sort_by_digest_4_5;
9779 opti_type = OPTI_TYPE_ZERO_BYTE
9780 | OPTI_TYPE_PRECOMPUTE_INIT
9781 | OPTI_TYPE_EARLY_SKIP
9782 | OPTI_TYPE_NOT_ITERATED
9783 | OPTI_TYPE_PREPENDED_SALT;
9784 dgst_pos0 = 3;
9785 dgst_pos1 = 4;
9786 dgst_pos2 = 2;
9787 dgst_pos3 = 1;
9788 break;
9789
9790 case 7700: hash_type = HASH_TYPE_SAPB;
9791 salt_type = SALT_TYPE_EMBEDDED;
9792 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9793 opts_type = OPTS_TYPE_PT_GENERATE_LE
9794 | OPTS_TYPE_PT_UPPER
9795 | OPTS_TYPE_ST_UPPER;
9796 kern_type = KERN_TYPE_SAPB;
9797 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9798 parse_func = sapb_parse_hash;
9799 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9800 opti_type = OPTI_TYPE_ZERO_BYTE
9801 | OPTI_TYPE_PRECOMPUTE_INIT
9802 | OPTI_TYPE_NOT_ITERATED;
9803 dgst_pos0 = 0;
9804 dgst_pos1 = 1;
9805 dgst_pos2 = 2;
9806 dgst_pos3 = 3;
9807 break;
9808
9809 case 7800: hash_type = HASH_TYPE_SAPG;
9810 salt_type = SALT_TYPE_EMBEDDED;
9811 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9812 opts_type = OPTS_TYPE_PT_GENERATE_BE
9813 | OPTS_TYPE_ST_ADD80
9814 | OPTS_TYPE_ST_UPPER;
9815 kern_type = KERN_TYPE_SAPG;
9816 dgst_size = DGST_SIZE_4_5;
9817 parse_func = sapg_parse_hash;
9818 sort_by_digest = sort_by_digest_4_5;
9819 opti_type = OPTI_TYPE_ZERO_BYTE
9820 | OPTI_TYPE_PRECOMPUTE_INIT
9821 | OPTI_TYPE_NOT_ITERATED;
9822 dgst_pos0 = 3;
9823 dgst_pos1 = 4;
9824 dgst_pos2 = 2;
9825 dgst_pos3 = 1;
9826 break;
9827
9828 case 7900: hash_type = HASH_TYPE_SHA512;
9829 salt_type = SALT_TYPE_EMBEDDED;
9830 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9831 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9832 kern_type = KERN_TYPE_DRUPAL7;
9833 dgst_size = DGST_SIZE_8_8;
9834 parse_func = drupal7_parse_hash;
9835 sort_by_digest = sort_by_digest_8_8;
9836 opti_type = OPTI_TYPE_ZERO_BYTE
9837 | OPTI_TYPE_USES_BITS_64;
9838 dgst_pos0 = 0;
9839 dgst_pos1 = 1;
9840 dgst_pos2 = 2;
9841 dgst_pos3 = 3;
9842 break;
9843
9844 case 8000: hash_type = HASH_TYPE_SHA256;
9845 salt_type = SALT_TYPE_EMBEDDED;
9846 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9847 opts_type = OPTS_TYPE_PT_GENERATE_BE
9848 | OPTS_TYPE_PT_UNICODE
9849 | OPTS_TYPE_ST_ADD80
9850 | OPTS_TYPE_ST_HEX;
9851 kern_type = KERN_TYPE_SYBASEASE;
9852 dgst_size = DGST_SIZE_4_8;
9853 parse_func = sybasease_parse_hash;
9854 sort_by_digest = sort_by_digest_4_8;
9855 opti_type = OPTI_TYPE_ZERO_BYTE
9856 | OPTI_TYPE_PRECOMPUTE_INIT
9857 | OPTI_TYPE_EARLY_SKIP
9858 | OPTI_TYPE_NOT_ITERATED
9859 | OPTI_TYPE_RAW_HASH;
9860 dgst_pos0 = 3;
9861 dgst_pos1 = 7;
9862 dgst_pos2 = 2;
9863 dgst_pos3 = 6;
9864 break;
9865
9866 case 8100: hash_type = HASH_TYPE_SHA1;
9867 salt_type = SALT_TYPE_EMBEDDED;
9868 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9869 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9870 kern_type = KERN_TYPE_NETSCALER;
9871 dgst_size = DGST_SIZE_4_5;
9872 parse_func = netscaler_parse_hash;
9873 sort_by_digest = sort_by_digest_4_5;
9874 opti_type = OPTI_TYPE_ZERO_BYTE
9875 | OPTI_TYPE_PRECOMPUTE_INIT
9876 | OPTI_TYPE_PRECOMPUTE_MERKLE
9877 | OPTI_TYPE_EARLY_SKIP
9878 | OPTI_TYPE_NOT_ITERATED
9879 | OPTI_TYPE_PREPENDED_SALT
9880 | OPTI_TYPE_RAW_HASH;
9881 dgst_pos0 = 3;
9882 dgst_pos1 = 4;
9883 dgst_pos2 = 2;
9884 dgst_pos3 = 1;
9885 break;
9886
9887 case 8200: hash_type = HASH_TYPE_SHA256;
9888 salt_type = SALT_TYPE_EMBEDDED;
9889 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9890 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9891 kern_type = KERN_TYPE_CLOUDKEY;
9892 dgst_size = DGST_SIZE_4_8;
9893 parse_func = cloudkey_parse_hash;
9894 sort_by_digest = sort_by_digest_4_8;
9895 opti_type = OPTI_TYPE_ZERO_BYTE;
9896 dgst_pos0 = 0;
9897 dgst_pos1 = 1;
9898 dgst_pos2 = 2;
9899 dgst_pos3 = 3;
9900 break;
9901
9902 case 8300: hash_type = HASH_TYPE_SHA1;
9903 salt_type = SALT_TYPE_EMBEDDED;
9904 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9905 opts_type = OPTS_TYPE_PT_GENERATE_BE
9906 | OPTS_TYPE_ST_HEX
9907 | OPTS_TYPE_ST_ADD80;
9908 kern_type = KERN_TYPE_NSEC3;
9909 dgst_size = DGST_SIZE_4_5;
9910 parse_func = nsec3_parse_hash;
9911 sort_by_digest = sort_by_digest_4_5;
9912 opti_type = OPTI_TYPE_ZERO_BYTE;
9913 dgst_pos0 = 3;
9914 dgst_pos1 = 4;
9915 dgst_pos2 = 2;
9916 dgst_pos3 = 1;
9917 break;
9918
9919 case 8400: hash_type = HASH_TYPE_SHA1;
9920 salt_type = SALT_TYPE_INTERN;
9921 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9922 opts_type = OPTS_TYPE_PT_GENERATE_BE
9923 | OPTS_TYPE_PT_ADD80
9924 | OPTS_TYPE_PT_ADDBITS15;
9925 kern_type = KERN_TYPE_WBB3;
9926 dgst_size = DGST_SIZE_4_5;
9927 parse_func = wbb3_parse_hash;
9928 sort_by_digest = sort_by_digest_4_5;
9929 opti_type = OPTI_TYPE_ZERO_BYTE
9930 | OPTI_TYPE_PRECOMPUTE_INIT
9931 | OPTI_TYPE_NOT_ITERATED;
9932 dgst_pos0 = 3;
9933 dgst_pos1 = 4;
9934 dgst_pos2 = 2;
9935 dgst_pos3 = 1;
9936 break;
9937
9938 case 8500: hash_type = HASH_TYPE_DESRACF;
9939 salt_type = SALT_TYPE_EMBEDDED;
9940 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9941 opts_type = OPTS_TYPE_PT_GENERATE_LE
9942 | OPTS_TYPE_ST_UPPER;
9943 kern_type = KERN_TYPE_RACF;
9944 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9945 parse_func = racf_parse_hash;
9946 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9947 opti_type = OPTI_TYPE_ZERO_BYTE
9948 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9949 dgst_pos0 = 0;
9950 dgst_pos1 = 1;
9951 dgst_pos2 = 2;
9952 dgst_pos3 = 3;
9953 break;
9954
9955 case 8600: hash_type = HASH_TYPE_LOTUS5;
9956 salt_type = SALT_TYPE_NONE;
9957 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9958 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9959 kern_type = KERN_TYPE_LOTUS5;
9960 dgst_size = DGST_SIZE_4_4;
9961 parse_func = lotus5_parse_hash;
9962 sort_by_digest = sort_by_digest_4_4;
9963 opti_type = OPTI_TYPE_EARLY_SKIP
9964 | OPTI_TYPE_NOT_ITERATED
9965 | OPTI_TYPE_NOT_SALTED
9966 | OPTI_TYPE_RAW_HASH;
9967 dgst_pos0 = 0;
9968 dgst_pos1 = 1;
9969 dgst_pos2 = 2;
9970 dgst_pos3 = 3;
9971 break;
9972
9973 case 8700: hash_type = HASH_TYPE_LOTUS6;
9974 salt_type = SALT_TYPE_EMBEDDED;
9975 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9976 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9977 kern_type = KERN_TYPE_LOTUS6;
9978 dgst_size = DGST_SIZE_4_4;
9979 parse_func = lotus6_parse_hash;
9980 sort_by_digest = sort_by_digest_4_4;
9981 opti_type = OPTI_TYPE_EARLY_SKIP
9982 | OPTI_TYPE_NOT_ITERATED
9983 | OPTI_TYPE_RAW_HASH;
9984 dgst_pos0 = 0;
9985 dgst_pos1 = 1;
9986 dgst_pos2 = 2;
9987 dgst_pos3 = 3;
9988 break;
9989
9990 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
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_ANDROIDFDE;
9995 dgst_size = DGST_SIZE_4_4;
9996 parse_func = androidfde_parse_hash;
9997 sort_by_digest = sort_by_digest_4_4;
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 8900: hash_type = HASH_TYPE_SCRYPT;
10006 salt_type = SALT_TYPE_EMBEDDED;
10007 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10008 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10009 kern_type = KERN_TYPE_SCRYPT;
10010 dgst_size = DGST_SIZE_4_8;
10011 parse_func = scrypt_parse_hash;
10012 sort_by_digest = sort_by_digest_4_8;
10013 opti_type = OPTI_TYPE_ZERO_BYTE;
10014 dgst_pos0 = 0;
10015 dgst_pos1 = 1;
10016 dgst_pos2 = 2;
10017 dgst_pos3 = 3;
10018 break;
10019
10020 case 9000: hash_type = HASH_TYPE_SHA1;
10021 salt_type = SALT_TYPE_EMBEDDED;
10022 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10023 opts_type = OPTS_TYPE_PT_GENERATE_LE
10024 | OPTS_TYPE_ST_GENERATE_LE;
10025 kern_type = KERN_TYPE_PSAFE2;
10026 dgst_size = DGST_SIZE_4_5;
10027 parse_func = psafe2_parse_hash;
10028 sort_by_digest = sort_by_digest_4_5;
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 9100: hash_type = HASH_TYPE_LOTUS8;
10037 salt_type = SALT_TYPE_EMBEDDED;
10038 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10039 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10040 kern_type = KERN_TYPE_LOTUS8;
10041 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10042 parse_func = lotus8_parse_hash;
10043 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10044 opti_type = OPTI_TYPE_ZERO_BYTE;
10045 dgst_pos0 = 0;
10046 dgst_pos1 = 1;
10047 dgst_pos2 = 2;
10048 dgst_pos3 = 3;
10049 break;
10050
10051 case 9200: hash_type = HASH_TYPE_SHA256;
10052 salt_type = SALT_TYPE_EMBEDDED;
10053 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10054 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10055 kern_type = KERN_TYPE_PBKDF2_SHA256;
10056 dgst_size = DGST_SIZE_4_32;
10057 parse_func = cisco8_parse_hash;
10058 sort_by_digest = sort_by_digest_4_32;
10059 opti_type = OPTI_TYPE_ZERO_BYTE
10060 | OPTI_TYPE_SLOW_HASH_SIMD;
10061 dgst_pos0 = 0;
10062 dgst_pos1 = 1;
10063 dgst_pos2 = 2;
10064 dgst_pos3 = 3;
10065 break;
10066
10067 case 9300: hash_type = HASH_TYPE_SCRYPT;
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_SCRYPT;
10072 dgst_size = DGST_SIZE_4_8;
10073 parse_func = cisco9_parse_hash;
10074 sort_by_digest = sort_by_digest_4_8;
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 9400: hash_type = HASH_TYPE_OFFICE2007;
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_OFFICE2007;
10087 dgst_size = DGST_SIZE_4_4;
10088 parse_func = office2007_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 9500: hash_type = HASH_TYPE_OFFICE2010;
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_OFFICE2010;
10102 dgst_size = DGST_SIZE_4_4;
10103 parse_func = office2010_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 9600: hash_type = HASH_TYPE_OFFICE2013;
10113 salt_type = SALT_TYPE_EMBEDDED;
10114 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10115 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10116 kern_type = KERN_TYPE_OFFICE2013;
10117 dgst_size = DGST_SIZE_4_4;
10118 parse_func = office2013_parse_hash;
10119 sort_by_digest = sort_by_digest_4_4;
10120 opti_type = OPTI_TYPE_ZERO_BYTE;
10121 dgst_pos0 = 0;
10122 dgst_pos1 = 1;
10123 dgst_pos2 = 2;
10124 dgst_pos3 = 3;
10125 break;
10126
10127 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
10128 salt_type = SALT_TYPE_EMBEDDED;
10129 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10130 opts_type = OPTS_TYPE_PT_GENERATE_LE
10131 | OPTS_TYPE_PT_ADD80
10132 | OPTS_TYPE_PT_UNICODE;
10133 kern_type = KERN_TYPE_OLDOFFICE01;
10134 dgst_size = DGST_SIZE_4_4;
10135 parse_func = oldoffice01_parse_hash;
10136 sort_by_digest = sort_by_digest_4_4;
10137 opti_type = OPTI_TYPE_ZERO_BYTE
10138 | OPTI_TYPE_PRECOMPUTE_INIT
10139 | OPTI_TYPE_NOT_ITERATED;
10140 dgst_pos0 = 0;
10141 dgst_pos1 = 1;
10142 dgst_pos2 = 2;
10143 dgst_pos3 = 3;
10144 break;
10145
10146 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
10147 salt_type = SALT_TYPE_EMBEDDED;
10148 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10149 opts_type = OPTS_TYPE_PT_GENERATE_LE
10150 | OPTS_TYPE_PT_ADD80;
10151 kern_type = KERN_TYPE_OLDOFFICE01CM1;
10152 dgst_size = DGST_SIZE_4_4;
10153 parse_func = oldoffice01cm1_parse_hash;
10154 sort_by_digest = sort_by_digest_4_4;
10155 opti_type = OPTI_TYPE_ZERO_BYTE
10156 | OPTI_TYPE_PRECOMPUTE_INIT
10157 | OPTI_TYPE_NOT_ITERATED;
10158 dgst_pos0 = 0;
10159 dgst_pos1 = 1;
10160 dgst_pos2 = 2;
10161 dgst_pos3 = 3;
10162 break;
10163
10164 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
10165 salt_type = SALT_TYPE_EMBEDDED;
10166 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10167 opts_type = OPTS_TYPE_PT_GENERATE_LE
10168 | OPTS_TYPE_PT_ADD80
10169 | OPTS_TYPE_PT_UNICODE
10170 | OPTS_TYPE_PT_NEVERCRACK;
10171 kern_type = KERN_TYPE_OLDOFFICE01CM2;
10172 dgst_size = DGST_SIZE_4_4;
10173 parse_func = oldoffice01cm2_parse_hash;
10174 sort_by_digest = sort_by_digest_4_4;
10175 opti_type = OPTI_TYPE_ZERO_BYTE
10176 | OPTI_TYPE_PRECOMPUTE_INIT
10177 | OPTI_TYPE_NOT_ITERATED;
10178 dgst_pos0 = 0;
10179 dgst_pos1 = 1;
10180 dgst_pos2 = 2;
10181 dgst_pos3 = 3;
10182 break;
10183
10184 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
10185 salt_type = SALT_TYPE_EMBEDDED;
10186 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10187 opts_type = OPTS_TYPE_PT_GENERATE_BE
10188 | OPTS_TYPE_PT_ADD80
10189 | OPTS_TYPE_PT_UNICODE;
10190 kern_type = KERN_TYPE_OLDOFFICE34;
10191 dgst_size = DGST_SIZE_4_4;
10192 parse_func = oldoffice34_parse_hash;
10193 sort_by_digest = sort_by_digest_4_4;
10194 opti_type = OPTI_TYPE_ZERO_BYTE
10195 | OPTI_TYPE_PRECOMPUTE_INIT
10196 | OPTI_TYPE_NOT_ITERATED;
10197 dgst_pos0 = 0;
10198 dgst_pos1 = 1;
10199 dgst_pos2 = 2;
10200 dgst_pos3 = 3;
10201 break;
10202
10203 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10204 salt_type = SALT_TYPE_EMBEDDED;
10205 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10206 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10207 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10208 dgst_size = DGST_SIZE_4_4;
10209 parse_func = oldoffice34cm1_parse_hash;
10210 sort_by_digest = sort_by_digest_4_4;
10211 opti_type = OPTI_TYPE_ZERO_BYTE
10212 | OPTI_TYPE_PRECOMPUTE_INIT
10213 | OPTI_TYPE_NOT_ITERATED;
10214 dgst_pos0 = 0;
10215 dgst_pos1 = 1;
10216 dgst_pos2 = 2;
10217 dgst_pos3 = 3;
10218 break;
10219
10220 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10221 salt_type = SALT_TYPE_EMBEDDED;
10222 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10223 opts_type = OPTS_TYPE_PT_GENERATE_BE
10224 | OPTS_TYPE_PT_ADD80
10225 | OPTS_TYPE_PT_UNICODE
10226 | OPTS_TYPE_PT_NEVERCRACK;
10227 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10228 dgst_size = DGST_SIZE_4_4;
10229 parse_func = oldoffice34cm2_parse_hash;
10230 sort_by_digest = sort_by_digest_4_4;
10231 opti_type = OPTI_TYPE_ZERO_BYTE
10232 | OPTI_TYPE_PRECOMPUTE_INIT
10233 | OPTI_TYPE_NOT_ITERATED;
10234 dgst_pos0 = 0;
10235 dgst_pos1 = 1;
10236 dgst_pos2 = 2;
10237 dgst_pos3 = 3;
10238 break;
10239
10240 case 9900: hash_type = HASH_TYPE_MD5;
10241 salt_type = SALT_TYPE_NONE;
10242 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10243 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10244 kern_type = KERN_TYPE_RADMIN2;
10245 dgst_size = DGST_SIZE_4_4;
10246 parse_func = radmin2_parse_hash;
10247 sort_by_digest = sort_by_digest_4_4;
10248 opti_type = OPTI_TYPE_ZERO_BYTE
10249 | OPTI_TYPE_PRECOMPUTE_INIT
10250 | OPTI_TYPE_EARLY_SKIP
10251 | OPTI_TYPE_NOT_ITERATED
10252 | OPTI_TYPE_NOT_SALTED;
10253 dgst_pos0 = 0;
10254 dgst_pos1 = 3;
10255 dgst_pos2 = 2;
10256 dgst_pos3 = 1;
10257 break;
10258
10259 case 10000: hash_type = HASH_TYPE_SHA256;
10260 salt_type = SALT_TYPE_EMBEDDED;
10261 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10262 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10263 kern_type = KERN_TYPE_PBKDF2_SHA256;
10264 dgst_size = DGST_SIZE_4_32;
10265 parse_func = djangopbkdf2_parse_hash;
10266 sort_by_digest = sort_by_digest_4_32;
10267 opti_type = OPTI_TYPE_ZERO_BYTE
10268 | OPTI_TYPE_SLOW_HASH_SIMD;
10269 dgst_pos0 = 0;
10270 dgst_pos1 = 1;
10271 dgst_pos2 = 2;
10272 dgst_pos3 = 3;
10273 break;
10274
10275 case 10100: hash_type = HASH_TYPE_SIPHASH;
10276 salt_type = SALT_TYPE_EMBEDDED;
10277 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10278 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10279 kern_type = KERN_TYPE_SIPHASH;
10280 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10281 parse_func = siphash_parse_hash;
10282 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10283 opti_type = OPTI_TYPE_ZERO_BYTE
10284 | OPTI_TYPE_NOT_ITERATED
10285 | OPTI_TYPE_RAW_HASH;
10286 dgst_pos0 = 0;
10287 dgst_pos1 = 1;
10288 dgst_pos2 = 2;
10289 dgst_pos3 = 3;
10290 break;
10291
10292 case 10200: hash_type = HASH_TYPE_MD5;
10293 salt_type = SALT_TYPE_EMBEDDED;
10294 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10295 opts_type = OPTS_TYPE_PT_GENERATE_LE
10296 | OPTS_TYPE_ST_ADD80
10297 | OPTS_TYPE_ST_ADDBITS14;
10298 kern_type = KERN_TYPE_HMACMD5_PW;
10299 dgst_size = DGST_SIZE_4_4;
10300 parse_func = crammd5_parse_hash;
10301 sort_by_digest = sort_by_digest_4_4;
10302 opti_type = OPTI_TYPE_ZERO_BYTE
10303 | OPTI_TYPE_NOT_ITERATED;
10304 dgst_pos0 = 0;
10305 dgst_pos1 = 3;
10306 dgst_pos2 = 2;
10307 dgst_pos3 = 1;
10308 break;
10309
10310 case 10300: hash_type = HASH_TYPE_SHA1;
10311 salt_type = SALT_TYPE_EMBEDDED;
10312 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10313 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10314 kern_type = KERN_TYPE_SAPH_SHA1;
10315 dgst_size = DGST_SIZE_4_5;
10316 parse_func = saph_sha1_parse_hash;
10317 sort_by_digest = sort_by_digest_4_5;
10318 opti_type = OPTI_TYPE_ZERO_BYTE;
10319 dgst_pos0 = 0;
10320 dgst_pos1 = 1;
10321 dgst_pos2 = 2;
10322 dgst_pos3 = 3;
10323 break;
10324
10325 case 10400: hash_type = HASH_TYPE_PDFU16;
10326 salt_type = SALT_TYPE_EMBEDDED;
10327 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10328 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10329 kern_type = KERN_TYPE_PDF11;
10330 dgst_size = DGST_SIZE_4_4;
10331 parse_func = pdf11_parse_hash;
10332 sort_by_digest = sort_by_digest_4_4;
10333 opti_type = OPTI_TYPE_ZERO_BYTE
10334 | OPTI_TYPE_NOT_ITERATED;
10335 dgst_pos0 = 0;
10336 dgst_pos1 = 1;
10337 dgst_pos2 = 2;
10338 dgst_pos3 = 3;
10339 break;
10340
10341 case 10410: hash_type = HASH_TYPE_PDFU16;
10342 salt_type = SALT_TYPE_EMBEDDED;
10343 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10344 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10345 kern_type = KERN_TYPE_PDF11CM1;
10346 dgst_size = DGST_SIZE_4_4;
10347 parse_func = pdf11cm1_parse_hash;
10348 sort_by_digest = sort_by_digest_4_4;
10349 opti_type = OPTI_TYPE_ZERO_BYTE
10350 | OPTI_TYPE_NOT_ITERATED;
10351 dgst_pos0 = 0;
10352 dgst_pos1 = 1;
10353 dgst_pos2 = 2;
10354 dgst_pos3 = 3;
10355 break;
10356
10357 case 10420: hash_type = HASH_TYPE_PDFU16;
10358 salt_type = SALT_TYPE_EMBEDDED;
10359 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10360 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10361 kern_type = KERN_TYPE_PDF11CM2;
10362 dgst_size = DGST_SIZE_4_4;
10363 parse_func = pdf11cm2_parse_hash;
10364 sort_by_digest = sort_by_digest_4_4;
10365 opti_type = OPTI_TYPE_ZERO_BYTE
10366 | OPTI_TYPE_NOT_ITERATED;
10367 dgst_pos0 = 0;
10368 dgst_pos1 = 1;
10369 dgst_pos2 = 2;
10370 dgst_pos3 = 3;
10371 break;
10372
10373 case 10500: hash_type = HASH_TYPE_PDFU16;
10374 salt_type = SALT_TYPE_EMBEDDED;
10375 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10376 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10377 kern_type = KERN_TYPE_PDF14;
10378 dgst_size = DGST_SIZE_4_4;
10379 parse_func = pdf14_parse_hash;
10380 sort_by_digest = sort_by_digest_4_4;
10381 opti_type = OPTI_TYPE_ZERO_BYTE
10382 | OPTI_TYPE_NOT_ITERATED;
10383 dgst_pos0 = 0;
10384 dgst_pos1 = 1;
10385 dgst_pos2 = 2;
10386 dgst_pos3 = 3;
10387 break;
10388
10389 case 10600: hash_type = HASH_TYPE_SHA256;
10390 salt_type = SALT_TYPE_EMBEDDED;
10391 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10392 opts_type = OPTS_TYPE_PT_GENERATE_BE
10393 | OPTS_TYPE_ST_ADD80
10394 | OPTS_TYPE_ST_ADDBITS15
10395 | OPTS_TYPE_HASH_COPY;
10396 kern_type = KERN_TYPE_SHA256_PWSLT;
10397 dgst_size = DGST_SIZE_4_8;
10398 parse_func = pdf17l3_parse_hash;
10399 sort_by_digest = sort_by_digest_4_8;
10400 opti_type = OPTI_TYPE_ZERO_BYTE
10401 | OPTI_TYPE_PRECOMPUTE_INIT
10402 | OPTI_TYPE_PRECOMPUTE_MERKLE
10403 | OPTI_TYPE_EARLY_SKIP
10404 | OPTI_TYPE_NOT_ITERATED
10405 | OPTI_TYPE_APPENDED_SALT
10406 | OPTI_TYPE_RAW_HASH;
10407 dgst_pos0 = 3;
10408 dgst_pos1 = 7;
10409 dgst_pos2 = 2;
10410 dgst_pos3 = 6;
10411 break;
10412
10413 case 10700: hash_type = HASH_TYPE_PDFU32;
10414 salt_type = SALT_TYPE_EMBEDDED;
10415 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10416 opts_type = OPTS_TYPE_PT_GENERATE_LE
10417 | OPTS_TYPE_HASH_COPY;
10418 kern_type = KERN_TYPE_PDF17L8;
10419 dgst_size = DGST_SIZE_4_8;
10420 parse_func = pdf17l8_parse_hash;
10421 sort_by_digest = sort_by_digest_4_8;
10422 opti_type = OPTI_TYPE_ZERO_BYTE
10423 | OPTI_TYPE_NOT_ITERATED;
10424 dgst_pos0 = 0;
10425 dgst_pos1 = 1;
10426 dgst_pos2 = 2;
10427 dgst_pos3 = 3;
10428 break;
10429
10430 case 10800: hash_type = HASH_TYPE_SHA384;
10431 salt_type = SALT_TYPE_NONE;
10432 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10433 opts_type = OPTS_TYPE_PT_GENERATE_BE
10434 | OPTS_TYPE_PT_ADD80
10435 | OPTS_TYPE_PT_ADDBITS15;
10436 kern_type = KERN_TYPE_SHA384;
10437 dgst_size = DGST_SIZE_8_8;
10438 parse_func = sha384_parse_hash;
10439 sort_by_digest = sort_by_digest_8_8;
10440 opti_type = OPTI_TYPE_ZERO_BYTE
10441 | OPTI_TYPE_PRECOMPUTE_INIT
10442 | OPTI_TYPE_PRECOMPUTE_MERKLE
10443 | OPTI_TYPE_EARLY_SKIP
10444 | OPTI_TYPE_NOT_ITERATED
10445 | OPTI_TYPE_NOT_SALTED
10446 | OPTI_TYPE_USES_BITS_64
10447 | OPTI_TYPE_RAW_HASH;
10448 dgst_pos0 = 6;
10449 dgst_pos1 = 7;
10450 dgst_pos2 = 4;
10451 dgst_pos3 = 5;
10452 break;
10453
10454 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10455 salt_type = SALT_TYPE_EMBEDDED;
10456 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10457 opts_type = OPTS_TYPE_PT_GENERATE_LE
10458 | OPTS_TYPE_ST_BASE64
10459 | OPTS_TYPE_HASH_COPY;
10460 kern_type = KERN_TYPE_PBKDF2_SHA256;
10461 dgst_size = DGST_SIZE_4_32;
10462 parse_func = pbkdf2_sha256_parse_hash;
10463 sort_by_digest = sort_by_digest_4_32;
10464 opti_type = OPTI_TYPE_ZERO_BYTE
10465 | OPTI_TYPE_SLOW_HASH_SIMD;
10466 dgst_pos0 = 0;
10467 dgst_pos1 = 1;
10468 dgst_pos2 = 2;
10469 dgst_pos3 = 3;
10470 break;
10471
10472 case 11000: hash_type = HASH_TYPE_MD5;
10473 salt_type = SALT_TYPE_INTERN;
10474 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10475 opts_type = OPTS_TYPE_PT_GENERATE_LE
10476 | OPTS_TYPE_PT_ADD80;
10477 kern_type = KERN_TYPE_PRESTASHOP;
10478 dgst_size = DGST_SIZE_4_4;
10479 parse_func = prestashop_parse_hash;
10480 sort_by_digest = sort_by_digest_4_4;
10481 opti_type = OPTI_TYPE_ZERO_BYTE
10482 | OPTI_TYPE_PRECOMPUTE_INIT
10483 | OPTI_TYPE_NOT_ITERATED
10484 | OPTI_TYPE_PREPENDED_SALT;
10485 dgst_pos0 = 0;
10486 dgst_pos1 = 3;
10487 dgst_pos2 = 2;
10488 dgst_pos3 = 1;
10489 break;
10490
10491 case 11100: hash_type = HASH_TYPE_MD5;
10492 salt_type = SALT_TYPE_EMBEDDED;
10493 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10494 opts_type = OPTS_TYPE_PT_GENERATE_LE
10495 | OPTS_TYPE_ST_ADD80;
10496 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10497 dgst_size = DGST_SIZE_4_4;
10498 parse_func = postgresql_auth_parse_hash;
10499 sort_by_digest = sort_by_digest_4_4;
10500 opti_type = OPTI_TYPE_ZERO_BYTE
10501 | OPTI_TYPE_PRECOMPUTE_INIT
10502 | OPTI_TYPE_PRECOMPUTE_MERKLE
10503 | OPTI_TYPE_EARLY_SKIP;
10504 dgst_pos0 = 0;
10505 dgst_pos1 = 3;
10506 dgst_pos2 = 2;
10507 dgst_pos3 = 1;
10508 break;
10509
10510 case 11200: hash_type = HASH_TYPE_SHA1;
10511 salt_type = SALT_TYPE_EMBEDDED;
10512 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10513 opts_type = OPTS_TYPE_PT_GENERATE_BE
10514 | OPTS_TYPE_PT_ADD80
10515 | OPTS_TYPE_ST_HEX;
10516 kern_type = KERN_TYPE_MYSQL_AUTH;
10517 dgst_size = DGST_SIZE_4_5;
10518 parse_func = mysql_auth_parse_hash;
10519 sort_by_digest = sort_by_digest_4_5;
10520 opti_type = OPTI_TYPE_ZERO_BYTE
10521 | OPTI_TYPE_EARLY_SKIP;
10522 dgst_pos0 = 3;
10523 dgst_pos1 = 4;
10524 dgst_pos2 = 2;
10525 dgst_pos3 = 1;
10526 break;
10527
10528 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10529 salt_type = SALT_TYPE_EMBEDDED;
10530 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10531 opts_type = OPTS_TYPE_PT_GENERATE_LE
10532 | OPTS_TYPE_ST_HEX
10533 | OPTS_TYPE_ST_ADD80;
10534 kern_type = KERN_TYPE_BITCOIN_WALLET;
10535 dgst_size = DGST_SIZE_4_4;
10536 parse_func = bitcoin_wallet_parse_hash;
10537 sort_by_digest = sort_by_digest_4_4;
10538 opti_type = OPTI_TYPE_ZERO_BYTE;
10539 dgst_pos0 = 0;
10540 dgst_pos1 = 1;
10541 dgst_pos2 = 2;
10542 dgst_pos3 = 3;
10543 break;
10544
10545 case 11400: hash_type = HASH_TYPE_MD5;
10546 salt_type = SALT_TYPE_EMBEDDED;
10547 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10548 opts_type = OPTS_TYPE_PT_GENERATE_LE
10549 | OPTS_TYPE_PT_ADD80
10550 | OPTS_TYPE_HASH_COPY;
10551 kern_type = KERN_TYPE_SIP_AUTH;
10552 dgst_size = DGST_SIZE_4_4;
10553 parse_func = sip_auth_parse_hash;
10554 sort_by_digest = sort_by_digest_4_4;
10555 opti_type = OPTI_TYPE_ZERO_BYTE;
10556 dgst_pos0 = 0;
10557 dgst_pos1 = 3;
10558 dgst_pos2 = 2;
10559 dgst_pos3 = 1;
10560 break;
10561
10562 case 11500: hash_type = HASH_TYPE_CRC32;
10563 salt_type = SALT_TYPE_INTERN;
10564 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10565 opts_type = OPTS_TYPE_PT_GENERATE_LE
10566 | OPTS_TYPE_ST_GENERATE_LE
10567 | OPTS_TYPE_ST_HEX;
10568 kern_type = KERN_TYPE_CRC32;
10569 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10570 parse_func = crc32_parse_hash;
10571 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10572 opti_type = OPTI_TYPE_ZERO_BYTE;
10573 dgst_pos0 = 0;
10574 dgst_pos1 = 1;
10575 dgst_pos2 = 2;
10576 dgst_pos3 = 3;
10577 break;
10578
10579 case 11600: hash_type = HASH_TYPE_AES;
10580 salt_type = SALT_TYPE_EMBEDDED;
10581 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10582 opts_type = OPTS_TYPE_PT_GENERATE_LE
10583 | OPTS_TYPE_PT_NEVERCRACK;
10584 kern_type = KERN_TYPE_SEVEN_ZIP;
10585 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10586 parse_func = seven_zip_parse_hash;
10587 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10588 opti_type = OPTI_TYPE_ZERO_BYTE;
10589 dgst_pos0 = 0;
10590 dgst_pos1 = 1;
10591 dgst_pos2 = 2;
10592 dgst_pos3 = 3;
10593 break;
10594
10595 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10596 salt_type = SALT_TYPE_NONE;
10597 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10598 opts_type = OPTS_TYPE_PT_GENERATE_LE
10599 | OPTS_TYPE_PT_ADD01;
10600 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10601 dgst_size = DGST_SIZE_4_8;
10602 parse_func = gost2012sbog_256_parse_hash;
10603 sort_by_digest = sort_by_digest_4_8;
10604 opti_type = OPTI_TYPE_ZERO_BYTE;
10605 dgst_pos0 = 0;
10606 dgst_pos1 = 1;
10607 dgst_pos2 = 2;
10608 dgst_pos3 = 3;
10609 break;
10610
10611 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10612 salt_type = SALT_TYPE_NONE;
10613 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10614 opts_type = OPTS_TYPE_PT_GENERATE_LE
10615 | OPTS_TYPE_PT_ADD01;
10616 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10617 dgst_size = DGST_SIZE_4_16;
10618 parse_func = gost2012sbog_512_parse_hash;
10619 sort_by_digest = sort_by_digest_4_16;
10620 opti_type = OPTI_TYPE_ZERO_BYTE;
10621 dgst_pos0 = 0;
10622 dgst_pos1 = 1;
10623 dgst_pos2 = 2;
10624 dgst_pos3 = 3;
10625 break;
10626
10627 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10628 salt_type = SALT_TYPE_EMBEDDED;
10629 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10630 opts_type = OPTS_TYPE_PT_GENERATE_LE
10631 | OPTS_TYPE_ST_BASE64
10632 | OPTS_TYPE_HASH_COPY;
10633 kern_type = KERN_TYPE_PBKDF2_MD5;
10634 dgst_size = DGST_SIZE_4_32;
10635 parse_func = pbkdf2_md5_parse_hash;
10636 sort_by_digest = sort_by_digest_4_32;
10637 opti_type = OPTI_TYPE_ZERO_BYTE
10638 | OPTI_TYPE_SLOW_HASH_SIMD;
10639 dgst_pos0 = 0;
10640 dgst_pos1 = 1;
10641 dgst_pos2 = 2;
10642 dgst_pos3 = 3;
10643 break;
10644
10645 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10646 salt_type = SALT_TYPE_EMBEDDED;
10647 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10648 opts_type = OPTS_TYPE_PT_GENERATE_LE
10649 | OPTS_TYPE_ST_BASE64
10650 | OPTS_TYPE_HASH_COPY;
10651 kern_type = KERN_TYPE_PBKDF2_SHA1;
10652 dgst_size = DGST_SIZE_4_32;
10653 parse_func = pbkdf2_sha1_parse_hash;
10654 sort_by_digest = sort_by_digest_4_32;
10655 opti_type = OPTI_TYPE_ZERO_BYTE
10656 | OPTI_TYPE_SLOW_HASH_SIMD;
10657 dgst_pos0 = 0;
10658 dgst_pos1 = 1;
10659 dgst_pos2 = 2;
10660 dgst_pos3 = 3;
10661 break;
10662
10663 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10664 salt_type = SALT_TYPE_EMBEDDED;
10665 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10666 opts_type = OPTS_TYPE_PT_GENERATE_LE
10667 | OPTS_TYPE_ST_BASE64
10668 | OPTS_TYPE_HASH_COPY;
10669 kern_type = KERN_TYPE_PBKDF2_SHA512;
10670 dgst_size = DGST_SIZE_8_16;
10671 parse_func = pbkdf2_sha512_parse_hash;
10672 sort_by_digest = sort_by_digest_8_16;
10673 opti_type = OPTI_TYPE_ZERO_BYTE
10674 | OPTI_TYPE_USES_BITS_64
10675 | OPTI_TYPE_SLOW_HASH_SIMD;
10676 dgst_pos0 = 0;
10677 dgst_pos1 = 1;
10678 dgst_pos2 = 2;
10679 dgst_pos3 = 3;
10680 break;
10681
10682 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10683 salt_type = SALT_TYPE_EMBEDDED;
10684 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10685 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10686 kern_type = KERN_TYPE_ECRYPTFS;
10687 dgst_size = DGST_SIZE_8_8;
10688 parse_func = ecryptfs_parse_hash;
10689 sort_by_digest = sort_by_digest_8_8;
10690 opti_type = OPTI_TYPE_ZERO_BYTE
10691 | OPTI_TYPE_USES_BITS_64;
10692 dgst_pos0 = 0;
10693 dgst_pos1 = 1;
10694 dgst_pos2 = 2;
10695 dgst_pos3 = 3;
10696 break;
10697
10698 case 12300: hash_type = HASH_TYPE_ORACLET;
10699 salt_type = SALT_TYPE_EMBEDDED;
10700 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10701 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10702 kern_type = KERN_TYPE_ORACLET;
10703 dgst_size = DGST_SIZE_8_16;
10704 parse_func = oraclet_parse_hash;
10705 sort_by_digest = sort_by_digest_8_16;
10706 opti_type = OPTI_TYPE_ZERO_BYTE
10707 | OPTI_TYPE_USES_BITS_64;
10708 dgst_pos0 = 0;
10709 dgst_pos1 = 1;
10710 dgst_pos2 = 2;
10711 dgst_pos3 = 3;
10712 break;
10713
10714 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10715 salt_type = SALT_TYPE_EMBEDDED;
10716 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10717 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10718 kern_type = KERN_TYPE_BSDICRYPT;
10719 dgst_size = DGST_SIZE_4_4;
10720 parse_func = bsdicrypt_parse_hash;
10721 sort_by_digest = sort_by_digest_4_4;
10722 opti_type = OPTI_TYPE_ZERO_BYTE
10723 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10724 dgst_pos0 = 0;
10725 dgst_pos1 = 1;
10726 dgst_pos2 = 2;
10727 dgst_pos3 = 3;
10728 break;
10729
10730 case 12500: hash_type = HASH_TYPE_RAR3HP;
10731 salt_type = SALT_TYPE_EMBEDDED;
10732 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10733 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10734 kern_type = KERN_TYPE_RAR3;
10735 dgst_size = DGST_SIZE_4_4;
10736 parse_func = rar3hp_parse_hash;
10737 sort_by_digest = sort_by_digest_4_4;
10738 opti_type = OPTI_TYPE_ZERO_BYTE;
10739 dgst_pos0 = 0;
10740 dgst_pos1 = 1;
10741 dgst_pos2 = 2;
10742 dgst_pos3 = 3;
10743 break;
10744
10745 case 12600: hash_type = HASH_TYPE_SHA256;
10746 salt_type = SALT_TYPE_INTERN;
10747 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10748 opts_type = OPTS_TYPE_PT_GENERATE_BE
10749 | OPTS_TYPE_PT_ADD80;
10750 kern_type = KERN_TYPE_CF10;
10751 dgst_size = DGST_SIZE_4_8;
10752 parse_func = cf10_parse_hash;
10753 sort_by_digest = sort_by_digest_4_8;
10754 opti_type = OPTI_TYPE_ZERO_BYTE
10755 | OPTI_TYPE_PRECOMPUTE_INIT
10756 | OPTI_TYPE_EARLY_SKIP
10757 | OPTI_TYPE_NOT_ITERATED;
10758 dgst_pos0 = 3;
10759 dgst_pos1 = 7;
10760 dgst_pos2 = 2;
10761 dgst_pos3 = 6;
10762 break;
10763
10764 case 12700: hash_type = HASH_TYPE_AES;
10765 salt_type = SALT_TYPE_EMBEDDED;
10766 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10767 opts_type = OPTS_TYPE_PT_GENERATE_LE
10768 | OPTS_TYPE_HASH_COPY;
10769 kern_type = KERN_TYPE_MYWALLET;
10770 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10771 parse_func = mywallet_parse_hash;
10772 sort_by_digest = sort_by_digest_4_5;
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 12800: 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_MS_DRSR;
10785 dgst_size = DGST_SIZE_4_8;
10786 parse_func = ms_drsr_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 12900: 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_ANDROIDFDE_SAMSUNG;
10800 dgst_size = DGST_SIZE_4_8;
10801 parse_func = androidfde_samsung_parse_hash;
10802 sort_by_digest = sort_by_digest_4_8;
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 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10811 salt_type = SALT_TYPE_EMBEDDED;
10812 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10813 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10814 kern_type = KERN_TYPE_RAR5;
10815 dgst_size = DGST_SIZE_4_4;
10816 parse_func = rar5_parse_hash;
10817 sort_by_digest = sort_by_digest_4_4;
10818 opti_type = OPTI_TYPE_ZERO_BYTE;
10819 dgst_pos0 = 0;
10820 dgst_pos1 = 1;
10821 dgst_pos2 = 2;
10822 dgst_pos3 = 3;
10823 break;
10824
10825 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10826 salt_type = SALT_TYPE_EMBEDDED;
10827 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10828 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10829 kern_type = KERN_TYPE_KRB5TGS;
10830 dgst_size = DGST_SIZE_4_4;
10831 parse_func = krb5tgs_parse_hash;
10832 sort_by_digest = sort_by_digest_4_4;
10833 opti_type = OPTI_TYPE_ZERO_BYTE
10834 | OPTI_TYPE_NOT_ITERATED;
10835 dgst_pos0 = 0;
10836 dgst_pos1 = 1;
10837 dgst_pos2 = 2;
10838 dgst_pos3 = 3;
10839 break;
10840
10841 case 13200: hash_type = HASH_TYPE_AES;
10842 salt_type = SALT_TYPE_EMBEDDED;
10843 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10844 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10845 kern_type = KERN_TYPE_AXCRYPT;
10846 dgst_size = DGST_SIZE_4_4;
10847 parse_func = axcrypt_parse_hash;
10848 sort_by_digest = sort_by_digest_4_4;
10849 opti_type = OPTI_TYPE_ZERO_BYTE;
10850 dgst_pos0 = 0;
10851 dgst_pos1 = 1;
10852 dgst_pos2 = 2;
10853 dgst_pos3 = 3;
10854 break;
10855
10856 case 13300: hash_type = HASH_TYPE_SHA1;
10857 salt_type = SALT_TYPE_NONE;
10858 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10859 opts_type = OPTS_TYPE_PT_GENERATE_BE
10860 | OPTS_TYPE_PT_ADD80
10861 | OPTS_TYPE_PT_ADDBITS15;
10862 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10863 dgst_size = DGST_SIZE_4_5;
10864 parse_func = sha1axcrypt_parse_hash;
10865 sort_by_digest = sort_by_digest_4_5;
10866 opti_type = OPTI_TYPE_ZERO_BYTE
10867 | OPTI_TYPE_PRECOMPUTE_INIT
10868 | OPTI_TYPE_EARLY_SKIP
10869 | OPTI_TYPE_NOT_ITERATED
10870 | OPTI_TYPE_NOT_SALTED;
10871 dgst_pos0 = 0;
10872 dgst_pos1 = 4;
10873 dgst_pos2 = 3;
10874 dgst_pos3 = 2;
10875 break;
10876
10877 case 13400: hash_type = HASH_TYPE_AES;
10878 salt_type = SALT_TYPE_EMBEDDED;
10879 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10880 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10881 kern_type = KERN_TYPE_KEEPASS;
10882 dgst_size = DGST_SIZE_4_4;
10883 parse_func = keepass_parse_hash;
10884 sort_by_digest = sort_by_digest_4_4;
10885 opti_type = OPTI_TYPE_ZERO_BYTE;
10886 dgst_pos0 = 0;
10887 dgst_pos1 = 1;
10888 dgst_pos2 = 2;
10889 dgst_pos3 = 3;
10890 break;
10891
10892 case 13500: hash_type = HASH_TYPE_SHA1;
10893 salt_type = SALT_TYPE_EMBEDDED;
10894 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10895 opts_type = OPTS_TYPE_PT_GENERATE_BE
10896 | OPTS_TYPE_PT_UNICODE
10897 | OPTS_TYPE_PT_ADD80;
10898 kern_type = KERN_TYPE_PSTOKEN;
10899 dgst_size = DGST_SIZE_4_5;
10900 parse_func = pstoken_parse_hash;
10901 sort_by_digest = sort_by_digest_4_5;
10902 opti_type = OPTI_TYPE_ZERO_BYTE
10903 | OPTI_TYPE_PRECOMPUTE_INIT
10904 | OPTI_TYPE_EARLY_SKIP
10905 | OPTI_TYPE_NOT_ITERATED
10906 | OPTI_TYPE_PREPENDED_SALT
10907 | OPTI_TYPE_RAW_HASH;
10908 dgst_pos0 = 3;
10909 dgst_pos1 = 4;
10910 dgst_pos2 = 2;
10911 dgst_pos3 = 1;
10912 break;
10913
10914 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
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_ZIP2;
10919 dgst_size = DGST_SIZE_4_4;
10920 parse_func = zip2_parse_hash;
10921 sort_by_digest = sort_by_digest_4_4;
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 13711: 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_XTS512;
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 13712: 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_XTS1024;
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 13713: hash_type = HASH_TYPE_RIPEMD160;
10960 salt_type = SALT_TYPE_EMBEDDED;
10961 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10962 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10963 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10964 dgst_size = DGST_SIZE_4_5;
10965 parse_func = veracrypt_parse_hash_655331;
10966 sort_by_digest = sort_by_digest_4_5;
10967 opti_type = OPTI_TYPE_ZERO_BYTE;
10968 dgst_pos0 = 0;
10969 dgst_pos1 = 1;
10970 dgst_pos2 = 2;
10971 dgst_pos3 = 3;
10972 break;
10973
10974 case 13721: hash_type = HASH_TYPE_SHA512;
10975 salt_type = SALT_TYPE_EMBEDDED;
10976 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10977 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10978 kern_type = KERN_TYPE_TCSHA512_XTS512;
10979 dgst_size = DGST_SIZE_8_8;
10980 parse_func = veracrypt_parse_hash_500000;
10981 sort_by_digest = sort_by_digest_8_8;
10982 opti_type = OPTI_TYPE_ZERO_BYTE
10983 | OPTI_TYPE_USES_BITS_64;
10984 dgst_pos0 = 0;
10985 dgst_pos1 = 1;
10986 dgst_pos2 = 2;
10987 dgst_pos3 = 3;
10988 break;
10989
10990 case 13722: hash_type = HASH_TYPE_SHA512;
10991 salt_type = SALT_TYPE_EMBEDDED;
10992 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10993 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10994 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10995 dgst_size = DGST_SIZE_8_8;
10996 parse_func = veracrypt_parse_hash_500000;
10997 sort_by_digest = sort_by_digest_8_8;
10998 opti_type = OPTI_TYPE_ZERO_BYTE
10999 | OPTI_TYPE_USES_BITS_64;
11000 dgst_pos0 = 0;
11001 dgst_pos1 = 1;
11002 dgst_pos2 = 2;
11003 dgst_pos3 = 3;
11004 break;
11005
11006 case 13723: hash_type = HASH_TYPE_SHA512;
11007 salt_type = SALT_TYPE_EMBEDDED;
11008 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11009 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11010 kern_type = KERN_TYPE_TCSHA512_XTS1536;
11011 dgst_size = DGST_SIZE_8_8;
11012 parse_func = veracrypt_parse_hash_500000;
11013 sort_by_digest = sort_by_digest_8_8;
11014 opti_type = OPTI_TYPE_ZERO_BYTE
11015 | OPTI_TYPE_USES_BITS_64;
11016 dgst_pos0 = 0;
11017 dgst_pos1 = 1;
11018 dgst_pos2 = 2;
11019 dgst_pos3 = 3;
11020 break;
11021
11022 case 13731: 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_XTS512;
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 13732: 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_XTS1024;
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 13733: hash_type = HASH_TYPE_WHIRLPOOL;
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_TCWHIRLPOOL_XTS1536;
11057 dgst_size = DGST_SIZE_4_8;
11058 parse_func = veracrypt_parse_hash_500000;
11059 sort_by_digest = sort_by_digest_4_8;
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 13741: 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_XTS512;
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 13742: 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_XTS1024;
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 13743: hash_type = HASH_TYPE_RIPEMD160;
11098 salt_type = SALT_TYPE_EMBEDDED;
11099 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11100 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11101 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11102 dgst_size = DGST_SIZE_4_5;
11103 parse_func = veracrypt_parse_hash_327661;
11104 sort_by_digest = sort_by_digest_4_5;
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 13751: 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_XTS512;
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 13752: 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_XTS1024;
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 13753: 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_XTS1536;
11147 dgst_size = DGST_SIZE_4_8;
11148 parse_func = veracrypt_parse_hash_500000;
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 13761: 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_XTS512;
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 13762: 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_XTS1024;
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 13763: hash_type = HASH_TYPE_SHA256;
11188 salt_type = SALT_TYPE_EMBEDDED;
11189 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11190 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11191 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11192 dgst_size = DGST_SIZE_4_8;
11193 parse_func = veracrypt_parse_hash_200000;
11194 sort_by_digest = sort_by_digest_4_8;
11195 opti_type = OPTI_TYPE_ZERO_BYTE;
11196 dgst_pos0 = 0;
11197 dgst_pos1 = 1;
11198 dgst_pos2 = 2;
11199 dgst_pos3 = 3;
11200 break;
11201
11202 case 13800: hash_type = HASH_TYPE_SHA256;
11203 salt_type = SALT_TYPE_EMBEDDED;
11204 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11205 opts_type = OPTS_TYPE_PT_GENERATE_BE
11206 | OPTS_TYPE_PT_UNICODE;
11207 kern_type = KERN_TYPE_WIN8PHONE;
11208 dgst_size = DGST_SIZE_4_8;
11209 parse_func = win8phone_parse_hash;
11210 sort_by_digest = sort_by_digest_4_8;
11211 opti_type = OPTI_TYPE_ZERO_BYTE
11212 | OPTI_TYPE_PRECOMPUTE_INIT
11213 | OPTI_TYPE_EARLY_SKIP
11214 | OPTI_TYPE_NOT_ITERATED
11215 | OPTI_TYPE_RAW_HASH;
11216 dgst_pos0 = 3;
11217 dgst_pos1 = 7;
11218 dgst_pos2 = 2;
11219 dgst_pos3 = 6;
11220 break;
11221
11222 default: usage_mini_print (PROGNAME); return (-1);
11223 }
11224
11225 /**
11226 * parser
11227 */
11228
11229 data.parse_func = parse_func;
11230
11231 /**
11232 * misc stuff
11233 */
11234
11235 if (hex_salt)
11236 {
11237 if (salt_type == SALT_TYPE_INTERN)
11238 {
11239 opts_type |= OPTS_TYPE_ST_HEX;
11240 }
11241 else
11242 {
11243 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11244
11245 return (-1);
11246 }
11247 }
11248
11249 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11250 | (salt_type == SALT_TYPE_EXTERN)
11251 | (salt_type == SALT_TYPE_EMBEDDED)
11252 | (salt_type == SALT_TYPE_VIRTUAL));
11253
11254 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
11255
11256 data.hash_type = hash_type;
11257 data.attack_mode = attack_mode;
11258 data.attack_kern = attack_kern;
11259 data.attack_exec = attack_exec;
11260 data.kern_type = kern_type;
11261 data.opts_type = opts_type;
11262 data.dgst_size = dgst_size;
11263 data.salt_type = salt_type;
11264 data.isSalted = isSalted;
11265 data.sort_by_digest = sort_by_digest;
11266 data.dgst_pos0 = dgst_pos0;
11267 data.dgst_pos1 = dgst_pos1;
11268 data.dgst_pos2 = dgst_pos2;
11269 data.dgst_pos3 = dgst_pos3;
11270
11271 esalt_size = 0;
11272
11273 switch (hash_mode)
11274 {
11275 case 2500: esalt_size = sizeof (wpa_t); break;
11276 case 5300: esalt_size = sizeof (ikepsk_t); break;
11277 case 5400: esalt_size = sizeof (ikepsk_t); break;
11278 case 5500: esalt_size = sizeof (netntlm_t); break;
11279 case 5600: esalt_size = sizeof (netntlm_t); break;
11280 case 6211: esalt_size = sizeof (tc_t); break;
11281 case 6212: esalt_size = sizeof (tc_t); break;
11282 case 6213: esalt_size = sizeof (tc_t); break;
11283 case 6221: esalt_size = sizeof (tc_t); break;
11284 case 6222: esalt_size = sizeof (tc_t); break;
11285 case 6223: esalt_size = sizeof (tc_t); break;
11286 case 6231: esalt_size = sizeof (tc_t); break;
11287 case 6232: esalt_size = sizeof (tc_t); break;
11288 case 6233: esalt_size = sizeof (tc_t); break;
11289 case 6241: esalt_size = sizeof (tc_t); break;
11290 case 6242: esalt_size = sizeof (tc_t); break;
11291 case 6243: esalt_size = sizeof (tc_t); break;
11292 case 6600: esalt_size = sizeof (agilekey_t); break;
11293 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11294 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
11295 case 7300: esalt_size = sizeof (rakp_t); break;
11296 case 7500: esalt_size = sizeof (krb5pa_t); break;
11297 case 8200: esalt_size = sizeof (cloudkey_t); break;
11298 case 8800: esalt_size = sizeof (androidfde_t); break;
11299 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
11300 case 9400: esalt_size = sizeof (office2007_t); break;
11301 case 9500: esalt_size = sizeof (office2010_t); break;
11302 case 9600: esalt_size = sizeof (office2013_t); break;
11303 case 9700: esalt_size = sizeof (oldoffice01_t); break;
11304 case 9710: esalt_size = sizeof (oldoffice01_t); break;
11305 case 9720: esalt_size = sizeof (oldoffice01_t); break;
11306 case 9800: esalt_size = sizeof (oldoffice34_t); break;
11307 case 9810: esalt_size = sizeof (oldoffice34_t); break;
11308 case 9820: esalt_size = sizeof (oldoffice34_t); break;
11309 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
11310 case 10200: esalt_size = sizeof (cram_md5_t); break;
11311 case 10400: esalt_size = sizeof (pdf_t); break;
11312 case 10410: esalt_size = sizeof (pdf_t); break;
11313 case 10420: esalt_size = sizeof (pdf_t); break;
11314 case 10500: esalt_size = sizeof (pdf_t); break;
11315 case 10600: esalt_size = sizeof (pdf_t); break;
11316 case 10700: esalt_size = sizeof (pdf_t); break;
11317 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
11318 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
11319 case 11400: esalt_size = sizeof (sip_t); break;
11320 case 11600: esalt_size = sizeof (seven_zip_t); break;
11321 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
11322 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
11323 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11324 case 13000: esalt_size = sizeof (rar5_t); break;
11325 case 13100: esalt_size = sizeof (krb5tgs_t); break;
11326 case 13400: esalt_size = sizeof (keepass_t); break;
11327 case 13500: esalt_size = sizeof (pstoken_t); break;
11328 case 13600: esalt_size = sizeof (zip2_t); break;
11329 case 13711: esalt_size = sizeof (tc_t); break;
11330 case 13712: esalt_size = sizeof (tc_t); break;
11331 case 13713: esalt_size = sizeof (tc_t); break;
11332 case 13721: esalt_size = sizeof (tc_t); break;
11333 case 13722: esalt_size = sizeof (tc_t); break;
11334 case 13723: esalt_size = sizeof (tc_t); break;
11335 case 13731: esalt_size = sizeof (tc_t); break;
11336 case 13732: esalt_size = sizeof (tc_t); break;
11337 case 13733: esalt_size = sizeof (tc_t); break;
11338 case 13741: esalt_size = sizeof (tc_t); break;
11339 case 13742: esalt_size = sizeof (tc_t); break;
11340 case 13743: esalt_size = sizeof (tc_t); break;
11341 case 13751: esalt_size = sizeof (tc_t); break;
11342 case 13752: esalt_size = sizeof (tc_t); break;
11343 case 13753: esalt_size = sizeof (tc_t); break;
11344 case 13761: esalt_size = sizeof (tc_t); break;
11345 case 13762: esalt_size = sizeof (tc_t); break;
11346 case 13763: esalt_size = sizeof (tc_t); break;
11347 case 13800: esalt_size = sizeof (win8phone_t); break;
11348 }
11349
11350 data.esalt_size = esalt_size;
11351
11352 /**
11353 * choose dictionary parser
11354 */
11355
11356 if (hash_type == HASH_TYPE_LM)
11357 {
11358 get_next_word_func = get_next_word_lm;
11359 }
11360 else if (opts_type & OPTS_TYPE_PT_UPPER)
11361 {
11362 get_next_word_func = get_next_word_uc;
11363 }
11364 else
11365 {
11366 get_next_word_func = get_next_word_std;
11367 }
11368
11369 /**
11370 * dictstat
11371 */
11372
11373 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11374
11375 #ifdef _POSIX
11376 size_t dictstat_nmemb = 0;
11377 #endif
11378
11379 #ifdef _WIN
11380 uint dictstat_nmemb = 0;
11381 #endif
11382
11383 char dictstat[256] = { 0 };
11384
11385 FILE *dictstat_fp = NULL;
11386
11387 if (keyspace == 0)
11388 {
11389 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11390
11391 dictstat_fp = fopen (dictstat, "rb");
11392
11393 if (dictstat_fp)
11394 {
11395 #ifdef _POSIX
11396 struct stat tmpstat;
11397
11398 fstat (fileno (dictstat_fp), &tmpstat);
11399 #endif
11400
11401 #ifdef _WIN
11402 struct stat64 tmpstat;
11403
11404 _fstat64 (fileno (dictstat_fp), &tmpstat);
11405 #endif
11406
11407 if (tmpstat.st_mtime < COMPTIME)
11408 {
11409 /* with v0.15 the format changed so we have to ensure user is using a good version
11410 since there is no version-header in the dictstat file */
11411
11412 fclose (dictstat_fp);
11413
11414 unlink (dictstat);
11415 }
11416 else
11417 {
11418 while (!feof (dictstat_fp))
11419 {
11420 dictstat_t d;
11421
11422 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11423
11424 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11425
11426 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11427 {
11428 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11429
11430 return -1;
11431 }
11432 }
11433
11434 fclose (dictstat_fp);
11435 }
11436 }
11437 }
11438
11439 /**
11440 * potfile
11441 */
11442
11443 char potfile[256] = { 0 };
11444
11445 if (potfile_path == NULL)
11446 {
11447 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11448 }
11449 else
11450 {
11451 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11452 }
11453
11454 data.pot_fp = NULL;
11455
11456 FILE *out_fp = NULL;
11457 FILE *pot_fp = NULL;
11458
11459 if (show == 1 || left == 1)
11460 {
11461 pot_fp = fopen (potfile, "rb");
11462
11463 if (pot_fp == NULL)
11464 {
11465 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11466
11467 return (-1);
11468 }
11469
11470 if (outfile != NULL)
11471 {
11472 if ((out_fp = fopen (outfile, "ab")) == NULL)
11473 {
11474 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11475
11476 fclose (pot_fp);
11477
11478 return (-1);
11479 }
11480 }
11481 else
11482 {
11483 out_fp = stdout;
11484 }
11485 }
11486 else
11487 {
11488 if (potfile_disable == 0)
11489 {
11490 pot_fp = fopen (potfile, "ab");
11491
11492 if (pot_fp == NULL)
11493 {
11494 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11495
11496 return (-1);
11497 }
11498
11499 data.pot_fp = pot_fp;
11500 }
11501 }
11502
11503 pot_t *pot = NULL;
11504
11505 uint pot_cnt = 0;
11506 uint pot_avail = 0;
11507
11508 if (show == 1 || left == 1)
11509 {
11510 SUPPRESS_OUTPUT = 1;
11511
11512 pot_avail = count_lines (pot_fp);
11513
11514 rewind (pot_fp);
11515
11516 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11517
11518 uint pot_hashes_avail = 0;
11519
11520 uint line_num = 0;
11521
11522 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11523
11524 while (!feof (pot_fp))
11525 {
11526 line_num++;
11527
11528 int line_len = fgetl (pot_fp, line_buf);
11529
11530 if (line_len == 0) continue;
11531
11532 char *plain_buf = line_buf + line_len;
11533
11534 pot_t *pot_ptr = &pot[pot_cnt];
11535
11536 hash_t *hashes_buf = &pot_ptr->hash;
11537
11538 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11539 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11540
11541 if (pot_cnt == pot_hashes_avail)
11542 {
11543 uint pos = 0;
11544
11545 for (pos = 0; pos < INCR_POT; pos++)
11546 {
11547 if ((pot_cnt + pos) >= pot_avail) break;
11548
11549 pot_t *tmp_pot = &pot[pot_cnt + pos];
11550
11551 hash_t *tmp_hash = &tmp_pot->hash;
11552
11553 tmp_hash->digest = mymalloc (dgst_size);
11554
11555 if (isSalted)
11556 {
11557 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11558 }
11559
11560 if (esalt_size)
11561 {
11562 tmp_hash->esalt = mymalloc (esalt_size);
11563 }
11564
11565 pot_hashes_avail++;
11566 }
11567 }
11568
11569 int plain_len = 0;
11570
11571 int parser_status;
11572
11573 int iter = MAX_CUT_TRIES;
11574
11575 do
11576 {
11577 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11578 {
11579 if (line_buf[i] == ':')
11580 {
11581 line_len--;
11582
11583 break;
11584 }
11585 }
11586
11587 if (data.hash_mode != 2500)
11588 {
11589 parser_status = parse_func (line_buf, line_len, hashes_buf);
11590 }
11591 else
11592 {
11593 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11594
11595 if (line_len > max_salt_size)
11596 {
11597 parser_status = PARSER_GLOBAL_LENGTH;
11598 }
11599 else
11600 {
11601 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11602
11603 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11604
11605 hashes_buf->salt->salt_len = line_len;
11606
11607 parser_status = PARSER_OK;
11608 }
11609 }
11610
11611 // if NOT parsed without error, we add the ":" to the plain
11612
11613 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11614 {
11615 plain_len++;
11616 plain_buf--;
11617 }
11618
11619 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11620
11621 if (parser_status < PARSER_GLOBAL_ZERO)
11622 {
11623 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11624
11625 continue;
11626 }
11627
11628 if (plain_len >= 255) continue;
11629
11630 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11631
11632 pot_ptr->plain_len = plain_len;
11633
11634 pot_cnt++;
11635 }
11636
11637 myfree (line_buf);
11638
11639 fclose (pot_fp);
11640
11641 SUPPRESS_OUTPUT = 0;
11642
11643 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11644 }
11645
11646 /**
11647 * word len
11648 */
11649
11650 uint pw_min = PW_MIN;
11651 uint pw_max = PW_MAX;
11652
11653 switch (hash_mode)
11654 {
11655 case 125: if (pw_max > 32) pw_max = 32;
11656 break;
11657 case 400: if (pw_max > 40) pw_max = 40;
11658 break;
11659 case 500: if (pw_max > 16) pw_max = 16;
11660 break;
11661 case 1500: if (pw_max > 8) pw_max = 8;
11662 break;
11663 case 1600: if (pw_max > 16) pw_max = 16;
11664 break;
11665 case 1800: if (pw_max > 16) pw_max = 16;
11666 break;
11667 case 2100: if (pw_max > 16) pw_max = 16;
11668 break;
11669 case 2500: if (pw_min < 8) pw_min = 8;
11670 break;
11671 case 3000: if (pw_max > 7) pw_max = 7;
11672 break;
11673 case 5200: if (pw_max > 24) pw_max = 24;
11674 break;
11675 case 5800: if (pw_max > 16) pw_max = 16;
11676 break;
11677 case 6300: if (pw_max > 16) pw_max = 16;
11678 break;
11679 case 7400: if (pw_max > 16) pw_max = 16;
11680 break;
11681 case 7700: if (pw_max > 8) pw_max = 8;
11682 break;
11683 case 7900: if (pw_max > 48) pw_max = 48;
11684 break;
11685 case 8500: if (pw_max > 8) pw_max = 8;
11686 break;
11687 case 8600: if (pw_max > 16) pw_max = 16;
11688 break;
11689 case 9710: pw_min = 5;
11690 pw_max = 5;
11691 break;
11692 case 9810: pw_min = 5;
11693 pw_max = 5;
11694 break;
11695 case 10410: pw_min = 5;
11696 pw_max = 5;
11697 break;
11698 case 10300: if (pw_max < 3) pw_min = 3;
11699 if (pw_max > 40) pw_max = 40;
11700 break;
11701 case 10500: if (pw_max < 3) pw_min = 3;
11702 if (pw_max > 40) pw_max = 40;
11703 break;
11704 case 10700: if (pw_max > 16) pw_max = 16;
11705 break;
11706 case 11300: if (pw_max > 40) pw_max = 40;
11707 break;
11708 case 11600: if (pw_max > 32) pw_max = 32;
11709 break;
11710 case 12500: if (pw_max > 20) pw_max = 20;
11711 break;
11712 case 12800: if (pw_max > 24) pw_max = 24;
11713 break;
11714 }
11715
11716 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11717 {
11718 switch (attack_kern)
11719 {
11720 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11721 break;
11722 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11723 break;
11724 }
11725 }
11726
11727 /**
11728 * charsets : keep them together for more easy maintainnce
11729 */
11730
11731 cs_t mp_sys[6] = { { { 0 }, 0 } };
11732 cs_t mp_usr[4] = { { { 0 }, 0 } };
11733
11734 mp_setup_sys (mp_sys);
11735
11736 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11737 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11738 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11739 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11740
11741 /**
11742 * load hashes, part I: find input mode, count hashes
11743 */
11744
11745 uint hashlist_mode = 0;
11746 uint hashlist_format = HLFMT_HASHCAT;
11747
11748 uint hashes_avail = 0;
11749
11750 if ((benchmark == 0) && (stdout_flag == 0))
11751 {
11752 struct stat f;
11753
11754 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11755
11756 if ((hash_mode == 2500) ||
11757 (hash_mode == 5200) ||
11758 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11759 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11760 (hash_mode == 9000))
11761 {
11762 hashlist_mode = HL_MODE_ARG;
11763
11764 char *hashfile = myargv[optind];
11765
11766 data.hashfile = hashfile;
11767
11768 logfile_top_var_string ("target", hashfile);
11769 }
11770
11771 if (hashlist_mode == HL_MODE_ARG)
11772 {
11773 if (hash_mode == 2500)
11774 {
11775 struct stat st;
11776
11777 if (stat (data.hashfile, &st) == -1)
11778 {
11779 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11780
11781 return (-1);
11782 }
11783
11784 hashes_avail = st.st_size / sizeof (hccap_t);
11785 }
11786 else
11787 {
11788 hashes_avail = 1;
11789 }
11790 }
11791 else if (hashlist_mode == HL_MODE_FILE)
11792 {
11793 char *hashfile = myargv[optind];
11794
11795 data.hashfile = hashfile;
11796
11797 logfile_top_var_string ("target", hashfile);
11798
11799 FILE *fp = NULL;
11800
11801 if ((fp = fopen (hashfile, "rb")) == NULL)
11802 {
11803 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11804
11805 return (-1);
11806 }
11807
11808 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11809
11810 hashes_avail = count_lines (fp);
11811
11812 rewind (fp);
11813
11814 if (hashes_avail == 0)
11815 {
11816 log_error ("ERROR: hashfile is empty or corrupt");
11817
11818 fclose (fp);
11819
11820 return (-1);
11821 }
11822
11823 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11824
11825 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11826 {
11827 log_error ("ERROR: remove not supported in native hashfile-format mode");
11828
11829 fclose (fp);
11830
11831 return (-1);
11832 }
11833
11834 fclose (fp);
11835 }
11836 }
11837 else
11838 {
11839 hashlist_mode = HL_MODE_ARG;
11840
11841 hashes_avail = 1;
11842 }
11843
11844 if (hash_mode == 3000) hashes_avail *= 2;
11845
11846 data.hashlist_mode = hashlist_mode;
11847 data.hashlist_format = hashlist_format;
11848
11849 logfile_top_uint (hashlist_mode);
11850 logfile_top_uint (hashlist_format);
11851
11852 /**
11853 * load hashes, part II: allocate required memory, set pointers
11854 */
11855
11856 hash_t *hashes_buf = NULL;
11857 void *digests_buf = NULL;
11858 salt_t *salts_buf = NULL;
11859 void *esalts_buf = NULL;
11860
11861 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11862
11863 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11864
11865 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11866 {
11867 u32 hash_pos;
11868
11869 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11870 {
11871 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11872
11873 hashes_buf[hash_pos].hash_info = hash_info;
11874
11875 if (username && (remove || show || left))
11876 {
11877 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11878 }
11879
11880 if (benchmark)
11881 {
11882 hash_info->orighash = (char *) mymalloc (256);
11883 }
11884 }
11885 }
11886
11887 if (isSalted)
11888 {
11889 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11890
11891 if (esalt_size)
11892 {
11893 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11894 }
11895 }
11896 else
11897 {
11898 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11899 }
11900
11901 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11902 {
11903 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11904
11905 if (isSalted)
11906 {
11907 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11908
11909 if (esalt_size)
11910 {
11911 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11912 }
11913 }
11914 else
11915 {
11916 hashes_buf[hash_pos].salt = &salts_buf[0];
11917 }
11918 }
11919
11920 /**
11921 * load hashes, part III: parse hashes or generate them if benchmark
11922 */
11923
11924 uint hashes_cnt = 0;
11925
11926 if (benchmark == 0)
11927 {
11928 if (keyspace == 1)
11929 {
11930 // useless to read hash file for keyspace, cheat a little bit w/ optind
11931 }
11932 else if (stdout_flag == 1)
11933 {
11934 // useless to read hash file for stdout, cheat a little bit w/ optind
11935 }
11936 else if (hashes_avail == 0)
11937 {
11938 }
11939 else if (hashlist_mode == HL_MODE_ARG)
11940 {
11941 char *input_buf = myargv[optind];
11942
11943 uint input_len = strlen (input_buf);
11944
11945 logfile_top_var_string ("target", input_buf);
11946
11947 char *hash_buf = NULL;
11948 int hash_len = 0;
11949
11950 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11951
11952 bool hash_fmt_error = 0;
11953
11954 if (hash_len < 1) hash_fmt_error = 1;
11955 if (hash_buf == NULL) hash_fmt_error = 1;
11956
11957 if (hash_fmt_error)
11958 {
11959 log_info ("WARNING: Failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11960 }
11961 else
11962 {
11963 if (opts_type & OPTS_TYPE_HASH_COPY)
11964 {
11965 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11966
11967 hash_info_tmp->orighash = mystrdup (hash_buf);
11968 }
11969
11970 if (isSalted)
11971 {
11972 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11973 }
11974
11975 int parser_status = PARSER_OK;
11976
11977 if (hash_mode == 2500)
11978 {
11979 if (hash_len == 0)
11980 {
11981 log_error ("ERROR: hccap file not specified");
11982
11983 return (-1);
11984 }
11985
11986 hashlist_mode = HL_MODE_FILE;
11987
11988 data.hashlist_mode = hashlist_mode;
11989
11990 FILE *fp = fopen (hash_buf, "rb");
11991
11992 if (fp == NULL)
11993 {
11994 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11995
11996 return (-1);
11997 }
11998
11999 if (hashes_avail < 1)
12000 {
12001 log_error ("ERROR: hccap file is empty or corrupt");
12002
12003 fclose (fp);
12004
12005 return (-1);
12006 }
12007
12008 uint hccap_size = sizeof (hccap_t);
12009
12010 char *in = (char *) mymalloc (hccap_size);
12011
12012 while (!feof (fp))
12013 {
12014 int n = fread (in, hccap_size, 1, fp);
12015
12016 if (n != 1)
12017 {
12018 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
12019
12020 break;
12021 }
12022
12023 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
12024
12025 if (parser_status != PARSER_OK)
12026 {
12027 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
12028
12029 continue;
12030 }
12031
12032 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
12033
12034 if ((show == 1) || (left == 1))
12035 {
12036 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
12037
12038 char *salt_ptr = (char *) tmp_salt->salt_buf;
12039
12040 int cur_pos = tmp_salt->salt_len;
12041 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12042
12043 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
12044
12045 // do the appending task
12046
12047 snprintf (salt_ptr + cur_pos,
12048 rem_len,
12049 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
12050 wpa->orig_mac1[0],
12051 wpa->orig_mac1[1],
12052 wpa->orig_mac1[2],
12053 wpa->orig_mac1[3],
12054 wpa->orig_mac1[4],
12055 wpa->orig_mac1[5],
12056 wpa->orig_mac2[0],
12057 wpa->orig_mac2[1],
12058 wpa->orig_mac2[2],
12059 wpa->orig_mac2[3],
12060 wpa->orig_mac2[4],
12061 wpa->orig_mac2[5]);
12062
12063 // memset () the remaining part of the salt
12064
12065 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
12066 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12067
12068 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
12069
12070 tmp_salt->salt_len += 1 + 12 + 1 + 12;
12071 }
12072
12073 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);
12074 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);
12075
12076 hashes_cnt++;
12077 }
12078
12079 fclose (fp);
12080
12081 myfree (in);
12082 }
12083 else if (hash_mode == 3000)
12084 {
12085 if (hash_len == 32)
12086 {
12087 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12088
12089 hash_t *lm_hash_left = NULL;
12090
12091 if (parser_status == PARSER_OK)
12092 {
12093 lm_hash_left = &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 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12103
12104 hash_t *lm_hash_right = NULL;
12105
12106 if (parser_status == PARSER_OK)
12107 {
12108 lm_hash_right = &hashes_buf[hashes_cnt];
12109
12110 hashes_cnt++;
12111 }
12112 else
12113 {
12114 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12115 }
12116
12117 // show / left
12118
12119 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12120 {
12121 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);
12122 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);
12123 }
12124 }
12125 else
12126 {
12127 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12128
12129 if (parser_status == PARSER_OK)
12130 {
12131 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12132 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12133 }
12134
12135 if (parser_status == PARSER_OK)
12136 {
12137 hashes_cnt++;
12138 }
12139 else
12140 {
12141 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12142 }
12143 }
12144 }
12145 else
12146 {
12147 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12148
12149 if (parser_status == PARSER_OK)
12150 {
12151 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12152 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12153 }
12154
12155 if (parser_status == PARSER_OK)
12156 {
12157 hashes_cnt++;
12158 }
12159 else
12160 {
12161 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12162 }
12163 }
12164 }
12165 }
12166 else if (hashlist_mode == HL_MODE_FILE)
12167 {
12168 char *hashfile = data.hashfile;
12169
12170 FILE *fp;
12171
12172 if ((fp = fopen (hashfile, "rb")) == NULL)
12173 {
12174 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12175
12176 return (-1);
12177 }
12178
12179 uint line_num = 0;
12180
12181 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12182
12183 while (!feof (fp))
12184 {
12185 line_num++;
12186
12187 int line_len = fgetl (fp, line_buf);
12188
12189 if (line_len == 0) continue;
12190
12191 char *hash_buf = NULL;
12192 int hash_len = 0;
12193
12194 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12195
12196 bool hash_fmt_error = 0;
12197
12198 if (hash_len < 1) hash_fmt_error = 1;
12199 if (hash_buf == NULL) hash_fmt_error = 1;
12200
12201 if (hash_fmt_error)
12202 {
12203 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12204
12205 continue;
12206 }
12207
12208 if (username)
12209 {
12210 char *user_buf = NULL;
12211 int user_len = 0;
12212
12213 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12214
12215 if (remove || show)
12216 {
12217 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12218
12219 *user = (user_t *) mymalloc (sizeof (user_t));
12220
12221 user_t *user_ptr = *user;
12222
12223 if (user_buf != NULL)
12224 {
12225 user_ptr->user_name = mystrdup (user_buf);
12226 }
12227 else
12228 {
12229 user_ptr->user_name = mystrdup ("");
12230 }
12231
12232 user_ptr->user_len = user_len;
12233 }
12234 }
12235
12236 if (opts_type & OPTS_TYPE_HASH_COPY)
12237 {
12238 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12239
12240 hash_info_tmp->orighash = mystrdup (hash_buf);
12241 }
12242
12243 if (isSalted)
12244 {
12245 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12246 }
12247
12248 if (hash_mode == 3000)
12249 {
12250 if (hash_len == 32)
12251 {
12252 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12253
12254 if (parser_status < PARSER_GLOBAL_ZERO)
12255 {
12256 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12257
12258 continue;
12259 }
12260
12261 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12262
12263 hashes_cnt++;
12264
12265 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12266
12267 if (parser_status < PARSER_GLOBAL_ZERO)
12268 {
12269 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12270
12271 continue;
12272 }
12273
12274 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12275
12276 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);
12277
12278 hashes_cnt++;
12279
12280 // show / left
12281
12282 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);
12283 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);
12284 }
12285 else
12286 {
12287 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12288
12289 if (parser_status < PARSER_GLOBAL_ZERO)
12290 {
12291 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12292
12293 continue;
12294 }
12295
12296 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);
12297
12298 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12299 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12300
12301 hashes_cnt++;
12302 }
12303 }
12304 else
12305 {
12306 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12307
12308 if (parser_status < PARSER_GLOBAL_ZERO)
12309 {
12310 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12311
12312 continue;
12313 }
12314
12315 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);
12316
12317 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12318 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12319
12320 hashes_cnt++;
12321 }
12322 }
12323
12324 myfree (line_buf);
12325
12326 fclose (fp);
12327
12328 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12329
12330 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12331 }
12332 }
12333 else
12334 {
12335 if (isSalted)
12336 {
12337 hashes_buf[0].salt->salt_len = 8;
12338
12339 // special salt handling
12340
12341 switch (hash_mode)
12342 {
12343 case 1500: hashes_buf[0].salt->salt_len = 2;
12344 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12345 break;
12346 case 1731: hashes_buf[0].salt->salt_len = 4;
12347 break;
12348 case 2410: hashes_buf[0].salt->salt_len = 4;
12349 break;
12350 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12351 break;
12352 case 3100: hashes_buf[0].salt->salt_len = 1;
12353 break;
12354 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
12355 break;
12356 case 5800: hashes_buf[0].salt->salt_len = 16;
12357 break;
12358 case 6800: hashes_buf[0].salt->salt_len = 32;
12359 break;
12360 case 8400: hashes_buf[0].salt->salt_len = 40;
12361 break;
12362 case 8800: hashes_buf[0].salt->salt_len = 16;
12363 break;
12364 case 8900: hashes_buf[0].salt->salt_len = 16;
12365 hashes_buf[0].salt->scrypt_N = 1024;
12366 hashes_buf[0].salt->scrypt_r = 1;
12367 hashes_buf[0].salt->scrypt_p = 1;
12368 break;
12369 case 9100: hashes_buf[0].salt->salt_len = 16;
12370 break;
12371 case 9300: hashes_buf[0].salt->salt_len = 14;
12372 hashes_buf[0].salt->scrypt_N = 16384;
12373 hashes_buf[0].salt->scrypt_r = 1;
12374 hashes_buf[0].salt->scrypt_p = 1;
12375 break;
12376 case 9400: hashes_buf[0].salt->salt_len = 16;
12377 break;
12378 case 9500: hashes_buf[0].salt->salt_len = 16;
12379 break;
12380 case 9600: hashes_buf[0].salt->salt_len = 16;
12381 break;
12382 case 9700: hashes_buf[0].salt->salt_len = 16;
12383 break;
12384 case 9710: hashes_buf[0].salt->salt_len = 16;
12385 break;
12386 case 9720: hashes_buf[0].salt->salt_len = 16;
12387 break;
12388 case 9800: hashes_buf[0].salt->salt_len = 16;
12389 break;
12390 case 9810: hashes_buf[0].salt->salt_len = 16;
12391 break;
12392 case 9820: hashes_buf[0].salt->salt_len = 16;
12393 break;
12394 case 10300: hashes_buf[0].salt->salt_len = 12;
12395 break;
12396 case 11500: hashes_buf[0].salt->salt_len = 4;
12397 break;
12398 case 11600: hashes_buf[0].salt->salt_len = 4;
12399 break;
12400 case 12400: hashes_buf[0].salt->salt_len = 4;
12401 break;
12402 case 12500: hashes_buf[0].salt->salt_len = 8;
12403 break;
12404 case 12600: hashes_buf[0].salt->salt_len = 64;
12405 break;
12406 }
12407
12408 // special esalt handling
12409
12410 switch (hash_mode)
12411 {
12412 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12413 break;
12414 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12415 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12416 break;
12417 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12418 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12419 break;
12420 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12421 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12422 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12423 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12424 break;
12425 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12426 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12427 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12428 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12429 break;
12430 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12431 break;
12432 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12433 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12434 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12435 break;
12436 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12437 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12438 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12439 break;
12440 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12441 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12442 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12443 break;
12444 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12445 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12446 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12447 break;
12448 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12449 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12450 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12451 break;
12452 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12453 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12454 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12455 break;
12456 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12457 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12458 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12459 break;
12460 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12461 break;
12462 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12463 break;
12464 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12465 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12466 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12467 break;
12468 }
12469 }
12470
12471 // set hashfile
12472
12473 switch (hash_mode)
12474 {
12475 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12476 break;
12477 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12478 break;
12479 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12480 break;
12481 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12482 break;
12483 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12484 break;
12485 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12486 break;
12487 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12488 break;
12489 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12490 break;
12491 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12492 break;
12493 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12494 break;
12495 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12496 break;
12497 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12498 break;
12499 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12500 break;
12501 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12502 break;
12503 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12504 break;
12505 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12506 break;
12507 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12508 break;
12509 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12510 break;
12511 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12512 break;
12513 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12514 break;
12515 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12516 break;
12517 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12518 break;
12519 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12520 break;
12521 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12522 break;
12523 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12524 break;
12525 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12526 break;
12527 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12528 break;
12529 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12530 break;
12531 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12532 break;
12533 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12534 break;
12535 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12536 break;
12537 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12538 break;
12539 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12540 break;
12541 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12542 break;
12543 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12544 break;
12545 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12546 break;
12547 }
12548
12549 // set default iterations
12550
12551 switch (hash_mode)
12552 {
12553 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12554 break;
12555 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12556 break;
12557 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12558 break;
12559 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12560 break;
12561 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12562 break;
12563 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12564 break;
12565 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12566 break;
12567 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12568 break;
12569 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12570 break;
12571 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12572 break;
12573 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12574 break;
12575 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12576 break;
12577 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12578 break;
12579 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12580 break;
12581 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12582 break;
12583 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12584 break;
12585 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12586 break;
12587 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12588 break;
12589 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12590 break;
12591 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12592 break;
12593 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12594 break;
12595 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12596 break;
12597 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12598 break;
12599 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12600 break;
12601 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12602 break;
12603 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12604 break;
12605 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12606 break;
12607 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12608 break;
12609 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12610 break;
12611 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12612 break;
12613 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12614 break;
12615 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12616 break;
12617 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12618 break;
12619 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12620 break;
12621 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12622 break;
12623 case 8900: hashes_buf[0].salt->salt_iter = 1;
12624 break;
12625 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12626 break;
12627 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12628 break;
12629 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12630 break;
12631 case 9300: hashes_buf[0].salt->salt_iter = 1;
12632 break;
12633 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12634 break;
12635 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12636 break;
12637 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12638 break;
12639 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12640 break;
12641 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12642 break;
12643 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12644 break;
12645 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12646 break;
12647 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12648 break;
12649 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12650 break;
12651 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12652 break;
12653 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12654 break;
12655 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12656 break;
12657 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12658 break;
12659 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12660 break;
12661 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12662 break;
12663 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12664 break;
12665 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12666 break;
12667 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12668 break;
12669 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12670 break;
12671 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12672 break;
12673 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12674 break;
12675 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12676 break;
12677 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12678 break;
12679 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12680 break;
12681 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12682 break;
12683 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12684 break;
12685 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12686 break;
12687 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12688 break;
12689 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12690 break;
12691 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12692 break;
12693 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12694 break;
12695 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12696 break;
12697 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12698 break;
12699 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12700 break;
12701 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12702 break;
12703 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12704 break;
12705 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12706 break;
12707 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12708 break;
12709 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12710 break;
12711 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12712 break;
12713 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12714 break;
12715 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12716 break;
12717 }
12718
12719 hashes_cnt = 1;
12720 }
12721
12722 if (show == 1 || left == 1)
12723 {
12724 for (uint i = 0; i < pot_cnt; i++)
12725 {
12726 pot_t *pot_ptr = &pot[i];
12727
12728 hash_t *hashes_buf = &pot_ptr->hash;
12729
12730 local_free (hashes_buf->digest);
12731
12732 if (isSalted)
12733 {
12734 local_free (hashes_buf->salt);
12735 }
12736 }
12737
12738 local_free (pot);
12739
12740 if (data.quiet == 0) log_info_nn ("");
12741
12742 return (0);
12743 }
12744
12745 if ((keyspace == 0) && (stdout_flag == 0))
12746 {
12747 if (hashes_cnt == 0)
12748 {
12749 log_error ("ERROR: No hashes loaded");
12750
12751 return (-1);
12752 }
12753 }
12754
12755 /**
12756 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12757 */
12758
12759 if (data.outfile != NULL)
12760 {
12761 if (data.hashfile != NULL)
12762 {
12763 #ifdef _POSIX
12764 struct stat tmpstat_outfile;
12765 struct stat tmpstat_hashfile;
12766 #endif
12767
12768 #ifdef _WIN
12769 struct stat64 tmpstat_outfile;
12770 struct stat64 tmpstat_hashfile;
12771 #endif
12772
12773 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12774
12775 if (tmp_outfile_fp)
12776 {
12777 #ifdef _POSIX
12778 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12779 #endif
12780
12781 #ifdef _WIN
12782 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12783 #endif
12784
12785 fclose (tmp_outfile_fp);
12786 }
12787
12788 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12789
12790 if (tmp_hashfile_fp)
12791 {
12792 #ifdef _POSIX
12793 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12794 #endif
12795
12796 #ifdef _WIN
12797 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12798 #endif
12799
12800 fclose (tmp_hashfile_fp);
12801 }
12802
12803 if (tmp_outfile_fp && tmp_outfile_fp)
12804 {
12805 tmpstat_outfile.st_mode = 0;
12806 tmpstat_outfile.st_nlink = 0;
12807 tmpstat_outfile.st_uid = 0;
12808 tmpstat_outfile.st_gid = 0;
12809 tmpstat_outfile.st_rdev = 0;
12810 tmpstat_outfile.st_atime = 0;
12811
12812 tmpstat_hashfile.st_mode = 0;
12813 tmpstat_hashfile.st_nlink = 0;
12814 tmpstat_hashfile.st_uid = 0;
12815 tmpstat_hashfile.st_gid = 0;
12816 tmpstat_hashfile.st_rdev = 0;
12817 tmpstat_hashfile.st_atime = 0;
12818
12819 #ifdef _POSIX
12820 tmpstat_outfile.st_blksize = 0;
12821 tmpstat_outfile.st_blocks = 0;
12822
12823 tmpstat_hashfile.st_blksize = 0;
12824 tmpstat_hashfile.st_blocks = 0;
12825 #endif
12826
12827 #ifdef _POSIX
12828 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12829 {
12830 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12831
12832 return (-1);
12833 }
12834 #endif
12835
12836 #ifdef _WIN
12837 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12838 {
12839 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12840
12841 return (-1);
12842 }
12843 #endif
12844 }
12845 }
12846 }
12847
12848 /**
12849 * Remove duplicates
12850 */
12851
12852 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12853
12854 if (isSalted)
12855 {
12856 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12857 }
12858 else
12859 {
12860 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12861 }
12862
12863 uint hashes_cnt_orig = hashes_cnt;
12864
12865 hashes_cnt = 1;
12866
12867 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12868 {
12869 if (isSalted)
12870 {
12871 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12872 {
12873 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12874 }
12875 }
12876 else
12877 {
12878 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12879 }
12880
12881 if (hashes_pos > hashes_cnt)
12882 {
12883 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12884 }
12885
12886 hashes_cnt++;
12887 }
12888
12889 /**
12890 * Potfile removes
12891 */
12892
12893 uint potfile_remove_cracks = 0;
12894
12895 if (potfile_disable == 0)
12896 {
12897 hash_t hash_buf;
12898
12899 hash_buf.digest = mymalloc (dgst_size);
12900 hash_buf.salt = NULL;
12901 hash_buf.esalt = NULL;
12902 hash_buf.hash_info = NULL;
12903 hash_buf.cracked = 0;
12904
12905 if (isSalted)
12906 {
12907 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12908 }
12909
12910 if (esalt_size)
12911 {
12912 hash_buf.esalt = mymalloc (esalt_size);
12913 }
12914
12915 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12916
12917 // no solution for these special hash types (for instane because they use hashfile in output etc)
12918 if ((hash_mode != 5200) &&
12919 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12920 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12921 (hash_mode != 9000))
12922 {
12923 FILE *fp = fopen (potfile, "rb");
12924
12925 if (fp != NULL)
12926 {
12927 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12928
12929 // to be safe work with a copy (because of line_len loop, i etc)
12930 // moved up here because it's easier to handle continue case
12931 // it's just 64kb
12932
12933 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12934
12935 while (!feof (fp))
12936 {
12937 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12938
12939 if (ptr == NULL) break;
12940
12941 int line_len = strlen (line_buf);
12942
12943 if (line_len == 0) continue;
12944
12945 int iter = MAX_CUT_TRIES;
12946
12947 for (int i = line_len - 1; i && iter; i--, line_len--)
12948 {
12949 if (line_buf[i] != ':') continue;
12950
12951 if (isSalted)
12952 {
12953 memset (hash_buf.salt, 0, sizeof (salt_t));
12954 }
12955
12956 hash_t *found = NULL;
12957
12958 if (hash_mode == 6800)
12959 {
12960 if (i < 64) // 64 = 16 * uint in salt_buf[]
12961 {
12962 // manipulate salt_buf
12963 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12964
12965 hash_buf.salt->salt_len = i;
12966
12967 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12968 }
12969 }
12970 else if (hash_mode == 2500)
12971 {
12972 if (i < 64) // 64 = 16 * uint in salt_buf[]
12973 {
12974 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12975 // manipulate salt_buf
12976
12977 memcpy (line_buf_cpy, line_buf, i);
12978
12979 char *mac2_pos = strrchr (line_buf_cpy, ':');
12980
12981 if (mac2_pos == NULL) continue;
12982
12983 mac2_pos[0] = 0;
12984 mac2_pos++;
12985
12986 if (strlen (mac2_pos) != 12) continue;
12987
12988 char *mac1_pos = strrchr (line_buf_cpy, ':');
12989
12990 if (mac1_pos == NULL) continue;
12991
12992 mac1_pos[0] = 0;
12993 mac1_pos++;
12994
12995 if (strlen (mac1_pos) != 12) continue;
12996
12997 uint essid_length = mac1_pos - line_buf_cpy - 1;
12998
12999 // here we need the ESSID
13000 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
13001
13002 hash_buf.salt->salt_len = essid_length;
13003
13004 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
13005
13006 if (found)
13007 {
13008 wpa_t *wpa = (wpa_t *) found->esalt;
13009
13010 // compare hex string(s) vs binary MAC address(es)
13011
13012 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13013 {
13014 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
13015 {
13016 found = NULL;
13017
13018 break;
13019 }
13020 }
13021
13022 // early skip ;)
13023 if (!found) continue;
13024
13025 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13026 {
13027 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
13028 {
13029 found = NULL;
13030
13031 break;
13032 }
13033 }
13034 }
13035 }
13036 }
13037 else
13038 {
13039 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
13040
13041 if (parser_status == PARSER_OK)
13042 {
13043 if (isSalted)
13044 {
13045 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
13046 }
13047 else
13048 {
13049 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
13050 }
13051 }
13052 }
13053
13054 if (found == NULL) continue;
13055
13056 if (!found->cracked) potfile_remove_cracks++;
13057
13058 found->cracked = 1;
13059
13060 if (found) break;
13061
13062 iter--;
13063 }
13064 }
13065
13066 myfree (line_buf_cpy);
13067
13068 myfree (line_buf);
13069
13070 fclose (fp);
13071 }
13072 }
13073
13074 if (esalt_size)
13075 {
13076 local_free (hash_buf.esalt);
13077 }
13078
13079 if (isSalted)
13080 {
13081 local_free (hash_buf.salt);
13082 }
13083
13084 local_free (hash_buf.digest);
13085 }
13086
13087 /**
13088 * Now generate all the buffers required for later
13089 */
13090
13091 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
13092
13093 salt_t *salts_buf_new = NULL;
13094 void *esalts_buf_new = NULL;
13095
13096 if (isSalted)
13097 {
13098 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
13099
13100 if (esalt_size)
13101 {
13102 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
13103 }
13104 }
13105 else
13106 {
13107 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13108 }
13109
13110 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13111
13112 uint digests_cnt = hashes_cnt;
13113 uint digests_done = 0;
13114
13115 size_t size_digests = digests_cnt * dgst_size;
13116 size_t size_shown = digests_cnt * sizeof (uint);
13117
13118 uint *digests_shown = (uint *) mymalloc (size_shown);
13119 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13120
13121 uint salts_cnt = 0;
13122 uint salts_done = 0;
13123
13124 hashinfo_t **hash_info = NULL;
13125
13126 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13127 {
13128 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13129
13130 if (username && (remove || show))
13131 {
13132 uint user_pos;
13133
13134 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13135 {
13136 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13137
13138 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13139 }
13140 }
13141 }
13142
13143 uint *salts_shown = (uint *) mymalloc (size_shown);
13144
13145 salt_t *salt_buf;
13146
13147 {
13148 // copied from inner loop
13149
13150 salt_buf = &salts_buf_new[salts_cnt];
13151
13152 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13153
13154 if (esalt_size)
13155 {
13156 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13157 }
13158
13159 salt_buf->digests_cnt = 0;
13160 salt_buf->digests_done = 0;
13161 salt_buf->digests_offset = 0;
13162
13163 salts_cnt++;
13164 }
13165
13166 if (hashes_buf[0].cracked == 1)
13167 {
13168 digests_shown[0] = 1;
13169
13170 digests_done++;
13171
13172 salt_buf->digests_done++;
13173 }
13174
13175 salt_buf->digests_cnt++;
13176
13177 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13178
13179 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13180 {
13181 hash_info[0] = hashes_buf[0].hash_info;
13182 }
13183
13184 // copy from inner loop
13185
13186 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13187 {
13188 if (isSalted)
13189 {
13190 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13191 {
13192 salt_buf = &salts_buf_new[salts_cnt];
13193
13194 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13195
13196 if (esalt_size)
13197 {
13198 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13199 }
13200
13201 salt_buf->digests_cnt = 0;
13202 salt_buf->digests_done = 0;
13203 salt_buf->digests_offset = hashes_pos;
13204
13205 salts_cnt++;
13206 }
13207 }
13208
13209 if (hashes_buf[hashes_pos].cracked == 1)
13210 {
13211 digests_shown[hashes_pos] = 1;
13212
13213 digests_done++;
13214
13215 salt_buf->digests_done++;
13216 }
13217
13218 salt_buf->digests_cnt++;
13219
13220 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13221
13222 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13223 {
13224 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13225 }
13226 }
13227
13228 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13229 {
13230 salt_t *salt_buf = &salts_buf_new[salt_pos];
13231
13232 if (salt_buf->digests_done == salt_buf->digests_cnt)
13233 {
13234 salts_shown[salt_pos] = 1;
13235
13236 salts_done++;
13237 }
13238
13239 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13240 }
13241
13242 local_free (digests_buf);
13243 local_free (salts_buf);
13244 local_free (esalts_buf);
13245
13246 digests_buf = digests_buf_new;
13247 salts_buf = salts_buf_new;
13248 esalts_buf = esalts_buf_new;
13249
13250 local_free (hashes_buf);
13251
13252 /**
13253 * special modification not set from parser
13254 */
13255
13256 switch (hash_mode)
13257 {
13258 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13259 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13260 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13261 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13262 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13263 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13264 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13265 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13266 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13267 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13268 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13269 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13270 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13271 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13272 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13273 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13274 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13275 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13276 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13277 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13278 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13279 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13280 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13281 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13282 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13283 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13284 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13285 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13286 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13287 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13288 }
13289
13290 if (truecrypt_keyfiles)
13291 {
13292 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13293
13294 char *keyfiles = strdup (truecrypt_keyfiles);
13295
13296 char *keyfile = strtok (keyfiles, ",");
13297
13298 do
13299 {
13300 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13301
13302 } while ((keyfile = strtok (NULL, ",")) != NULL);
13303
13304 free (keyfiles);
13305 }
13306
13307 if (veracrypt_keyfiles)
13308 {
13309 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13310
13311 char *keyfiles = strdup (veracrypt_keyfiles);
13312
13313 char *keyfile = strtok (keyfiles, ",");
13314
13315 do
13316 {
13317 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13318
13319 } while ((keyfile = strtok (NULL, ",")) != NULL);
13320
13321 free (keyfiles);
13322 }
13323
13324 data.digests_cnt = digests_cnt;
13325 data.digests_done = digests_done;
13326 data.digests_buf = digests_buf;
13327 data.digests_shown = digests_shown;
13328 data.digests_shown_tmp = digests_shown_tmp;
13329
13330 data.salts_cnt = salts_cnt;
13331 data.salts_done = salts_done;
13332 data.salts_buf = salts_buf;
13333 data.salts_shown = salts_shown;
13334
13335 data.esalts_buf = esalts_buf;
13336 data.hash_info = hash_info;
13337
13338 /**
13339 * Automatic Optimizers
13340 */
13341
13342 if (salts_cnt == 1)
13343 opti_type |= OPTI_TYPE_SINGLE_SALT;
13344
13345 if (digests_cnt == 1)
13346 opti_type |= OPTI_TYPE_SINGLE_HASH;
13347
13348 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13349 opti_type |= OPTI_TYPE_NOT_ITERATED;
13350
13351 if (attack_mode == ATTACK_MODE_BF)
13352 opti_type |= OPTI_TYPE_BRUTE_FORCE;
13353
13354 data.opti_type = opti_type;
13355
13356 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13357 {
13358 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13359 {
13360 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13361 {
13362 if (opts_type & OPTS_TYPE_ST_ADD80)
13363 {
13364 opts_type &= ~OPTS_TYPE_ST_ADD80;
13365 opts_type |= OPTS_TYPE_PT_ADD80;
13366 }
13367
13368 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13369 {
13370 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13371 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13372 }
13373
13374 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13375 {
13376 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13377 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13378 }
13379 }
13380 }
13381 }
13382
13383 /**
13384 * Some algorithm, like descrypt, can benefit from JIT compilation
13385 */
13386
13387 int force_jit_compilation = -1;
13388
13389 if (hash_mode == 8900)
13390 {
13391 force_jit_compilation = 8900;
13392 }
13393 else if (hash_mode == 9300)
13394 {
13395 force_jit_compilation = 8900;
13396 }
13397 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13398 {
13399 force_jit_compilation = 1500;
13400 }
13401
13402 /**
13403 * generate bitmap tables
13404 */
13405
13406 const uint bitmap_shift1 = 5;
13407 const uint bitmap_shift2 = 13;
13408
13409 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13410
13411 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13412 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13413 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13414 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13415 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13416 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13417 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13418 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13419
13420 uint bitmap_bits;
13421 uint bitmap_nums;
13422 uint bitmap_mask;
13423 uint bitmap_size;
13424
13425 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13426 {
13427 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13428
13429 bitmap_nums = 1 << bitmap_bits;
13430
13431 bitmap_mask = bitmap_nums - 1;
13432
13433 bitmap_size = bitmap_nums * sizeof (uint);
13434
13435 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13436
13437 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;
13438 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;
13439
13440 break;
13441 }
13442
13443 bitmap_nums = 1 << bitmap_bits;
13444
13445 bitmap_mask = bitmap_nums - 1;
13446
13447 bitmap_size = bitmap_nums * sizeof (uint);
13448
13449 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);
13450 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);
13451
13452 /**
13453 * prepare quick rule
13454 */
13455
13456 data.rule_buf_l = rule_buf_l;
13457 data.rule_buf_r = rule_buf_r;
13458
13459 int rule_len_l = (int) strlen (rule_buf_l);
13460 int rule_len_r = (int) strlen (rule_buf_r);
13461
13462 data.rule_len_l = rule_len_l;
13463 data.rule_len_r = rule_len_r;
13464
13465 /**
13466 * load rules
13467 */
13468
13469 uint *all_kernel_rules_cnt = NULL;
13470
13471 kernel_rule_t **all_kernel_rules_buf = NULL;
13472
13473 if (rp_files_cnt)
13474 {
13475 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13476
13477 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13478 }
13479
13480 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13481
13482 int rule_len = 0;
13483
13484 for (uint i = 0; i < rp_files_cnt; i++)
13485 {
13486 uint kernel_rules_avail = 0;
13487
13488 uint kernel_rules_cnt = 0;
13489
13490 kernel_rule_t *kernel_rules_buf = NULL;
13491
13492 char *rp_file = rp_files[i];
13493
13494 char in[BLOCK_SIZE] = { 0 };
13495 char out[BLOCK_SIZE] = { 0 };
13496
13497 FILE *fp = NULL;
13498
13499 uint rule_line = 0;
13500
13501 if ((fp = fopen (rp_file, "rb")) == NULL)
13502 {
13503 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13504
13505 return (-1);
13506 }
13507
13508 while (!feof (fp))
13509 {
13510 memset (rule_buf, 0, HCBUFSIZ);
13511
13512 rule_len = fgetl (fp, rule_buf);
13513
13514 rule_line++;
13515
13516 if (rule_len == 0) continue;
13517
13518 if (rule_buf[0] == '#') continue;
13519
13520 if (kernel_rules_avail == kernel_rules_cnt)
13521 {
13522 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13523
13524 kernel_rules_avail += INCR_RULES;
13525 }
13526
13527 memset (in, 0, BLOCK_SIZE);
13528 memset (out, 0, BLOCK_SIZE);
13529
13530 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13531
13532 if (result == -1)
13533 {
13534 log_info ("WARNING: Skipping invalid or unsupported rule in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13535
13536 continue;
13537 }
13538
13539 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13540 {
13541 log_info ("WARNING: Cannot convert rule for use on OpenCL device in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13542
13543 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13544
13545 continue;
13546 }
13547
13548 /* its so slow
13549 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13550 {
13551 log_info ("Duplicate rule for use on OpenCL device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13552
13553 continue;
13554 }
13555 */
13556
13557 kernel_rules_cnt++;
13558 }
13559
13560 fclose (fp);
13561
13562 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13563
13564 all_kernel_rules_buf[i] = kernel_rules_buf;
13565 }
13566
13567 /**
13568 * merge rules or automatic rule generator
13569 */
13570
13571 uint kernel_rules_cnt = 0;
13572
13573 kernel_rule_t *kernel_rules_buf = NULL;
13574
13575 if (attack_mode == ATTACK_MODE_STRAIGHT)
13576 {
13577 if (rp_files_cnt)
13578 {
13579 kernel_rules_cnt = 1;
13580
13581 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13582
13583 repeats[0] = kernel_rules_cnt;
13584
13585 for (uint i = 0; i < rp_files_cnt; i++)
13586 {
13587 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13588
13589 repeats[i + 1] = kernel_rules_cnt;
13590 }
13591
13592 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13593
13594 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13595
13596 for (uint i = 0; i < kernel_rules_cnt; i++)
13597 {
13598 uint out_pos = 0;
13599
13600 kernel_rule_t *out = &kernel_rules_buf[i];
13601
13602 for (uint j = 0; j < rp_files_cnt; j++)
13603 {
13604 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13605 uint in_pos;
13606
13607 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13608
13609 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13610 {
13611 if (out_pos == RULES_MAX - 1)
13612 {
13613 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13614
13615 break;
13616 }
13617
13618 out->cmds[out_pos] = in->cmds[in_pos];
13619 }
13620 }
13621 }
13622
13623 local_free (repeats);
13624 }
13625 else if (rp_gen)
13626 {
13627 uint kernel_rules_avail = 0;
13628
13629 while (kernel_rules_cnt < rp_gen)
13630 {
13631 if (kernel_rules_avail == kernel_rules_cnt)
13632 {
13633 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13634
13635 kernel_rules_avail += INCR_RULES;
13636 }
13637
13638 memset (rule_buf, 0, HCBUFSIZ);
13639
13640 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13641
13642 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13643
13644 kernel_rules_cnt++;
13645 }
13646 }
13647 }
13648
13649 myfree (rule_buf);
13650
13651 /**
13652 * generate NOP rules
13653 */
13654
13655 if ((rp_files_cnt == 0) && (rp_gen == 0))
13656 {
13657 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13658
13659 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13660
13661 kernel_rules_cnt++;
13662 }
13663
13664 data.kernel_rules_cnt = kernel_rules_cnt;
13665 data.kernel_rules_buf = kernel_rules_buf;
13666
13667 if (kernel_rules_cnt == 0)
13668 {
13669 log_error ("ERROR: No valid rules left");
13670
13671 return (-1);
13672 }
13673
13674 /**
13675 * OpenCL platforms: detect
13676 */
13677
13678 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13679 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13680
13681 cl_uint platforms_cnt = 0;
13682 cl_uint platform_devices_cnt = 0;
13683
13684 if (keyspace == 0)
13685 {
13686 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13687
13688 if (platforms_cnt == 0)
13689 {
13690 log_info ("");
13691 log_info ("ATTENTION! No OpenCL compatible platform found");
13692 log_info ("");
13693 log_info ("You're probably missing the OpenCL runtime installation");
13694 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13695 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13696 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13697 log_info ("");
13698
13699 return (-1);
13700 }
13701
13702 if (opencl_platforms_filter != (uint) -1)
13703 {
13704 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13705
13706 if (opencl_platforms_filter > platform_cnt_mask)
13707 {
13708 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13709
13710 return (-1);
13711 }
13712 }
13713 }
13714
13715 if (opencl_device_types == NULL)
13716 {
13717 /**
13718 * OpenCL device types:
13719 * 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.
13720 */
13721
13722 cl_device_type device_types_all = 0;
13723
13724 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13725 {
13726 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13727
13728 cl_platform_id platform = platforms[platform_id];
13729
13730 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13731
13732 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13733 {
13734 cl_device_id device = platform_devices[platform_devices_id];
13735
13736 cl_device_type device_type;
13737
13738 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13739
13740 device_types_all |= device_type;
13741 }
13742 }
13743
13744 // In such a case, automatically enable CPU device type support, since it's disabled by default.
13745
13746 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13747 {
13748 device_types_filter |= CL_DEVICE_TYPE_CPU;
13749 }
13750
13751 // In another case, when the user uses --stdout, using CPU devices is much faster to setup
13752 // If we have a CPU device, force it to be used
13753
13754 if (stdout_flag == 1)
13755 {
13756 if (device_types_all & CL_DEVICE_TYPE_CPU)
13757 {
13758 device_types_filter = CL_DEVICE_TYPE_CPU;
13759 }
13760 }
13761 }
13762
13763 /**
13764 * OpenCL devices: simply push all devices from all platforms into the same device array
13765 */
13766
13767 int need_adl = 0;
13768 int need_nvapi = 0;
13769 int need_nvml = 0;
13770 int need_xnvctrl = 0;
13771
13772 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13773
13774 data.devices_param = devices_param;
13775
13776 uint devices_cnt = 0;
13777
13778 uint devices_active = 0;
13779
13780 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13781 {
13782 cl_platform_id platform = platforms[platform_id];
13783
13784 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13785
13786 char platform_vendor[INFOSZ] = { 0 };
13787
13788 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13789
13790 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13791 // this causes trouble with vendor id based macros
13792 // we'll assign generic to those without special optimization available
13793
13794 cl_uint platform_vendor_id = 0;
13795
13796 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13797 {
13798 platform_vendor_id = VENDOR_ID_AMD;
13799 }
13800 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13801 {
13802 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13803 }
13804 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13805 {
13806 platform_vendor_id = VENDOR_ID_APPLE;
13807 }
13808 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13809 {
13810 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13811 }
13812 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13813 {
13814 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13815 }
13816 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13817 {
13818 platform_vendor_id = VENDOR_ID_MESA;
13819 }
13820 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13821 {
13822 platform_vendor_id = VENDOR_ID_NV;
13823 }
13824 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13825 {
13826 platform_vendor_id = VENDOR_ID_POCL;
13827 }
13828 else
13829 {
13830 platform_vendor_id = VENDOR_ID_GENERIC;
13831 }
13832
13833 const uint platform_skipped = ((opencl_platforms_filter & (1 << platform_id)) == 0);
13834
13835 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13836 {
13837 if (machine_readable == 0)
13838 {
13839 if (platform_skipped == 0)
13840 {
13841 const int len = log_info ("OpenCL Platform #%u: %s", platform_id + 1, platform_vendor);
13842
13843 char line[256] = { 0 };
13844
13845 for (int i = 0; i < len; i++) line[i] = '=';
13846
13847 log_info (line);
13848 }
13849 else
13850 {
13851 log_info ("OpenCL Platform #%u: %s, skipped", platform_id + 1, platform_vendor);
13852 log_info ("");
13853 }
13854 }
13855 }
13856
13857 if (platform_skipped == 1) continue;
13858
13859 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13860 {
13861 size_t param_value_size = 0;
13862
13863 const uint device_id = devices_cnt;
13864
13865 hc_device_param_t *device_param = &data.devices_param[device_id];
13866
13867 device_param->platform_vendor_id = platform_vendor_id;
13868
13869 device_param->device = platform_devices[platform_devices_id];
13870
13871 device_param->device_id = device_id;
13872
13873 device_param->platform_devices_id = platform_devices_id;
13874
13875 // device_type
13876
13877 cl_device_type device_type;
13878
13879 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13880
13881 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13882
13883 device_param->device_type = device_type;
13884
13885 // device_name
13886
13887 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13888
13889 char *device_name = (char *) mymalloc (param_value_size);
13890
13891 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13892
13893 device_param->device_name = device_name;
13894
13895 // device_vendor
13896
13897 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13898
13899 char *device_vendor = (char *) mymalloc (param_value_size);
13900
13901 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13902
13903 device_param->device_vendor = device_vendor;
13904
13905 cl_uint device_vendor_id = 0;
13906
13907 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13908 {
13909 device_vendor_id = VENDOR_ID_AMD;
13910 }
13911 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13912 {
13913 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13914 }
13915 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13916 {
13917 device_vendor_id = VENDOR_ID_APPLE;
13918 }
13919 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13920 {
13921 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13922 }
13923 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13924 {
13925 device_vendor_id = VENDOR_ID_INTEL_SDK;
13926 }
13927 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13928 {
13929 device_vendor_id = VENDOR_ID_MESA;
13930 }
13931 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13932 {
13933 device_vendor_id = VENDOR_ID_NV;
13934 }
13935 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13936 {
13937 device_vendor_id = VENDOR_ID_POCL;
13938 }
13939 else
13940 {
13941 device_vendor_id = VENDOR_ID_GENERIC;
13942 }
13943
13944 device_param->device_vendor_id = device_vendor_id;
13945
13946 // tuning db
13947
13948 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13949
13950 // device_version
13951
13952 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13953
13954 char *device_version = (char *) mymalloc (param_value_size);
13955
13956 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13957
13958 device_param->device_version = device_version;
13959
13960 // device_opencl_version
13961
13962 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13963
13964 char *device_opencl_version = (char *) mymalloc (param_value_size);
13965
13966 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13967
13968 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13969
13970 myfree (device_opencl_version);
13971
13972 // vector_width
13973
13974 cl_uint vector_width;
13975
13976 if (opencl_vector_width_chgd == 0)
13977 {
13978 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13979 {
13980 if (opti_type & OPTI_TYPE_USES_BITS_64)
13981 {
13982 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13983 }
13984 else
13985 {
13986 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13987 }
13988 }
13989 else
13990 {
13991 vector_width = (cl_uint) tuningdb_entry->vector_width;
13992 }
13993 }
13994 else
13995 {
13996 vector_width = opencl_vector_width;
13997 }
13998
13999 if (vector_width > 16) vector_width = 16;
14000
14001 device_param->vector_width = vector_width;
14002
14003 // max_compute_units
14004
14005 cl_uint device_processors;
14006
14007 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
14008
14009 device_param->device_processors = device_processors;
14010
14011 // device_maxmem_alloc
14012 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
14013
14014 cl_ulong device_maxmem_alloc;
14015
14016 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
14017
14018 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
14019
14020 // device_global_mem
14021
14022 cl_ulong device_global_mem;
14023
14024 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
14025
14026 device_param->device_global_mem = device_global_mem;
14027
14028 // max_work_group_size
14029
14030 size_t device_maxworkgroup_size;
14031
14032 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
14033
14034 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
14035
14036 // max_clock_frequency
14037
14038 cl_uint device_maxclock_frequency;
14039
14040 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
14041
14042 device_param->device_maxclock_frequency = device_maxclock_frequency;
14043
14044 // device_endian_little
14045
14046 cl_bool device_endian_little;
14047
14048 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
14049
14050 if (device_endian_little == CL_FALSE)
14051 {
14052 log_info ("- Device #%u: WARNING: Not a little endian device", device_id + 1);
14053
14054 device_param->skipped = 1;
14055 }
14056
14057 // device_available
14058
14059 cl_bool device_available;
14060
14061 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
14062
14063 if (device_available == CL_FALSE)
14064 {
14065 log_info ("- Device #%u: WARNING: Device not available", device_id + 1);
14066
14067 device_param->skipped = 1;
14068 }
14069
14070 // device_compiler_available
14071
14072 cl_bool device_compiler_available;
14073
14074 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
14075
14076 if (device_compiler_available == CL_FALSE)
14077 {
14078 log_info ("- Device #%u: WARNING: No compiler available for device", device_id + 1);
14079
14080 device_param->skipped = 1;
14081 }
14082
14083 // device_execution_capabilities
14084
14085 cl_device_exec_capabilities device_execution_capabilities;
14086
14087 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
14088
14089 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
14090 {
14091 log_info ("- Device #%u: WARNING: Device does not support executing kernels", device_id + 1);
14092
14093 device_param->skipped = 1;
14094 }
14095
14096 // device_extensions
14097
14098 size_t device_extensions_size;
14099
14100 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
14101
14102 char *device_extensions = mymalloc (device_extensions_size + 1);
14103
14104 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
14105
14106 if (strstr (device_extensions, "base_atomics") == 0)
14107 {
14108 log_info ("- Device #%u: WARNING: Device does not support base atomics", device_id + 1);
14109
14110 device_param->skipped = 1;
14111 }
14112
14113 if (strstr (device_extensions, "byte_addressable_store") == 0)
14114 {
14115 log_info ("- Device #%u: WARNING: Device does not support byte addressable store", device_id + 1);
14116
14117 device_param->skipped = 1;
14118 }
14119
14120 myfree (device_extensions);
14121
14122 // device_local_mem_size
14123
14124 cl_ulong device_local_mem_size;
14125
14126 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
14127
14128 if (device_local_mem_size < 32768)
14129 {
14130 log_info ("- Device #%u: WARNING: Device local mem size is too small", device_id + 1);
14131
14132 device_param->skipped = 1;
14133 }
14134
14135 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
14136 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
14137 // This results in both utilizing it for 50%
14138 // However, Intel has much better SIMD control over their own hardware
14139 // It makes sense to give them full control over their own hardware
14140
14141 if (device_type & CL_DEVICE_TYPE_CPU)
14142 {
14143 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14144 {
14145 if (data.force == 0)
14146 {
14147 if (algorithm_pos == 0)
14148 {
14149 log_info ("- Device #%u: WARNING: Not a native Intel OpenCL runtime, expect massive speed loss", device_id + 1);
14150 log_info (" You can use --force to override this but do not post error reports if you do so");
14151 }
14152
14153 device_param->skipped = 1;
14154 }
14155 }
14156 }
14157
14158 // skipped
14159
14160 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14161 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14162
14163 // driver_version
14164
14165 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14166
14167 char *driver_version = (char *) mymalloc (param_value_size);
14168
14169 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14170
14171 device_param->driver_version = driver_version;
14172
14173 // device_name_chksum
14174
14175 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14176
14177 #if __x86_64__
14178 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);
14179 #else
14180 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);
14181 #endif
14182
14183 uint device_name_digest[4] = { 0 };
14184
14185 md5_64 ((uint *) device_name_chksum, device_name_digest);
14186
14187 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14188
14189 device_param->device_name_chksum = device_name_chksum;
14190
14191 // device_processor_cores
14192
14193 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14194 {
14195 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14196 {
14197 need_adl = 1;
14198 }
14199
14200 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14201 {
14202 need_nvml = 1;
14203
14204 #ifdef LINUX
14205 need_xnvctrl = 1;
14206 #endif
14207
14208 #ifdef WIN
14209 need_nvapi = 1;
14210 #endif
14211 }
14212 }
14213
14214 // device_processor_cores
14215
14216 if (device_type & CL_DEVICE_TYPE_CPU)
14217 {
14218 cl_uint device_processor_cores = 1;
14219
14220 device_param->device_processor_cores = device_processor_cores;
14221 }
14222
14223 if (device_type & CL_DEVICE_TYPE_GPU)
14224 {
14225 if (device_vendor_id == VENDOR_ID_AMD)
14226 {
14227 cl_uint device_processor_cores = 0;
14228
14229 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
14230
14231 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
14232
14233 device_param->device_processor_cores = device_processor_cores;
14234 }
14235 else if (device_vendor_id == VENDOR_ID_NV)
14236 {
14237 cl_uint kernel_exec_timeout = 0;
14238
14239 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14240
14241 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14242
14243 device_param->kernel_exec_timeout = kernel_exec_timeout;
14244
14245 cl_uint device_processor_cores = 0;
14246
14247 #define CL_DEVICE_WARP_SIZE_NV 0x4003
14248
14249 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
14250
14251 device_param->device_processor_cores = device_processor_cores;
14252
14253 cl_uint sm_minor = 0;
14254 cl_uint sm_major = 0;
14255
14256 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14257 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14258
14259 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14260 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14261
14262 device_param->sm_minor = sm_minor;
14263 device_param->sm_major = sm_major;
14264
14265 // CPU burning loop damper
14266 // Value is given as number between 0-100
14267 // By default 100%
14268
14269 device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14270
14271 if (nvidia_spin_damp_chgd == 0)
14272 {
14273 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14274 {
14275 /**
14276 * the workaround is not a friend of rule based attacks
14277 * the words from the wordlist combined with fast and slow rules cause
14278 * fluctuations which cause inaccurate wait time estimations
14279 * using a reduced damping percentage almost compensates this
14280 */
14281
14282 device_param->nvidia_spin_damp = 64;
14283 }
14284 }
14285
14286 device_param->nvidia_spin_damp /= 100;
14287 }
14288 else
14289 {
14290 cl_uint device_processor_cores = 1;
14291
14292 device_param->device_processor_cores = device_processor_cores;
14293 }
14294 }
14295
14296 // display results
14297
14298 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14299 {
14300 if (machine_readable == 0)
14301 {
14302 if (device_param->skipped == 0)
14303 {
14304 log_info ("- Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14305 device_id + 1,
14306 device_name,
14307 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14308 (unsigned int) (device_global_mem / 1024 / 1024),
14309 (unsigned int) device_processors);
14310 }
14311 else
14312 {
14313 log_info ("- Device #%u: %s, skipped",
14314 device_id + 1,
14315 device_name);
14316 }
14317 }
14318 }
14319
14320 // common driver check
14321
14322 if (device_param->skipped == 0)
14323 {
14324 if (device_type & CL_DEVICE_TYPE_GPU)
14325 {
14326 if (platform_vendor_id == VENDOR_ID_AMD)
14327 {
14328 int catalyst_check = (force == 1) ? 0 : 1;
14329
14330 int catalyst_warn = 0;
14331
14332 int catalyst_broken = 0;
14333
14334 if (catalyst_check == 1)
14335 {
14336 catalyst_warn = 1;
14337
14338 // v14.9 and higher
14339 if (atoi (device_param->driver_version) >= 1573)
14340 {
14341 catalyst_warn = 0;
14342 }
14343
14344 catalyst_check = 0;
14345 }
14346
14347 if (catalyst_broken == 1)
14348 {
14349 log_info ("");
14350 log_info ("ATTENTION! The Catalyst driver installed on your system is known to be broken!");
14351 log_info ("It passes over cracked hashes and will not report them as cracked");
14352 log_info ("You are STRONGLY encouraged not to use it");
14353 log_info ("You can use --force to override this but do not post error reports if you do so");
14354 log_info ("");
14355
14356 return (-1);
14357 }
14358
14359 if (catalyst_warn == 1)
14360 {
14361 log_info ("");
14362 log_info ("ATTENTION! Unsupported or incorrectly installed Catalyst driver detected!");
14363 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver");
14364 log_info ("See hashcat's homepage for official supported catalyst drivers");
14365 #ifdef _WIN
14366 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14367 #endif
14368 log_info ("You can use --force to override this but do not post error reports if you do so");
14369 log_info ("");
14370
14371 return (-1);
14372 }
14373 }
14374 else if (platform_vendor_id == VENDOR_ID_NV)
14375 {
14376 if (device_param->kernel_exec_timeout != 0)
14377 {
14378 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);
14379 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14380 }
14381 }
14382 }
14383
14384 /* turns out pocl still creates segfaults (because of llvm)
14385 if (device_type & CL_DEVICE_TYPE_CPU)
14386 {
14387 if (platform_vendor_id == VENDOR_ID_AMD)
14388 {
14389 if (force == 0)
14390 {
14391 log_info ("");
14392 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14393 log_info ("You are STRONGLY encouraged not to use it");
14394 log_info ("You can use --force to override this but do not post error reports if you do so");
14395 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14396 log_info ("");
14397
14398 return (-1);
14399 }
14400 }
14401 }
14402 */
14403
14404 /**
14405 * kernel accel and loops tuning db adjustment
14406 */
14407
14408 device_param->kernel_accel_min = 1;
14409 device_param->kernel_accel_max = 1024;
14410
14411 device_param->kernel_loops_min = 1;
14412 device_param->kernel_loops_max = 1024;
14413
14414 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14415
14416 if (tuningdb_entry)
14417 {
14418 u32 _kernel_accel = tuningdb_entry->kernel_accel;
14419 u32 _kernel_loops = tuningdb_entry->kernel_loops;
14420
14421 if (_kernel_accel)
14422 {
14423 device_param->kernel_accel_min = _kernel_accel;
14424 device_param->kernel_accel_max = _kernel_accel;
14425 }
14426
14427 if (_kernel_loops)
14428 {
14429 if (workload_profile == 1)
14430 {
14431 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14432 }
14433 else if (workload_profile == 2)
14434 {
14435 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14436 }
14437
14438 device_param->kernel_loops_min = _kernel_loops;
14439 device_param->kernel_loops_max = _kernel_loops;
14440 }
14441 }
14442
14443 // commandline parameters overwrite tuningdb entries
14444
14445 if (kernel_accel)
14446 {
14447 device_param->kernel_accel_min = kernel_accel;
14448 device_param->kernel_accel_max = kernel_accel;
14449 }
14450
14451 if (kernel_loops)
14452 {
14453 device_param->kernel_loops_min = kernel_loops;
14454 device_param->kernel_loops_max = kernel_loops;
14455 }
14456
14457 /**
14458 * activate device
14459 */
14460
14461 devices_active++;
14462 }
14463
14464 // next please
14465
14466 devices_cnt++;
14467 }
14468
14469 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14470 {
14471 if (machine_readable == 0)
14472 {
14473 log_info ("");
14474 }
14475 }
14476 }
14477
14478 if (keyspace == 0 && devices_active == 0)
14479 {
14480 log_error ("ERROR: No devices found/left");
14481
14482 return (-1);
14483 }
14484
14485 // 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)
14486
14487 if (devices_filter != (uint) -1)
14488 {
14489 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14490
14491 if (devices_filter > devices_cnt_mask)
14492 {
14493 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14494
14495 return (-1);
14496 }
14497 }
14498
14499 data.devices_cnt = devices_cnt;
14500
14501 data.devices_active = devices_active;
14502
14503 /**
14504 * HM devices: init
14505 */
14506
14507 #ifdef HAVE_HWMON
14508 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14509 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14510 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14511 hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX] = { { 0 } };
14512
14513 if (gpu_temp_disable == 0)
14514 {
14515 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14516 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14517 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14518 XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));
14519
14520 data.hm_adl = NULL;
14521 data.hm_nvapi = NULL;
14522 data.hm_nvml = NULL;
14523 data.hm_xnvctrl = NULL;
14524
14525 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14526 {
14527 data.hm_nvml = nvml;
14528 }
14529
14530 if (data.hm_nvml)
14531 {
14532 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14533 {
14534 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14535
14536 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14537
14538 int tmp_out = 0;
14539
14540 for (int i = 0; i < tmp_in; i++)
14541 {
14542 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14543 }
14544
14545 for (int i = 0; i < tmp_out; i++)
14546 {
14547 unsigned int speed;
14548
14549 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14550
14551 // doesn't seem to create any advantages
14552 //hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14553 //hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14554 }
14555 }
14556 }
14557
14558 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14559 {
14560 data.hm_nvapi = nvapi;
14561 }
14562
14563 if (data.hm_nvapi)
14564 {
14565 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14566 {
14567 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14568
14569 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14570
14571 int tmp_out = 0;
14572
14573 for (int i = 0; i < tmp_in; i++)
14574 {
14575 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14576 }
14577 }
14578 }
14579
14580 if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0))
14581 {
14582 data.hm_xnvctrl = xnvctrl;
14583 }
14584
14585 if (data.hm_xnvctrl)
14586 {
14587 if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
14588 {
14589 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14590 {
14591 hc_device_param_t *device_param = &data.devices_param[device_id];
14592
14593 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14594
14595 hm_adapters_xnvctrl[device_id].xnvctrl = device_id;
14596
14597 int speed = 0;
14598
14599 if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
14600 }
14601 }
14602 }
14603
14604 if ((need_adl == 1) && (adl_init (adl) == 0))
14605 {
14606 data.hm_adl = adl;
14607 }
14608
14609 if (data.hm_adl)
14610 {
14611 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14612 {
14613 // total number of adapters
14614
14615 int hm_adapters_num;
14616
14617 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14618
14619 // adapter info
14620
14621 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14622
14623 if (lpAdapterInfo == NULL) return (-1);
14624
14625 // get a list (of ids of) valid/usable adapters
14626
14627 int num_adl_adapters = 0;
14628
14629 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14630
14631 if (num_adl_adapters > 0)
14632 {
14633 hc_thread_mutex_lock (mux_adl);
14634
14635 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14636
14637 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14638
14639 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14640 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14641
14642 hc_thread_mutex_unlock (mux_adl);
14643 }
14644
14645 myfree (valid_adl_device_list);
14646 myfree (lpAdapterInfo);
14647 }
14648 }
14649
14650 if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14651 {
14652 gpu_temp_disable = 1;
14653 }
14654 }
14655
14656 /**
14657 * OpenCL devices: allocate buffer for device specific information
14658 */
14659
14660 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14661
14662 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14663
14664 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14665
14666 /**
14667 * User-defined GPU temp handling
14668 */
14669
14670 if (gpu_temp_disable == 1)
14671 {
14672 gpu_temp_abort = 0;
14673 gpu_temp_retain = 0;
14674 }
14675
14676 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14677 {
14678 if (gpu_temp_abort < gpu_temp_retain)
14679 {
14680 log_error ("ERROR: Invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14681
14682 return (-1);
14683 }
14684 }
14685
14686 data.gpu_temp_disable = gpu_temp_disable;
14687 data.gpu_temp_abort = gpu_temp_abort;
14688 data.gpu_temp_retain = gpu_temp_retain;
14689 #endif
14690
14691 /**
14692 * enable custom signal handler(s)
14693 */
14694
14695 if (benchmark == 0)
14696 {
14697 hc_signal (sigHandler_default);
14698 }
14699 else
14700 {
14701 hc_signal (sigHandler_benchmark);
14702 }
14703
14704 /**
14705 * inform the user
14706 */
14707
14708 if (data.quiet == 0)
14709 {
14710 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14711
14712 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);
14713
14714 if (attack_mode == ATTACK_MODE_STRAIGHT)
14715 {
14716 log_info ("Rules: %u", kernel_rules_cnt);
14717 }
14718
14719 if (opti_type)
14720 {
14721 log_info ("Applicable Optimizers:");
14722
14723 for (uint i = 0; i < 32; i++)
14724 {
14725 const uint opti_bit = 1u << i;
14726
14727 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14728 }
14729 }
14730
14731 /**
14732 * Watchdog and Temperature balance
14733 */
14734
14735 #ifdef HAVE_HWMON
14736 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14737 {
14738 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14739 }
14740
14741 if (gpu_temp_abort == 0)
14742 {
14743 log_info ("Watchdog: Temperature abort trigger disabled");
14744 }
14745 else
14746 {
14747 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14748 }
14749
14750 if (gpu_temp_retain == 0)
14751 {
14752 log_info ("Watchdog: Temperature retain trigger disabled");
14753 }
14754 else
14755 {
14756 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14757 }
14758
14759 if (data.quiet == 0) log_info ("");
14760 #endif
14761 }
14762
14763 #ifdef HAVE_HWMON
14764
14765 /**
14766 * HM devices: copy
14767 */
14768
14769 if (gpu_temp_disable == 0)
14770 {
14771 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14772 {
14773 hc_device_param_t *device_param = &data.devices_param[device_id];
14774
14775 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14776
14777 if (device_param->skipped) continue;
14778
14779 const uint platform_devices_id = device_param->platform_devices_id;
14780
14781 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14782 {
14783 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14784 data.hm_device[device_id].nvapi = 0;
14785 data.hm_device[device_id].nvml = 0;
14786 data.hm_device[device_id].xnvctrl = 0;
14787 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14788 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14789 data.hm_device[device_id].fan_set_supported = 0;
14790 }
14791
14792 if (device_param->device_vendor_id == VENDOR_ID_NV)
14793 {
14794 data.hm_device[device_id].adl = 0;
14795 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14796 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14797 data.hm_device[device_id].xnvctrl = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
14798 data.hm_device[device_id].od_version = 0;
14799 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14800 data.hm_device[device_id].fan_set_supported = 0;
14801 }
14802 }
14803 }
14804
14805 /**
14806 * powertune on user request
14807 */
14808
14809 if (powertune_enable == 1)
14810 {
14811 hc_thread_mutex_lock (mux_adl);
14812
14813 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14814 {
14815 hc_device_param_t *device_param = &data.devices_param[device_id];
14816
14817 if (device_param->skipped) continue;
14818
14819 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14820 {
14821 /**
14822 * Temporary fix:
14823 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14824 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14825 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14826 * Driver / ADL bug?
14827 */
14828
14829 if (data.hm_device[device_id].od_version == 6)
14830 {
14831 int ADL_rc;
14832
14833 // check powertune capabilities first, if not available then skip device
14834
14835 int powertune_supported = 0;
14836
14837 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14838 {
14839 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14840
14841 return (-1);
14842 }
14843
14844 // first backup current value, we will restore it later
14845
14846 if (powertune_supported != 0)
14847 {
14848 // powercontrol settings
14849
14850 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14851
14852 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14853 {
14854 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14855 }
14856
14857 if (ADL_rc != ADL_OK)
14858 {
14859 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14860
14861 return (-1);
14862 }
14863
14864 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14865 {
14866 log_error ("ERROR: Failed to set new ADL PowerControl values");
14867
14868 return (-1);
14869 }
14870
14871 // clocks
14872
14873 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14874
14875 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14876
14877 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)
14878 {
14879 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14880
14881 return (-1);
14882 }
14883
14884 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14885
14886 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14887
14888 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14889 {
14890 log_error ("ERROR: Failed to get ADL device capabilities");
14891
14892 return (-1);
14893 }
14894
14895 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14896 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14897
14898 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14899 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14900
14901 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14902 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14903
14904 // warning if profile has too low max values
14905
14906 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14907 {
14908 log_info ("WARN: The custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14909 }
14910
14911 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14912 {
14913 log_info ("WARN: The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14914 }
14915
14916 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14917
14918 performance_state->iNumberOfPerformanceLevels = 2;
14919
14920 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14921 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14922 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14923 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14924
14925 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)
14926 {
14927 log_info ("ERROR: Failed to set ADL performance state");
14928
14929 return (-1);
14930 }
14931
14932 local_free (performance_state);
14933 }
14934
14935 // set powertune value only
14936
14937 if (powertune_supported != 0)
14938 {
14939 // powertune set
14940 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14941
14942 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14943 {
14944 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14945
14946 return (-1);
14947 }
14948
14949 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14950 {
14951 log_error ("ERROR: Failed to set new ADL PowerControl values");
14952
14953 return (-1);
14954 }
14955 }
14956 }
14957 }
14958
14959 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14960 {
14961 // first backup current value, we will restore it later
14962
14963 unsigned int limit;
14964
14965 int powertune_supported = 0;
14966
14967 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14968 {
14969 powertune_supported = 1;
14970 }
14971
14972 // if backup worked, activate the maximum allowed
14973
14974 if (powertune_supported != 0)
14975 {
14976 unsigned int minLimit;
14977 unsigned int maxLimit;
14978
14979 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14980 {
14981 if (maxLimit > 0)
14982 {
14983 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14984 {
14985 // now we can be sure we need to reset later
14986
14987 nvml_power_limit[device_id] = limit;
14988 }
14989 }
14990 }
14991 }
14992 }
14993 }
14994
14995 hc_thread_mutex_unlock (mux_adl);
14996 }
14997
14998 #endif // HAVE_HWMON
14999
15000 #ifdef DEBUG
15001 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
15002 #endif
15003
15004 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
15005
15006 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15007 {
15008 /**
15009 * host buffer
15010 */
15011
15012 hc_device_param_t *device_param = &data.devices_param[device_id];
15013
15014 if (device_param->skipped) continue;
15015
15016 /**
15017 * device properties
15018 */
15019
15020 const char *device_name_chksum = device_param->device_name_chksum;
15021 const u32 device_processors = device_param->device_processors;
15022 const u32 device_processor_cores = device_param->device_processor_cores;
15023
15024 /**
15025 * create context for each device
15026 */
15027
15028 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
15029
15030 /**
15031 * create command-queue
15032 */
15033
15034 // not supported with NV
15035 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
15036
15037 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
15038
15039 /**
15040 * kernel threads: some algorithms need a fixed kernel-threads count
15041 * because of shared memory usage or bitslice
15042 * there needs to be some upper limit, otherwise there's too much overhead
15043 */
15044
15045 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
15046
15047 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
15048 {
15049 kernel_threads = KERNEL_THREADS_MAX_CPU;
15050 }
15051
15052 if (hash_mode == 1500) kernel_threads = 64; // DES
15053 if (hash_mode == 3000) kernel_threads = 64; // DES
15054 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
15055 if (hash_mode == 7500) kernel_threads = 64; // RC4
15056 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
15057 if (hash_mode == 9700) kernel_threads = 64; // RC4
15058 if (hash_mode == 9710) kernel_threads = 64; // RC4
15059 if (hash_mode == 9800) kernel_threads = 64; // RC4
15060 if (hash_mode == 9810) kernel_threads = 64; // RC4
15061 if (hash_mode == 10400) kernel_threads = 64; // RC4
15062 if (hash_mode == 10410) kernel_threads = 64; // RC4
15063 if (hash_mode == 10500) kernel_threads = 64; // RC4
15064 if (hash_mode == 13100) kernel_threads = 64; // RC4
15065
15066 device_param->kernel_threads = kernel_threads;
15067
15068 device_param->hardware_power = device_processors * kernel_threads;
15069
15070 /**
15071 * create input buffers on device : calculate size of fixed memory buffers
15072 */
15073
15074 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
15075 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
15076
15077 device_param->size_root_css = size_root_css;
15078 device_param->size_markov_css = size_markov_css;
15079
15080 size_t size_results = sizeof (uint);
15081
15082 device_param->size_results = size_results;
15083
15084 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
15085 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
15086
15087 size_t size_plains = digests_cnt * sizeof (plain_t);
15088 size_t size_salts = salts_cnt * sizeof (salt_t);
15089 size_t size_esalts = salts_cnt * esalt_size;
15090
15091 device_param->size_plains = size_plains;
15092 device_param->size_digests = size_digests;
15093 device_param->size_shown = size_shown;
15094 device_param->size_salts = size_salts;
15095
15096 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
15097 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
15098 size_t size_tm = 32 * sizeof (bs_word_t);
15099
15100 // scryptV stuff
15101
15102 size_t size_scryptV = 1;
15103
15104 if ((hash_mode == 8900) || (hash_mode == 9300))
15105 {
15106 uint tmto_start = 0;
15107 uint tmto_stop = 10;
15108
15109 if (scrypt_tmto)
15110 {
15111 tmto_start = scrypt_tmto;
15112 }
15113 else
15114 {
15115 // in case the user did not specify the tmto manually
15116 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
15117 // but set the lower end only in case the user has a device with too less memory
15118
15119 if (hash_mode == 8900)
15120 {
15121 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15122 {
15123 tmto_start = 1;
15124 }
15125 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15126 {
15127 tmto_start = 2;
15128 }
15129 }
15130 else if (hash_mode == 9300)
15131 {
15132 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15133 {
15134 tmto_start = 2;
15135 }
15136 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15137 {
15138 tmto_start = 2;
15139 }
15140 }
15141 }
15142
15143 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
15144 {
15145 // TODO: in theory the following calculation needs to be done per salt, not global
15146 // we assume all hashes have the same scrypt settings
15147
15148 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
15149
15150 size_scryptV /= 1 << tmto;
15151
15152 size_scryptV *= device_processors * device_processor_cores;
15153
15154 if (size_scryptV > device_param->device_maxmem_alloc)
15155 {
15156 if (quiet == 0) log_info ("WARNING: Not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15157
15158 continue;
15159 }
15160
15161 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
15162 {
15163 data.salts_buf[salts_pos].scrypt_tmto = tmto;
15164 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
15165 }
15166
15167 break;
15168 }
15169
15170 if (data.salts_buf[0].scrypt_phy == 0)
15171 {
15172 log_error ("ERROR: Can't allocate enough device memory");
15173
15174 return -1;
15175 }
15176
15177 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
15178 }
15179
15180 /**
15181 * some algorithms need a fixed kernel-loops count
15182 */
15183
15184 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15185 {
15186 const u32 kernel_loops_fixed = 1024;
15187
15188 device_param->kernel_loops_min = kernel_loops_fixed;
15189 device_param->kernel_loops_max = kernel_loops_fixed;
15190 }
15191
15192 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15193 {
15194 const u32 kernel_loops_fixed = 1024;
15195
15196 device_param->kernel_loops_min = kernel_loops_fixed;
15197 device_param->kernel_loops_max = kernel_loops_fixed;
15198 }
15199
15200 if (hash_mode == 8900)
15201 {
15202 const u32 kernel_loops_fixed = 1;
15203
15204 device_param->kernel_loops_min = kernel_loops_fixed;
15205 device_param->kernel_loops_max = kernel_loops_fixed;
15206 }
15207
15208 if (hash_mode == 9300)
15209 {
15210 const u32 kernel_loops_fixed = 1;
15211
15212 device_param->kernel_loops_min = kernel_loops_fixed;
15213 device_param->kernel_loops_max = kernel_loops_fixed;
15214 }
15215
15216 if (hash_mode == 12500)
15217 {
15218 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15219
15220 device_param->kernel_loops_min = kernel_loops_fixed;
15221 device_param->kernel_loops_max = kernel_loops_fixed;
15222 }
15223
15224 /**
15225 * some algorithms have a maximum kernel-loops count
15226 */
15227
15228 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15229 {
15230 u32 innerloop_cnt = 0;
15231
15232 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15233 {
15234 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15235 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15236 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15237 }
15238 else
15239 {
15240 innerloop_cnt = data.salts_buf[0].salt_iter;
15241 }
15242
15243 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15244 (innerloop_cnt <= device_param->kernel_loops_max))
15245 {
15246 device_param->kernel_loops_max = innerloop_cnt;
15247 }
15248 }
15249
15250 u32 kernel_accel_min = device_param->kernel_accel_min;
15251 u32 kernel_accel_max = device_param->kernel_accel_max;
15252
15253 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15254
15255 size_t size_pws = 4;
15256 size_t size_tmps = 4;
15257 size_t size_hooks = 4;
15258
15259 while (kernel_accel_max >= kernel_accel_min)
15260 {
15261 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15262
15263 // size_pws
15264
15265 size_pws = kernel_power_max * sizeof (pw_t);
15266
15267 // size_tmps
15268
15269 switch (hash_mode)
15270 {
15271 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15272 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15273 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15274 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15275 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15276 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15277 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15278 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15279 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15280 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15281 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15282 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15283 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15284 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15285 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15286 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15287 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15288 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15289 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15290 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15291 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15292 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15293 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15294 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
15295 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
15296 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
15297 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
15298 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
15299 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15300 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15301 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
15302 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
15303 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15304 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
15305 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15306 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
15307 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
15308 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15309 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15310 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
15311 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
15312 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
15313 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15314 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
15315 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
15316 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
15317 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
15318 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15319 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
15320 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
15321 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
15322 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15323 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15324 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
15325 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
15326 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
15327 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
15328 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
15329 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15330 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15331 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15332 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
15333 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
15334 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15335 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15336 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15337 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15338 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15339 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15340 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15341 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15342 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15343 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15344 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15345 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15346 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15347 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15348 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15349 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15350 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15351 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15352 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15353 };
15354
15355 // size_hooks
15356
15357 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15358 {
15359 switch (hash_mode)
15360 {
15361 }
15362 }
15363
15364 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15365 // if not, decrease amplifier and try again
15366
15367 int memory_limit_hit = 0;
15368
15369 if (size_pws > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15370 if (size_tmps > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15371 if (size_hooks > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15372
15373 const u64 size_total
15374 = bitmap_size
15375 + bitmap_size
15376 + bitmap_size
15377 + bitmap_size
15378 + bitmap_size
15379 + bitmap_size
15380 + bitmap_size
15381 + bitmap_size
15382 + size_bfs
15383 + size_combs
15384 + size_digests
15385 + size_esalts
15386 + size_hooks
15387 + size_markov_css
15388 + size_plains
15389 + size_pws
15390 + size_pws // not a bug
15391 + size_results
15392 + size_root_css
15393 + size_rules
15394 + size_rules_c
15395 + size_salts
15396 + size_scryptV
15397 + size_shown
15398 + size_tm
15399 + size_tmps;
15400
15401 if (size_total > device_param->device_global_mem) memory_limit_hit = 1;
15402
15403 if (memory_limit_hit == 1)
15404 {
15405 kernel_accel_max--;
15406
15407 continue;
15408 }
15409
15410 break;
15411 }
15412
15413 if (kernel_accel_max < kernel_accel_min)
15414 {
15415 log_error ("- Device #%u: Device does not provide enough allocatable device-memory to handle this attack", device_id + 1);
15416
15417 return -1;
15418 }
15419
15420 device_param->kernel_accel_min = kernel_accel_min;
15421 device_param->kernel_accel_max = kernel_accel_max;
15422
15423 /*
15424 if (kernel_accel_max < kernel_accel)
15425 {
15426 if (quiet == 0) log_info ("- Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
15427
15428 device_param->kernel_accel = kernel_accel_max;
15429 }
15430 */
15431
15432 device_param->size_bfs = size_bfs;
15433 device_param->size_combs = size_combs;
15434 device_param->size_rules = size_rules;
15435 device_param->size_rules_c = size_rules_c;
15436 device_param->size_pws = size_pws;
15437 device_param->size_tmps = size_tmps;
15438 device_param->size_hooks = size_hooks;
15439
15440 /**
15441 * default building options
15442 */
15443
15444 char cpath[1024] = { 0 };
15445
15446 char build_opts[1024] = { 0 };
15447
15448 #if _WIN
15449
15450 snprintf (cpath, sizeof (cpath) - 1, "%s\\OpenCL\\", shared_dir);
15451
15452 char *cpath_real = mymalloc (MAX_PATH);
15453
15454 if (GetFullPathName (cpath, MAX_PATH, cpath_real, NULL) == 0)
15455 {
15456 log_error ("ERROR: %s: %s", cpath, "GetFullPathName()");
15457
15458 return -1;
15459 }
15460
15461 naive_replace (cpath_real, '\\', '/');
15462
15463 // not escaping here, windows has quotes
15464
15465 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\"", cpath_real);
15466
15467 myfree (cpath_real);
15468
15469 #else
15470
15471 snprintf (cpath, sizeof (cpath) - 1, "%s/OpenCL/", shared_dir);
15472
15473 char *cpath_real = mymalloc (PATH_MAX);
15474
15475 if (realpath (cpath, cpath_real) == NULL)
15476 {
15477 log_error ("ERROR: %s: %s", cpath, strerror (errno));
15478
15479 return -1;
15480 }
15481
15482 naive_escape (cpath_real, PATH_MAX, ' ', '\\');
15483
15484 snprintf (build_opts, sizeof (build_opts) - 1, "-I %s", cpath_real);
15485
15486 myfree (cpath_real);
15487
15488 #endif
15489
15490 // we don't have sm_* on vendors not NV but it doesn't matter
15491
15492 char build_opts_new[1024] = { 0 };
15493
15494 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);
15495
15496 strncpy (build_opts, build_opts_new, sizeof (build_opts));
15497
15498 #ifdef DEBUG
15499 log_info ("- Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15500 #endif
15501
15502 /**
15503 * main kernel
15504 */
15505
15506 {
15507 /**
15508 * kernel source filename
15509 */
15510
15511 char source_file[256] = { 0 };
15512
15513 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15514
15515 struct stat sst;
15516
15517 if (stat (source_file, &sst) == -1)
15518 {
15519 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15520
15521 return -1;
15522 }
15523
15524 /**
15525 * kernel cached filename
15526 */
15527
15528 char cached_file[256] = { 0 };
15529
15530 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15531
15532 int cached = 1;
15533
15534 struct stat cst;
15535
15536 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15537 {
15538 cached = 0;
15539 }
15540
15541 /**
15542 * kernel compile or load
15543 */
15544
15545 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15546
15547 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15548
15549 if (force_jit_compilation == -1)
15550 {
15551 if (cached == 0)
15552 {
15553 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));
15554
15555 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15556
15557 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15558
15559 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15560
15561 #ifdef DEBUG
15562 size_t build_log_size = 0;
15563
15564 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15565
15566 if (build_log_size > 1)
15567 {
15568 char *build_log = (char *) malloc (build_log_size + 1);
15569
15570 memset (build_log, 0, build_log_size + 1);
15571
15572 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15573
15574 puts (build_log);
15575
15576 free (build_log);
15577 }
15578 #endif
15579
15580 if (rc != 0)
15581 {
15582 device_param->skipped = true;
15583
15584 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15585
15586 continue;
15587 }
15588
15589 size_t binary_size;
15590
15591 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15592
15593 u8 *binary = (u8 *) mymalloc (binary_size);
15594
15595 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15596
15597 writeProgramBin (cached_file, binary, binary_size);
15598
15599 local_free (binary);
15600 }
15601 else
15602 {
15603 #ifdef DEBUG
15604 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15605 #endif
15606
15607 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15608
15609 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15610
15611 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15612 }
15613 }
15614 else
15615 {
15616 #ifdef DEBUG
15617 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15618 #endif
15619
15620 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15621
15622 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15623
15624 char build_opts_update[1024] = { 0 };
15625
15626 if (force_jit_compilation == 1500)
15627 {
15628 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15629 }
15630 else if (force_jit_compilation == 8900)
15631 {
15632 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);
15633 }
15634 else
15635 {
15636 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15637 }
15638
15639 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15640
15641 #ifdef DEBUG
15642 size_t build_log_size = 0;
15643
15644 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15645
15646 if (build_log_size > 1)
15647 {
15648 char *build_log = (char *) malloc (build_log_size + 1);
15649
15650 memset (build_log, 0, build_log_size + 1);
15651
15652 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15653
15654 puts (build_log);
15655
15656 free (build_log);
15657 }
15658 #endif
15659
15660 if (rc != 0)
15661 {
15662 device_param->skipped = true;
15663
15664 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15665 }
15666 }
15667
15668 local_free (kernel_lengths);
15669 local_free (kernel_sources[0]);
15670 local_free (kernel_sources);
15671 }
15672
15673 /**
15674 * word generator kernel
15675 */
15676
15677 if (attack_mode != ATTACK_MODE_STRAIGHT)
15678 {
15679 /**
15680 * kernel mp source filename
15681 */
15682
15683 char source_file[256] = { 0 };
15684
15685 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15686
15687 struct stat sst;
15688
15689 if (stat (source_file, &sst) == -1)
15690 {
15691 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15692
15693 return -1;
15694 }
15695
15696 /**
15697 * kernel mp cached filename
15698 */
15699
15700 char cached_file[256] = { 0 };
15701
15702 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15703
15704 int cached = 1;
15705
15706 struct stat cst;
15707
15708 if (stat (cached_file, &cst) == -1)
15709 {
15710 cached = 0;
15711 }
15712
15713 /**
15714 * kernel compile or load
15715 */
15716
15717 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15718
15719 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15720
15721 if (cached == 0)
15722 {
15723 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));
15724 if (quiet == 0) log_info ("");
15725
15726 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15727
15728 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15729
15730 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15731
15732 if (rc != 0)
15733 {
15734 device_param->skipped = true;
15735
15736 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15737
15738 continue;
15739 }
15740
15741 size_t binary_size;
15742
15743 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15744
15745 u8 *binary = (u8 *) mymalloc (binary_size);
15746
15747 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15748
15749 writeProgramBin (cached_file, binary, binary_size);
15750
15751 local_free (binary);
15752 }
15753 else
15754 {
15755 #ifdef DEBUG
15756 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15757 #endif
15758
15759 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15760
15761 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15762
15763 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15764 }
15765
15766 local_free (kernel_lengths);
15767 local_free (kernel_sources[0]);
15768 local_free (kernel_sources);
15769 }
15770
15771 /**
15772 * amplifier kernel
15773 */
15774
15775 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15776 {
15777
15778 }
15779 else
15780 {
15781 /**
15782 * kernel amp source filename
15783 */
15784
15785 char source_file[256] = { 0 };
15786
15787 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15788
15789 struct stat sst;
15790
15791 if (stat (source_file, &sst) == -1)
15792 {
15793 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15794
15795 return -1;
15796 }
15797
15798 /**
15799 * kernel amp cached filename
15800 */
15801
15802 char cached_file[256] = { 0 };
15803
15804 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15805
15806 int cached = 1;
15807
15808 struct stat cst;
15809
15810 if (stat (cached_file, &cst) == -1)
15811 {
15812 cached = 0;
15813 }
15814
15815 /**
15816 * kernel compile or load
15817 */
15818
15819 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15820
15821 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15822
15823 if (cached == 0)
15824 {
15825 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));
15826 if (quiet == 0) log_info ("");
15827
15828 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15829
15830 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15831
15832 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15833
15834 if (rc != 0)
15835 {
15836 device_param->skipped = true;
15837
15838 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15839
15840 continue;
15841 }
15842
15843 size_t binary_size;
15844
15845 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15846
15847 u8 *binary = (u8 *) mymalloc (binary_size);
15848
15849 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15850
15851 writeProgramBin (cached_file, binary, binary_size);
15852
15853 local_free (binary);
15854 }
15855 else
15856 {
15857 #ifdef DEBUG
15858 if (quiet == 0) log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15859 #endif
15860
15861 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15862
15863 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15864
15865 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15866 }
15867
15868 local_free (kernel_lengths);
15869 local_free (kernel_sources[0]);
15870 local_free (kernel_sources);
15871 }
15872
15873 // some algorithm collide too fast, make that impossible
15874
15875 if (benchmark == 1)
15876 {
15877 ((uint *) digests_buf)[0] = -1;
15878 ((uint *) digests_buf)[1] = -1;
15879 ((uint *) digests_buf)[2] = -1;
15880 ((uint *) digests_buf)[3] = -1;
15881 }
15882
15883 /**
15884 * global buffers
15885 */
15886
15887 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15888 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15889 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15890 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15891 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15892 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15893 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15894 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15895 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15896 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15897 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15898 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15899 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15900 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15901 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15902 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15903 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15904 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15905
15906 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);
15907 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);
15908 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);
15909 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);
15910 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);
15911 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);
15912 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);
15913 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);
15914 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15915 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15916 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15917
15918 /**
15919 * special buffers
15920 */
15921
15922 if (attack_kern == ATTACK_KERN_STRAIGHT)
15923 {
15924 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15925 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15926
15927 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15928 }
15929 else if (attack_kern == ATTACK_KERN_COMBI)
15930 {
15931 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15932 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15933 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15934 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15935 }
15936 else if (attack_kern == ATTACK_KERN_BF)
15937 {
15938 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15939 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15940 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15941 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15942 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15943 }
15944
15945 if (size_esalts)
15946 {
15947 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15948
15949 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15950 }
15951
15952 /**
15953 * main host data
15954 */
15955
15956 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15957
15958 device_param->pws_buf = pws_buf;
15959
15960 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15961
15962 device_param->combs_buf = combs_buf;
15963
15964 void *hooks_buf = mymalloc (size_hooks);
15965
15966 device_param->hooks_buf = hooks_buf;
15967
15968 /**
15969 * kernel args
15970 */
15971
15972 device_param->kernel_params_buf32[21] = bitmap_mask;
15973 device_param->kernel_params_buf32[22] = bitmap_shift1;
15974 device_param->kernel_params_buf32[23] = bitmap_shift2;
15975 device_param->kernel_params_buf32[24] = 0; // salt_pos
15976 device_param->kernel_params_buf32[25] = 0; // loop_pos
15977 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15978 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15979 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15980 device_param->kernel_params_buf32[29] = 0; // digests_offset
15981 device_param->kernel_params_buf32[30] = 0; // combs_mode
15982 device_param->kernel_params_buf32[31] = 0; // gid_max
15983
15984 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15985 ? &device_param->d_pws_buf
15986 : &device_param->d_pws_amp_buf;
15987 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15988 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15989 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15990 device_param->kernel_params[ 4] = &device_param->d_tmps;
15991 device_param->kernel_params[ 5] = &device_param->d_hooks;
15992 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15993 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15994 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15995 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15996 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15997 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15998 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15999 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
16000 device_param->kernel_params[14] = &device_param->d_plain_bufs;
16001 device_param->kernel_params[15] = &device_param->d_digests_buf;
16002 device_param->kernel_params[16] = &device_param->d_digests_shown;
16003 device_param->kernel_params[17] = &device_param->d_salt_bufs;
16004 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
16005 device_param->kernel_params[19] = &device_param->d_result;
16006 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
16007 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
16008 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
16009 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
16010 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
16011 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
16012 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
16013 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
16014 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
16015 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
16016 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
16017 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
16018
16019 device_param->kernel_params_mp_buf64[3] = 0;
16020 device_param->kernel_params_mp_buf32[4] = 0;
16021 device_param->kernel_params_mp_buf32[5] = 0;
16022 device_param->kernel_params_mp_buf32[6] = 0;
16023 device_param->kernel_params_mp_buf32[7] = 0;
16024 device_param->kernel_params_mp_buf32[8] = 0;
16025
16026 device_param->kernel_params_mp[0] = NULL;
16027 device_param->kernel_params_mp[1] = NULL;
16028 device_param->kernel_params_mp[2] = NULL;
16029 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
16030 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
16031 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
16032 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
16033 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
16034 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
16035
16036 device_param->kernel_params_mp_l_buf64[3] = 0;
16037 device_param->kernel_params_mp_l_buf32[4] = 0;
16038 device_param->kernel_params_mp_l_buf32[5] = 0;
16039 device_param->kernel_params_mp_l_buf32[6] = 0;
16040 device_param->kernel_params_mp_l_buf32[7] = 0;
16041 device_param->kernel_params_mp_l_buf32[8] = 0;
16042 device_param->kernel_params_mp_l_buf32[9] = 0;
16043
16044 device_param->kernel_params_mp_l[0] = NULL;
16045 device_param->kernel_params_mp_l[1] = NULL;
16046 device_param->kernel_params_mp_l[2] = NULL;
16047 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
16048 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
16049 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
16050 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
16051 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
16052 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
16053 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
16054
16055 device_param->kernel_params_mp_r_buf64[3] = 0;
16056 device_param->kernel_params_mp_r_buf32[4] = 0;
16057 device_param->kernel_params_mp_r_buf32[5] = 0;
16058 device_param->kernel_params_mp_r_buf32[6] = 0;
16059 device_param->kernel_params_mp_r_buf32[7] = 0;
16060 device_param->kernel_params_mp_r_buf32[8] = 0;
16061
16062 device_param->kernel_params_mp_r[0] = NULL;
16063 device_param->kernel_params_mp_r[1] = NULL;
16064 device_param->kernel_params_mp_r[2] = NULL;
16065 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
16066 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
16067 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
16068 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
16069 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
16070 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
16071
16072 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
16073 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
16074
16075 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
16076 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
16077 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
16078 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
16079 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
16080 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
16081 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
16082
16083 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
16084 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
16085
16086 device_param->kernel_params_memset_buf32[1] = 0; // value
16087 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
16088
16089 device_param->kernel_params_memset[0] = NULL;
16090 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
16091 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
16092
16093 /**
16094 * kernel name
16095 */
16096
16097 size_t kernel_wgs_tmp;
16098
16099 char kernel_name[64] = { 0 };
16100
16101 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16102 {
16103 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16104 {
16105 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
16106
16107 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16108
16109 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
16110
16111 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16112
16113 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
16114
16115 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16116 }
16117 else
16118 {
16119 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
16120
16121 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16122
16123 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
16124
16125 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16126
16127 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
16128
16129 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16130 }
16131
16132 if (data.attack_mode == ATTACK_MODE_BF)
16133 {
16134 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16135 {
16136 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
16137
16138 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16139
16140 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);
16141 }
16142 }
16143 }
16144 else
16145 {
16146 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
16147
16148 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16149
16150 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
16151
16152 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16153
16154 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
16155
16156 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16157
16158 if (opts_type & OPTS_TYPE_HOOK12)
16159 {
16160 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
16161
16162 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16163
16164 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);
16165 }
16166
16167 if (opts_type & OPTS_TYPE_HOOK23)
16168 {
16169 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
16170
16171 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16172
16173 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);
16174 }
16175 }
16176
16177 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);
16178 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);
16179 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);
16180
16181 for (uint i = 0; i <= 20; i++)
16182 {
16183 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
16184 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
16185 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
16186
16187 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
16188 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
16189 }
16190
16191 for (uint i = 21; i <= 31; i++)
16192 {
16193 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
16194 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
16195 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
16196
16197 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
16198 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
16199 }
16200
16201 // GPU memset
16202
16203 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
16204
16205 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);
16206
16207 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
16208 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
16209 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
16210
16211 // MP start
16212
16213 if (attack_mode == ATTACK_MODE_BF)
16214 {
16215 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
16216 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
16217
16218 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);
16219 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);
16220
16221 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16222 {
16223 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
16224 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
16225 }
16226 }
16227 else if (attack_mode == ATTACK_MODE_HYBRID1)
16228 {
16229 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16230
16231 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);
16232 }
16233 else if (attack_mode == ATTACK_MODE_HYBRID2)
16234 {
16235 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16236
16237 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);
16238 }
16239
16240 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16241 {
16242 // nothing to do
16243 }
16244 else
16245 {
16246 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
16247
16248 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);
16249 }
16250
16251 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16252 {
16253 // nothing to do
16254 }
16255 else
16256 {
16257 for (uint i = 0; i < 5; i++)
16258 {
16259 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
16260 }
16261
16262 for (uint i = 5; i < 7; i++)
16263 {
16264 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
16265 }
16266 }
16267
16268 // maybe this has been updated by clGetKernelWorkGroupInfo()
16269 // value can only be decreased, so we don't need to reallocate buffers
16270
16271 device_param->kernel_threads = kernel_threads;
16272
16273 // zero some data buffers
16274
16275 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
16276 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
16277 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
16278 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
16279 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
16280 run_kernel_bzero (device_param, device_param->d_result, size_results);
16281
16282 /**
16283 * special buffers
16284 */
16285
16286 if (attack_kern == ATTACK_KERN_STRAIGHT)
16287 {
16288 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
16289 }
16290 else if (attack_kern == ATTACK_KERN_COMBI)
16291 {
16292 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
16293 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
16294 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16295 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16296 }
16297 else if (attack_kern == ATTACK_KERN_BF)
16298 {
16299 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
16300 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
16301 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
16302 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16303 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16304 }
16305
16306 #if defined(HAVE_HWMON)
16307
16308 /**
16309 * Store initial fanspeed if gpu_temp_retain is enabled
16310 */
16311
16312 if (gpu_temp_disable == 0)
16313 {
16314 if (gpu_temp_retain != 0)
16315 {
16316 hc_thread_mutex_lock (mux_adl);
16317
16318 if (data.hm_device[device_id].fan_get_supported == 1)
16319 {
16320 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
16321 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
16322
16323 // we also set it to tell the OS we take control over the fan and it's automatic controller
16324 // if it was set to automatic. we do not control user-defined fanspeeds.
16325
16326 if (fanpolicy == 1)
16327 {
16328 data.hm_device[device_id].fan_set_supported = 1;
16329
16330 int rc = -1;
16331
16332 if (device_param->device_vendor_id == VENDOR_ID_AMD)
16333 {
16334 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
16335 }
16336 else if (device_param->device_vendor_id == VENDOR_ID_NV)
16337 {
16338 #ifdef LINUX
16339 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE);
16340 #endif
16341
16342 #ifdef WIN
16343 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
16344 #endif
16345 }
16346
16347 if (rc == 0)
16348 {
16349 data.hm_device[device_id].fan_set_supported = 1;
16350 }
16351 else
16352 {
16353 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
16354
16355 data.hm_device[device_id].fan_set_supported = 0;
16356 }
16357 }
16358 else
16359 {
16360 data.hm_device[device_id].fan_set_supported = 0;
16361 }
16362 }
16363
16364 hc_thread_mutex_unlock (mux_adl);
16365 }
16366 }
16367
16368 #endif // HAVE_HWMON
16369 }
16370
16371 if (data.quiet == 0) log_info_nn ("");
16372
16373 /**
16374 * In benchmark-mode, inform user which algorithm is checked
16375 */
16376
16377 if (benchmark == 1)
16378 {
16379 if (machine_readable == 0)
16380 {
16381 quiet = 0;
16382
16383 data.quiet = quiet;
16384
16385 char *hash_type = strhashtype (data.hash_mode); // not a bug
16386
16387 log_info ("Hashtype: %s", hash_type);
16388 log_info ("");
16389 }
16390 }
16391
16392 /**
16393 * keep track of the progress
16394 */
16395
16396 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16397 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16398 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16399
16400 /**
16401 * open filehandles
16402 */
16403
16404 #if _WIN
16405 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
16406 {
16407 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
16408
16409 return (-1);
16410 }
16411
16412 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
16413 {
16414 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
16415
16416 return (-1);
16417 }
16418
16419 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
16420 {
16421 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
16422
16423 return (-1);
16424 }
16425 #endif
16426
16427 /**
16428 * dictionary pad
16429 */
16430
16431 segment_size *= (1024 * 1024);
16432
16433 data.segment_size = segment_size;
16434
16435 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
16436
16437 wl_data->buf = (char *) mymalloc (segment_size);
16438 wl_data->avail = segment_size;
16439 wl_data->incr = segment_size;
16440 wl_data->cnt = 0;
16441 wl_data->pos = 0;
16442
16443 cs_t *css_buf = NULL;
16444 uint css_cnt = 0;
16445 uint dictcnt = 0;
16446 uint maskcnt = 1;
16447 char **masks = NULL;
16448 char **dictfiles = NULL;
16449
16450 uint mask_from_file = 0;
16451
16452 if (attack_mode == ATTACK_MODE_STRAIGHT)
16453 {
16454 if (wordlist_mode == WL_MODE_FILE)
16455 {
16456 int wls_left = myargc - (optind + 1);
16457
16458 for (int i = 0; i < wls_left; i++)
16459 {
16460 char *l0_filename = myargv[optind + 1 + i];
16461
16462 struct stat l0_stat;
16463
16464 if (stat (l0_filename, &l0_stat) == -1)
16465 {
16466 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
16467
16468 return (-1);
16469 }
16470
16471 uint is_dir = S_ISDIR (l0_stat.st_mode);
16472
16473 if (is_dir == 0)
16474 {
16475 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16476
16477 dictcnt++;
16478
16479 dictfiles[dictcnt - 1] = l0_filename;
16480 }
16481 else
16482 {
16483 // do not allow --keyspace w/ a directory
16484
16485 if (keyspace == 1)
16486 {
16487 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16488
16489 return (-1);
16490 }
16491
16492 char **dictionary_files = NULL;
16493
16494 dictionary_files = scan_directory (l0_filename);
16495
16496 if (dictionary_files != NULL)
16497 {
16498 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16499
16500 for (int d = 0; dictionary_files[d] != NULL; d++)
16501 {
16502 char *l1_filename = dictionary_files[d];
16503
16504 struct stat l1_stat;
16505
16506 if (stat (l1_filename, &l1_stat) == -1)
16507 {
16508 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16509
16510 return (-1);
16511 }
16512
16513 if (S_ISREG (l1_stat.st_mode))
16514 {
16515 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16516
16517 dictcnt++;
16518
16519 dictfiles[dictcnt - 1] = strdup (l1_filename);
16520 }
16521 }
16522 }
16523
16524 local_free (dictionary_files);
16525 }
16526 }
16527
16528 if (dictcnt < 1)
16529 {
16530 log_error ("ERROR: No usable dictionary file found.");
16531
16532 return (-1);
16533 }
16534 }
16535 else if (wordlist_mode == WL_MODE_STDIN)
16536 {
16537 dictcnt = 1;
16538 }
16539 }
16540 else if (attack_mode == ATTACK_MODE_COMBI)
16541 {
16542 // display
16543
16544 char *dictfile1 = myargv[optind + 1 + 0];
16545 char *dictfile2 = myargv[optind + 1 + 1];
16546
16547 // find the bigger dictionary and use as base
16548
16549 FILE *fp1 = NULL;
16550 FILE *fp2 = NULL;
16551
16552 struct stat tmp_stat;
16553
16554 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16555 {
16556 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16557
16558 return (-1);
16559 }
16560
16561 if (stat (dictfile1, &tmp_stat) == -1)
16562 {
16563 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16564
16565 fclose (fp1);
16566
16567 return (-1);
16568 }
16569
16570 if (S_ISDIR (tmp_stat.st_mode))
16571 {
16572 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16573
16574 fclose (fp1);
16575
16576 return (-1);
16577 }
16578
16579 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16580 {
16581 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16582
16583 fclose (fp1);
16584
16585 return (-1);
16586 }
16587
16588 if (stat (dictfile2, &tmp_stat) == -1)
16589 {
16590 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16591
16592 fclose (fp1);
16593 fclose (fp2);
16594
16595 return (-1);
16596 }
16597
16598 if (S_ISDIR (tmp_stat.st_mode))
16599 {
16600 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16601
16602 fclose (fp1);
16603 fclose (fp2);
16604
16605 return (-1);
16606 }
16607
16608 data.combs_cnt = 1;
16609
16610 data.quiet = 1;
16611
16612 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16613
16614 data.quiet = quiet;
16615
16616 if (words1_cnt == 0)
16617 {
16618 log_error ("ERROR: %s: empty file", dictfile1);
16619
16620 fclose (fp1);
16621 fclose (fp2);
16622
16623 return (-1);
16624 }
16625
16626 data.combs_cnt = 1;
16627
16628 data.quiet = 1;
16629
16630 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16631
16632 data.quiet = quiet;
16633
16634 if (words2_cnt == 0)
16635 {
16636 log_error ("ERROR: %s: empty file", dictfile2);
16637
16638 fclose (fp1);
16639 fclose (fp2);
16640
16641 return (-1);
16642 }
16643
16644 fclose (fp1);
16645 fclose (fp2);
16646
16647 data.dictfile = dictfile1;
16648 data.dictfile2 = dictfile2;
16649
16650 if (words1_cnt >= words2_cnt)
16651 {
16652 data.combs_cnt = words2_cnt;
16653 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16654
16655 dictfiles = &data.dictfile;
16656
16657 dictcnt = 1;
16658 }
16659 else
16660 {
16661 data.combs_cnt = words1_cnt;
16662 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16663
16664 dictfiles = &data.dictfile2;
16665
16666 dictcnt = 1;
16667
16668 // we also have to switch wordlist related rules!
16669
16670 char *tmpc = data.rule_buf_l;
16671
16672 data.rule_buf_l = data.rule_buf_r;
16673 data.rule_buf_r = tmpc;
16674
16675 int tmpi = data.rule_len_l;
16676
16677 data.rule_len_l = data.rule_len_r;
16678 data.rule_len_r = tmpi;
16679 }
16680 }
16681 else if (attack_mode == ATTACK_MODE_BF)
16682 {
16683 char *mask = NULL;
16684
16685 maskcnt = 0;
16686
16687 if (benchmark == 0)
16688 {
16689 mask = myargv[optind + 1];
16690
16691 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16692
16693 if ((optind + 2) <= myargc)
16694 {
16695 struct stat file_stat;
16696
16697 if (stat (mask, &file_stat) == -1)
16698 {
16699 maskcnt = 1;
16700
16701 masks[maskcnt - 1] = mystrdup (mask);
16702 }
16703 else
16704 {
16705 int wls_left = myargc - (optind + 1);
16706
16707 uint masks_avail = INCR_MASKS;
16708
16709 for (int i = 0; i < wls_left; i++)
16710 {
16711 if (i != 0)
16712 {
16713 mask = myargv[optind + 1 + i];
16714
16715 if (stat (mask, &file_stat) == -1)
16716 {
16717 log_error ("ERROR: %s: %s", mask, strerror (errno));
16718
16719 return (-1);
16720 }
16721 }
16722
16723 uint is_file = S_ISREG (file_stat.st_mode);
16724
16725 if (is_file == 1)
16726 {
16727 FILE *mask_fp;
16728
16729 if ((mask_fp = fopen (mask, "r")) == NULL)
16730 {
16731 log_error ("ERROR: %s: %s", mask, strerror (errno));
16732
16733 return (-1);
16734 }
16735
16736 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16737
16738 while (!feof (mask_fp))
16739 {
16740 memset (line_buf, 0, HCBUFSIZ);
16741
16742 int line_len = fgetl (mask_fp, line_buf);
16743
16744 if (line_len == 0) continue;
16745
16746 if (line_buf[0] == '#') continue;
16747
16748 if (masks_avail == maskcnt)
16749 {
16750 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16751
16752 masks_avail += INCR_MASKS;
16753 }
16754
16755 masks[maskcnt] = mystrdup (line_buf);
16756
16757 maskcnt++;
16758 }
16759
16760 myfree (line_buf);
16761
16762 fclose (mask_fp);
16763 }
16764 else
16765 {
16766 log_error ("ERROR: %s: unsupported file-type", mask);
16767
16768 return (-1);
16769 }
16770 }
16771
16772 mask_from_file = 1;
16773 }
16774 }
16775 else
16776 {
16777 custom_charset_1 = (char *) "?l?d?u";
16778 custom_charset_2 = (char *) "?l?d";
16779 custom_charset_3 = (char *) "?l?d*!$@_";
16780
16781 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16782 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16783 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16784
16785 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16786
16787 wordlist_mode = WL_MODE_MASK;
16788
16789 data.wordlist_mode = wordlist_mode;
16790
16791 increment = 1;
16792
16793 maskcnt = 1;
16794 }
16795 }
16796 else
16797 {
16798 /**
16799 * generate full masks and charsets
16800 */
16801
16802 masks = (char **) mymalloc (sizeof (char *));
16803
16804 switch (hash_mode)
16805 {
16806 case 1731: pw_min = 5;
16807 pw_max = 5;
16808 mask = mystrdup ("?b?b?b?b?b");
16809 break;
16810 case 12500: pw_min = 5;
16811 pw_max = 5;
16812 mask = mystrdup ("?b?b?b?b?b");
16813 break;
16814 default: pw_min = 7;
16815 pw_max = 7;
16816 mask = mystrdup ("?b?b?b?b?b?b?b");
16817 break;
16818 }
16819
16820 maskcnt = 1;
16821
16822 masks[maskcnt - 1] = mystrdup (mask);
16823
16824 wordlist_mode = WL_MODE_MASK;
16825
16826 data.wordlist_mode = wordlist_mode;
16827
16828 increment = 1;
16829 }
16830
16831 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16832
16833 if (increment)
16834 {
16835 if (increment_min > pw_min) pw_min = increment_min;
16836
16837 if (increment_max < pw_max) pw_max = increment_max;
16838 }
16839 }
16840 else if (attack_mode == ATTACK_MODE_HYBRID1)
16841 {
16842 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16843
16844 // display
16845
16846 char *mask = myargv[myargc - 1];
16847
16848 maskcnt = 0;
16849
16850 masks = (char **) mymalloc (1 * sizeof (char *));
16851
16852 // mod
16853
16854 struct stat file_stat;
16855
16856 if (stat (mask, &file_stat) == -1)
16857 {
16858 maskcnt = 1;
16859
16860 masks[maskcnt - 1] = mystrdup (mask);
16861 }
16862 else
16863 {
16864 uint is_file = S_ISREG (file_stat.st_mode);
16865
16866 if (is_file == 1)
16867 {
16868 FILE *mask_fp;
16869
16870 if ((mask_fp = fopen (mask, "r")) == NULL)
16871 {
16872 log_error ("ERROR: %s: %s", mask, strerror (errno));
16873
16874 return (-1);
16875 }
16876
16877 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16878
16879 uint masks_avail = 1;
16880
16881 while (!feof (mask_fp))
16882 {
16883 memset (line_buf, 0, HCBUFSIZ);
16884
16885 int line_len = fgetl (mask_fp, line_buf);
16886
16887 if (line_len == 0) continue;
16888
16889 if (line_buf[0] == '#') continue;
16890
16891 if (masks_avail == maskcnt)
16892 {
16893 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16894
16895 masks_avail += INCR_MASKS;
16896 }
16897
16898 masks[maskcnt] = mystrdup (line_buf);
16899
16900 maskcnt++;
16901 }
16902
16903 myfree (line_buf);
16904
16905 fclose (mask_fp);
16906
16907 mask_from_file = 1;
16908 }
16909 else
16910 {
16911 maskcnt = 1;
16912
16913 masks[maskcnt - 1] = mystrdup (mask);
16914 }
16915 }
16916
16917 // base
16918
16919 int wls_left = myargc - (optind + 2);
16920
16921 for (int i = 0; i < wls_left; i++)
16922 {
16923 char *filename = myargv[optind + 1 + i];
16924
16925 struct stat file_stat;
16926
16927 if (stat (filename, &file_stat) == -1)
16928 {
16929 log_error ("ERROR: %s: %s", filename, strerror (errno));
16930
16931 return (-1);
16932 }
16933
16934 uint is_dir = S_ISDIR (file_stat.st_mode);
16935
16936 if (is_dir == 0)
16937 {
16938 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16939
16940 dictcnt++;
16941
16942 dictfiles[dictcnt - 1] = filename;
16943 }
16944 else
16945 {
16946 // do not allow --keyspace w/ a directory
16947
16948 if (keyspace == 1)
16949 {
16950 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16951
16952 return (-1);
16953 }
16954
16955 char **dictionary_files = NULL;
16956
16957 dictionary_files = scan_directory (filename);
16958
16959 if (dictionary_files != NULL)
16960 {
16961 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16962
16963 for (int d = 0; dictionary_files[d] != NULL; d++)
16964 {
16965 char *l1_filename = dictionary_files[d];
16966
16967 struct stat l1_stat;
16968
16969 if (stat (l1_filename, &l1_stat) == -1)
16970 {
16971 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16972
16973 return (-1);
16974 }
16975
16976 if (S_ISREG (l1_stat.st_mode))
16977 {
16978 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16979
16980 dictcnt++;
16981
16982 dictfiles[dictcnt - 1] = strdup (l1_filename);
16983 }
16984 }
16985 }
16986
16987 local_free (dictionary_files);
16988 }
16989 }
16990
16991 if (dictcnt < 1)
16992 {
16993 log_error ("ERROR: No usable dictionary file found.");
16994
16995 return (-1);
16996 }
16997
16998 if (increment)
16999 {
17000 maskcnt = 0;
17001
17002 uint mask_min = increment_min; // we can't reject smaller masks here
17003 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17004
17005 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17006 {
17007 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17008
17009 if (cur_mask == NULL) break;
17010
17011 masks[maskcnt] = cur_mask;
17012
17013 maskcnt++;
17014
17015 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17016 }
17017 }
17018 }
17019 else if (attack_mode == ATTACK_MODE_HYBRID2)
17020 {
17021 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
17022
17023 // display
17024
17025 char *mask = myargv[optind + 1 + 0];
17026
17027 maskcnt = 0;
17028
17029 masks = (char **) mymalloc (1 * sizeof (char *));
17030
17031 // mod
17032
17033 struct stat file_stat;
17034
17035 if (stat (mask, &file_stat) == -1)
17036 {
17037 maskcnt = 1;
17038
17039 masks[maskcnt - 1] = mystrdup (mask);
17040 }
17041 else
17042 {
17043 uint is_file = S_ISREG (file_stat.st_mode);
17044
17045 if (is_file == 1)
17046 {
17047 FILE *mask_fp;
17048
17049 if ((mask_fp = fopen (mask, "r")) == NULL)
17050 {
17051 log_error ("ERROR: %s: %s", mask, strerror (errno));
17052
17053 return (-1);
17054 }
17055
17056 char *line_buf = (char *) mymalloc (HCBUFSIZ);
17057
17058 uint masks_avail = 1;
17059
17060 while (!feof (mask_fp))
17061 {
17062 memset (line_buf, 0, HCBUFSIZ);
17063
17064 int line_len = fgetl (mask_fp, line_buf);
17065
17066 if (line_len == 0) continue;
17067
17068 if (line_buf[0] == '#') continue;
17069
17070 if (masks_avail == maskcnt)
17071 {
17072 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
17073
17074 masks_avail += INCR_MASKS;
17075 }
17076
17077 masks[maskcnt] = mystrdup (line_buf);
17078
17079 maskcnt++;
17080 }
17081
17082 myfree (line_buf);
17083
17084 fclose (mask_fp);
17085
17086 mask_from_file = 1;
17087 }
17088 else
17089 {
17090 maskcnt = 1;
17091
17092 masks[maskcnt - 1] = mystrdup (mask);
17093 }
17094 }
17095
17096 // base
17097
17098 int wls_left = myargc - (optind + 2);
17099
17100 for (int i = 0; i < wls_left; i++)
17101 {
17102 char *filename = myargv[optind + 2 + i];
17103
17104 struct stat file_stat;
17105
17106 if (stat (filename, &file_stat) == -1)
17107 {
17108 log_error ("ERROR: %s: %s", filename, strerror (errno));
17109
17110 return (-1);
17111 }
17112
17113 uint is_dir = S_ISDIR (file_stat.st_mode);
17114
17115 if (is_dir == 0)
17116 {
17117 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17118
17119 dictcnt++;
17120
17121 dictfiles[dictcnt - 1] = filename;
17122 }
17123 else
17124 {
17125 // do not allow --keyspace w/ a directory
17126
17127 if (keyspace == 1)
17128 {
17129 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17130
17131 return (-1);
17132 }
17133
17134 char **dictionary_files = NULL;
17135
17136 dictionary_files = scan_directory (filename);
17137
17138 if (dictionary_files != NULL)
17139 {
17140 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17141
17142 for (int d = 0; dictionary_files[d] != NULL; d++)
17143 {
17144 char *l1_filename = dictionary_files[d];
17145
17146 struct stat l1_stat;
17147
17148 if (stat (l1_filename, &l1_stat) == -1)
17149 {
17150 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17151
17152 return (-1);
17153 }
17154
17155 if (S_ISREG (l1_stat.st_mode))
17156 {
17157 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17158
17159 dictcnt++;
17160
17161 dictfiles[dictcnt - 1] = strdup (l1_filename);
17162 }
17163 }
17164 }
17165
17166 local_free (dictionary_files);
17167 }
17168 }
17169
17170 if (dictcnt < 1)
17171 {
17172 log_error ("ERROR: No usable dictionary file found.");
17173
17174 return (-1);
17175 }
17176
17177 if (increment)
17178 {
17179 maskcnt = 0;
17180
17181 uint mask_min = increment_min; // we can't reject smaller masks here
17182 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17183
17184 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17185 {
17186 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17187
17188 if (cur_mask == NULL) break;
17189
17190 masks[maskcnt] = cur_mask;
17191
17192 maskcnt++;
17193
17194 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17195 }
17196 }
17197 }
17198
17199 data.pw_min = pw_min;
17200 data.pw_max = pw_max;
17201
17202 /**
17203 * weak hash check
17204 */
17205
17206 if (weak_hash_threshold >= salts_cnt)
17207 {
17208 hc_device_param_t *device_param = NULL;
17209
17210 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17211 {
17212 device_param = &data.devices_param[device_id];
17213
17214 if (device_param->skipped) continue;
17215
17216 break;
17217 }
17218
17219 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
17220
17221 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
17222 {
17223 weak_hash_check (device_param, salt_pos);
17224 }
17225
17226 // Display hack, guarantee that there is at least one \r before real start
17227
17228 //if (data.quiet == 0) log_info ("");
17229 }
17230
17231 /**
17232 * status and monitor threads
17233 */
17234
17235 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17236 {
17237 data.devices_status = STATUS_STARTING;
17238 }
17239
17240 uint inner_threads_cnt = 0;
17241
17242 hc_thread_t *inner_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17243
17244 /**
17245 * Outfile remove
17246 */
17247
17248 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
17249 {
17250 if (outfile_check_timer != 0)
17251 {
17252 if (data.outfile_check_directory != NULL)
17253 {
17254 if ((hash_mode != 5200) &&
17255 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
17256 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
17257 (hash_mode != 9000))
17258 {
17259 hc_thread_create (inner_threads[inner_threads_cnt], thread_outfile_remove, NULL);
17260
17261 inner_threads_cnt++;
17262 }
17263 else
17264 {
17265 outfile_check_timer = 0;
17266 }
17267 }
17268 else
17269 {
17270 outfile_check_timer = 0;
17271 }
17272 }
17273 }
17274
17275 /**
17276 * Inform the user if we got some hashes remove because of the pot file remove feature
17277 */
17278
17279 if (data.quiet == 0)
17280 {
17281 if (potfile_remove_cracks > 0)
17282 {
17283 if (potfile_remove_cracks == 1) log_info ("INFO: Removed 1 hash found in pot file\n");
17284 else log_info ("INFO: Removed %u hashes found in pot file\n", potfile_remove_cracks);
17285 }
17286 }
17287
17288 data.outfile_check_timer = outfile_check_timer;
17289
17290 /**
17291 * main loop
17292 */
17293
17294 char **induction_dictionaries = NULL;
17295
17296 int induction_dictionaries_cnt = 0;
17297
17298 hcstat_table_t *root_table_buf = NULL;
17299 hcstat_table_t *markov_table_buf = NULL;
17300
17301 uint initial_restore_done = 0;
17302
17303 data.maskcnt = maskcnt;
17304
17305 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
17306 {
17307 if (data.devices_status == STATUS_CRACKED) continue;
17308 if (data.devices_status == STATUS_ABORTED) continue;
17309 if (data.devices_status == STATUS_QUIT) continue;
17310
17311 if (maskpos > rd->maskpos)
17312 {
17313 rd->dictpos = 0;
17314 }
17315
17316 rd->maskpos = maskpos;
17317 data.maskpos = maskpos;
17318
17319 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
17320 {
17321 char *mask = masks[maskpos];
17322
17323 if (mask_from_file == 1)
17324 {
17325 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
17326
17327 char *str_ptr;
17328 uint str_pos;
17329
17330 uint mask_offset = 0;
17331
17332 uint separator_cnt;
17333
17334 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
17335 {
17336 str_ptr = strstr (mask + mask_offset, ",");
17337
17338 if (str_ptr == NULL) break;
17339
17340 str_pos = str_ptr - mask;
17341
17342 // escaped separator, i.e. "\,"
17343
17344 if (str_pos > 0)
17345 {
17346 if (mask[str_pos - 1] == '\\')
17347 {
17348 separator_cnt --;
17349
17350 mask_offset = str_pos + 1;
17351
17352 continue;
17353 }
17354 }
17355
17356 // reset the offset
17357
17358 mask_offset = 0;
17359
17360 mask[str_pos] = '\0';
17361
17362 switch (separator_cnt)
17363 {
17364 case 0:
17365 mp_reset_usr (mp_usr, 0);
17366
17367 custom_charset_1 = mask;
17368 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17369 break;
17370
17371 case 1:
17372 mp_reset_usr (mp_usr, 1);
17373
17374 custom_charset_2 = mask;
17375 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17376 break;
17377
17378 case 2:
17379 mp_reset_usr (mp_usr, 2);
17380
17381 custom_charset_3 = mask;
17382 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17383 break;
17384
17385 case 3:
17386 mp_reset_usr (mp_usr, 3);
17387
17388 custom_charset_4 = mask;
17389 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
17390 break;
17391 }
17392
17393 mask = mask + str_pos + 1;
17394 }
17395 }
17396
17397 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17398 {
17399 if (maskpos > 0)
17400 {
17401 local_free (css_buf);
17402 local_free (data.root_css_buf);
17403 local_free (data.markov_css_buf);
17404
17405 local_free (masks[maskpos - 1]);
17406 }
17407
17408 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17409
17410 data.mask = mask;
17411 data.css_cnt = css_cnt;
17412 data.css_buf = css_buf;
17413
17414 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17415
17416 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17417
17418 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17419 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17420
17421 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17422
17423 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17424
17425 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17426 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17427
17428 data.root_css_buf = root_css_buf;
17429 data.markov_css_buf = markov_css_buf;
17430
17431 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17432
17433 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17434
17435 local_free (root_table_buf);
17436 local_free (markov_table_buf);
17437
17438 // args
17439
17440 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17441 {
17442 hc_device_param_t *device_param = &data.devices_param[device_id];
17443
17444 if (device_param->skipped) continue;
17445
17446 device_param->kernel_params_mp[0] = &device_param->d_combs;
17447 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
17448 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
17449
17450 device_param->kernel_params_mp_buf64[3] = 0;
17451 device_param->kernel_params_mp_buf32[4] = css_cnt;
17452 device_param->kernel_params_mp_buf32[5] = 0;
17453 device_param->kernel_params_mp_buf32[6] = 0;
17454 device_param->kernel_params_mp_buf32[7] = 0;
17455
17456 if (attack_mode == ATTACK_MODE_HYBRID1)
17457 {
17458 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
17459 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
17460 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
17461 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
17462 }
17463 else if (attack_mode == ATTACK_MODE_HYBRID2)
17464 {
17465 device_param->kernel_params_mp_buf32[5] = 0;
17466 device_param->kernel_params_mp_buf32[6] = 0;
17467 device_param->kernel_params_mp_buf32[7] = 0;
17468 }
17469
17470 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]);
17471 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]);
17472 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]);
17473
17474 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);
17475 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);
17476 }
17477 }
17478 else if (attack_mode == ATTACK_MODE_BF)
17479 {
17480 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
17481
17482 if (increment)
17483 {
17484 for (uint i = 0; i < dictcnt; i++)
17485 {
17486 local_free (dictfiles[i]);
17487 }
17488
17489 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17490 {
17491 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17492
17493 if (l1_filename == NULL) break;
17494
17495 dictcnt++;
17496
17497 dictfiles[dictcnt - 1] = l1_filename;
17498 }
17499 }
17500 else
17501 {
17502 dictcnt++;
17503
17504 dictfiles[dictcnt - 1] = mask;
17505 }
17506
17507 if (dictcnt == 0)
17508 {
17509 log_error ("ERROR: Mask is too small");
17510
17511 return (-1);
17512 }
17513 }
17514 }
17515
17516 free (induction_dictionaries);
17517
17518 // induction_dictionaries_cnt = 0; // implied
17519
17520 if (attack_mode != ATTACK_MODE_BF)
17521 {
17522 if (keyspace == 0)
17523 {
17524 induction_dictionaries = scan_directory (induction_directory);
17525
17526 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17527 }
17528 }
17529
17530 if (induction_dictionaries_cnt)
17531 {
17532 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17533 }
17534
17535 /**
17536 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17537 */
17538 if (keyspace == 1)
17539 {
17540 if ((maskcnt > 1) || (dictcnt > 1))
17541 {
17542 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17543
17544 return (-1);
17545 }
17546 }
17547
17548 for (uint dictpos = rd->dictpos; dictpos < dictcnt; dictpos++)
17549 {
17550 if (data.devices_status == STATUS_CRACKED) continue;
17551 if (data.devices_status == STATUS_ABORTED) continue;
17552 if (data.devices_status == STATUS_QUIT) continue;
17553
17554 rd->dictpos = dictpos;
17555
17556 char *subid = logfile_generate_subid ();
17557
17558 data.subid = subid;
17559
17560 logfile_sub_msg ("START");
17561
17562 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17563 {
17564 data.devices_status = STATUS_INIT;
17565 }
17566
17567 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17568 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17569 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17570
17571 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17572
17573 data.cpt_pos = 0;
17574
17575 data.cpt_start = time (NULL);
17576
17577 data.cpt_total = 0;
17578
17579 if (data.restore == 0)
17580 {
17581 rd->words_cur = skip;
17582
17583 skip = 0;
17584
17585 data.skip = 0;
17586 }
17587
17588 data.ms_paused = 0;
17589
17590 data.kernel_power_final = 0;
17591
17592 data.words_cur = rd->words_cur;
17593
17594 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17595 {
17596 hc_device_param_t *device_param = &data.devices_param[device_id];
17597
17598 if (device_param->skipped) continue;
17599
17600 device_param->speed_pos = 0;
17601
17602 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17603 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17604
17605 device_param->exec_pos = 0;
17606
17607 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17608
17609 device_param->outerloop_pos = 0;
17610 device_param->outerloop_left = 0;
17611 device_param->innerloop_pos = 0;
17612 device_param->innerloop_left = 0;
17613
17614 // some more resets:
17615
17616 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17617
17618 device_param->pws_cnt = 0;
17619
17620 device_param->words_off = 0;
17621 device_param->words_done = 0;
17622 }
17623
17624 // figure out some workload
17625
17626 if (attack_mode == ATTACK_MODE_STRAIGHT)
17627 {
17628 if (data.wordlist_mode == WL_MODE_FILE)
17629 {
17630 char *dictfile = NULL;
17631
17632 if (induction_dictionaries_cnt)
17633 {
17634 dictfile = induction_dictionaries[0];
17635 }
17636 else
17637 {
17638 dictfile = dictfiles[dictpos];
17639 }
17640
17641 data.dictfile = dictfile;
17642
17643 logfile_sub_string (dictfile);
17644
17645 for (uint i = 0; i < rp_files_cnt; i++)
17646 {
17647 logfile_sub_var_string ("rulefile", rp_files[i]);
17648 }
17649
17650 FILE *fd2 = fopen (dictfile, "rb");
17651
17652 if (fd2 == NULL)
17653 {
17654 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17655
17656 return (-1);
17657 }
17658
17659 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17660
17661 fclose (fd2);
17662
17663 if (data.words_cnt == 0)
17664 {
17665 logfile_sub_msg ("STOP");
17666
17667 continue;
17668 }
17669 }
17670 }
17671 else if (attack_mode == ATTACK_MODE_COMBI)
17672 {
17673 char *dictfile = data.dictfile;
17674 char *dictfile2 = data.dictfile2;
17675
17676 logfile_sub_string (dictfile);
17677 logfile_sub_string (dictfile2);
17678
17679 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17680 {
17681 FILE *fd2 = fopen (dictfile, "rb");
17682
17683 if (fd2 == NULL)
17684 {
17685 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17686
17687 return (-1);
17688 }
17689
17690 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17691
17692 fclose (fd2);
17693 }
17694 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17695 {
17696 FILE *fd2 = fopen (dictfile2, "rb");
17697
17698 if (fd2 == NULL)
17699 {
17700 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17701
17702 return (-1);
17703 }
17704
17705 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17706
17707 fclose (fd2);
17708 }
17709
17710 if (data.words_cnt == 0)
17711 {
17712 logfile_sub_msg ("STOP");
17713
17714 continue;
17715 }
17716 }
17717 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17718 {
17719 char *dictfile = NULL;
17720
17721 if (induction_dictionaries_cnt)
17722 {
17723 dictfile = induction_dictionaries[0];
17724 }
17725 else
17726 {
17727 dictfile = dictfiles[dictpos];
17728 }
17729
17730 data.dictfile = dictfile;
17731
17732 char *mask = data.mask;
17733
17734 logfile_sub_string (dictfile);
17735 logfile_sub_string (mask);
17736
17737 FILE *fd2 = fopen (dictfile, "rb");
17738
17739 if (fd2 == NULL)
17740 {
17741 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17742
17743 return (-1);
17744 }
17745
17746 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17747
17748 fclose (fd2);
17749
17750 if (data.words_cnt == 0)
17751 {
17752 logfile_sub_msg ("STOP");
17753
17754 continue;
17755 }
17756 }
17757 else if (attack_mode == ATTACK_MODE_BF)
17758 {
17759 local_free (css_buf);
17760 local_free (data.root_css_buf);
17761 local_free (data.markov_css_buf);
17762
17763 char *mask = dictfiles[dictpos];
17764
17765 logfile_sub_string (mask);
17766
17767 // base
17768
17769 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17770
17771 if (opts_type & OPTS_TYPE_PT_UNICODE)
17772 {
17773 uint css_cnt_unicode = css_cnt * 2;
17774
17775 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17776
17777 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17778 {
17779 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17780
17781 css_buf_unicode[j + 1].cs_buf[0] = 0;
17782 css_buf_unicode[j + 1].cs_len = 1;
17783 }
17784
17785 free (css_buf);
17786
17787 css_buf = css_buf_unicode;
17788 css_cnt = css_cnt_unicode;
17789 }
17790
17791 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17792
17793 uint mask_min = pw_min;
17794 uint mask_max = pw_max;
17795
17796 if (opts_type & OPTS_TYPE_PT_UNICODE)
17797 {
17798 mask_min *= 2;
17799 mask_max *= 2;
17800 }
17801
17802 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17803 {
17804 if (css_cnt < mask_min)
17805 {
17806 log_info ("WARNING: Skipping mask '%s' because it is smaller than the minimum password length", mask);
17807 }
17808
17809 if (css_cnt > mask_max)
17810 {
17811 log_info ("WARNING: Skipping mask '%s' because it is larger than the maximum password length", mask);
17812 }
17813
17814 // skip to next mask
17815
17816 logfile_sub_msg ("STOP");
17817
17818 continue;
17819 }
17820
17821 uint save_css_cnt = css_cnt;
17822
17823 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17824 {
17825 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17826 {
17827 uint salt_len = (uint) data.salts_buf[0].salt_len;
17828 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17829
17830 uint css_cnt_salt = css_cnt + salt_len;
17831
17832 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17833
17834 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17835
17836 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17837 {
17838 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17839 css_buf_salt[j].cs_len = 1;
17840 }
17841
17842 free (css_buf);
17843
17844 css_buf = css_buf_salt;
17845 css_cnt = css_cnt_salt;
17846 }
17847 }
17848
17849 data.mask = mask;
17850 data.css_cnt = css_cnt;
17851 data.css_buf = css_buf;
17852
17853 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17854
17855 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17856
17857 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17858
17859 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17860 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17861
17862 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17863
17864 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17865
17866 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17867 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17868
17869 data.root_css_buf = root_css_buf;
17870 data.markov_css_buf = markov_css_buf;
17871
17872 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17873
17874 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17875
17876 local_free (root_table_buf);
17877 local_free (markov_table_buf);
17878
17879 // copy + args
17880
17881 uint css_cnt_l = css_cnt;
17882 uint css_cnt_r;
17883
17884 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17885 {
17886 if (save_css_cnt < 6)
17887 {
17888 css_cnt_r = 1;
17889 }
17890 else if (save_css_cnt == 6)
17891 {
17892 css_cnt_r = 2;
17893 }
17894 else
17895 {
17896 if (opts_type & OPTS_TYPE_PT_UNICODE)
17897 {
17898 if (save_css_cnt == 8 || save_css_cnt == 10)
17899 {
17900 css_cnt_r = 2;
17901 }
17902 else
17903 {
17904 css_cnt_r = 4;
17905 }
17906 }
17907 else
17908 {
17909 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17910 {
17911 css_cnt_r = 3;
17912 }
17913 else
17914 {
17915 css_cnt_r = 4;
17916 }
17917 }
17918 }
17919 }
17920 else
17921 {
17922 css_cnt_r = 1;
17923
17924 /* unfinished code?
17925 int sum = css_buf[css_cnt_r - 1].cs_len;
17926
17927 for (uint i = 1; i < 4 && i < css_cnt; i++)
17928 {
17929 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17930
17931 css_cnt_r++;
17932
17933 sum *= css_buf[css_cnt_r - 1].cs_len;
17934 }
17935 */
17936 }
17937
17938 css_cnt_l -= css_cnt_r;
17939
17940 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17941
17942 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17943 {
17944 hc_device_param_t *device_param = &data.devices_param[device_id];
17945
17946 if (device_param->skipped) continue;
17947
17948 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17949 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17950 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17951
17952 device_param->kernel_params_mp_l_buf64[3] = 0;
17953 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17954 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17955 device_param->kernel_params_mp_l_buf32[6] = 0;
17956 device_param->kernel_params_mp_l_buf32[7] = 0;
17957 device_param->kernel_params_mp_l_buf32[8] = 0;
17958
17959 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17960 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17961 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17962 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17963
17964 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17965 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17966 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17967
17968 device_param->kernel_params_mp_r_buf64[3] = 0;
17969 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17970 device_param->kernel_params_mp_r_buf32[5] = 0;
17971 device_param->kernel_params_mp_r_buf32[6] = 0;
17972 device_param->kernel_params_mp_r_buf32[7] = 0;
17973
17974 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]);
17975 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]);
17976 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]);
17977
17978 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]);
17979 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]);
17980 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]);
17981
17982 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);
17983 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);
17984 }
17985 }
17986
17987 u64 words_base = data.words_cnt;
17988
17989 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17990 {
17991 if (data.kernel_rules_cnt)
17992 {
17993 words_base /= data.kernel_rules_cnt;
17994 }
17995 }
17996 else if (data.attack_kern == ATTACK_KERN_COMBI)
17997 {
17998 if (data.combs_cnt)
17999 {
18000 words_base /= data.combs_cnt;
18001 }
18002 }
18003 else if (data.attack_kern == ATTACK_KERN_BF)
18004 {
18005 if (data.bfs_cnt)
18006 {
18007 words_base /= data.bfs_cnt;
18008 }
18009 }
18010
18011 data.words_base = words_base;
18012
18013 if (keyspace == 1)
18014 {
18015 log_info ("%llu", (unsigned long long int) words_base);
18016
18017 return (0);
18018 }
18019
18020 if (data.words_cur > data.words_base)
18021 {
18022 log_error ("ERROR: Restore value greater keyspace");
18023
18024 return (-1);
18025 }
18026
18027 if (data.words_cur)
18028 {
18029 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18030 {
18031 for (uint i = 0; i < data.salts_cnt; i++)
18032 {
18033 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
18034 }
18035 }
18036 else if (data.attack_kern == ATTACK_KERN_COMBI)
18037 {
18038 for (uint i = 0; i < data.salts_cnt; i++)
18039 {
18040 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
18041 }
18042 }
18043 else if (data.attack_kern == ATTACK_KERN_BF)
18044 {
18045 for (uint i = 0; i < data.salts_cnt; i++)
18046 {
18047 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
18048 }
18049 }
18050 }
18051
18052 /*
18053 * Update loopback file
18054 */
18055
18056 if (loopback == 1)
18057 {
18058 time_t now;
18059
18060 time (&now);
18061
18062 uint random_num = get_random_num (0, 9999);
18063
18064 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
18065
18066 data.loopback_file = loopback_file;
18067 }
18068
18069 /*
18070 * Update dictionary statistic
18071 */
18072
18073 if (keyspace == 0)
18074 {
18075 dictstat_fp = fopen (dictstat, "wb");
18076
18077 if (dictstat_fp)
18078 {
18079 lock_file (dictstat_fp);
18080
18081 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
18082
18083 fclose (dictstat_fp);
18084 }
18085 }
18086
18087 /**
18088 * create autotune threads
18089 */
18090
18091 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
18092
18093 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18094 {
18095 data.devices_status = STATUS_AUTOTUNE;
18096 }
18097
18098 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18099 {
18100 hc_device_param_t *device_param = &devices_param[device_id];
18101
18102 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
18103 }
18104
18105 hc_thread_wait (data.devices_cnt, c_threads);
18106
18107 /*
18108 * Inform user about possible slow speeds
18109 */
18110
18111 uint hardware_power_all = 0;
18112
18113 uint kernel_power_all = 0;
18114
18115 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18116 {
18117 hc_device_param_t *device_param = &devices_param[device_id];
18118
18119 hardware_power_all += device_param->hardware_power;
18120
18121 kernel_power_all += device_param->kernel_power;
18122 }
18123
18124 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
18125
18126 data.kernel_power_all = kernel_power_all;
18127
18128 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18129 {
18130 if (data.words_base < kernel_power_all)
18131 {
18132 if (quiet == 0)
18133 {
18134 clear_prompt ();
18135
18136 log_info ("ATTENTION!");
18137 log_info (" The wordlist or mask you are using is too small.");
18138 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
18139 log_info (" The cracking speed will drop.");
18140 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
18141 log_info ("");
18142 }
18143 }
18144 }
18145
18146 /**
18147 * create cracker threads
18148 */
18149
18150 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18151 {
18152 data.devices_status = STATUS_RUNNING;
18153 }
18154
18155 if (initial_restore_done == 0)
18156 {
18157 if (data.restore_disable == 0) cycle_restore ();
18158
18159 initial_restore_done = 1;
18160 }
18161
18162 hc_timer_set (&data.timer_running);
18163
18164 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18165 {
18166 if ((quiet == 0) && (status == 0) && (benchmark == 0))
18167 {
18168 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
18169 if (quiet == 0) fflush (stdout);
18170 }
18171 }
18172 else if (wordlist_mode == WL_MODE_STDIN)
18173 {
18174 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
18175 if (data.quiet == 0) log_info ("");
18176 }
18177
18178 time_t runtime_start;
18179
18180 time (&runtime_start);
18181
18182 data.runtime_start = runtime_start;
18183
18184 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18185 {
18186 hc_device_param_t *device_param = &devices_param[device_id];
18187
18188 if (wordlist_mode == WL_MODE_STDIN)
18189 {
18190 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
18191 }
18192 else
18193 {
18194 hc_thread_create (c_threads[device_id], thread_calc, device_param);
18195 }
18196 }
18197
18198 hc_thread_wait (data.devices_cnt, c_threads);
18199
18200 local_free (c_threads);
18201
18202 logfile_sub_var_uint ("status-after-work", data.devices_status);
18203
18204 data.restore = 0;
18205
18206 if (induction_dictionaries_cnt)
18207 {
18208 unlink (induction_dictionaries[0]);
18209 }
18210
18211 free (induction_dictionaries);
18212
18213 if (attack_mode != ATTACK_MODE_BF)
18214 {
18215 induction_dictionaries = scan_directory (induction_directory);
18216
18217 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18218 }
18219
18220 if (benchmark == 1)
18221 {
18222 status_benchmark ();
18223
18224 if (machine_readable == 0)
18225 {
18226 log_info ("");
18227 }
18228 }
18229 else
18230 {
18231 if (quiet == 0)
18232 {
18233 clear_prompt ();
18234
18235 log_info ("");
18236
18237 if (stdout_flag == 0) status_display ();
18238
18239 log_info ("");
18240 }
18241 }
18242
18243 if (induction_dictionaries_cnt)
18244 {
18245 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18246 }
18247
18248 time_t runtime_stop;
18249
18250 time (&runtime_stop);
18251
18252 data.runtime_stop = runtime_stop;
18253
18254 logfile_sub_uint (runtime_start);
18255 logfile_sub_uint (runtime_stop);
18256
18257 logfile_sub_msg ("STOP");
18258
18259 global_free (subid);
18260
18261 // from this point we handle bypass as running
18262
18263 if (data.devices_status == STATUS_BYPASS)
18264 {
18265 data.devices_status = STATUS_RUNNING;
18266 }
18267
18268 // finalize task
18269
18270 if (data.devices_status == STATUS_CRACKED) break;
18271 if (data.devices_status == STATUS_ABORTED) break;
18272 if (data.devices_status == STATUS_QUIT) break;
18273 }
18274
18275 if (data.devices_status == STATUS_CRACKED) break;
18276 if (data.devices_status == STATUS_ABORTED) break;
18277 if (data.devices_status == STATUS_QUIT) break;
18278 }
18279
18280 // 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
18281 if (attack_mode == ATTACK_MODE_STRAIGHT)
18282 {
18283 if (data.wordlist_mode == WL_MODE_FILE)
18284 {
18285 if (data.dictfile == NULL)
18286 {
18287 if (dictfiles != NULL)
18288 {
18289 data.dictfile = dictfiles[0];
18290
18291 hc_timer_set (&data.timer_running);
18292 }
18293 }
18294 }
18295 }
18296 // NOTE: combi is okay because it is already set beforehand
18297 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
18298 {
18299 if (data.dictfile == NULL)
18300 {
18301 if (dictfiles != NULL)
18302 {
18303 hc_timer_set (&data.timer_running);
18304
18305 data.dictfile = dictfiles[0];
18306 }
18307 }
18308 }
18309 else if (attack_mode == ATTACK_MODE_BF)
18310 {
18311 if (data.mask == NULL)
18312 {
18313 hc_timer_set (&data.timer_running);
18314
18315 data.mask = masks[0];
18316 }
18317 }
18318
18319 // if cracked / aborted remove last induction dictionary
18320
18321 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
18322 {
18323 struct stat induct_stat;
18324
18325 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
18326 {
18327 unlink (induction_dictionaries[file_pos]);
18328 }
18329 }
18330
18331 // wait for non-interactive threads
18332
18333 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18334 {
18335 data.devices_status = STATUS_EXHAUSTED;
18336 }
18337
18338 for (uint thread_idx = 0; thread_idx < inner_threads_cnt; thread_idx++)
18339 {
18340 hc_thread_wait (1, &inner_threads[thread_idx]);
18341 }
18342
18343 local_free (inner_threads);
18344
18345 // we dont need restore file anymore
18346 if (data.restore_disable == 0)
18347 {
18348 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
18349 {
18350 unlink (eff_restore_file);
18351 unlink (new_restore_file);
18352 }
18353 else
18354 {
18355 cycle_restore ();
18356 }
18357 }
18358
18359 // finally save left hashes
18360
18361 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
18362 {
18363 save_hash ();
18364 }
18365
18366 /**
18367 * Clean up
18368 */
18369
18370 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18371 {
18372 hc_device_param_t *device_param = &data.devices_param[device_id];
18373
18374 if (device_param->skipped) continue;
18375
18376 local_free (device_param->combs_buf);
18377 local_free (device_param->hooks_buf);
18378 local_free (device_param->device_name);
18379 local_free (device_param->device_name_chksum);
18380 local_free (device_param->device_version);
18381 local_free (device_param->driver_version);
18382
18383 if (device_param->pws_buf) myfree (device_param->pws_buf);
18384 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
18385 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
18386 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
18387 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
18388 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
18389 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
18390 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
18391 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
18392 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
18393 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
18394 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
18395 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
18396 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
18397 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
18398 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
18399 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
18400 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
18401 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
18402 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
18403 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
18404 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
18405 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
18406 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
18407 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
18408 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
18409 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
18410 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
18411 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
18412
18413 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
18414 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
18415 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
18416 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
18417 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
18418 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
18419 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
18420 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
18421 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
18422 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
18423 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
18424
18425 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
18426 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
18427 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
18428
18429 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
18430 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
18431 }
18432
18433 // reset default fan speed
18434
18435 #ifdef HAVE_HWMON
18436 if (gpu_temp_disable == 0)
18437 {
18438 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
18439 {
18440 hc_thread_mutex_lock (mux_adl);
18441
18442 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18443 {
18444 hc_device_param_t *device_param = &data.devices_param[device_id];
18445
18446 if (device_param->skipped) continue;
18447
18448 if (data.hm_device[device_id].fan_set_supported == 1)
18449 {
18450 int rc = -1;
18451
18452 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18453 {
18454 rc = hm_set_fanspeed_with_device_id_adl (device_id, 100, 0);
18455 }
18456 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18457 {
18458 #ifdef LINUX
18459 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE);
18460 #endif
18461
18462 #ifdef WIN
18463 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, 100, 8);
18464 #endif
18465 }
18466
18467 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18468 }
18469 }
18470
18471 hc_thread_mutex_unlock (mux_adl);
18472 }
18473 }
18474
18475 // reset power tuning
18476
18477 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
18478 {
18479 hc_thread_mutex_lock (mux_adl);
18480
18481 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18482 {
18483 hc_device_param_t *device_param = &data.devices_param[device_id];
18484
18485 if (device_param->skipped) continue;
18486
18487 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18488 {
18489 if (data.hm_device[device_id].od_version == 6)
18490 {
18491 // check powertune capabilities first, if not available then skip device
18492
18493 int powertune_supported = 0;
18494
18495 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18496 {
18497 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18498
18499 return (-1);
18500 }
18501
18502 if (powertune_supported != 0)
18503 {
18504 // powercontrol settings
18505
18506 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18507 {
18508 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18509
18510 return (-1);
18511 }
18512
18513 // clocks
18514
18515 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18516
18517 performance_state->iNumberOfPerformanceLevels = 2;
18518
18519 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18520 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18521 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18522 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18523
18524 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18525 {
18526 log_info ("ERROR: Failed to restore ADL performance state");
18527
18528 return (-1);
18529 }
18530
18531 local_free (performance_state);
18532 }
18533 }
18534 }
18535
18536 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18537 {
18538 unsigned int limit = nvml_power_limit[device_id];
18539
18540 if (limit > 0)
18541 {
18542 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18543 }
18544 }
18545 }
18546
18547 hc_thread_mutex_unlock (mux_adl);
18548 }
18549
18550 if (gpu_temp_disable == 0)
18551 {
18552 if (data.hm_nvml)
18553 {
18554 hm_NVML_nvmlShutdown (data.hm_nvml);
18555
18556 nvml_close (data.hm_nvml);
18557
18558 data.hm_nvml = NULL;
18559 }
18560
18561 if (data.hm_nvapi)
18562 {
18563 hm_NvAPI_Unload (data.hm_nvapi);
18564
18565 nvapi_close (data.hm_nvapi);
18566
18567 data.hm_nvapi = NULL;
18568 }
18569
18570 if (data.hm_xnvctrl)
18571 {
18572 hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);
18573
18574 xnvctrl_close (data.hm_xnvctrl);
18575
18576 data.hm_xnvctrl = NULL;
18577 }
18578
18579 if (data.hm_adl)
18580 {
18581 hm_ADL_Main_Control_Destroy (data.hm_adl);
18582
18583 adl_close (data.hm_adl);
18584
18585 data.hm_adl = NULL;
18586 }
18587 }
18588 #endif // HAVE_HWMON
18589
18590 // free memory
18591
18592 local_free (masks);
18593
18594 local_free (dictstat_base);
18595
18596 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18597 {
18598 pot_t *pot_ptr = &pot[pot_pos];
18599
18600 hash_t *hash = &pot_ptr->hash;
18601
18602 local_free (hash->digest);
18603
18604 if (isSalted)
18605 {
18606 local_free (hash->salt);
18607 }
18608 }
18609
18610 local_free (pot);
18611
18612 local_free (all_kernel_rules_cnt);
18613 local_free (all_kernel_rules_buf);
18614
18615 local_free (wl_data->buf);
18616 local_free (wl_data);
18617
18618 local_free (bitmap_s1_a);
18619 local_free (bitmap_s1_b);
18620 local_free (bitmap_s1_c);
18621 local_free (bitmap_s1_d);
18622 local_free (bitmap_s2_a);
18623 local_free (bitmap_s2_b);
18624 local_free (bitmap_s2_c);
18625 local_free (bitmap_s2_d);
18626
18627 #ifdef HAVE_HWMON
18628 local_free (od_clock_mem_status);
18629 local_free (od_power_control_status);
18630 local_free (nvml_power_limit);
18631 #endif
18632
18633 global_free (devices_param);
18634
18635 global_free (kernel_rules_buf);
18636
18637 global_free (root_css_buf);
18638 global_free (markov_css_buf);
18639
18640 global_free (digests_buf);
18641 global_free (digests_shown);
18642 global_free (digests_shown_tmp);
18643
18644 global_free (salts_buf);
18645 global_free (salts_shown);
18646
18647 global_free (esalts_buf);
18648
18649 global_free (words_progress_done);
18650 global_free (words_progress_rejected);
18651 global_free (words_progress_restored);
18652
18653 if (pot_fp) fclose (pot_fp);
18654
18655 if (data.devices_status == STATUS_QUIT) break;
18656 }
18657
18658 // wait for interactive threads
18659
18660 for (uint thread_idx = 0; thread_idx < outer_threads_cnt; thread_idx++)
18661 {
18662 hc_thread_wait (1, &outer_threads[thread_idx]);
18663 }
18664
18665 local_free (outer_threads);
18666
18667 // destroy others mutex
18668
18669 hc_thread_mutex_delete (mux_dispatcher);
18670 hc_thread_mutex_delete (mux_counter);
18671 hc_thread_mutex_delete (mux_display);
18672 hc_thread_mutex_delete (mux_adl);
18673
18674 // free memory
18675
18676 local_free (eff_restore_file);
18677 local_free (new_restore_file);
18678
18679 local_free (rd);
18680
18681 // tuning db
18682
18683 tuning_db_destroy (tuning_db);
18684
18685 // loopback
18686
18687 local_free (loopback_file);
18688
18689 if (loopback == 1) unlink (loopback_file);
18690
18691 // induction directory
18692
18693 if (induction_dir == NULL)
18694 {
18695 if (attack_mode != ATTACK_MODE_BF)
18696 {
18697 if (rmdir (induction_directory) == -1)
18698 {
18699 if (errno == ENOENT)
18700 {
18701 // good, we can ignore
18702 }
18703 else if (errno == ENOTEMPTY)
18704 {
18705 // good, we can ignore
18706 }
18707 else
18708 {
18709 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18710
18711 return (-1);
18712 }
18713 }
18714
18715 local_free (induction_directory);
18716 }
18717 }
18718
18719 // outfile-check directory
18720
18721 if (outfile_check_dir == NULL)
18722 {
18723 if (rmdir (outfile_check_directory) == -1)
18724 {
18725 if (errno == ENOENT)
18726 {
18727 // good, we can ignore
18728 }
18729 else if (errno == ENOTEMPTY)
18730 {
18731 // good, we can ignore
18732 }
18733 else
18734 {
18735 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18736
18737 return (-1);
18738 }
18739 }
18740
18741 local_free (outfile_check_directory);
18742 }
18743
18744 time_t proc_stop;
18745
18746 time (&proc_stop);
18747
18748 logfile_top_uint (proc_start);
18749 logfile_top_uint (proc_stop);
18750
18751 logfile_top_msg ("STOP");
18752
18753 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18754 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18755
18756 if (data.ocl) ocl_close (data.ocl);
18757
18758 if (data.devices_status == STATUS_ABORTED) return 2;
18759 if (data.devices_status == STATUS_QUIT) return 2;
18760 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18761 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18762 if (data.devices_status == STATUS_CRACKED) return 0;
18763
18764 return -1;
18765 }
Hashcat additions to support pwdhash